数据库连接池

 对于共享资源，有一个很著名的设计模式：资源池(resource pool)。该模式正是为解决资源频繁分配、释放所造成的问题。数据库连接池的基本思想就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需要从缓冲池中取出一个了，使用完毕后再放回去。我们可以通过设定连接池最大数来防止系统无尽的与数据库连接。更为重要的是我们可以通过连接池的管理机制监视数据库连接使用数量，使用情况，为系统开发，测试以及性能调整提供依据。

模拟数据库连接池：

myPool.java

package pool;

import java.sql.Connection;
import java.util.LinkedList;

import utils.JdbcUtils;

public class myPool {

    //
    private static LinkedList<Connection> pool = new LinkedList<Connection>();
    static{
        //连接之前先创建好连接池
        for (int i = 0; i < 10; i++) {
            Connection conn = JdbcUtils.getConnection();
            pool.add(conn);
        }
    }
    
    //获得连接   synchronized同步
    public synchronized static Connection getConnection(){
        //先判断池中是否有连接
        if(pool.size() > 0){
            //不能使用get，你用别人就不能用了
            return  pool.removeFirst();
        }else{
            throw new RuntimeException("对不起，服务器正忙");
        }
    }
    
    public static void close(Connection conn){
        //还回池中
        if(conn != null){
            pool.addLast(conn);//放回池中
        }
    }
}

DaoImpl.java

package dao.impl;

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

import pool.myPool;

//模拟连接池的原理
public class DaoImpl {

    public void add(){
        //拿到连接
        Connection conn = null;
        PreparedStatement pstmt = null;
        try {
            conn = myPool.getConnection(); //左边：抽象类  右边：真实的对象，com.mysql.jdbc.Connection
            pstmt = conn.prepareStatement("");
            //业务逻辑
            
        } catch (Exception e) {
            // TODO: handle exception
        }finally{
            myPool.close(conn);
            
        }
    }
}

 DataSource对象是获取连接的首选方法。

 适配器模式：

 动态代理：

 start.java

package connection;

public interface start {

    public void eat();
    
    public void sing(float money);
    
    public void dance(float money);
}

SpringBrother.java

package connection;

public class SpringBrother implements start {

    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("eating ...");
    }

    @Override
    public void sing(float money) {
        // TODO Auto-generated method stub
        System.out.println("make money" + money + "singing");
    }

    @Override
    public void dance(float money) {
        // TODO Auto-generated method stub
        System.out.println("make money" + money + "dancing");

    }

}

boss.java

package connection;

import static org.junit.Assert.*;

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

import org.junit.Test;

public class boss {

    @Test
    public void test() {
//        start s = new SpringBrother();
//        
//        s.eat();
//        s.sing(100);
//        s.dance(200);
        
//        start s = new proxy(new SpringBrother());
//        s.eat();
//        s.dance(2000);
//        s.sing(600);
        //调用虚拟机的代理类
        /**
         * proxy 代理类 
         */
        final SpringBrother sb = new SpringBrother();
        //第一个参数是实现类，第二个是接口，第三那个是代理实例的调用处理程序
        start s = (start)Proxy.newProxyInstance(sb.getClass().getClassLoader(),
                sb.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     * invoke(Object arg0, Method arg1, Object[] arg2)
                     * proxy:代理人
                     * method:代理的方法
                     * args:方法对的参数
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] arg2)
                            throws Throwable {
                        System.out.println("被代理了");
                        method.invoke(sb, arg2);
                        return null;
                    }
                });
                
        s.eat();
        s.sing(100);
        s.dance(2000);          
    }

}

扩展已知类的功能：（不能修改源码）

1.子类；

2.包装类(装饰模式)

3.动态代理；

 虚拟机帮你实现动态代理。