数据库连接池

连接池介绍

  1. 什么是连接池

实际开发中“获得连接”或“释放资源”是非常消耗系统资源的两个过程，为了解决此类性能问题，通常情况我们采用连接池技术，来共享连接Connection。这样我们就不需要每次都创建连接、释放连接了，这些操作都交给了连接池.

  1. 连接池的好处

用池来管理Connection，这样可以重复使用Connection。 当使用完Connection后，调用Connection的
close()方法也不会真的关闭Connection，而是把Connection“归还”给池。

JDBC方式与连接池方式

任务二_数据库连接池&DBUtils - 图1普通 JDBC方式
连接池方式

任务二_数据库连接池&DBUtils - 图2

如何使用数据库连接池

Java为数据库连接池提供了公共的接口：javax.sql.DataSource，各个厂商需要让自己的连接池实现这个接口。 这样应用程序可以方便的切换不同厂商的连接池！
常见的连接池有 DBCP连接池, C3P0连接池, Druid连接池, 接下里我们就详细学习一下

数据准备

  1. #创建数据库
  2. CREATE DATABASE db5 CHARACTER SET utf8;
  4. #使用数据库
  5. USE db5;
  7. #创建员工表
  8. CREATE TABLE employee (
  9. eid INT PRIMARY KEY AUTO_INCREMENT ,
  10. ename VARCHAR (20),    -- 员工姓名
  11. age INT ,    -- 员工年龄
  12. sex VARCHAR (6),    -- 员工性别
  13. salary DOUBLE ,    -- 薪 水
  14. empdate DATE    -- 入职日期
  15. );
  17. #插入数据
  18. INSERT INTO employee (eid, ename, age, sex, salary, empdate) VALUES(NULL,'李清照',22,'女',4000,'2018-11-12');
  19. INSERT INTO employee (eid, ename, age, sex, salary, empdate) VALUES(NULL,'林黛玉',20,'女',5000,'2019-03-14');
  20. INSERT INTO employee (eid, ename, age, sex, salary, empdate) VALUES(NULL,'杜甫',40,'男',6000,'2020-01-01');
  21. INSERT INTO employee (eid, ename, age, sex, salary, empdate) VALUES(NULL,'李白',25,'男',3000,'2017-10-01');

DBCP连接池

DBCP也是一个开源的连接池，是Apache成员之一，在企业开发中也比较常见，tomcat内置的连接池。

创建项目 导入 jar包

  1. 将这两个 jar包添加到 myJar文件夹中 （jar包在资料里的软件文件夹中）

任务二_数据库连接池&DBUtils - 图3

  1. 任务二_数据库连接池&DBUtils - 图4添加myJar库 到项目的依赖中

编写工具类

连接数据库表的工具类, 采用DBCP连接池的方式来完成

  • Java中提供了一个连接池的规则接口 ：DataSource,它是java中提供的连接池
  • 在DBCP包中提供了DataSource接口的实现类，我们要用的具体的连接池BasicDataSource类

代码示例

  1. package com.lagou.utils;
  3. import org.apache.commons.dbcp.BasicDataSource;
  5. import java.sql.Connection;
  6. import java.sql.ResultSet;
  7. import java.sql.SQLException;
  8. import java.sql.Statement;
  10. public class DBCPUtils {
  12.     //1.定义常量 保存数据库连接的相关信息
  13.     public static final String DRIVERNAME = "com.mysql.jdbc.Driver";
  14.     public static final String URL = "jdbc:mysql://localhost:3306/db5?characterEncoding=UTF-8";
  15.     public static final String USERNAME = "root";
  16.     public static final String PASSWORD = "123456";
  18.     //2.创建连接池对象 (有DBCP提供的实现类)
  19.     public static BasicDataSource dataSource = new BasicDataSource();
  21.     //3.使用静态代码块进行配置
  22.     static{
  23.         dataSource.setDriverClassName(DRIVERNAME);
  24.         dataSource.setUrl(URL);
  25.         dataSource.setUsername(USERNAME);
  26.         dataSource.setPassword(PASSWORD);
  27.         dataSource.setMaxActive(20);
  28.     }
  30.     //4.获取连接的方法
  31.     public static Connection getConnection() throws SQLException {
  33.         //从连接池中获取连接
  34.         Connection connection = dataSource.getConnection();
  35.         return connection;
  36.     }
  38.     //5.释放资源方法
  39.     public static void close(Connection con, Statement statement){
  41.         if(con != null && statement != null){
  42.             try {
  43.                 statement.close();
  44.                 //归还连接
  45.                 con.close();
  46.             } catch (SQLException e) {
  47.                 e.printStackTrace();
  48.             }
  49.         }
  51.     }
  53.     public static void close(Connection con, Statement statement, ResultSet resultSet){
  55.         if(con != null && statement != null && resultSet != null){
  56.             try {
  57.                 resultSet.close();
  58.                 statement.close();
  59.                 //归还连接
  60.                 con.close();
  61.             } catch (SQLException e) {
  62.                 e.printStackTrace();
  63.             }
  64.         }
  66.     }
  68. }

测试工具类

需求: 查询所有员工的姓名

  1. package com.lagou.testpool;
  3. import com.lagou.utils.DBCPUtils;
  5. import java.sql.Connection;
  6. import java.sql.ResultSet;
  7. import java.sql.SQLException;
  8. import java.sql.Statement;
  10. public class TestDBCP {
  12.     /*
  13.     * 测试DBCP连接池
  14.     * */
  15.     public static void main(String[] args) throws SQLException {
  17.         //1.从DBCP连接池中拿到连接
  18.         Connection con = DBCPUtils.getConnection();
  20.         //2.获取Statement对象
  21.         Statement statement = con.createStatement();
  23.         //3.查询所有员工的姓名
  24.         String sql = "select ename from employee";
  25.         ResultSet resultSet = statement.executeQuery(sql);
  27.         //4.处理结果集
  28.         while(resultSet.next()){
  29.             String ename = resultSet.getString("ename");
  30.             System.out.println("员工姓名: " + ename);
  31.         }
  33.         //5.释放资源
  34.         DBCPUtils.close(con,statement,resultSet);
  35.     }
  37. }

