由代理模式到AOP的实例分析

内容来自书籍《架构探险-从零开始写Java Web框架》的整理

代理模式

首先看什么是代理？

代理的英文单词是Proxy，意思是不用你自己去做某件事，而是指派一位代理去帮你做，完成的效果和你自己做是一样的！比如单就上班打卡来说，你自己打卡和别人帮你打卡，对于打卡任务来说，结果是一样的！

代理有下面几种：

1．静态代理

代码综述：

一个业务接口，

一个业务接口的实现类，

一个代理类，

一个测试类

业务接口类（这个是后面实例要实现的一个公共接口）：

package com.hm;
/**实际的主要的业务接口*/
public interface IHello {
    void sayHello();
}

业务接口实现类（这个是后面实例要代理的一个公共业务实现类，并且后续会有改动）

package com.hm;
import org.springframework.stereotype.Component;
/**实际的实现了业务接口的实现类，也是将要被代理的目标类*/
public class HelloImpl implements IHello{
    @Override
    public void sayHello() {
        System.out.println("hello in helloImpl");
    }
}

业务实现类的静态代理类

package com.hm.staticproxy;
import com.hm.HelloImpl;
import com.hm.IHello;
/**
 * 这是一个代理类，但是都这样代理的话，代理类会越来越多
 */
public class HelloProxy implements IHello{

    private HelloImpl helloImpl;
    
    public HelloProxy(){
        this.helloImpl = new HelloImpl();
    }
    
    @Override
    public void sayHello() {
        before();
        this.helloImpl.sayHello();
        after();
    }
    
    public void before(){
        System.out.println("before in helloProxy");
    }
    
    public void after(){
        System.out.println("after in helloProxy");
    }
}

测试类（没有使用Junit）：

package com.hm.staticproxy;
public class Test1 {
    public static void main(String[] args) {
        HelloProxy hp = new HelloProxy();
        hp.sayHello();
    }
}

可以看出静态代理类HelloProxy实现了和业务实现类HelloImpl实现了相同的接口IHello，在使用时，直接使用代理类就可以调用到实际的业务实现方法sayHello()，但是缺点也很明显，随着实现类变多，静态代理类也会随之变多，从而变成“类爆炸”。

2.JDK动态代理

使用JDK动态代理类会解决上述类爆炸的问题，只需要实现一个InvocationHandler接口就可以由JDK来生成你自己的代理类，比较方便。

JDK的动态代理类：

package com.hm.dynamicproxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
 * JDK的动态代理类只有一个，一个类即完成了各种代理任务
 * 但是被代理类必须实现某个接口才行
 * @author Administrator
 */
public class DynamicProxy implements InvocationHandler{

    private Object target;
    
    public DynamicProxy(Object target){
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object result = method.invoke(target, args);
        after();
        return result;
    }

    /**
     * 这个是为了方便特意优化的一点
     * 并且使用了泛型，不用每次强制转型
     * 由这个方法的参数this.target.getClass().getInterfaces()可以看出
     * 使用JDK的动态代理，被代理类必须实现最少一个接口
     * 否则 无法实现代理，这时候需要使用CGLib
     * @return
     */
    @SuppressWarnings("unchecked")
    public <T> T getProxy(){
        T t = (T) Proxy.newProxyInstance(
                this.target.getClass().getClassLoader(), 
                this.target.getClass().getInterfaces(), 
                this);
        return t;
        
    }
    
    public void before(){
        System.out.println("before in DynamicProxy");
    }
    
    public void after(){
        System.out.println("after in DynamicProxy");
    }
}

测试类如下：

package com.hm.dynamicproxy;

import java.lang.reflect.Proxy;
import com.hm.HelloImpl;
import com.hm.IHello;

public class Test2 {
    
    public static void main(String[] args) {
        Test2 t2 = new Test2();
        t2.test1();
        System.out.println("----------------------------");
        t2.test2();
    }
    
    //这个是直接使用动态代理的方式，不过每次使用都要重复写出newInstance的过程，可以优化
    public void test1(){
        IHello hello = new HelloImpl();
        DynamicProxy dp = new DynamicProxy(hello);
        //需要强制转型
        IHello helloProxy = (IHello) Proxy.newProxyInstance(
                hello.getClass().getClassLoader(), 
                hello.getClass().getInterfaces(), 
                dp);
        helloProxy.sayHello();
    }
    
