Spring AOP简介

1. AOP 概述
1.1.1 What's AOP?
AOP（Aspect Orient Programming）:面向切面编程
AOP是一种设计思维，是软件设计畛域中的面向切面编程，它是面向对象编程(OOP)的一种补充和欠缺。它以通过预编译形式和运行期动静代理形式，实现在不批改源代码的状况下给程序动静对立增加额定性能的一种技术。如图-1所示：

AOP与OOP（Object Orient Programming）字面意思相近，但其实两者齐全是面向不同畛域的设计思维。理论我的项目中咱们通常将面向对象了解为一个动态过程(例如一个零碎有多少个模块，一个模块有哪些对象，对象有哪些属性)，面向切面的运行期代理形式，了解为一个动静过程，能够在对象运行时动静织入一些扩大性能或管制对象执行。
1.1.2 AOP 利用场景剖析？
理论我的项目中通常会将零碎分为两大部分，一部分是外围业务，一部分是非核业务。在编程实现时咱们首先要实现的是外围业务的实现，非核心业务个别是通过特定形式切入到零碎中，这种特定形式个别就是借助AOP进行实现。

AOP就是要基于OCP(开闭准则)，在不扭转原有系统核心业务代码的根底上动静增加一些扩大性能并能够"管制"对象的执行。例如AOP利用于我的项目中的日志解决，事务处理，权限解决，缓存解决等等。如图-2所示：

思考:现有一业务,在没有AOP编程时,如何基于OCP准则实现性能扩大?
实现对象性能扩大如图所示：

1.1.3 AOP 利用原理剖析(先理解)？
Spring AOP底层基于代理机制实现性能扩大：

  1. 如果指标对象(被代理对象)实现接口，则底层能够采纳JDK动静代理机制为指标对象创立代理对象（指标类和代理类会实现独特接口）。
  2. 如果指标对象(被代理对象)没有实现接口，则底层能够采纳CGLIB代理机制为指标对象创立代理对象（默认创立的代理类会继承指标对象类型）。
    Spring AOP 原理剖析，如图-3所示：

阐明:Spring boot2.x版本中AOP当初默认应用的CGLIB代理,如果须要应用JDK动静代理能够在配置文件(applicatiion.properties)中进行如下配置:

spring.aop.proxy-target-class=false

1.2 AOP 相干术语剖析

  • 切面(aspect): 横切面对象,个别为一个具体类对象(能够借助@Aspect申明)。
  • 告诉(Advice):在切面的某个特定连接点上执行的动作(扩大性能)，例如around,before,after等。
  • 连接点(joinpoint):程序执行过程中某个特定的点，个别指被拦挡到的的办法。
  • 切入点(pointcut):对多个连接点(Joinpoint)一种定义,个别能够了解为多个连接点的汇合。

连接点与切入点定义如图-4所示：

阐明：咱们能够简略的将机场的一个安检口了解为连接点，多个安检口为切入点，安全检查过程看成是告诉。总之，概念很艰涩难懂，多做例子，做完就会清晰。先能够按文言去了解。

2 Spring AOP疾速实际

2.1 业务形容
基于我的项目中的外围业务，增加简略的日志操作，借助SLF4J日志API输入指标办法的执行时长。(前提，不能批改指标办法代码-遵循OCP准则)

2.2 我的项目创立及配置
创立maven我的项目或在已有我的项目根底上增加AOP启动依赖：

<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId></dependency>

阐明：基于此依赖spring能够整合AspectJ框架疾速实现AOP的根本实现。AspectJ 是一个面向切面的框架，他定义了AOP的一些语法，有一个专门的字节码生成器来生成恪守java标准的class文件。

2.3 扩大业务剖析及实现
2.3.1 创立日志切面类对象
将此日志切面类作为外围业务加强（一个横切面对象）类，用于输入业务执行时长，其要害代码如下：