常见配置项

属性 描述
driverClassName 数据库驱动名称
url 数据库地址
username 用户名
password 密码
maxActive 最大连接数量
maxIdle 最大空闲连接
minIdle 最小空闲连接
initialSize 初始化连接

C3P0连接池

C3P0是一个开源的JDBC连接池,支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate、Spring等。

导入jar包及配置文件

  1. 将jar包 复制到myJar文件夹即可,IDEA会自动导入

任务二_数据库连接池&DBUtils - 图5

导入配置文件 c3p0-config.xml

c3p0-config.xml 文件名不可更改

直接放到src下,也可以放到到资源文件夹中

  1. <c3p0-config>
  3.   <!--默认配置-->
  4.     <default-config>  
  6.         <!-- initialPoolSize：初始化时获取三个连接，
  7.               取值应在minPoolSize与maxPoolSize之间。 --> 
  8.         <property name="initialPoolSize">3</property>  
  10.         <!-- maxIdleTime：最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。-->
  11.         <property name="maxIdleTime">60</property>  
  13.         <!-- maxPoolSize：连接池中保留的最大连接数 -->
  14.         <property name="maxPoolSize">100</property>  
  15.         <!-- minPoolSize: 连接池中保留的最小连接数 -->
  16.         <property name="minPoolSize">10</property>  
  18.     </default-config>  
  20.    <!--配置连接池mysql-->
  22.     <named-config name="mysql">
  23.         <property name="driverClass">com.mysql.jdbc.Driver</property>
  24.         <property name="jdbcUrl">jdbc:mysql://192.168.197.4:3306/db5?characterEncoding=UTF-8</property>
  25.         <property name="user">root</property>
  26.         <property name="password">123456</property>
  27.         <property name="initialPoolSize">10</property>
  28.         <property name="maxIdleTime">30</property>
  29.         <property name="maxPoolSize">100</property>
  30.         <property name="minPoolSize">10</property>
  31.     </named-config>
  32.     <!--配置连接池2,可以配置多个-->
  34. </c3p0-config>
  1. 在项目下创建一个resource文件夹(专门存放资源文件)

任务二_数据库连接池&DBUtils - 图6

2.文件夹,右键 将resource文件夹指定为资源文件夹
任务二_数据库连接池&DBUtils - 图7

  1. 将文件放在resource目录下即可,创建连接池对象的时候会去加载这个配置文件

任务二_数据库连接池&DBUtils - 图8

编写C3P0工具类

  • C3P0提供的核心工具类, ComboPooledDataSource , 如果想使用连接池,就必须创建该类的对象

new ComboPooledDataSource(); 使用 默认配置
new ComboPooledDataSource(“mysql”); 使用命名配置

  1. package com.lagou.utils;
  3. import com.mchange.v2.c3p0.ComboPooledDataSource;
  4. import org.apache.commons.dbutils.QueryRunner;
  6. import java.sql.Connection;
  7. import java.sql.ResultSet;
  8. import java.sql.SQLException;
  9. import java.sql.Statement;
  11. public class C3P0Utils {
  13.     //1.创建连接池对象 C3P0对DataSource接口的实现类
  14.     //使用的配置是 配置文件中的默认配置
  15.     //public static ComboPooledDataSource dataSource = new ComboPooledDataSource();
  17.     //使用指定的配置
  18.     public static ComboPooledDataSource dataSource = new ComboPooledDataSource("mysql");
  20.     //获取连接的方法
  21.     public static Connection getConnection() throws SQLException {
  23.         return dataSource.getConnection();
  24.     }
  26.     //释放资源
  27.     public static void close(Connection con, Statement statement){
  30.         if(con != null && statement != null){
  31.             try {
  32.                 statement.close();
  33.                 //归还连接
  34.                 con.close();
  35.             } catch (SQLException e) {
  36.                 e.printStackTrace();
  37.             }
  38.         }
  40.     }
  42.     public static void close(Connection con, Statement statement, ResultSet resultSet){
  44.         if(con != null && statement != null && resultSet != null){
  45.             try {
  46.                 resultSet.close();
  47.                 statement.close();
  48.                 //归还连接
  49.                 con.close();
  50.             } catch (SQLException e) {
  51.                 e.printStackTrace();
  52.             }
  53.         }
  55.     }
  56. }

测试工具类

需求: 查询姓名为 李白的员工信息

  1. package com.lagou.testpool;
  3. import com.lagou.utils.C3P0Utils;
  5. import java.sql.*;
  7. public class TestC3P0 {
  9.     //需求 查询姓名为李白的 记录
  10.     public static void main(String[] args) throws SQLException {
  12.         //1.获取连接
  13.         Connection con = C3P0Utils.getConnection();
  15.         //2.获取预处理对象
  16.         String sql = "select * from employee where ename = ?";
  17.         PreparedStatement ps = con.prepareStatement(sql);
  19.         //3.设置占位符的值
  20.         ps.setString(1,"李白");
  21.         ResultSet resultSet = ps.executeQuery();
  23.         //4.处理结果集
  24.         while(resultSet.next()){
  25.             int eid = resultSet.getInt("eid");
  26.             String ename = resultSet.getString("ename");
  27.             int age = resultSet.getInt("age");
  28.             String sex = resultSet.getString("sex");
  29.             double salary = resultSet.getDouble("salary");
  30.             Date date = resultSet.getDate("empdate");
  32.             System.out.println(eid +" " + ename + " " + age +" " + sex +" " + salary +" " +date);
  33.         }
  35.         //5.释放资源
  36.         C3P0Utils.close(con,ps,resultSet);
  37.     }
  39. }

