JDBC连接、CRUD、事务、连接池知识从入门到入土

学习JDBC一文便足

一、JDBC概述

1.1JDBC介绍

• JDBC（java Database Connectivity）是一个独立于特定数据库管理系统、通用的SQL数据库存取4和操作的公共接口（一组API），定义了用来访问数据库的标准java类库，（java.sql.javax.sql）使用这些类库可以以一种标准的方法、方便地访问数据库资源。
• JDBC为访问不同的数据库提供了一种统一的途径，为开发者屏蔽了一些细节问题。
• JDBC的目标是使java程序员使用JDBC可以连接任何提供了JDBC驱动程序的数据库系统，这样就使得程序员无需对特定的数据库系统的特点有过多的了解，从而大大简化和加快了开发过程。

可以简单观察如下流程：

• 如果没有JDBC，那么JAVA程序访问数据库就成了这样：

• 有了JDBC,java程序访问数据库是这样的：

• 总结如下：

1.2 JDBC体系结构

• JDBC接口 （API）包括俩个层次：
  • 面向应用API：java API,抽象接口，供应用程序开发人员使用（连接数据库，执行SQL语句，获得结果）
  • 面向数据库的API：java Driver API,供开发商开发数据库驱动程序用。

JDBC是sun公司提供一套用于数据库操作接口,java程序员只需要面向这套接口编程即可.

不同的数据库厂商,需要针对这套接口,提供不同实现,不同的实现的集合,即为不同数据库的驱动.

​ 面向接口编程

• 看到这你对JDBC应该已有了初步了解,接下来我们将从JDBC实际编写的代码步骤来看.

二、JDBC程序编写步骤

• 在编写步骤前我么来一起看一下编写步骤的流程

ODBC(Open Database Connectivity,开放式数据库连接),是微软在Windows平台下推出的,使用者在程序中只需要调用ODBC API,由ODBC驱动程序将调用转换成为对特定的数据库的调用请求.

2.1获取数据库连接

• 获取连接时有个坑千万别踩,就是驱动根据你的mysql版本来进行选择,尤其时mysql5.0.x和mysql8.0.x的驱动包使用起来有很大的区别,需要注意的有以下两点:
  • sJDBC driver 由“com.mysql.jdbc.Driver”改为“com.mysql.cj.jdbc.Driver”
  • url中加上“userSSL=false”和“serverTimezone=GMT%2B8”（GMT%2B8代表东八区）

**示例URL:注意下方"?"**是英文的

jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=UTF-8&userSSL=false&serverTimezone=GMT%2B8

