@AspectJ准备

AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。
在使用AspectJ之前，我们需要导入aspectJ相应的jar包，可到我的资源页http://download.csdn.net/detail/qwe6112071/9468329 中下载，而如果使用maven则可直接在pom.xml中加入如下代码：

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>${org.aspectj-version}</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.1</version>
</dependency>

AspectJ使用示例

前面我们把增强织入到目标对象是通过在IOC容器中配置代理对象工厂实现的，这样做的缺点很明显，如果我需要为大量的类织入相同的增强时，我需要将每个类都配置进去，操作繁琐，除了这种方法，我们还能使用@AspectJ注解，通过在增强的类方法中标注注解的形式来配置增强，同时我们可以通过切点表达式函数来定义切点，这种切点定位的功能是动态而及其强大的。针对前面文章spring学习笔记(6)AOP增强（advice）配置与应用中同样的示例，我们来看看如何用@AspectJ来实现。

1. 配置切面（在原来前置增强的基础上）

    package test.aop;

    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;

    @Aspect//注解为切面，让IOC容器识别并配置AOP
    public class BeforeAdvice {

        @Before("execution(public String test.aop.Target.speak(Integer))")//定义前置增强并定位切点,定义到test.aop包下的Target对象的public域以String为返回值类型，入参为Integer的speak方法。
        public void before(JoinPoint joinPoint) throws Throwable {//切点入参
            System.out.println("前置日志记录： "
                    + ((Target) joinPoint.getTarget()).getName() + "调用了"
                    + joinPoint.getSignature().getName() + "方法,传入参数为："
                    + joinPoint.getArgs()[0]);
        }
    }

2. 定义目标对象（还是原来的target)

package test.aop;
//被代理对象
public class Target{

    private static final String name = "zenghao";

    public String speak(Integer age){
        System.out.println("hello I'm " + age + " years old");
        return "I'm return value";
    }
    public static String getName() {
        return name;
    }
}

3. 配置IOC容器

<aop:aspectj-autoproxy /><!-- 使注解@AspectJ生效 -->
    <!-- 配置前置增强  -->
<bean class="test.aop.BeforeAdvice" /><!-- 这里不用声明id,因为我们无须显示引用此bean，只需要注册让IOC容器识别并完成相关的AOP配置 -->
<bean id="target" class="test.aop.Target" /><!-- 注册目标对象，方便在测试时调用 -->

4. 调用测试函数

@Test
public void test(){
    ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:test/aop/aop.xml");
    Target target = (Target) ac.getBean("target");
    target.speak(21);
}

打印结果：
前置日志记录： zenghao调用了speak方法,传入参数为：21
hello I’m 21 years old
相对于我们之前的配置，使用@AspectJ看起来简洁了很多，但这里只是个简单实例，使用@AspectJ的很多强大特性我们会在后面一一提到。

增强注解

下面先分析增强注解的配置格式。括号中为注解的属性，部分属性含义相同就不重复介绍了。

1. 前置增强

`@Before(value,argNames)`

- value：定义切点
- argsName：指定注解所标注的增强方法的参数名，多个参数用都好隔开。

2.后置增强

 `@AfterReturning(value/pointcut,returning,argNames)`

- value/pointcut:定义切点，若同时定义，value会被pointcut覆盖
- returning:将目标对象的方法绑定到增强的方法中

3. 异常增强

`AfterThrowing(value/pointcut,throwing,argNames)`

- throwing:将抛出的异常绑定到增强方法中

4. 最终（final)增强

`After(value,argNames)`

无论是抛出异常还是正常退出，都会执行此增强

5. 引介增强

`@DeclareParents(value,defaultImpl)`

- defaultImpl:默认的接口实现类

关于引介增强的详细分析，可参考本系列后面的一篇博文 《spring学习笔记(12)引介增强详解：定时器实例：无侵入式动态增强类功能》

对于以上的增强，都可以在增强方法中绑定入参org.aspectj.lang.JoinPoint。
在一开始提到的例子中，我们将切面改造如下：

    @Aspect
    public class BeforeAdvice {

        @Before("execution(public String test.aop.Target.speak(Integer))")
        public void before(JoinPoint joinPoint) throws Throwable {
            System.out.println("前置日志记录： "
                    + ((Target) joinPoint.getTarget()).getName() + "调用了"
                    + joinPoint.getSignature().getName() + "方法,传入参数为："
                    + joinPoint.getArgs()[0]);
                    + 
            System.out.println(joinPoint.getKind());
            System.out.println(joinPoint.getTarget());//获取目标对象
            System.out.println(joinPoint.getThis());//获取目标对象
            System.out.println(joinPoint.getArgs());//获取目标对象方法入参
            System.out.println(joinPoint.getClass());
            System.out.println(joinPoint.getSignature());//获取完整的方法签名
            System.out.println(joinPoint.getSourceLocation());
            System.out.println(joinPoint.getStaticPart());//获取切点定位信息
        }
    }

我们会得到打印信息：
method-execution
test.aop2.UserController@14febdb5
test.aop2.UserController@14febdb5
[Ljava.lang.Object;@3ce4387d
class org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint
void test.aop2.UserController.login(String)
org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint$SourceLocationImpl@34a3ef26
execution(void test.aop2.UserController.login(String))

Joinpoint有个子类ProceedingJoinPoint,但它只能在被@Around注解的增强方法中作入参，相对与JoinPoint,ProceedingJoinPoint 新增了两个方法：
1. Object org.aspectj.lang.ProceedingJoinPoint.proceed() throws Throwable。作用类似于环绕增强中的org.aopalliance.intercept.Invocation的proceed方法，用于调用原目标对象方法。
2. Object org.aspectj.lang.ProceedingJoinPoint.proceed(Object[] newArgument) throws Throwable此方法和1的区别在于填入了新的入参，即用newArgument代替了原目标方法的入参。

在切点表达式函数中使用通配符

增强注解中的value/pointcut属性都是用于定义切点的，对于切点的定义，我们常用到切点表达式函数，而在表达式函数中，我们可以通过一些通配符来辅助定位连接点。

1. 通配符类型

涉及到的通配符主要有3种：
1. * 匹配任意一个元素，如返回值，某个包，某个类，某个方法等
2. .. 匹配多个元素，表示类时要和*联合使用（如com.yc.controller..*定位controller包下的所有类 ),表示入参时则单独使用(com.yc.controller.UserController.login(..)定位与对应包、类下参数类型数量任意的名为login的方法，这在使用多态特性和不确定入参时常用)
3. + 按类型匹配指定类及其子类

2. 不同的函数对通配符的支持度不同

可以分为如下3类

逻辑运算符

在切点表达式函数的使用中，除了通过通配符外，我们还可以通过一些逻辑运算符来进一步精确而灵活地定位我们要织入增强的连接点。