常见配置
任务二_数据库连接池&DBUtils - 图9

Druid连接池

Druid（德鲁伊）是阿里巴巴开发的号称为监控而生的数据库连接池，Druid是目前最好的数据库连接池。在功
能、性能、扩展性方面，都超过其他数据库连接池，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况。

导入jar包及配置文件

  1. 导入 jar包

任务二_数据库连接池&DBUtils - 图10导入

  1. 导入配置文件
  • 是properties形式的
  • 可以叫任意名称，可以放在任意目录下,我们统一放到 resources资源目录

任务二_数据库连接池&DBUtils - 图11

  1. driverClassName=com.mysql.jdbc.Driver 
  2. url=jdbc:mysql://127.0.0.1:3306/db5?characterEncoding=UTF-8 
  3. username=root
  4. password=123456 
  5. initialSize=5 
  6. maxActive=10 
  7. maxWait=300

编写Druid工具类

获取数据库连接池对象

  • 通过工厂来来获取 DruidDataSourceFactory类的createDataSource方法
  • createDataSource(Properties p) 方法参数可以是一个属性集对象 ```java package com.lagou.utils;

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource; import java.io.IOException; import java.io.InputStream; import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; import java.util.Properties;

public class DruidUtils {

  1. //1.定义成员变量
  2. public static DataSource dataSource;
  4. //2.静态代码块
  5. static{
  6.     try {
  7.         //3.创建属性集对象
  8.         Properties p = new Properties();
  10.         //4.加载配置文件 Druid 连接池不能够主动加载配置文件 ,需要指定文件
  11.         InputStream inputStream = DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties");
  13.         //5. 使用Properties对象的 load方法 从字节流中读取配置信息
  14.         p.load(inputStream);
  16.         //6. 通过工厂类获取连接池对象
  17.         dataSource = DruidDataSourceFactory.createDataSource(p);
  19.     } catch (Exception e) {
  20.         e.printStackTrace();
  21.     }
  22. }
  24. //获取连接的方法
  25. public static Connection getConnection(){
  27.     try {
  29.         return dataSource.getConnection();
  31.     } catch (SQLException e) {
  32.         e.printStackTrace();
  33.         return null;
  34.     }
  35. }
  37. //获取Druid连接池对象的方法
  38. public static DataSource getDataSource(){
  39.     return dataSource;
  40. }
  43. //释放资源
  44. public static void close(Connection con, Statement statement){
  46.     if(con != null && statement != null){
  47.         try {
  48.             statement.close();
  49.             //归还连接
  50.             con.close();
  51.         } catch (SQLException e) {
  52.             e.printStackTrace();
  53.         }
  54.     }
  56. }
  58. public static void close(Connection con, Statement statement, ResultSet resultSet){
  60.     if(con != null && statement != null && resultSet != null){
  61.         try {
  62.             resultSet.close();
  63.             statement.close();
  64.             //归还连接
  65.             con.close();
  66.         } catch (SQLException e) {
  67.             e.printStackTrace();
  68.         }
  69.     }
  71. }

}

  1. <a name="wHXqP"></a>
  2. ### 测试工具类
  3. 需求: 查询薪资在3000 - 5000元之间的员工姓名
  4. ```java
  5. package com.lagou.testpool;
  7. import com.lagou.utils.DruidUtils;
  9. import java.sql.Connection;
  10. import java.sql.ResultSet;
  11. import java.sql.SQLException;
  12. import java.sql.Statement;
  14. public class TestDruid {
  16.     // 需求 查询 薪资在3000 到 5000之间的员工的姓名
  17.     public static void main(String[] args) throws SQLException {
  19.         //1.获取连接
  20.         Connection con = DruidUtils.getConnection();
  22.         //2.获取Statement对象
  23.         Statement statement = con.createStatement();
  25.         //3.执行查询
  26.         ResultSet resultSet = statement.executeQuery("select ename from employee where salary between 3000 and 5000");
  28.         //4.处理结果集
  29.         while(resultSet.next()){
  30.             String ename = resultSet.getString("ename");
  31.             System.out.println(ename);
  32.         }
  34.         //5.释放资源
  35.         DruidUtils.close(con,statement,resultSet);
  36.     }
  38. }

DBUtils工具类

DBUtils简介

使用JDBC我们发现冗余的代码太多了,为了简化开发 我们选择使用 DbUtils
Commons DbUtils是Apache组织提供的一个对JDBC进行简单封装的开源工具类库，使用它能够简化JDBC应用程序的开发，同时也不会影响程序的性能。
使用方式:
DBUtils就是JDBC的简化开发工具包。需要项目导入 commons-dbutils-1.6.jar。
任务二_数据库连接池&DBUtils - 图12

Dbutils核心功能介绍

  1. QueryRunner 中提供对sql语句操作的API.
  2. ResultSetHandler接口，用于定义select操作后，怎样封装结果集.

  3. DbUtils类,他就是一个工具类,定义了关闭资源与事务处理相关方法.

    案例相关知识

    表和类之间的关系

    整个表可以看做是一个类
    表中的一行记录,对应一个类的实例(对象) 表中的一列,对应类中的一个成员属性
    任务二_数据库连接池&DBUtils - 图13

    JavaBean组件

  4. JavaBean 就是一个类, 开发中通常用于封装数据,有一下特点

  • 需要实现 序列化接口, Serializable (暂时可以省略)
  • 提供私有字段: private 类型 变量名;
  • 提 供 getter 和 setter
  • 提供 空参构造
  1. 创建Employee类和数据库的employee表对应
  • 我们可以创建一个 entity包,专门用来存放 JavaBean类

