Spring温故而知新

AOP的相关专业术语

通知（Advice）：定义在连接点做什么

　　　　　　 Spring中通知类型：前置通知，后置通知，返回通知，异常通知，环绕通知

连接点（JoinPoint）：程序执行过程中拦截的点，Sping中一般是方法

切点（PointCut）：决定advice通知应该作用域哪个连接点

切面（Aspect）：切面就是对横切关注点的抽象

引入（Introduction）：无需修改现有类的代码，向现有类添加新的方法或属性

织入（Weaving）：把切面应用到目标对象并创建新的代理对象的过程。

先理解两个概念：

静态织入：通过特定的编译器在编译期间将需要增加的代码织入，即编译生成.class文件后，字节码已经被织入。

动态织入：运行时动态将要增强的代码织入到目标类中，一般通过动态代理的技术实现，如JDK动态代理或者CGLIB动态代理

Spring借鉴了AspectJ的切面，可以使用AspectJ来做切点解析和匹配,但是在运行时仍然是基于动态代理的AOP，并不依赖于AspectJ的编译器和织入器weaver (这点上区别于AspectJ：采用静态织入),但是编程模型几乎与编写成熟的AspectJ注解切面完全一致，这种AOP风格的好处在与能够不使用XML配置来完成。

AspectJ切点表达式

Spring借助AspectJ的切点表达式语言完成切面的定义，常见AspectJ指示器如下：

execution ：匹配方法执行的连接点，这是你将会用到的Spring的最主要的切入点指示符。

within ：限定匹配特定类型的连接点（在使用Spring AOP的时候，在匹配的类型中定义的方法的执行）。

this ：限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中bean reference（Spring AOP 代理）是指定类型的实例。

target ：限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中目标对象（被代理的应用对象）是指定类型的实例。

args：限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中参数是指定类型的实例。

@target：限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中正执行对象的类持有指定类型的注解。

@args：限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中实际传入参数的运行时类型持有指定类型的注解。

@within：限定匹配特定的连接点，其中连接点所在类型（类）已指定注解（在使用Spring AOP的时候，所执行的方法所在类型已指定注解）。

@annotation：限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中连接点（方法）的主题持有指定的注解。（在使用Spring AOP的时候，所执行的方法已指定注解）

其中只有execution指示器是执行匹配的，其他的指示器都是用来限制匹配的，具体指示器使用方式如下：

execution指示器：

execution（<修饰符> <返回类型> <类路径> <方法名>(<参数列表>) <异常模式> ）

<修饰符>：类型修饰符，可选，如public、protected，*表示任意修饰符

<返回类型>：必填，如void,String等，*表示任意类型

<类路径>：类型表达式匹配（包名.类名），可选 “包名.*”表示包下所有类，“包名..*”表示包以及子包下所有的类

<方法名>：方法名匹配，必填，*表示可以匹配任意方法

（参数列表）：参数匹配，必填,()表示没有参数，(..)表示匹配任意个数参数,(..,String)表示匹配最后一个参数是String类型方法，前面可以是任意参数

<异常模式>：异常列表，可选

使用示例：

1：匹配com.sl.aop包下所有公共类型方法

execution(public * com.sl.aop.*.*(..))

2：匹配com.sl.aop包下所有以Order结尾的方法

execution(* com.sl.aop.*.*Order(..))

3：匹配com.sl.aop包下OrderService接口下所有无参方法

execution(* com.sl.aop.OrderService.*())

within 指示器：

within（<类路径>）

使用示例：

1: com.sl.aop包以及子包下任意连接点

within(com.sl.aop.OrderService.*)

2: com.sl.aop包以及子包下OrderService类型及子类型的任意连接点

within(com.sl.aop.OrderService+)

其他指示器：

//实现OrderService接口的代理对象的任意连接点（这里是AOP代理对象类型匹配）

this(com.sl.aop.OrderSerivce)

可以与excution组合使用

@Before("execution(* com.sl.aop.*.*(..)) && this(com.sl.aop.OrderService)")

