zoukankan      html  css  js  c++  java
  • java深入探究08-连接池,分页

    1.连接池

      1)自定义连接池

        思路:定义一个类Pool->添加4个属性(最大连接数,初始化连接数,当前连接数,用来存放连接对象的LinkList集合对象)->定义一个createConnection()方法创造连接对象定义一个getConnection()方法,定义一个realeaseConnection()释放资源的方法

            其中的CreateConnection()需要解释下:我们想在对我们创建出来的conn对象只处理接口一部分功能(监听conn.close()使用接口方法时触发将conn对象添加到连接池中)

                   此时需要用到“代理对象”:如果想对接口指定方法扩展,不想实现所有方法,可以创建代理对象

                          创建方法:Proxy.newProxyInstance(

                                ClassLoader loader,  当前使用的类加载器

                                Class<?>[] interface,  目标对象实现的接口

                                InvocationHandler h    事件处理器:当执行上面接口中的方法的时候,就会自动触发事件处理器代码,把当前执行的方法(method)作为参数传入。

                               )

        例子:

    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.util.LinkedList;
    
    /**
     * 自定义连接池, 管理连接
     * 代码实现:
        1.  MyPool.java  连接池类,   
        2.  指定全局参数:  初始化数目、最大连接数、当前连接、   连接池集合
        3.  构造函数:循环创建3个连接
        4.  写一个创建连接的方法
        5.  获取连接
        ------>  判断: 池中有连接, 直接拿
         ------>                池中没有连接,
        ------>                 判断,是否达到最大连接数; 达到,抛出异常;没有达到最大连接数,
                创建新的连接
        6. 释放连接
         ------->  连接放回集合中(..)
     *
     */
    public class MyPool {
    
        private int init_count = 3;        // 初始化连接数目
        private int max_count = 6;        // 最大连接数
        private int current_count = 0;  // 记录当前使用连接数
        // 连接池 (存放所有的初始化连接)
        private LinkedList<Connection> pool = new LinkedList<Connection>();
        
        
        //1.  构造函数中,初始化连接放入连接池
        public MyPool() {
            // 初始化连接
            for (int i=0; i<init_count; i++){
                // 记录当前连接数目
                current_count++;
                // 创建原始的连接对象
                Connection con = createConnection();
                // 把连接加入连接池
                pool.addLast(con);
            }
        }
        
        //2. 创建一个新的连接的方法
        private Connection createConnection(){
            try {
                Class.forName("com.mysql.jdbc.Driver");
                // 原始的目标对象
                final Connection con = DriverManager.getConnection("jdbc:mysql:///test", "root", "mysql");
                
                /**********对con对象代理**************/
                
                // 对con创建其代理对象
                Connection proxy = (Connection) Proxy.newProxyInstance(
                        
                        con.getClass().getClassLoader(),    // 类加载器
                        //con.getClass().getInterfaces(),   // 当目标对象是一个具体的类的时候 
                        new Class[]{Connection.class},      // 目标对象实现的接口
                        
                        new InvocationHandler() {            // 当调用con对象方法的时候, 自动触发事务处理器
                            public Object invoke(Object proxy, Method method, Object[] args)
                                    throws Throwable {
                                // 方法返回值
                                Object result = null;
                                // 当前执行的方法的方法名
                                String methodName = method.getName();
                                
                                // 判断当执行了close方法的时候,把连接放入连接池
                                if ("close".equals(methodName)) {
                                    System.out.println("begin:当前执行close方法开始!");
                                    // 连接放入连接池 (判断..)
                                    pool.addLast(con);
                                    System.out.println("end: 当前连接已经放入连接池了!");
                                } else {
                                    // 调用目标对象方法
                                    result = method.invoke(con, args);
                                }
                                return result;
                            }
                        }
                );
                return proxy;
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
        
        //3. 获取连接
        public Connection getConnection(){
            
            // 3.1 判断连接池中是否有连接, 如果有连接,就直接从连接池取出
            if (pool.size() > 0){
                return pool.removeFirst();
            }
            
            // 3.2 连接池中没有连接: 判断,如果没有达到最大连接数,创建;
            if (current_count < max_count) {
                // 记录当前使用的连接数
                current_count++;
                // 创建连接
                return createConnection();
            }
            
            // 3.3 如果当前已经达到最大连接数,抛出异常
            throw new RuntimeException("当前连接已经达到最大连接数目 !");
        }
        
        
        //4. 释放连接
        public void realeaseConnection(Connection con) {
            // 4.1 判断: 池的数目如果小于初始化连接,就放入池中
            if (pool.size() < init_count){
                pool.addLast(con);
            } else {
                try {
                    // 4.2 关闭 
                    current_count--;
                    con.close();
                } catch (SQLException e) {
                    throw new RuntimeException(e);
                }
            }
        }
        
        public static void main(String[] args) throws SQLException {
            MyPool pool = new MyPool();
            System.out.println("当前连接: " + pool.current_count);  // 3
            
            // 使用连接
            pool.getConnection();
            pool.getConnection();
            Connection con4 = pool.getConnection();
            Connection con3 = pool.getConnection();
            Connection con2 = pool.getConnection();
            Connection con1 = pool.getConnection();
            
            // 释放连接, 连接放回连接池
    //        pool.realeaseConnection(con1);
            /*
             * 希望:当关闭连接的时候,要把连接放入连接池!【当调用Connection接口的close方法时候,希望触发pool.addLast(con);操作】
             *                                                                             把连接放入连接池
             * 解决1:实现Connection接口,重写close方法
             * 解决2:动态代理
             */
            con1.close();
            
            // 再获取
            pool.getConnection();
            
            System.out.println("连接池:" + pool.pool.size());      // 0
            System.out.println("当前连接: " + pool.current_count);  // 3
        }
        
    }
    View Code

      2)DBCP连接池

          导入:commons-dbcp-1.4.jar;commons-pool-1.5.6.jar

          核心API:BasicDataSource

          例子:

    // DBCP连接池核心类
        1.硬编码实现连接池
    BasicDataSource dataSouce = new BasicDataSource(); // 连接池参数配置:初始化连接数、最大连接数 / 连接字符串、驱动、用户、密码 dataSouce.setUrl("jdbc:mysql:///jdbc_demo"); //数据库连接字符串 dataSouce.setDriverClassName("com.mysql.jdbc.Driver"); //数据库驱动 dataSouce.setUsername("root"); //数据库连接用户 dataSouce.setPassword("root"); //数据库连接密码 dataSouce.setInitialSize(3); // 初始化连接 dataSouce.setMaxActive(6); // 最大连接 dataSouce.setMaxIdle(3000); // 最大空闲时间
        2.配置方式实现连接池
        前提有一个db.properties
    url=jdbc:mysql:///jdbc_demo
    
    driverClassName=com.mysql.jdbc.Driver
    
    username=root
    
    password=root
    
    initialSize=3
    
    maxActive=6
    
    maxIdle=3000
    View Code
        // 加载prop配置文件

          Properties prop = new Properties();

        // 获取文件流

          InputStream inStream = App_DBCP.class.getResourceAsStream("db.properties");

        // 加载属性配置文件

          prop.load(inStream);

        // 根据prop配置,直接创建数据源对象

          DataSource dataSouce = BasicDataSourceFactory.createDataSource(prop);

      3)C3P0连接池

    连接池配置详解

    <c3p0-config>
      <default-config>
     <!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 -->
     <property name="acquireIncrement">3</property>
     
     <!--定义在从数据库获取新连接失败后重复尝试的次数。Default: 30 -->
     <property name="acquireRetryAttempts">30</property>
     
     <!--两次连接中间隔时间,单位毫秒。Default: 1000 -->
     <property name="acquireRetryDelay">1000</property>
     
     <!--连接关闭时默认将所有未提交的操作回滚。Default: false -->
     <property name="autoCommitOnClose">false</property>
     
     <!--c3p0将建一张名为Test的空表,并使用其自带的查询语句进行测试。如果定义了这个参数那么
      属性preferredTestQuery将被忽略。你不能在这张Test表上进行任何操作,它将只供c3p0测试
      使用。Default: null-->
     <property name="automaticTestTable">Test</property>
     
     <!--获取连接失败将会引起所有等待连接池来获取连接的线程抛出异常。但是数据源仍有效
      保留,并在下次调用getConnection()的时候继续尝试获取连接。如果设为true,那么在尝试
      获取连接失败后该数据源将申明已断开并永久关闭。Default: false-->
     <property name="breakAfterAcquireFailure">false</property>
     
     <!--当连接池用完时客户端调用getConnection()后等待获取新连接的时间,超时后将抛出
      SQLException,如设为0则无限期等待。单位毫秒。Default: 0 --> 
     <property name="checkoutTimeout">100</property>
     
     <!--通过实现ConnectionTester或QueryConnectionTester的类来测试连接。类名需制定全路径。
      Default: com.mchange.v2.c3p0.impl.DefaultConnectionTester-->
     <property name="connectionTesterClassName"></property>
     
     <!--指定c3p0 libraries的路径,如果(通常都是这样)在本地即可获得那么无需设置,默认null即可
      Default: null-->
     <property name="factoryClassLocation">null</property>
     
     <!--Strongly disrecommended. Setting this to true may lead to subtle and bizarre bugs. 
      (文档原文)作者强烈建议不使用的一个属性--> 
     <property name="forceIgnoreUnresolvedTransactions">false</property>
     
     <!--每60秒检查所有连接池中的空闲连接。Default: 0 --> 
     <property name="idleConnectionTestPeriod">60</property>
     
     <!--初始化时获取三个连接,取值应在minPoolSize与maxPoolSize之间。Default: 3 --> 
     <property name="initialPoolSize">3</property>
     
     <!--最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 -->
     <property name="maxIdleTime">60</property>
     
     <!--连接池中保留的最大连接数。Default: 15 -->
     <property name="maxPoolSize">15</property>
     
     <!--JDBC的标准参数,用以控制数据源内加载的PreparedStatements数量。但由于预缓存的statements
      属于单个connection而不是整个连接池。所以设置这个参数需要考虑到多方面的因素。
      如果maxStatements与maxStatementsPerConnection均为0,则缓存被关闭。Default: 0-->
     <property name="maxStatements">100</property>
     
     <!--maxStatementsPerConnection定义了连接池内单个连接所拥有的最大缓存statements数。Default: 0  -->
     <property name="maxStatementsPerConnection"></property>
     
     <!--c3p0是异步操作的,缓慢的JDBC操作通过帮助进程完成。扩展这些操作可以有效的提升性能
      通过多线程实现多个操作同时被执行。Default: 3--> 
     <property name="numHelperThreads">3</property>
     
     <!--当用户调用getConnection()时使root用户成为去获取连接的用户。主要用于连接池连接非c3p0
      的数据源时。Default: null--> 
     <property name="overrideDefaultUser">root</property>
     
     <!--与overrideDefaultUser参数对应使用的一个参数。Default: null-->
     <property name="overrideDefaultPassword">password</property>
     
     <!--密码。Default: null--> 
     <property name="password"></property>
     
     <!--定义所有连接测试都执行的测试语句。在使用连接测试的情况下这个一显著提高测试速度。注意:
      测试的表必须在初始数据源的时候就存在。Default: null-->
     <property name="preferredTestQuery">select id from test where id=1</property>
     
     <!--用户修改系统配置参数执行前最多等待300秒。Default: 300 --> 
     <property name="propertyCycle">300</property>
     
     <!--因性能消耗大请只在需要的时候使用它。如果设为true那么在每个connection提交的
      时候都将校验其有效性。建议使用idleConnectionTestPeriod或automaticTestTable
      等方法来提升连接测试的性能。Default: false -->
     <property name="testConnectionOnCheckout">false</property>
     
     <!--如果设为true那么在取得连接的同时将校验连接的有效性。Default: false -->
     <property name="testConnectionOnCheckin">true</property>
     
     <!--用户名。Default: null-->
     <property name="user">root</property>
     
     <!--早期的c3p0版本对JDBC接口采用动态反射代理。在早期版本用途广泛的情况下这个参数
      允许用户恢复到动态反射代理以解决不稳定的故障。最新的非反射代理更快并且已经开始
      广泛的被使用,所以这个参数未必有用。现在原先的动态反射与新的非反射代理同时受到
      支持,但今后可能的版本可能不支持动态反射代理。Default: false-->
     <property name="usesTraditionalReflectiveProxies">false</property>
    
        <property name="automaticTestTable">con_test</property>
        <property name="checkoutTimeout">30000</property>
        <property name="idleConnectionTestPeriod">30</property>
        <property name="initialPoolSize">10</property>
        <property name="maxIdleTime">30</property>
        <property name="maxPoolSize">25</property>
        <property name="minPoolSize">10</property>
        <property name="maxStatements">0</property>
        <user-overrides user="swaldman">
        </user-overrides>
      </default-config>
      <named-config name="dumbTestConfig">
        <property name="maxStatements">200</property>
        <user-overrides user="poop">
          <property name="maxStatements">300</property>
        </user-overrides>
       </named-config>
    </c3p0-config>
    View Code

        引入:c3p0-0.9.1.2.jar

        核心api:CombopooledDataSource 

        与DBCP区别:一个需要自己配置properice,c3p0有自己的c3p0-config.xml会自己加载

        例子:

    c3p0-config:

    <c3p0-config>
        <default-config>
            <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbc_demo
            </property>
            <property name="driverClass">com.mysql.jdbc.Driver</property>
            <property name="user">root</property>
            <property name="password">root</property>
            <property name="initialPoolSize">3</property>
            <property name="maxPoolSize">6</property>
            <property name="maxIdleTime">1000</property>
        </default-config>
    
    
        <named-config name="oracle_config">
            <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbc_demo</property>
            <property name="driverClass">com.mysql.jdbc.Driver</property>
            <property name="user">root</property>
            <property name="password">root</property>
            <property name="initialPoolSize">3</property>
            <property name="maxPoolSize">6</property>
            <property name="maxIdleTime">1000</property>
        </named-config>

    主程序】

    两种实现方式:硬编码,自动加载c3p0-config

    @Test
        //1. 硬编码方式,使用C3P0连接池管理连接
        public void testCode() throws Exception {
            // 创建连接池核心工具类
            ComboPooledDataSource dataSource = new ComboPooledDataSource();
            // 设置连接参数:url、驱动、用户密码、初始连接数、最大连接数
            dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/jdbc_demo");
            dataSource.setDriverClass("com.mysql.jdbc.Driver");
            dataSource.setUser("root");
            dataSource.setPassword("root");
            dataSource.setInitialPoolSize(3);
            dataSource.setMaxPoolSize(6);
            dataSource.setMaxIdleTime(1000);
            
            // ---> 从连接池对象中,获取连接对象
            Connection con = dataSource.getConnection();
            // 执行更新
            con.prepareStatement("delete from admin where id=7").executeUpdate();
            // 关闭
            con.close();
        }
        
        @Test
        //2. XML配置方式,使用C3P0连接池管理连接
        public void testXML() throws Exception {
            // 创建c3p0连接池核心工具类
            // 自动加载src下c3p0的配置文件【c3p0-config.xml】
            ComboPooledDataSource dataSource = new ComboPooledDataSource([配置中的name]);// 使用默认的配置
            PreparedStatement pstmt = null;
            
            // 获取连接
            Connection con = dataSource.getConnection();
            for (int i=1; i<11;i++){
                String sql = "insert into employee(empName,dept_id) values(?,?)";
                // 执行更新
                pstmt = con.prepareStatement(sql);
                pstmt.setString(1, "Rose" + i);
                pstmt.setInt(2, 1);
                pstmt.executeUpdate();
            }
            pstmt.close();
            // 关闭
            con.close();
            
        }

    2.分页项目

  • 相关阅读:
    day003|python基础回顾3
    14Linux之网络管理
    13Linux之磁盘管理
    12Linux之进程管理
    11Linux之软件包管理
    10Linux之用户权限管理
    09Linux之文件管理
    08Linux之目录结构
    07Linux之bash解释器交互式环境特性
    06Linux之shell介绍
  • 原文地址:https://www.cnblogs.com/xiaoping1993/p/6866234.html
Copyright © 2011-2022 走看看