2.1.6 连接池DBCP, C3P0, Druid, DBUtils工具类QueryRunner核心类, JavaBean, XXXHandle结果集处理类, 批处理, 元数据

-- 创建数据库
CREATEDATABASE db5 CHARACTER SET utf8;

-- 使用数据库
USE db5;

-- 创建员工表
CREATE TABLE employee (
    eid INT PRIMARY KEY AUTO_INCREMENT,
    ename VARCHAR (20), -- 员工姓名
    age INT , -- 员工年龄
    sex VARCHAR (6), -- 员工性别
    salary DOUBLE , -- 薪水
    empdate DATE -- 入职日期
);

-- 插入数据
INSERT INTO employee (eid, ename, age, sex, salary, empdate) 
VALUES(NULL,'李清照',22,'女',4000,'2018-11-12');

INSERT INTO employee (eid, ename, age, sex, salary, empdate) 
VALUES(NULL,'林黛玉',20,'女',5000,'2019-03-14');

INSERT INTO employee (eid, ename, age, sex, salary, empdate) 
VALUES(NULL,'杜甫',40,'男',6000,'2020-01-01');

INSERT INTO employee (eid, ename, age, sex, salary, empdate) 
VALUES(NULL,'李白',25,'男',3000,'2017-10-01');

1.5 DBCP连接池的使用

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

1.5.1 创建项目导入 jar包

1）将这两个 jar包添加到 myJar文件夹中

2）添加myJar库到项目的依赖中

1.5.2 代码: 编写DBCP工具类

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

Java中提供了一个连接池的规则接口： DataSource , 它是java中提供的连接池

在DBCP包中提供了DataSource接口的实现类，我们要用的具体的连接池 BasicDataSource 类

package com.lg.utils;

import org.apache.commons.dbcp.BasicDataSource;

import javax.naming.ldap.UnsolicitedNotification;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * @author CH
 * @date 2020/10/28 17:38
 */
public class DBCPUtils {

    //1. 定义常量, 保存数据库连接的相关信息
    public static final String DRIVERNAME = "com.mysql.jdbc.Driver";
    public static final String URL = "jdbc:mysql://localhost:3306/db5?characterEncoding=UTF-8";
    public static final String USERNAME = "root";
    public static final String PASSWORD = "123456";

    //2. 创建连接池对象(由DBCP提供的实现类)
    public static BasicDataSource dataSource = new BasicDataSource();

    //3. 使用静态代码块进行配置
    static {
        dataSource.setDriverClassName(DRIVERNAME);
        dataSource.setUrl(URL);
        dataSource.setUsername(USERNAME);
        dataSource.setPassword(PASSWORD);
    }

    //4. 获取连接的方法
    public static Connection getConnection() throws SQLException {

        //从连接池中获取连接
        Connection connection = dataSource.getConnection();
        return connection;
    }

