强悍的Spring之AOP动态代理实现

---

1、初识代理

Proxy代理模式是一种结构型设计模式，主要解决的问题是：在直接访问对象时带来的过度耦合问题

代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。

为了保持行为的一致性，代理类和委托类通常会实现相同的接口，所以在访问者看来两者没有丝毫的区别。通过代理类这中间一层，能有效控制对委托类对象的直接访问，也可以很好地隐藏和保护委托类对象，同时也为实施不同控制策略预留了空间，从而在设计上获得了更大的灵活性。

更通俗的说，代理解决的问题当两个类需要通信时，引入第三方代理类，将两个类的关系解耦，让我们只了解代理类即可，而且代理的出现还可以让我们完成与另一个类之间的关系的统一管理，但是切记，代理类和委托类要实现相同的接口，因为代理真正调用的还是委托类的方法。

使用场合举例：如果需要委托类处理某一业务，那么我们就可以先在代理类中统一处理然后在调用具体实现类

按照代理的创建时期，代理类可以分为两种：

静态：由程序员创建代理类或特定工具自动生成源代码再对其编译。在程序运行前代理类的.class文件就已经存在了。

动态：在程序运行时运用反射机制动态创建而成。

1.1 静态代理

接口：

public interface UserManager {
	void addUser(String userName);
}

实现类：

public class UserManagerImpl implements UserManager {
    @Override
    public void addUser(String userName) {
        System.out.println("UserManagerImpl add user name is:" + userName);
    }
}

代理类：

public class UserManagerImplProxy implements UserManager {
    private UserManagerImpl userManager;

    public UserManagerImplProxy(UserManagerImpl userManager) {
        this.userManager = userManager;
    }

    @Override
    public void addUser(String userName) {
        System.out.println("before add user, user name is :" + userName);
        this.userManager.addUser(userName);
        System.out.println("after add user, user name is :" + userName);
    }
}

客户端调用：

@Test
public void test_static_proxy() {
    UserManagerImplProxy proxy = new UserManagerImplProxy(new UserManagerImpl());

    proxy.addUser("steven");
}
输出：
before add user, user name is :steven
UserManagerImpl add user name is:steven
after add user, user name is :steven

优点：

代理使客户端不需要知道实现类是什么，怎么做的，而客户端只需知道代理即可（解耦合），对于如上的客户端代码，newUserManagerImpl()可以应用工厂将它隐藏，如上只是举个例子而已。

缺点：

1）代理类和委托类实现了相同的接口，代理类通过委托类实现了相同的方法。这样就出现了大量的代码重复。如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。

2）代理对象只服务于一种类型的对象，如果要服务多类型的对象。势必要为每一种对象都进行代理，静态代理在程序规模稍大时就无法胜任了。如上的代码是只为UserManager类的访问提供了代理，但是如果还要为其他类如Department类提供代理的话，就需要我们再次添加代理Department的代理类。

举例说明：代理可以对实现类进行统一的管理，如在调用具体实现类之前，需要打印日志等信息，这样我们只需要添加一个代理类，在代理类中添加打印日志的功能，然后调用实现类，这样就避免了修改具体实现类。满足我们所说的开闭原则。但是如果想让每个实现类都添加打印日志的功能的话，就需要添加多个代理类，以及代理类中各个方法都需要添加打印日志功能（如上的代理方法中删除，修改，以及查询都需要添加上打印日志的功能）

即静态代理类只能为特定的接口(Service)服务。如想要为多个接口服务则需要建立很多个代理类。

1.2 动态代理

根据如上的介绍，你会发现每个代理类只能为一个接口服务，这样程序开发中必然会产生许多的代理类

所以我们就会想办法可以通过一个代理类完成全部的代理功能，那么我们就需要用动态代理

在上面的示例中，一个代理只能代理一种类型，而且是在编译器就已经确定被代理的对象。而动态代理是在运行时，通过反射机制实现动态代理，并且能够代理各种类型的对象

在Java中要想实现动态代理机制，需要java.lang.reflect.InvocationHandler接口和 java.lang.reflect.Proxy 类的支持

java.lang.reflect.InvocationHandler接口的定义如下：

来看一下动态代理的代码：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

上面这个就是动态代理类（Proxy）类中的创建代理对象的方法，下面介绍一下方法的三个参数：

ClassLoader loader：方法需要动态生成一个类，这个类实现了需要代理的接口，然后创建这个类的对象。需要生成一个类，而且这个类也需要加载到方法区中，所以我们需要一个ClassLoader来加载该类