    //这个也是直接使用动态代理的方式，不过生成代理的代码进行了优化
    public void test2(){
        IHello helloProxy = new DynamicProxy(new HelloImpl()).getProxy();
        helloProxy.sayHello();
    }
}

这样JDK动态代理类也实现了，并且只有一个代理类，很方便。但是，由这句代码

Proxy.newProxyInstance(

            this.target.getClass().getClassLoader(),

            this.target.getClass().getInterfaces(),

            this)

可以看出，第二个参数是返回业务类的父接口。那如果该业务类没有实现任何接口，JDK代理就无法使用了！

3.CGLib动态代理

Cglib是一个开源类库，这里使用它的话需要引入cglib.jar，可以自行下载

package com.hm.cglibproxy;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
/**
 * CGLib的代理不要求被代理类必须实现某接口，它是方法级别 的代理(拦截)
 * @author Administrator
 *
 */
public class CGLibProxy implements MethodInterceptor{

    private static CGLibProxy instance;

    public static CGLibProxy getInstance(){
        if(instance == null){
            instance = new CGLibProxy();
        }
        return instance;
    }
    
    @Override
    public Object intercept(Object obj, Method method, Object[] args,
            MethodProxy proxy) throws Throwable {
        before();
        Object result = proxy.invokeSuper(obj, args);
        after();
        return null;
    }
    
    public <T> T getProxy(Class<T> clazz){
        return (T) Enhancer.create(clazz, this);
    }
    
    public void before(){
        System.out.println("before in CGLibProxy");
    }
    
    public void after(){
        System.out.println("after in CGLibProxy");
    }
}

测试类如下：

package com.hm.cglibproxy;

import com.hm.HelloImpl;
import com.hm.IHello;

public class Test3 {

    public static void main(String[] args) {
        test1();
        System.out.println("--------------------------------");
        test2();
    }
    
    public static void test1(){
        CGLibProxy cp = new CGLibProxy();
        IHello helloProxy = cp.getProxy(HelloImpl.class);
        helloProxy.sayHello();
    }
    public static void test2(){
        IHello helloProxy = CGLibProxy.getInstance().getProxy(HelloImpl.class);
        helloProxy.sayHello();
    }
    
}

至此三种代理的简单实现就讲完了！

Spring AOP

下面就来看看AOP吧

AOP面向切面编程，横切逻辑…等等就不多说了

这里主要分为：前置增强，后置增强，环绕增强，异常抛出增强

需要引入spring的jar包，我这里使用的是3.2版本

Jar如下：

 

为了方便我直接把spring3.2的所有jar包都引入了

还是来实现之前的业务接口IHello，代理之前的实现类HelloImpl吧

编程式：

前置增强

代码如下：

package com.hm.spring;

import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;
/**
 * 前置增强
 * @author Administrator
 */
public class HelloBeforeAdvice implements MethodBeforeAdvice {
    @Override
    public void before(Method arg0, Object[] arg1, Object arg2)
            throws Throwable {
        System.out.println("Before in HelloBeforeAdvice");
    }
}

后置增强

package com.hm.spring;

import java.lang.reflect.Method;
import org.springframework.aop.AfterReturningAdvice;
/**
 * 后置增强
 * @author Administrator
 */
public class HelloAfterAdvice implements AfterReturningAdvice{

    @Override
    public void afterReturning(Object arg0, Method arg1, Object[] arg2,
            Object arg3) throws Throwable {
        System.out.println("After in HelloAfterAdvice");
    }
}

测试类如下

（这个是后面spring的公共测试类，后面会改动，注意文件名）

package com.hm.spring;

import org.springframework.aop.framework.ProxyFactory;
import com.hm.HelloImpl;
import com.hm.IHello;

public class ClientTest {
    public static void main(String[] args) {
        test1();
        System.out.println("------------------");
        test2();
    }
    
    /**
     * 前置增强
     */
    static void test1(){
        //创建代理工厂
        ProxyFactory pf = new ProxyFactory();
        //射入目标类对象
        pf.setTarget(new HelloImpl());
        //添加前置增强
        pf.addAdvice(new HelloBeforeAdvice());
        //添加后置增强
        pf.addAdvice(new HelloAfterAdvice());
        //从方法中获取代理
        IHello hello = (IHello) pf.getProxy();
        //调用代理的方法
        hello.sayHello();    
}
    /**
     * 后置增强
     */
    static void test2(){
        ProxyFactory pf = new ProxyFactory();
        pf.setTarget(new HelloImpl());
        pf.addAdvice(new HelloBeforeAfterAdvice());
        
        IHello hello = (IHello) pf.getProxy();
        hello.sayHello();
    }
}

