Spring AOP简介

最新推荐文章于 2022-06-13 11:45:00 发布

abu1216

最新推荐文章于 2022-06-13 11:45:00 发布

阅读量270

点赞数

本文链接：https://blog.csdn.net/abu1216/article/details/110631424

版权

AOP 概述

AOP 是什么？

AOP（Aspect Orient Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程(OOP)的一种补充和完善。它以通过预编译方式和运行期动态代理方式，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。如图-1所示：

AOP与OOP字面意思相近，但其实两者完全是面向不同领域的设计思想。实际项目中我们通常将面向对象理解为一个静态过程(例如一个系统有多少个模块，一个模块有哪些对象，对象有哪些属性)，面向切面的运行期代理方式，理解为一个动态过程，可以在对象运行时动态织入一些扩展功能或控制对象执行。

AOP 应用场景分析？

实际项目中通常会将系统分为两大部分，一部分是核心业务，一部分是非核业务。在编程实现时我们首先要完成的是核心业务的实现，非核心业务一般是通过特定方式切入到系统中，这种特定方式一般就是借助AOP进行实现。

AOP就是要基于OCP(开闭原则)，在不改变原有系统核心业务代码的基础上动态添加一些扩展功能并可以"控制"对象的执行。例如AOP应用于项目中的日志处理，事务处理，权限处理，缓存处理等等。如图-2所示：

思考:现有一业务,在没有AOP编程时,如何基于OCP原则实现功能扩展?

AOP 应用原理分析(先了解)？

Spring AOP底层基于代理机制实现功能扩展：

假如目标对象(被代理对象)实现接口，则底层可以采用JDK动态代理机制为目标对象创建代理对象（目标类和代理类会实现共同接口）。
假如目标对象(被代理对象)没有实现接口，则底层可以采用CGLIB代理机制为目标对象创建代理对象（默认创建的代理类会继承目标对象类型）。

Spring AOP 原理分析，如图-3所示：

说明:Spring boot2.x 中AOP现在默认使用的CGLIB代理,假如需要使用JDK动态代理可以在配置文件(applicatiion.properties)中进行如下配置:

spring.aop.proxy-target-class=false

AOP 相关术语分析

切面(aspect): 横切面对象,一般为一个具体类对象(可以借助@Aspect声明)。
通知(Advice):在切面的某个特定连接点上执行的动作(扩展功能)，例如around,before,after等。
连接点(joinpoint):程序执行过程中某个特定的点，一般指被拦截到的的方法。
切入点(pointcut):对多个连接点(Joinpoint)一种定义,一般可以理解为多个连接点的集合。

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

说明：我们可以简单的将机场的一个安检口理解为连接点，多个安检口为切入点，安全检查过程看成是通知。总之，概念很晦涩难懂，多做例子，做完就会清晰。先可以按白话去理解。

Spring AOP快速实践

业务描述

基于项目中的核心业务，添加简单的日志操作，借助SLF4J日志API输出目标方法的执行时长。

项目创建及配置

创建maven项目或在已有项目基础上添加AOP启动依赖：

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-aop</artifactId>

</dependency>

说明：基于此依赖spring可以整合AspectJ框架快速完成AOP的基本实现。AspectJ 是一个面向切面的框架，他定义了AOP的一些语法，有一个专门的字节码生成器来生成遵守java规范的class文件。

扩展业务分析及实现

创建日志切面类对象

将此日志切面类作为核心业务增强（一个横切面对象）类，用于输出业务执行时长，其关键代码如下：

package com.cy.pj.common.aspect;

@Aspect

@Slf4j

@Component