//实现OrderService接口的目标对象的任意连接点（区别于this的代理对象）

target(com.sl.aop.OrderSerivce)

具体this和target的区别可参考CSDN这篇文章https://blog.csdn.net/yangshangwei/article/details/77861658

//匹配使用了@Service注解的类（类上加注解，接口上加注解不起作用）

@within(org.springframework.stereotype.Service)

@Before("execution(* com.sl.aop.*.*(..)) && @within(org.springframework.stereotype.Service)")

//匹配使用了@ Secure注解的方法(方法上加注解)

@annotation(cn.javass.spring.chapter6.Secure )

使用注解配置AOP

示例代码：

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"

    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.xsd

           http://www.springframework.org/schema/context

           http://www.springframework.org/schema/context/spring-context.xsd" >

    <!-- 组件扫描，扫描含有注解的类 -->

    <context:component-scan base-package="com.sl.aop"></context:component-scan>

    <!—启用aspectj注解 -->

    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

java代码：

@Component

@Aspect // 定义切面

public class OrderLogger {

    //定义切点函数

    // 前置通知 ：在目标方法被调用之前调用该通知

    //@Before("execution(* com.sl.aop.*.*(..))")

    //@Before("execution(public * com.sl.aop.*.*(..))")

    //@Before("execution(* com.sl.aop.OrderService.*())")

    //@Before("execution(* com.sl.aop.*.*(..)) && this(com.sl.aop.OrderService)")

    @Before("execution(* com.sl.aop.*.*(..)) && @within(org.springframework.stereotype.Service)")

    public void beforeCreateOrder() {

        System.out.println("before create order");

    }

//使用args处理通知中的参数

    @Before("execution(public * com.sl.aop.*.*(..)) && args(orderNumber,..)")

    public void beforeCreateOrder(String orderNumber) {

        System.out.println("before create order:"+orderNumber);

    }

    // 后置通知：在目标方法返回或抛异常后调用该通知

    @After("execution(* com.sl.aop.OrderServiceImpl.createOrder(..))")

    public void afterCreateOrder() {

        System.out.println("after create order");

    }

    // 返回通知：在目标方法正常返回后调用

    @AfterReturning("execution(* com.sl.aop.OrderServiceImpl.createOrder(..))")

    public void createOrderSuccess() {

        System.out.println("create order success");

    }

    // 异常通知：在目标方法抛出异常后调用

    @AfterThrowing("execution(* com.sl.aop.OrderServiceImpl.createOrder(..))")

    public void createOrderError() {

        System.out.println("create order error");

    }

    // 异常通知：在目标方法抛出异常后调用

    @Around("execution(* com.sl.aop.OrderServiceImpl.createOrder(..))")

    public void createOrderError(ProceedingJoinPoint jp) throws Throwable {

        System.out.println("around before create order");

        jp.proceed();

        System.out.println("around after create order");

    }

}

public interface OrderService {

    public void createOrder();

    public void createOrder(String orderNumber);

}

//@Service

@Component("orderServiceImpl")

public class OrderServiceImpl implements OrderService {

    @Override

    public void createOrder() {

        System.out.println("creating order");

    }

    @Override

    public void createOrder(String orderNumber) {

        System.out.println("creating order："+orderNumber);

    }

}

测试代码：

@Test

 public void TestAspectAop() {

        ApplicationContext context =

                new ClassPathXmlApplicationContext("aoptextbean.xml");

        OrderService orderService =    (OrderService)context.getBean("orderServiceImpl");

 
       orderService.createOrder();


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


        orderService.createOrder("888");

    }

结果：

使用XML配置AOP