任务二_数据库连接池&DBUtils - 图14

  1. package com.lagou.entity;
  3. import java.io.Serializable;
  4. import java.sql.Date;
  6. /**
  7.  * @author 悟空
  8.  * @create 2021/3/21 下午12:08
  9.  */
  10. public class Employee implements Serializable {
  11.     /**
  12.      * JavaBean类
  13.      * 用来存数据 成员变量私有 提供get set 提供空参 实现序列化接口
  14.      *  * Employee类 就是对应了 数据库中Employee表
  15.      *  *   `eid` INT(11) NOT NULL AUTO_INCREMENT,
  16.      *  *   `ename` VARCHAR(20) DEFAULT NULL,
  17.      *  *   `age` INT(11) DEFAULT NULL,
  18.      *  *   `sex` VARCHAR(6) DEFAULT NULL,
  19.      *  *   `salary` DOUBLE DEFAULT NULL,
  20.      *  *   `empdate` DATE DEFAULT NULL,
  21.      */
  23.         // 成员变量的名称 与 表中的列要一样
  24.     private int eid;
  26.     private String ename;
  28.     private int age;
  30.     private String sex;
  32.     private double salary;
  34.     private Date empdate;
  36.     public Employee() {
  37.     }
  39.     public Employee(int eid, String ename, int age, String sex, double salary, Date empdate) {
  40.         this.eid = eid;
  41.         this.ename = ename;
  42.         this.age = age;
  43.         this.sex = sex;
  44.         this.salary = salary;
  45.         this.empdate = empdate;
  46.     }
  48.     public int getEid() {
  49.         return eid;
  50.     }
  52.     public void setEid(int eid) {
  53.         this.eid = eid;
  54.     }
  56.     public String getEname() {
  57.         return ename;
  58.     }
  60.     public void setEname(String ename) {
  61.         this.ename = ename;
  62.     }
  64.     public int getAge() {
  65.         return age;
  66.     }
  68.     public void setAge(int age) {
  69.         this.age = age;
  70.     }
  72.     public String getSex() {
  73.         return sex;
  74.     }
  76.     public void setSex(String sex) {
  77.         this.sex = sex;
  78.     }
  80.     public double getSalary() {
  81.         return salary;
  82.     }
  84.     public void setSalary(double salary) {
  85.         this.salary = salary;
  86.     }
  88.     public Date getEmpdate() {
  89.         return empdate;
  90.     }
  92.     public void setEmpdate(Date empdate) {
  93.         this.empdate = empdate;
  94.     }
  96.     @Override
  97.     public String toString() {
  98.         return "Employee{" +
  99.                 "eid=" + eid +
  100.                 ", ename='" + ename + '\'' +
  101.                 ", age=" + age +
  102.                 ", sex='" + sex + '\'' +
  103.                 ", salary=" + salary +
  104.                 ", empdate=" + empdate +
  105.                 '}';
  106.     }
  107. }

DBUtils完成 CRUD

QueryRunner核心类

构造方法

  • QueryRunner()
  • QueryRunner(DataSource ds) ,提供数据源（连接池），DBUtils底层自动维护连接connection

常用方法

  • update(Connection conn, String sql, Object… params) ，用来完成表数据的增加、删除、更新操

作

  • query(Connection conn, String sql, ResultSetHandler rsh, Object… params) ，用来完成表

数据的查询操作

QueryRunner的创建

  • 手动模式

    1. //手动方式 创建QueryRunner对象
    2. QueryRunner qr = new QueryRunner();

  • 自动模式

    1. //自动创建 传入数据库连接池对象
    2. QueryRunner qr2 = new QueryRunner(DruidUtils.getDataSource());

    自动模式需要传入连接池对象

    1. //获取连接池对象
    2. public static DataSource getDataSource(){ 
    3.   return dataSource;
    4. }

    QueryRunner实现增、删、改操作

    核心方法
    update(Connection conn, String sql, Object… params)

参数 说明
Connection conn 数据库连接对象, 自动模式创建QueryRun 可以不传 ,手动模式必须传递
String sql 占位符形式的SQL ,使用 ? 号占位符
Object… param Object类型的 可变参,用来设置占位符上的参数

步骤
1.创建QueryRunner(手动或自动)
2.占位符方式 编写SQL
3.设置占位符参数

4.执行

  1. package com.lagou.testDBUtils;
  3. import com.lagou.utils.DBCPUtils;
  4. import com.lagou.utils.DruidUtils;
  5. import org.apache.commons.dbutils.DbUtils;
  6. import org.apache.commons.dbutils.QueryRunner;
  7. import org.junit.Test;
  9. import java.sql.Connection;
  10. import java.sql.SQLException;
  12. /*
  13. *   使用QueryRunner对象 完成增删改
  14. *       update(Connection con,String sql,Object... param) 方法
  15. *
  16. * */
  17. public class DBUtilsDemo02 {
  19.     //插入操作
  20.     @Test
  21.     public void testInsert() throws SQLException {
  23.         //1.创建 QueryRunner 手动模式创建
  24.         QueryRunner qr = new QueryRunner();
  26.         //2.编写 占位符方式 SQL
  27.         String sql = "insert into employee values(?,?,?,?,?,?)";
  29.         //3.设置占位符的参数
  30.         Object[] param = {null,"张百万",20,"女",10000,"1990-12-26"};
  32.         //4.执行 update方法
  33.         Connection con = DruidUtils.getConnection();
  34.         int i = qr.update(con, sql, param);
  36.         //5.释放资源
  37.         DbUtils.closeQuietly(con);
  38.     }
  40.     //修改操作 修改姓名为 张百万的员工的工资为 15000
  41.     @Test
  42.     public void testUpdate() throws SQLException {
  44.         //1.创建 核心类 自动模式 需要传递 数据库连接池对象
  45.         QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
  47.         //2.编写SQl
  48.         String sql = "update employee set salary = ? where ename = ?";
  50.         //3.设置占位符的参数
  51.         Object[] param = {15000,"张百万"};
  53.         //4.执行修改操作 自动模式不需要传入connection对象
  54.         qr.update(sql,param);
  56.     }
  58.     //删除操作 删除id为1的 记录
  59.     @Test
  60.     public void testDelete() throws SQLException {
  62.         QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
  64.         String sql = "delete from employee where eid = ?";
  66.         //如果只有一个参数的话 不需要创建数组
  67.         qr.update(sql,1);
  68.     }
  69. }

