Spring in Action 4th 学习笔记 之 AOP

前提：本文中的AOP仅限于Spring AOP。

 

先说说为什么需要AOP

 

最简单的一个例子就是日志记录，如果想记录一些方法的执行情况，最笨的办法就是修改每一个需要记录的方法。但这，真的很笨。。。

好的方法，应该是通过反射获取方法，然后去匹配，如果需要记录日志，那就调用日志方法即可。

这就是AOP 的Weaving，俗称编织、织入，就是将需要添加的功能编织到现有功能中，而不需要修改现有代码。

 

另一个例子，不那么大众的需求：我想给一个对象添加方法，怎么实现？

如果有学过js、Python等动态语言，你肯定知道它们支持给对象添加方法，直接添加即可。

但是Java不行，因为Java的类型是封闭的。

Spring给出办法就是通过代理，拦截请求，然后去调用实际拥有该方法的对象的该方法！（略绕） 这就是Introduction，俗称引入。

如图：

这是书中自带的图片，很形象。

如图所示，如果调用Advised bean的Existing method，那就是Weaving（织入）；如果调用introduced method，那就是Introduction。

但是，无论那种，Spring都是通过其代理功能实现的。（如果你已经知道Spring的代理功能仅限于method，那你也可以想到Spring AOP仅限于method --- 稍后讨论）

 

以上，记住一点就行：Spring AOP中，给方法添加功能就是织入，给对象添加功能就是引入。

（至于为什么强调是Spring AOP，这是因为还有其他的AOP框架，稍后讨论。）

 

再列一下其他概念：

Weaving织入部分：

　　Advice ： 需要添加的功能，例如日志功能、权限功能等，以及什么时候添加（目标方法执行前、后、异常等时候）。

　　Join-point ： 目标类中能够添加功能的地方！

　　Pointcut ： 指定目标类中添加功能的地方！因为不可能给所有Join-point织入Advice！（Spring AOP仅限于方法，因为它基于代理实现。其他的框架还可以针对字段添加功能！了解就行。）

　　需要注意的是，Advice定义了什么时候做、做什么，而Pointcut则定义了在哪里做。

　　Aspect = Advices + Pointcuts     // Aspect可以认为是一堆Advice的类，且其中指定了每个Advice执行的Pointcut。

 

Introduction引入部分：

　　暂无

 

以上，Pointcut是关键，它决定了一个AOP框架的行为。

因为Pointcut意味着where（field？method？exception？）和when（编译时？加载时？运行时？）。

【】通常，使用class和method name来定义Pointcut，或者使用正则表达式匹配class和method name来定义Pointcut！！！

 

 

Weaving应用部分

Spring AOP和AspectJ有很多协同。Spring AOP借鉴了AspectJ很多理念。

Spring对AOP的支持有四种形式：
    ① 经典的Spring基于代理的AOP。
    ② 纯POJO aspect。
    ③ @AspectJ注解驱动的aspect。
    ④ 注入的AspectJ aspect。
以上，前三种是Spring自有AOP的变体，由于都是基于代理，所以，仅限于方法拦截！！！

Spring AOP引用了AspectJ EL。

AspectJ EL表达式：核心就是execution，其他的都是用于限制各种参数的。【】【】

例如：

execution(* concert.Performance.perform(..)) && within(concert.*)     // 这里就定义了一个pointcut，而且仅限于被concert包下的aspect使用。   

上面的AspectJ EL是由两部分组成：execution定义切入点，within限定切入点。见下图：

 

 

 

上面，可以使用&&或and、||或or、！或not。 类似EL或JSTL。

Spring还增加一个bean()，意思是仅限于该bean的Pointcut。    

例如：execution(* concert.Performance.perform()) and bean('woodstock')    这里就定义了一个woodstock的pointcut。
例如：execution(* concert.Performance.perform()) and !bean('woodstock')    注意这里！！！很有意思的用法。

 

AspectJ 注解开发：

AspectJ 从 5 开始引入了注解开发，Spring AOP同样引入AspectJ的注解。
但是，Spring AOP仅仅是利用AspectJ的注解名词，底层仍然是Spring AOP的代理实现。

 

注解开发过程：

