3.2 API介绍

com.mchange.v2.c3p0.ComboPooledDataSource类表示C3P0的连接池对象，常用2种创建连接池的方式：

1.无参构造，使用默认配置

2.有参构造，使用命名配置

1. public ComboPooledDataSource()
   无参构造使用默认配置（使用xml中default-config标签中对应的参数）

2. public ComboPooledDataSource(String configName)
   有参构造使用命名配置（configName：xml中配置的名称，使用xml中named-config标签中对应的参数）

3. public Connection getConnection() throws SQLException
   从连接池中取出一个连接

3.3 常用的配置参数解释

常用的配置参数：

初始连接数：刚创建好连接池的时候准备的连接数量 最大连接数：连接池中最多可以放多少个连接 最大等待时间：连接池中没有连接时最长等待时间 最大空闲回收时间：连接池中的空闲连接多久没有使用就会回收

完整参数

3.4 硬编码方式实现C3P0连接池(了解)

3.4.1 案例需求

使用代码给C3P0连接池设置相应的参数。

3.4.2 案例步骤

1. 导入jar包c3p0-0.9.5.2.jar 和 mchange-commons-java-0.2.12.jar
2. 创建连接池对象ComboPooledDataSource对象
3. 设置连接参数：driverClass，jdbcUrl，user，password
4. 设置连接池参数
   1. 初始连接数initialPoolSize
   2. 最大连接数maxPoolSize
   3. 最大等待时间checkoutTimeout
   4. 最大空闲回收时间maxIdleTime
5. 获取连接对象(getConnection()方法)

3.4.3 案例代码

CREATE TABLE student (
   id INT PRIMARY KEY AUTO_INCREMENT,
   NAME VARCHAR(20),
   age INT,
   score DOUBLE DEFAULT 0.0
);

public class Demo01 {
​
    public static void main(String[] args) throws Exception {
        // 2.创建连接池对象ComboPooledDataSource对象
        ComboPooledDataSource ds = new ComboPooledDataSource();
        
        // 连接到数据库的相关参数
        // 3.设置连接参数:driverClass , jdbcUrl, user, password
        ds.setDriverClass("com.mysql.jdbc.Driver"); // 设置驱动的名称
        ds.setJdbcUrl("jdbc:mysql://localhost:3306/day25");
        ds.setUser("root");
        ds.setPassword("root");
        
        // 4.设置连接池参数
        // a.初始连接数initialPoolSize
        ds.setInitialPoolSize(5);
        
        // b.最大连接数maxPoolSize
        ds.setMaxPoolSize(10);
        
        // c.最大等待时间checkoutTimeout
        // Java程序去连接池中取连接,最长的等待时间,超过这个时间会有异常
        ds.setCheckoutTimeout(5000);
        
        // d.最大空闲回收时间maxIdleTime
        // 连接池中的连接超过这个时间没有人使用,就会自动销毁
        ds.setMaxIdleTime(3000);
        
        //  for (int i = 0; i < 10; i++) {
        //          Connection conn = ds.getConnection();
        //          System.out.println(conn);
        //  }
      
        Connection conn = ds.getConnection(); // 从一个连接池中取出一个连接
        // jdbc操作sql语句
         String sql = "INSERT INTO student VALUES (NULL, ?, ?, ?);";
         PreparedStatement pstmt = conn.prepareStatement(sql);
         pstmt.setString(1, "张三");
         pstmt.setInt(2, 25);
         pstmt.setDouble(3, 99.5);
​
         int i = pstmt.executeUpdate();
         System.out.println("影响的行数： " + i);
         pstmt.close();
      
         conn.close(); // 将连接还回连接池中
    }
}

3.3.5 案例效果

• 正常获取连接

• 获取连接超时

• 使用连接池中连接执行SQL语句

总结：使用纯代码获取配置C3P0连接池的弊端，所有配置信息都写在代码中。一旦需要改配置信息，就需要改动源代码，非常麻烦。

3.5 配置文件方式实现C3P0连接池

3.5.1 C3P0配置文件

我们看到要使用C3P0连接池，需要设置一些参数。那么这些参数怎么设置最为方便呢？使用配置文件方式。

配置文件的要求：

1. 文件名：c3p0-config.xml
2. 放在源代码即src目录下
3. 配置方式一：使用默认配置（default-config）
4. 配置方式二：使用命名配置（named-config）

配置文件c3p0-config.xml