public class SysLogAspect {

@Pointcut("bean(sysUserServiceImpl)")

public void logPointCut() {}

@Around("logPointCut()")

public Object around(ProceedingJoinPoint jp)

throws Throwable{

try {

log.info("start:"+System.currentTimeMillis());

Object result=jp.proceed();//调用下一个切面方法或目标方法

log.info("after:"+System.currentTimeMillis());

return result;

}catch(Throwable e) {

log.error(e.getMessage());

throw e;

}

说明：

@Aspect 注解用于标识或者描述AOP中的切面类型，基于切面类型构建的对象用于为目标对象进行功能扩展或控制目标对象的执行。
@Pointcut注解用于描述切面中的方法，并定义切面中的切入点（基于特定表达式的方式进行描述），在本案例中切入点表达式用的是bean表达式，这个表达式以bean开头，bean括号中的内容为一个spring管理的某个bean对象的名字。
@Around注解用于描述切面中方法，这样的方法会被认为是一个环绕通知（核心业务方法执行之前和之后要执行的一个动作），@Aournd注解内部value属性的值为一个切入点表达式或者是切入点表达式的一个引用(这个引用为一个@PointCut注解描述的方法的方法名)。
ProceedingJoinPoint类为一个连接点类型，此类型的对象用于封装要执行的目标方法相关的一些信息。一般用于@Around注解描述的方法参数。

业务切面测试实现

启动项目测试或者进行单元测试，其中Spring Boot项目中的单元测试代码如下：

@SpringBootTest

public 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相关对象分析,如图-5所示:

扩展业务织入增强分析

基于JDK代理方式实现

假如目标对象有实现接口,则可以基于JDK为目标对象创建代理代理对象,然后为目标对象进行功能扩展,如图-6所示：

基于CGLIB代理方式实现

假如目标对象没有实现接口，可以基于CGLIB代理方式为目标织入功能扩展，如图-7所示：

说明：目标对象实现了接口也可以基于CGLIB为目标对象创建代理对象。

Spring AOP编程增强

切面通知应用增强

通知类型

在基于Spring AOP编程的过程中，基于AspectJ框架标准，spring中定义了五种类型的通知(通知描述的是一种扩展业务)，它们分别是：

前置通知 (@Before) 。
返回通知 (@AfterReturning) 。
异常通知 (@AfterThrowing) 。
后置通知 (@After)。
环绕通知 (@Around) :重点掌握（优先级最高）

通知执行顺序

假如这些通知全部写到一个切面对象中，其执行顺序及过程，如图-8所示：

说明：实际项目中可能不会在切面中定义所有的通知，具体定义哪些通知要结合业务进行实现。

通知实践过程分析

代码实践分析如下：

@Component

@Aspect

public class SysTimeAspect {

@Pointcut("bean(sysUserServiceImpl)")

public void doTime(){}

@Before("doTime()")

public void doBefore(JoinPoint jp){

System.out.println("time doBefore()");

}

@After("doTime()")

public void doAfter(){

System.out.println("time doAfter()");

}

/**核心业务正常结束时执行* 说明：假如有after，先执行after,再执行returning*/

@AfterReturning("doTime()")

public void doAfterReturning(){

System.out.println("time doAfterReturning");

}

/**核心业务出现异常时执行说明：假如有after，先执行after,再执行Throwing*/

@AfterThrowing("doTime()")

public void doAfterThrowing(){

System.out.println("time doAfterThrowing");

}

@Around("doTime()")

public Object doAround(ProceedingJoinPoint jp)

throws Throwable{

System.out.println("doAround.before");

try{

Object obj=jp.proceed();

System.out.println("doAround.after");

}catch(Throwable e){

System.out.println(e.getMessage());

throw e;

}

return obj;

}

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

课堂练习:定义一个异常监控切面,对目标页面方法进行异常监控,并以日志信息?

形式输出异常

package com.cy.pj.common.aspect;

import lombok.extern.slf4j.Slf4j;

@Slf4j

@Aspect

@Component

public 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属性的值，需要与它描述的方法的异常参数名相同。

切入点表达式增强

Spring中通过切入点表达式定义具体切入点，其常用AOP切入点表达式定义及说明：

表-1 Spring AOP 中切入点表达式说明

指示符	作用
bean	用于匹配指定bean对象的所有方法
within	用于匹配指定包下所有类内的所有方法
execution	用于按指定语法规则匹配到具体方法
@annotation	用于匹配指定注解修饰的方法

bean表达式（重点）

bean表达式一般应用于类级别，实现粗粒度的切入点定义，案例分析：

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

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

其中:RequiredLog为我们自己定义的注解,当我们使用@RequiredLog注解修饰业务层方法时,系统底层会在执行此方法时进行日扩展操作。

课堂练习:定义一Cache相关切面,使用注解表达式定义切入点,并使用此注解对需要使用cache的业务方法进行描述,代码分析如下:

第一步:定义注解RequiredCache

within表达式（了解）
within表达式应用于类级别，实现粗粒度的切入点表达式定义，案例分析：
within("aop.service.UserServiceImpl")指定当前包中这个类内部的所有方法。
within("aop.service.*") 指定当前目录下的所有类的所有方法。
within("aop.service..*") 指定当前目录以及子目录中类的所有方法。
execution表达式（了解）
execution表达式应用于方法级别，实现细粒度的切入点表达式定义，案例分析：

语法：execution(返回值类型包名.类名.方法名(参数列表))。
execution(void aop.service.UserServiceImpl.addUser())匹配addUser方法。
execution(void aop.service.PersonServiceImpl.addUser(String)) 方法参数必须为String的addUser方法。
execution(* aop.service..*.*(..)) 万能配置。
@annotation表达式（重点）
@annotaion表达式应用于方法级别，实现细粒度的切入点表达式定义，案例分析
@annotation(anno.RequiredLog) 匹配有此注解描述的方法。
@annotation(anno.RequiredCache) 匹配有此注解描述的方法。

package com.cy.pj.common.annotation;

/**

* 自定义注解,一个特殊的类,所有注解都默认继承Annotation接口

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.METHOD)

public @interface RequiredCache {

//...

}

第二步:定义SysCacheAspect切面对象。

package com.cy.pj.common.aspect;

@Aspect

@Component

public class SysCacheAspect {

@Pointcut("@annotation(com.cy.pj.common.annotation.RequiredCache)")

public void doCache() {}

@Around("doCache()")

public Object around(ProceedingJoinPoint jp)throws Throwable{

System.out.println("Get data from cache");

Object obj=jp.proceed();

System.out.println("Put data to cache");

return obj;

}

第三步:使用@RequiredCache注解对特定业务目标对象中的查询方法进行描述。

@RequiredCache

@Override

public List<Map<String, Object>> findObjects() {

….

return list;

}

切面优先级设置实现

切面的优先级需要借助@Order注解进行描述，数字越小优先级越高，默认优先级比较低。例如：

定义日志切面并指定优先级。

@Order(1)

@Aspect

@Component

public class SysLogAspect {

…

}

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

@Order(2)

@Aspect

@Component

public class SysCacheAspect {

…

}

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

关键对象与术语总结

Spring 基于AspectJ框架实现AOP设计的关键对象概览，如图-10所示：

用户行为日志记录实现（实践）

本小节作为课堂练习，以AOP方式记录项目中的用户行为信息，并将其存储到数据库。参考日志模块的文档。

Spring AOP事务处理

Spring 中事务简介

事务定义

事务(Transaction)是一个业务,是一个不可分割的逻辑工作单元，基于事务可以更好的保证业务的正确性。

说明:目前市场上在事务一致性方面,通常会做一定的优化,比方说只要最终一致就可以了,这样的事务我们通常会称之为柔性事务(只要最终一致就可以了).

事务特性
事务具备ACID特性，分别是：
原子性（Atomicity）：一个事务中的多个操作要么都成功要么都失败。
一致性（Consistency): (例如存钱操作,存之前和存之后的总钱数应该是一致的。
隔离性（Isolation）：事务与事务应该是相互隔离的。
持久性（Durability）：事务一旦提交,数据要持久保存。
Spring 中事务管理
Spring 中事务方式概述

Spring框架中提供了一种声明式事务的处理方式，此方式基于AOP代理,可以将具体业务逻辑与事务处理进行解耦。也就是让我们的业务代码逻辑不受污染或少量污染,就可以实现事务控制。

在SpringBoot项目中,其内部提供了事务的自动配置，当我们在项目中添加了指定依赖spring-boot-starter-jdbc时，框架会自动为我们的项目注入事务管理器对象，最常用的为DataSourceTransactionManager对象。

Spring 中事务管理实现

本小节重点讲解实际项目中最常用的注解方式的事务管理，以注解@Transactional配置方式为例，进行实践分析。

基于@Transactional 注解进行声明式事务管理的实现步骤分为两步：

其代码示例如下：

启用声明式事务管理，在配置类上添加@EnableTransactionManagement，新版本中也可不添加（例如新版Spring Boot项目）。
将@Transactional注解添加到合适的业务类或方法上，并设置合适的属性信息。

@Transactional(timeout = 30,

readOnly = false,

isolation = Isolation.READ_COMMITTED,

rollbackFor = Throwable.class,

propagation = Propagation.REQUIRED)

@Service

public class SysUserServiceImpl implements SysUserService {

@Transactional(readOnly = true)

@Override

public PageObject<SysUserDeptVo> findPageObjects(

String username, Integer pageCurrent) {

…

}

其中，代码中的@Transactional注解用于描述类或方法，告诉spring框架我们要在此类的方法执行时进行事务控制，其具体说明如下：。

当@Transactional注解应用在类上时表示类中所有方法启动事务管理，并且一般用于事务共性的定义。
当@Transactional描述方法时表示此方法要进行事务管理，假如类和方法上都有@Transactional注解，则方法上的注解一般用于事务特性的定义。

@Transactional 常用属性应用说明：

timeout：事务的超时时间，默认值为-1,表示没有超时显示。如果配置了具体时间,则超过该时间限制但事务还没有完成，则自动回滚事务。
read-only：指定事务是否为只读事务，默认值为 false；为了忽略那些不需要事务的方法，比如读取数据，可以设置 read-only 为 true。
rollback-for：用于指定能够触发事务回滚的异常类型，如果有多个异常类型需要指定，各类型之间可以通过逗号分隔。
no-rollback- for 抛出 no-rollback-for 指定的异常类型，不回滚事务。
isolation事务的隔离级别，默认值采用 DEFAULT。

Spring 中事务控制过程分析,如图-11所示:

Spring事务管理是基于接口代理（JDK）或动态字节码（CGLIB）技术，然后通过AOP实施事务增强的。当我们执行添加了事务特性的目标方式时，系统会通过目标对象的代理对象调用DataSourceTransactionManager对象，在事务开始的时，执行doBegin方法，事务结束时执行doCommit或doRollback方法。

Spring 中事务传播特性

事务传播(Propagation)特性指"不同业务(service)对象"中的事务方法之间相互调用时,事务的传播方式,如图-12所示:

其中,常用事务传播方式如下:

@Transactional(propagation=Propagation.REQUIRED) 。

如果没有事务创建新事务, 如果当前有事务参与当前事务, Spring 默认的事务传播行为是PROPAGATION_REQUIRED，它适合于绝大多数的情况。假设 ServiveX#methodX() 都工作在事务环境下（即都被 Spring 事务增强了），假设程序中存在如下的调用链：

Service1#method1()->Service2#method2()->Service3#method3()，那么这 3 个服务类的 3 个方法通过 Spring 的事务传播机制都工作在同一个事务中。如图-13所示：

代码示例如下：

@Transactional(propagation = Propagation.REQUIRED)

@Override

public List<Node> findZtreeMenuNodes() {

return sysMenuDao.findZtreeMenuNodes();

}

当有一个业务对象调用如上方法时，此方法始终工作在一个已经存在的事务方法，或者是由调用者创建的一个事务方法中。

@Transactional(propagation=Propagation.REQUIRES_NEW)。

必须是新事务, 如果有当前事务, 挂起当前事务并且开启新事务，如图-14所示：

代码示例如下：

@Transactional(propagation = Propagation.REQUIRES_NEW)

@Override

public void saveObject(SysLog entity) {

sysLogDao.insertObject(entity);

}

当有一个业务对象调用如上业务方法时，此方法会始终运行在一个新的事务中。

Spring 中事务管理小结

Spring 声明式事务是 Spring 最核心，最常用的功能。由于 Spring 通过 IOC 和 AOP的功能非常透明地实现了声明式事务的功能，对于一般的开发者基本上无须了解 Spring声明式事务的内部细节，仅需要懂得如何配置就可以了。但对于中高端开发者还需要了解其内部机制。

Spring AOP异步操作实现

异步场景分析

在开发系统的过程中，通常会考虑到系统的性能问题，提升系统性能的一个重要思想就是“串行”改“并行”。说起“并行”自然离不开“异步”，今天我们就来聊聊如何使用Spring的@Async的异步注解。

Spring 业务的异步实现

启动异步配置

在基于注解方式的配置中，借助@EnableAsync注解进行异步启动声明，Spring Boot版的项目中，将@EnableAsync注解应用到启动类上，代码示例如下：

@EnableAsync //spring容器启动时会创建线程池

@SpringBootApplication

public class Application {

public static void main(String[] args) {

SpringApplication.run(Application.class, args);

}

Spring中@Async注解应用

在需要异步执行的业务方法上，使用@Async方法进行异步声明。

@Async

@Transactional(propagation = Propagation.REQUIRES_NEW)

@Override

public void saveObject(SysLog entity) {

System.out.println("SysLogServiceImpl.save:"+

Thread.currentThread().getName());

sysLogDao.insertObject(entity);

//try{Thread.sleep(5000);}catch(Exception e) {}

}

假如需要获取业务层异步方法的执行结果，可参考如下代码设计进行实现：

@Transactional(propagation = Propagation.REQUIRES_NEW)

@Async

@Override

public Future<Integer> saveObject(SysLog entity) {

System.out.println("SysLogServiceImpl.save:"+

Thread.currentThread().getName());

int rows=sysLogDao.insertObject(entity);

//try{Thread.sleep(5000);}catch(Exception e) {}

return new AsyncResult<Integer>(rows);

}

其中，AsyncResult对象可以对异步方法的执行结果进行封装，假如外界需要异步方法结果时，可以通过Future对象的get方法获取结果。

当我们需要自己对spring框架提供的连接池进行一些简易配置，可以参考如下代码：

spring:

task:

execution:

pool:

queue-capacity: 128

core-size: 5

max-size: 128

keep-alive: 60000

thread-name-prefix: db-service-task-

对于spring框架中线程池配置参数的涵义，可以参考ThreadPoolExecutor对象中的解释。

说明：对于@Async注解默认会基于ThreadPoolTaskExecutor对象获取工作线程，然后调用由@Async描述的方法，让方法运行于一个工作线程，以实现异步操作。但是假如系统中的默认拒绝处理策略,任务执行过程的异常处理不能满足我们自身业务需求的话,我可以对异步线程池进行自定义.(SpringBoot中默认的异步配置可以参考自动配置对象TaskExecutionAutoConfiguration).

Spring 自定义异步池的实现(拓展)

为了让Spring中的异步池更好的服务于我们的业务,同时也尽量避免OOM，可以自定义线程池优化设计如下：关键代码如下：

package com.cy.pj.common.config

@Slf4j

@Setter

@Configuration

@ConfigurationProperties("async-thread-pool")

public class SpringAsyncConfig implements AsyncConfigurer{

/**核心线程数*/

private int corePoolSize=20;

/**最大线程数*/

private int maximumPoolSize=1000;

/**线程空闲时间*/

private int keepAliveTime=30;

/**阻塞队列容量*/

private int queueCapacity=200;

/**构建线程工厂*/

private ThreadFactory threadFactory=new ThreadFactory() {

//CAS算法

private AtomicInteger at=new AtomicInteger(1000);

@Override

public Thread newThread(Runnable r) {

return new Thread(r,

"db-async-thread-"+at.getAndIncrement());

}

};

@Override

public Executor getAsyncExecutor() {

ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();

executor.setCorePoolSize(corePoolSize);

executor.setMaxPoolSize(maximumPoolSize);

executor.setKeepAliveSeconds(keepAliveTime);

executor.setQueueCapacity(queueCapacity);

executor.setRejectedExecutionHandler((Runnable r,

ThreadPoolExecutor exe) -> {

log.warn("当前任务线程池队列已满.");

});

executor.initialize();

return executor;

}

@Override

public AsyncUncaughtExceptionHandler

getAsyncUncaughtExceptionHandler() {

return new AsyncUncaughtExceptionHandler() {

@Override

public void handleUncaughtException(Throwable ex ,

Method method , Object... params) {

log.error("线程池执行任务发生未知异常.", ex);

}

};

}}

async-thread-pool:

corePoolSize: 20

maxPoolSize: 1000

keepAliveSeconds: 30

queueCapacity: 1000

后续在业务类中,假如我们使用@Async注解描述业务方法，默认会使用ThreadPoolTaskExecutor池对象中的线程执行异步任务。

Spring AOP中Cache操作实现(拓展)

缓存场景分析

在业务方法中我们可能调用数据层方法获取数据库中数据,假如访问数据的频率比较为高,为了提高的查询效率,降低数据库的访问压力,可以在业务层对数据进行缓存.

Spring 中业务缓存应用实现

启动缓存配置

在项目(SpringBoot项目)的启动类上添加@EnableCaching注解,以启动缓存配置。关键代码如下：

package com.cy;

/**

* 异步的自动配置生效).

* @EnableCaching 注解表示启动缓存配置

@EnableCaching

@SpringBootApplication

public class Application {

public static void main(String[] args) {

SpringApplication.run(Application.class, args);

}

业务方法上应用缓存配置

在需要进行缓存的业务方法上通过@Cacheable注解对方法进行相关描述.表示方法的

返回值要存储到Cache中,假如在更新操作时需要将cache中的数据移除,可以在更新方法上使用@CacheEvict注解对方法进行描述。例如：

第一步:在相关模块查询相关业务方法中,使用缓存，关键代码如下：

@Cacheable(value = "deptCache")

@Transactional(readOnly = true)

public List<Map<String,Object>> findObjects() {

....

}

其中，value属性的值表示要使用的缓存对象,名字自己指定，其中底层为一个map对象，当向cache中添加数据时，key默认为方法实际参数的组合。

第二步：在相关模块更新时,清除指定缓存数据,关键代码如下:

@CacheEvict(value="deptCache",allEntries=true)

@Override

public int saveObject(SysDept entity) {...}

其中，allEntries表示清除所有。

说明：spring中的缓存应用原理，如图-15所示：

Spring中自定义缓存的实现(拓展)

在Spring中默认cache底层实现是一个Map对象,假如此map对象不能满足我们实际需要,在实际项目中我们可以将数据存储到第三方缓存系统中.

Spring AOP原生方式实现（拓展）

概述

Spring 整合AspectJ框架实现AOP只是Spring框架中AOP的一种实现方式，此方式相对比较简单，实现方便。但此方式底层还是要转换为Spring原生AOP的实现，Spring AOP原生方式实现的核心有三大部分构成，分别是：

JDK代理。
CGLIB代理。
org.aopalliance包下的拦截体系。

案例架构分析

本小节以Spring中一种原生AOP架构的基本实现为例进行原理分析和说明，其简易架构如图-16所示：

其中DefaultAdvisorAutoProxyCreator这个类功能更为强大，这个类的奇妙之处是他实现BeanPostProcessor接口,当ApplicationContext读取所有的Bean配置信息后，这个类将扫描上下文，寻找所有的Advisor对象(一个Advisor由切入点和通知组成)，将这些Advisor应用到所有符合切入点的Bean中。

案例业务实现

业务描述

创建SpringBoot项目，并基于Spring原生AOP的实现为特定业务对象添加简易日志实现。

核心业务接口定义及实现

定义RequiredLog注解，用于描述目标业务对象

package com.cy.spring.annotation;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.METHOD)

public @interface RequiredLog {

}

定义搜索业务接口，用于定义搜索业务规范

package com.cy.spring.aop;

public interface SearchService {

Object search(String key);

}

定义搜索业务接口实现，并使用requiredLog注解描述

package com.cy.spring.aop;

import org.springframework.stereotype.Service;

import com.cy.spring.annotation.RequiredLog;

@Service

public class DefaultSearchService implements SearchService {

@RequiredLog

@Override

public Object search(String key) {

System.out.println("search by "+key);

return null;

}

日志Advice对象定义

定义LogAdvice对象，基于此对象为目标业务对象做日志增强。

package com.cy.spring.advisor;

import org.aopalliance.intercept.MethodInterceptor;

import org.aopalliance.intercept.MethodInvocation;

public class LogAdvice implements MethodInterceptor {

@Override

public Object invoke(MethodInvocation invocation)

throws Throwable {

System.out.println("start:"+System.currentTimeMillis());

Object result=invocation.proceed();

System.out.println("after:"+System.currentTimeMillis());

return result;

}

其中，MethodInterceptor对象继承Advice对象，基于此对象方法可以对目标方法进行拦截。

日志Advisor对象定义及实现

创建日志Advisor对象，在对象内部定义要切入扩展功能的点以及要应用的通知(Advice)对象。

package com.cy.spring.advisor;

import java.lang.reflect.Method;

import org.springframework.stereotype.Component;

import com.cy.spring.annotation.RequiredLog;

@Component

public class LogAdvisor extends StaticMethodMatcherPointcutAdvisor {

private static final long serialVersionUID = 7022316764822635205L;

public LogMethodMatcher() {

//在特定切入点上要执行的通知

setAdvice(new LogAdvice());

}

//Pointcut

//方法返回值为true时,则可以为目标方法对象创建代理对象

@Override

public boolean matches(Method method,Class<?> targetClass) {

try {

Method targetMethod=

targetClass.getMethod(method.getName(),

method.getParameterTypes());

return targetMethod.isAnnotationPresent(RequiredLog.class);

}catch(Exception e) {

return false;

}

其中，StaticMethodMatcherPointcutAdvisor类为Spring框架中定义的一种Advisor，我们自己写的Advisor可以直接继承此类进行资源整合。

日志业务单元测试实现

基于Spring boot项目进行单元测试：

package com.cy;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.junit4.SpringRunner;

import com.cy.spring.aop.SearchService;

@SpringBootTest

public class CgbSbootAop01ApplicationTests {

@Autowired

private SearchService searchService;

@Test

public void testSearch() {

//System.out.println(searchService);

searchService.search("tedu");

}

说明：在spring 框架中，很多功能都是原生AOP进行了功能的扩展和实现。

总结

重难点分析

AOP 是什么，解决了什么问题，实现原理，应用场景。
AOP 编程基本步骤及实现过程(以基于AspectJ框架实现为例)。
AOP 编程中的核心对象及应用关系。
AOP 思想在Spring中的实现原理分析。
AOP 编程中基于注解注解方式的配置实现。
AOP 编程中基于注解方式的事务控制。
AOP 编程中异步操作的实现?
AOP 编程中的缓存应用?

FAQ分析

什么是OCP原则（开闭原则）？
什么是DIP原则 (依赖倒置)？
什么是单一职责原则(SRP)？
Spring 中AOP的有哪些配置方式？(XML,注解)
Spring 中AOP 的通知有哪些基本类型？(5种)
Spring 中AOP是如何为Bean对象创建代理对象的?(JDK,CGLIB)
Spring 中AOP切面的执行顺序如何指定?(@Order)
Spring 单体架构项目中事务的控制要通过Connection对象实现,？
Spring 如何保证一个线程一个Connection对象?借助ThreadLocal实现.？
多个事务并发执行时可能会出现什么问题？
如何理解数据库中的的悲观锁和乐观锁?
你了解事务的隔离级别吗？知道具体的应用场景吗？
……
….
Bug分析
切入点应用错误,如图-17所示:

问题分析:检查切入点的引入是否丢掉了"()".

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-parent</artifactId>
       <version>2.3.0.RELEASE</version>
       <relativePath/> 
   </parent>
   <groupId>com.cy</groupId>
   <artifactId>CGB-DB-SYS-V3.02</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>CGB-DB-SYS-V3.02</name>
   <description>Demo project for Spring Boot</description>
   <properties>
       <java.version>1.8</java.version>
   </properties>
   <dependencies>
       
       <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
       </dependency>

       
       <dependency>
           <groupId>com.github.pagehelper</groupId>
           <artifactId>pagehelper-spring-boot-starter</artifactId>
           <version>1.3.0</version>
       </dependency>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-actuator</artifactId>
       </dependency>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-jdbc</artifactId>
       </dependency>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-thymeleaf</artifactId>
       </dependency>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-web</artifactId>
       </dependency>
       <dependency>
           <groupId>org.mybatis.spring.boot</groupId>
           <artifactId>mybatis-spring-boot-starter</artifactId>
           <version>2.1.4</version>
       </dependency>

       <dependency>
           <groupId>mysql</groupId>
           <artifactId>mysql-connector-java</artifactId>
           <scope>runtime</scope>
       </dependency>
       <dependency>
           <groupId>org.projectlombok</groupId>
           <artifactId>lombok</artifactId>
           <optional>true</optional>
       </dependency>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-test</artifactId>
           <scope>test</scope>
           <exclusions>
               <exclusion>
                   <groupId>org.junit.vintage</groupId>
                   <artifactId>junit-vintage-engine</artifactId>
               </exclusion>
           </exclusions>
       </dependency>

       <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.6.0</version>
       </dependency>

   </dependencies>

   <build>
       <plugins>
           <plugin>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-maven-plugin</artifactId>
               <configuration>
                   <excludes>
                       <exclude>
                           <groupId>org.projectlombok</groupId>
                           <artifactId>lombok</artifactId>
                       </exclude>
                   </excludes>
               </configuration>
           </plugin>
       </plugins>
   </build>

</project>

#server
server:
port: 80
servlet:
context-path: /

#spring datasource,thymeleaf
spring:
datasource:
url: jdbc:mysql:///dbms?serverTimezone=GMT%2B8&characterEncoding=utf8
username: root
password: root

thymeleaf:
cache: false
prefix: classpath:/templates/pages/
suffix: .html

aop:
proxy-target-class: false #false表示为目标对象基于JDK方式产生代理对象

task:
execution:
pool:
core-size: 8
max-size: 128
keep-alive: 60000
queue-capacity: 256
thread-name-prefix: db-service-thread-

#mybatis
mybatis:
mapper-locations:
- classpath:/mapper/*/*.xml

#log
logging:
level:
com.cy: debug

<ul class="pagination pagination-sm no-margin pull-right">
<li><a class="first">首页</a></li>
   <li><a class="pre">上一页</a></li>
   <li><a class="next">下一页</a></li>
   <li><a class="last">尾页</a></li>
   <li><a class="rowCount">总记录数(0)</a></li>
   <li><a class="pageCount">总页数(0)</a></li>
   <li><a class="pageCurrent">当前页(1)</a></li>
</ul>
<script type="text/javascript">
$(function(){
   $("#pageId")
   .on("click",".first,.pre,.next,.last",doJumpToPage)
})
//初始化分页信息
function doSetPagination(page){//pageObject {rowCount:10,pageCount:3,...}
   //1.初始化总记录数;
   $(".rowCount").html("总记录数("+page.rowCount+")");
   //2.初始化总页数
   $(".pageCount").html("总页数("+page.pageCount+")");
   //3.初始化当前页码值
   $(".pageCurrent").html("当前页("+page.pageCurrent+")");
   //4.存储page信息到指定对象上。
   //data函数为jquery中的一个数据绑定函数，其语法为data(key[,value]);,假如只有key表示取值，两个都有表示值的绑定
   $("#pageId").data("pageCurrent",page.pageCurrent);
   $("#pageId").data("pageCount",page.pageCount);
}
//处理分页点击事件
function doJumpToPage(){
   //debugger
   //1.获得被点击对象的class属性值，基于此值判定被点击的对象
   //prop 函数为jquery中用于获取class属性值的一个函数，其语法为prop(key[,value]);
   var cls=$(this).prop("class");
//2.基于class属性值，修改当前页码值
//2.1获得当前页码值，获得总页数
var pageCurrent=$("#pageId").data("pageCurrent");
var pageCount=$("#pageId").data("pageCount");
//2.2修改当前页码值，并存储(其它地方用到了可以获取)
//2.2.1修改当前页码值
if(cls=="first"){
   pageCurrent=1;
}else if(cls=="pre"&&pageCurrent>1){//上一页
   pageCurrent--;
}else if(cls=="next"&&pageCurrent<pageCount){
   pageCurrent++;
}else if(cls=="last"){
   pageCurrent=pageCount;
}else{
   return;
}
//2.2.2 存储当前页码值
$("#pageId").data("pageCurrent",pageCurrent);
//3.基于新页码值进行新的查询
doGetObjects();
}
</script>

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<title>AdminLTE 2 | Log in</title>

<meta content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no" name="viewport">

<link rel="stylesheet" href="bower_components/bootstrap/dist/css/bootstrap.min.css">

<link rel="stylesheet" href="bower_components/font-awesome/css/font-awesome.min.css">

<link rel="stylesheet" href="bower_components/Ionicons/css/ionicons.min.css">

<link rel="stylesheet" href="dist/css/AdminLTE.min.css">

<link rel="stylesheet" href="plugins/iCheck/square/blue.css">

</head>
<body class="hold-transition login-page">
<div class="login-box">
<div class="login-logo">
<a href="#"><b>DB-</b>SYS</a>
</div>

<div class="login-box-body">
<p class="login-box-msg">Sign in to start your session</p>

<div class="row">
<div class="col-xs-8">
<div class="checkbox icheck">
<label>
<input type="checkbox" id="rememberId"> Remember Me
</label>
</div>
</div>

<div class="col-xs-4">
<button type="button" class="btn btn-primary btn-block btn-flat btn-login">Sign In</button>
</div>

</div>
</form>

</div>

</div>

<script src="bower_components/jquery/dist/jquery.min.js"></script>

<script src="bower_components/bootstrap/dist/js/bootstrap.min.js"></script>

<script src="plugins/iCheck/icheck.min.js"></script>
<script>
$(function () {
$('input').iCheck({
checkboxClass: 'icheckbox_square-blue',
radioClass: 'iradio_square-blue',
increaseArea: '20%' // optional
});
$(".btn").click(doLogin);
});
function doLogin(){

   var params={
       username:$("#usernameId").val(),
       password:$("#passwordId").val(),
       isRememberMe:$("#rememberId").prop("checked"),
   }
   var url="user/doLogin";
   console.log("params",params);
   $.post(url,params,function(result){
       console.log("login.result",result);
       if(result.state==1){
           //跳转到indexUI对应的页面
           location.href="doIndexUI?t="+Math.random();
       }else{
           $(".login-box-msg").html(result.message);
       }
       return false;//防止刷新时重复提交
   });
}
</script>
</body>
</html>

<!DOCTYPE html>

<html>
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<title>动吧 | Starter</title>

<meta content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no" name="viewport">
<link rel="stylesheet" href="bower_components/bootstrap/dist/css/bootstrap.min.css">

<link rel="stylesheet" href="bower_components/font-awesome/css/font-awesome.min.css">

<link rel="stylesheet" href="bower_components/Ionicons/css/ionicons.min.css">

<link rel="stylesheet" href="dist/css/AdminLTE.min.css">

<link rel="stylesheet" href="dist/css/skins/skin-blue.min.css">
<link rel="stylesheet" href="bower_components/layer/skin/default/layer.css">
<link rel="stylesheet" href="bower_components/ztree/css/metroStyle/metroStyle.css"/>
<link rel="stylesheet" href="bower_components/treegrid/jquery.treegrid.css"/>

</head>

<body class="hold-transition skin-blue sidebar-mini">
<div class="wrapper">

<header class="main-header">

<a href="index2.html" class="logo">

<span class="logo-mini">动吧旅游</span>

<span class="logo-lg">动吧旅游</span>
</a>

<nav class="navbar navbar-static-top" role="navigation">

<a href="#" class="sidebar-toggle" data-toggle="push-menu" role="button">
<span class="sr-only">Toggle navigation</span>
</a>

<div class="navbar-custom-menu">
<ul class="nav navbar-nav">

<li class="dropdown messages-menu">

<a href="#" class="dropdown-toggle" data-toggle="dropdown">
<i class="fa fa-envelope-o"></i>
<span class="label label-success">4</span>
</a>
<ul class="dropdown-menu">
<li class="header">You have 4 messages</li>
<li>

<ul class="menu">
<li>
<a href="#">
<div class="pull-left">

<img src="dist/img/user2-160x160.jpg" class="img-circle" alt="User Image">
</div>

<h4>
Support Team
<small><i class="fa fa-clock-o"></i> 5 mins</small>
</h4>

<p>Why not buy a new awesome theme?</p>
</a>
</li>

</ul>

</li>
<li class="footer"><a href="#">See All Messages</a></li>
</ul>
</li>

<li class="dropdown notifications-menu">

<a href="#" class="dropdown-toggle" data-toggle="dropdown">
<i class="fa fa-bell-o"></i>
<span class="label label-warning">10</span>
</a>
<ul class="dropdown-menu">
<li class="header">You have 10 notifications</li>
<li>

<ul class="menu">
<li>
<a href="#">
<i class="fa fa-users text-aqua"></i> 5 new members joined today
</a>
</li>

</ul>
</li>
<li class="footer"><a href="#">View all</a></li>
</ul>
</li>

<li class="dropdown tasks-menu">

<a href="#" class="dropdown-toggle" data-toggle="dropdown">
<i class="fa fa-flag-o"></i>
<span class="label label-danger">9</span>
</a>
<ul class="dropdown-menu">
<li class="header">You have 9 tasks</li>
<li>

<ul class="menu">
<li>
<a href="#">

<h3>
Design some buttons
<small class="pull-right">20%</small>
</h3>

<div class="progress xs">

<div class="progress-bar progress-bar-aqua" style="width: 20%" role="progressbar"
aria-valuenow="20" aria-valuemin="0" aria-valuemax="100">
<span class="sr-only">20% Complete</span>
</div>
</div>
</a>
</li>

</ul>
</li>
<li class="footer">
<a href="#">View all tasks</a>
</li>
</ul>
</li>

<li class="dropdown user user-menu">

<a href="#" class="dropdown-toggle" data-toggle="dropdown">

<img src="dist/img/user2-160x160.jpg" class="user-image" alt="User Image">

<span class="hidden-xs" id="loginUserId">[[${user.username}]]</span>
</a>
<ul class="dropdown-menu">

<li class="user-header">
<img src="dist/img/user2-160x160.jpg" class="img-circle" alt="User Image">

<p>
Alexander Pierce - Web Developer
<small>Member since Nov. 2012</small>
</p>
</li>

<li class="user-body">
<div class="row">
<div class="col-xs-4 text-center">
<a href="#">Followers</a>
</div>
<div class="col-xs-4 text-center">
<a href="#">Sales</a>
</div>
<div class="col-xs-4 text-center">
<a href="#">Friends</a>
</div>
</div>

</li>

<li class="user-footer">
<div class="pull-left">
<a href="#" class="btn btn-default btn-flat">Profile</a>
</div>
<div class="pull-right">
<a href="doLogout" class="btn btn-default btn-sign-out">Sign out</a>
</div>
</li>
</ul>
</li>

<li>
<a href="#" data-toggle="control-sidebar"><i class="fa fa-gears"></i></a>
</li>
</ul>
</div>
</nav>
</header>

<aside class="main-sidebar">

<section class="sidebar">

<ul class="sidebar-menu" data-widget="tree">
<li class="header">HEADER</li>

<li class="treeview">
<a href="#"><i class="fa fa-link"></i>
<span>商品管理</span>
<span class="pull-right-container">
<i class="fa fa-angle-left pull-right"></i>
</span>
</a>
<ul class="treeview-menu">
<li><a id="load-base-id">基本管理</a></li>
<li><a id="load-type-id">类目管理</a></li>
<li><a id="load-brand-id">品牌管理</a></li>
<li><a id="load-attr-id">属性管理</a></li>
</ul>
</li>
<li class="treeview">
<a href="#"><i class="fa fa-link"></i>
<span>系统管理</span>
<span class="pull-right-container">
<i class="fa fa-angle-left pull-right"></i>
</span>
</a>
<ul class="treeview-menu">
<li><a id="load-dept-id">部门管理</a></li>
<li><a id="load-menu-id">菜单管理</a></li>
<li><a id="load-role-id">角色管理</a></li>
<li><a id="load-user-id">用户管理</a></li>
<li><a id="load-log-id"> 日志管理</a></li>
<li><a id="load-pwd-id"> 修改密码</a></li>
</ul>
</li>
</ul>

</section>


</aside>

<div class="content-wrapper">

<section class="content-header">
<h1>
Page Header
<small>Optional description</small>
</h1>
<ol class="breadcrumb">
<li><a href="#"><i class="fa fa-dashboard"></i> Level</a></li>
<li class="active">Here</li>
</ol>
</section>

<section id="mainContentId" class="content container-fluid">

</section>

</div>

<footer class="main-footer">

<div class="pull-right hidden-xs">
Anything you want
</div>

<strong>Copyright © 2016 <a href="#">Company</a>.</strong> All rights reserved.
</footer>

<aside class="control-sidebar control-sidebar-dark">

<ul class="nav nav-tabs nav-justified control-sidebar-tabs">
<li class="active"><a href="#control-sidebar-home-tab" data-toggle="tab"><i class="fa fa-home"></i></a></li>
<li><a href="#control-sidebar-settings-tab" data-toggle="tab"><i class="fa fa-gears"></i></a></li>
</ul>

<div class="tab-content">

<div class="tab-pane active" id="control-sidebar-home-tab">
<h3 class="control-sidebar-heading">Recent Activity</h3>
<ul class="control-sidebar-menu">
<li>
<a href="javascript:;">
<i class="menu-icon fa fa-birthday-cake bg-red"></i>
<div class="menu-info">
<h4 class="control-sidebar-subheading">Langdon's Birthday</h4>
<p>Will be 23 on April 24th</p>
</div>
</a>
</li>
</ul>

<h3 class="control-sidebar-heading">Tasks Progress</h3>
<ul class="control-sidebar-menu">
<li>
<a href="javascript:;">
<h4 class="control-sidebar-subheading">
Custom Template Design
<span class="pull-right-container">
<span class="label label-danger pull-right">70%</span>
</span>
</h4>

</div>


<div class="tab-pane" id="control-sidebar-stats-tab">Stats Tab Content</div>


<div class="tab-pane" id="control-sidebar-settings-tab">
<form method="post">
<h3 class="control-sidebar-heading">General Settings</h3>

<div class="form-group">
<label class="control-sidebar-subheading">
Report panel usage
<input type="checkbox" class="pull-right" checked>
</label>

<p>
Some information about this general settings option
</p>
</div>

</form>
</div>

</div>
</aside>


<div class="control-sidebar-bg"></div>
</div>

<div class="modal fade" id="myModal" tabindex="-1" role="dialog" aria-labelledby="myModalLabel" aria-hidden="true">
<div class="modal-dialog">
<div class="modal-content">
<div class="modal-header">
<button type="button" class="close" data-dismiss="modal" aria-hidden="true">×</button>
<h4 class="modal-title" id="myModalLabel">Modal title</h4>
</div>
<div class="modal-body">
</div>
<div class="modal-footer">
<button type="button" class="btn btn-default" data-dismiss="modal">Close</button>
<button type="button" class="btn btn-primary btn-save">Save changes</button>
</div>
</div>
</div>
</div>



<script src="bower_components/jquery/dist/jquery.min.js"></script>

<script src="bower_components/bootstrap/dist/js/bootstrap.min.js"></script>

<script src="dist/js/adminlte.min.js"></script>
<script type="text/javascript">

$(function(){//页面加载完成之后执行
   doLoadUI("load-log-id","log/log_list");
   doLoadUI("load-menu-id","menu/menu_list");
   doLoadUI("load-role-id","role/role_list");
   doLoadUI("load-dept-id","dept/dept_list");
   doLoadUI("load-user-id","user/user_list");
   doLoadUI("load-pwd-id","user/pwd_edit");
});

</script>
</body>
</html>

<header class="main-header">

<section class="sidebar">

</section>

</div>

<div class="form-group">
<label class="control-sidebar-subheading">
Report panel usage
<input type="checkbox" class="pull-right" checked>
</label>

<p>
Some information about this general settings option
</p>
</div>

</form>
</div>

</div>
</aside>


<div class="control-sidebar-bg"></div>
</div>

<div class="modal fade" id="myModal" tabindex="-1" role="dialog" aria-labelledby="myModalLabel" aria-hidden="true">
<div class="modal-dialog">
<div class="modal-content">
<div class="modal-header">
<button type="button" class="close" data-dismiss="modal" aria-hidden="true">×</button>
<h4 class="modal-title" id="myModalLabel">Modal title</h4>
</div>
<div class="modal-body">
</div>
<div class="modal-footer">
<button type="button" class="btn btn-default" data-dismiss="modal">Close</button>
<button type="button" class="btn btn-primary btn-save">Save changes</button>
</div>
</div>
</div>
</div>



<script src="bower_components/jquery/dist/jquery.min.js"></script>

<script src="bower_components/bootstrap/dist/js/bootstrap.min.js"></script>

<script src="dist/js/adminlte.min.js"></script>
<script type="text/javascript">
function doLoadRS(url){
   //移除可能在mainContentId绑定的数据
   $("#mainContentId").removeData();
   //重新加载url对应的资源，将资源更新到mainContentId对应的位置
   $("#mainContentId").load(url);
}