@Aspect注解到aspect所在的类上，然后@Before等注解到advice（aspect对应的方法）上。如下：

@Component  // 这个是必须的！！
@Aspect
public class Audience {
    @Before("execution(** concert.Performance.perform(..))")    // 该注解声明了silenceCellPhones()需要应用到的Pointcut。
    public void silenceCellPhones() {
        System.out.println("Silencing cell phones");
    }
    @Before("execution(** concert.Performance.perform(..))")
    public void takeSeats() {
        System.out.println("Taking seats");
    }
    @AfterReturning("execution(** concert.Performance.perform(..))")
    public void applause() {
        System.out.println("CLAP CLAP CLAP!!!");
    }
    @AfterThrowing("execution(** concert.Performance.perform(..))")
    public void demandRefund() {
        System.out.println("Demanding a refund");
    }
}

但是，上面这种写法很不方便，因为Pointcut是重复的。

解决办法：使用@Pointcut一次性定义好一个Pointcut。如下：

@Component  // 这个是必须的！！！
@Aspect
public class Audience {
    @Pointcut("execution(** concert.Performance.perform(..))")
    public void perform(){};    // 必须要定义一个方法，用于承载pointcut！

    // 其他的正常代码，略
}    

 但是，到目前为止，AOP仍然是无法执行的，因为Spring AOP不知道这些注解代表什么，所以需要先开启AspectJ自动代理。

开启方法：@EnableAspectJAutoProxy注解到JavaConfig上面。或者，如果使用XML，<aop:aspectj-autoproxy> 。注意导入名称空间。

 

现在，上面的内容可以直接进行测试了：

package aop.performance;

/**
 * 用这个演示join-point和pointcut。
 * perform()就是join-point！
 * 
 * @author Larry
 */
public interface Performance {
    void perform();
}

package aop.performance;
import org.springframework.stereotype.Component;

@Component
public class PerformanceImpl implements Performance{
    @Override
    public void perform() {
        System.out.println(this.getClass()+"正在演出~~~");
    }
}

package aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**
 * 用Audience类来掩饰AspectJ 5的注解用法。
 * 
 * @author Larry
 *
 */
@Component
@Aspect
public class Audience {
    @Before("execution(** aop.performance.Performance.perform(..))")
    public void takeSeat() {
        System.out.println("演出之前要入座~");
    }

    @Before("execution(** aop.performance.Performance.perform(..))")
    public void silenceCellPhones() {
        System.out.println("演出之前要静音~");
    }

    @After("execution(** aop.performance.Performance.perform(..))")
    public void applause() {
        System.out.println("演出之后要鼓掌！");
    }
    
    // TODO: 貌似不能这样用？？而且会导致大BUG！！！阻止访问Pointcut！！！见下面
    //@Around("execution(** aop.performance.Performance.perform(..))")
    public void greet() {
        System.out.println("演出前后要致意~");    
    }

    @AfterReturning("execution(** aop.performance.Performance.perform(..))")
    public void leave() {
        System.out.println("结束后，goodbye~");
    }

    @AfterThrowing("execution(** aop.performance.Performance.perform(..))")
    public void demandRefund(){
        System.out.println("退钱！！！");
    }

    //上面，不好的地方是每次都要写相同的pointcut！解决办法如下：
    @Pointcut("execution(** aop.performance.Performance.perform(..))")
    public void perform(){}
    // 这样就定义了一个pointcut：performance()，然后就可以直接使用了！如下：
    @Before("perform()")
    public void wave(){
        System.out.println("挥挥手~");
    }
    
    // TODO: 务必注意，@Around必须手动调用Pointcut，否则会阻止对Pointcut的访问！！！
    @Around("perform()")
    public void greet2(ProceedingJoinPoint jp) {
        try {
            System.out.println("演出前后要致意~A");    
            jp.proceed();//TODO:这里还可以调用带参数的！
            System.out.println("演出前后要致意~B");    
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }
}

package aop;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import aop.performance.PerformanceImpl;

@Configuration
@ComponentScan(basePackageClasses={ Audience.class,PerformanceImpl.class,AudienceB.class,IntroductionEncoreable.class })
@EnableAspectJAutoProxy    //激活AspectJ
public class JavaConfig {
    
}

package aop.test;

import java.util.Arrays;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.core.env.Environment;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import aop.JavaConfig;
import aop.performance.Performance;

@RunWith(SpringJUnit4ClassRunner.class)      
@ContextConfiguration(classes = { JavaConfig.class })
public class PerformanceAOPTest {
    @Autowired
    Environment env;
    @Autowired
    ApplicationContext ac;