运行结果如下：

Before in HelloBeforeAdvice

hello in helloImpl

After in HelloAfterAdvice

------------------

before in HelloBeforeAfterAdvice

hello in helloImpl

after in HelloBeforeAfterAdvice

 

环绕增强

也可以定义一个增强类，同时实现这两个接口，这就形成了环绕增强

package com.hm.spring;

import java.lang.reflect.Method;
import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.MethodBeforeAdvice;

/**
 * 实现两个接口，共同完成环绕增强
 * @author Administrator
 */
public class HelloBeforeAfterAdvice implements     MethodBeforeAdvice,AfterReturningAdvice{

    @Override
    public void before(Method arg0, Object[] arg1, Object arg2)
            throws Throwable {
        System.out.println("before in HelloBeforeAfterAdvice");    
    }
    
    @Override
    public void afterReturning(Object arg0, Method arg1, Object[] arg2,
            Object arg3) throws Throwable {
        System.out.println("after in HelloBeforeAfterAdvice");    
    }
}

同时也可以直接实现MethodInterceptor接口从而实现环绕增强，该接口不是spring提供的，而是AOP联盟写的，spring只是借用了它，故需要引入aopalliance.jar

如下：

package com.hm.spring;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
/**
 * 环绕增强
 * @author Administrator
 *
 */
public class HelloAroundAdvice implements MethodInterceptor{

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        before();
        Object result = invocation.proceed();
        after();
        return result;
    }
    
    private void before(){
        System.out.println("before in HelloAroundAdvice");
    }
    private void after(){
        System.out.println("after in HelloAroundAdvice");
    }
}

声明式

先提供一个spring的配置文件，beans.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:tx="http://www.springframework.org/schema/tx" 
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd  
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd  
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd  
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd">

    <!-- 自动包扫描 -->
<context:component-scan base-package="com.hm" />
    
    <bean id="helloProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <!-- 需要代理的接口 ，注意是value-->
        <property name="interfaces" value="com.hm.IHello"/>
        <!-- 接口的实现类(目标类)，注意是ref，指向一个bean -->
        <property name="target" ref="HelloImpl"/>
        <!-- 拦截器名称，即增强类的名称,spring bean的id -->
        <property name="interceptorNames">
            <list>
                <value>HelloAroundAdvice</value>
<value>HelloAfterAdvice</value>
<value>HelloBeforeAdvice</value>
            </list>
        </property>
        <!--仅一个增强类时可以像如下配置--> 
        <!--
        <property name="interceptorNames" value="HelloAroundAdvice"/>
         -->
    </bean>
</beans>

主要注意的地方有：

1:

        <!-- 接口的实现类(目标类)，注意是ref，指向一个bean -->
        <property name="target" ref="HelloImpl"/>

这里使用的是ref配置，所以HelloImpl是一个bean的名字，由于使用声明式配置，所以需要在公共业务实现类HelloImpl.java中添加一个注解，如下：

……
@Component("HelloImpl")
public class HelloImpl implements IHello{
……

2：

        <!-- 拦截器名称，即增强类的名称,spring bean的id -->
        <property name="interceptorNames">

这里同样是bean的名字，故需要在这上个增强类上添加注解：

@Component("HelloBeforeAdvice")
public class HelloBeforeAdvice implements MethodBeforeAdvice {


@Component("HelloAfterAdvice")
public class HelloAfterAdvice implements AfterReturningAdvice{

@Component("HelloAroundAdvice")
public class HelloAroundAdvice implements MethodInterceptor{

这样在公共测试类ClientTest.java里面添加两个方法：

    /**
     * 环绕增强
     * 编程式
     */
    static void test3(){
        ProxyFactory pf = new ProxyFactory();
        pf.setTarget(new HelloImpl());
        pf.addAdvice(new HelloAroundAdvice());
        
        IHello hello = (IHello) pf.getProxy();
        hello.sayHello();
    }
    