原文链接:[(41条消息) jdbc连接mysql 8 的一些坑_wanglong1221的博客-CSDN博客](https://blog.csdn.net/wanglong1221/article/details/81148146?ops_request_misc=%7B%22request%5Fid%22%3A%22166359729616800192240219%22%2C%22scm%22%3A%2220140713.130102334…%22%7D&request_id=166359729616800192240219&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_allsobaiduend~default-1-81148146-null-null.142^v47pc_rank_34_queryrelevant25,201^v3control_1&utm_term=jdbc连接mysql 8 的一些坑&spm=1018.2226.3001.4187)

2.(1)要素一:Driver接口实现类

2.1.1Driver接口介绍

• java.sql.Driver接口是所有JDBC驱动程序需要实现的接口。这个接口是提供给数据库厂商使用的，不同数据库厂商提供不同的实现。

• 在程序中不需要直接去访问实现了Driver接口的类，而是由驱动程序管理器类(java.sql.DriverManager)去调用这些Driver实现。

  • Oracle的驱动：oracle.jdbc.driver.OracleDriver
  • mySql的驱动：com.mysql.jdbc.Driver

• 我此处使用的是mysql8.0.11的jar驱动包

2.1.2 加载与注册JDBC驱动

• 加载驱动：加载JDBC驱动需调用Class类的静态方法forName()，向其传递要加载的JDBC驱动的类名
• Class.forName(“com.mysql.cj.jdbc.Driver”);
• 注册驱动：DriverManager类是驱动程序管理器类，负责管理驱动程序
  • 使用DriverManager.registerDriver(com.mysql.jdbc.Driver)来注册驱动
  • 通常不用显式调用DriverManager类的registerDriver()方法来注册驱动程序类的实例，因为Driver接口的驱动程序类都包含了静态代码块，在这个静态代码块中，会调用DriverManager.registerDriver()方法来注册自身的一个实例。下图是MySQL的Driver实现类的源码：

正因有上述源码，所以在**Class.forName(“com.mysql.cj.jdbc.Driver”);**被注解时也能获取到Driver的原因

2.2 要素二：URL

• JDBC URL用于标识一个被注册的驱动程序，驱动程序管理器通过这个URL选择正确的驱动程序，从而建立到数据库的连接。

• JDBC URL的标准由三部分组成，各部分间用冒号分隔。

  • jdbc:子协议:子名称协议：

  • JDBC URL中的协议总是

  • jdbc子协议：子协议用于标识一个数据库驱动程序

  • 子名称：一种标识数据库的方法。子名称可以依不同的子协议而变化，用子名称的目的是为了定位数据库提供足够的信息。包含主机名(对应服务端的ip地址)，端口号，数据库名

URL处只需注意一点不同数据库的URL格式有区别，mysql5.0.x和mysql8.0.x编写也有区别

2.3 要素三：用户名和密码

• user,password可以用“属性名=属性值”方式告诉数据库
• 可以调用DriverManager类的getConnection()方法建立到数据库的连接

2.4数据库连接方式

此处连接方式共有五种，前四种大家浏览下，第五种可以上手敲一敲

2.4.1连接方式1

下方代码使用了第三方数据库API

//连接方式1：
  public static void main(String[] args) throws SQLException {
    //1.获取Driver实现类的对象
    Driver driver = new com.mysql.cj.jdbc.Driver();
    //url:jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&userSSL=false&serverTimezone=GMT%2B8
    //jdbc:mysql:协议
    //localhost:ip地址
    //3306:默认的mysql的端口号
    //test:test数据库
    /*如果是mysql5.0.x的驱动jar包，写到这就结束了，如果是8.0.x还需要
    加上：?useUnicode=true&characterEncoding=UTF-8&userSSL=false&serverTimezone=GMT%2B8*/
    String url="jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&userSSL=false&serverTimezone=GMT%2B8";
    //将用户名和密码封装在Properties中
    Properties info = new Properties();
    info.setProperty("user","root");
    info.setProperty("password","123456");

    Connection conn = driver.connect(url, info);
    System.out.println(conn);

  }

2.4.2连接方式二

方式二，对方式一的迭代:在如下的程序中不出现第三方的api，使得程序具有更好的移植性

  public void  ConnectionTest2() throws Exception {
     //1.获取Driver实现类的对象:使用反射
    Class aClass = Class.forName("com.mysql.cj.jdbc.Driver");
    Driver driver = (Driver) aClass.newInstance();

    //2.提供要连接的数据库
    String url="jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&userSSL=false&serverTimezone=GMT%2B8";
    //3.提供连接需要的用户名和密码
    Properties info = new Properties();
    info.setProperty("user","root");
    info.setProperty("password","123456");
    //4.获取连接
    Connection conn = driver.connect(url, info);
    System.out.println(conn);
  }

2.4.3 连接方式三

方式三:使用DriverManager替换Driver

public void ConnectionTest3() throws Exception {
    //1.获取Driver实现类的对象
    Class aClass = Class.forName("com.mysql.cj.jdbc.Driver");
    Driver driver = (Driver) aClass.newInstance();


    //2.模板三个连接的基本信息：

    String url="jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&userSSL=false&serverTimezone=GMT%2B8";
    String user="root";
    String password="123456";

    //注册驱动  DriverManager.registerDriver(driver);
    DriverManager.registerDriver(driver);


    //获取连接   DriverManager.getConnection(url,user,password);
    Connection conn = DriverManager.getConnection(url,user,password);
    System.out.println(conn);
  }

2.4.4 连接方式四

可以只是加载驱动，不用显示注册驱动了

 public void ConnectionTest4() throws Exception {
    //1.提供三个连接的基本信息：

    String url="jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&userSSL=false&serverTimezone=GMT%2B8";
    String user="root";
    String password="123456";


    //1.获取Driver实现类的对象

    Class.forName("com.mysql.cj.jdbc.Driver");
   

    //获取连接   DriverManager.getConnection(url,user,password);
    Connection conn = DriverManager.getConnection(url,user,password);
    System.out.println(conn);
  }

//相较于方式三可以省略如下操作
// Driver driver = (Driver) aClass.newInstance();

//注册驱动 DriverManager.registerDriver(driver);
// DriverManager.registerDriver(driver);
//**为什么可以省略如上操作呢？**原因如下

在DriverManager的源码中已经存在静态代码块，实现了驱动的注册。

2.4.5 连接方式5

方式五（final版），将数据库连接需要的4个基本信息声明在配置文件中，通过读取配置文件的方式，获取连接
此方式的好处
1.实现类数据与代码的分离，实现了解耦
2.如果需要修改配置文件的信息，可以避免程序重新打包

• 配置文件应在src包下

• 内容

public void ConnectionTest5() throws Exception {
    //1.读取配置文件中的4个
  InputStream inputStream = ConnectionTest.class.getClassLoader().getResourceAsStream("jdbc.properties");
  Properties pros = new Properties();
  pros.load(inputStream);

  String user= pros.getProperty("user");
  String password=pros.getProperty("password");
  String url=pros.getProperty("url");
  String driverClass=pros.getProperty("driverClass");
//  System.out.println(driverClass);
//2.加载驱动
  Class.forName(driverClass);
  //获取连接
  Connection conn = DriverManager.getConnection(url, user, password);
  System.out.println(conn);
}

三、使用PreparedStatement实现CRUD操作

3.1操作和访问数据库

• 数据库连接被用于向数据库服务器发送命令和SQL语句，并接受数据库服务器返回的结果。其实一个数据库连接就是一个Socket连接。

• 在java.sql包中有3个接口分别定义了对数据库的调用的不同方式：

  • Statement：用于执行静态SQL语句并返回它所生成结果的对象。
  • PrepatedStatement：SQL语句被预编译并存储在此对象中，可以使用此对象多次高效地执行该语句。
  • CallableStatement：用于执行SQL存储过程

3.2 使用Statement操作数据表的弊端

• 通过调用Connection对象的createStatement()方法创建该对象。该对象用于执行静态的SQL语句，并且返回执行结果。
• Statement接口中定义了下列方法用于执行SQL语句：

int excuteUpdate(Stringsql)：执行更新操作INSERT、UPDATE、DELETE ResultSet executeQuery(Stringsql)：执行查询操作SELECT

• 但是使用Statement操作数据表存在弊端：

  • 问题一：存在拼串操作，繁琐
  • 问题二：存在SQL注入问题

• SQL注入是利用某些系统没有对用户输入的数据进行充分的检查，而在用户输入数据中注入非法的SQL语句段或命令(如：SELECT user, password FROM user_table WHERE user=‘a’ OR 1 = ’ AND password = ’ OR ‘1’ =‘1’)，从而利用系统的SQL引擎完成恶意行为的做法。

• 对于Java而言，要防范SQL注入，只要用PreparedStatement(从Statement扩展而来)取代Statement就可以了。

3.3 PreparedStatement的使用

3.3.1 PreparedStatement介绍

• 可以通过调用Connection对象的preparedStatement(String sql)方法获取PreparedStatement对象
• PreparedStatement接口是Statement的子接口，它表示一条预编译过的SQL语句
• PreparedStatement对象所代表的SQL语句中的参数用问号(?)来表示，调用PreparedStatement对象的setXxx()方法来设置这些参数.setXxx()方法有两个参数，第一个参数是要设置的SQL语句中的参数的索引(从1开始)，第二个是设置的SQL语句中的参数的值

3.3.2PreparedStatement vs Staement

• 代码的可读性和可维护性。

• PreparedStatement能最大可能提高性能：

• DBServer会对预编译语句提供性能优化。因为预编译语句有可能被重复调用，所以语句在被DBServer的编译器编译后的执行代码被缓存下来，那么下次调用时只要是相同的预编译语句就不需要编译，只要将参数直接传入编译过的语句执行代码中就会得到执行。

• 在statement语句中,即使是相同操作但因为数据内容不一样,所以整个语句本身不能匹配,没有缓存语句的意义.事实是没有数据库会对普通语句编译后的执行代码缓存。这样每执行一次都要对传入的语句编译一次。

• (语法检查，语义检查，翻译成二进制命令，缓存)

• PreparedStatement可以防止SQL注入

3.3.3 使用PreparedStatement实现 增 删 改 操作

• 这里的配置文件跟上述的配置文件一样

//1.读取配置文件中的4个基本信息
    Connection conn = null;
    PreparedStatement ps = null;
    try {
      InputStream info = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");
      Properties properties = new Properties();
      properties.load(info);

      String user=properties.getProperty("user");
      String password=properties.getProperty("password");
      String url=properties.getProperty("url");
      String driverClass=properties.getProperty("driverClass");

      //2.加载驱动
      Class.forName(driverClass);
      //3.获取连接
      conn = DriverManager.getConnection(url, user, password);
      System.out.println(conn);
      //4.预编译sql语句，返回PreparedStatement的实例
      String sql="insert into customers(name,email,birth)values(?,?,?)";//?占位符
      ps = conn.prepareStatement(sql);

      //5.填充占位符
      ps.setString(1,"王大超");
      ps.setString(2, "156125@gmail.com");
     SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
      java.util.Date date = format.parse("2000-09-21");
      ps.setDate(3, new java.sql.Date(date.getTime()));

      //6.执行语句
      ps.execute();
    } catch (Exception e) {
      e.printStackTrace();
    } finally {

      //7.资源关闭
      try {

        if (ps != null) {
          ps.close();
        }
      } catch (SQLException throwables) {
        throwables.printStackTrace();
      }
      try {
        if(conn!=null){

          conn.close();
        }
      } catch (SQLException throwables) {
        throwables.printStackTrace();
      }

    }

  }