package com.cy.pj.common.aspect;import org.aspectj.lang.ProceedingJoinPoint;import org.aspectj.lang.Signature;import org.aspectj.lang.annotation.Around;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Pointcut;import org.aspectj.lang.reflect.MethodSignature;import org.springframework.core.annotation.Order;import org.springframework.stereotype.Component;import lombok.extern.slf4j.Slf4j;/** * @Aspect 注解，形容的类为spring容器中一个切面对象类型(此类型中封装切入点与告诉办法) * 1）切入点：要执行扩大业务的办法的汇合 * 2）告诉办法：封装了在切入点办法上要执行的扩大业务办法 */@Order(1)//@Order注解用于形容切面的优先级，数字越小优先级越高，默认优先级比拟低@Aspect@Slf4j@Componentpublic class SysLogAspect {//    private static final Logger log=LoggerFactory.getLogger(SysLogAspect.class); //这句代码等效于@Slf4j注解    /**     * @Pointcut 注解用于形容切入点(在哪些点上执行扩大业务)     * bean(bean对象名字  默认为类名首字母小写):为一种切入点表达式(这个表达式中定义了哪个或哪些bean对象的办法要进行性能扩大).     *     例如,bean(sysUserServiceImpl)表达式示意名字为sysUserServiceImpl的bean对象中所有办法的汇合为切入点,      *  也就是说这个sysUserServiceImpl对象中的任意办法执行时都要进行性能扩大.     */    @Pointcut("bean(sysUserServiceImpl)")      public void doLogPointCut() {}//此办法外部不须要写具体实现，办法的办法名也是任意的    /**     * @Around 注解形容的办法为一个告诉办法(即是一个服务增益办法)，此办法外部能够做服务增益(扩大业务)，@Around注解     *  外部要指定切入点表达式，在此切入点表达式对应的切入点办法上做性能扩大     * @param jp  示意连接点,连接点是动静确定的,用于封装正在执行的切入点办法(指标办法)信息.     * @return 指标办法的执行后果     * @throws Throwable  告诉办法中执行过程呈现的异样     */    @Around("doLogPointCut()")    public Object around(ProceedingJoinPoint jp) throws Throwable {        try {            //1.记录办法开始执行工夫            long start = System.currentTimeMillis();            log.info("start:{}",start);            //2.执行指标办法            Object result=jp.proceed();//最终（两头还能够调用本类其它告诉或其它切面的告诉）会调用指标办法            //3.记录办法完结执行工夫            long after = System.currentTimeMillis();            log.info("after:{}",after);            String targetClassMethod=getTargetClassMethod(jp);            log.info("{}指标办法的执行耗时：{}",targetClassMethod,(after-start));            //4.返回指标办法的执行后果            return result;//指标办法的执行后果        }catch(Throwable e) {            log.error("指标办法执行时呈现了异样:{}",e.getMessage());            throw e;        }    }    /**获取指标办法的全限定名(指标类全名（包名+类名）+办法名)*/    private String getTargetClassMethod(ProceedingJoinPoint jp) {        //1.获取指标对象的类型         Class<?> targetCls = jp.getTarget().getClass();        //2.获取指标对象的类全名(包名+类名)        String targetClsName = targetCls.getName();        //3.火球指标对象的办法名        //3.1 获取办法签名(办法签名对象中封装了办法相干信息)        MethodSignature ms = (MethodSignature)jp.getSignature();        //3.2 基于办法签名获取办法名        String methodName=ms.getName();        //4.构建办法的全限定名并返回        return targetClsName+"."+methodName;            }    }

阐明：

  • @Aspect 注解用于标识或者形容AOP中的切面类型，基于切面类型构建的对象用于为指标对象进行性能扩大或控制目标对象的执行。
  • @Pointcut注解用于形容切面中的办法，并定义切面中的切入点（基于特定表达式的形式进行形容），在本案例中切入点表达式用的是bean表达式，这个表达式以bean结尾，bean括号中的内容为一个spring治理的某个bean对象的名字。
  • @Around注解用于形容切面中办法，这样的办法会被认为是一个盘绕告诉（外围业务办法执行之前和之后要执行的一个动作），@Aournd注解外部value属性的值为一个切入点表达式或者是切入点表达式的一个援用(这个援用为一个@PointCut注解形容的办法的办法名)。
  • ProceedingJoinPoint类为一个连接点类型，此类型的对象用于封装要执行的指标办法相干的一些信息。只能用于@Around注解形容的办法参数。

2.3.1 业务切面测试实现
启动我的项目测试或者进行单元测试，其中Spring Boot我的项目中的单元测试代码如下：

@SpringBootTestpublic class AopTests { @Autowired private SysUserService userService; @Test public void testSysUserService() { PageObject<SysUserDeptVo> po\= userService.findPageObjects("admin",1); System.out.println("rowCount:"+po.getRowCount()); }}

对于测试类中的userService对象而言,它有可能指向JDK代理,也有可能指向CGLIB代理,具体是什么类型的代理对象,要看application.yml配置文件中的配置。

aop:      proxy-target-class: false #false示意零碎底层会基于JDK形式为指标对象创立代理对象。默认为true，示意零碎底层会基于CGLIB形式为指标对象创立代理对象

2.3.2 利用总结剖析
在业务利用,AOP相干对象剖析,如图-5所示:

2.4 扩大业务织入加强剖析

2.4.1 基于JDK代理形式实现
如果指标对象有实现接口,则能够基于JDK为指标对象创立代理对象,而后为指标对象进行性能扩大,如图-6所示：