使用上面的代码，切面类中删除所以aop相关注解，通过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"

    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.xsd

           http://www.springframework.org/schema/context

           http://www.springframework.org/schema/context/spring-context.xsd" >

    <!-- 组件扫描，扫描含有注解的类 -->

    <context:component-scan base-package="com.sl.aop"></context:component-scan>

    <!-- 使用aspectj注解 -->

    <!-- <aop:aspectj-autoproxy></aop:aspectj-autoproxy> -->

    <bean id="orderLogger" class="com.sl.aop.OrderLogger"></bean>

    <aop:config>

        <!--1： 申明一个切面   多个切面时order指定优先级-->

        <aop:aspect ref="orderLogger" order="0">

            <!-- 2:定义通知  method:指定通知名  pointcut：指定切点-->

            <aop:before method="beforeCreateOrder" pointcut="execution(* com.sl.aop.OrderService.*())" />

            <!-- <aop:before method="beforeCreateOrder" pointcut="execution(public * com.sl.aop.*.*(String)) and args(orderNumber)" /> -->

            <aop:after method="afterCreateOrder" pointcut="execution(* com.sl.aop.OrderServiceImpl.createOrder(..))" />

            <aop:after-returning method="createOrderSuccess" pointcut="execution(* com.sl.aop.OrderServiceImpl.createOrder(..))" />

            <aop:after-throwing method="createOrderError" pointcut="execution(* com.sl.aop.OrderServiceImpl.createOrder(..))" />

            <aop:around method="createOrderAround" pointcut="execution(* com.sl.aop.OrderServiceImpl.createOrder(..))" />

        </aop:aspect>

    </aop:config>

</beans>

@Component

public class OrderLogger {

    //定义切点函数

    // 前置通知 ：在目标方法被调用之前调用该通知

    public void beforeCreateOrder() {

        System.out.println("before create order");

    }

    //使用args处理通知中的参数

    public void beforeCreateOrder(String orderNumber) {

        System.out.println("before create order:"+orderNumber);

    }

    // 后置通知：在目标方法返回或抛异常后调用该通知

    public void afterCreateOrder() {

        System.out.println("after create order");

    }

    // 返回通知：在目标方法正常返回后调用

    public void createOrderSuccess() {

        System.out.println("create order success");

    }

    // 异常通知：在目标方法抛出异常后调用

    public void createOrderError() {

        System.out.println("create order error");

    }

    // 异常通知：在目标方法抛出异常后调用

    public void createOrderAround(ProceedingJoinPoint jp) throws Throwable {

        System.out.println("around before create order");

        jp.proceed();

        System.out.println("around after create order");

    }

}

测试代码：

@Test

    public void TestAspectAop() {

        ApplicationContext context =

                new ClassPathXmlApplicationContext("aoptextbean.xml");

        OrderService orderService =    (OrderService)context.getBean("orderServiceImpl");

        orderService.createOrder();

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

        orderService.createOrder("888");

    }

运行结果：

最后解释一下Spring中使用xml配置AOP的标签及其属性使用方式：

<aop:config>                               　　　　　　　　　　　　　　 <!--AOP配置根节点  -->

     <aop:pointcut expression="" id=""/>       　　　　　　　　　　　　<!--定义切点   expression切点表达式，比如 expression="execution(* com.sl.aop.*.*(..))"， id：定义切点id="tempId"-->

     <aop:advisor advice-ref=""/>              　　　　　　　　　　　　<!--定义通知器  -->

     <aop:aspect  ref="" order="">                               　<!--定义切面  ref:切面引用（切面beanID） order:执行顺序，多个切面可以指定优先级-->

        <aop:before method="" pointcut="" pointcut-ref="" />    　　<!--前置通知  method:通知方法名，poincut:切点表达式，pointcut-ref:切点引用（切点id），如pointcut-ref="tempId"，可以如其他通知引用相同切点-->

        <aop:after method="" pointcut="" pointcut-ref=""/>                    <!--后置通知 -->

        <aop:after-returning method="" pointcut="" pointcut-ref=""/>        　<!--返回通知 -->

        <aop:after-throwing method="" pointcut="" pointcut-ref=""/>           <!--异常通知 -->

        <aop:around method="" pointcut="" pointcut-ref=""/>                   <!--环绕通知 -->

        <aop:declare-parents types-matching="" implement-interface=""/>       <!--引入额外接口 -->

        <aop:pointcut expression="" id=""/>                                   <!--定义切点  -->

     </aop:aspect>

</aop:config>