jdk动态代理和Cglib动态代理

jdk动态代理是基于反射,只能对实现了接口的类生成代理；cglib动态代理是基于继承的，针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法

jdk动态代理

首先编写一个接口MyInterface

**
 * @version: 1.00.00
 * @description:
 * @author: panfan
 * @date: 2018/9/10 16:32
 * @history:
 */
public interface MyInterface {

    void print();

    void print(String value);
}

然后是接口的实现类

/**
 * @version: 1.00.00
 * @description:
 * @author: panfan
 * @date: 2018/9/10 16:33
 * @history:
 */
public class Target implements MyInterface {

    @Override
    public void print() {
        System.out.println("target print");
    }

    @Override
    public void print(String value) {
        System.out.println("target print === " + value);
    }
}

编写代理类

/**
 * @version: 1.00.00
 * @description: jdk动态代理类可以设置对一个接口中所有方法都执行同一类型操作，而不需像静态代理一样，每个方法都得设置
 * @author: panfan
 * @date: 2018/9/10 16:50
 * @history:
 */
public class DynamicProxy implements InvocationHandler {

    // 被代理的实例
    private MyInterface myInterface;

    public DynamicProxy(MyInterface myInterface) {
        this.myInterface = myInterface;
    }


    public MyInterface create(){
        return (MyInterface) Proxy.newProxyInstance(
                myInterface.getClass().getClassLoader(),
                myInterface.getClass().getInterfaces(),
                this);
    }

    // 实现在接口中的每个方法前后都打印当前时间
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(System.currentTimeMillis() + "======before");
        method.invoke(myInterface, args);
        System.out.println(System.currentTimeMillis() + "======after");
        return null;
    }

}

main函数测试一下

public class DynamicProxyMain {

    public static void main(String[] args) {
        // 真实对象
        MyInterface realTarget = new Target();
        // 中介类
        DynamicProxy dynamicProxy = new DynamicProxy(realTarget);
        //动态产生一个代理类
        MyInterface proxy = dynamicProxy.create();
        //通过代理类，执行doSomething方法；
        proxy.print();
        proxy.print("panfan");
    }
}

可以看到如下结果

CGLIB动态代理

还是使用刚才实现类Target，当做普通类来使用

 

/**
 * @version: 1.00.00
 * @description: Cglib的动态代理是基于继承的，所以有final修饰的类不能代理
 * @author: panfan
 * @date: 2018/9/11 8:58
 * @history:
 */
public class CglibProxy implements MethodInterceptor {

    private Object target;//业务类对象，供代理方法中进行真正的业务方法调用

    public Object bind(Object target){
        this.target = target;  //给业务对象赋值
        Enhancer enhancer = new Enhancer(); //创建加强器，用来创建动态代理类
        enhancer.setSuperclass(this.target.getClass());  //为加强器指定要代理的业务类（即：为下面生成的代理类指定父类）
        //设置回调：对于代理类上所有方法的调用，都会调用CallBack，而Callback则需要实现intercept()方法进行拦
        enhancer.setCallback(this);
        // 创建动态代理类对象并返回
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("cglib before    --------------------");
        Object ob = methodProxy.invokeSuper(o, objects);
        System.out.println("cglib after     --------------------");
        return ob;
    }
}

main函数测试一下

public static void main(String[] args) {
        // 创建接口实现类
        Target target = new Target();
        // 创建代理类
        CglibProxy cglibProxy = new CglibProxy();
        // 获得代理生成的对象，传入的实现类是生成的代理类的父类
        Target target1 = (Target) cglibProxy.bind(target);
        target1.print();
        target1.print("panfan");
    }

可以看到如下效果

日后补充spring aop的介绍。。先水到这。