    //5. 释放资源的方法
    public static void close(Connection connection, Statement statement) {

        if (null != connection && null != statement) {
            try {
                statement.close();
                //归还连接给连接池
                connection.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }

    //5. 释放资源的方法
    public static void close(Connection connection, Statement statement, ResultSet resultSet) {

        if (null != connection && null != statement && null != resultSet) {
            try {
                resultSet.close();
                statement.close();
                //归还连接给连接池
                connection.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}

1.5.3 测试DBCP工具类

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

package com.lg.testpool;

import com.lg.utils.DBCPUtils;

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

/**
 * @author CH
 * @date 2020/10/28 20:07
 */
public class TestDBCP {

    /*
    *   测试DBCP连接池
    * */
    public static void main(String[] args) throws SQLException {

        //1. 从DBCP连接池中拿到连接
        Connection connection = DBCPUtils.getConnection();

        //2. 获取Statement对象
        Statement statement = connection.createStatement();

        //3. 查询所有员工的姓名
        String sql = "select ename from employee";
        ResultSet resultSet = statement.executeQuery(sql);

        //4. 处理结果集
        while(resultSet.next()) {
            String ename = resultSet.getString("ename");
            System.out.println(ename);
        }

        //5. 释放资源
        DBCPUtils.close(connection,statement,resultSet);
    }
}

1.5.4 常见配置项

1.6 C3P0连接池

C3P0是一个开源的JDBC连接池,支持JDBC3规范和JDBC2的标准扩展。

目前使用它的开源项目有Hibernate、Spring等。

1.6.1 导入jar包及配置文件

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

2) 导入配置文件 c3p0-config.xml

c3p0-config.xml 文件名不可更改
直接放到src下,也可以放到到资源文件夹中

<c3p0-config>
<!--默认配置-->
<default-config>
<property name="driverClass">com.mysql.jdbc.Driver</property>
<property name="jdbcUrl">jdbc:mysql://localhost:3306/db5?characterEncoding=UTF-8</property>
<property name="user">root</property>
<property name="password">123456</property>
<!-- initialPoolSize：初始化时获取三个连接，
取值应在minPoolSize与maxPoolSize之间。 -->
<property name="initialPoolSize">3</property>
<!-- maxIdleTime：最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。-->
<property name="maxIdleTime">60</property>
<!-- maxPoolSize：连接池中保留的最大连接数 -->
<property name="maxPoolSize">100</property>
<!-- minPoolSize: 连接池中保留的最小连接数 -->
<property name="minPoolSize">10</property>
</default-config>
<!--配置连接池mysql-->
<named-config name="mysql">
<property name="driverClass">com.mysql.jdbc.Driver</property>
<property name="jdbcUrl">jdbc:mysql://localhost:3306/db5</property>
<property name="user">root</property>
<property name="password">123456</property>
<property name="initialPoolSize">10</property>
<property name="maxIdleTime">30</property>
<property name="maxPoolSize">100</property>
<property name="minPoolSize">10</property>
</named-config>
<!--配置连接池2,可以配置多个-->
</c3p0-config>

3) 在项目下创建一个resource文件夹(专门存放资源文件)

4) 选择文件夹,右键将resource文件夹指定为资源文件夹

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

1.6.2 代码: 编写C3P0工具类

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

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

package com.lg.utils;

import com.mchange.v2.c3p0.ComboPooledDataSource;

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

/**
 * @author CH
 * @date 2020/10/29 14:19
 */
public class C3P0Utils {

    //1. 创建连接池对象, C3P0对DataSource接口的实现类
    // 空参构造, 使用的配置是配置文件中的默认配置
    //public static ComboPooledDataSource dataSource = new ComboPooledDataSource();

    // 使用指定的配置
    public static ComboPooledDataSource dataSource = new ComboPooledDataSource("mysql");

    public static Connection getConnection() throws SQLException {

        return dataSource.getConnection();
    }

    //释放资源
    public static void close(Connection connection, Statement statement) {

        if(null != connection && null != statement) {
            try {
                statement.close();
                connection.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }

    public static void close(Connection connection, Statement statement, ResultSet resultSet) {
        if (null != connection && null != statement && null != resultSet) {
            try {
                resultSet.close();
                statement.close();
                //归还连接给连接池
                connection.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}

1.6.3 代码: 测试C3P0工具类

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

package com.lg.testpool;

import com.lg.utils.C3P0Utils;

import java.sql.*;

/**
 * @author CH
 * @date 2020/10/29 15:01
 */
public class TestC3P0 {

    //需求 查询姓名为李白的记录
    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement ps = null;
        ResultSet resultSet = null;

        try {
            //1. 获取连接
            connection = C3P0Utils.getConnection();

            //2. 获取语句执行对象
            ps = connection.prepareStatement("select * from employee where ename = ?");

            //3. 设置占位符值
            ps.setString(1, "李白");

            resultSet = ps.executeQuery();

            //4. 处理结果集
            while (resultSet.next()) {
                int eid = resultSet.getInt("eid");
                String ename = resultSet.getString("ename");
                int age = resultSet.getInt("age");
                String sex = resultSet.getString("sex");
                double salary = resultSet.getDouble("salary");
                Date emdate = resultSet.getDate("empdate");

                System.out.println(eid + ", " + ename + ", " + age + ", " + sex + ", " + salary + ", " + emdate);
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            //5. 释放资源
            C3P0Utils.close(connection, ps, resultSet);
        }
    }
}

1.6.4 C3P0常见配置

1.7 Druid连接池

Druid（德鲁伊）是阿里巴巴开发的号称为监控而生的数据库连接池，Druid是目前最好的数据库连接池。

在功能、性能、扩展性方面，都超过其他数据库连接池，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况。

1.7.1 导入jar包及配置文件

1) 导入 jar包

2) 导入配置文件

properties形式, 可以叫任意名称，可以放在任意目录下, 统一放到 resources资源目录

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/db5?characterEncoding=UTF-8
username=root
password=123456
initialSize=5
maxActive=10
maxWait=3000

1.7.2 代码: 编写Druid工具类

获取数据库连接池对象

通过工厂来来获取 DruidDataSourceFactory类的createDataSource方法
createDataSource(Properties p) 方法参数可以是一个属性集对象

package com.lg.utils;

import com.alibaba.druid.pool.DruidDataSourceFactory;

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

/**
 * @author CH
 * @date 2020/10/29 15:22
 */
public class DruidUtils {

    //1. 定义一个成员变量
    public static DataSource dataSource;

    //2. 静态代码块
    static {
        try {
            //3. 创建属性集对象
            Properties p = new Properties();

            //4. 加载配置文件 Druid连接池 不能主动加载配置文件, 需要指定文件
            InputStream inputStream = DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties");

            //5. 使用Properties对象的load方法 从字节流中读取配置信息
            p.load(inputStream);

            //6. 通过工厂类, 获取连接池对象
            dataSource = DruidDataSourceFactory.createDataSource(p);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //7. 获取连接的方法
    public static Connection getConnection() {

        try {

            return dataSource.getConnection();

        } catch (SQLException throwables) {
            throwables.printStackTrace();
            return null;
        }
    }

    // 连接testDBUtils方面知识点
    // 获取Druid连接池对象的方法
    public static DataSource getDataSource() {

        return dataSource;
    }



    //8. 释放资源的方法
    public static void close(Connection connection, Statement statement) {

        if (null != connection && null != statement) {
            try {
                statement.close();
                //归还连接给连接池
                connection.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
    public static void close(Connection connection, Statement statement, ResultSet resultSet) {

        if (null != connection && null != statement && null != resultSet) {
            try {
                resultSet.close();
                statement.close();
                //归还连接给连接池
                connection.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}

1.7.3 代码: 测试Druid工具类

需求: 查询薪资在3000 - 5000元之间的员工姓名

package com.lg.testpool;

import com.lg.utils.DruidUtils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;

/**
 * @author CH
 * @date 2020/10/29 16:34
 */
public class TestDruid {

    // 需求  查询薪资在3000到5000之间员工的姓名
    public static void main(String[] args) throws Exception {

        //1. 获取连接
        Connection connection = DruidUtils.getConnection();

        //2. 获取Statement 对象
        Statement statement = connection.createStatement();

        //3. 执行查询
        ResultSet resultSet = statement.executeQuery("select ename from employee where salary between 3000 and 5000");

        //4. 处理结果集
        while(resultSet.next()) {
            String ename = resultSet.getString("ename");
            System.out.println( ename);
        }

        //5. 关闭资源
        DruidUtils.close(connection,statement,resultSet);

    }

}

2.DBUtils工具类

2.1 DBUtils简介

使用JDBC冗余代码太多,为简化开发使用 DbUtils ,

Commons DbUtils是Apache组织提供的一个对JDBC进行简单封装的开源工具类库，使用它能够简化JDBC应用程序的开发，同

时也不会影响程序的性能。

使用方式:
DBUtils就是JDBC的简化开发工具包。需要项目导入 commons-dbutils-1.6.jar

2.1.1 Dbutils核心功能介绍

QueryRunner 中提供对sql语句操作的API.
ResultSetHandler接口，用于定义select操作后，怎样封装结果集.
DbUtils类,他就是一个工具类,定义了关闭资源与事务处理相关方法.

2.2 案例相关知识

2.2.1 表和类之间的关系

整个表可以看做是一个类
表中的一行记录,对应一个类的实例(对象)
表中的一列,对应类中的一个成员属性

2.2.2 JavaBean组件

1) JavaBean 就是一个类, 开发中通常用于封装数据,有以下特点 (一般一个javabean的类对应一张表)

需要实现序列化接口, Serializable (暂时可以省略)
提供私有字段: private 类型变量名;
提供 getter 和 setter
提供空参构造

2) 创建Employee类和数据库的employee表对应

创建一个 entity包,专门用来存放 JavaBean类

代码: Employee类JavaBean的编写

package com.lg.entity;

import java.io.Serializable;
import java.util.Date;

/**
 * @author CH
 * @date 2020/10/29 17:37
 */
/*
     JavaBean类
   用来存储数据, 成员变量私有, 提供 getter, setter, 空参构造, 实现序列化接口

   Employee类 就是对应了 数据库中的 employee表
        `eid` int(11) NOT NULL AUTO_INCREMENT,
        `ename` varchar(20) DEFAULT NULL,
        `age` int(11) DEFAULT NULL,
        `sex` varchar(6) DEFAULT NULL,
        `salary` double DEFAULT NULL,
        `empdate` date DEFAULT NULL,
 */

public class Employee implements Serializable {

    // 成员变量的名称, 和表中的列名要一样
    private int eid;
    private String ename;
    private int age;
    private String sex;
    private double salary;
    private Date empdate;

    // 构造, getter setter 省略

    @Override
    public String toString() {
        return "Employee{" +
                "eid=" + eid +
                ", ename='" + ename + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                ", salary=" + salary +
                ", empdate=" + empdate +
                '}';
    }
}

2.3 DBUtils完成 CRUD

2.3.1 QueryRunner核心类

构造方法

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

常用方法

update(Connection con, String sql, Object... params) ，用来完成表数据的增加、删除、更新操作
query(Connection con, String sql, ResultSetHandler<T> rsh, Object... params) ，用来完成表数据的查询操作

2.3.2 QueryRunner的创建

手动模式

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

自动模式

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

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

//获取连接池对象
public static DataSource getDataSource(){
    return dataSource;
}

2.3.3 QueryRunner实现增、删、改操作

核心方法

update(Connection conn, String sql, Object... params)

步骤

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

代码: 使用QueryRunner对象完成增删改, 占位符?

package com.lg.testDBUtils;

import com.lg.utils.DruidUtils;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.junit.Test;

import java.io.ObjectInputStream;
import java.sql.Connection;
import java.sql.SQLException;

/**
 * @author CH
 * @date 2020/10/29 17:51
 */

/*
    使用QueryRunner对象  完成增删改
        update(Connection con, String sql, Object... param)方法
* */
public class DBUtilsDemo02 {

    @Test
    public void testInsert() throws SQLException {

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

        //2. 编写, 占位符方式 sql
        String sql = "insert into employee values(?,?,?,?,?,?)";

        //3. 设置占位符的参数
        Object[] param = {null, "张百万", 20, "女", 10000, "1990-12-26"};

        //4. 执行update方法
        Connection connection = DruidUtils.getConnection();
        int i = qr.update(connection, sql, param);

        //5. 释放资源
        DbUtils.closeQuietly(connection);

    }

    // 修改操作, 修改姓名为张百万的员工的薪资为15000
    @Test
    public void testUpdate() throws SQLException {

        //1. 创建核心类 自动模式 需要传递 数据库连接池对象
        QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());

        //2. 编写SQL
        String sql = "update employee set salary = ? where ename = ?";

        //3. 设置占位符的参数
        Object[] param = {15000, "张百万"};

        //4. 执行SQL修改操作  自动模式, 不需要传入connection对象, 也不需要进行关闭操作
        int i = qr.update(sql, param);

    }

    //删除操作, 将eid为1 的数据删除
    @Test
    public void testDelete() throws SQLException {

        QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());

        String sql = "delete from employee where eid = ?";

        // 如果只有一个参数的话, 不需要创建数组
        int i = qr.update(sql, 1);

        System.out.println(i);
    }
}

2.3.4 QueryRunner实现查询操作

ResultSetHandler接口简介

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

ResultSetHandler 结果集处理类

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

ResultSetHandler 常用实现类测试

query方法的返回值都是泛型,具体的返回值类型,会根据结果集的处理方式,发生变化

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

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

代码: ResultSetHandler 常用实现类测试 ArrayListHandler, JavaBeanHandler, BeanListHandler, MapHandler, ScalarHandler

package com.lg.testDBUtils;

import com.lg.entity.Employee;
import com.lg.utils.DruidUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.*;
import org.junit.Test;

import java.sql.SQLException;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @author CH
 * @date 2020/10/29 18:43
 */
public class DBUtilsDemo03 {

    /*
    *   查询id为5的记录, 封装到数组中
    *   ArrayHandler 将结果集的第一条数据封装到数组中
    *
    * */

    @Test
    public void testFindById() throws SQLException {

        //1. 创建QueryRunner
        QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());

        //2. 编写SQL
        String sql = "select * from employee where eid = ?";

        //3. 执行查询
        Object[] query = qr.query(sql, new ArrayHandler(), 5);

        //4. 获取数据
        System.out.println(Arrays.toString(query));
    }

    /*
    *   查询所有数据, 封装到List集合中
    *   ArrayListHandler 可以将每条数据, 先封装到数组中, 再将数组封装到集合中
    *
    * */

    @Test
    public void testFindAll() throws SQLException {

        //1. 创建QueryRunner
        QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());

        //2. 编写SQL
        String sql = "select * from employee";

        //3. 查询结果放入集合中
        List<Object[]> queryList = qr.query(sql, new ArrayListHandler());

        //4. 遍历打印
        for (Object[] ot : queryList) {
            System.out.println(Arrays.toString(ot));
        }
    }

    /*
    *   查询id为5的记录, 封装到指定Javabean中
    *   BeanHandler 将结果集的第一条数据封装到JavaBean中
    *
    * */

    @Test
    public void testFindByIdJavaBean() throws SQLException {

        QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());

        String sql = "select * from employee where eid = ?";
        
        // 创建BeanHandler需要传递一个参数,参数就是JavaBean类的Class文件对象
        // Employee.class 通过反射去创建对象,将结果集封装到对象中并返回
        Employee e1 = qr.query(sql, new BeanHandler<Employee>(Employee.class), 5);

        System.out.println(e1);
    }

    /*
    *   查询薪资大于3000的所有员工信息,封装到JavaBean中, 再封装到集合List中
    *   BeanListHandler  将结果集的每条数据封装到JavaBean中, 再放入集合中
    *
    * */

    @Test
    public void testFindBySalary () throws SQLException {

        QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());

        String sql = "select * from employee where salary > ?";

        List<Employee> emList = qr.query(sql, new BeanListHandler<Employee>(Employee.class), 3000);

        for (Employee et : emList) {
            System.out.println(et);
        }
    }

    /*
    *   查询姓名是 张百万的员工信息,将结果封装到Map集合中
    *   MapHandler 将结果集的第一条记录 封装到 Map<String, Object> 中
    *                                        key是列名, value是值
    * */

    @Test
    public void testFindByName() throws SQLException {

        QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());

        String sql = "select * from employee where ename = ?";

        // 下面是个集合, 集合中的key是列名, 例如ename ; 对应的value是列的值, 例如 张百万
        Map<String, Object> m1 = qr.query(sql, new MapHandler(), "张百万");

        // 将Map集合中的 key-value对 依次转换为Set集合中的一个元素
        Set<Map.Entry<String, Object>> entries = m1.entrySet();

        for (Map.Entry<String, Object> entry : entries) {
            System.out.println(entry.getKey() + " = " + entry.getValue());
        }

    }

    /*
    *   查询所有员工的薪资总额
    *   ScalarHandler
    *
    * */

    @Test
    public void testGetSum() throws SQLException {

        QueryRunner qr = new QueryRunner(DruidUtils.getDataSource());

        String sql = "select sum(salary) from employee";

        // 下面不写泛型的话,会返回Object类型的
        Double sum = (Double)qr.query(sql, new ScalarHandler<>());

        System.out.println("员工薪资总额为: " + sum);
    }
}

3.数据库批处理

3.1 什么是批处理

批处理(batch) 操作数据库

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

举例: 送货员的工作：

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

3.2 实现PreparedStatement的批处理

Statement和PreparedStatement都支持批处理操作，此处介绍PreparedStatement的批处理方式：

1) 要用到的方法

2) mysql 批处理是默认关闭的，所以需要加一个参数才打开mysql 数据库批处理，在url中添加

rewriteBatchedStatements=true
例如: url=jdbc:mysql://127.0.0.1:3306/db5?characterEncoding=UTF-8&rewriteBatchedStatements=true

3) 创建一张表

CREATE TABLE testBatch (
id INT PRIMARY KEY AUTO_INCREMENT,
uname VARCHAR(50)
)

4) 测试向表中插入 1万条数据

