Spring源码-AOP（一）-代理模式

前言

之前已经完成了IOC的源码分析，接下来分析下AOP相关代码。在分析之前，先记录下aop的概念。

• 概念：作为面向对象编程的一种补充，经常用于一些具有横切性质的系统级服务，如事务，日志，安全等。AOP带来可以分为动态和静态两大类。
  • 其中静态带来指的是使用AOP框架提供的命令进行编译，从而在编译阶段生成AOP代理类，因此也称为编译时增强；
  • 而动态代理在在运行时借助于JDK动态代理、CGLIB等在内存中"临时"生成AOP动态代理类，因此也被称为运行时增强。
• 解决问题？
  一种技术的出现，肯定是存在之前解决不了的问题。而AOP作为面向对象的补充，解决哪些问题呢，让我们看看。

1.1 、Aop存在的意义

• 1、假如在项目中有多个模块公用了一个功能，之前的方法可能是每处copy一份，如下图
  
  
  
  这样很明显不代码复用的原则，并且如果有一天，图 1 中的深色代码段需要修改，那是不是要打开 3 个地方的代码进行修改。
• 2、可能有同学给出了新的解决方案，如下图
  
  
  将公用的方法抽取出来，这样确实是一种很好的解决方案。但是假如说，后来需求要求方法1添加日志，方法二做安全校验，方法三增加事务，这时候要我们修改方法1、2、3，而过了段时间又要改动。这个时候是不是已经崩溃。这个时候我们希望有一种特殊的方法：我们只要定义该方法，无须在方法 1、方法 2、方法 3 中显式调用它，系统会“自动”执行该特殊方法。
  这就是AOP了，AOP 专门用于处理系统中分布于各个模块（不同方法）中的交叉关注点的问题，在 Java EE 应用中，常常通过 AOP 来处理一些具有横切性质的系统级服务，如事务管理、安全检查、缓存、对象池管理等，AOP 已经成为一种非常常用的解决方案

1.2、AOP的概念

面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，高程序的可重用性，同时提高了开发的效率。主要有动态代理和静态代理两种实现。
根据代理类的生成时间不同可以将代理分为静态代理和动态代理两种。

代理模式一般涉及3个对象：

• 抽象角色：真实对象和代理对象的共有接口，对应（Subject）
• 真实角色：真实实现我们想要业务的实现类，对应（RealSubject）
• 代理角色：该角色内部含有对真实对象的引用，从而可以操作真实对象，对应（ProxySubject）
  两种实现：

1.3、静态代理：

先看代码
1、代理接口

/**
 * created by sunliangliang
 * 代理类接口，定义操作
 */
public interface Subject {
    /**
     * 处理任务
     * @param taskName 任务名称
     */
    public void dealTask(String taskName);
}

2、具体业务类

/**
 * created by sunliangliang
 * 真实处理业务的类，实现代理接口
 */
public class RealSubject implements Subject{
    @Override
    public void dealTask(String taskName) {
        System.out.println("--------【正在处理任务】-------");
        try {
            //休眠5s，模拟处理业务时间
            Thread.sleep(1000*5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

3、静态代理类

/**
 * created by sunliangliang
 * 静态处理类，实现接口
 */
public class ProxySubject implements Subject{
    //代理类持有一个委托类的对象引用
    private Subject delegate;
    public ProxySubject(Subject delegate){
        this.delegate = delegate;
    }

    /**
     * 请求分配给委托类执行，有委托类调用真实类实现具体功能
     * @param taskName 任务名称
     */
    @Override
    public void dealTask(String taskName) {
        long time = System.currentTimeMillis();
        delegate.dealTask(taskName);
        long endTime = System.currentTimeMillis();
        System.out.println("---------【花费时间】:"+(endTime-time));
    }
}

4、静态代理工厂类

/**
 * created by sunliangliang
 * 静态代理工厂
 */

public class SubjectStaticFactory {
    //客户类调用此工厂方法获得代理对象。
    //对客户类来说，其并不知道返回的是代理类对象还是委托类对象。
    public static Subject getInstance(){
        return new ProxySubject(new RealSubject());
    }
}

5、客户端调用类

/**
 * created by sunliangliang
 * 客户1
 */
public class Client {
    public static void main(String[] args) {
        Subject proxy = SubjectStaticFactory.getInstance();
        proxy.dealTask("DBQueryTask");
    }
}

静态代理的优缺点：

• 优点：业务类只需要关注业务逻辑本身，保证了业务类的重用性。这是代理的共有优点。
• 缺点：
  • 代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理，静态代理在程序规模稍大时就无法胜任了。
  • 如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度
  • 必须事先知道委托的角色，即真实类

1.4、动态代理：

动态代理类的源码是在程序运行期间由JVM根据反射等机制动态的生成，所以不存在代理类的字节码文件。代理类和委托类的关系是在程序运行时确定。

• 先看看jdk源码的实现，java.lang.reflect.Proxy，这是 Java动态代理机制生成的所有动态代理类的父类，它提供了一组静态方法来为一组接口动态地生成代理类及其对象。

Proxy类的静态方法

// 方法 1: 该方法用于获取指定代理对象所关联的调用处理器  
static InvocationHandler getInvocationHandler(Object proxy)   
  
// 方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象  
static Class getProxyClass(ClassLoader loader, Class[] interfaces)   
  
// 方法 3：该方法用于判断指定类对象是否是一个动态代理类  
static boolean isProxyClass(Class cl)   
  
// 方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例  
static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)  

• java.lang.reflect.InvocationHandler
  这是调用处理器接口，它自定义了一个 invoke（调用） 方法，用于集中处理在动态代理类对象上的方法调用，通常在该方法中实现对委托类的代理访问。每次生成动态代理类对象时都要指定一个对应的调用处理器对象。
  InvocationHandler核心方法

// 该方法负责集中处理动态代理类上的所有方法调用。第一个参数既是代理类实例，第二个参数是被调用的方法对象  
// 第三个方法是调用参数。调用处理器根据这三个参数进行预处理或分派到委托类实例上反射执行  
Object invoke(Object proxy, Method method, Object[] args);  

• java.lang.ClassLoader

这是类装载器类，负责将类的字节码装载到 Java 虚拟机（JVM）中并为其定义类对象，然后该类才能被使用。Proxy 静态方法生成动态代理类同样需要通过类装载器来进行装载才能使用，它与普通类的唯一区别就是其字节码是由 JVM 在运行时动态生成的而非预存在于任何一个 .class 文件中。
每次生成动态代理类对象时都需要指定一个类装载器对象

动态代理的实现

a. 实现InvocationHandler接口创建自己的调用处理器
b. 给Proxy类提供ClassLoader和代理接口类型数组创建动态代理类
c. 以调用处理器类型为参数，利用反射机制得到动态代理类的构造函数
d. 以调用处理器对象为参数，利用动态代理类的构造函数创建动态代理类对象

1、分步骤实现动态代理

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发  
// 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用  
InvocationHandler handler = new InvocationHandlerImpl(..);   
  
// 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象  
Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... }); 
  
// 通过反射从生成的类对象获得构造函数对象  
Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class });   
  
