JAVA11-JDBC学习

1.JDBC概念

      全称：java database connectivity ，JDBC 规范定义接口，

1） JDBC 是 官方（SUN公司）定义的一套操作所有关系型数据库的规则，也就是接口，称之为Java 访问数据库的标准规范；

2）具体的实现由各大数据库厂商来实现这套接口，提供数据库驱动的jar包，我们可以使用这套接口(jdbc)编程，实际上执行的代码是jar包的实现类。操作数据库还需要具体的实现类，也就是数据库驱动。真正执行的代码是驱动jar包中的实现类，比方说之前写的接口

     Person接口    worker实现类  写出： Person person = new worker（）；

含义就是父类引用指向子类对象的方式，而执行person.eat（）执行worker实现类的方法，产生了一个多态的调用。因此在jdbc编程当中，都是用接口类型来调用方法，而当我导入了jar包之后，调用的是实现类的实现方法。

3）每个 数据库厂商根据自家数据库的通信格式编写好自己数据库的驱动。所以我们只需要会调用 JDBC 接口中的方法即 可，数据库驱动由数据库厂商提供。

4）jar包一般包含的内容

     使用 JDBC 的好处：

1) 程序员如果要开发访问数据库的程序，只需要会调用 JDBC 接口中的方法即可，不用关注类是如何实现的。

2) 使用同一套 Java 代码，进行少量的修改就可以访问其他 JDBC 支持的数据库

1.1.jdbc的快速入门之jdbc执行的基本步骤

• 1）导入驱动jar包，我们目前用的是mysql-connector-java-5.1.37
• 2）去编写代码来注册驱动
• 3）获取数据库的连接对象Connection，它是本地的java代码和数据库之间的桥梁对象
• 4）有了连接对象后，我们就可以定义sql语句
• 5）Connection不能直接执行sql语句，需要获取执行sql语句对象（也就是Statement）
• 6）执行sql，接收返回结果
• 7）有了返回结果，处理这个返回结果。
• 8）释放资源

public class jdbcDemo01 {
    public static void main(String[] args) throws Exception {
        // 1)导入驱动jar包
        // 2)注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        //3) 获取数据库的连接对象
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db2", "root", "root");
        //4) 定义sql语句
        String sql = "update account set balance = 5000 where id =1 ";
        // 5) 获取执行sql语句的对象 Statement
        Statement stmt = conn.createStatement();
        // 6）执行sql语句
        int conut = stmt.executeUpdate(sql);
        //7)有了结果，处理结果，打印一下
        System.out.println(conut);
        // 8）释放资源
        stmt.close();
        conn.close();
    }
}

2.现在我们针对这里面出现的各个对象进行详细解答

2.1 DriverManager  驱动管理对象

      功能1： 注册驱动  为何能注册驱动，因为里面有方法  static void  registerDriver(Driver driver)  向 DriverManager 注册给定驱动程序。

                我们写代码  Class.forName("com.mysql.jdbc.Driver");来注册加载驱动，为何不是上面的方法呢，，此处com.mysql.jdbc.Driver加载能执行，说明com.mysql.jdbc.Driver这个类里面一定存在一个静态代码块自动执行，我们找寻下这个com.mysql.jdbc.Driver来找寻下这：确实有静态代码块。

static {
     try {
         java.sql.DriverManager.registerDriver(new Driver());
     } catch (SQLException E) {
         throw new RuntimeException("Can't register driver!");
     }
}

      mysql5之后的驱动jar包可以不写

      功能2：获取数据库连接 方法如下：

       static Connection  getConnection(String url, String user, String password)   试图建立到给定数据库 URL 的连接。

     *url  指定连接的数据库路径 语法 jdbc：mysql：//ip地址  ,举例如下:

                                                 jdbc：mysql：//localhost:3306/db3

     * user 用户名

     *password：密码

2.2 Connection       数据库连接对象

     功能：

         1）获取执行sql的对象 

方法1：Statement  createStatement() 创建一个 Statement 对象来将 SQL 语句发送到数据库。

方法2： PreparedStatement  prepareStatement(String sql)  创建一个 PreparedStatement 对象来将参数化的 SQL 语句发送到数据库。

          2）管理事务功能，针对开启事务、提交事务和回滚也封装了三个方法

开启事务   void  setAutoCommit(boolean autoCommit)

     含义：将此连接的自动提交模式设置为给定状态。调用该房屋设置参数为false，即开启事务

提交事务    void  commit()

     含义：使所有上一次提交/回滚后进行的更改成为持久更改，并释放此 Connection 对象当

              前持有的所有数据库锁。

回滚事务      void  rollback()

     含义：取消在当前事务中进行的所有更改，并释放此 Connection 对象当前持有的所有数据

              库锁。

2.3 Statement        执行sql的对象 statement在beans和sql两个包下都有， 本次看sql

     功能：Statement用于执行静态 SQL 语句并返回它所生成结果的对象。而PreparedStatement执行的是动态预编译sql语句，静态sql含义就是sql语句中的值是给定的就是静态sql。