Class<?>[] interfaces：我们需要代理对象实现的数组

InvocationHandler h：调用处理器

@Test
public void test_dynamic_proxy() {
    /**
     * 三个参数
     * 1、ClassLoader
     * 方法需要动态生成一个类，这个类实现了UserManager接口，然后创建这个类的对象
     * 需要生成一个类，这个类也需要加载到方法区中，所以我们需要一个ClassLoader来加载该类
     *
     * 2、Class[] interfaces
     * 我们需要代理对象实现的数组
     *
     * 3、InvocationHandler
     * 调用处理器
     */
    ClassLoader classLoader = this.getClass().getClassLoader();
    //这里创建一个空实现的调用处理器。
    InvocationHandler invocationHandler = new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            return null;
        }
    };
    Object obj = Proxy.newProxyInstance(classLoader, new Class[]{UserManager.class}, invocationHandler);
    //强转为UserManager接口类型，说明生成的代理对象实现了UserManager接口
    UserManager userManager = (UserManager) obj;
    userManager.addUser("steven");
}

执行测试后我们可以发现什么也没有发生。这是因为我们根本没有为代理对象添加实现逻辑。可是实现逻辑添加在哪里呢？当然是InvocationHandler中了。下面就看一看添加了实现逻辑的代码：

@Test
public void test_dynamic_proxy() {
    ClassLoader classLoader = this.getClass().getClassLoader();
    InvocationHandler invocationHandler = new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("add user:" + Arrays.toString(args));
            return null;
        }
    };
    Object obj = Proxy.newProxyInstance(classLoader, new Class[]{UserManager.class}, invocationHandler);
    UserManager userManager = (UserManager) obj;
    userManager.addUser("steven");
}
输出：add user:[steven]

这里我们发现UserManager接口的实现逻辑都是调用了invoke这个方法中的逻辑，其实除了调用代理对象的native方法，调用代理对象的其他所有方法本质都是调用了invoke方法，invoke方法的返回值就是调用代理方法的返回值。

2.简易AOP

在我们对动态代理有了一定的认识之后，我们就可以实现最基本版本的AOP了，当然，这是一个非常残缺的AOP实现，甚至都不能称之为AOP实现。

public class UserManagerHandle implements InvocationHandler {
    private UserManager userManager;

    public UserManagerHandle(UserManager userManager) {
        this.userManager = userManager;
    }

    @Override
    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
        System.out.println("Before add user");
        this.userManager.addUser(String.valueOf(objects[0]));
        System.out.println("After add user");
        return null;
    }
}

测试：

@Test
public void test_aop() {
    ClassLoader classLoader = this.getClass().getClassLoader();
    UserManagerHandle userManagerHandle = new UserManagerHandle(new UserManagerImpl());
    Object obj = Proxy.newProxyInstance(classLoader, new Class[]{UserManager.class}, userManagerHandle);
    UserManager userManager = (UserManager) obj;

    userManager.addUser("steven");
}
//输出：
Before add user
UserManagerImpl add user name is:steven
After add user

你肯定要说了，这算什么AOP，增强的代码都是硬编码到invoke方法中的，大家稍安勿躁，我们不是已经对需要增强的对象做了增强吗。这里可以的目标对象为userManager，增强为System.out.println(“Before add user”);和System.out.println(“After add user”);，切点为addUser()方法调用。其实还是可以看做一下原始的AOP的。

3.完善AOP

我们从初步实现的AOP中可以发现很多问题，比如我们不能把增强的逻辑硬编码到代码中，我们需要实现可变的增强，下面我们就解决一下这些问题，来实现一个比较完善的AOP。

添加一个前置增强和后置接口：

public interface BeforeAdvice {
    void before();
}

public interface AfterAdvice {
    void after();
}

@Setter
public class ProxyFactory {
    private Object targetObject;//目标对象
    private BeforeAdvice beforeAdvice;//前值增强
    private AfterAdvice afterAdvice;//后置增强

    public ProxyFactory(Object targetObject) {
        this.targetObject = targetObject;
    }

    public Object creatProxy() {
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                // 在调用代理对象的方法时，会执行这里的内容
                if (beforeAdvice != null) {
                    beforeAdvice.before();
                }
                Object result = method.invoke(targetObject, args);//调用目标对象的目标方法
                //执行后续增强
                if (afterAdvice != null) {
                    afterAdvice.after();
                }
                //返回目标对象的返回值
                return result;
            }
        };
        ClassLoader classLoader = this.getClass().getClassLoader();
        //获取当前类型所实现的所有接口类型
        Class[] interfaces = targetObject.getClass().getInterfaces();
        //得到代理对象
        return Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
    }
}