• 在写完第一遍操作以后我们发现，代码处还有很多地方可以优化，比如每次执行操作时都得执行以下操作：

  ①读取配置文件②加载驱动③获取连接④关闭资源

• 综上，我们可以写处将①②④步的方法封装到一个工具类里，首先在util包下建立相关的工具类：

首先，是①②步

 public static Connection getConnection() throws Exception{
    //1.读取配置文件中的4个
    InputStream inputStream = ClassLoader.getSystemClassLoader().getResourceAsStream("jdbc.properties");
    Properties pros = new Properties();
    pros.load(inputStream);

    String user= pros.getProperty("user");
    String password=pros.getProperty("password");
    String url=pros.getProperty("url");
    String driverClass=pros.getProperty("driverClass");
//  System.out.println(driverClass);
//2.加载驱动
    Class.forName(driverClass);
    //获取连接
    Connection conn = DriverManager.getConnection(url, user, password);
return conn;
  }

接着是关闭关闭连接PreparedStatement的操作

 public static void closeResource(Connection conn, Statement ps){
    try {

      if (ps != null) {
        ps.close();
      }
    } catch (SQLException throwables) {
      throwables.printStackTrace();
    }
    try {
      if(conn!=null){

        conn.close();
      }
    } catch (SQLException throwables) {
      throwables.printStackTrace();
    }

  }

