Spring源码分析spring源码

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

2017-08-28  本文已影响312人  阿亮私语

前言

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

1.1 、Aop存在的意义

1.2、AOP的概念

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


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

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根据反射等机制动态的生成，所以不存在代理类的字节码文件。代理类和委托类的关系是在程序运行时确定。

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)  


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

这是类装载器类，负责将类的字节码装载到 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");  
 }   
}

优缺点

结束

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

上一篇下一篇

猜你喜欢

热点阅读