添加

  1. //插入操作
  2.     @Test
  3.     public void testInsert() throws SQLException {
  5.         //1.创建 QueryRunner 手动模式创建
  6.         QueryRunner qr = new QueryRunner();
  8.         //2.编写 占位符方式 SQL
  9.         String sql = "insert into employee values(?,?,?,?,?,?)";
  11.         //3.设置占位符的参数
  12.         Object[] param = {null,"张百万",20,"女",10000,"1990-12-26"};
  14.         //4.执行 update方法
  15.         Connection con = DruidUtils.getConnection();
  16.         int i = qr.update(con, sql, param);
  18.         //5.释放资源
  19.         DbUtils.closeQuietly(con);
  20.     }

修改

  1. //修改操作 修改姓名为 张百万的员工的工资为 15000
  2.     @Test
  3.     public void testUpdate() throws SQLException {
  5.         //1.创建 核心类 自动模式 需要传递 数据库连接池对象
  6.         QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
  8.         //2.编写SQl
  9.         String sql = "update employee set salary = ? where ename = ?";
  11.         //3.设置占位符的参数
  12.         Object[] param = {15000,"张百万"};
  14.         //4.执行修改操作 自动模式不需要传入connection对象
  15.         qr.update(sql,param);
  17.     }

删除

  1. //删除操作 删除id为1的 记录
  2.     @Test
  3.     public void testDelete() throws SQLException {
  5.         QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
  7.         String sql = "delete from employee where eid = ?";
  9.         //如果只有一个参数的话 不需要创建数组
  10.         qr.update(sql,1);
  11.     }

QueryRunner实现查询操作

ResultSetHandler接口简介

ResultSetHandler可以对查询出来的ResultSet结果集进行处理，达到一些业务上的需求。

ResultSetHandler 结果集处理类

本例展示的是使用ResultSetHandler接口的几个常见实现类实现数据库的增删改查，可以大大减少代码量，优化 程序。
每一种实现类都代表了对查询结果集的一种处理方式

ResultSetHandler
实现类		 说明


ArrayHandler		 将结果集中的第一条记录封装到一个Object[]数组中，数组中的每一个元素就是这条记录中的每一个字段的值


ArrayListHandler		 将结果集中的每一条记录都封装到一个Object[]数组中，将这些数组在封装到List集 合中。
BeanHandler 将结果集中第一条记录封装到一个指定的javaBean中.


BeanListHandler		 将结果集中每一条记录封装到指定的javaBean中，再将这些javaBean在封装到List 集合中
ColumnListHandler 将结果集中指定的列的字段值，封装到一个List集合中


KeyedHandler		 将结果集中每一条记录封装到Map,在将这个map集合做为另一个
Map的value,另一个Map集合的key是指定的字段的值。


MapHandler		 将结果集中第一条记录封装到了Map集合中，key就是字段名称，
value就是字段值


MapListHandler		 将结果集中每一条记录封装到了Map集合中，key就是字段名称，
value就是字段值，在将这些Map封装到List集合中。
ScalarHandler 它是用于封装单个数据。例如 select count(*) from 表操作。

ResultSetHandler 常用实现类测试

  • QueryRunner的查询方法
  • query方法的返回值都是泛型,具体的返回值类型,会根据结果集的处理方式,发生变化
方法 说明
query(String sql, handler ,Object[] param) 自动模式创建QueryRunner, 执行查询<b
query(Connection con,String sql,handler,Object[] param) 手动模式创建QueryRunner, 执行查询

