Aop动态代理和cglib

一般我们使用Aop对象时，常用动态代理模式，即是采用映射一个相同的类在此基础上进行前置后置操作。

动态代理多是采用原类实现父类接口，然后动态代理一个和原类相同的双胞胎兄弟类来实现映射。

父类

public interface InterF {
    public  void save();
}

需要映射的类

public class Origin implements InterF{
    @Override
    public void save() {
        System.out.println("测试一下");
    }
}

动态代理映射，此类需要传入相应的原类对象

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

/**
 * @author bai
 * @create 2019-10-25-16:47
 */
public class ProxyJdk implements InvocationHandler {

    private Object target;

    public Object getProxy(Object target){
        this.target=target;
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);

    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("我来了");
        Object invoke = method.invoke(target, args);
        System.out.println("我走了");
        return invoke;
    }
}

测试类

public class Mytest {


    public static void main(String[] args) {
        Origin o=new Origin();
        ProxyJdk pj=new ProxyJdk();
        InterF proxy = (InterF) pj.getProxy(o);

        proxy.save();
    }
}

cglib模式的代理和动态代理大同小异，模式上相同，但cglib采用的是直接实现父子类，继承原类来实现映射。

原类

public class Origin{
    public void save() {
        System.out.println("测试一下");
    }
}

cglib映射类，此类也需要传入原类

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * @author bai
 * @create 2019-10-25-17:26
 */
public class CglibProxy implements MethodInterceptor{
    private Object target;//被代理目标

    public Object getProxy(Object target){
        this.target=target;
        Enhancer enhancer = new Enhancer();
//1.设置基类
        enhancer.setSuperclass(target.getClass());
//2.设置回调接口
        enhancer.setCallback(this);//MethodInterceptor实现类
//3.创建动态代理
        return enhancer.create();
    }
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("准备前");
        Object invoke = method.invoke(target, objects);
        System.out.println("准备后");
        return invoke;
    }
}

o是传入的对象，method是相应的切点所切方法，objects即参数。

测试类

public class Mytest2 {
    public static void main(String[] args) {
        Origin o=new Origin();
        CglibProxy cp=new CglibProxy();
        Origin proxy = (Origin) cp.getProxy(o);
        proxy.save();
    }
}

cglib相对于动态代理少了一个父类，更加便捷。且cglib使用时需要导入相应的jar包