• 拥有俩个工具类后，我们就能将上述代码进行优化了

 @Test
  public void testUpdate(){
    //1.读取配置文件中的4个基本信息

    Connection conn = null;
    PreparedStatement ps = null;
    try {
      conn = JDBCUtils.getConnection();

      //4.预编译sql语句，返回PreparedStatement的实例
      String sql="update customers set  name =? where id=?";//?占位符
      ps = conn.prepareStatement(sql);

      //5.填充占位符
      ps.setString(1,"妇女主席-王超");
      ps.setObject(2, 20);

      //6.执行语句
      ps.execute();
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      //7.资源关闭
      JDBCUtils.closeResource(conn,ps);
    }


  }

这时大家可以感受到拥有工具类后的便利，可是上述方法只能进行修改操作，如果要进行增删操作还需改动代码，而我们JAVA要遵循高内聚低耦合的设计原则，所以接下来我们将写通用的增删改的方法；

通用的增删改操作

  /*
  * 通用的增删改操作
  * */
  public  static  void  update(String sql,Object ...args){
    Connection conn = null;
    PreparedStatement ps = null;
    try {
      //1.获取数据库连接
     conn = JDBCUtils.getConnection();
//    2.预编译sql语句，返回PreparedStatement的实例
       ps = conn.prepareStatement(sql);
      //3.填充占位符
      for (int i = 0; i < args.length; i++) {
                      //SQL的索引从1开始， 数组从0索引开始
        ps.setObject(i+1,args[i]);//注意参数声明
      }
      //4.执行
      ps.execute();
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      JDBCUtils.closeResource(conn,ps);
    }
  }

测试

  public void updateTest()  {
    //删除
//    String sql = "delete from customers where id = ?";
//      JDBCUtils.update(sql,3);
    //修改
    String sql = "update `order` set order_name=? where order_id=?";
    JDBCUtils.update(sql,"DD","2");
  }
}

上述操作可以针对不同的表

3.3.4 使用PreparedStatement实现查询操作

 public ArrayList<Customer> queryForCustomer( String sql, Object... args) {
    Connection conn = null;
    PreparedStatement ps = null;
    ResultSet rs = null;
    try {
      conn = JDBCUtils.getConnection();

      ps = conn.prepareStatement(sql);

      for (int i = 0; i < args.length; i++) {
        ps.setObject(i + 1, args[i]);

      }
      rs = ps.executeQuery();
      //获取结果集的元素数据：ResultSetMetaData
      ResultSetMetaData rsmd = rs.getMetaData();
      //通过ResultSetMetaData获取结果集中的列数
      int columnCount = rsmd.getColumnCount();

      ArrayList<Customer> list = new ArrayList<>();
      while (rs.next()) {
        Customer cust = new Customer();
        //处理结果集一行数据的每一个列
        for (int j = 0; j < columnCount; j++) {
          //获取列值
          Object columValue = rs.getObject(j + 1);
          //获取每个列的列名
          String columnLabel = rsmd.getColumnLabel(j + 1);

          //给cust对象指定的clumName属性，赋值为columValue,通过反射
          Field field = Customer.class.getDeclaredField(columnLabel);
          field.setAccessible(true);
          field.set(cust, columValue);
        }

        list.add(cust);
//        return list;
      }
      return list;
//      for (Customer customer : list) {
//        System.out.println(customer);
//      }
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      JDBCUtils.closeResource(conn, ps, rs);
    }
    return null;
  }

之前的关闭工具类应多加个关闭结果集的操作

  public static void closeResource(Connection conn, Statement ps,ResultSet rs){
    try {

      if (ps != null) {
        ps.close();
      }
    } catch (SQLException throwables) {
      throwables.printStackTrace();
    }
    try {
      if(conn!=null){

        conn.close();
      }
    } catch (SQLException throwables) {
      throwables.printStackTrace();
    }
    try {
      if(rs!=null){

        rs.close();
      }
    } catch (SQLException throwables) {
      throwables.printStackTrace();
    }
  }

Customer类

/*
*
* OMR编程思想 （object relational mapping）
* 一个数据表对应一个java类
* 表中的一条数据记录对应java类的一个对象
* 表中的一个字段对应Java类的一个属性
* */
public class Customer {
  public Customer() {
  }

