MySQL---数据库从入门走向大神系列(十)-Connection对象池、装饰模式与动态代理模式

问题概述：

之前本系列博客写的，全部都是一个connection对象，不知道大家发现没有，我们既然做了一个Connection工具类，那么大家肯定都是从那里面拿Connection对象的，之前的如果是多线程运行，很容易出问题的，你想想事务处理就知道了，同时用事务处理操作同一个Connection，肯定会出问题的。

例如：
一方的事务在提交的时候，你正好运行了一个事务中的一个操作，那么你这个操作也会被提交，而且你后面的提交或回滚失效的，如果对方把Connection关闭了，你的程序还会挂。
等等问题…

那么，我们就需要一个Connection对象池，谁来了，就去池中拿对象，不会再是同一个了，而且可以很好的控制池中Connection对象的数目，不可能一直new Connection对象的，如果池中的对象用完了，我们就让那个客户端等，等别人用完Connection对象还回到池中。

配置文件：jdbc.propertise

##MySQL
driver=com.mysql.jdbc.Driver
url=jdbc:mysql:///hncu?useUnicode=true&characterEncoding=utf-8
username=root
password=1234

##Oracle
#driver=oracle.jdbc.driver.OracleDriver
#url=jdbc:oracle:thin:@localhost:1521:orcl
#username=scott
#password=tiger

ConnsUtil:Connection池

package cn.hncu.pool;

import java.sql.Connection;
import java.sql.DriverManager;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

public class ConnsUtil {