// 通过构造函数对象创建动态代理类实例  
Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });   

Proxy类的静态方法newProxyInstance对上面具体步骤的后三步做了封装，简化了动态代理对象的获取过程。

2、简化后的动态代理实现

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发  
InvocationHandler handler = new InvocationHandlerImpl(..);   
  
// 通过 Proxy 直接创建动态代理类实例  
Interface proxy = (Interface)Proxy.newProxyInstance( classLoader,   
     new Class[] { Interface.class },  handler ); 

3、动态代理的实现示例

创建自己的调用处理器

/**
 * created by sunliangliang
 */
/**
 * 动态代理类对应的调用处理程序类
 */
public class SubjectInvocationHandler implements InvocationHandler {
    //声明一个代理类
    private Object delegate;

    public SubjectInvocationHandler(Object delegate) {
        this.delegate = delegate;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long stime = System.currentTimeMillis();
        //利用反射机制将请求分派给委托类处理。Method的invoke返回Object对象作为方法执行结果。
        //因为示例程序没有返回值，所以这里忽略了返回值处理
        method.invoke(delegate, args);
        long ftime = System.currentTimeMillis();
        System.out.println("执行任务耗时"+(ftime - stime)+"毫秒");

        return null;
    }
}

生成动态代理对象的工厂，工厂方法列出了如何生成动态代理类对象的步骤

/**
 * 生成动态代理对象的工厂
 */
public class DynProxyFactory {
    public static Subject getInstance(){
        Subject delegate = new RealSubject();
        InvocationHandler handler = new SubjectInvocationHandler(delegate);
        Subject proxy = null;
        proxy = (Subject) Proxy.newProxyInstance(
                delegate.getClass().getClassLoader(),
                delegate.getClass().getInterfaces(),
                handler);
        return proxy;
    }
}

动态代理客户类

public class Client {  
  
 public static void main(String[] args) {  
  
  Subject proxy = DynProxyFactory.getInstance();  
  proxy.dealTask("DBQueryTask");  
 }   
}  

优缺点

• 优点：动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。在本示例中看不出来，因为invoke方法体内嵌入了具体的外围业务（记录任务处理前后时间并计算时间差），实际中可以类似Spring AOP那样配置外围业务
• 缺点：诚然，Proxy 已经设计得非常优美，但是还是有一点点小小的遗憾之处，那就是它始终无法摆脱仅支持 interface 代理的桎梏，因为它的设计注定了这个遗憾。回想一下那些动态生成的代理类的继承关系图，它们已经注定有一个共同的父类叫 Proxy。Java 的继承机制注定了这些动态代理类们无法实现对 class 的动态代理，原因是多继承在 Java 中本质上就行不通。
  有很多条理由，人们可以否定对 class 代理的必要性，但是同样有一些理由，相信支持 class 动态代理会更美好。接口和类的划分，本就不是很明显，只是到了 Java 中才变得如此的细化。如果只从方法的声明及是否被定义来考量，有一种两者的混合体，它的名字叫抽象类。实现对抽象类的动态代理，相信也有其内在的价值。此外，还有一些历史遗留的类，它们将因为没有实现任何接口而从此与动态代理永世无缘。如此种种，不得不说是一个小小的遗憾。

结束

下一章继续AOP相关的分析，从jdk代理的方式去实现，如下：
java代理的实现：

• CGLIB：
• jdkproxy：
  原文地址