创建一个测试类, 对ResultSetHandler接口的几个常见实现类进行测试

  • 查询id为5的记录,封装到数组中
  • 查询所有数据,封装到List集合中
  • 查询id为5的记录,封装到指定JavaBean中
  • 查询薪资大于 3000 的所员工信息,封装到JavaBean中再封装到List集合中
  • 查询姓名是 张百万的员工信息,将结果封装到Map集合中
  • 查询所有员工的薪资总额


  1. package com.lagou.testDBUtils;
  3. import com.lagou.entity.Employee;
  4. import com.lagou.utils.DruidUtils;
  5. import org.apache.commons.dbutils.QueryRunner;
  6. import org.apache.commons.dbutils.handlers.*;
  7. import org.junit.Test;
  9. import java.sql.SQLException;
  10. import java.util.Arrays;
  11. import java.util.List;
  12. import java.util.Map;
  13. import java.util.Set;
  15. public class DBUtilsDemo03 {
  18.     /*
  19.     *   查询id为5的记录,封装到数组中
  20.     *   ArrayHandler 将结果集的第一条数据封装到数组中
  21.     * */
  22.     @Test
  23.     public void testFindById() throws SQLException {
  25.         //1.创建QueryRunner
  26.         QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
  28.         //2.编写SQL
  29.         String sql = "select * from employee where eid = ?";
  31.         //3.执行查询
  32.         Object[] query = qr.query(sql, new ArrayHandler(), 5);
  34.         //4.获取数据
  35.         System.out.println(Arrays.toString(query));
  36.     }
  38.     /**
  39.      * 查询所有数据,封装到List集合中
  40.      * ArrayListHandler可以将每条数据先封装到数组中, 再将数组封装到集合中
  41.      *
  42.      */
  43.     @Test
  44.     public void testFindAll() throws SQLException {
  46.         //1.创建QueryRunner
  47.         QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
  49.         //2.编写SQL
  50.         String sql = "select * from employee";
  52.         //3.执行查询
  53.         List<Object[]> query = qr.query(sql, new ArrayListHandler());
  55.         //4.遍历集合获取数据
  56.         for (Object[] objects : query) {
  57.             System.out.println(Arrays.toString(objects));
  58.         }
  59.     }
  61.     /**
  62.      * 查询id为3的记录,封装到指定JavaBean中
  63.      * BeanHandler 将结果集的第一条数据封装到 javaBean中
  64.      *
  65.      **/
  66.     @Test
  67.     public void testFindByIdJavaBean() throws SQLException {
  69.         QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
  71.         String sql = "select * from employee where eid = ?";
  73.         Employee employee = qr.query(sql, new BeanHandler<Employee>(Employee.class), 3);
  75.         System.out.println(employee);
  76.     }
  78.     /*
  79.     * 查询薪资大于 3000 的所员工信息,封装到JavaBean中再封装到List集合中
  80.     * BeanListHandler 将结果集的每一条和数据封装到 JavaBean中 再将JavaBean 放到list集合中
  81.     * */
  82.     @Test
  83.     public void testFindBySalary() throws SQLException {
  85.         QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
  87.         String sql = "select * from employee where salary > ?";
  89.         List<Employee> list = qr.query(sql, new BeanListHandler<Employee>(Employee.class), 3000);
  91.         for (Employee employee : list) {
  92.             System.out.println(employee);
  93.         }
  94.     }
  96.     /*
  97.     * 查询姓名是 张百万的员工信息,将结果封装到Map集合中
  98.     * MapHandler 将结果集的第一条记录封装到 Map<String,Object>中
  99.     * key对应的是 列名 value对应的是 列的值
  100.     * */
  101.     @Test
  102.     public void testFindByName() throws SQLException {
  104.         QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
  106.         String sql = "select * from employee where ename = ?";
  108.         Map<String, Object> map = qr.query(sql, new MapHandler(), "张百万");
  110.         Set<Map.Entry<String, Object>> entries = map.entrySet();
  112.         for (Map.Entry<String, Object> entry : entries) {
  113.             //打印结果
  114.             System.out.println(entry.getKey() +" = " +entry.getValue());
  115.         }
  116.     }
  118.     /*
  119.     *  查询所有员工的薪资总额
  120.     *  ScalarHandler 用于封装单个的数据
  121.     * */
  122.     @Test
  123.     public void testGetSum() throws SQLException {
  125.         QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
  127.         String sql = "select sum(salary) from employee";
  129.         Double sum = (Double)qr.query(sql, new ScalarHandler<>());
  131.         System.out.println("员工薪资总额: " + sum);
  132.     }
  134. }

  1. 查询id为5的记录,封装到数组中

    1. /*
    2.  *   查询id为5的记录,封装到数组中
    3.  *   ArrayHandler 将结果集的第一条数据封装到数组中
    4.  * */
    5.  @Test
    6.  public void testFindById() throws SQLException {
    8.      //1.创建QueryRunner
    9.      QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
    11.      //2.编写SQL
    12.      String sql = "select * from employee where eid = ?";
    14.      //3.执行查询
    15.      Object[] query = qr.query(sql, new ArrayHandler(), 5);
    17.      //4.获取数据
    18.      System.out.println(Arrays.toString(query));
    19.  }

  2. 查询所有数据,封装到List集合中

    1.  /**
    2.   * 查询所有数据,封装到List集合中
    3.   * ArrayListHandler可以将每条数据先封装到数组中, 再将数组封装到集合中
    4.   *
    5.   */
    6.  @Test
    7.  public void testFindAll() throws SQLException {
    9.      //1.创建QueryRunner
    10.      QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
    12.      //2.编写SQL
    13.      String sql = "select * from employee";
    15.      //3.执行查询
    16.      List<Object[]> query = qr.query(sql, new ArrayListHandler());
    18.      //4.遍历集合获取数据
    19.      for (Object[] objects : query) {
    20.          System.out.println(Arrays.toString(objects));
    21.      }
    22.  }

  3. 根据ID查询,封装到指定JavaBean中

    1.  /**
    2.   * 查询id为3的记录,封装到指定JavaBean中
    3.   * BeanHandler 将结果集的第一条数据封装到 javaBean中
    4.   *
    5.   **/
    6.  @Test
    7.  public void testFindByIdJavaBean() throws SQLException {
    9.      QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
    11.      String sql = "select * from employee where eid = ?";
    13.      Employee employee = qr.query(sql, new BeanHandler<Employee>(Employee.class), 3);
    15.      System.out.println(employee);
    16.  }

  4. 查询薪资大于 3000 的所员工信息,封装到JavaBean中再封装到List集合中

    1.  /*
    2.  * 查询薪资大于 3000 的所员工信息,封装到JavaBean中再封装到List集合中
    3.  * BeanListHandler 将结果集的每一条和数据封装到 JavaBean中 再将JavaBean 放到list集合中
    4.  * */
    5.  @Test
    6.  public void testFindBySalary() throws SQLException {
    8.      QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
    10.      String sql = "select * from employee where salary > ?";
    12.      List<Employee> list = qr.query(sql, new BeanListHandler<Employee>(Employee.class), 3000);
    14.      for (Employee employee : list) {
    15.          System.out.println(employee);
    16.      }
    17.  }

  5. 查询姓名是 张百万的员工信息,将结果封装到Map集合中

    1.  /*
    2.  * 查询姓名是 张百万的员工信息,将结果封装到Map集合中
    3.  * MapHandler 将结果集的第一条记录封装到 Map<String,Object>中
    4.  * key对应的是 列名 value对应的是 列的值
    5.  * */
    6.  @Test
    7.  public void testFindByName() throws SQLException {
    9.      QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
    11.      String sql = "select * from employee where ename = ?";
    13.      Map<String, Object> map = qr.query(sql, new MapHandler(), "张百万");
    15.      Set<Map.Entry<String, Object>> entries = map.entrySet();
    17.      for (Map.Entry<String, Object> entry : entries) {
    18.          //打印结果
    19.          System.out.println(entry.getKey() +" = " +entry.getValue());
    20.      }
    21.  }

  6. 查询所有员工的薪资总额

    1.  /*
    2.  *  查询所有员工的薪资总额
    3.  *  ScalarHandler 用于封装单个的数据
    4.  * */
    5.  @Test
    6.  public void testGetSum() throws SQLException {
    8.      QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());
    10.      String sql = "select sum(salary) from employee";
    12.      Double sum = (Double)qr.query(sql, new ScalarHandler<>());
    14.      System.out.println("员工薪资总额: " + sum);
    15.  }

    数据库批处理

    什么是批处理

    批处理(batch) 操作数据库

  • 批处理指的是一次操作中执行多条SQL语句，批处理相比于一次一次执行效率会提高很多。
  • 当向数据库中添加大量的数据时，需要用到批处理。