1）执行sql  boolean  execute(String sql) 执行给定的 SQL 语句，该语句可能返回多个结果。

         返回： 如果第一个结果为 ResultSet 对象，则返回 true；如果其为更新计数或者不存在任何结果，则返回 false

2）执行sql   int  executeUpdate(String sql) 执行给定 SQL 语句，该语句可能为 INSERT、UPDATE 或 DELETE 语句，或者不返回任何内容的 SQL 语句（如 SQL DDL 语句）。

     DML  insert update delete

     DDL create alter  drop

3）ResultSet  executeQuery(String sql) 执行给定的 SQL（select） 语句，该语句返回单个 ResultSet 对象。

* int 返回值是影响的行数

练习1 向db2中account表插入一个数据 insert into account values (null,'王五',3000)

package cn.itcast.demo01.demo01.demo05;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class JdbcDemo02 {
    public static void main(String[] args) {
        Statement stmt = null;
        Connection conn = null;
        try {
            //注册驱动，我们这次抓取异常
            Class.forName("com.mysql.jdbc.Driver");
            //定义sql
            String sql  = "insert into account values (null,'王五',3000)";
            //获取Connection对象
            conn = DriverManager.getConnection("jdbc:mysql:///db2", "root", "root");
            //获取执行sql的对象Statement
            stmt = conn.createStatement();
            //执行sql
            int count = stmt.executeUpdate(sql);
            System.out.println(count);
            if(count > 0 ){
                System.out.println("添加成功");
            }else{
                System.out.println("添加失败");
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            if (stmt != null){//避免空指针异常
                try {
                    stmt.close();//stemt原来作用域在try中，因此需要提前定义
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn != null){//避免空指针异常
                try {
                    conn.close();//stemt原来作用域在try中，因此需要提前定义
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

练习2，我们修改db2中的account表的数据金额 update account set balance = 1500 where id = 3

public class JdbcDemo02 {
    public static void main(String[] args) {
        Statement stmt = null;
        Connection conn = null;
        try {
            //注册驱动，我们这次抓取异常
            Class.forName("com.mysql.jdbc.Driver");
            //定义sql
            String sql = "update account set balance = 1500 where id = 3";
            //获取Connection对象
            conn = DriverManager.getConnection("jdbc:mysql:///db2", "root", "root");
            //获取执行sql的对象Statement
            stmt = conn.createStatement();
            //执行sql
            int count = stmt.executeUpdate(sql);
            System.out.println(count);
            if(count > 0 ){
                System.out.println("添加成功");
            }else{
                System.out.println("添加失败");
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            if (stmt != null){//避免空指针异常
                try {
                    stmt.close();//stemt原来作用域在try中，因此需要提前定义
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn != null){//避免空指针异常
                try {
                    conn.close();//stemt原来作用域在try中，因此需要提前定义
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

练习3：删除表中一个记录   delete from account where id = 3

public class JdbcDemo02 {
    public static void main(String[] args) {
        Statement stmt = null;
        Connection conn = null;
        try {
            //注册驱动，我们这次抓取异常
            Class.forName("com.mysql.jdbc.Driver");
            //定义sql
            String sql = "delete from account where  id = 3";
            //获取Connection对象
            conn = DriverManager.getConnection("jdbc:mysql:///db2", "root", "root");
            //获取执行sql的对象Statement
            stmt = conn.createStatement();
            //执行sql
            int count = stmt.executeUpdate(sql);
            System.out.println(count);
            if(count > 0 ){
                System.out.println("添加成功");
            }else{
                System.out.println("添加失败");
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            if (stmt != null){//避免空指针异常
                try {
                    stmt.close();//stemt原来作用域在try中，因此需要提前定义
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn != null){//避免空指针异常
                try {
                    conn.close();//stemt原来作用域在try中，因此需要提前定义
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

练习4 创建一个表，DDL无返回值，因此if语句可以删除

public class JdbcDemo02 {
    public static void main(String[] args) {
        Statement stmt = null;
        Connection conn = null;
        try {
            //注册驱动，我们这次抓取异常
            Class.forName("com.mysql.jdbc.Driver");
            //定义sql
            String sql = "create table  student(id int, name varchar(20))";
            //获取Connection对象
            conn = DriverManager.getConnection("jdbc:mysql:///db2", "root", "root");
            //获取执行sql的对象Statement
            stmt = conn.createStatement();
            //执行sql
            int count = stmt.executeUpdate(sql);
            System.out.println(count);

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            if (stmt != null){//避免空指针异常
                try {
                    stmt.close();//stemt原来作用域在try中，因此需要提前定义
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn != null){//避免空指针异常
                try {
                    conn.close();//stemt原来作用域在try中，因此需要提前定义
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2.4 ResultSet          结果集对象，就是来封装查询结果的，例如ResultSet  executeQuery(String sql) 执行给定的 SQL（select） 语句，该语句返回单个 ResultSet 对象。

       ResultSet接口，返回值是结果集，常见的方法如下：

• boolean next（）；方法 游标向下移动一行，默认指向表头；判断是否最后一行末尾，如果是返回false，如果返回ture说明不是最后一行，还有数据
• getXxx（参数）；一次获取一行某一列的数据，XX代表数据类型，如int，double等

其中xxx代表数据类型，如int getInt（）；String类型 getString（）；

     参数 int 代表列的编号，从第一列开始（没有0列），如getString（1）；

           string 代表列的名称 ，如 getDouble（“balance”）

使用步骤：

     1）游标向下移动一行 

     2）判断释放有数据

     3）获取数据

public class JdbcDemo02 {
    public static void main(String[] args) {
        Statement stmt = null;
        Connection conn = null;
        ResultSet rd = null;//这个结果集也是一个资源，也需要是否
        try {
            //1.注册驱动，我们这次抓取异常
            Class.forName("com.mysql.jdbc.Driver");
            //2.定义sql
            String sql = "select * from account";
            //3.获取Connection对象
            conn = DriverManager.getConnection("jdbc:mysql:///db2", "root", "root");
            //4.获取执行sql的对象Statement
            stmt = conn.createStatement();
            //5.执行sql
            rd = stmt.executeQuery(sql);
            while (rd.next()){
                int anInt = rd.getInt(1);
                String name = rd.getString("name");
                double balance = rd.getDouble(3);
                System.out.println(anInt + "----" + name + "-----" + balance );
                System.out.println(rd);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{
            if (stmt != null){//避免空指针异常
                try {
                    stmt.close();//stemt原来作用域在try中，因此需要提前定义
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn != null){//避免空指针异常
                try {
                    conn.close();//stemt原来作用域在try中，因此需要提前定义
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

练习：查询emp表的数据，将其封装为对象，而专门装载对象的用集合即可

我们可以定义一个方法，查询emp表的数据，将其封装为对象，然后装载集合，返回，分为三步

类名 Emp类

方法： public List<emp> findAll(){}

实现方法 select * from emp；

    public static void main(String[] args) {
        List<Emp> list = new Jdbcdemo08().findAll();
        for(Emp emp : list){
            System.out.println(emp);
        }

package cn.itcast.demo01.demo01.demo05;

import java.sql.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Jdbcdemo08 {
    public static void main(String[] args) {
        List<Emp> list = new Jdbcdemo08().findAll();
        System.out.println(list);
    }
    /*
    查询所有emp对象
     */
    public List<Emp> findAll(){
        Connection conn = null;
        Statement stme = null;
        ResultSet rs = null;
        List<Emp> list = null;
        try {
            // 1)注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 2)获取连接
            conn = DriverManager.getConnection("jdbc:mysql:///db1", "root", "root");
            //3） 定义sql
            String sql = "select * from emp";
            //4)获取执行sql的对象
            stme = conn.createStatement();
            // 5）执行sql语句
            rs = stme.executeQuery(sql);
            // 7） 创建emp对象
            Emp emp = null;
            list = new ArrayList<Emp>();
            //6） 遍历结果集
            while (rs.next()){
                int id = rs.getInt("id");//此处的名称与emp表要一样，与类可不一样。
                String ename = rs.getString("ename");
                int job_id = rs.getInt("job_id");
                int mgr = rs.getInt("mgr");
                Date joindate = rs.getDate("joindate");
                double salary = rs.getDouble("salary");
                double bonus = rs.getDouble("bonus");
                int dept_id = rs.getInt("dept_id");

                //创建emp对象,并赋值
                emp = new Emp();
                emp.setId(id);
                emp.setEname(ename);
                emp.setJob_id(job_id);
                emp.setMgr(mgr);
                emp.setJoindate(joindate);
                emp.setSalary(salary);
                emp.setBonus(bonus);
                emp.setDept_id(dept_id);

                // 装载集合
                list.add(emp);

            }

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            if (rs != null){
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn != null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (stme != null){
                try {
                    stme.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        return list;//这个集合需要前置定义
    }
}

package cn.itcast.demo01.demo01.demo05;

import java.util.Date;

/*
封装emp数据的javaBean
 */
public class Emp {
    private int id;//参考数据表中的各个字段，补充进来 这里面的名字尽量一样
    private String ename;
    private int job_id;
    private int mgr;
    private Date joindate;
    private double salary;
    private double bonus;
    private int dept_id;

    @Override
    public String toString() {//方便打印看效果
        return "Emp{" +
                "id=" + id +
                ", ename='" + ename + '\'' +
                ", job_id=" + job_id +
                ", mgr=" + mgr +
                ", joindate=" + joindate +
                ", salary=" + salary +
                ", bonus=" + bonus +
                ", dept_id=" + dept_id +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getEname() {
        return ename;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public int getJob_id() {
        return job_id;
    }

    public void setJob_id(int job_id) {
        this.job_id = job_id;
    }

    public int getMgr() {
        return mgr;
    }

    public void setMgr(int mgr) {
        this.mgr = mgr;
    }

    public Date getJoindate() {
        return joindate;
    }

    public void setJoindate(Date joindate) {
        this.joindate = joindate;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    public int getDept_id() {
        return dept_id;
    }

    public void setDept_id(int dept_id) {
        this.dept_id = dept_id;
    }
}

2.5 PreparedStatement  执行Sql的对象，功能比Statement丰富

前面

抽取JDBC的工具类 JDBCUtils，目的是简化书写