  public Customer(int id, String name, String email, Date birth) {
    this.id = id;
    this.name = name;
    this.email = email;
    this.birth = birth;
  }

  private int id;

  public int getId() {
    return id;
  }

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

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public String getEmail() {
    return email;
  }

  public void setEmail(String email) {
    this.email = email;
  }

  public Date getBirth() {
    return birth;
  }

  public void setBirth(Date birth) {
    this.birth = birth;
  }

  private String name;
  private String email;
  private Date birth;

  @Override
  public String toString() {
    return "Customer{" +
      "id=" + id +
      ", name='" + name + '\'' +
      ", email='" + email + '\'' +
      ", birth=" + birth +
      '}';
  }
}

3.3.4.1 Java与SQL对应数据类型转换表

Java类型	SQL类型
boolean	BIT
byte	TINYINT
short	SMALLINT
int	INTEGER
long	BIGINT
String	CHAR,VARCHAR,LONGVARCHAR
byte array	BINARY , VAR BINARY
java.sql.Date	DATE
java.sql.Time	TIME
java.sql.Timestamp	TIMESTAMP

通用的查询操作

public <T> List<T> getForList(Class<T> clazz, String sql, Object... args){
    Connection conn = null;
    PreparedStatement ps = null;
    ResultSet rs = null;
    try {
      conn = JDBCUtils.getConnection();

      ps = conn.prepareStatement(sql);

      for (int i = 0; i < args.length; i++) {
        ps.setObject(i + 1, args[i]);

      }
      rs = ps.executeQuery();
      //获取结果集的元素数据：ResultSetMetaData
      ResultSetMetaData rsmd = rs.getMetaData();
      //通过ResultSetMetaData获取结果集中的列数
      int columnCount = rsmd.getColumnCount();

      ArrayList<T> list = new ArrayList<>();
      while (rs.next()) {
        //使用反射获取对象
        T t = clazz.newInstance();
        //处理结果集一行数据的每一个列
        for (int j = 0; j < columnCount; j++) {
          //获取列值
          Object columValue = rs.getObject(j + 1);
          //获取每个列的列名
          String columnLabel = rsmd.getColumnLabel(j + 1);

          //给cust对象指定的clumName属性，赋值为columValue,通过反射
          Field field = Customer.class.getDeclaredField(columnLabel);
          field.setAccessible(true);
          field.set(t, columValue);
        }

        list.add(t);

      }
      return list;

    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      JDBCUtils.closeResource(conn, ps, rs);
    }
    return null;
  }

测试

public class CustomerForQuery {
  @Test
  public  void testQueryForCoustomer(){
String sql="select id,name,birth,email from customers where id<?";
    ArrayList<Customer> customers = queryForCustomer(sql, 13);
    customers.forEach(System.out::println);
    String sql1="select id,name,birth,email from customers where id>?";
    List<Customer> list = getForList(Customer.class, sql1, 5);
    list.forEach(System.out ::println);
  }

3.4 ResultSet与ResultSetMetaData

3.4.1 ResultSet

• 查询需要调用PreparedStatement的executeQuery()方法，查询结果是一个ResultSet对象
• ResultSet对象以逻辑表格的形式封装了执行数据库操作的结果集，ResultSet接口由数据库厂商提供实现
• ResultSet返回的实际上就是一张数据表。有一个指针指向数据表的第一条记录的前面。
• ResultSet对象维护了一个指向当前数据行的游标，初始的时候，游标在第一行之前，可以通过ResultSet对象的next()方法移动到下一行。调用next()方法检测下一行是否有效。若有效，该方法返回true，且指针下移。相当于Iterator对象的hasNext()和next()方法的结合体。
• 当指针指向一行时,可以通过调用getXxx(int index)或getXxx(int columnName)获取每一列的值.
  • 例如：getInt(1),getString(“name”)
  • 注意：Java与数据库交互涉及到的相关Java API中的索引都从1开始。
• ResultSet接口常用方法
  • boolean next()
  • getString()

3.4.2 ResultSetMetaData

• 可用于获取关于ResultSet对象列的类型和属性信息的对象
• ResultSetMetaData meta = rs.getMetaData();
  • getColumnName(int column)：获取指定列的名称；
  • getColumnLabel(int column)：获取指定列的别名；
  • getColumnCount()：返回当前ResultSet对象中的列数。
  • getColumnTypeName(int column)：检索指定列的数据库特定的类型名称。
  • getColumnDisplaySize(int column)：指示指定列的最大标准宽度，以字符为单位。
  • isNullable(int column)：指示指定列中的值是否可以为null。
  • isAutoIncrement(int column)：指示是否自动为指定列进行编号，这样这些列仍然是只读的。

问题1：得到结果集后,如何知道该结果集中有哪些列？列名是什么？

需要使用一个描述ResultSet的对象，即ResultSetMetaData

问题2：关于ResultSetMetaData

​ 1.如何获取ResultSetMetaData：调用ResultSet的getMetaData()方法即可

​ 2.获取ResultSet中有多少列：调用ResultSetMetaData的getColumnCount()方法

​ 3.获取ResultSet每一列的列的别名是什么：调用ResultSetMetaData的getColumnLabel()方法

• 看完这些内容想必对我上述操作也了解更加深刻了吧

四、数据库事务

4.1 数据库事务介绍

• 事务：一组逻辑操作单元,使数据从一种状态变换到另一种状态。
• 事务处理（事务操作）：保证所有事务都作为一个工作单元来执行，即使出现了故障，都不能改变这种执行方式。当在一个事务中执行多个操作时，要么所有的事务都被提交(commit)，那么这些修改就永久地保存下来；要么数据库管理系统将放弃所作的所有修改，整个事务**回滚(rollback)**到最初状态。
• 为确保数据库中数据的一致性，数据的操纵应当是离散的成组的逻辑单元：当它全部完成时，数据的一致性可以保持，而当这个单元中的一部分操作失败，整个事务应全部视为错误，所有从起始点以后的操作应全部回退到开始状态。

4.2 JDBC事务处理

• 数据一旦提交，就不可回滚
• 数据什么时候意味着提交？
  • 当一个连接对象被创建时，默认情况下是自动提交事务：每次执行一个SQL语句时，如果执行成功，就会向数据库自动提交，而不能回滚。
  • **关闭数据库连接，数据就会自动的提交。**如果多个操作，每个操作使用的是自己单独的连接，则无法保证事务。即同一个事务的多个操作必须在同一个连接下。
• JDBC程序中为了让多个SQL语句作为一个事务执行：
  • 调用Connection对象的**setAutoCommit(false);**以取消自动提交事务
  • 在所有的SQL语句都成功执行后，调用**commit();**方法提交事务
  • 在出现异常时，调用**rollback();**方法回滚事务

若此时Connection没有被关闭，还可能被重复使用，则需要恢复其自动提交状态setAutoCommit(true)。尤其是在使用数据库连接池技术时，执行close()方法前，建议恢复自动提交状态。

• **案例：**用户AA向用户BB转账100

对数据库操作的方法：