2.4.2 基于CGLIB代理形式实现
如果指标对象没有实现接口(当然实现了接口也是能够的)，能够基于CGLIB代理形式为指标对象织入性能扩大，如图-7所示：

阐明：指标对象实现了接口也能够基于CGLIB为指标对象创立代理对象。

3 Spring AOP编程加强

3.1切面告诉利用加强
3.1.1 告诉类型
在基于Spring AOP编程的过程中，基于AspectJ框架规范，spring中定义了五种类型的告诉(告诉形容的是一种扩大业务)，它们别离是：

  • @Before。
  • @AfterReturning。
  • @AfterThrowing。
  • @After。
  • @Around.重点把握（优先级最高）
    阐明：在切面类中应用什么告诉，由业务决定，并不是说，在切面中要把所有告诉都写上。

    3.1.2 告诉执行程序
    如果五种类型的告诉全副写到一个切面对象中，其执行程序及过程，如图-8所示：

    阐明：理论我的项目中可能不会在切面中定义所有的告诉，具体定义哪些告诉要联合业务进行实现。

    3.1.3 告诉实际过程剖析
    代码实际剖析如下：

package com.cy.pj.common.aspect;import org.aspectj.lang.JoinPoint;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;@Aspect@Componentpublic class SysTimeAspect {    @Pointcut("bean(sysUserServiceImpl)")    public void doTime() {        //不写具体内容    }    @Before("doTime()")    public void doBefore(JoinPoint jp){        System.out.println("@Before");    }    @After("doTime()")    public void doAfter(){        System.out.println("@After");    }    /**外围业务失常完结时执行* 阐明：如果有after，先执行after,再执行returning*/    @AfterReturning("doTime()")    public void doAfterReturning(){        System.out.println("@AfterReturning");    }    /**外围业务出现异常时执行阐明：如果有after，先执行after,再执行Throwing*/    @AfterThrowing("doTime()")    public void doAfterThrowing(){        System.out.println("@AfterThrowing");    }        @Around("doTime()")    public Object doAround(ProceedingJoinPoint jp)            throws Throwable{        System.out.println("@Around.before");        try{            Object obj=jp.proceed(); //执行指标办法            System.out.println("@Around.after");            return obj;        }catch(Throwable e){            //e.printStackTrace();            System.out.println(e.getMessage());            System.out.println("@Around.throwing");            throw e;        }    }}

阐明：对于@AfterThrowing告诉只有在出现异常时才会执行，所以当做一些异样监控时可在此办法中进行代码实现。

课堂练习:定义一个异样监控切面,对指标页面办法进行异样监控,并以日志信息的模式输入异样

package com.cy.pj.common.aspect;import lombok.extern.slf4j.Slf4j;@Slf4j@Aspect@Componentpublic class SysExceptionAspect { @AfterThrowing(pointcut="bean(\*ServiceImpl)",throwing = "e") public void doHandleException(JoinPoint jp,Throwable e) { MethodSignature ms\=(MethodSignature)jp.getSignature(); log.error("{}'exception msg is{}",ms.getName(),e.getMessage()); }}

阐明：AfterThrowing中throwing属性的值，须要与它形容的办法的异样参数名雷同。

3.2 切入点表达式加强
Spring中通过切入点表达式定义具体切入点，其罕用AOP切入点表达式定义及阐明：

表-1 Spring AOP 中切入点表达式阐明
| 批示符 | 作用 |
|bean| 用于匹配指定bean对象的所有办法|
| within | 用于匹配指定包下所有类内的所有办法|
|execution | 用于按指定语法规定匹配到具体方法 |
| @annotation | 用于匹配指定注解润饰的办法 |

3.2.4 bean表达式（重点）
bean表达式个别利用于类级别，实现粗粒度的切入点定义，案例剖析：

  • bean("userServiceImpl")指定一个userServiceImpl类中所有办法。
  • bean("*ServiceImpl")指定所有后缀为ServiceImpl的类中所有办法。

阐明:bean表达式外部的对象是由spring容器治理的一个bean对象,表达式外部的名字应该是spring容器中某个bean的name。

3.2.5 within表达式（理解）
within表达式利用于类级别，实现粗粒度的切入点表达式定义，案例剖析：

  • within("aop.service.UserServiceImpl")指定以后包中这个类外部的所有办法。
  • within("aop.service.*") 指定当前目录下的所有类的所有办法。
  • within("aop.service..*") 指定当前目录以及子目录中类的所有办法。

within表达式利用场景剖析：

1)对所有业务bean都要进行性能加强，然而bean名字又没有规定。

2)按业务模块(不同包下的业务)对bean对象进行业务性能加强。