代码: 批处理向表中插入 1万条数据

package com.lg.testbatch;

import com.lg.utils.DruidUtils;

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


/**
 * @author CH
 * @date 2020/10/29 20:58
 */
public class BatchInsert {

    //使用批处理, 向表中添加 一万条数据
    public static void main(String[] args) throws SQLException {

        //1. 获取连接
        Connection connection = DruidUtils.getConnection();

        //2. 获取预处理对象
        PreparedStatement ps = connection.prepareStatement("insert into testBatch(uname) values(?)");

        //3. 执行批量插入操作
        for (int i = 0; i < 10000; i++) {
            ps.setString(1, "小强" + i);

            //将SQL添加到批处理列表
            ps.addBatch();
        }
        long l1 = System.currentTimeMillis();

        //4. 统一执行批量插入操作
        ps.executeBatch();

        long l2 = System.currentTimeMillis();

        System.out.println("插入10000条数据, 需要时间:" + ( l2 - l1) + "ms") ;

        //5. 关闭连接
        DruidUtils.close(connection,ps);

    }
}

4.MySql元数据

4.1 什么是元数据

除了表之外的数据都是元数据,可以分为三类

查询结果信息： UPDATE 或 DELETE语句受影响的记录数。

数据库和数据表的信息：包含了数据库及数据表的结构信息。

