动态代理

jdk动态代理,代理模式的一种，只能代理接口。

必要条件就是  代理类必须实现InvocationHandler 接口，被代理的类必须是实现接口的类。

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


/**
 * 动态代理类，jdk动态代理的核心。
 * 代理类必须实现InvocationHandler并实现invoke方法，"增强"的位置就在这里
 */
public class Dtdl implements InvocationHandler {

    private Object insta;

    public Dtdl(Object insta1) {
        insta = insta1;
    }

    /**
     * 获取代理对象的接口
     * 方法返回值使用泛型，这样调用的地方就可以不用强转了。
     * @param 
     * @return
     */
    public  T getProxy(){
     return (T) Proxy.newProxyInstance(insta.getClass().getClassLoader(),insta.getClass().getInterfaces(),this);
    }


    /**
     *
     * @param proxy  这个参数可以使用反射获取代理类的对象信息，可以将代理对象返回进行连续调用。基本用不上
     * @param method  被代理的方法
     * @param args 被代理的类的参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("前置增强"+args[0]);
        args[0]= (Integer)args[0]+2 ;
        Object o  = method.invoke(insta,args);
        System.out.println("后置增强");

        return o;
    }
}

/**
 * 动态代理是基于接口实现的，目标类必须实现了接口，并且必须是接口中的方法
 */
interface MovenInt {

     int mytest(int b);
}

/**
 * 被代理的类既实现了父接口的一个子类
 */
class Moven implements MovenInt{


    /**
     * 能被代理类执行的方法是实现于接口的，
     * 接口中没有的话调用不到
     * @param b
     * @return
     */
    public int mytest(int b){

        System.out.println(b);
        return 0;
    }


}

/**
 * 测试类，里边就一个main方法，里边描述了动态代理的调用的方式
 */
class TestMy{


    /**
     *
     * @param args
     */
    public static void main(String[] args) {
        //用动态代理类提供的方法获取到被代理类实现的接口。
        MovenInt d  = new Dtdl(new Moven()).getProxy();
        int i = d.mytest(5);
        System.out.println("结束"+ i);
    }
}