java动态代理学习笔记

动态代理步骤
1.创建一个实现接口InvocationHandler的类，它必须重写invoke方法
2.创建被代理的类以及接口
3.通过Proxy的静态方法
    newProxyInstance(ClassLoader loder,Class[] interfaces,InvocationHandler h)创建一个代理

4.通过代理创建调用方法

InvocationHandler接口：
public interface InvocationHandler {
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable;
}
参数说明：
Object proxy：指被代理的对象。
Method method：要调用的方法
Object[] args：方法调用时所需要的参数

可以将InvocationHandler接口的子类想象成一个代理的最终操作类，替换掉ProxySubject。

Proxy类：
Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)throws IllegalArgumentException
参数说明：
ClassLoader loader：类加载器
Class<?>[] interfaces：得到全部的接口
InvocationHandler h：得到InvocationHandler接口的子类实例

实例：

package com.test.proxy;

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

/**
 *
 *@author Joshua
 *创建一个实现接口InvocationHandler的类
 */
public class Agence implements InvocationHandler{
    private Object target;
    
    //绑定委托对象并返回一个代理类 
    public Object connect(Object target){
        this.target = target;
        System.out.println(target.getClass());
        Class<?> classType = target.getClass();
        //创建一个代理
        return Proxy.newProxyInstance(classType.getClassLoader(),classType.getInterfaces(),this);
    }
    @Override
    //重写invoke方法 
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(proxy.getClass().getInterfaces());
        before(args);
        Object result = method.invoke(target, args);
        after();
        return result;
    }
    
    private void before(Object[] args){
        System.out.print("调用方法之前的参数是: ");
        for(Object arg:args){
            System.out.println(arg);
        }
    }
    
    private void after(){
        System.out.println("调用方法之后！");
    }

}

package com.test.proxy;

/**
 *
 *@author Joshua
 *
 */
public interface House {
    public void rent(String address);
}

package com.test.proxy;

/**
 * 
 * @author Joshua
 * 
 */
public class HouseImpl implements House{

    public void rent(String address) {
        System.out.println("租到的房子在  "+address);
    }
}

//测试

package com.test.proxy;

import java.util.ArrayList;
import java.util.List;

/**
 *
 *@author Joshua
 *
 */
public class ProxyTest {
public static void main(String[] args) {
    
    Agence lettingAgence = new Agence();
    House house = (House) lettingAgence.connect(new HouseImpl());
    //通过代理创建调用方法
    house.rent("龙泽城铁口");
    System.out.println(house.getClass());
    //因为代理类中是Object类型 所以你可以通过代理类调用其他的类
   Agence vectorProxy = new Agence(); 
   List a = (List)vectorProxy.connect(new ArrayList());
   a.add("呼和浩特");
   a.add("济南");
   a.add("北京");
}
}

关于 public Object invoke(Object proxy,Method method,Object[] args) throws Throwable

方法中的proxy代理实例的作用：

如果你调用proxy除了getClass()方法外的任何方法他都会报异常，还会无限调用invoke方法

但是只要有了proxy.getClass()还有什么做不了的呢？从而可以获得关于proxy代理实例的所有类信息，如方法列表，Annotation等，这就为我们提供的一个分析proxy的有力工具，如通过分析Annotation分析方法的声明式事务需求。

参考：菈普蘭徳、java动态代理（JDK和cglib）