41-数据库连接池与DBUtils

数据库连接池与DBUtils 实际开发中"获得连接"或"释放资源"是非常消耗系统资源的两个过程，为了解决此类性能问题 通常情况我们采用连接池技术，来共享连接Connection 这样我们就不需要每次都创建连接、释放连接了，这些操作都交给了连接池 用池来管理Connection，这样可以重复使用Connection 当使用完Connection后，调用Connection的close()方法也不会真的关闭Connection，而是把Connection"归还"给池

Java为数据库连接池提供了公共的接口：javax.sql.DataSource，各个厂商需要让自己的连接池实现这个接口 这样应用程序可以方便的切换不同厂商的连接池，常见的连接池有DBCP连接池，C3P0连接池，Druid连接池等等 DBCP也是一个开源的连接池，是Apache成员之一（一个组织，开源免费），在企业开发中也比较常见，tomcat内置的连接池

上面是需要的包 在项目里iml文件是写的配置文件，即你设置的什么，如仓库jar包的地方 连接数据库表的工具类，采用DBCP连接池的方式来完成 Java中提供了一个连接池的规则接口：DataSource，它是java中提供的连接池 在DBCP包中提供了DataSource接口的实现类，我们要用的具体的连接池BasicDataSource类

package com.lagou.utils;