举例: 送货员的工作：

  • 未使用批处理的时候，送货员每次只能运送 一件货物给商家；
  • 使用批处理，则是送货员将所有要运送的货物, 都用车带到发放处派给客户。

    实现批处理

    Statement和PreparedStatement都支持批处理操作，这里我们介绍一下PreparedStatement的批处理方式：

  1. 要用到的方法 | 方法 | 说明 | | —- | —- | |

    void addBatch() | 将给定的 SQL 命令添加到此 Statement 对象的当前命令列表中。通过调用方法 executeBatch 可以批量执行此列表中的命令。 | |

    int[] executeBatch() | 每次提交一批命令到数据库中执行，如果所有的命令都成功执行了， 那么返回一个数组，这个数组是说明每条命令所影响的行数 |


  1. mysql 批处理是默认关闭的，所以需要加一个参数才打开mysql 数据库批处理，在url中添加
  1. rewriteBatchedStatements=true
  2. 例如: url=jdbc:mysql://127.0.0.1:3306/db5?characterEncoding=UTF-8&rewriteBatchedStatements=true

  1. 创建一张表

    1. CREATE TABLE testBatch (
    2. id INT PRIMARY KEY AUTO_INCREMENT,
    3. uname VARCHAR(50)
    4. );

  2. 测试向表中插入 1万条数据 ```java package com.lagou.testbatch;

import com.lagou.utils.DruidUtils;

import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.SQLException;

public class BatchInsert {

  1. //使用批处理 向表中添加 10000条数据
  2. public static void main(String[] args) throws SQLException {
  4.     //1.获取连接
  5.     Connection connection = DruidUtils.getConnection();
  7.     //2.获取预处理对象
  8.     PreparedStatement ps = connection.prepareStatement("insert into testBatch(uname) values(?)");
  10.     //3.执行批量插入操作
  11.     for (int i = 0; i < 10000 ; i++){
  12.         ps.setString(1,"小强" + i);
  14.         //将SQL添加到批处理列表
  15.         ps.addBatch();
  16.     }
  17.     //添加时间戳 测试执行效率
  18.     long start = System.currentTimeMillis();
  20.     //4.统一执行 批量插入操作
  21.     ps.executeBatch();
  23.     long end = System.currentTimeMillis();
  25.     System.out.println("插入10000条数据需要使用: " + (end - start) + " 毫秒!");
  26.     //5.关闭连接
  27.     DruidUtils.close(connection,ps);
  28. }

}

  1. <a name="OKfNq"></a>
  2. # MySql元数据
  4. <a name="M0ZGx"></a>
  5. ## 什么是元数据
  6. 除了表之外的数据都是元数据,可以分为三类
  8. - **查询结果信息： **UPDATE 或 DELETE语句 受影响的记录数。
  9. - **数据库和数据表的信息： **包含了数据库及数据表的结构信息。
  10. - **MySQL服务器信息： **包含了数据库服务器的当前状态，版本号等。
  11. <a name="k2dgi"></a>
  12. ## 常用命令
  14. -- 元数据相关的命令介绍
  16. -- 1.查看服务器当前状态
  18. -- 2.查看MySQl的版本信息
  20. -- 3.查询表中的详细信息
  22. -- 4.显示数据表的详细索引信息
  24. -- 5.列出所有数据库
  26. -- 6.显示当前数据库的所有表
  28. -- 7.获取当前的数据库名
  30. - select version(); 获取mysql服务器的版本信息
  32. ![](https://cdn.nlark.com/yuque/0/2021/jpeg/258783/1616295313356-cf262e60-aba0-482c-9710-34de46cb0414.jpeg#align=left&display=inline&height=72&margin=%5Bobject%20Object%5D&originHeight=72&originWidth=240&status=done&style=none&width=240)
  34. - show status; 查看服务器的状态信息
  36. ![](https://cdn.nlark.com/yuque/0/2021/jpeg/258783/1616295313857-824a2bc3-25f4-43ea-9948-8cb5c3b9c9c3.jpeg#align=left&display=inline&height=330&margin=%5Bobject%20Object%5D&originHeight=330&originWidth=1014&status=done&style=none&width=1014)
  38. - show columns from table_name; 显示表的字段信息等，和desc table_name一样
  40. ![](https://cdn.nlark.com/yuque/0/2021/jpeg/258783/1616295314362-c4513222-03fe-4218-80ea-f7471004d6b8.jpeg#align=left&display=inline&height=138&margin=%5Bobject%20Object%5D&originHeight=138&originWidth=1501&status=done&style=none&width=1501)
  42. - show index from table_name; 显示数据表的详细索引信息，包括PRIMARY KEY（主键）
  44. ![](https://cdn.nlark.com/yuque/0/2021/jpeg/258783/1616295314609-ff4ab2d4-e9fd-4e75-a5c0-ca1d02e5cccb.jpeg#align=left&display=inline&height=80&margin=%5Bobject%20Object%5D&originHeight=80&originWidth=1352&status=done&style=none&width=1352)
  46. - show databases:列出所有数据库
  47. - show tables : 显示当前数据库的所有表
  48. - select database(): 获取当前的数据库名
  50. <a name="o3zTe"></a>
  51. ## 使用JDBC 获取元数据
  52. 通过JDBC 也可以获取到元数据,比如数据库的相关信息,或者当我们使用程序查询一个不熟悉的表时, 我们可以通过获取元素据信息,了解表中有多少个字段,字段的名称 和 字段的类型.
  53. <a name="Rwx4V"></a>
  54. ### 常用类介绍
  55. JDBC中描述元数据的类
  57. | **元数据类** | **作用** |
  58. | --- | --- |
  59. | DatabaseMetaData | 描述数据库的元数据对象 |
  60. | ResultSetMetaData | 描述结果集的元数据对象 |
  63. 获取元数据对象的方法 : getMetaData ()
  65. - connection 连接对象, 调用 getMetaData () 方法,获取的是DatabaseMetaData 数据库元数据对象
  66. - PrepareStatement 预处理对象调用 getMetaData () , 获取的是ResultSetMetaData , 结果集元数据对象
  70. DatabaseMetaData的常用方法
  72. | **方法说明** |
  73. | --- |
  74. | getURL() : 获取数据库的URL |
  75. | getUserName(): 获取当前数据库的用户名 |
  76. | getDatabaseProductName(): 获取数据库的产品名称 |
  77. | getDatabaseProductVersion(): 获取数据的版本号 |
  78. | getDriverName(): 返回驱动程序的名称 |
  79. | isReadOnly(): 判断数据库是否只允许只读 true 代表只读 |
  82. ResultSetMetaData的常用方法
  84. | **方法说明** |
  85. | --- |
  86. | getColumnCount() : 当前结果集共有多少列 |
  87. | getColumnName(int i) : 获取指定列号的列名, 参数是整数 从1开始 |
  88. | getColumnTypeName(int i): 获取指定列号列的类型, 参数是整数 从1开始 |
  91. <a name="5k4e7"></a>
  92. ### 代码示例
  93. ```java
  94. package com.lagou.testmetadata;
  96. import com.lagou.utils.DruidUtils;
  97. import org.junit.Test;
  99. import java.sql.*;
  101. public class TestMetaData {
  103.     //1.获取数据库相关的元数据信息 使用DatabaseMetaData
  104.     @Test
  105.     public void testDataBaseMetaData() throws SQLException {
  107.         //1.获取数据库连接对象 connection
  108.         Connection connection = DruidUtils.getConnection();
  110.         //2.获取代表数据库的 元数据对象 DatabaseMetaData
  111.         DatabaseMetaData metaData = connection.getMetaData();
  113.         //3.获取数据库相关的元数据信息
  114.         String url = metaData.getURL();
  115.         System.out.println("数据库URL: " + url);
  117.         String userName = metaData.getUserName();
  118.         System.out.println("当前用户: " + userName );
  120.         String productName = metaData.getDatabaseProductName();
  121.         System.out.println("数据库产品名: " + productName);
  123.         String version = metaData.getDatabaseProductVersion();
  124.         System.out.println("数据库版本: " + version);
  126.         String driverName = metaData.getDriverName();
  127.         System.out.println("驱动名称: " + driverName);
  129.         //判断当前数据库是否只允许只读
  130.         boolean b = metaData.isReadOnly();  //如果是 true 就表示 只读
  131.         if(b){
  132.             System.out.println("当前数据库只允许读操作!");
  133.         }else{
  134.             System.out.println("不是只读数据库");
  135.         }
  137.         connection.close();
  138.     }
  140.    //获取结果集中的元数据信息
  141.     @Test
  142.     public void testResultSetMetaData() throws SQLException {
  144.         //1.获取连接
  145.         Connection con = DruidUtils.getConnection();
  147.         //2.获取预处理对象
  148.         PreparedStatement ps = con.prepareStatement("select * from employee");
  149.         ResultSet resultSet = ps.executeQuery();
  151.         //3.获取结果集元素据对象
  152.         ResultSetMetaData metaData = ps.getMetaData();
  154.         //1.获取当前结果集 共有多少列
  155.         int count = metaData.getColumnCount();
  156.         System.out.println("当前结果集中共有: " + count + " 列");
  158.         //2.获结果集中 列的名称 和 类型
  159.         for (int i = 1; i <=  count; i++) {
  160.             String columnName = metaData.getColumnName(i);
  161.             System.out.println("列名: "+ columnName);
  163.             String columnTypeName = metaData.getColumnTypeName(i);
  164.             System.out.println("类型: " +columnTypeName);
  165.         }
  167.         //释放资源
  168.         DruidUtils.close(con,ps,resultSet);
  169.     }
  170. }