13 AOP面向切面编程简单入门

简介

AOP是对OOP面向对象编程的一种补充和完善,可以不改变原有系统核心业务代码前提下,在对象运行时动态织入一些扩展功能和控制对象的执行.

代理机制

JDK代理: 底层采用JDK动态代理机制为目标对象创建代理对象(前提是目标类必须实现接口.最终代理类和目标类实现共同接口)
CGLIB代理: 底层采用CGLIB代理机制为目标创建代理对象(不需要前提条件,最终代理类会继承目标对象类)

基本点简介

切面(aspect) :切面对象由@Aspect注解声明的类
通知(Advice):@Around,@Before,@After,@AfterReturning,@AfterThrowing
连接点(joinpoint):被拦截的目标对象方法
切入点(pointcut):就是一个标记,有这个标记的方法就是连接点方法,可理解为多个连接点的集合
(切入点表达式:bean,@annotation,within,execution)

项目中用法

首先 pom文件中添加AOP依赖 --基于此依赖spring整合AspectJ框架完成AOP基本实现
其次 定义切面类对象加**@Aspect注解及@Component**交给spring容器管理
其次 添加切入点方法(不添加直接将切入点表达式写在通知注解上也可以)用@Pointcut(“切入点表达式”)
最后 编写功能扩展方法添加通知注解@Around(“切入点方法或者切入点表达式”)
@Around环绕通知是核心可以控制目标方法的执行方法参数ProceedingJoinPoint jp执行jp.proceed()方法就是调用执行目标方法.

总结:不使用AOP时controller调service接口注入的是serviceImpl实现类
使用了AOP后(AOP在serviceImpl实现类上做功能扩展)controller调service接口时,实现类依赖注入会被底层拦截,创建代理对象经过Aspect切面对象对目标对象(serviceImpl实现类)功能扩展后返回数据给代理对象,之后代理对象依赖注入到service,后将数据返回给调用者controller.

基本点详解

通知类型(五种):

@Around(优先级最高,目标方法执行前后都执行)
@Before(目标方法执行前执行)
@After(目标方法执行之后执行)
@AfterReturning()
@AfterThrowing

异常监控切面

其中@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());

切入点表达式

bean表达式 --粗粒度 指定类
"bean(userServiceImpl)"指定spring容器中bean对象名字为userServiceImpl的类里的所有方法执行时都被拦截执行AOP方法做功能扩展
"bean(*ServiceImpl)"指定所有后缀为ServiceImpl的类

within表达式 --粗粒度 指定包 类
"within(aop.service.UserServiceImpl)"指定包中的指定类的所有方法
"within(aop.service.)"指定包中(目录下)的所有类的所有方法
"within(aop.service…)"指定包及其子包的所有类的所有方法

excution表达式 --细粒度 指定方法
“excution(返回值类型 包名.类名.方法名(参数列表))”
"excution(void aop.service.UserServiceImpl.addUser())"匹配指定方法
"excution(void aop.service.UserServiceImpl.addUser(String))"指定方法参数必须为String的方法
"excution(* aop.service….(…))"指定返回值类型任意 aop.service包及其子包下 所有的类 的所有方法参数为任意类型的方法 –万能配置

@annotation表达式 --细粒度 指定方法
"@annotation(anno.RequiredCache)"匹配有该注解的方法 --@RequiredCache为自己编写的方法
首先编写RequiredCache注解