<c3p0-config>
  <!-- 使用默认的配置读取连接池对象 -->
  <default-config>
    <!--  连接参数 -->
    <property name="driverClass">com.mysql.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/day25</property>
    <property name="user">root</property>
    <property name="password">root</property>
    
    <!-- 连接池参数 -->
    <property name="initialPoolSize">5</property>
    <property name="maxPoolSize">10</property>
    <property name="checkoutTimeout">2000</property>
    <property name="maxIdleTime">1000</property>
  </default-config>
​
  <named-config name="itheimac3p0"> 
    <!--  连接参数 -->
    <property name="driverClass">com.mysql.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/day25</property>
    <property name="user">root</property>
    <property name="password">root</property>
    
    <!-- 连接池参数 -->
    <property name="initialPoolSize">5</property>
    <property name="maxPoolSize">15</property>
    <property name="checkoutTimeout">2000</property>
    <property name="maxIdleTime">1000</property>
  </named-config>
</c3p0-config>

3.5.2 使用步骤

1. 导入jar包c3p0-0.9.5.2.jar``mchange-commons-java-0.2.12.jar
2. 编写c3p0-config.xml配置文件，配置对应参数
3. 将配置文件放在src目录下
4. 创建连接池对象ComboPooledDataSource，使用默认配置或命名配置
5. 从连接池中获取连接对象
6. 使用连接对象操作数据库
7. 关闭资源

3.5.3 注意事项

C3P0配置文件名称必须为c3p0-config.xml C3P0命名配置可以有多个

3.5.4 案例代码

• 配置文件

 <c3p0-config>
   <!-- 使用默认的配置读取连接池对象 -->
   <default-config>
     <!--  连接参数 -->
     <property name="driverClass">com.mysql.jdbc.Driver</property>
     <property name="jdbcUrl">jdbc:mysql://localhost:3306/day25</property>
     <property name="user">root</property>
     <property name="password">root</property>
​
     <!-- 连接池参数 -->
     <property name="initialPoolSize">5</property>
     <property name="maxPoolSize">10</property>
     <property name="checkoutTimeout">2000</property>
     <property name="maxIdleTime">1000</property>
   </default-config>
​
   <named-config name="itheimac3p0"> 
     <!--  连接参数 -->
     <property name="driverClass">com.mysql.jdbc.Driver</property>
     <property name="jdbcUrl">jdbc:mysql://localhost:3306/day25</property>
     <property name="user">root</property>
     <property name="password">root</property>
​
     <!-- 连接池参数 -->
     <property name="initialPoolSize">5</property>
     <property name="maxPoolSize">15</property>
     <property name="checkoutTimeout">2000</property>
     <property name="maxIdleTime">1000</property>
   </named-config>
 </c3p0-config>

• java代码

 public class Demo01 {
​
     public static void main(String[] args) throws Exception {
         // 方式一: 使用默认配置（default-config）
         // new ComboPooledDataSource();
         // ComboPooledDataSource ds = new ComboPooledDataSource();
​
         // 方式二： 使用命名配置（named-config：配置名）
         // new ComboPooledDataSource("配置名");
         ComboPooledDataSource ds = new ComboPooledDataSource("otherc3p0");
​
         // 从连接池中取出连接
         Connection conn = ds.getConnection();
​
         // jdbc执行SQL语句省略
        
         System.out.println(conn);
         conn.close(); // 将连接还回连接池中
     }
 }

3.5.5 总结

配置文件名称必须为：c3p0-config.xml，将配置文件放在src目录下 使用配置文件方式好处：只需要单独修改配置文件，不用修改代码 多个配置的好处：

1. 可以连接不同的数据库：db1,db2
2. 可以使用不同的连接池参数：maxPoolSize
3. 可以连接不同厂商的数据库：Oracle或MySQL

4.2 DRUID常用的配置参数

常用的配置参数：

4.3 DRUID连接池基本使用

4.3.1 API介绍

com.alibaba.druid.pool.DruidDataSourceFactory类有创建连接池的方法

public static DataSource createDataSource(Properties properties)
创建一个连接池，连接池的参数使用properties中的数据

我们可以看到DRUID连接池在创建的时候需要一个Properties对象来设置参数，所以我们使用properties文件来保存对应的参数。 DRUID连接池的配置文件名称随便，建议放到src目录下面方便加载。 druid.properties文件内容：

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/day25
username=root
password=root
initialSize=5
maxActive=10
maxWait=3000
maxIdle=6
minIdle=3

4.3.2 使用步骤

1. 在src目录下创建一个properties文件，并设置对应参数
2. 加载properties文件的内容到Properties对象中
3. 创建DRUID连接池，使用配置文件中的参数
4. 从DRUID连接池中取出连接
5. 执行SQL语句
6. 关闭资源

4.3.3 案例代码