 public  static  void  update(Connection conn,String sql,Object ...args){
    PreparedStatement ps = null;
    try {
//    1.预编译sql语句，返回PreparedStatement的实例
       ps = conn.prepareStatement(sql);
      //2.填充占位符
      for (int i = 0; i < args.length; i++) {
                      //SQL的索引从1开始， 数组从0索引开始
        ps.setObject(i+1,args[i]);//注意参数声明
      }
      //3.执行
      ps.execute();
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      JDBCUtils.closeResource(null,ps);
    }


  }

  public  void  testJDBCTransfer() throws Exception {
    Connection conn = null;
    try {
       conn = JDBCUtils.getConnection();
      conn.setAutoCommit(false);

      String sql1= "update  user_table set  balance=balance -100 where user=?";
      update(conn,sql1,"AA");

      //模拟网络异常
      //System.out.println(10/0);

      String sql2 = "update  user_table set  balance=balance +100 where user=?";
      update(conn, sql2, "BB");
      //若无异常，提交事务
      conn.commit();

    } catch (Exception e) {
      e.printStackTrace();
      //若有异常，则回滚事务
      try {
        conn.rollback();
      } catch (SQLException throwables) {
        throwables.printStackTrace();
      }
    } finally {
      try {
        conn.setAutoCommit(true);
      } catch (SQLException throwables) {
        throwables.printStackTrace();
      }
      JDBCUtils.closeResource(conn,null,null);
    }
  }

4.3 事物的ACID属性

1.原子性（Atomicity）原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。

2.**一致性（Consistency）**事务必须使数据库从一个一致性状态变换到另外一个一致性状态。

3.隔离性（Isolation）事务的隔离性是指一个事务的执行不能被其他事务干扰，即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。

4.**持久性（Durability）**持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来的其他操作和数据库故障不应该对其有任何影响。

4.3.1 数据库的并发问题

• 对于同时运行的多个事务,当这些事务访问数据库中相同的数据时,如果没有采取必要的隔离机制,就会导致各种并发问题:
  • **脏读:**对于两个事务T1, T2, T1读取了已经被T2更新但还没有被提交的字段。之后,若T2回滚,T1读取的内容就是临时且无效的。
  • 不可重复读:对于两个事务T1, T2, T1读取了一个字段,然后T2更新了该字段。之后, T1再次读取同一个字段,值就不同了。
  • **幻读:**对于两个事务T1, T2, T1从一个表中读取了一个字段,然后T2在该表中插入了一些新的行。之后,如果T1再次读取同一个表,就会多出几行。
• 数据库事务的隔离性:数据库系统必须具有隔离并发运行各个事务的能力,使它们不会相互影响,避免各种并发问题。
• 一个事务与其他事务隔离的程度称为隔离级别。数据库规定了多种事务隔离级别,不同隔离级别对应不同的干扰程度,隔离级别越高,数据一致性就越好,但并发性越弱。

4.3.2 四种隔离级别

• 数据库提供的4种事务隔离级别：

