Spring-AOP

AOP：面向切面编程。（和代理很像）

---

关注点：对哪些方法进行拦截，拦截后怎么处理，这些关注点称之为横切关注点
简说：在事务之前或之后用到的与事务无关的方法；例如计时。

---

切面：类是对物体特征的抽象，切面就是对横切关注点的抽象。
简说：放置关注点的类；也就是无关业务的方法放置的类。
注意：该类的类名之上放置注解@Aspect

---

连接点：被拦截到的点，因为Spring只支持方法类型的连接点，所以在Spring中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器。

---

切入点：对连接点进行拦截的定义。poincut

关于连接点与切入点的示例：

/**
 * Spring的事务管理切面<br/>
 *
 * @version 1.0
 * @since JDK 1.7
 */
@Component
@Aspect
public class SpringTransactionManagementAspect {

    /**
     * 定义切入点，也就是指定需要动态织入关注点的连接点（被拦截的方法）. <br/>
     *
     * 切入点表达式： execution (返回值类型 方法(参数列表))<br/>
     * 
     * 1. * 表示匹配任何
     * 
     * 2. .. 表示匹配任何参数列表
     * 
     * 3. Integer com.huaxin.spring.aop.service.impl.**.*(..)<br/>
     * 表示拦截包com.huaxin.spring.aop.service.impl及其子包下所有返回值类型为Integer的方法
     */
    @Pointcut("execution (Integer com.huaxin.spring.aop.service.impl.**.*(..))")
    void pointCut() {
        // 空方法，没有实际意思，纯粹是为了使用Annotation的方式定义切入点
    }

    /**
     * execution (* com.huaxin.spring.aop.service.impl.*.add*(..))<br/>
     * 表示拦截包com.huaxin.spring.aop.service.impl下所有以 add开头的方法
     */
    @Pointcut("execution (* com.huaxin.spring.aop.service.impl.**.add*(..))")
    void pointCut2() {

    }

    /**
     * 前置通知：在业务方法执行之前，需要执行的关注点<br/>
     */
    @Before("pointCut()")
    public void beginTransaction() {
        System.out.println("开启事务");
    }

    /**
     * 返回通知：在业务方法正常返回(业务方法没有发生异常)之后，需要执行的关注点. <br/>
     *
     */
    @AfterReturning("pointCut()")
    public void commit() {
        System.out.println("提交事务");
    }

    /**
     * 异常通知：业务方法发生异常之后，需要执行的关注点. <br/>
     *
     */
    @AfterThrowing("pointCut()")
    public void rollback() {
        System.out.println("回滚事务");
    }

    /**
     * 后置通知：在业务方法执行之后，需要执行的关注点. <br/>
     * 与返回通知的区别：返回通知，只在业务方法正常返回（没有发生异常）之后执行；<br/>
     * 后置通知，不管业务方法有无发生异常，都执行
     */
    @After("pointCut()")
    public void after() {
        System.out.println("后置通知");
    }

    /**
     * 环绕通知：在业务方法执行之前，执行之后都执行. <br/>
     *
     */
    @Around("pointCut2()")
    public Object around(ProceedingJoinPoint joinPoint) {
        try {
            // 1. 等价于前置通知
            this.beginTransaction();
            // 调用业务方法
            Object result = joinPoint.proceed();
            // 2. 等价于后置通知
            this.after();
            // 3. 等价于返回通知
            this.commit();
            return result;
        } catch (Throwable t) {
            // 等价于后置通知
            this.after();
            // 4. 等价于异常通知
            this.rollback();
            throw new RuntimeException();
        }
    }
}

---

通知：所谓通知指的就是指拦截到连接点之后要执行的代码，通知分为前置、后置、异常、返回、环绕通知五类。

---

添加自动装配的配置文件

<?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:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context      
    http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 开启组件扫描，以便Spring能扫描到通过Annotation配置的Bean -->
    <context:component-scan base-package="com.huaxin.spring.aop.service,com.huaxin.spring.aop.dao" />
    <context:component-scan base-package="com.huaxin.spring.aop.aspect" />

    <!-- 开启自动生成代理对象：
        1. 如果目标对象实现了接口，使用JDK的基于接口的动态代理
        2. 如果目标对象没有实现接口，使用cglib的基于继承的动态代理
     -->
    <aop:aspectj-autoproxy />
</beans>

模拟性能统计

/**
 * 性能统计切面 <br/>
 * 
 * @Aspect 定义切面
 *
 * @version 1.0
 * @since JDK 1.7
 */
@Aspect
@Component
public class SpringPerformanceStatisAspect {

    private static final ThreadLocal<Long> startTimes = new ThreadLocal<Long>();

    /**
     * @Pointcut 定义切入点 TODO. <br/>
     *
     */
    @Pointcut("execution (* com.huaxin.spring.aop.service.impl.UserServiceImpl.addUser(..))")
    public void pointCut() {

    }
    //利用主线程进行方法间传值
    // 前置通知
    @Before("pointCut()")
    public void start() {
        startTimes.set(System.currentTimeMillis());
    }

    // 后置通知
    @After("pointCut()")
    public void end() {
        Long start = startTimes.get();
        if (start != null) {
            long cost = System.currentTimeMillis() - start;
            System.out.println("cost:" + cost + " ms");
        }
    }
}