• 在src目录下新建一个DRUID配置文件，命名为：druid.properties，内容如下

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/day25
username=root
password=root
initialSize=5
maxActive=10
maxWait=3000
maxIdle=6
minIdle=3

java代码

public class Demo02 {
    public static void main(String[] args) throws Exception {
        // 加载配置文件中的配置参数
        InputStream is = Demo03.class.getResourceAsStream("/druid.properties");
        Properties pp = new Properties();
        pp.load(is);
        
        // 创建连接池，使用配置文件中的参数
        DataSource ds = DruidDataSourceFactory.createDataSource(pp);
            
        // 从连接池中取出连接
        Connection conn = ds.getConnection();
        
        // 使用jdbc执行SQL语句 省略
        
        conn.close(); // 将连接还回连接池中
    }
}

4.3.4 案例效果

• 正常获取连接池中的连接

• 获取连接池中的连接超时

• 使用DRUID连接池中的连接操作数据库

4.3.5 总结

DRUID连接池根据Properties对象中的数据作为连接池参数去创建连接池，我们自己定义properties类型的配置文件，名称自己取，也可以放到其他路径，建议放到src目录下方便加载。 ​ 不管是C3P0连接池，还是DRUID连接池，配置大致都可以分为2种：1.连接数据库的参数，2.连接池的参数，这2种配置大致参数作用都相同，只是参数名称可能不一样。

4.4 Jdbc工具类

我们每次操作数据库都需要创建连接池，获取连接，关闭资源，都是重复的代码。我们可以将创建连接池和获取连接池的代码放到一个工具类中，简化代码。

Jdbc工具类步骤：

1. 声明静态数据源成员变量
2. 创建连接池对象
3. 定义公有的得到数据源的方法
4. 定义得到连接对象的方法
5. 定义关闭资源的方法

案例代码 DataSourceUtils.java

public class DataSourceUtils {
    // 1.   声明静态数据源成员变量
    private static DataSource ds;
​
    // 2. 创建连接池对象
    static {
        // 加载配置文件中的数据
        InputStream is = JdbcUtils.class.getResourceAsStream("/druid.properties");
        Properties pp = new Properties();
        try {
            pp.load(is);
            // 创建连接池，使用配置文件中的参数
            ds = DruidDataSourceFactory.createDataSource(pp);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
​
    // 3. 定义公有的得到数据源的方法
    public static DataSource getDataSource() {
        return ds;
    }
​
    // 4. 定义得到连接对象的方法
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }
​
    // 5.定义关闭资源的方法
    public static void close(Connection conn, Statement stmt, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {}
        }
​
        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {}
        }
​
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {}
        }
    }
​
    // 6.重载关闭方法
    public static void close(Connection conn, Statement stmt) {
        close(conn, stmt, null);
    }
}

测试类代码

public class Demo03 {
    public static void main(String[] args) throws Exception {
        // 拿到连接
        Connection conn = DataSourceUtils.getConnection();
​
        // 执行sql语句
        String sql = "INSERT INTO student VALUES (NULL, ?, ?, ?);";
        PreparedStatement pstmt = conn.prepareStatement(sql);
        pstmt.setString(1, "李四");
        pstmt.setInt(2, 30);
        pstmt.setDouble(3, 50);
        int i = pstmt.executeUpdate();
        System.out.println("影响的函数: " + i);
​
        // 关闭资源
        DataSourceUtils.close(conn, pstmt);
    }
}

小结：使用Jdbc工具类后可以简化代码，我们只需要写SQL去执行。

第5章 动态代理

刚才我们学习完了常用的连接池，我们知晓了如果连接需要归还给连接池，那么直接调用close方法即可。 但是我们在学习jdbc时调用connection.close() 是关闭连接，而现在是将连接还回连接池。这个是怎么做到的呢 ? 其实是对Connection的close方法进行了增强，我们现在来学习下使用动态代理来增强方法。

5.1 代理模式

5.1.1 现实生活中的代理

假如我们要去买电脑，我们通常需要去找电脑代理商购买，电脑代理商去电脑工厂提货，电脑代理商可以赚取中间的差价。 ​ 假如我们想买火车票，我们可以直接去12306网站买票。可是太难抢到票了，于是我们去找火车票的黄牛，让黄牛帮我们去12306买票，黄牛买到票再加价卖给我们，赚取中间的差价。

你买电脑       ->     电脑代理商    ->       电脑工厂
你买火车票   ->      黄牛              ->      12306
调用者                   代理对象                  真正干活的目标对象

我们发现代理对象和真正干活的目标都具有相同的功能（卖电脑/卖票），代理可以在中间赚取差价（增强功能）。