  隔离级别	描述
  READ UNCOMMITTED(读未提交数据)	允许事务读取未被其他事物提交的变更，脏读，不可重复读和幻读的问题都会出现
  READ COMMITED(读已提交数据)	只允许事务读取已经被其它事务提交的变更，可以避免脏读，但不可重复读和幻读问题仍然可能出现
  REPEATABLE READ(可重复读)	确保事务可以多次从一个字段中读取相同的值，在这个事务持续期间，禁止其他事物对这个字段进行更新，可以避免脏读和不可重复读，但幻读的问题仍然存在。
  SERIALIZABLE(串行化)	确保事务可以从一个表中读取相同的行，在这个事务持续期间，禁止其他事务对该表执行插入，更新和删除操作，所有并发问题都可以避免，但性能十分低下。

• Oracle支持的2种事务隔离级别：READ COMMITED, SERIALIZABLE。Oracle默认的事务隔离级别为: READ COMMITED。

• Mysql支持4种事务隔离级别。Mysql默认的事务隔离级别为: REPEATABLE READ。

4.3.3 在MySql中设置隔离级别

• 每启动一个mysql程序,就会获得一个单独的数据库连接.每个数据库连接都有一个全局变量@@tx_isolation,表示当前的事务隔离级别。
• 查看当前的隔离级别：

SELECT @@tx_isolation;

• 设置当前mySQL连接的隔离级别:

set transaction isolation level read committed;

• 设置数据库系统的全局的隔离级别:

set global transaction isolation level read committed;

• 设置完隔离级别后，要把全局隔离级数恢复到数据库默认的操作：

只需在系统服务里重启MySql即可

4.3.4 在JAVA里设置隔离级别

• 设数据库隔离级别

conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);

五、数据库连接池

5.1JDBC数据库连接池的必要性

• 在使用开发基于数据库的web程序时，传统的模式基本是按以下步骤：
  • 在主程序（如servlet、beans）中建立数据库连接
  • 进行sql操作
  • 断开数据库连接
• 这种模式开发，存在的问题:
  • 普通的JDBC数据库连接使用DriverManager来获取，每次向数据库建立连接的时候都要将Connection加载到内存中，再验证用户名和密码(得花费0.05s～1s的时间)。需要数据库连接的时候，就向数据库要求一个，执行完成后再断开连接。这样的方式将会消耗大量的资源和时间。**数据库的连接资源并没有得到很好的重复利用。**若同时有几百人甚至几千人在线，频繁的进行数据库连接操作将占用很多的系统资源，严重的甚至会造成服务器的崩溃。
  • **对于每一次数据库连接，使用完后都得断开。**否则，如果程序出现异常而未能关闭，将会导致数据库系统中的内存泄漏，最终将导致重启数据库。
  • 这种开发不能控制被创建的连接对象数，系统资源会被毫无顾及的分配出去，如连接过多，也可能导致内存泄漏，服务器崩溃。

5.2 数据库连接池技术

• 为解决传统开发中的数据库连接问题，可以采用数据库连接池技术。
• **数据库连接池的基本思想：**就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再放回去。
• 数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是重新建立一个。
• 数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库连接数来设定的。无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量。连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。

• 工作原理

• 数据库连接池技术的优点

1.资源重用

由于数据库连接得以重用，避免了频繁创建，释放连接引起的大量性能开销。在减少系统消耗的基础上，另一方面也增加了系统运行环境的平稳性。

2.更快的系统反应速度

数据库连接池在初始化过程中，往往已经创建了若干数据库连接置于连接池中备用。此时连接的初始化工作均已完成。对于业务请求处理而言，直接利用现有可用连接，避免了数据库连接初始化和释放过程的时间开销，从而减少了系统的响应时间

3.新的资源分配手段

对于多应用共享同一数据库的系统而言，可在应用层通过数据库连接池的配置，实现某一应用最大可用数据库连接数的限制，避免某一应用独占所有的数据库资源

4.统一的连接管理，避免数据库连接泄漏

在较为完善的数据库连接池实现中，可根据预先的占用超时设定，强制回收被占用连接，从而避免了常规数据库连接操作中可能出现的资源泄露

5.3 多种开源的数据库连接池

• JDBC的数据库连接池使用javax.sql.DataSource来表示，DataSource只是一个接口，该接口通常由服务器(Weblogic, WebSphere, Tomcat)提供实现，也有一些开源组织提供实现：
  • DBCP是Apache提供的数据库连接池。tomcat服务器自带dbcp数据库连接池。速度相对c3p0较快，但因自身存在BUG，Hibernate3已不再提供支持。
  • C3P0是一个开源组织提供的一个数据库连接池，速度相对较慢，稳定性还可以。hibernate官方推荐使用
  • Proxool是sourceforge下的一个开源项目数据库连接池，有监控连接池状态的功能，稳定性较c3p0差一点
  • BoneCP是一个开源组织提供的数据库连接池，速度快
  • Druid是阿里提供的数据库连接池，据说是集DBCP、C3P0、Proxool优点于一身的数据库连接池，但是速度不确定是否有BoneCP快
