精华内容
下载资源
问答
  • 需要使用 java API 编写查询接口,参考网上的示例自己写了一个接口类: Neo4jUtil.java。目前只完成了查询方法。创建、删除及修改方法未实现。请自行参考代码来实现。 使用方法: 在 eclipse 中导入解压缩的工程...
  • NULL 博文链接:https://mypyg.iteye.com/blog/849176
  • Java数据库连接,(Java Database Connectivity,简称JDBC)是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口,提供了诸如查询和更新数据库中数据的方法 模型 JDBC API 既支持数据库访问的两层模型(C...
  • 需要jdk1.8的环境变量。 模板支持自定义,点击“自定义模板?”按钮,将新增的模板复制到该目录下即可。 本人将源码开放出来了,有需要的可以下载下来:https://github.com/JAdmin-JAVA/dbToDoc
  • java实现上传图片存入到数据库,只能用炫酷来形容,感兴趣就下载看看吧
  • Java 数据库接口

    2010-03-19 14:34:43
    JDBC 是Sun 提供的一套数据库编程接口API 函数,由Java 语言编写的类、界面组 成。用JDBC写的程序能够自动地将SQL语句传送给相应的数据库管理系统。
  • java提供的一套访问数据库接口 java--->操作数据库 JDBC发展历史:[了解] TYPE1:JDBC--odbc桥:间接访问数据库//odbc是c语言的jdbc TYPE2:java---本地api; java语言通过本地客户端---->访问数据 TYPE3...

    JDBC


    java提供的一套访问数据库接口
    java--->操作数据库
    JDBC发展历史:[了解]
    TYPE1:JDBC--odbc桥:间接访问数据库//odbc是c语言的jdbc
    TYPE2:java---本地api;
    java语言通过本地客户端---->访问数据
    TYPE3:java---中间服务器(网络):
    java通过中间服务器-----访问数据库(mysql,oracle,db2)
    优点:可移植性高
    缺点:效率低.
    TYPE4:JDBC---访问数据库

    数据库厂商提供接口的实现类-----数据库的驱动 
    ojdbc14.jar(jdk1.4)ojdbc5.jar(jdk5.0) ojdbc6.jar
    常见数据库访问接口(类)
    java.sql.Connection(interface):
    //代表一个数据库的连接
    java.sql.Statement(interface):
    //执行sql的工具
    java.sql.ResultSet(interface):
    //存放查询的结果数据
    **只有执行查询sql,才会有结果数据返回
    java.sql.DriverManager;
    //管理多个驱动类
    **DriverManager会管理多个数据库驱动,会自动选择最合适的驱动类,去建立数据库的连接
    JDBC操作数据库的模型:
    1.加载驱动
    2.建立数据库连接(Connection)
    3.准备一个执行sql的工具(发送sql语句至数据库)
    4.执行sql语句
    5.(执行查询sql),DB 会将数据返回给Resultset,处理结果集
    6.释放资源;
    ***Connection   Statement  ResultSet
    **原则:先打开的后释放


    课堂案例t_account表:
    create table t_account(
    c_id number(10) primary key,
    username varchar2(50),
    password varchar2(50),
    balance number(20,5)
    );
    第一个jdbc程序
    //0.将ojdbc5.jar放入classpath环境中
    //classpath: .;D:\ojdbc5.jar
    //1.加载驱动 oracle.jdbc.OracleDriver
    Class.forName("oracle.jdbc.OracleDriver");
    //2.建立数据库连接 协议url 用户名user 密码password
    String url = "jdbc:oracle:thin:@127.0.0.1:1521:xe";
    // 协议@ip:端口号:实例名(xe|orcl)
    //本地ip:localhost127.0.0.1
    String user = "hr";
    String password = "hr";
    java.sql.Connection conn = java.sql.DriverManager.getConnection(url,user,password);//conn代表一个数据库连接
    //3.创建发送sql的工具
    java.sql.Statement stm = conn.createStatement();
    //4.执行sql:insert into t_account values。。。。
    String sql = "insert into t_account values(100001,'wangyx','123',10)";
    //**sql字符串后不加  分号  
    stm.executeUpdate(sql);//执行增删改
    //5.释放资源
    if(stm!= null)
    stm.close();
    if(conn != null)
    conn.close();
    myeclipse开发jdbc:
    0.导入ojdbc5.jar
    1.项目右键---build path--configured build path--librari---add external jars


    ResultSet ;
    1.存放查询语句执行返回的结果数据
    2.结果集ResultSet的rs指针初始位置,第一行数据前一行
    3.next(); 返回值boolean:true当前行有数据,false 当前行没有数据
    让指针下移1位
    4.获得rs指针所指向的当前行数据
    getXXXXX()
    getInt(下标)|getInt("c_id")c_id number
    getString("username");username varchar2
    getDouble("balance");balance number(10,2)
    getDate(下标|列名)


    【重点】


    JDBC6步骤
    ResultSet 结果集的处理

    思考:
    写一个程序:
    让用户输入卡号和密码,如果卡号和密码正确
    打印“你可以取钱挥霍了”
    否则打印“吞卡.....”
    ======================================================================

    JDBC编程6步骤:

    1.加载驱动:oracle.jdbc.OracleDriver

    2.建立连接:   url user password

    3.创建发送sql的工具

    4.执行sql

    5.(查询),处理结果集ResultSet

    6.释放资源:后打开的先释放;

     


    ResultSet结果集
    next(): 将rs的指针下移一位,(会指向第一行数据),
    返回值为boolean值,true代表当前行有数据
    getInt(1)|getInt("c_id")---获得数字类型
    getString("username")--获得字符串类型
    ======================================================
    Statement:
    stm.executeUpdate("增删改sql")---执行增删改的sql
    返回值 int
    影响了表中多少行数据
    stm.executeQuery("查询sql")---执行查询sql
    返回值:ResultSet
    是一个容器,存放查询语句返回的结果数据
    **即使发送的sql语句查询不到任何数据,resultSet对象也不会为null


    动态sql:
    动态sql的构建
    jdbc发送的sql语句,由用户输入的内容不同,导致发送的sql语句也不同
    String :
    "select * from t_account where username = '"+username+"' and password = '"+password+"'"

    问题描述:
    输入username: aas' or 1=1 --
    password:  123
    select * from t_account where username = 'aas' or 1=1 --' and password = '123';
    结果:能够查询数据,验证通过

    ***SQL注入漏洞
    PreparedStatement: 是Statement子接口.
    **发送sql语句 
    1.创建发送sql工具
    String sql = "select * from t_account where username = ? and password = ?";
    PreparedStatement pstm  = conn.prepareStatement(sql);//接收的sql是不完整的
    2.对sql中的?进行绑定参数
    pstm.setInt(?下标,绑定的值);
    pstm.setString(..),
    pstm.setDouble(..);
    pstm.setDate(...);
    3.执行sql
    pstm.executeUpdate();//执行方法不需要sql
    ResultSet rs = pstm.executeQuery();
    课堂练习:
    1。写一个程序,向t_account表中插入一条数据(卡号,用户名,密码,余额),让用户输入
    2.练习pstm的登录程序

    需求:
    向数据库中插入1000条数据
    1000 10000
    Statement 901878716 4188379667
    PreparedStatement826617465 3988919980
    批处理 474696792559667059
    **1.PreparedStatement执行同构sql比Statement效率高(大量数据插入)
    ①当创建PreparedStatement是,需要sql
    PreparedStatement pstm = conn.prepareStatement(sql);//将sql语句发送给 数据库
    oracle执行:
    数据库验证该sql的执行权限
    验证slq的语法结构
    翻译成内部指令
    ②pstm发送绑定参数 发送10000
    Oracle执行sql的过程:
    1.验证sql语句执行权限
    2.验证sql语句的语法结构
    3.将sql语句转换成内部指令
    4.执行内部指令


    批处理:
    处理大量同构sql
    1.创建发送sql的工具 PreparedStatement
    String sql = "....???";
    PreparedStatement pstm = conn.prepareStatement(sql);
    2.绑定参数
    pstm.setXXX(?的下标,值);
    pstm.setXXX
    pstm.setXXX
    //缓存绑定参数到本地
    pstm.addBatch();
    3.发送缓存的绑定参数
    pstm.executeBatch();
    ***以内存空间换时间效率;

    问题:现有的JDBC存在大量的冗余代码
    1.加载驱动
    获得连接
    // 1.加载驱动
    Class.forName("oracle.jdbc.OracleDriver");
    // 2.获得数据库连接 Connection
    String url = "jdbc:oracle:thin:@localhost:1521:xe";
    String user = "hr";
    String password = "hr";
    Connection conn = DriverManager.getConnection(url, user, password);
    2.释放资源
    // 6.释放资源
    if(rs != null)
    rs.close();
    if(stm != null)
    stm.close();
    if(conn != null)
    conn.close();
    解决方案:
    将所有重复代码封装在函数中.
    JDBCUtil工具类
    1.获得连接
    2.释放资源
    【重点】
    preparedStatement 概念和代码
    批处理()TestBatchUpdate.java
    JDBCUtil

    习题:11.19,20,22
    ==============================================================================
     问题:
    JDBCUtil1中有一些在使用过程中需要经常修改的值
    解决方案:
    将需要经常修改的值,从java代码中抽取出来.放在文件中.
    **
     1.jdbcpropertie.txt
    "oracle.jdbc.OracleDriver"
    "jdbc:oracle:thin:@localhost:1521:xe"
    "hr"
    "hr"
     2.
    InputStream is = new InputStream("路径");
    InputStreamReader isr  = new InputStreamReader(is);
    BufferedReader br = new BufferedReader(isr);
    ..br.readLine();


    properties 文件
    文件名:**.properties
    内容:字符串
    特点: key=value
    *******************************************
    driverClassName=oracle.jdbc.OracleDriver
    url=jdbc:oracle:thin:@localhost:1521:xe
    user=hr
    password=hr
    properties 类
    Map集合
    特点:键--字符串 值--字符串
    读取properties文件
    使用:
    1.创建读取properties文件的Properties对象
    Properties prop = new Properties();
    2.准备一个对应properties文件的输入流
    InputStream is = new InputStream("路径");
    **类加载:jvm读取硬盘上.class文件过程
    类名.class.getResourceAsStream("路径");
    3.加载文件信息到prop
    prop.load(is);
    4.获得prop中的内容
    prop.getProperty("key");
    prop.getProperty("driverClassName");//oracle.jdbc.OracleDriver


    JDBCUtil3
    getConnection方法中:将加载配置文件,和加载驱动,只执行一次
    **放在JDBCUtil工具类的static代码块中

    课堂练习:
    1.联系JDBCUitl新版本,并测试
    2.程序:
    让用户输入信息,插入account表中
    根据用户输入的卡号,删除account表中的一条数据
    思考:
    account表中一条数据修改的程序(根据卡号修改)




    分析:
    对于数据库中一张表的操作总结:增删改查
    **将该表的所有操作封装在一个类中
    类名:AccountDAO
    //1.查询
    //2.添加
    //3.删除
    //4.修改
    实体:Entity
    **属性对应表的列
    public class Account{// t_account
    private Integer cid;// c_id
    private String username;// username
    private String password;// password
    private Double balance;// balance
    }
    **提供有参和无参构造方法
    **提供get/set方法



    DAO编程模型: data access  object 数据访问对象
    命名:***DAO
    方法://将对于该表的所有的数据库操作,全部封装在DAO类中
    public Account selectAccountById(Integer id){}

    public void insertAccount(Account Acccount){}

    public void deleteAccount(Integer id){}

    public void updateAccount(Account account){}

    public List<Account>  selectAllAccounts(){}
    ...
    Entity实体: javaBean
    封装数据库数据
    1.类名和表名相关
    2.所有属性和表中所有列一一对应
    3.添加无参和有参构造方法
    4.添加所有属性的set/get方法
    5.实现serializable接口 


    作业:
    ①完成AccountDAO剩余的方法;(删除,查询所有,修改)


    表:
    create table person(
    id number(10) primary key,
    username varchar2(50),
    email varchar2(100),
    phone varchar2(20),
    address varchar2(200)
    );
    create sequence seq_person start with 10000;
    书写该表操作的DA---PersonDAO
    书写全部的方法实现+测试
    ==================================================================
    【重点】
    吃货(吃饭需求) 服务员(收集需求)----厨师(处理业务需求)--- 采购员(采购原材料)

    用户(取钱) (收集数据)view (业务处理)AccountDAO(数据库数据)

    项目分层:
    view 接收用户数据,展示数据AccountView

    biz(service) 业务处理 AccountService

    dao 数据库访问AccountDAO
    **解耦和,优化代码结构,代码可重用
    1.将业务功能封装成service中的方法


    Service层:业务处理
    一个业务功能就是一个事务,需要将所有的业务代码放在一个事务中执行
    **jdbc中的conn的事务提交模式为自动提交
    方法:
    try{
    开启事务
    业务处理
    提交事务
    }cath(){
    conn.rollback;事务回滚
    }
    课堂作业:
    1.取钱三层结构:
    2.转账功能
    收集数据(转账卡号,密码,到账卡号,转账金额)
    将转账业务封装在service中
    //开启事务
    **根据转账卡号查询账户,判断账户是否存在
    **判断密码
    **判断到账卡号是否存在
    **将到账账户+¥
    **将转账账户-¥
    //提交事务



    【难点】
    转账业务分析:
    问题:如果转账失败,数据不发生改变,但是却到账卡号+钱...
    事务控制失败了.....
    原因:
    service控制事务所用的conn和dao发送sql语句所用的conn不是同一连接对象
    解决方案:
    **一次调用过程中:保证service和dao用同一个连接对象
    1.只调用一次jdbcutil,将service获得的连接对象传给dao
    缺点:将jdbc API耦合在方法参数中,不利于解耦和

    ----
    线程Thread对象中有一小块内存空间,可以用来存储数据;(类似Map类型)
    ThreadLocal:操作当前线程对象的内部小块内存空间
    ThreadLocal<Connection> tdl = new ThreadLocal<Connection>();
    set(conn);//将conn对象存入当前线程对象中
    get();//将当前线程对象中的值取出
    remove();//将当前线程中的值,移除;
    ---------------------------------------------
    JDBCUtil4:
    getConnection();
    先获得当前线程中的conn
    conn = tdl.get();
    判断conn是否为空
    if(conn == null){
    //创建新的conn
    //将新的conn放入当前Thread
    tdl.set(conn);
    }
    release()
    //释放conn资源
    tdl.remove();
    conn.close()
    Service:
    获得连接
    开启事务
    提交事务
    回滚事务
    释放conn资源
    DAO
    。。。
    释放资源(不能关闭conn)
    ========================================================================
    view:收集数据,展示数据:调用service
    service:处理业务:(事务开启,提交事务|回滚事务)[释放资源conn]:调用dao
    dao:数据访问(DB): JDBC代码 释放资源(rs,stm|pstm,null)
    开发注意事项:
    1.需要给dao和service定义接口
    项目分包管理:
    com.zpark.项目名.view
    com.zpark.项目名.service
    .impl
    com.zpark.项目名.dao
    .impl
    com.zpark.项目名.entity
    com.zpark.项目名.util
    com.zpark.项目名.sql--项目用到的sql文件语句
    com.zpark.项目名.test
    步骤:
    1.新建java项目
    **导入项目需要的jar包
    2.创建包结构
    xxx.xxx.xxx.view
    .service
    .dao
    .entity
    .sql
    .test
    .util
    .conf ---放配置文件
    -----------------------
    多表操作:
    1 对 n
    --学生管理系统
    (学号,姓名,年龄,班级id   班级名称)

    学生表:
    stu_id  stu_name   agec_id
    001 wangyx17 001
    002 houhui16 001
    003 chengcheng19 001
    班级表
    class_id   class_name
    001 java35班
    **原则:将外键建在多的一方;

    表---实体
    public class Student{//学生
    private Integer stuId;
    private String stuName;
    private Integer age;
    private Clazz clazz;//该学生所在的班级信息
    }
    public class Clazz{//班级
    private Integer classId;
    private String className;
    private List<Student> students;//该班级所有的学生对象
    }
    **原则:
    1.表对应实体
    2.列(本实体信息)对应属性
    3.在实体中添加另一方的关系属性
    1 对 1
    --学生租赁电脑的管理系统;(一个学生只能对应一台电脑)
    学号,姓名,年龄,电脑编号,电脑名称

    学生表
    stu_id stu_name age c_id(unique)
    022 孙振19 001
    023 王乐20 002
    024 罗亮21 003


    电脑表
    computer_id computer_name s_id(unique)
    001 Thinkpad022
    002 dell023
    003 HP024
    **FK+UK(外键+唯一)
    **将外键建在更重要的一方;
    实体:
    public class Student{
    private Integer stuId;
    private String stuName;
    private Integer age;
    private Computer computer;
    }
    public class Computer{
    private Integer cId;
    private String comName;
    private Student student;
    }
    原则:
    1.表和实体
    2.列和属性对应
    3.互相保留对方的引用(关系属性)

    n 对 n
    --学生考试系统
    (学生学号,姓名,年龄,科目,科目编号,成绩)


    学生表
    stu_id stu_name age
    001 李山20
    002 侯青21
    003 刘yi22
    课程表
    course_id course_name
    01 coreJava
    02 jdbc


    学生课程关系表(选课表)
       s_id   c_idscore
    001 01100
    001 02100
    002 01150
    003 01180
    **创建一张关系表,将外键建在关系表中
    --每个学生每个课程只能选一次
    primary key(s_id,c_id)


    实体:
    public class Student{
    private Integer stuId;
    private String stuName;
    private Integer stuAge;
    //private List<Course> courses;
    private Map<Course,Double> score;
    }

    public class Course{
    private Integer cID;
    private String courseName;
    //private List<Student> student;
    private Map<Student,Double> score;
    }
    原则:
    1.实体和表对应(关系表一般不会创建实体)
    2.属性和列对应
    3.互相保留对方的集合引用

    功能:学生管理系统(学号,姓名,年龄,班级id   班级名称)
    1.添加学生信息 insertStudent(Student stu)
    输入信息:
    姓名
    年龄
    班级编号
    2.查询学生信息 selectStudentById(Integer sId);
    展示信息:
    学号
    姓名
    年龄
    班级名称
    步骤:
    1.建表(测试数据)
    2.建实体
    作业:
    完成Person通讯录的功能:
    1.添加个人信息
    2.根据编号查询个人信息
    3.修改个人信息
    4.根据编号删除个人信息
    5.展示所有的通讯录信息
    create table person(
    id number(10) primary key,
    username varchar2(50),
    email varchar2(100),
    phone varchar2(20),
    address varchar2(200)
    );
    create sequence seq_person start with 10000;
    要求:
    0.ojdbc5.jar
    1.代码分包
    2.分层
    PersonDAO
    PersonDAOImpl
    personService
    PersonServiceImpl
    PersonView
    JDBCUtil4
    jdbc.properties

     

    展开全文
  • JDBC连接数据库Java系列技术中数据库知识的核心技术,是学习后续课程JavaWeb入门前需要掌握的基础! 这门课的前导课是《Java系列技术之Mysql》。
  • java程序使用JDBC接口连接数据库

    千次阅读 2016-05-22 22:12:17
    本文主要总结了这两天学习的关于Java使用JDBC连接数据库的实现方法1、加载连接数据库的驱动到JVM(Driver接口)1、使用JDBC接口连接数据库的第一步:加载连接数据库的驱动即Driver到JVM. Driver接口是由数据库厂家...

    本文主要总结了这两天学习的关于Java使用JDBC连接数据库的实现方法。使用JDBC连接数据库一般步骤有:
    1、加载驱动程序
    Class.forName(“com.mysql.jdbc.Driver”);
    2、创建连接对象
    Connection conn = DriverManager.getConnection(String url,String user, String password);
    3、创建执行sql语句的对象
    4、对结果集进行处理
    5、关闭资源

    一、加载连接数据库的驱动到JVM(Driver接口)

    1、使用JDBC接口连接数据库的第一步:加载连接数据库的驱动即Driver到JVM. Driver接口是由数据库厂家提供的,对于我们java开发者而言,只需要使用Driver接口就可以了.SUN公司只提供JDBC接口,具体实现交由各个数据库厂商实现具体的连接类。
    2、加载Mysql驱动
    Class.forName(“com.mysql.jdbc.Driver”);注意在加载驱动前需要引进jar包。

    二、使用ManagerDriver接口创建连接对象

    1、这个接口用于管理驱动,是JDBC的管理层。
    2、ManagerDriver跟踪可用的驱动程序,并且建立驱动程序与数据库之间的连接。
    3、具体实现连接方法
    Connection conn = DriverManager.getConnection(String url,String user, String password);
    其中url = “jdbc:mysql://localhost/xxxx”,localhost代表本机,当然也可以使用回送IP地址127.0.0.1,xxxx代表自己创建的数据库;
    4、建立连接比较耗时,实际中一般采用连接池来管理连接,从而提高效率。

    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    /**
     * 测试加载连接数据库的驱动到JVM,然后建立连接
     * @author Liubangxin
     *
     */
    public class DBDemo03 {
        public static void main(String[] args) {
            Connection conn = null;
            try {
                //1、加载驱动到JVM
                Class.forName("com.mysql.jdbc.Driver");
                long d1= System.currentTimeMillis();
                //2、建立连接,其实连接内部包含了socket对象,是一个远程连接对象,比较耗时
                //真正的开发中,为了提高效率,通常会使用连接池来管理连接
                conn = DriverManager.getConnection("jdbc:mysql://localhost/lbx","root","19930701");
                long d2 = System.currentTimeMillis();
                System.out.println("创建连接耗时:"+(d2-d1)+"ms");
                System.out.println(conn);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (SQLException e) {
                e.printStackTrace();
            }finally{
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    控制台输出结果:
    创建连接耗时:231ms
    com.mysql.jdbc.JDBC4Connection@2dda6444

    三、创建执行sql语句的对象

    Statement接口:用于执行静态 SQL 语句并返回它所生成结果的对象。

    1、三种Statement类

    ①、statement:

    由createStatement创建,用于执行简单的sql语句,不带参数。一般很少。
    Statement stmt = conn.createStatement();

    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.sql.Statement;
    /**
     * 测试Statement :The object used for executing a static SQL statement
     * and returning the results it produces.
     * @author Liubangxin
     *
     */
    
    public class DBDemo04 {
        public static void main(String[] args) {
            Connection conn = null;
            Statement stmt = null;
            try {
                //1、加载驱动到JVM
                Class.forName("com.mysql.jdbc.Driver");
                //2、建立连接,其实连接内部包含了socket对象,是一个远程连接对象,比较耗时
                //真正的开发中,为了提高效率,通常会使用连接池来管理连接
                conn = DriverManager.getConnection("jdbc:mysql://localhost/lbx","root","19930701");
                //3、执行sql语句,实际中很少用statement因为可能会有sql注入现象
                stmt = conn.createStatement();
    //          String name = "zhang";
    //          String sql = "insert into persons values (7,'Li','"+name+"','Ding Street','Nanjing',52)";
    //          stmt.execute(sql);
                //测试sql注入
                String name = "1 or 1=1";   //一直未true,所以数据全没了
                String sql = "delete from dogs where id="+name;
                stmt.execute(sql);
    
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (SQLException e) {
                e.printStackTrace();
            }finally{
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    

    ②、PreparedStatement:

    • 1、表示预编译的 SQL 语句的对象。SQL 语句被预编译并存储在 PreparedStatement对象中。然后可以使用此对象多次高效地执行该语句。

    • 2、继承Statement接口,由prepareStatement(sql)创建。比Statement效率更高,并且可以防止sql注入。一般使用这个。
      测试代码:

    import java.sql.Connection;
    import java.sql.Date;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.SQLException;
    
    /**
     * 测试PreparedStatement的使用:SQL 语句被预编译并存储在 PreparedStatement 
     *  对象中。然后可以使用此对象多次高效地执行该语句。
     * @author Liubangxin
     *  */
    public class DBDemo05 {
        public static void main(String[] args) {
            Connection conn = null;
            PreparedStatement stmt = null;
            try {
                Class.forName("com.mysql.jdbc.Driver");
                conn = DriverManager.getConnection("jdbc:mysql://localhost/lbx","root","19930701");
    
                String sql = "insert into dogs values(?,?,?)";  //?占位符
                stmt = conn.prepareStatement(sql);
    //          stmt.setInt(1,1);
    //          stmt.setString(2, "Tom");
    //          stmt.setDate(3, new Date(System.currentTimeMillis()));
                //或者为了方便可以用如下写法
                stmt.setObject(1, 2);
                stmt.setObject(2, "Jomi");
                stmt.setObject(3, new Date(System.currentTimeMillis()));
                stmt.execute();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (SQLException e) {
                e.printStackTrace();
            }finally{
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    执行后:这里写图片描述

    • 3、程序说明:
      1、 String sql = “insert into dogs values(?,?,?)”;其中?表示占位符。
      2、给相应的占位符指定值
      stmt.setInt(1,1);
      stmt.setString(2, “Tom”);
      stmt.setDate(3, new Date(System.currentTimeMillis()));

    ③、CallableStatement:

    • 继承PreparedStatement接口。由方法prePareCall创建,用于调用存储过程。

    2、常用的Statement方法

    ①、execute()

    • 运行一般sql语句,返回类型为boolean。如果返回一个结果集(ResultSet)则为true,比如执行查询数据库语句,如果没结果或者只是更新数据库则为false,比如执行update语句。

    ②、executeQuery()

    • 运行select语句,返回一个结果集(ResultSet)

    ③、executeUpdate()

    • 执行update,delete,insert语句。返回操作的行数。

    四、获取与处理结果集

    ResultSet接口:statement执行executeQuery()方法返回一个结果集。
    经常如下使用:

    ResultSet rst = stmt.executeQuery();
                while(rst.next()){
                    System.out.println(rst.getInt(1)+"--"+rst.getString(2)+"--"+rst.getDate(3));
                }
    

    五、关闭接口

    操作完成以后要把所有使用的JDBC对象全都关闭,以释放JDBC资源。关闭接口遵循如下规则: 关闭顺序和声明顺序相反:即关闭顺序:rst—>stmt—>conn。并且三个捕获异常要分开写。
    查询数据库的代码:

    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    /**
     * 测试ResultSet: A table of data representing a database result set, which
     * is usually generated by executing a statement that queries the database.
     * @author Liubangxin
     *
     */
    public class DBDemo06 {
        public static void main(String[] args) {
            Connection conn = null;
            PreparedStatement stmt = null;
            ResultSet rst = null;
            try {
                Class.forName("com.mysql.jdbc.Driver");
                conn = DriverManager.getConnection("jdbc:mysql://localhost/lbx","root","19930701");
    
                String sql = "select * from dogs where id>=?";  //?占位符
                stmt = conn.prepareStatement(sql);
                stmt.setObject(1, 1);
                rst = stmt.executeQuery();
                while(rst.next()){
                    System.out.println(rst.getInt(1)+"--"+rst.getString(2)+"--"+rst.getDate(3));
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (SQLException e) {
                e.printStackTrace();
            }finally{
                //后打开的先关闭 而且将三个分开写
                try {
                    rst.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    控制台输出结果:
    1–Tom–2016-05-22
    2–Jomi–2016-05-22

    展开全文
  • java多个数据库实现数据同步

    热门讨论 2015-03-16 21:54:59
    内部java实现多个数据库,保持数据同步案例。
  • 这是一个简单的Java面向接口的ATM机系统,用类模拟数据库的,可以实现登陆,注册,查看余额,存取款,转账等简单功能
  • 1.java代码,结构如下入 1.pom.xml文件 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:...

    1.java代码,结构如下入

    在这里插入图片描述

    1.pom.xml文件

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>tcl.ln.geturl</groupId>
        <artifactId>geturl</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <dependencies>
            <!--map和json数据交换转换-->
            <dependency>
                <groupId>net.sf.json-lib</groupId>
                <artifactId>json-lib</artifactId>
                <version>2.4</version>
                <classifier>jdk15</classifier>
            </dependency>
    
            <!--mysql驱动jar包 -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.25</version>
            </dependency>
        </dependencies>
        <!--Spring Boot可以以jar包的形式独立运行。指定运行主类 -->
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <configuration>
                        <mainClass>geturl.Iputil</mainClass>
                    </configuration>
                    <executions>
                        <execution>
                            <goals>
                                <goal>repackage</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    
    
    </project>
    

    2. 通过此数据建立实体类

    作用:定义json封装的bean对象
    在这里插入图片描述

    package geturl;
    
    
    import java.util.List;
    
    public class JsonBean {
        private String status;
        private String msg;
    //    封装data的数据
        private DataBean data;
    
        public String getStatus() {
            return status;
        }
    
        public void setStatus(String status) {
            this.status = status;
        }
    
        public String getMsg() {
            return msg;
        }
    
        public void setMsg(String msg) {
            this.msg = msg;
        }
    
        public DataBean getData() {
            return data;
        }
    
        public void setData(DataBean data) {
            this.data = data;
        }
    
        //Data数据封装
        public static class DataBean {
            private Integer totalSize;
            private Integer hasNext;
            //    封装tuples的数据
            private List<TuplesBean> list;
    
    
            public Integer getTotalSize() {
                return totalSize;
            }
    
            public void setTotalSize(Integer totalSize) {
                this.totalSize = totalSize;
            }
    
            public Integer getHasNext() {
                return hasNext;
            }
    
            public void setHasNext(Integer hasNext) {
                this.hasNext = hasNext;
            }
    
            public List<TuplesBean> getList() {
                return list;
            }
    
            public void setList(List<TuplesBean> list) {
                this.list = list;
            }
        }
    //Tuples数据封装
        public static class TuplesBean {
            private String id;
            private String sn;
            private String activationCode;
            private String source;
            private String phoneNum;
            private String ip;
            private String status;
            private String obtainTime;
            private String synTime;
    
            public TuplesBean() {
            }
    
            public String getId() {
                return id;
            }
    
            public void setId(String id) {
                this.id = id;
            }
    
            public String getSn() {
                return sn;
            }
    
            public void setSn(String sn) {
                this.sn = sn;
            }
    
            public String getActivationCode() {
                return activationCode;
            }
    
            public void setActivationCode(String activationCode) {
                this.activationCode = activationCode;
            }
    
    
            public String getSource() {
                return source;
            }
    
            public void setSource(String source) {
                this.source = source;
            }
    
            public String getIp() {
                return ip;
            }
    
            public void setIp(String ip) {
                this.ip = ip;
            }
    
            public String getStatus() {
                return status;
            }
    
            public void setStatus(String status) {
                this.status = status;
            }
    
            public String getObtainTime() {
                return obtainTime;
            }
    
            public void setObtainTime(String obtainTime) {
                this.obtainTime = obtainTime;
            }
    
            public String getSynTime() {
                return synTime;
            }
    
            public void setSynTime(String synTime) {
                this.synTime = synTime;
            }
    
            public String getPhoneNum() {
                return phoneNum;
            }
    
            public void setPhoneNum(String phoneNum) {
                this.phoneNum = phoneNum;
            }
    
        }
    }
    
    
    
    

    3.数据库连接类

    package geturl;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    
    
    public class Conn {
    //数据库连接类
    
        /**
         * @return Connection
         * @method getConn()
         */
        public Connection getConn() {
    
            String driver = "com.mysql.jdbc.Driver";
            String url = "jdbc:mysql://10.68.23.151:3306/tcl_adwdfa";
            String username = "ddadad";
            String password = "dsadaw";
            Connection conn = null;
    
            try {
                Class.forName(driver); //
                conn = (Connection) DriverManager.getConnection(url, username, password);
    
                System.out.println("数据库连接成功");
    
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (SQLException e) {
                e.printStackTrace();
            }
    
            return conn;
        }
    
    
    }
    
    

    4.解析存储类

    package geturl;
    
    import java.net.*;
    import java.security.MessageDigest;
    import java.sql.Connection;
    import java.sql.ResultSet;
    import java.sql.Statement;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.*;
    import java.io.*;
    
    import net.sf.json.JSONArray;
    import net.sf.json.JSONObject;
    
    //解析存储类
    public class Iputil {
    // 记录请求的json的页数
        static  int  count = 1;
    // 记录日志的日期
        static  String  date ;
        public static void main(String[] args) throws ParseException {
    
    //请求得到json,有多少页执行多少次
           for (int i=1;i<=count ;i++){
    // 得到执行日期前一天的日期
               Calendar calendar = Calendar.getInstance();
               SimpleDateFormat sj = new SimpleDateFormat("yyyyMMdd");
               calendar.add(Calendar.DATE, -1);//当前时间减去一年,即一年前的时间  
               String str = sj.format(calendar.getTime());
    //    将日期赋值给data,run方法需要用
               date = str ;
    //           用md5 信息摘要算法解密
               String token = md5(str + "hyugtf@tcl.com");
    //           post请求的参数
               HashMap<String, String> map = new HashMap<>();
               map.put("date", str);
               map.put("pageSize", "1000");
               map.put("pageNum", i+"");
               map.put("token", token);
               Iputil iputil = new Iputil();
               iputil.run(map);
    
            }
    
    
    
        }
    //md5 信息摘要算法
        public static String md5(String source) {
            StringBuffer sb = new StringBuffer(32);
            try {
                MessageDigest md = MessageDigest.getInstance("MD5");
                byte[] array = md.digest(source.getBytes("utf-8"));
                for (int i = 0; i < array.length; i++) {
                    sb.append(Integer.toHexString((array[i] & 0xFF) | 0x100).toUpperCase().substring(1, 3));
                }
            } catch (Exception e) {
            }
            return sb.toString();
        }
    //向接口请求数据后封装后写入数据库
        public void run(Map<String, String> params) {
            JsonBean jsonBean = new JsonBean();
    //        post请求参数拼接
            StringBuffer sb = new StringBuffer();
            if (params != null) {
                for (Map.Entry<String, String> e : params.entrySet()) {
                    sb.append(e.getKey());
                    sb.append("=");
                    sb.append(e.getValue());
                    sb.append("&");
                }
                //去掉最后一个&
                sb.substring(0, sb.length() - 1);
            }
            try {
                URL url = new URL("https://tvactivity.api.my7v.com/auddath/activity/dafa");
                URLConnection urlConnection = url.openConnection();
                HttpURLConnection connection = null;
                if (urlConnection instanceof HttpURLConnection) {
                    connection = (HttpURLConnection) urlConnection;
                } else {
                    System.out.println("输入urlַ");
                    return;
                }
                connection.setRequestMethod("POST");
                connection.setDoOutput(true);
                connection.setDoInput(true);
                connection.setUseCaches(false);
                connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
                OutputStreamWriter osw = new OutputStreamWriter(connection.getOutputStream(), "UTF-8");
                osw.write(sb.toString());
                osw.flush();
                osw.close();
    
                BufferedReader in = new BufferedReader(
                        new InputStreamReader(connection.getInputStream()));
    //            存储得到的json
                String urlString = "";
                String current;
                while ((current = in.readLine()) != null) {
                    urlString += current;
                }
    
    //将json解析为JSONObject对象
                JSONObject json = JSONObject.fromObject(urlString);
    //            从json对象中获取数据存入jsonBean对象中
                jsonBean.setStatus(json.optString("status"));
                jsonBean.setMsg(json.optString("msg"));
    //            得到date仍然是json对象,需要进一步封装
                JSONObject dataObj = json.optJSONObject("data");
                JsonBean.DataBean data = new JsonBean.DataBean();
    
                data.setHasNext(dataObj.optInt("hasNext"));
                data.setTotalSize(dataObj.optInt("totalSize"));
    //            更改count的次数,每页1000条
                count = (data.getTotalSize()/1000+1);
    //            将tuples直接封装为JSONArray
                JSONArray tuplesArray = dataObj.optJSONArray("tuples");
                List<JsonBean.TuplesBean> tuplesBeansList = new ArrayList<>();
    //进一步封装tuples的数据
                for (int i = 0; i < tuplesArray.size(); i++) {
                    JSONObject tuplesObj = tuplesArray.optJSONObject(i);
                    JsonBean.TuplesBean tuplesBean = new JsonBean.TuplesBean();
                    tuplesBean.setId(tuplesObj.getString("id"));
                    tuplesBean.setSn(tuplesObj.getString("sn"));
                    tuplesBean.setActivationCode(tuplesObj.getString("activationCode"));
                    tuplesBean.setSource(tuplesObj.getString("source"));
                    try {
                        tuplesBean.setPhoneNum(tuplesObj.getString("phoneNum"));
                    } catch (Exception e){
                        tuplesBean.setPhoneNum("");
                    }
                    tuplesBean.setIp(tuplesObj.getString("ip"));
                    tuplesBean.setStatus(tuplesObj.getString("status"));
                    tuplesBean.setObtainTime(tuplesObj.getString("obtainTime"));
                    tuplesBean.setSynTime(tuplesObj.getString("synTime"));
    
    
    //                tuplesBean增加到tuplesBeansList
                    tuplesBeansList.add(tuplesBean);
                }
    //            tuplesBeansList增加到data
                data.setList(tuplesBeansList);
    //           data增加到jsonBean
                jsonBean.setData(data);
    
            } catch (IOException e) {
                e.printStackTrace();
            }     //get数据
            Conn c = new Conn();  //连接数据库
            Connection con = c.getConn();
    
            try {
                Statement sql;
                ResultSet res;
                int a;
    
                sql = con.createStatement();
    		      	/*	sql.executeQuery("CREATE TABLE Map (id varchar(255), name varchar(255),tag varchar(255),"
    		      				+ "type varchar(255),typecode varchar(255), biz_type varchar(255),address varchar(255),location varchar(255),"
    		      				+ "tel varchar(255),postcode varchar(255),website varchar(255),email varchar(255),pcode varchar(255),pname varchar(255),"
    		      				+ "citycode varchar(255), cityname varchar(255), adcode varchar(255),adname varchar(255), importance varchar(255),shopid varchar(255),shopinfo varchar(255),poiweight varchar(255),"
    		      				+ "gridcode varchar(255),distance varchar(255),navi_poiid varchar(255),entr_location varchar(255),business_area varchar(255),exit_location varchar(255),"
    		      				+ "match varchar(255),recommend varchar(255),timestamp varchar(255),alias varchar(255),indoor_map varchar(255),indoor_data varchar(255),"
    		      				+ "groupbuy_num varchar(255),discount_num varchar(255),biz_ext varchar(255),event varchar(255),children varchar(255),photos varchar(400))  ");
    		      			*/
    
    //从jsonBean中获取封装的数据插入数据库中,得道的每条的数据都插入
                for (int i = 0; i < jsonBean.getData().getList().size(); i++) {
                    a = sql.executeUpdate("insert into huannet_dzbd_info_inc_daily (sn,activationCode,source,phoneNum,ip,status,obtainTime,synTime,date)"
                            + "values('"  + jsonBean.getData().getList().get(i).getSn() + "','"
                             + jsonBean.getData().getList().get(i).getActivationCode() + "','" + jsonBean.getData().getList().get(i).getSource() + "','"+ jsonBean.getData().getList().get(i).getPhoneNum() +"','"+ jsonBean.getData().getList().get(i).getIp() + "'"
                            + ",'" + jsonBean.getData().getList().get(i).getStatus() + "','" + jsonBean.getData().getList().get(i).getObtainTime() + "','" + jsonBean.getData().getList().get(i).getSynTime() + "','" + date + "')");
    
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
    
    
        }
    }
    
    
    

    2.将打好的jar上传到服务器

    1.打包步骤

    点击idea的Maven后,点击package。如下图
    在这里插入图片描述
    在这里插入图片描述

    2.执行打包后的jar

    java -jar geturl-1.0-SNAPSHOT.jar
    
    展开全文
  • JAVA通过JDBC操作MySQL数据库(二):Statement接口操作数据库JAVA项目配置MySQL驱动文件驱动文件下载配置驱动文件连接数据库(Connection接口)操作数据库(Statement接口JAVA项目配置MySQL驱动文件 JDBC是JAVA...

    JAVA项目配置MySQL驱动文件

    JDBC是JAVA操作关系型数据库的一个标准,操作数据库的接口由JAVA提供,但是具体的实现不由JAVA负责,而是由各种数据库提供的驱动文件负责,类似于JAVA中的native方法,native方法JAVA只是提供接口不提供具体实现,具体实现有操作系统完成。实现MySQL数据库具体操作的就是MySQL针对JAVA的的驱动文件

    驱动文件下载

    在MySQL官网 https://www.mysql.com/ 中DOWNLOADS—Community—MySQL Connectors—Connector/J 就是JAVA中使用的MySQL的驱动文件,操作系统选择Platform Independent,Windows系统下载zip文件,如下图所示:
    在这里插入图片描述
    下载下来的文件中的mysql-connector-java-8.0.13.jar就是我们要在JAVA工程中配置的驱动文件。

    配置驱动文件

    在Eclipse中选中你要使用MySQL的JAVA工程,右键—Properties—Java Build Path—Libraries—Add-Externel JARs,选择mysql-connector-java-8.0.13.jar,这样mysql-connector-java-8.0.13.jar就出现在了本项目的Libraries中,如下图所示,然后选择OK。
    在这里插入图片描述

    连接数据库(Connection接口)

    通过JDBC操作数据库的类和接口都在java.sql包中,我们主要使用的是java.sql.Connection、java.sql.Statement、java.sql.PreparedStatement三个接口和DriverManager类。
    数据库的连接步骤:

    1. 加载驱动类,但此项已经不需要,程序会自动加载
    2. DriverManeger产生Connection的实例化对象(public static Connection getConnection(String url,String user,String password) throws SQLException),Connection的实例化对象不为空表明数据库连接成功。其中url为数据库的地址,地址随数据库类别不同而不同,MySQL的地址模式是 jdbc:mysql://主机名:端口名/具体数据库名 ;主机名和端口号可以在Workbench中看到,在JAVA通过JDBC操作MySQL数据库(一):MySQL数据库准备 中有讲到,具体数据库名就是我们要操作的数据库名。要连接我的电脑上的gc数据库,那么url应该为jdbc:mysql://localhost:3306/gc? serverTimezone=GMT ,其中 ? serverTimezone=GMT 为指明时间标准,因为数据库的操作涉及到时间、数据库的操作历史也需要时间,如果不加 ? serverTimezone=GMT 的话会报错。
    3. 数据库属于资源操作,操作结束后应该关闭连接。
    public class Mydemo {
    	private static final String DBDRIVER="com.mysql.cj.jdbc.Driver";
    	//MySQL 8.0的Driver所在包发生了变化,不再是com.mysql.jdbc.driver
    	private static final String DBURL="jdbc:mysql://localhost:3306/gc? serverTimezone=GMT";
    	private static final String DBUSER="root";
    	private static final String DBPASSWORD="root";
    	public static void main(String[] args) throws Exception {
    		//1.加载数据库驱动类,但此项现在已经不需要,程序会自动加载
    		Class.forName(DBDRIVER);
    		//2.连接数据库,产生Connection的实例化对象
    		Connection connection=DriverManager.getConnection(DBURL, DBUSER, DBPASSWORD);
    		System.out.println(connection);//如果输出结果不为空那么数据库连接成功
    		connection.close();
    	}
    }
    

    操作数据库(Statement接口)

    操作数据库的主要内容为:

    1. Connection产生Statement的实例化对象(Statement createStatement() throws SQLException )。
    2. 更新数据库(int executeUpdate(String sql) throws SQLException),String sql 是完整的SQL语言命令组成的字符串,返回的int型数据是改语句更新数据库的行数。
    3. 查询数据库(ResultSet executeQuery(String sql) throws SQLException),ResultSet 中保存所有的查询结果集,根据next() 方法从第一条结果开始往后判断结果集是否有数据,getString(int columnIndex) 或者getString(String columnLable) 返回String类型的数据,类似的还有*getInt()*等。

    更新数据库(插入、删除、修改)

    以数据库gc中的student表为例,原始表如下:
    在这里插入图片描述
    更新数据库代码:

    public class Mydemo {
    	private static final String DBURL="jdbc:mysql://localhost:3306/gc? serverTimezone=GMT";
    	private static final String DBUSER="root";
    	private static final String DBPASSWORD="root";
    	public static void main(String[] args) throws Exception {
    		Connection connection=DriverManager.getConnection(DBURL, DBUSER, DBPASSWORD);
    		Statement st=connection.createStatement();//产生Statement实例化对象
    		String sql=" insert into student values('zx',20,'chengdu','new student','1998-11-8') ";//插入数据
    		//完整的SQL语句,sql前后最好有空格,防止在换行的时候出现不可知错误。
    		String sql1=" delete from student where name='zs' ";//删除数据
    		String sql2=" update student set city='xiamen' where name='ls' ";//修改数据
    		int len=st.executeUpdate(sql);//执行更新操作
    		System.out.println(len);
    		len=st.executeUpdate(sql1);
    		System.out.println(len);
    		len=st.executeUpdate(sql2);
    		System.out.println(len);
    		connection.close();
    	}
    }
    

    执行后的结果如下:
    在这里插入图片描述

    查询数据库

    以上图中student表中的数据为准,查询代码如下:

    public class Mydemo {
    	private static final String DBURL="jdbc:mysql://localhost:3306/gc? serverTimezone=GMT";
    	private static final String DBUSER="root";
    	private static final String DBPASSWORD="root";
    	public static void main(String[] args) throws Exception {
    		Connection connection=DriverManager.getConnection(DBURL, DBUSER, DBPASSWORD);
    		Statement st=connection.createStatement();//产生Statement实例化对象
    		String sql=" select name,age,city from student ";//查询数据
    		ResultSet result=st.executeQuery(sql);//执行查询操作
    		while (result.next()) {
    			//以列名:columnIndex取出数据
    //			String name=result.getString("name");
    //			int age=result.getInt("age");
    //			String city=result.getString("city");
    			//以列序号columnLabel取出数据
    			String name=result.getString(1);
    			//注意这里的序号是以sql中的查询顺序写的,不是数据库本身中的列顺序,为了方便一般使用序号,因此最好不要使用select *
    			int age=result.getInt(2);
    			String city=result.getString(3);
    			System.out.println(name+"、"+age+"、"+city);
    		}
    		connection.close();
    	}
    }
    

    主要注意的是,本文中讲的Statement接口在操作数据库时有其缺点,所以在编程时基本上不使用Statement接口,而是使用PreparedStatement接口,这里之所以将Statement接口是为了更好的过渡到PreparedStatement,PreparedStatement的讲解在JAVA通过JDBC操作MySQL数据库(三):PreparedStatement接口操作数据库


    系列博客:
    JAVA通过JDBC操作MySQL数据库(一):MySQL数据库准备
    JAVA通过JDBC操作MySQL数据库(三):PreparedStatement接口操作数据库

    展开全文
  • 基于java开发的proess数据库接口,被EDI调用,适用开发EDI第三方接口应用
  • 根据实体创建数据库表,资源共享出来,希望有人可以用到,抽出时间多陪陪您的家人,恋人,程序员真的很辛苦...
  • 主要介绍了Java程序连接数据库的常用的类和接口,包括Connection类和Statement类等,需要的朋友可以参考下
  • Java实战之Spring Boot入门到精通

    千人学习 2019-12-24 15:22:48
    内容简介: 本课程主要是从...其完整的功能流程图如下图所示: 基本要求: 1、基本要求:具备一定的JavaSE以及Java Web项目的开发基础、了解spring boot更佳 2、工具要求:会使用Intellij IDEA 、Navicat 以及 Postman
  • 一键生成java三层代码、数据库设计文档、接口对接文档(dao、entity、mapper、service、controller),一键启动非常适合偷懒的各位
  • 完整代码,Java高效实现数据库迁移同步
  • MySQL封装了一些Java的库来操作其数据库,我们可以在Java中直接调用这些库中的函数来操作MySQL。
  • Java直接通过连接数据库生成对应的Resful格式的API,是的,什么都不用写,只需要配置数据库地址和账号密码就可以了,支持多数据库切换
  • 将本地硬盘中的文本数据读取到mysql的数据库表中。...5. 编写dao层接口,定义添加数据的接口方法。 6. 编写dao层实现类,实现添加数据的方法。 7. 编写一个main方法,逐行读取数据,并调用dao层方法进行逐行的导入。
  • 第14章 Java数据库编程接口;利用JDBC访问数据库;利用JDBC访问数据库;利用JDBC访问数据库;利用JDBC访问数据库;利用JDBC访问数据库;利用JDBC访问数据库;利用JDBC访问数据库;利用JDBC访问数据库;利用JDBC访问数据库;...
  • 基于JAVA和SQL SERVER数据库实现的酒店管理系统

    万次阅读 多人点赞 2019-01-03 08:53:00
    1 设计目标就数据库学习应用于生活,以简单数据库应用为例,本小组以制作“酒店管理系统”为目标。该管理系统已经能实现一些酒店住房管理的一些基本功能,适用于中小型宾馆使用及访问,旨在用计算机系统为操作人员...
  • HSQLDB(Hypersonic SQL)是纯Java开发的关系型数据库,并提供JDBC驱动存取数据。支持ANSI-92标准SQL语法。而且他占的空间很小。大约只有160K,拥有快速的数据库引擎。  Axion  Axion是一个小型,快速,开源的关系型...
  • java完成登录页面+连接数据库

    千次阅读 2021-01-15 11:11:06
    java完成登录页面+连接数据库 import java.awt.FlowLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.sql.Connection; import java.sql.DriverManager; import java....
  • Java之JDBC连接数据库实现增删改查(2018 使用Dao层实现) 实体类:User.java 接口类:IUserDao.java 实现接口类:UserDaoImpl.java 使用Junit4测试增删改查类:UserDaoTest.java
  • 使用Java连接数据库需要使用JDBC驱动JDBCJava Data Base Connectivity,java数据库连接是一种用于执行SQL语句的Java API可以为多种关系数据库提供统一访问它由一组用Java语言编写的类和接口组成以下是使用方法 ...
  • Java数据库编程

    千次阅读 多人点赞 2019-07-08 21:06:19
    JDBC:提拱了一种与平台无关的用于执行Sql语句的标准JAVA API,可以方便的实现多种关系型数据库的统一操作,它由一组用JAVA编写的类和接口组成 在实际开发中可以直接使用JDBC进行各个数据库的连接与操作,而且可以...
  • import java.sql.*; public class Main { private static void displayResultSet(ResultSet rs) throws SQLException { // 取得结果集元数据 ResultSetMetaData rsmd = rs.getMetaData(); // 取得结果集所...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 654,865
精华内容 261,946
关键字:

数据库接口java

java 订阅