JDBC（1）

1）JDBC概述

什么是JDBC
JDBC（Java DataBase Connectivity, Java数据库连接） ,是一种用于执行SQL语句的Java API，为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成

有了JDBC，程序员只需用JDBC API写一个程序，就可访问所有数据库。

Sun公司、数据库厂商、程序员三方关系
SUN公司是规范制定者，制定了规范JDBC（连接数据库规范）
DriverManager类 作用：管理各种不同的JDBC驱动
Connection接口
Statement接口和PreparedStatement接口
ResultSet接口
数据库厂商微软、甲骨文等分别提供实现JDBC接口的驱动jar包
程序员学习JDBC规范来应用这些jar包里的类。

JDBC访问数据库编码步骤

1：加载一个Driver驱动

2：创建数据库连接（Connection）

3：创建SQL命令发送器Statement

4：通过Statement发送SQL命令并得到结果

5：处理结果（select语句）

6：关闭数据库资源ResultSet Statement Connection

创建模块/项目 导入jar包

JDBD历史版本及特征

JDBC 1.0

JDBC 1.0 随JDK1.1一起发布,JDBC操作相关的接口和类位于java.sql包中。

JDBC 2.0

JDBC 2.0 API被划分为两部分：核心API和扩展API,有两个包,分别是java.sql包和javax.sql包。

java.sql核心API包

在支持新功能方面：包括结果集可以向后滚动，批量的更新数据。另外，还提供了UNICODE字符集的字符流操作。

在支持SQL的数据类型方面：新增加的BLOB, CLOB,和数组接口能够是应用程序操作大块的数据类型

javax.sql扩展API包

DataSource数据源接口：

JDBC1.0是原来是用DriverManager类来产生一个对数据源的连接。JDBC2.0用一种替代的方法，使用DataSource的实现，代码变的更小巧精致，也更容易控制。

Connection pooling

如果DataSource对象实现与一个支持连接池的中间层的服务器一起工作，DataSource对象就会自动的返回连接池中的连接，这个连接也是可以重复利用的。

Distrubute transaction：

在一个事务中涉及到了多个数据库服务器。获得一个用来支持分布式事务的连接与获得连接池中的连接是很相似的。同样，不同之处在于DataSource的实现上的不同，而不是在应用程序中获得连接的方式上有什么不同。

Rowsets：

RowSet接口扩展了ResultSet接口。这样RowSet对象就有了ResultSet对象所有的功能。不可以滚动的ResultSet变成了可以滚动的RowSet。

2）JDBC初识

(1)、代码：

public class test1 {
    //这是一个main方法，是程序的入口：
    public static void main(String []args) throws SQLException {
         /*
            * 向Dept表增加一条数据
            *
         */
         //1.加载驱动：Driver
        Driver driver = new com.mysql.cj.jdbc.Driver();
         //2.注册驱动：DriverManager
        DriverManager.registerDriver(driver);
        //3.获得连接：Connection
        String url ="jdbc:mysql://localhost:3306/four tables?useSSL=false &useUnicode=true&characterEncoding=UTF-8 &serverTimezone=UTC";
        String user = "root";
        String password = "root";
        Connection connection = DriverManager.getConnection(url,user,password);
        /*
         * user:用户名
         * password:密码
         * url:统一资源定位符 定位我们要连接的数据库的
         *   1协议         jdbc:mysql
         *   2IP          127.0.0.1/localhost
         *   3端口号       3306
         *   4数据库名字   mydb
         *   5参数
         *   协议://ip:端口/资源路径?参数名=参数值&参数名=参数值&....
         *   jdbc:mysql://127.0.0.1:3306/mydb
         *   useSSL=false  是否使用SLL认证机制
         *   useUnicode=true  是否使用Unicode字符集
         *   characterEncoding=UTF-8  指定Unicode的字符集
         *   serverTimezone=UTC   服务器时区：UTC/Asia/地名
         *
         */
        //4获得语句对象 Statment
        Statement statement = connection.createStatement();
        //5、执行SQL语句，返回结果
        String sql = "insert into dept values(60,'音乐部','北京');";
        int rows = statement.executeUpdate(sql);
        System.out.println("影响数据行数为：" + rows);
        //6释放资源
        statement.close();
        connection.close();
        /*
         * 注意顺序
         * 后获得的先关闭,先获得的后关闭
         */
    }
}