5.1.2 代理模式的作用

代理对象可以在调用者和目标对象之间起到中介的作用。代理对象可以对目标对象的功能进行增强。

5.1.3 代理模式涉及到四个要素

1. 调用者: 你。
2. 代理对象: 联想电脑代理商/黄牛。
3. 目标对象: 电脑工厂/12306。
4. 抽象对象: 代理对象和目标对象都共有的接口,保证代理对象和真实对象都有相应的方法，如电脑代理商和电脑工厂都需要有卖电脑的功能。

5.2 动态代理

5.2.1 什么是动态代理

在程序运行的过程中，动态创建出代理对象。

5.2.2 动态代理类相应的API

• Proxy类

static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) 
作用：生成实现指定接口的代理对象
​
参数说明：
loader参数：目标对象的类加载器
interfaces：代理对象实现的接口数组
h: 具体的代理操作，InvocationHandler是一个接口，需要传入一个实现了此接口的实现类。
​
返回值：实现指定接口的代理对象。

• InvocationHandler接口

Object invoke(Object proxy, Method method, Object[] args)
作用：在这个方法中实现对真实方法的增强
​
参数说明：
proxy：即方法newProxyInstance()方法返回的代理对象，该对象一般不要在invoke方法中使用。
method: 代理对象调用的方法对象。
args：代理对象调用方法时传递的参数。
​
返回值：是真实对象方法的返回值。

5.2.3 动态代理模式的开发步骤

1. 直接创建真实对象
2. 通过Proxy类，创建代理对象
3. 调用代理方法
4. 在InvocationHandler的invoke进行处理

5.2.4 动态代理模式使用

• Providable接口

/*
    提供商品的接口
 */
public interface Providable {
    // 卖电脑
    public abstract void sellComputer(double price);
    // 维修电脑
    public abstract void repairComputer(double price);
}

• ComputerFactory目标对象

/*
    电脑工厂，真正生产电脑的厂商
 */
public class ComputerFactory implements Providable {
    @Override
    public void sellComputer(double price) {
        System.out.println("电脑工厂卖出一台电脑，价格： " + price);
    }
​
    @Override
    public void repairComputer(double price) {
        System.out.println("电脑工厂修好一台电脑，价格： " + price);
    }
}

• 调用者，动态生成代理对象

public class Demo05 {
    public static void main(String[] args) {
        // 1. 直接创建真实对象
        ComputerFactory computerFactory = new ComputerFactory();
        // 2. 通过Proxy类，创建代理对象
        Providable proxy = (Providable) Proxy.newProxyInstance(
                ComputerFactory.class.getClassLoader(),
                new Class[] {Providable.class},
                new MyInvocationHandler(computerFactory)
        );
​
        // 3. 调用代理方法
        proxy.sellComputer(5000);
        proxy.repairComputer(800);
    }
}
​
// InvocationHandler实现类
class MyInvocationHandler implements InvocationHandler {
    private ComputerFactory computerFactory;
​
    public MyInvocationHandler(ComputerFactory computerFactory) {
        this.computerFactory = computerFactory;
    }
​
    // 4. 在InvocationHandler的invoke进行处理
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (method.getName().equals("sellComputer")) { // 对于是要增强的方法进行增强
            // 代理对象处理卖电脑的方法。
            double price = (double) args[0];
            double realPrice = price* 0.75;
            System.out.println("代理商收到：" + price + "元，实际使用" + realPrice + "去电脑工厂买电脑");
            computerFactory.sellComputer(realPrice);
            System.out.println("代理商赚到：" + (price - realPrice) + "元钱");
            return null;
        } else  { // 不需要增强的方法直接调用目标对象的方法
            return method.invoke(computerFactory, args);
        }
    }
}

5.2.5 动态代理模式小结

1. 什么是动态代理 在程序运行的过程中，动态创建出代理对象。
2. 动态代理使用到的API Proxy类的newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)方法 InvocationHandler接口的invoke(Object proxy, Method method, Object[] args)方法
3. Proxy.newProxyInstance()方法的本质 创建了代理对象，代理对象实现了传入的接口。
4. InvocationHandler接口的作用 调用代理对象的方法就会执行到InvocationHandler接口的invoke方法。
5. 动态代理使用步骤
6. 直接创建真实对象
7. 通过Proxy类，创建代理对象
8. 调用代理方法
9. 在InvocationHandler的invoke进行处理
10. 代理模式的好处 在不改变目标类的代码情况下，代理对象可以对目标对象的功能进行增强。

5.2.6 动态代理解决close问题 (了解)

