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("LogServiceImpl.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-
      thread-name-prefix: DD-SEVICE-THREAD-

对于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);
            }
        };
    }}

其中:@ConfigurationProperties(“async-thread-pool”)的含义是读取application.yml配置文件中以"async-thread-pool"名为前缀的配置信息,并通过所描述类的set方法赋值给对应的属性,在application.yml中连接器池的关键配置如下:

async-thread-pool:
       corePoolSize: 20
       maxPoolSize: 1000
       keepAliveSeconds: 30
       queueCapacity: 1000

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

Spring AOP中Cache操作实现

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

Spring 中业务缓存应用实现：

• 启动缓存配置
  在项目(SpringBoot项目)的启动类上添加@EnableCaching注解,以启动缓存配置。

业务方法上应用缓存配置

在需要进行缓存的业务方法上通过@Cacheable注解对方法进行相关描述.表示方法的
返回值要存储到Cache中,假如在更新操作时需要将cache中的数据移除,可以在更新方法上使用@CacheEvict注解对方法进行描述。

• 在相关模块查询相关业务方法中,使用缓存

@Cacheable(value = "deptCache")
@Transactional(readOnly = true)

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

• 在相关模块更新时,清除指定缓存数据

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

其中，allEntries表示清除所有。

spring中的缓存应用原理

• Spring中自定义缓存的实现
  在Spring中默认cache底层实现是一个Map对象,假如此map对象不能满足我们实际需要,在实际项目中我们可以将数据存储到第三方缓存系统中.
  （ps：大概是那样zookeeper）

Spring AOP原生方式实现

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

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

案例架构分析

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

其中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)
pu

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

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进行了功能的扩展和实现。