MySQL服务器信息：包含了数据库服务器的当前状态，版本号等。

4.2 常用命令

-- 元数据相关的命令介绍

-- 1.查看服务器当前状态
SHOW STATUS;

-- 2.查看MySQl的版本信息
SELECT VERSION();

-- 3.查询表中的详细信息
SHOW COLUMNS FROM employee;

-- 4.显示数据表的详细索引信息
SHOW INDEX FROM testBatch;

-- 5.列出所有数据库
SHOW DATABASES;

-- 6.显示当前数据库的所有表
SHOW TABLES;

-- 7.获取当前的数据库名
SELECT DATABASE();

select version();

获取mysql服务器的版本信息

show status;

查看服务器的状态信息

show columns from table_name;

显示表的字段信息等，和desc table_name一样

show index from table_name;

显示数据表的详细索引信息，包括PRIMARY KEY（主键）

show databases:列出所有数据库
show tables : 显示当前数据库的所有表
select database(): 获取当前的数据库名

4.3 使用JDBC 获取元数据

通过JDBC 也可以获取到元数据,比如数据库的相关信息,或者当我们使用程序查询一个不熟悉的表时, 我们可以通过
获取元素据信息,了解表中有多少个字段,字段的名称和字段的类型.

4.3.1 常用类介绍

