总结代理模式 并根据数据库连接池原理来模拟实现自己的数据库连接池工具类

代理模式

需求：对系统中已有的某个类的功能，进行扩展（增强）

     要求：在不修改源码的情况下，对已有的功能进行增强

     

 静态代理

抽象接口：保证包含增强功能的对象和原有功能的对象，对外提供相同的方法

目标对象：封装了原有功能

代理对象：封装了增强功能和原有功能（通过持有一个目标对象的引用实现）

 问题：代码不够灵活，产生大量冗余工作

动态代理

动态代理的实现API：

Proxy :

帮助程员产生代理对象，提供产生代理类和代理对象的静态方法

      InvocationHandler :

句柄接口，拦截到，所有代理对象调用的方法（所有代理对象调用的方法，都可以被

InvocationHandler拦截到）

模拟实现数据库连接池

数据库的操作：考虑性能问题

频繁的连接和断开数据，本身很消耗资源（操作数据的性能）

---对数据库连接对象，进行池管理（由池中获得资源，用完之后将资源再次放入）

连接池的具体实现：

1 创建一个集合对象，封装n个Connection对象

2 定义获得连接

3 和归还连接的功能

实现代码：

public class DBPoolUtils {
    private static String driver;
    private static String url;
    private static String username;
    private static String password;
    private static int maxconn;//线程池最大的连接数
    
    //定义一个集合表示线程池
    static List<Connection> list=new ArrayList<Connection>();
    //类加载的时候就初始化，创建好连接对象
    static{
        Properties properties=new Properties();
        try {
            //读取配置文件信息
            properties.load(DBPoolUtils.class.getResourceAsStream("mysql.properties"));
            driver=properties.getProperty("driver");
            url=properties.getProperty("url");
            username=properties.getProperty("username");
            password=properties.getProperty("password");
            maxconn=Integer.parseInt(properties.getProperty("maxconn"));
            Class.forName(driver);
            /*
             * 创建连接对象
             * 因为当用户关闭的时候要把线程连接对象还到线程池中，
             * 所有拿到的对象与还回来的对象都应该是代理对象。
             * 对close()方法进行拦截,把原来断开连接改成将线程连接对象还到连接池
             */            
            for (int i = 0; i < maxconn; i++) {
                final Connection conn=DriverManager.getConnection(url, username, password);
                //创建代理对象
                Object connProxy=Proxy.newProxyInstance(
                        DBPoolUtils.class.getClassLoader(),//自定义类的类加载器
                        new Class<?>[]{Connection.class},//实现的接口的class文件数组
                        new InvocationHandler() {//匿名内部类实现InvocationHandler
                            
                            @Override
                            public Object invoke(
                                    Object proxy,//代理对象
                                    Method method,//代理对象实现接口中调用的方法
                                    Object[] args//代理对象实现接口中调用的方法中的参数
                                    )throws Throwable {
                                //拦截close()方法，将原来的断开连接改为还回连接池,即：将当前的代理对象加到线程池中
                                String methodName=method.getName();
                                if ("close".equals(methodName)) {
                                    list.add((Connection) proxy);
                                    //唤醒等待的线程
                                    synchronized (list) {
                                        list.notifyAll();
                                    }
                                }
                                //放行:调用原来的对象方法
                                Object obj=method.invoke(conn, args);    
                                return obj;
                            }
                        });
                //将创建好的代理线程对象加线程池
                list.add((Connection) connProxy);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }        
    }
    /**
     * 对外提供一个连接对象
     * @return
     */
    public static Connection getConnection(){
        //当线程池中没有连接对象的时候，让线程等待，而不报异常，等待其他线程返回时再唤醒
        synchronized (list) {
            if (list.size()==0) {
                try {
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }        
        //每次从线程池中取出第一个线程
        Connection conn=list.remove(0);
        System.out.println("剩余："+list.size());
        return conn;
    }
}