Java代理模式学习---完成一个数据库连接池中的close方法拦截

本篇博客知识点
1.个人对代理模式的理解
2.代理模式： Proxy.newProxyInstance方法的讲解
3.拦截java.util.List方法
4.写一个通用的拦截工具类
5.完成数据库连接池 close方法的拦截
代理模式

 代理模式本质上是利用java.lang.reflect.Proxy类中的一个静态方法:
   newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 
 帮我们创建出一个代理后的对象， 用代理后的对象去执行方法，会被拦截！ 具体拦截的动作(功能)由参数h来实现。 

我的理解是这样的。

Proxy.newProxyInstance方法的讲解（代理模式的底层是通过类放射实现）

@Test
    public void proxyDemo(){

        final Renter r = new Renter();//原型对象----将要被代理的对象(房东)

        //newProxyInstance()方法返回的对象(proxiedObj)即是代理后的对象------出租代理
        Object proxiedObj = Proxy.newProxyInstance(
                Client.class.getClassLoader(),  //参数1:必须给一个加载被代理对象的类加载器，注意通常要用与当前类相同的类加载器，否则生成的代理对象在当前类中无法使用
                new Class[]{IRenter.class},     //参数2:给一个接口数组，该数组中的所有接口将会是代理后的对象要实现的，同时也是以后通过这些接口调用代理后对象的方法(功能)
                new InvocationHandler() {   //参数3: 代理对象所有通过接口调用的方法都是通过下面的类反射方式调用的，我们可以在该反射方法中更改(拦截、增强)原型方法的功能
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args)
                            throws Throwable {

                        System.out.println("来了来了....."+method.getName());

                        Object res = method.invoke(r, args);//放行---原型对象执行当前方法

                        System.out.println("请交水电费.....");

                        return res;
                    }
                });

        IRenter ir = (IRenter) proxiedObj; //一定要用代理后的对象去执行方法，这样才有拦截功能
        ir.rent();
        //ir.toString();

        //注意，代理后的对象和原型对象是不同的类型，属父接口下的兄弟，相互间不能强转赋值
        //Renter r2 = (Renter) proxiedObj; //WA: java.lang.ClassCastException: $Proxy4 cannot be cast to cn.hncu.proxy.Renter
    }

下面是一个拦截list方法的案例

//想把java.util.List中的方法给拦截了
public class ProxyDemo2 {

    @Test
    public void demo(){
        List list = new ArrayList();
        list.add("aa");
        list.add(123);
        System.out.println(list.size());
        System.out.println(list.get(0));
    }

    @Test
    public void demo2(){
        Object ProxiedObj = Proxy.newProxyInstance(
                ProxyDemo2.class.getClassLoader(), 
                new Class[]{List.class}, 
                new MyInvocation());
        List list = (List) ProxiedObj;
        list.add("aa");
        list.add(123);
        System.out.println(list.size());
        System.out.println(list.get(0));

    }

    class MyInvocation implements InvocationHandler{
        List list = new ArrayList();  //原型对象
        @Override
        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            //System.out.println("马上执行:"+method.getName());
            if(args==null || args.length==0){ //把空参方法拦截，不放行
                System.out.println("空参:"+method.getName());
                return 0;
            }
            return method.invoke(list, args);
        }
    }
}

.写一个通用的拦截工具类
需求：利用一个通用的拦截工具类拦截两个不同的接口的实现类
两个接口以及他们的实现类

拦截工具类代码

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

public class ProxyUtil implements InvocationHandler{
    private  Object obj = null;
    private ProxyUtil(Object obj){
        this.obj = obj;
    }

    public static Object getProxj(Object obj){
        Object objs = Proxy.newProxyInstance(
                ProxyUtil.class.getClassLoader(), 
                obj.getClass().getInterfaces(), 
                new ProxyUtil(obj));
        return objs;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("拦截---");
        return method.invoke(obj, args);
    }

}

测试代码以及拦截结果

完成数据库连接池 close方法的拦截

package Studying.d16.Utils;

import java.io.FileInputStream;
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 ConnUtils4 {
    private static List<Connection> pool= new ArrayList<Connection>();
    private static final int Max = 3;
    private ConnUtils4(){
    }
    static{
        try {
            Properties p = new Properties();
            p.load( new FileInputStream("jdbc.properties"));
            String driver = p.getProperty("driver");
            String url = p.getProperty("url");
            String username = p.getProperty("username");
            String password = p.getProperty("password");

            Class.forName(driver);
            for(int i=0;i<Max;i++){
                final Connection con = DriverManager.getConnection(url, username, password);
                //使用动态代理,实现对con.close()方法的拦截
                Object proxiedobj = Proxy.newProxyInstance(
                        ConnUtils4.class.getClassLoader(), 
                        new Class[]{Connection.class}, //注意，jdbc包中con的类加载器应该不是AppClassLoader,所以此处采用“conn.getClass().getInterfaces()”方式不行
                        //上面一个参数，用将要把代理后对象强转的接口类型，是最保险的!

                        new InvocationHandler() {

                            @Override//proxy参数就是代理后的对象，如果在invoke()方法中使用代理后对象就用这个，如果在外面就用proxiedObj
                            public Object invoke(Object proxy, Method method, Object[] args)
                                    throws Throwable {
                                if(method.getName().equals("close")){//指定只拦截close()方法
                                    // 调用close的时候把 代理还回来~
                                    System.out.println("线程还回来一个连接");
                                    pool.add((Connection) proxy);
                                    return null;
                                }else{
                                    return method.invoke(con, args);
                                }
                            }
                        });
                // 一开始就使用代理
                pool.add((Connection) proxiedobj);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
    public static Connection getConn() throws InterruptedException{
        if(pool.size()<=0){
            System.out.println("池中暂时没了，请稍后...");
            Thread.sleep(1000);
            return getConn();
        }else{
            return pool.remove(0);
        }
    }
//  public static void back(Connection con){
//      System.out.println("往池中还回来一个....");
//      pool.add(con);
//  }
}