    /**
     * 测试annotation版本的环绕增强
     * 声明式
     */
    static void test4(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        IHello hello = (IHello) context.getBean("helloProxy");
        hello.sayHello();
    }

然后在main方法里面执行，结果如下：

before in HelloAroundAdvice

Before in HelloBeforeAdvice

hello in helloImpl

After in HelloAfterAdvice

after in HelloAroundAdvice

可以看出相比前置和后置增强，环绕增强的结果在更前更后的位置

异常抛出增强

代码如下：

package com.hm.spring;

import java.lang.reflect.Method;
import org.springframework.aop.ThrowsAdvice;
import org.springframework.stereotype.Component;

/**
 * 异常抛出增强
 * @author Administrator
 *
 */
@Component("HelloThrowAdvice")
public class HelloThrowAdvice implements ThrowsAdvice{
    
    public void afterThrowing(Method method,Object[] args,Object target,Exception e){
        System.out.println("-------Throw Exception------");
        System.out.println("Target Class: " + target.getClass().getName());
        System.out.println("Method Name: " + method.getName());
        System.out.println("Exception Message: " + e.getMessage());
        System.out.println("---------------------------");
    }
}

直接在beans.xml中配置该bean：

<bean id="helloThrowProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="interfaces" value="com.hm.IHello"/>
        <property name="target" ref="HelloThrowsImpl"/>
        <property name="interceptorNames" value="HelloThrowAdvice"/>
    </bean>

在测试方法ClientTest.java中添加测试方法：

/**
     * 测试异常抛出增强
     */
    static void test5(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        IHello hello = (IHello) context.getBean("helloThrowProxy");
        hello.sayHello();
    }

在main方法中测试如下：

正是我们抛出的异常，已经被拦截（捕获，增强），拿到这些异常信息，则可以将其写到日志，持久化到数据库中。

引入增强

如果某个类实现了接口A，但是没有实现接口B，那么该类是否可以调用B中的方法呢？

通过引入增强则可以做到（只能说厉害）

首先在加入另外一个接口IApology

package com.hm;

/**
 * 不相关的接口
 * HelloImpl没有实现该接口，但是在ClientTest#test6()中却可以看到这样的调用
 * IApology apology = (IApology) helloImpl;
 * apology.saySorry();
 * 将HelloImpl转型为IApology即可以调用
 * @author Administrator
 *
 */
public interface IApology {

    void saySorry();
}

可以看到业务实现类HelloImpl并没有实现IApology接口，但是却想在程序运行的时候动态实现它，同时，如果HelloImpl业务很复杂，代码很多，并不想改动它的代码。怎么做呢？

借助一个spring的引入增强：

package com.hm.spring;

import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.support.DelegatingIntroductionInterceptor;
import org.springframework.stereotype.Component;
import com.hm.IApology;

/**
 * 简述：
 * 某个类实现了A接口，但是没有实现B接口，那么该类是否可以调用B接口的方法呢？
 * 使用下面的代理即可
 * 这是对类的增强-Introduction Advice
 * @author Administrator
 *
 */
@Component("HelloIntroAdvice")
public class HelloIntroAdvice extends DelegatingIntroductionInterceptor implements IApology{

    public Object invoke(MethodInvocation invocation) throws Throwable{
        return super.invoke(invocation);
    }
    
    @Override
    public void saySorry() {
        System.out.println("sorry in HelloIntroAdvice");
    }
}

在beans.xml中配置该bean：

<bean id="helloIntroProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="interfaces" value="com.hm.IApology"/>
        <property name="target" ref="HelloImpl"/>
        <property name="interceptorNames" value="HelloIntroAdvice"/>
        <!-- 代理目标的类：true表示spring用CGLib做代理，false表示用JDK的动态代理 -->
        <property name="proxyTargetClass" value="true"/>
    </bean>

在ClientTest中添加测试方法：

    /**
     * 测试织入增强
     */
    static void test6(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //这里转为目标类，而不是它的接口类
        HelloImpl helloImpl = (HelloImpl) context.getBean("helloIntroProxy");
        helloImpl.sayHello();
        //将目标类强制 向上转型为IApology接口--"接口动态代理"
        IApology apology = (IApology) helloImpl;
        apology.saySorry();
    }

在main方法中执行如下：

 

可以看到，最终通过强制类型转换实现了由helloImpl到apology的转化，从而调用到了saySorry()方法，真腻害！

测试拦截方法的数量：

测试上述方式会对公共接口的所有方法进行拦截：

修改接口，添加一个方法如下：

package com.hm;

/**
 * 实际的主要的业务接口
 * @author Administrator
*/
public interface IHello {
    