测试：

@Test
public void test_aop() {
    ProxyFactory proxyFactory = new ProxyFactory(new UserManagerImpl());
    proxyFactory.setBeforeAdvice(() -> {
        System.out.println("before action");
    });
    proxyFactory.setAfterAdvice(() -> {
        System.out.println("after action");
    });

    UserManager userManager = (UserManager)proxyFactory.creatProxy();
    userManager.addUser("steven");
}
输出：
before action
UserManagerImpl add user name is:steven
after action

AOP（AspectOrientedProgramming）：将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码—解耦。

我们来看上面的UserManagerImplProxy类，它的两个方法System.out.println(“before action”)和System.out.println(“after action”)，这是做核心动作之前和之后的两个截取段，正是这两个截取段，却是AOP的基础，在OOP里，System.out.println(“before action”)、核心动作、System.out.println(“after action”)这个三个动作在多个类里始终在一起，但他们所要完成的逻辑却是不同的，如System.out.println(“before action”)里做的可能是权限的判断，在所有类中它都是做权限判断，而在每个类里核心动作却各不相同，System.out.println(“after action”)可能做的是日志，在所有类里它都做日志。正是因为在所有的类里，核心代码之前的操作和核心代码之后的操作都做的是同样的逻辑，因此我们需要将它们提取出来，单独分析，设计和编码，这就是我们的AOP思想。一句话说，AOP只是在对OOP的基础上进行进一步抽象，使类的职责更加单一。

动态代理优点：

动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。而且动态代理的应用使我们的类职责更加单一，复用性更强

4.总结

其实所谓代理，就是一个人或者一个机构代表另一个人或者另一个机构采取行动。在一些情况下，一个客户不想或者不能够直接引用一个对象，而代理对象可以在客户端和目标对象之前起到中介的作用。

代理对象就是把被代理对象包装一层，在其内部做一些额外的工作，比如用户需要上facebook,而普通网络无法直接访问，网络代理帮助用户先翻墙，然后再访问facebook。这就是代理的作用了。

纵观静态代理与动态代理，它们都能实现相同的功能，而我们看从静态代理到动态代理的这个过程，我们会发现其实动态代理只是对类做了进一步抽象和封装，使其复用性和易用性得到进一步提升而这不仅仅符合了面向对象的设计理念，其中还有AOP的身影，这也提供给我们对类抽象的一种参考。关于动态代理与AOP的关系，个人觉得AOP是一种思想，而动态代理是一种AOP思想的实现！

下面我把Spring中的ProxyFactory实现贴出来，大家可以研究一下Spring中的ProxyFactory的优势在哪里，另外，Spring中还有其他的基于动态代理实现的织入器，ProxyFactory只是其中最基础的版本，大家有兴趣可以研究一下。

public class ProxyFactory extends ProxyCreatorSupport {
    public ProxyFactory() {
    }

    public ProxyFactory(Object target) {
        this.setTarget(target);
        this.setInterfaces(ClassUtils.getAllInterfaces(target));
    }

    public ProxyFactory(Class... proxyInterfaces) {
        this.setInterfaces(proxyInterfaces);
    }

    public ProxyFactory(Class<?> proxyInterface, Interceptor interceptor) {
        this.addInterface(proxyInterface);
        this.addAdvice(interceptor);
    }

    public ProxyFactory(Class<?> proxyInterface, TargetSource targetSource) {
        this.addInterface(proxyInterface);
        this.setTargetSource(targetSource);
    }

    public Object getProxy() {
        return this.createAopProxy().getProxy();
    }

    public Object getProxy(@Nullable ClassLoader classLoader) {
        return this.createAopProxy().getProxy(classLoader);
    }

    public static <T> T getProxy(Class<T> proxyInterface, Interceptor interceptor) {
        return (new ProxyFactory(proxyInterface, interceptor)).getProxy();
    }

    public static <T> T getProxy(Class<T> proxyInterface, TargetSource targetSource) {
        return (new ProxyFactory(proxyInterface, targetSource)).getProxy();
    }

    public static Object getProxy(TargetSource targetSource) {
        if (targetSource.getTargetClass() == null) {
            throw new IllegalArgumentException("Cannot create class proxy for TargetSource with null target class");
        } else {
            ProxyFactory proxyFactory = new ProxyFactory();
            proxyFactory.setTargetSource(targetSource);
            proxyFactory.setProxyTargetClass(true);
            return proxyFactory.getProxy();
        }
    }
}