• DataSource通常被称为数据源，它包含连接池和连接池管理两个部分，习惯上也经常把DataSource称为连接池
• DataSource用来取代DriverManager来获取Connection，获取速度快，同时可以大幅度提高数据库访问速度。
• 注意：
  • 数据源和数据库连接不同，数据源无需创建多个，它是产生数据库连接的工厂，因此整个应用只需要一个数据源即可。
  • 当数据库访问结束后，程序还是像以前一样关闭数据库连接：conn.close();但conn.close()并没有关闭数据库的物理连接，它仅仅把数据库连接释放，归还给了数据库连接池。

接下来我这里只介绍最后一种连接池技术，是阿里巴巴的Druid(德鲁伊)数据库连接池，是目前市面上比较主流的一种连接池技术，在开发中够用，大家如果感兴趣上面说到的DBCP和C3P0可以下来在B站上搜取相关视频。

5.3.1Druid(德鲁伊)数据库连接池

Druid是阿里巴巴开源平台上一个数据库连接池实现，它结合了C3P0、DBCP、Proxool等DB池的优点，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况，可以说是针对监控而生的DB连接池，可以说是目前最好的连接池之一。

packagecom.atguigu.druid;

importjava.sql.Connection;
importjava.util.Properties;

importjavax.sql.DataSource;

importcom.alibaba.druid.pool.DruidDataSourceFactory;

publicclassTestDruid{publicstaticvoidmain(String[]args)throwsException{
Propertiespro=newProperties();
pro.load(TestDruid.class.getClassLoader().getResourceAsStream("druid.properties"));
DataSourceds=DruidDataSourceFactory.createDataSource(pro);
Connectionconn=ds.getConnection();
System.out.println(conn);
}
}

• src下的配置文件为：druid.properties

url=jdbc:mysql://localhost:3306/test?rewriteBatchedStatements=true
username=root
password=123456
driverClassName=com.mysql.cj.jdbc.Driver
initialSize=10
maxActive=20
maxWait=1000
filters=wall

配置	缺省	说明
name		配置这个属性的意义在于，如果存在多个数据源，监控的时候可以通过名字来区分开来。如果没有配置，将会生成一个名字，格式是：”DataSource-”+System.identityHashCode(this)
url		连接数据库的url，不同数据库不一样。例如：mysql:jdbc:mysql://10.20.153.104:3306/druid2oracle:jdbc:oracle:thin:@10.20.149.85:1521:ocnauto
username		连接数据库的用户名
password		连接数据库的密码。如果你不希望密码直接写在配置文件中，可以使用ConfigFilter。详细看这里：https://github.com/alibaba/druid/wiki/%E4%BD%BF%E7%94%A8ConfigFilter
driverClassName		根据url自动识别这一项可配可不配，如果不配置druid会根据url自动识别dbType，然后选择相应的driverClassName(建议配置下)
initialSize	0	初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getConnection时
maxActive	8	最大连接池数量
maxIdle	8	已经不再使用，配置了也没效果
minIdle		最小连接池数量
maxWait		获取连接时最大等待时间，单位毫秒。配置了maxWait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置useUnfairLock属性为true使用非公平锁。
poolPreparedStatements	false	是否缓存preparedStatement，也就是PSCache。PSCache对支持游标的数据库性能提升巨大，比如说oracle。在mysql下建议关闭。
maxOpenPreparedStatements	-1	要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true。在Druid中，不会存在Oracle下PSCache占用内存过多的问题，可以把这个数值配置大一些，比如说100
validationQuery		用来检测连接是否有效的sql，要求是一个查询语句。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会其作用。
testOnBorrow	true	申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
testOnReturn	false	归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
testWhileIdle	false	建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
timeBetweenEvictionRunsMillis		有两个含义：1)Destroy线程会检测连接的间隔时间2)testWhileIdle的判断依据，详细看testWhileIdle属性的说明
numTestsPerEvictionRun		不再使用，一个DruidDataSource只支持一个EvictionRun
minEvictableIdleTimeMillis
connectionInitSqls		物理连接初始化的时候执行的sql
exceptionSorter		根据dbType自动识别当数据库抛出一些不可恢复的异常时，抛弃连接
filters		属性类型是字符串，通过别名的方式配置扩展插件，常用的插件有：监控统计用的filter:stat日志用的filter:log4j防御sql注入的filter:wall
proxyFilters		类型是List，如果同时配置了filters和proxyFilters，是组合关系，并非替换关系

总结

此份博客JDBC学习的内容摘自沈老师和宋老师课堂之上，学完和敲完以上内容已是我学习JDBC第六天的时间，我将课堂内容精简到以上五个方面，希望会对各位读者有用，还有相关jar包和相关数据库表内容，如若需要，请在评论区留言，我看到后会在第一时间分享给大家

持续关注，后续还会更新JDBC与数据表相关的Blob类型数据、DBUtils的操作