import org.apache.commons.dbcp.BasicDataSource;

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

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);
        dataSource.setMaxActive(20);
        //将参数用在这里，保持连接，而不需要一个一个创建连接
        //可以直接从这个连接池里获得，关闭也变成了归还，而不是销毁，因为实际上con.close()是使用该连接池的方法
        //而该连接池就不是关闭，而是归还
    }

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

        //从连接池中获取连接
        Connection connection = dataSource.getConnection(); //不用连接池的话，这里就需要使用上面三个参数
        return connection;
    }

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

        if(con != null && statement != null){
            try {
                statement.close();
                //归还连接
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }

    public static void close(Connection con, Statement statement, ResultSet resultSet){

        if(con != null && statement != null && resultSet != null){
            try {
                resultSet.close();
                statement.close();
                //归还连接
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }

}

package com.lagou.testpool;

import com.lagou.utils.DBCPUtils;

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

public class TestDBCP {

    
    public static void main(String[] args) throws SQLException {

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

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

        //3.查询所有员工的姓名
        String sql = "select ename from employee";
        ResultSet resultSet = statement.executeQuery(sql);
        //不可以用executeUpdate来传入查询的语句，否则报错
        //不可以用executeQuery来传入不是查询的语句，否则报错

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

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

}

在迭代器中删除元素，实际上是删除当前所在位置的值，而不是下标所在位置 即next()方法在remove()方法前面时，不会删除他后移的值，而是当前位置的值 DBCP的配置项

//DBCP配置项默认值
protected int maxActive = 8; //连接的最大数量
protected int maxIdle = 8; //最大有多少个没使用
protected int minIdle = 0; //最小有多少个没使用
protected int initialSize = 0; //开始的连接数
//上述，只要没达到条件，就会自动创建连接来满足条件，如最小空闲连接数为10
//当使用连接时，只剩下5个空闲连接的话，会创建5个连接

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

上面是需要的包 导入配置文件c3p0-config.xml c3p0-config.xml文件名不可更改，应为C3P0底层指定了该名字的配置文件 若改变名字，那么就找不到配置文件了，即有可能会报错，或者阻塞等等（具体看底层的操作，运行时看也可以） 直接放到src 必须在src下，不可以放到src下的目录里，底层有指定的路劲 即项目路径下，记住是class文件的项目路径（没有src和其他特定的文件夹），而不是java的项目路径下 也可以放到到资源文件夹（编译后路径与src一样）中 对于我们的代码，实际运行的是class文件之间的操作，那么配置文件也是class进行操作的 那么对于所有代码的编译或者配置文件，都是放在idea中的out文件夹下的production目录的，该目录就存放了你的项目

可以发现，在idea里面，class存放的路径里没有src和resources文件夹，因为他们是特定的文件夹，即他们的内容就放在项目下面 可以看到，resources的内容与src的内容在同一路径 所以C3P0可以找到资源文件下的配置文件，也就是可以找到src目录下的配置文件 c3p0-config.xml---------------------------------------

  
  
      
	
		 
        3
        
		
		
        60  
		
		
        100  
		
        10  
		
      
  
   

    
        com.mysql.jdbc.Driver
        jdbc:mysql://localhost:3306/db5?characterEncoding=UTF-8
        root
        123456
        10
        30
        100
        10
    
    

Mark Directory as：将目录标记为 Sources Root：通过这个类指定一个文件夹，你告诉IntelliJ IDEA 这个文件夹及其子文件夹中包含的源代码，可以编译为构建过程的一部分 Test Sources Root：这些根类似于源根，但用于用于测试的代码（例如用于单元测试） 测试源文件夹允许您将与测试相关的代码与生产代码分开 通常，源和测试源的编译结果被放置在不同的文件夹中 Resources Root：用于应用程序中的资源文件（图像、各种配置XML和属性文件等），编译后路径与src实际一样 Test Resources Root：（或测试资源文件夹，只有在java模块）是资源文件与您的测试源有关 在所有其他方面，这些文件夹类似于资源文件夹 Excluded：将文件标记为Excluded目录后，idea就不会为该文件创建索引，全局搜索也不会搜里面的内容 编辑代码不会智能提示，相当于代码废弃场

只所以有C3P0是因为DBCP在连接信息需要改变时，需要修改代码，但由于开闭设计原则，对扩展开放对修改关闭 基本上是不可以修改代码的，若当你写上多个DBCP连接池时，又要全部改变，非常麻烦（一个一个的改变） 但可以修改扩展的，如配置文件 所以就出现了C3P0，他的连接信息在配置文件里，所以只要改变配置文件，就可以了，若当你写上多个C3P0连接池时 又要全部改变，只要修改配置文件就可以了，这样就满足了所有的C3P0连接池

package com.lagou.utils;

import com.mchange.v2.c3p0.ComboPooledDataSource;

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

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 con, Statement statement){


        if(con != null && statement != null){
            try {
                statement.close();
                //归还连接
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }

    public static void close(Connection con, Statement statement, ResultSet resultSet){

        if(con != null && statement != null && resultSet != null){
            try {
                resultSet.close();
                statement.close();
                //归还连接
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }
}

package com.lagou.testpool;

import com.lagou.utils.C3P0Utils;

import java.sql.*;

public class TestC3P0 {

    //需求 查询姓名为李白的 记录
    public static void main(String[] args) throws SQLException {

        //1.获取连接
        Connection con = C3P0Utils.getConnection();

        //2.获取预处理对象
        String sql = "select * from employee where ename = ?";
        PreparedStatement ps = con.prepareStatement(sql);

        //3.设置占位符的值
        ps.setString(1,"李白");
        ResultSet 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 date = resultSet.getDate("empdate");

            System.out.println(eid +" " + ename + " " + age +" " + sex +" " + salary +" " +date);
        }

        //5.释放资源
        C3P0Utils.close(con,ps,resultSet);
    }

}

由于C3P0读取的是配置文件，那么在运行时，通常会有日志产生（读取配置文件的基本都有日志），将操作的信息打印出来

当你初始化的连接数小于最小连接数时，会给你个警告，然后创建连接满足条件 最后出结果，由于默认的配置，没有配置连接信息（必须项没有），那么在使用默认配置时，连接信息记得写上，否则会没结果 数据库都找不到了 由于C3P0灵活性不高，即路径基本固定，所以我们就有一个灵活性高的连接池Druid Druid（德鲁伊）是阿里巴巴开发的号称为监控而生的数据库连接池，Druid是目前最好的数据库连接池 在功能、性能、扩展性方面，都超过其他数据库连接池，同时加入了日志监控，可以很好的监控DB池连接和SQL的执行情况

上述是需要的包 是properties形式的 在druid里可以叫任意名称，可以放在任意目录下（因为不像C3P0一样，有内置的路径，且不可更改） 因为Druid是可以设置指定路径的，即不主动加载配置文件，没有内置路径 所以可以说是任意目录下，因为你不管放在那里，我都可以直接指定路径，来达到使用该配置文件 大多数的需要配置文件的代码都可以指定配置文件路径的（因为没有内置路径），但有些不可，如C3P0（有内置路径）等等 在这里，我们统一放到resources资源目录，即编译和路径与src一样，且更好的管理，虽然路径一样 但还是会优先使用资源文件的配置（即优先使用编译后的资源文件的内容），没有的话，就使用内置路径的配置 注意：对于复制的文件，他的路径其实不是你复制到的哪个路径，还是原来的路径（通常这就是找不到文件的原因） 因为项目配置文件可能还没有对其路径进行关联，即更新，因为文件是包含路径的，在没有进行更新的情况下 使用复制的文件，就会去他没更新的路径去，导致路径不对，从而发生错误 在idea的File（文件）里的Invalidate Caches / Restart…（使缓存无效重新启动），基本可以解决大部分问题 而在idea的最上方的Bulid（建造，在idea叫做构造）里的Rebuild Project（重建项目，可以说是对项目重新编译） 可以解决一些小问题，如复制后的路径关联不上的问题，使得路径更新 长按电源键5秒重新启动电脑，可以解决99%的问题 剩下的问题就需要自己去百度了 druid.properties----------------------------------

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

package com.lagou.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;

public class DruidUtils {

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

    //2.静态代码块
    static{
        try {
            //3.创建属性集对象,用来读取配置文件,因为他里面是HashMap的集合
            // 即用来存放数据的，一个放key,一个放value,对应与配置文件等于号的左边和右边
            //即需要有数据进入，他需要别人读取配置文件再交给他存储
            //这时别人可以读取他的数据，使得进行设置属性
            //C3P0底层也类似，因为配置文件就是用来给属性设置值的
            // 而设置值就需要将配置文件变为数据（如变为map集合），而进行设置
            Properties p = new Properties();

            //4.加载配置文件 Druid 连接池不能够主动加载配置文件 ,需要指定文件
            //主要是getResourceAsStream方法的作用
            //类加载器是用来将类进行加载的操作，也可以（加载）指定路径
            //而Class虽然也有getResourceAsStream方法，但是其实还是类加载器在使用该方法
            //但这里
            //Class.getResourceAsStream(String path)
            // path 不以'/'开头时默认是从此类所在的包下取资源
            // 以'/'开头则是从ClassPath根下获取,即idea的out文件夹的production目录里的对应项目里
            //没有src和其他的特定文件，在同一目录，即项目目录
            // 其只是通过path构造一个绝对路径，最终还是由ClassLoader获取资源
            //Class.getClassLoader.getResourceAsStream(String path)
            // 默认则是从ClassPath根下获取，path不能以'/'开头，最终是由ClassLoader获取资源
            InputStream inputStream =  
                DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties");

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

            //6. 通过工厂类获取连接池对象
            //利用jar包的类，获取连接对象，将属性集的属性进行设置
            //取出map集合的数据，进行判断key，来设置value
            dataSource = DruidDataSourceFactory.createDataSource(p);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

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

        try {

            return dataSource.getConnection();

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

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


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

        if(con != null && statement != null){
            try {
                statement.close();
                //归还连接
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }

    public static void close(Connection con, Statement statement, ResultSet resultSet){

        if(con != null && statement != null && resultSet != null){
            try {
                resultSet.close();
                statement.close();
                //归还连接
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }

}

package com.lagou.testpool;

import com.lagou.utils.DruidUtils;

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

public class TestDruid {

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

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

        //2.获取Statement对象
        Statement statement = con.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(con,statement,resultSet);
    }

}

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

上面是需要的包 Dbutils核心功能介绍------------------------ QueryRunner类中提供对sql语句操作的API ResultSetHandler接口，用于定义select操作后，怎样封装结果集 DbUtils类，他就是一个工具类,定义了关闭资源与事务处理相关方法 注意：java中的jar文件 ，装的是 .class 文件，它是一种压缩，和zip兼容，被称为jar包

对于mysql大小写问题：在不同的操作系统中有不同差异 在windows系统下，mysql数据库不区分大小写，且实际上你用大写时，最后都会变成小写，如创建表 在linux系统下，mysql数据库区分大小写，只能用小写，大写会找不到表 而在java与mysql之间操作时，java虽然不受操作系统的限制，但语句大小写受mysql限制（除非会自动变成小写） 以上是可以通过修改文件（或者配置，或者你厉害一点，修改底层）来改变 因为再怎么说，他都是人为的，只要是人为的基本都可以修改

//对于结果集来说
int id = resultSet.getInt("id");
//id可以大写
//但最后都会变成小写，对于结果集会转化（或者忽略）的

复习： 项目名全部小写 包名全部小写 类名首字母大写,其余组成词首字母依次大写 变量名和方法名首字母小写,如果名称由多个单词组成,除首字母外的每个单词的首字母都要大写. 常量名全部大写 所有命名规则必须遵循以下规则 : 名称只能由字母、数字、下划线、$符号组成 不能以数字开头 名称不能使用Java中的关键字 坚决不允许出现中文及拼音命名（实在不写，拼音也可以凑合，但不能太长） 只所以要这样，是一种规范，很多年的java经验得到的，有助与代码的浏览，但不适用于所有人（即有些人除外）

package com.lagou.entity;

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


public class Employee implements Serializable {

    //成员变量的名称 与 表中的列要一样
    //都是小写，因为表名和字段名基本都是小写的
    //这样做有助与观察，也防止因为大小写而出现的错误
    private int eid;

    private String ename;

    private int age;

    private String sex;

    private double salary;

    private Date empdate;

    public Employee() {
    }

    public Employee(int eid, String ename, int age, String sex, double salary, Date empdate) {
        this.eid = eid;
        this.ename = ename;
        this.age = age;
        this.sex = sex;
        this.salary = salary;
        this.empdate = empdate;
    }

    public int getEid() {
        return eid;
    }

    public void setEid(int eid) {
        this.eid = eid;
    }

    public String getEname() {
        return ename;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public double getSalary() {
        return salary;
    }

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

    public Date getEmpdate() {
        return empdate;
    }

    public void setEmpdate(Date empdate) {
        this.empdate = empdate;
    }

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

QueryRunner核心类------------------------

package com.lagou.testDBUtils;

import com.lagou.utils.DruidUtils;
import org.apache.commons.dbutils.QueryRunner;

public class DBUtilsDemo01 {

    //QueryRunner 核心类的创建方式
    public static void main(String[] args) {

        //方式1 手动模式
        //QueryRunner()
        QueryRunner qr = new QueryRunner();


        //方式2 自动模式 提供数据库连接池对象 DBUtils会自动的维护连接
        //QueryRunner(DataSource ds) ,提供数据源（连接池），DBUtils底层自动维护连接connection
        QueryRunner qr2 = new QueryRunner(DruidUtils.getDataSource());


    }

}

package com.lagou.testDBUtils;

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

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


public class DBUtilsDemo02 {

    //插入操作
    @Test
    public void testInsert() throws SQLException {

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

        //2.编写 占位符方式 SQL
        String sql = "insert into employee values(?,?,?,?,?,?)"; //没有分号,mysql会自动加上
        //由于sql最终是要到mysql的，那么这个sql错了，到mysql时报错，会让java也报错

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

        //4.执行 update方法
        Connection con = DruidUtils.getConnection();
        //Connection conn，数据库连接对象, 自动模式创建QueryRunner可以不传，也可以传
        //因为都是获得连接
        //手动模式必须传递，因为不传的话，没有连接获得了
        //因为手动是获得一个池的连接(构造方法里没操作,需要手动去获得连接)
        // 而自动的话，我们给池给他（构造方法里给)，他自动获得连接
        //但实际上双方都需要连接（前者需要传递连接，也可获得池的连接，即手动）
        // 后者可以传连接，也可不传（因为构造方法有池，不传的话，从池里拿连接），即自动获取连接
        //String sql占位符形式的SQL ,使用 ? 号占位符
        //Object... paramObject类型的 可变参,用来设置占位符上的参数
        //在这里注意一点，由于可变长参数可以看作一维数组看待，那么参数也就可以是一维数组，但要对应类型
        //就如单个参数一样，也需要对应类型
        int i = qr.update(con, sql, param);
        //返回受影响的行数
        //实际上获取连接的方法差不多，主要的就是设置占位符要简便了
        //利用连接池的简便，然后再让占位符再简便，使得JDBC简便，不冗余，冗余：多余的重复或罗嗦话

        //5.释放资源
        DbUtils.closeQuietly(con);
        //对于有资源占用的基本上都有close方法，来进行关闭，有些没有，如这里的QueryRunner,没有close方法
        //底层就是com.close()，且会判断是否为空，多个参数也是如此
    }

    //修改操作 修改姓名为 张百万的员工的工资为 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.执行修改操作 自动模式不需要传入connection对象
        //也可以不用去关闭连接，因为他DBUtils底层自动维护连接connection，即他会帮你关闭
        //若传入connection对象，则用传入的连接，而不用连接池的连接，且需要关闭该连接
        qr.update(sql,param);

    }

    //删除操作 删除id为1的 记录
    @Test
    public void testDelete() throws SQLException {

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

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

        //如果只有一个参数的话 不需要创建数组，因为考虑到一个参数还用数组的话，会占用内存
        //即有重载方法来进行一个参数的占位符，即不是可变长参数了，而是Object（指向包装类）
        qr.update(sql,1);//1变成包装类，自动装箱，父类指向子类，若有对象，则要看对象的判断
        //如父类->父类对象
        //然后子类 ->(子类)父类
        //会出现类型转化异常，且编译没错，因为转化是没错的（看不到底层），但运行时就错了（看到底层）
        //因为子类不可指向父类对象
    }


}

ResultSetHandler接口可以对查询出来的ResultSet结果集进行处理，达到一些业务上的需求 ResultSetHandler接口的实现类如下--------------------------

上述每一种实现类都代表了对查询结果集的一种处理方式 QueryRunner的查询方法--------------------------- query方法的返回值都是泛型，具体的返回值类型，会根据结果集的处理方式，发生变化

package com.lagou.testDBUtils;

import com.lagou.entity.Employee;
import com.lagou.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;

public class DBUtilsDemo03 {


    
    @Test
    public void testFindById() throws SQLException {

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

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

        //3.执行查询
        //具体的返回值类型，会根据结果集的处理方式，发生变化
        //ArrayHandler
        //将结果集中的第一条记录封装到一个Object[]数组中，数组中的每一个元素就是这条记录中的每一个字段的值
        //注意是第一条，其他的数据就不用了
        Object[] query = qr.query(sql, new ArrayHandler(), 5);
        //5这个地方是可变长参数，当然也可以使用数组
        //无论参数是一个还是数组，没有重载方法

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

    
    @Test
    public void testFindAll() throws SQLException {

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

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

        //3.执行查询
        //ArrayListHandler
        // 将结果集中的每一条记录都封装到一个Object[]数组中，将这些数组在封装到List集合中
        //注意是多条
        List query = qr.query(sql, new ArrayListHandler());

        //4.遍历集合获取数据
        for (Object[] objects : query) {
            System.out.println(Arrays.toString(objects));
        }
        //对于循环来说
       

    }

    
    @Test
    public void testFindByIdJavaBean() throws SQLException {

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

        String sql = "select * from employee where eid = ?";
        //BeanHandler
        // 将结果集中第一条记录封装到一个指定的javaBean中
        //注意是第一条
        Employee employee = qr.query(sql, new BeanHandler(Employee.class), 3);
        //对于泛型，再说明一点，泛型方法（指定对应泛型的返回）的返回值也可以是泛型，自己写的必须强转
        //而java提供的可以不强转
        //以a类为列子
        //若用var来接收，那么就可以通过指向，推出变量类型或者泛型规则
        //要想看是如何推出的，再new a()后面按alt+enter就知道他能推出什么了
        //可以理解为参照对象（有泛型参照泛型）来进行操作，因为没有自己类型了
        //而直接的new a()当参数时，就类似于var a = new a();,即这个实参参数，会推出形参参数（变量）泛型规则
        // 当然形式参数变量类型是参照本身的，因为不是var这个模糊的类型
        //即上述new BeanHandler(Employee.class)，可以写成
        //new BeanHandler<>(Employee.class)，也不会报错(也可以通过参数推出，如a.class）
        //若不用var来接收，结果的泛型规则写没写无所谓，因为泛型就是限制你写什么，但最后还是Object来调用
        //即你使用谁的变量，就用谁的变量的泛型来限制，如a a = new a()
        // 你任然可以给a的变量设置字符串的值，因为对于变量a来说没有限制，且最后都用Object来操作
        //所以经常说，编译时，泛型限制，运行时，泛型不限制（Object）
        //最后，只有满足泛型规则，无论怎么样的运行基本都不会错，因为最后是由Object来操作的

        System.out.println(employee);
    }

    
    @Test
    public void testFindBySalary() throws SQLException {

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

        String sql = "select * from employee where salary > ?";
        //BeanListHandler
        // 将结果集中每一条记录封装到指定的javaBean中，再将这些javaBean在封装到List集合中
        //注意是多条
        List list = qr.query(sql, new BeanListHandler(Employee.class), 3000);
        //当然这只是List，也可map，或者其他，如new BeanMapHandler(Employee.class)

        for (Employee employee : list) {
            System.out.println(employee);
        }
    }

    
    @Test
    public void testFindByName() throws SQLException {

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

        String sql = "select * from employee where ename = ?";
        //MapHandler
        // 将结果集中第一条记录封装到了Map集合中，key就是字段名称，value就是字段值
        //注意是第一条
        //Object[] d = {"张百万"};
        Map map = qr.query(sql, new MapHandler(), "张百万");

        Set> entries = map.entrySet();

        for (Map.Entry entry : entries) {
            //打印结果
            System.out.println(entry.getKey() +" = " +entry.getValue());
        }
    }

    
    @Test
    public void testGetSum() throws SQLException {

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

        String sql = "select sum(salary) from employee";
        //ScalarHandler
        // 它是用于封装单个数据，例如 select count(*) from 表操作。
        Double sum = (Double)qr.query(sql, new ScalarHandler<>());
        //虽然他推出的是Object
        //但这里可以不强转，是因为他不是自己手写提供的（java提供的，有特权，即可以看对象类型来推断）
        // 而自己写的需要强转
        //而对于泛型的推断，可以理解为编译的检查
        System.out.println("员工薪资总额: " + sum);
    }

}

批处理(batch) 操作数据库批处理指的是一次操作中执行多条SQL语句 批处理相比于一次一次执行效率会提高很多 当向数据库中添加大量的数据时，需要用到批处理 举例： 送货员的工作：未使用批处理的时候，送货员每次只能运送 一件货物给商家 使用批处理，则是送货员将所有要运送的货物, 都用车带到发放处派给客户 Statement和PreparedStatement都支持批处理操作 mysql批处理是默认关闭的，所以需要加一个参数才打开mysql 数据库批处理，在url中添加

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

package com.lagou.testbatch;

import com.lagou.utils.DruidUtils;

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

public class BatchInsert {

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

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

        //2.获取预处理对象
        PreparedStatement ps = connection.prepareStatement("insert into testBatch(uname) values(?)");
        //当你将values变为value时，可以很明显的看到values快
        // 即再次验证了
        //插入单行时，使用values比较快
        //插入多行时（用逗号隔开的，一次插入），使用value比较快
        //且我们多用values，因为用逗号隔开的影响观察

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

            //将SQL添加到批处理列表,比一个一个的执行快很多
            ps.addBatch();
        }
        //添加时间戳 测试执行效率
        long start = System.currentTimeMillis();

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

        long end = System.currentTimeMillis();

        System.out.println("插入10000条数据需要使用: " + (end - start) + " 毫秒!");
        //5.关闭连接
        DruidUtils.close(connection,ps);
    }

}

除了表之外的数据都是元数据,可以分为三类 查询结果信息： UPDATe 或 DELETE语句 受影响的记录数 数据库和数据表的信息： 包含了数据库及数据表的结构信息 MySQL服务器信息： 包含了数据库服务器的当前状态，版本号等

-- 查看服务器的状态信息
show status;

185是：表示非正常中断的连接数 2是：连接失败的连接数 13220是：从客户端接收的字节数 285596是：发送的字节数

-- 获取mysql服务器的版本信息
select version();

版本信息

-- 显示表的字段信息等，和desc 表名一样
SHOW COLUMNS FROM employee;
desc employee
-- 两者一样
-- 其中employee是表名，即可以是其他的表

--  显示数据表的详细索引信息，包括PRIMARY KEY（主键）
SHOW INDEX FROM testbatch;
-- 其中testbatch是表名，即可以是其他的表

-- 列出所有数据库
show databases;

-- 显示当前数据库的所有表
show tables;

-- 获取当前的数据库名
select database();

通过JDBC 也可以获取到元数据，比如数据库的相关信息 或者当我们使用程序查询一个不熟悉的表时 我们可以通过获取元素据信息，了解表中有多少个字段，字段的名称和字段的类型 JDBC中描述元数据的类 DatabasemetaData描述数据库的元数据对象 ResultSetmetaData描述结果集的元数据对象 connection连接对象，调用getmetaData()方法，获取的是DatabasemetaData数据库元数据对象 PrepareStatement预处理对象调用 getmetaData()，获取的是ResultSetmetaData结果集元数据对象 DatabasemetaData的常用方法

ResultSetmetaData的常用方法

package com.lagou.testmetadata;

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

import java.sql.*;

public class TestmetaData {

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

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

        //2.获取代表数据库的 元数据对象 DatabasemetaData
        //connection连接对象，调用getmetaData()方法，获取的是DatabasemetaData数据库元数据对象
        DatabasemetaData metaData = connection.getmetaData();

        //3.获取数据库相关的元数据信息
        //getURL() : 获取数据库的URL
        String url = metaData.getURL();
        System.out.println("数据库URL: " + url);
        //getUserName(): 获取当前数据库的用户名
        String userName = metaData.getUserName();
        System.out.println("当前用户: " + userName );
        //getDatabaseProductName(): 获取数据库的产品名称
        String productName = metaData.getDatabaseProductName();
        System.out.println("数据库产品名: " + productName);
        //getDatabaseProductVersion(): 获取数据的版本号
        String version = metaData.getDatabaseProductVersion();
        System.out.println("数据库版本: " + version);
        //getDriverName(): 返回驱动程序的名称
        String driverName = metaData.getDriverName();
        System.out.println("驱动名称: " + driverName);

        //判断当前数据库是否只允许只读
        //isReadonly(): 判断数据库是否只允许只读 true 代表只读
        boolean b = metaData.isReadOnly();  //如果是 true 就表示 只读
        if(b){
            System.out.println("当前数据库只允许读操作!");
        }else{
            System.out.println("不是只读数据库");
        }
        //从上面可以看出，连接操作运行后，就相当于连接上数据库了
        connection.close();
    }

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

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

        //2.获取预处理对象
        PreparedStatement ps = con.prepareStatement("select * from employee");
        ResultSet resultSet = ps.executeQuery();
        //这个获得结果集可以不写，因为不影响获取结果集元数据对象
        //都是获取操作

        //3.获取结果集元数据对象
        //PrepareStatement 预处理对象调用 getmetaData () , 获取的是ResultSetmetaData , 结果集元数据对象
        ResultSetmetaData metaData = ps.getmetaData();

        //1.获取当前结果集 共有多少列
        //getColumnCount() : 当前结果集共有多少列
        int count = metaData.getColumnCount();
        System.out.println("当前结果集中共有: " + count + " 列");

        //2.获结果集中 列的名称 和 类型
        for (int i = 1; i <=  count; i++) {
            //getColumnName(int i) : 获取指定列号的列名, 参数是整数 从1开始
            String columnName = metaData.getColumnName(i);
            System.out.println("列名: "+ columnName);
            //getColumnTypeName(int i): 获取指定列号列的类型, 参数是整数 从1开始
            String columnTypeName = metaData.getColumnTypeName(i);
            System.out.println("类型: " +columnTypeName);
        }

        //释放资源
        DruidUtils.close(con,ps,resultSet);
    }

}

m.out.println("不是只读数据库");
        }
        //从上面可以看出，连接操作运行后，就相当于连接上数据库了
        connection.close();
    }

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

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

        //2.获取预处理对象
        PreparedStatement ps = con.prepareStatement("select * from employee");
        ResultSet resultSet = ps.executeQuery();
        //这个获得结果集可以不写，因为不影响获取结果集元数据对象
        //都是获取操作

        //3.获取结果集元数据对象
        //PrepareStatement 预处理对象调用 getmetaData () , 获取的是ResultSetmetaData , 结果集元数据对象
        ResultSetmetaData metaData = ps.getmetaData();

        //1.获取当前结果集 共有多少列
        //getColumnCount() : 当前结果集共有多少列
        int count = metaData.getColumnCount();
        System.out.println("当前结果集中共有: " + count + " 列");

        //2.获结果集中 列的名称 和 类型
        for (int i = 1; i <=  count; i++) {
            //getColumnName(int i) : 获取指定列号的列名, 参数是整数 从1开始
            String columnName = metaData.getColumnName(i);
            System.out.println("列名: "+ columnName);
            //getColumnTypeName(int i): 获取指定列号列的类型, 参数是整数 从1开始
            String columnTypeName = metaData.getColumnTypeName(i);
            System.out.println("类型: " +columnTypeName);
        }

        //释放资源
        DruidUtils.close(con,ps,resultSet);
    }

}