    @Autowired
    Performance p;

    @Test
    public void run() {
        String[] activeProfiles = env.getActiveProfiles();
        System.out.println("activeProfiles的长度"+activeProfiles.length);
        for (String string : activeProfiles) {
            System.out.println("activeProfiles:" + string);
        }

        System.out.println("-------------------------------------");

        String applicationName = ac.getApplicationName();
        System.out.println("applicationName："+applicationName);
        String[] beanDefinitionNames = ac.getBeanDefinitionNames();
        String beans = Arrays.toString(beanDefinitionNames);
        System.out.println("applicationContext中的beans："+beans);

    }

    @Test
    public void run1() {
        p.perform();    // 注意有没有激活AspectJ！
    }
}

上面的代码就是一个测试的全过程，其中遇到的一个问题就是环绕通知@Around，这个注解要求必须手动调用Pointcut（方法），否则Spring代理会丢失该方法！

丢失该方法，就意味着后面的代理无法继续！！！（类似拦截器拦截请求，拦截之后还要手动放行，否则后面的程序无法接收到该请求，也就是 丢失请求！）

需要注意的是，还可以多次调用该方法！！！应用场景：异常后重新执行。

@Around("performance()")
public void watchPerformance(ProceedingJoinPoint jp) {
    try {
        System.out.println("Silencing cell phones");   // 相当于@Before
        System.out.println("Taking seats");  // 相当于@Before
        jp.proceed();    // 【】【】这个，就是调用pointcut。可能忘记调用，也可能重复调用。。。
        System.out.println("CLAP CLAP CLAP!!!");  // 相当于@After 【奇怪，那@AfterReturning呢】
    } catch (Throwable e) {
        System.out.println("Demanding a refund");   // 相当于@AfterThrowing
    }
}

 

到目前为止，介绍的都是无参数的Pointcut（是指Advice不使用Pointcut的参数），下面开始带参数的Pointcut。

带参数的Pointcut（Advice使用Pointcut的参数）

// 样式
execution(* soundsystem.CompactDisc.playTrack(int)) && args(trackNumber)

注意，需要在Pointcut中给定参数类型，以及形参名。然后，再给Advice添加相同的形参即可（类型和形参名）。如下：

/*
    注意，这里实现的功能是统计trackNumber的播放次数！
*/
@Aspect
@Component
public class TrackCounter {
    private Map<Integer, Integer> trackCounts = new HashMap<Integer, Integer>();

    // 定义Pointcut
    @Pointcut("execution(* soundsystem.CompactDisc.playTrack(int)) && args(trackNumber)")
    public void trackPlayed(int trackNumber) {}
    
　// Advice　
    @Before("trackPlayed(trackNumber)")        // trackNumber就是pointcut方法的形参名！！！
    public void countTrack(int trackNumber) {
        int currentCount = getPlayCount(trackNumber);
        trackCounts.put(trackNumber, currentCount + 1);
    }
    
　// 普通的方法　
    public int getPlayCount(int trackNumber) {
        return trackCounts.containsKey(trackNumber) ? trackCounts.get(trackNumber) : 0;
    }
}

 

 

Introduction应用部分

Introduction就是给对象（Bean）引入需要的功能，而不修改原有代码。（例如你拿不到源代码的情况~）

Spring AOP的实现方法就是拦截请求，再转而调用实现了所需方法的对象即可。

示例：

　　现在需要给Performance引入一个performEncore功能（再来一个、加演、额外演出 的意思）。

　　根据Spring AOP的原理，我们需要一个拥有该方法的Bean，所以我们先定义一个接口，再去实现它。

　　

package aop.performance;

/**
 * Encore，加演。延长演出的意思。
 * @author Larry
 *
 */
public interface Encoreable {
    void performEncore();
}

package aop.performance;

import org.springframework.stereotype.Component;

@Component
public class EncoreableImpl implements Encoreable{
    @Override
    public void performEncore() {
        System.out.println("加演一场~~~");
    }
}

package aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.DeclareParents;
import org.springframework.stereotype.Component;
import aop.performance.Encoreable;
import aop.performance.EncoreableImpl;

/**
 * AOP应用之Introduction，就是给对象（bean）添加功能，类似js之类的动态语言给对象添加方法。。
 * @author Larry
 *
 */
@Component
@Aspect
public class IntroductionEncoreable {
    