3.2.6 execution表达式（理解）
execution表达式利用于办法级别，实现细粒度的切入点表达式定义，案例剖析：
语法：execution(返回值类型 包名.类名.办法名(参数列表))。

  • execution(void aop.service.UserServiceImpl.addUser())匹配addUser办法。
  • execution(void aop.service.PersonServiceImpl.addUser(String)) 办法参数必须为String的addUser办法。
  • execution(* aop.service..*.*(..)) 万能配置。

    3.2.7 @annotation表达式（重点)

@annotaion表达式利用于办法级别，实现细粒度的切入点表达式定义，案例剖析

  • @annotation(anno.RequiredLog) 匹配有此注解形容的办法。
  • @annotation(anno.RequiredCache) 匹配有此注解形容的办法。

其中:RequiredLog为咱们本人定义的注解,当咱们应用@RequiredLog注解润饰业务层办法时,零碎底层会在执行此办法时进行日志扩大操作。
课堂练习:定义一Cache相干切面,应用注解表达式定义切入点,并应用此注解对须要应用cache的业务办法进行形容,代码剖析如下:
第一步:定义注解RequiredCache

package com.cy.pj.common.annotation;import java.lang.annotation.Documented;import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;/** *  自定义注解,一个非凡的类,所有注解都默认继承Annotation接口 * @Retention注解用于定义注解何时失效 * @Target注解用于定义注解能够形容对象 * @Documented 将注解中的文档正文在提取时也要生存API文档 * @author Administrator * */@Retention(RetentionPolicy.RUNTIME)//@Retention注解用于定义注解何时失效@Target(ElementType.METHOD) //@Target注解用于定义注解能够形容对象@Documented //将注解中的文档正文在提取也要生存API文档public @interface RequiredCache {        String key() default "";}

第二步:定义SysCacheAspect切面对象

package com.cy.pj.common.aspect;import java.util.HashMap;import java.util.Map;import java.util.concurrent.ConcurrentHashMap;import org.aspectj.lang.ProceedingJoinPoint;import org.aspectj.lang.annotation.AfterReturning;import org.aspectj.lang.annotation.Around;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Pointcut;import org.springframework.stereotype.Component;@Aspect@Componentpublic class SysCacheAspect {    //假如这个容器就是cache(当然这个cache还须要进行更好的设计)//    private Map<Object,Object> cache=new HashMap<>();//此map为线程不平安的hashMap    private Map<Object,Object> cache=new ConcurrentHashMap<>();  //此map为线程平安的hashMap<>();//此map为线程不平安的hashMap            /**     * 基于@annotation(注解类全名 )表达式定义切入点(这种切入点通常了解为细粒度的切入点)     */    @Pointcut("@annotation(com.cy.pj.common.annotation.RequiredCache)") //自定义注解    public void doCache() {}        @Pointcut("@annotation(com.cy.pj.common.annotation.ClearCache)") //自定义注解    public void doClearCache() {}    //FAQ剖析  如果我当初须要一个分明chache的告诉办法，咱们该写在哪个告诉办法中？写在@AfterReturning告诉办法中        @AfterReturning("doClearCache()")    public void doAfterReturing() {        cache.clear();    }                    @Around("doCache()")    public Object around(ProceedingJoinPoint jp)throws Throwable{        //1.从cache中获取数据，如果cache中有咱们须要的数据集则间接返回，不须要在查问数据，这样能够确保更好的性能        System.out.println("Get data from cahce");        Object result = cache.get("dept");//这个key的名字是本人随便指定的(未来能够写得更加灵便)        //FAQ剖析? 如何将cache中的key定义的更加灵便(在形容切入点的办法注解中直指定)        //FAQ剖析?如何获取切入点办法上注解中的key？(向获取指标办法，而后基于指标办法获取办法上的注解，再通过注解提取key的值)        if(result!=null)return result;        //2.如果cache中没有，则从数据库中去查问        result = jp.proceed();        System.out.println("Put data to cache");        //3.将查问的后果存储到cache中，便于下次查问应用        cache.put("dept", result);        return result;                    }}

第三步:应用@RequiredCache注解对特定业务指标对象中的查询方法进行形容。

 @RequiredCache @Override public List<Map<String, Object\>> findObjects() { …. return list; }

3.3 切面优先级设置实现
切面的优先级须要借助@Order注解进行形容，数字越小优先级越高，默认优先级比拟低。例如：
定义日志切面并指定优先级。

@Order(1)@Aspect@Componentpublic class SysLogAspect { …}

定义缓存切面并指定优先级：

@Order(2)@Aspect@Componentpublic class SysCacheAspect { …}

阐明：当多个切面作用于同一个指标对象办法时，这些切面会构建成一个切面链，相似过滤器链、拦截器链，其执行剖析如图-9所示：

3.4 要害对象与术语总结
Spring 基于AspectJ框架实现AOP设计的要害对象概览，如图-10所示：