    void sayHello();
    
    void sayHelloToo();

}

仅仅在HelloImpl中实现该方法：

    @Override
    public void sayHelloToo() {
        System.out.println("say hello too");
    }

修改ClientTest中test1()方法

    static void test1(){
        //创建代理工厂
        ProxyFactory pf = new ProxyFactory();
        //射入目标类对象
        pf.setTarget(new HelloImpl());
        //添加前置增强
        pf.addAdvice(new HelloBeforeAdvice());
        //添加后置增强
        pf.addAdvice(new HelloAfterAdvice());
        //从方法中获取代理
        IHello hello = (IHello) pf.getProxy();
        //调用代理的方法
        hello.sayHello();
        hello.sayHelloToo();
    }

仅仅需要调用一下sayHelloToo方法即可

其他实现了IHello接口的实现类不要改动

此时HelloImpl实现了两个方法：sayHello()和sayHelloToo()，运行ClientTest中的test1()方法，结果如下：

Before in HelloBeforeAdvice

hello in helloImpl　　（注意这个）

After in HelloAfterAdvice

Before in HelloBeforeAdvice

say hello too　　（注意这个）

After in HelloAfterAdvice

可以看出，两个方法均被拦截（增强）了，故上述方式会对被代理类的所有接口实现类进行增强

还原回原来的IHello,HelloImpl,ClientTest代码吧

AOP切面

由上面的测试可以看出之前的代理都是对类级别的拦截，会拦截类里面的所有方法，而在实际情况中，一般只需要拦截特定的方法就行了，这里需要引入Advisor切面的概念了，它是将增强类与拦截匹配条件组合在一起，然后将这个切面配置到ProxyFactory中，从而生成代理。

既然需要拦截特定的方法，那么肯定需要提供一个拦截的条件，即什么样的方法可以被增强，Spring AOP提供了一些切面类，最常见的就是正则表达式的切面类，实例如下：

在HelloImpl中添加两个方法，一个以good开头，另一个不是，并且都不是接口中的方法，如下：

    /**
     * 该方法以good开头，故调用的时候会被拦截（增强），可以参见beans.xml的配置
     */
    public void goodMorning(){
        System.out.println("goodMorning in HelloImpl");
    }
    
    /**
     * 为了区分goodMorning方法，该方法不以good开头，故调用的时候不会被拦截（增强）
     */
    public void notGoodAfternoon(){
        System.out.println("not goodMorning in HelloImpl");
    }

在beans.xml中添加bean配置：

<!-- 配置一个切面 -->
    <bean id="helloAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <property name="advice" ref="HelloAroundAdvice"></property>
        <property name="pattern" value="com.hm.HelloImpl.good.*"></property>
    </bean>
    
    <!-- 配置一个代理 -->
    <bean id="helloImplProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target" ref="HelloImpl"></property>
        <property name="interceptorNames" value="helloAdvisor"></property>
        <property name="ProxyTargetClass" value="true"></property>
    </bean>

其中

<property name="pattern" value="com.hm.HelloImpl.good.*"></property>

com.hm.HellImpl.good.*表示匹配HelloImpl类中以good开头的方法，即拦截这些被匹配了的方法

在ClientTest中添加方法：

    /**
     * 测试自定义方法增强（拦截）
     */
    static void test7(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //这里转为目标类，而不是它的接口类
        HelloImpl helloImpl = (HelloImpl) context.getBean("helloImplProxy");
        helloImpl.sayHello();
        System.out.println("-------------------------");
        //可以看出只有goodMorning方法被拦截（增强）了
        helloImpl.goodMorning();
        System.out.println("-------------------------");
        helloImpl.notGoodAfternoon();
    }

在main方法中运行：

hello in helloImpl

-------------------------

before in HelloAroundAdvice

goodMorning in HelloImpl

after in HelloAroundAdvice

-------------------------

not goodMorning in HelloImpl

可以看出只有以good开头的方法被拦截（增强）了

待续。。

 工程截图：

jar包截图：