JDBC中描述元数据的类

获取元数据对象的方法 : getMetaData ()

connection 连接对象, 调用 getMetaData () 方法,获取的是DatabaseMetaData 数据库元数据对象
PrepareStatement 预处理对象调用 getMetaData () , 获取的是ResultSetMetaData , 结果集元数据对象

DatabaseMetaData的常用方法

ResultSetMetaData的常用方法

4.3.2 代码: 使用JDBC 获取元数据

package com.lg.testmetaData;

import com.lg.utils.DruidUtils;
import org.junit.Test;

import java.sql.*;

/**
 * @author CH
 * @date 2020/10/30 14:07
 */
public class TestMetaData {

    //1. 获取数据库相关的元数据信息, 使用DataBaseMetaData
    @Test
    public void testDataBaseMetaData () throws SQLException {

        //1. 获取数据库连接对象 connection
        Connection connection = DruidUtils.getConnection();

        //2. 获取代表数据库的 元数据对象 DatabaseMetaData
        DatabaseMetaData metaData = connection.getMetaData();

        //3. 获取数据相关的元数据信息
        String url = metaData.getURL();
        System.out.println("数据库的url是: " + url);

        String userName = metaData.getUserName();
        System.out.println("当前用户是: " + userName);

        String databaseProductName = metaData.getDatabaseProductName();
        System.out.println("数据库产品名: " + databaseProductName);

        String version = metaData.getDatabaseProductVersion();
        System.out.println("数据库版本是: " + version);

        String driverName = metaData.getDriverName();
        System.out.println("驱动名称: " + driverName);

        //判断当前数据库是否只允许只读
        boolean b = metaData.isReadOnly();  // 如果是 true 就表示只读
        if(b) {
            System.out.println("是只读!");
        } else {
            System.out.println("不是只读!");
        }

        connection.close();
    }