package com.cy.pj.common.annotation;
/**
 * 自定义注解,一个特殊的类,所有注解都默认继承Annotation接口
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RequiredCache {
   //...
}

其次编写Aspect切面对象

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修饰需要添加该缓存的方法即可对目标方法扩展缓存功能.

切面优先级设置

切面优先级需要借助***@Order注解进行描述切面类***(表示该切面类的优先级,优先执行哪个切面类里的方法),数字越小优先级越高,默认优先级最低

Spring AOP事务管理

事务特性

原子性:一个事务中的多个操作,全成功或全失败
一致性:业务执行前后数据总量不变(最终一直即可–柔性事务)
隔离性:事务之间相互隔离
持久性:事务一旦提交,数据要持久保存

Spring中事务管理

Spring框架中提供了一种声明式事务处理方式,此方式基于AOP代理
SpringBoot项目中,内部提供了事务的自动配置,添加spring-boot-starter-jdbc依赖时,框架就会自动注入事务管理器对象(常用的是DataSourceTransactionManager对象)
应用时直接在目标方法上添加@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注解应用在类上时表示类中所有方法启动事务管理，并且一般用于事务共性的定义。
当@Transactional描述方法时表示此方法要进行事务管理，假如类和方法上都有@Transactional注解，则方法上的事务特性优先级比较高。

@Transactional 常用属性：
timeout：事务的超时时间，默认值为-1,表示没有超时显示。如果配置了具体时间,则超过该时间限制但事务还没有完成，则自动回滚事务。这个时间是事务开启以后到sql语句执行之前。
read-only：指定事务是否为只读事务，默认值为 false；为了忽略那些不需要事务的方法，比如读取数据，可以设置read-only为true。对添加，修改，删除业务read-only的值应该为false。
rollback-for：用于指定能够触发事务回滚的异常类型，如果有多个异常类型需要指定，各类型之间可以通过逗号分隔。
no-rollback- for: 抛出no-rollback-for 指定的异常类型，不回滚事务。
isolation事务的隔离级别，默认值采用 DEFAULT。当多个事务并发执行时，可能会出现脏读，不可重复读，幻读等现象时，但假如不希望出现这些现象可考虑修改事务的隔离级别(但隔离级别越高并发就会越小，性能就会越差)
Propagation(事务传播)特性:指"不同业务(service)对象"中的事务方法之间相互调用时
@Transactional(propagation=Propagation.REQUIRED) 。–此方法始终工作在一个已经存在的事务方法，或者是由调用者创建的一个事务方法中
//@Transactional(propagation=Propagation.REQUIRED) Spring 默认的事务传播行为满足大多数情况,因为一般都需要将哪怕是不同事务中各环节调用,都统一放入一个事务中,整个完整的调用链都成功或都失败,下面的_NEW则是始终运行在单独的事务中(开启单独的线程),若有当前事务,则当前事务挂起.
@Transactional(propagation=Propagation.REQUIRES_NEW)。–必须是新事务, 如果有当前事务, 挂起当前事务并且开启新事务(当有一个业务对象调用如上业务方法时，此方法会始终运行在一个新的事务中)

Spring AOP 异步操作实现

首先启动异步配置 –启动类上添加@EnableAsync注解//spring容器启动时会创建线程池
其次在需要异步执行的业务方法上，添加**@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);
	    return new AsyncResult<Integer>(rows);
	}

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

spring框架线程池简易配置

说明:开启异步@Async就会开启一个新的线程,可以对开启线程做一些配置:

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

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

Spring AOP中Cache操作实现

首先 在启动类上添加**@EnableCaching注解**,启动缓存配置
其次 在需要进行缓存的业务方法上通过**@Cacheable注解**
假如在更新操作时需要将cache中的数据移除,可以在更新方法上使用**@CacheEvict注解**对方法进行描述

@Cacheable(value = "menuCache")
@Transactional(readOnly = true)
public List<Map<String,Object>> findObjects() {
....
}

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

 @CacheEvict(value="menuCache",allEntries=true)
 @Override
 public int saveObject(SysDept entity) {...}

allEntries表示清除所有

具体项目中AOP案例

1 定义RequiredLog注解

package com.cy.pj.mail.annotation;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RequiredLog {
}

2 定义Aspect切面对象做功能扩展

3 定义service实现类，并对目标方法使用requiredLog注解描述

package com.cy.pj.mail.aop;
@Service
public class MailServiceImpl implements MailService {
	@RequiredLog
	@Override
	public boolean search(String msg) {
		System.out.println("send "+ key);
		return true;
	}
}

总结

AOP 编程中基于注解方式的事务控制。(@Transactional)
AOP 编程中异步操作的实现?(@EnableAsync,@Async)
AOP 编程中的缓存应用?(@EnableCaching,@Cacheable,@CacheEvict)