在创建Connection连接时使用动态代理产生Connection代理对象，使用代理对象。修改createConnection方法，创建Connection代理对象。

• 自定义连接池类：MyPool2.java

public class MyPool2 implements DataSource {
    private int initCount = 5; //初始化的个数
    private int maxCount = 10; //最大的连接个数
    private int curCount = 0; //当前已经创建的连接个数
​
    // 存储连接的容器
    private LinkedList<Connection> list = new LinkedList<Connection>();
​
    // 构造方法,初始化连接池的，连接池一旦创建那么连接池中就应该要有指定个数的连接。
    public MyPool2() {
        for (int i = 0; i < initCount; i++) {
            Connection connection = createConnection();
            // 把连接存储到容器中
            list.add(connection);
        }
    }
​
    // 创建Connection的方法
    public Connection createConnection() {
        Connection proxyConnection = null;
        try {
            Connection connection = JDBCUtils.getConnection();
            // 使用动态代理，产生代理对象
            proxyConnection = (Connection) Proxy.newProxyInstance(
                    MyPool2.class.getClassLoader(),
                    new Class[]{Connection.class},
                    new ConnectionHandler(connection));
        } catch (SQLException e) {
            e.printStackTrace();
        }
        curCount++;
        return proxyConnection;
    }
​
    // 自定义处理器 ---内部类
    class ConnectionHandler implements InvocationHandler {
        private Connection connection;    // 在内部维护一个需要被增强的对象（被代理对象）
        public ConnectionHandler(Connection connection) {
            this.connection = connection;
        }
​
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            // 先得到当前调用的方法的方法名
            String methodName = method.getName();
            if ("close".equalsIgnoreCase(methodName)) {
                // 需要增强的方法，进行增强
                list.addLast((Connection) proxy);
            } else {
                // 其他方法正常调用
                return method.invoke(connection, args);
            }
            return null;
        }
    }
​
    // 别人问你的连接池要连接
    @Override
    public Connection getConnection() {
        // 情况一: 先判断连接池是否有连接
        if (list.size() > 0) {
            //如果连接池有连接，那么直接取出连接，返回即可
            Connection connection = list.removeFirst();
            return connection;
        }
​
        // 情况二: 连接池中没有连接，然后先判断目前的连接个数是否已经超过了最大的连接个数
        if (curCount < maxCount) {
            // 创建连接
            Connection connection = createConnection();
            return connection;
        } else {
            // 没有连接，并且已经超过了最大的连接个数
            throw new RuntimeException("已经达到了最大的连接个数，请稍后");
        }
    }
​
    // 回收Connection
    public void close(Connection connection) {
        list.addLast(connection);
    }
​
    @Override
    public Connection getConnection(String username, String password) throws SQLException {
        return null;
    }
​
    @Override
    public PrintWriter getLogWriter() throws SQLException {
        return null;
    }
​
    @Override
    public void setLogWriter(PrintWriter out) throws SQLException {
​
    }
​
    @Override
    public void setLoginTimeout(int seconds) throws SQLException {
​
    }
​
    @Override
    public int getLoginTimeout() throws SQLException {
        return 0;
    }
​
    @Override
    public Logger getParentLogger() throws SQLFeatureNotSupportedException {
        return null;
    }
​
    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        return null;
    }
​
    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return false;
    }
}

• 测试类：Demo05.java

public class Demo05 {
    public static void main(String[] args) throws SQLException {
        //创建自定义的连接池
        MyPool2 myPool = new MyPool2();
        System.out.println("连接："+ myPool.getConnection());
        System.out.println("连接："+ myPool.getConnection());
        System.out.println("连接："+ myPool.getConnection());
        System.out.println("连接："+ myPool.getConnection());
        System.out.println("连接："+ myPool.getConnection());
        System.out.println("连接："+ myPool.getConnection());
        System.out.println("连接："+ myPool.getConnection());
        System.out.println("连接："+ myPool.getConnection());
        System.out.println("连接："+ myPool.getConnection());
        Connection connection = myPool.getConnection() ;   ///代理COnnection
        System.out.println("连接："+ connection );
        /*
            目前的问题： 由于我们编程习惯的问题，我们都习惯关闭资源的时候直接调用close方法，不习惯传递进去。
            目标：  如果连接需要归还给连接池,那么直接调用close方法即可。
            对connection的close方法不满意，需要增强。
         */
​
        // 把连接还回给连接池
        connection.close(); // 代理对象的Connection调用close，那么还回给连接池的对象是原有connection还是代理对象？
​
        System.out.println("连接："+ myPool.getConnection());
    }
}

• 效果