    //获取结果集中的元数据信息
    @Test
    public void testResultSetMetaData() throws SQLException {

        //1. 获取连接
        Connection connection = DruidUtils.getConnection();

        //2. 获取预处理对象
        PreparedStatement ps = connection.prepareStatement("select * from employee");
        ResultSet resultSet = ps.executeQuery();

        //3. 获取结果集元数据对象
        ResultSetMetaData metaData = ps.getMetaData();

        //3.1 获取当前结果集公有多少列
        int columnCount = metaData.getColumnCount();
        System.out.println("当前结果集中有列数: " + columnCount);

        //3.2 获取结果集中列的名称和类型
        for (int i = 1; i <= columnCount; i++) {
            String columnName = metaData.getColumnName(i);
            System.out.println("列名: " + columnName);

            String columnTypeName = metaData.getColumnTypeName(i);
            System.out.println("类型: " + columnTypeName);
        }

        DruidUtils.close(connection,ps,resultSet);
    }
}

CH_ENN

关注

3
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
2.1.6 连接池DBCP, C3P0, Druid, DBUtils工具类QueryRunner核心类, JavaBean, XXXHandle结果集处理类, 批处理, 元数据

目录1.数据库连接池1.1 连接池介绍1.2 JDBC方式与连接池方式特点1.3 如何使用数据库连接池1.4 数据准备1.5 DBCP连接池的使用1.5.1 创建项目导入 jar包1.5.2 代码: 编写DBCP工具类1.5.3 测试DBCP工具类1.5.4 常见配置项1.6 C3P0连接池1.6.1 导入jar包及配置文件1.6.2 代码: 编写C3P0工具类1.6.3 代码: 测试C3P0工具类1.6.4 C3P0常见配置1.7 ..
复制链接

扫一扫