aop(面向切面编程)在Java中的两种动态代理实现

Aop(面向切面编程)的实现核心是通过代理模式对目标进行增强的一种技术，他的目的在于解耦合，自我感觉编程不是在解耦合就是在去解耦合的路上~~

在Java语言中，有两种实现Aop的方式，JDK和cjlib

Jdk的实现方式是通过java.lang.reflect包下的动态代理类newProxyInstance实现的，我在之前的动态代理模式这篇博客中有详细记录这个方法的参数。

之前在动态代理模式这篇博客中模拟增强是打印的一句话代表增强，这里记录一下是怎么通过增强类来增强目标类的。

JDk的代理是通过接口来实现的，目标类和匿名增强逻辑类都要实现(匿名增强逻辑类用接口接受参数)同一个接口。

/**
 * 接口
 */
public interface TargetInterface {
    public void save();
}

/**
 * 目标类
 */
public class Target implements TargetInterface {
    public void save() {
        System.out.println("save Runing......");
    }
}

/**
 * 增强类
 */
public class Advice {
    /**
     * 前置增强
     */
    public void before()
    {
        System.out.println("前置方法Runing.....");
    }

    /**
     * 后置增强
     */
    public void After()
    {
        System.out.println("后置方法Runing.....");
    }
}

public static void main(String[] args) {
        final Target target = new Target();//目标类
        final Advice advice = new Advice();//增强类
        //jdk动态代理的实现方式
        TargetInterface o = (TargetInterface) Proxy.newProxyInstance(
                Target.class.getClassLoader(), //目标对象类加载器
                Target.class.getInterfaces(), //目标接口类加载器
                new InvocationHandler() {//代理增强逻辑实现
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
                    {
                        advice.before();//前置增强
                        Object invoke = method.invoke(target, args);//原始方法
                        advice.After();//后置增强

                        return invoke;
                    }
        });
        o.save();

    }

cjlib动态代理的实现方式不需要对接口进行定义(需要使用Cjlib的依赖包),相当于将目标类当作父类，匿名的具体增强逻辑增强类是子类，可以直接使用父类(目标类)进行参数的接收

/**
 * 目标类
 */
public class Target {
    public void save() {
        System.out.println("save Runing......");
    }
}

这个目标类与上面的目标类区别是没有实现接口，增强类未作改动

public static void main(String[] args) {
        final Target target = new Target();//目标类
        final Advice advice = new Advice();//增强类
        //cjlib动态代理的实现方式

        //1.设置增强器
        Enhancer enhancer = new Enhancer();
        //2.设置父类，目标
        enhancer.setSuperclass(target.getClass());
        //3。设置回调
        enhancer.setCallback(new MethodInterceptor() {
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                advice.before();
                Object invoke = method.invoke(target, objects);
                advice.After();
                return invoke;
            }
        });
        //4.创建代理对象
        Target o = (Target) enhancer.create();
        o.save();
    }

注意：这里的匿名内部逻辑实现类是通过实例化一个MethodInterceptor，而jdk的是通过InvocationHandler。

ok~,分享结束~