(2)、总结

MySQL8中数据库连接的四个参数有两个发生了变化

        String driver = "com.mysql.cj.jdbc.Driver";

String url = “jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai”;

        或者String url = ".......serverTimezone=GMT%2B8";

错误1：Exception in thread “main” java.lang.ClassNotFoundException: com.mysql.jdbc2.Driver

原因：没有添加jar包或者com.mysql.jdbc2.Driver路径错误

错误2：Exception in thread “main” java.sql.SQLException:

No suitable driver found for jbdc:mysql://127.0.0.1:3306/stumgr

原因：url错误

错误3：Exception in thread “main” java.sql.SQLException:

Access denied for user ‘root’@‘localhost’ (using password: YES)

原因：用户名或者密码错误

错误4：Exception in thread “main” com.mysql.jdbc.exceptions

.jdbc4.MySQLIntegrityConstraintViolationException:Duplicate entry ‘90’ for key ‘PRIMARY’

原因：主键冲突

错误5：Public Key Retrieval is not allowed

如果用户使用 sha256_password 认证，密码在传输过程中必须使用 TLS 协议保护，但是如果 RSA 公钥不可用，可以使用服务器提供的公钥；可以在连接中通过 ServerRSAPublicKeyFile 指定服务器的 RSA 公钥，或者AllowPublicKeyRetrieval=True参数以允许客户端从服务器获取公钥；但是需要注意的是 AllowPublicKeyRetrieval=True可能会导致恶意的代理通过中间人攻击(MITM)获取到明文密码，所以默认是关闭的，必须显式开启
在jdbc连接添加上参数allowPublicKeyRetrieval=true即可，注意参数间用&
(3)、驱动的加载
加载数据库驱动时,我们可以通过自己创建一个实例的方式,然后去注册驱

在查看Driver的源代码时我们发现,该类内部有一个静态代码块,在代码块中就是在实例化一个驱动并在驱动中心注册.静态代码块会在类进入内存时执行,也就是说,我们只要让该类字节码进入内存,就会自动完成注册,不需要我们手动去new

所以我们在代码中直接使用反射,通过Class.forName(“com.mysql.jdbc.Driver”),加载该类进入内存即可
我们继续查看jar包发现,jar包中已经默认配置了驱动类的加载

jar–META-INF–services–java.sql.Driver–com.mysql.jdbc.Driver,在加载jar包时,会自动读取该内容并加载驱动,所以我们不去编写Class.forName(“com.mysql.jdbc.Driver”),程序也是可以自动完成加载驱动的
(4)、结合异常处理代码