    //声明一个池
    private static List<Connection> pool = new ArrayList<Connection>();
    //声明池中的Connection对象个数
    private static final int NUM = 3;
    static{
        try {
            //读取配置文件
            Properties p = new Properties();
            p.load(ConnsUtil.class.getClassLoader().getResourceAsStream("jdbc.properties"));
            String driver = p.getProperty("driver");
            String url = p.getProperty("url");
            String user = p.getProperty("username");
            String password = p.getProperty("password");

            Class.forName(driver);
            for(int i=0;i<NUM;i++){
                Connection con = DriverManager.getConnection(url, user, password);
                //加入池中
                pool.add(con);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static synchronized Connection getConnection() throws InterruptedException{
        if(pool.size()<=0){
            Thread.sleep(100);
            return getConnection();
        }
        return pool.remove(0);
    }

    public static void back(Connection con){
        System.out.println("还回来一个Connection连接...");
        pool.add(con);
    }

}

测试类：

package cn.hncu.pool;

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

public class TestPool {

    public static void main(String[] args) {
        Connection con = null;
        try{
            con = ConnsUtil.getConnection();
            con.setAutoCommit(false);

            Statement st = con.createStatement();
            String sql ="insert into stud values('P201','关羽',30) ";
            st.execute(sql);
            sql ="insert into stud values('P202','张飞',25) ";
            st.execute(sql);
            new OneThread(1).start();
            new OneThread(2).start();
            new OneThread(3).start();
            new OneThread(4).start();
            new OneThread(5).start();

            System.out.println("主线程准备提交...");
            con.commit();
            System.out.println("主线程提交完毕...");
        }catch (Exception e) {
            try {
                con.rollback();
                System.out.println("主线程回滚了...");
            } catch (SQLException e1) {
                throw new RuntimeException("主线程事务回滚失败!", e1);
            }
        }finally{
            try {
                if(con!=null){
                    con.setAutoCommit(true);
                    ConnsUtil.back(con);
                    //con.close();//如果要把close内部的功能换成还连接，就需要我们以后的技术来实现
                }
            } catch (SQLException e) {
                throw new RuntimeException("主线程连接关闭失败!", e);
            }
        }

    }
}

class OneThread extends Thread{
    private int n;
    public OneThread(int n) {
        this.n = n;
    }

    @Override
    public void run() {
        Connection con = null;
        try{
            con = ConnsUtil.getConnection();
            con.setAutoCommit(false);

            Statement st = con.createStatement();
            String sql ="insert into stud values('P30"+n+"','刘备',30) ";
            st.execute(sql);
            sql ="insert into stud values('P31"+n+"','曹操',25) ";
            st.execute(sql);
            System.out.println("第"+n+"个线程准备提交...");
            con.commit();
            System.out.println("第"+n+"个线程提交完毕...");
        }catch (Exception e) {
            try {
                con.rollback();
                System.out.println("第"+n+"个线程回滚了...");
            } catch (SQLException e1) {
                throw new RuntimeException("第"+n+"事务回滚失败!", e1);
            }
        }finally{
            try {
                if(con!=null){
                    con.setAutoCommit(true);
                    //con.close();//这里就是我们需要改进的地方
                    ConnsUtil.back(con);
                }
            } catch (SQLException e) {
                throw new RuntimeException("第"+n+"连接关闭失败!", e);
            }
        }
    }

}

在调用返回Connection对象回到池中的时候，用普通的调用，不可避免的要去调用自己写的一个返回方法，如何在不改变程序员变成习惯(一般都习惯用close()去关闭那个对象)的情况下去实现Connection对象的回收呢，那就需要用到装饰模式，或者代理模式了。

装饰模式：

装饰模式又名包装(Wrapper)模式。装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案。

装饰模式以对客户透明的方式动态地给一个对象附加上更多的责任。换言之，客户端并不会觉得对象在装饰前和装饰后有什么不同。装饰模式可以在不使用创造更多子类的情况下，将对象的功能加以扩展。

其实我们要做的就是写一个MyConnection类实现Connection接口，实现所有方法，再进行扩展！

public class ConnsUtil {

    private static List<Connection> pool = new ArrayList<Connection>();
    private static final int NUM=3;
    static{
        try {
            Properties p = new Properties();
            p.load(ConnsUtil.class.getClassLoader().getResourceAsStream("jdbc.properties"));
            String drive = p.getProperty("driver");
            String url = p.getProperty("url");
            String user = p.getProperty("username");
            String password = p.getProperty("password");

            Class.forName(drive);

            for(int i=0;i<NUM;i++){
                Connection conn = DriverManager.getConnection(url, user, password);

            }

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public static synchronized Connection getConnection() throws InterruptedException{
        if(pool.size()<=0){
            Thread.sleep(50);
            return getConnection();
        }
        return pool.remove(0);
    }

    static class MyConnection implements Connection{
        //封装一个Connection
        private Connection con;
        public MyConnection(Connection con){
            this.con=con;
        }
        @Override
        public <T> T unwrap(Class<T> iface) throws SQLException {
            return con.unwrap(iface);
        }
        @Override
        public void rollback() throws SQLException {
            con.rollback();
        }
        @Override
        public Statement createStatement() throws SQLException {
            return con.createStatement();
        }
        @Override
        public void setAutoCommit(boolean autoCommit) throws SQLException {
            con.setAutoCommit(autoCommit);
        }
        @Override
        public void commit() throws SQLException {
            con.commit();
        }
        ......
        //...需要把接口的所有方法都实现了，按照上面的样式去写就行，如果不用增加功能或修改的，直接返回con.方法(参数);就可以了。如果需要修改，就自己写。比如:这里我们需要修改close();方法.
        @Override
        public void close() throws SQLException {
            pool.add(this);
            //直接把自己这个对象加进去
        }
    }
}

测试类：

package cn.hncu.pool2;

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

public class Testpool {

    public static void main(String[] args) {
        Connection con = null;
        try{
            con = ConnsUtil.getConnection();
            con.setAutoCommit(false);

            Statement st = con.createStatement();
            String sql ="insert into stud values('P203','关羽',30) ";
            st.execute(sql);
            sql ="insert into stud values('P204','张飞',25) ";
            st.execute(sql);
            new OneThread(1).start();
            new OneThread(2).start();
            new OneThread(3).start();
            new OneThread(4).start();
            new OneThread(5).start();

            System.out.println("主线程准备提交...");
            con.commit();
            System.out.println("主线程提交完毕...");
        }catch (Exception e) {
            try {
                con.rollback();
                System.out.println("主线程回滚了...");
            } catch (SQLException e1) {
                throw new RuntimeException("主线程事务回滚失败!", e1);
            }
        }finally{
            try {
                if(con!=null){
                    con.setAutoCommit(true);
                    con.close();//这样，我们直接调用close方法就可以了！！！
                }
            } catch (SQLException e) {
                throw new RuntimeException("主线程连接关闭失败!", e);
            }
        }

    }
}

class OneThread extends Thread{
    private int n;
    public OneThread(int n) {
        this.n = n;
    }

    @Override
    public void run() {
        Connection con = null;
        try{
            con = ConnsUtil.getConnection();
            con.setAutoCommit(false);

            Statement st = con.createStatement();
            String sql ="insert into stud values('P40"+n+"','刘备"+n+"',30) ";
            st.execute(sql);
            sql ="insert into stud values('P41"+n+"','曹操"+n+"',25) ";
            st.execute(sql);
            System.out.println("第"+n+"个线程准备提交...");
            con.commit();
            System.out.println("第"+n+"个线程提交完毕...");
        }catch (Exception e) {
            try {
                con.rollback();
                System.out.println("第"+n+"个线程回滚了...");
            } catch (SQLException e1) {
                throw new RuntimeException("第"+n+"事务回滚失败!", e1);
            }
        }finally{
            try {
                if(con!=null){
                    con.setAutoCommit(true);
                    con.close();//这样，我们直接调用close方法就可以了！！！
                }
            } catch (SQLException e) {
                throw new RuntimeException("第"+n+"连接关闭失败!", e);
            }
        }
    }

}

测试结果：

代理模式：

代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。

好处就是：
在某些情况下，如果不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

可以为原来的方法增加或者修改动作！

代理模式一般需要3个角色：

抽象角色：声明真实对象和代理对象的共同接口(必须是接口；

代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装与包装。

真实角色(被代理的角色)：代理角色所代表的真实对象，是我们最终要引用的对象。

代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。 代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后 续处理。

接口：

package cn.hncu.proxy.demo1;

public interface IRenter {
    public void rent(int i);
    public String say();
}

实际对象：

package cn.hncu.proxy.demo1;

public class Renter implements IRenter{
    @Override
    public void rent(int i) {
        System.out.println("给你"+i+"个房间,需要交500元!");
    }

    public String say() {
        System.out.println("Renter:你好，我是房东，房子实际只要300元");
        return "房东的返回结果...";
    }
}

代理模式的核心部分：

package cn.hncu.proxy.demo1;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class Client {

    public static void main(String[] args) {
        //被代理的对象
        final IRenter r = new Renter();

        //这个obj是代理后的对象
        Object obj = Proxy.newProxyInstance(Client.class.getClassLoader(),
                new Class[]{IRenter.class},
                new InvocationHandler() {
                    @Override
                    //proxy是代理后的对象(等价于返回的obj)，method就是类反射中的方法对象, args是执行method方法所需的参数
                    public Object invoke(Object proxy, Method method, Object[] args)
                            throws Throwable {
                        System.out.println("我是中介...");
                        //在这里，我们把房东说的话和返回值给拦截了。
                        if(method.getName().equals("say")){
                            System.out.println("我是中介，你还没交中介费,无法联系房东...");
                            return "";
                        }
                        Object obj = method.invoke(r, args);
                        System.out.println("欢迎再来找我中介...");
                        //r就是原来的对象
                        return obj;
                        //这个返回结果是调用r中的方法method.invoke(r, args);返回的结果
                    }
                });
        IRenter ir = (IRenter) obj;
        ir.rent(3);
        System.out.println(ir.say());
    }
}

可以看出来InvocationHandler这个接口中的invoke方法是最核心的部分！！！
在里面我们利用类加载器和类反射，直接可以来调用原来的类，而且可以加上自己需要的功能，或者实现拦截！！！

上面的例子只能实现对Renter 类的代理。

通用的代理模板类：

public interface IAnimal {
   public void run();
}

public class Dog implements IAnimal{
    private String name;
    public Dog(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        System.out.println("Doge:"+name+"is 

running...");
    }
}
public interface IPerson {
   public void sayHi();
}

public class Person implements IPerson {
    private String name;
    public Person(String name){
        this.name = name;
    }
    @Override
    public void sayHi() {
        System.out.println(name+"说：祝你快乐...");
    }

}

ProxyUtil.java

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyUtil implements InvocationHandler{
   private Object srcObj=null;

    public ProxyUtil(Object srcObj) {
        this.srcObj=srcObj;
    }

    public static Object getProxy(Object srcObj){
        Object obj = Proxy.newProxyInstance(
                ProxyUtil.class.getClassLoader(),
                srcObj.getClass().getInterfaces(),
                new ProxyUtil(srcObj)); 

        //obj是代理后的返回结果其实就是method.invoke(srcObj, args)的返回结果
        return obj;
    }

    //这个就是代理的方法了
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("进入了代理区域~~");

        //这个srcObj就是原来的对象
        return method.invoke(srcObj, args);
    }
}

client

package cn.hncu.proxy.demo2;

import cn.hncu.proxy.demo2.domain.Dog;
import cn.hncu.proxy.demo2.domain.IAnimal;
import cn.hncu.proxy.demo2.domain.IPerson;
import cn.hncu.proxy.demo2.domain.Person;

public class Client {
    public static void main(String[] args) {
        Dog dag = new Dog("旺财");
        IAnimal iDag = (IAnimal) ProxyUtil.getProxy(dag);
        iDag.run();

        Person p = new Person("小明");
        IPerson ip =(IPerson)  ProxyUtil.getProxy(p);
        ip.sayHi();
    }
}

输出结果：

我们现在再来把之前用装饰模式写的ConnsUtil类改写成代理模式：

ConnsUtil类的代理模式：

package cn.hncu.pool3;

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.util.ArrayList;
import java.util.List;
import java.util.Properties;

public class ConnsUtil {
    private static List<Connection> pool = new ArrayList<Connection>();
    private static final int NUM=3;
    static{
        try {
            //读取配置文件
            Properties p = new Properties();
            p.load(ConnsUtil.class.getClassLoader().getResourceAsStream("jdbc.properties"));
            String driver = p.getProperty("driver");
            String url = p.getProperty("url");
            String user = p.getProperty("username");
            String password = p.getProperty("password");
            Class.forName(driver);

            for(int i=0;i<NUM;i++){
                final Connection conn = DriverManager.getConnection(url, user, password);

                //只需要改这里就行了！
                //使用动态代理代理conn对象，实现对close方法的拦截
                Object obj = Proxy.newProxyInstance(
                        ConnsUtil.class.getClassLoader(),
                        conn.getClass().getInterfaces(),
                        new InvocationHandler() {

                            @Override
                            public Object invoke(Object proxy, Method method, Object[] args)
                                    throws Throwable {
                                if(method.getName().equalsIgnoreCase("close") && (args==null || args.length==0)){
                                    pool.add((Connection)proxy);
                                    return null;
                                }else{
                                    return method.invoke(conn, args);
                                }
                            }
                        });
                pool.add((Connection)obj);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static synchronized Connection getConn() throws Exception{
        if(pool.size()<=0){
            Thread.sleep(100);
            return getConn();
        }
        return pool.remove(0);
    }

}

大家可以自己动手写一写，加深印象， Proxy.newProxyInstance(类加载器,class数组(被代理对象的接口的class数组),new InvocationHandler());
记住这个就可以了！
被代理对象的接口的class数组可以用conn.getClass().getInterfaces(),来获得。
conn为被代理的对象！

动态代理比装饰模式方便很多！

时间： 2024-10-25 11:24:30

MySQL---数据库从入门走向大神系列(十)-Connection对象池、装饰模式与动态代理模式的相关文章

MySQL---数据库从入门走向大神系列(十四)-ComboPooledDataSource(C3P0连接池配置)

需要准备的jar包: MySQL的jar包mysql-connector-java-5.1.39-bin目前是5.1.39版本: http://dev.mysql.com/downloads/connector/j/ C3p0的2个包: https://sourceforge.net/projects/c3p0/ c3p0-0.9.1.2.jar和c3p0-sources-0.9.1.2.jar 配置文件:c3p0-config.xml 名字必须为这个! <c3p0-config> <!

MySQL---数据库从入门走向大神系列(十六)-JavaWeb分页技术实例演示1

分页,是一种将所有数据分段展示给用户的技术.用户每次看到的不 是全部数据,而是其中的一部分,如果在其中没有找到自己想要的内容,用户可以通过指定页码或是点上/下一页的方式进行翻页. 本例演示静态分页,也就是先设置好每页显示10行,再根据总行数,来算出总页数,将所有页数的页号都显示出来. 相关算法(技术): 总行数(num): select count(1) from stud; 每页显示的行数(n): 固定值---已知的一个常量 页数: pageSize= num/n +( (num%n==0)?

MySQL---数据库从入门走向大神系列(十五)-Apache的DBUtils框架使用

DBUtils简介: commons-dbutils 是 Apache 组织提供的一个开源 JDBC工具类库,它是对JDBC的简单封装,学习成本极低,并且使用dbutils能极大简化jdbc编码的工作量,同时也不会影响程序的性能.因此dbutils成为很多不喜欢hibernate的公司的首选(嗯~商业竞争-..). commons-dbutilsAPI介绍: org.apache.commons.dbutils.QueryRunner org.apache.commons.dbutils.Res

MySQL---数据库从入门走向大神系列(三)-修改数据库编码/DOS窗口编码

如何查看与修改数据库的编码,如何修改dos窗口的显示编码,都在本篇详细讲解. 查看当前数据库的编码: show variables where variable_name like 'character%'; 如果出现了中文乱码,我们只要看: character_set_client -客户端的编码 character_set_connection -连接的编码(传输时的编码) character_set_results - 最后的输出编码 只要保证这三个编码是相同的,且编码集有中文,中文就不会

MySQL---数据库从入门走向大神系列(十三)-BasicDataSource创建DataSource(DBCP连接池配置)

DBCP(DataBase connection pool),数据库连接池.是 apache 上的一个 java 连接池项目,也是 tomcat 使用的连接池组件.单独使用dbcp需要2个包:commons-dbcp.jar,commons-pool.jar由于建立数据库连接是一个非常耗时耗资源的行为,所以通过连接池预先同数据库建立一些连接,放在内存中,应用程序需要建立数据库连接时直接到连接池中申请一个就行,用完后再放回去. 首先,下载必须的jar包 dbcp包,目前版本是2.1.1 : htt

MySQL---数据库从入门走向大神系列(九)-用Java向数据库读写大文本/二进制文件数据

介绍MySQL的文本和图形数据类型: Text 类型: 数据类型:描述 ------------------------------------------------------ char(size):保存固定长度的字符串(可包含字母.数字以及特殊字符).在括号中指定字符串的长度.最多 255 个字符. varchar(size):保存可变长度的字符串(可包含字母.数字以及特殊字符).在括号中指定字符串的最大长度.最多 255 个字符. 注释:如果值的长度大于 255,则被转换为 text类型

MySQL---数据库从入门走向大神系列(七)-Java访问数据库配置及简单使用方法execute

从操作配置文件properties中读取连接字符串,通过该字符串进行数据连接,需要写三个文件其中,两个是java类,一个是后缀名为.properties的文件,该文件放在src工作目录下. 需要准备的包: https://github.com/chenhaoxiang/Java 后缀为.properties的文件此处为其取名为jdbc.properties,其中的代码如下: ##MySQL driver=com.mysql.jdbc.Driver url=jdbc:mysql://127.0.0

MySQL---数据库从入门走向大神系列(二)-用Java对MySQL进行增删改查

上节已经学会对MySQL进行简单的增删改查了,那么,我们如何实现用Java来对数据库操作增删改呢. 本节将用Java演示对MySQL进行增删改查. 简单的来说,分为4个步骤: 1.加载连接器(驱动)   通过Driver类 (最好用类反射来加载,更加灵活) 2.建立与数据库的连接 3.获取语句对象 4.对数据库进行操作(增删改查) 其实第一步现在可以不用写了,高版本的MySQL已经在内部帮我们写好了第一步,但是,为了兼容性更好(兼容低版本的MySQL)我们最好还是写上第一步. 我们先看一下原数据

MySQL---数据库从入门走向大神系列(八)-在java中执行MySQL的存储过程

http://blog.csdn.net/qq_26525215/article/details/52143733 在上面链接的博客中,写了如何用MySQL语句定义和执行存储过程 Java执行存储过程: 准备表stud: 列类型分别为: varchar,varchar,int 定义的存储过程分别为: p1:-无参 delimiter && create procedure p1() begin insert into stud values('P100','小李',43); select