    @DeclareParents(value="aop.performance.Performance+",defaultImpl=EncoreableImpl.class)   // 稍后讲
    public static Encoreable encoreable; // 先引入需要引入的方法所在的接口
}

package aop;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

import aop.performance.PerformanceImpl;

@Configuration
@ComponentScan(basePackageClasses={ PerformanceImpl.class,IntroductionEncoreable.class })
@EnableAspectJAutoProxy    //激活AspectJ
public class JavaConfig {
    
}

package IntroductionEncoreable;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import aop.JavaConfig;
import aop.performance.Encoreable;
import aop.performance.Performance;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes={JavaConfig.class})
public class IntroductionAOPTest {
    @Autowired
    ApplicationContext ac;
    @Autowired
    Performance p;

    @Test
    public void run1(){
        ((Encoreable)p).performEncore(); // 通过类型强转调用Introduction的方法！！！
    }
}

上面就是测试Introduction的全部代码。

需要注意两点：

　　① @DeclareParents Field，其value为Pointcut所在的类（这里是接口，+表示其所有实现类或子类），defaultImpl则是接口的默认实现类，而Field则是所需方法所在的接口。

　　② 通过类型强转，将目标Bean转成@DeclareParents Field类型，再去调用方法！

 

 

最后，XML中配置Weaving织入，懒得弄了，直接上图吧

 

在XML中，一样可以定义Pointcut，然后在其他地方引用：

<aop:config>
    <aop:aspect ref="audience">
        <aop:pointcut id="performance" expression="execution(** aop.performance.Performance.perform(..))" />
        <aop:before pointcut-ref="performance"  method="silenceCellPhones"/>
        <aop:before pointcut-ref="performance" method="takeSeats"/>
        <aop:after-returning pointcut-ref="performance" method="applause"/>
        <aop:after-throwing pointcut-ref="performance" method="demandRefund"/>
    </aop:aspect>
</aop:config>   

XML配置和注解配置类似，唯一需要注意的是环绕通知@Around，还是需要指定一个方法，该方法接收ProceedingJoinPoint对象。

就是说，实际上同@Aspect Class的@Around Method一样，只不过现在去掉@Aspect和@Around，改为XML配置。

package aop;

import org.aspectj.lang.ProceedingJoinPoint;

public class Audience {
    
    public void greet3(ProceedingJoinPoint jp) {
        try {
            System.out.println("演出前后要致意~A");    
            jp.proceed(); // TODO:这里还可以调用带参数的！
            System.out.println("演出前后要致意~B");    
        } catch (Throwable e) {
            e.printStackTrace();
        }
    }
}

<aop:config>
    <aop:aspect ref="audience">
        <aop:pointcut id="performance" expression="execution(** aop.performance.Performance.perform(..))" />   
        <aop:around pointcut-ref="performance" method="greet3"/>
    </aop:aspect>
</aop:config>

 

另外，XML配置中的带参数Pointcut，略。见Spring in Action, 4th Edition   p147。

 

XML中Introduction引入配置

 

<aop:aspect>
    <aop:declare-parents types-matching="aop.performance.Performance+" implement-interface="aop.performance.Encoreable" default-impl="aop.performance.DefaultEncoreable" />
</aop:aspect>

 

或者，不使用default-impl，而使用delegate-ref。

<bean id="encoreableDelegate" class="aop.performance.DefaultEncoreable" />
<aop:aspect>
    <aop:declare-parents types-matching="aop.performance.Performance+" implement-interface="aop.performance.Encoreable" delegate-ref="encoreableDelegate" />
</aop:aspect>

 

 

未完待续