public class test4 {
    private static String driver = "com.mysql.cj.jdbc.Driver";
    private static String url ="jdbc:mysql://localhost:3306/four tables?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC";
    private static String user = "root";
    private static String password = "root";
    //这是一个main方法，是程序的入口：
    public static void main(String[] args)  {

       Connection connection = null;
       Statement statement = null;

        try {
            //1、通过反射加载驱动：Driver 2、注册驱动：DriverManager
            Class.forName(driver);
            //2、获得连接: Connection
            connection = DriverManager.getConnection(url,user,password);
            //3、获得语句对象: Statement
            statement = connection.createStatement();
            //4、执行SQL语句，返回结果
            String sql = "insert into dept values(50,'影视部','上海');";
            int rows = statement.executeUpdate(sql);
            System.out.println("影响数据行数：" + rows);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            //5、释放结果
           if(null != statement){
               try {
                   statement.close();
               } catch (SQLException e) {
                   e.printStackTrace();
               }
           }
            if(null != connection){
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            }
    }
}

(5)、添加功能

public class test3 {
        //这是一个main方法，是程序的入口：
        public static void main(String[] args) throws SQLException, ClassNotFoundException {
            //1、通过反射加载驱动：Driver 2、注册驱动：DriverManager
            Class.forName("com.mysql.cj.jdbc.Driver");
            //2、获得连接: Connection
            String url ="jdbc:mysql://localhost:3306/four tables?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC";
            String user = "root";
            String password = "root";
            Connection connection = DriverManager.getConnection(url,user,password);
            //3、获得语句对象: Statement
            Statement statement = connection.createStatement();
            //4、执行SQL语句，返回结果
            String sql = "insert into dept values(44,'影视部','上海');";
            int rows = statement.executeUpdate(sql);
            System.out.println("影响数据行数：" + rows);
            //5、释放结果
            statement.close();
            connection.close();
        }
}

(6)、删除和修改功能

public class test5 {
    private static String driver = "com.mysql.cj.jdbc.Driver";
    private static String url ="jdbc:mysql://localhost:3306/four tables?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC";
    private static String user = "root";
    private static String password = "root";
    //这是一个main方法，是程序的入口：
    public static void main(String[] args)  {
         // testInster();
        //testDelete();
        testUpdate();
    }
    public static void testInster(){
        Connection connection = null;
        Statement statement = null;
        try {
            //1、通过反射加载驱动：Driver 2、注册驱动：DriverManager
            Class.forName(driver);
            //2、获得连接: Connection
            connection = DriverManager.getConnection(url,user,password);
            //3、获得语句对象: Statement
            statement = connection.createStatement();
            //4、执行SQL语句，返回结果   //40,'OPERATIONS','BOSTON'
            String sql = "insert into dept values (40,'OPERATIONS','BOSTON');";
            int rows = statement.executeUpdate(sql);
            System.out.println("影响数据行数：" + rows);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            //5、释放结果
            if(null != statement){
                try {
                    statement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(null != connection){
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static void testDelete(){
        Connection connection = null;
        Statement statement = null;
        try {
            //1、通过反射加载驱动：Driver 2、注册驱动：DriverManager
            Class.forName(driver);
            //2、获得连接: Connection
            connection = DriverManager.getConnection(url,user,password);
            //3、获得语句对象: Statement
            statement = connection.createStatement();
            //4、执行SQL语句，返回结果
            String sql = "delete from dept where deptno = 40;";
            int rows = statement.executeUpdate(sql);
            System.out.println("影响数据行数：" + rows);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            //5、释放结果
            if(null != statement){
                try {
                    statement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(null != connection){
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static void testUpdate(){
        Connection connection = null;
        Statement statement = null;
        try {
            //1、通过反射加载驱动：Driver 2、注册驱动：DriverManager
            Class.forName(driver);
            //2、获得连接: Connection
            connection = DriverManager.getConnection(url,user,password);
            //3、获得语句对象: Statement
            statement = connection.createStatement();
            //4、执行SQL语句，返回结果      'OPERATIONS','BOSTON'
            String sql = "update dept set dname = '总部' ,loc = '北京' where deptno = 40;";
            int rows = statement.executeUpdate(sql);
            System.out.println("影响数据行数：" + rows);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            //5、释放结果
            if(null != statement){
                try {
                    statement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(null != connection){
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

(7)、查询操作
【1】代码：

public class test6 {
    private static String driver = "com.mysql.cj.jdbc.Driver";
    private static String url ="jdbc:mysql://localhost:3306/four tables?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC";
    private static String user = "root";
    private static String password = "root";
    //这是一个main方法，是程序的入口：
    public static void main(String[] args)  {
        testQuery();
    }
    public static void testQuery(){
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;
        try {
            //1、通过反射加载驱动：Driver 2、注册驱动：DriverManager
            Class.forName(driver);
            //2、获得连接: Connection
            connection = DriverManager.getConnection(url,user,password);
            //3、获得语句对象: Statement
            statement = connection.createStatement();
            //4、执行SQL语句，返回结果  ResultSet:结果集
            String sql = "select * from emp;";
            resultSet = statement.executeQuery(sql);
            //boolean next = resultSet.next();
            //System.out.println(next);
            //int anInt = resultSet.getInt(1);
            //System.out.println(anInt);
            while(resultSet.next()){
                int empno = resultSet.getInt("empno");
                String ename = resultSet.getString("ename");
                String job = resultSet.getString("job");
                int mgr = resultSet.getInt("mgr");
                Date hiredate = resultSet.getDate("hiredate");
                double sal = resultSet.getDouble("sal");
                double comm = resultSet.getDouble("comm");
                int deptno = resultSet.getInt("deptno");
                System.out.println(empno+"  "+ename+"  "+job+"  "+mgr+"  "+hiredate+"  "+sal+"  "+comm+"  "+deptno);
            }

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            //5、释放结果
            if(null != statement){
                try {
                    statement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(null != connection){
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(null != resultSet){
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

【2】
ResultSet里的数据一行一行排列，每行有多个字段，且有一个记录指针，指针所指的数据行叫做当前数据行，我们只能来操作当前的数据行。我们如果想要取得某一条记录，就要使用ResultSet的next()方法 ,如果我们想要得到ResultSet里的所有记录，就应该使用while循环。

ResultSet对象自动维护指向当前数据行的游标。每调用一次next()方法，游标向下移动一行。

初始状态下记录指针指向第一条记录的前面，通过next()方法指向第一条记录。循环完毕后指向最后一条记录的后面。

方法名	说明
boolean next()	将光标从当前位置向下移动一行
boolean previous()	游标从当前位置向上移动一行
void close()	关闭ResultSet 对象
int getInt(int colIndex)	以int形式获取结果集当前行指定列号值
int getInt(String colLabel)	以int形式获取结果集当前行指定列名值
float getFloat(int colIndex)	以float形式获取结果集当前行指定列号值
Float getFloat(String colLabel)	以float形式获取结果集当前行指定列名值
String getString(int colIndex)	以String 形式获取结果集当前行指定列号值
StringgetString(String colLabel)	以String形式获取结果集当前行指定列名值

作为一种好的编程风格，应在不需要Statement对象和Connection对象时显式地关闭它们。关闭Statement对象和Connection对象的语法形式为：用户不必关闭ResultSet。当它的 Statement 关闭、重新执行或用于从多结果序列中获取下一个结果时，该ResultSet将被自动关闭。

(8)、实体类封装结果集
【1】为什么将结果封装成对象或者对象集合?

1java是面向对象的编程语言,java中所有的数据处理都是基于面向对象的编码风格实现的,让数据以符合java风格的形式存在,便于对数据的后续处理

2ResultSet 集合虽然可以存放数据,但是它是JDBC中查询数据的一种手段,是一种数据的临时存储方案,使用完毕是要进行释放和关闭
封装后台查询数据并在前台显示

如何将结果集中的数据在java中进行存储和传递?

准备和数据库表格相对应的一个实体类,用于封装结果集中的每一条数据,数据库表格中的每一个字段就是实体类的一个属性,实体类的一个对象就可以用于存储数据库表中的一条记录.

准备实体类
【2】代码：

public class test6 {
    private static String driver = "com.mysql.cj.jdbc.Driver";
    private static String url ="jdbc:mysql://localhost:3306/four tables?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC";
    private static String user = "root";
    private static String password = "root";
    //这是一个main方法，是程序的入口：
    public static void main(String[] args){
        List<Emp> emps = testQuery();
        // 遍历集合
        for (Emp emp : emps) {
            System.out.println(emp);
        }
    }
    public static List<Emp> testQuery() {
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;
        List<Emp> list = null;
        try {
            //1、通过反射加载驱动：Driver 2、注册驱动：DriverManager
            Class.forName(driver);
            //2、获得连接: Connection
            connection = DriverManager.getConnection(url, user, password);
            //3、获得语句对象: Statement
            statement = connection.createStatement();
            //4、执行SQL语句，返回结果  ResultSet:结果集
            String sql = "select * from emp;";
            resultSet = statement.executeQuery(sql);
            //boolean next = resultSet.next();
            //System.out.println(next);
            //int anInt = resultSet.getInt(1);
            //System.out.println(anInt);
            list = new ArrayList<>();
            while (resultSet.next()) {
                int empno = resultSet.getInt("empno");
                String ename = resultSet.getString("ename");
                String job = resultSet.getString("job");
                int mgr = resultSet.getInt("mgr");
                Date hiredate = resultSet.getDate("hiredate");
                double sal = resultSet.getDouble("sal");
                double comm = resultSet.getDouble("comm");
                int deptno = resultSet.getInt("deptno");
                Emp emp = new Emp(empno, ename, job, mgr, hiredate, sal, comm, deptno);
                list.add(emp);
            }

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            //5、释放结果
            if (null != statement) {
                try {
                    statement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (null != connection) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (null != resultSet) {
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        return list;
    }
}

/*
 * 实体类:
 * 和数据库表格名称和字段是一一对应的类
 * 该类的对象主要用处是存储从数据库中查询出来的数据
 * 除此之外,该类没有任何的其他功能
 * 要求
 * 1类名和表名保持一致  (见名知意)
 * 2属性个数和数据库的表的列数保持一致
 * 3属性的数据类型和列的数据类型保持一致
 * 4属性名和数据库表格的列名要保持一致
 * 5所有的属性必须都是私有的 (出于安全考虑)
 * 6实体类的属性推荐写成包装类
 * 7日期类型推荐写成java.util.Date
 * 8所有的属性都要有get和set方法
 * 9必须具备空参构造方法
 * 10实体类应当实现序列化接口 (mybatis缓存  分布式需要 )
 * 11实体类中其他构造方法可选
 * */
public class Emp implements Serializable {
    //属性：
    private Integer EMPNO = null;
    private String  ename = null;
    private String  job = null;
    private Integer mgr = null;
    private Date    hiredate = null;
    private Double  sal = null;
    private Double  comm = null;
    private Integer deptno = null;
    //重写toString

    @Override
    public String toString() {
        return "Emp{" +
                "EMPNO=" + EMPNO +
                ", ename='" + ename + '\'' +
                ", job='" + job + '\'' +
                ", mgr=" + mgr +
                ", hiredate=" + hiredate +
                ", sal=" + sal +
                ", comm=" + comm +
                ", deptno=" + deptno +
                '}';
    }

    //空构造器：
    public Emp() {
    }
    //构造器：包含全部参数的方法
    public Emp(Integer EMPNO, String ename, String job, Integer mgr, Date hiredate, Double sal, Double comm, Integer deptno) {
        this.EMPNO = EMPNO;
        this.ename = ename;
        this.job = job;
        this.mgr = mgr;
        this.hiredate = hiredate;
        this.sal = sal;
        this.comm = comm;
        this.deptno = deptno;
    }

    //getter、setter方法
    public Integer getEMPNO() {
        return EMPNO;
    }

    public void setEMPNO(Integer EMPNO) {
        this.EMPNO = EMPNO;
    }

    public String getEname() {
        return ename;
    }

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

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    public Integer getMgr() {
        return mgr;
    }

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

    public Date getHiredate() {
        return hiredate;
    }

    public void setHiredate(Date hiredate) {
        this.hiredate = hiredate;
    }

    public Double getSal() {
        return sal;
    }

    public void setSal(Double sal) {
        this.sal = sal;
    }

    public Double getComm() {
        return comm;
    }

    public void setComm(Double comm) {
        this.comm = comm;
    }

    public Integer getDeptno() {
        return deptno;
    }

    public void setDeptno(Integer deptno) {
        this.deptno = deptno;
    }
}