SpringBoot使用异步线程处理热点接口提高接口并发

• 环境参数
• 配置步骤
• 1.配置项 @Configuration SysConfigure
• 2.配置文件 application.yml
• 3.控制器 Controller
• 4.业务接口 Service
• 5.结果

环境参数

SpringBoot版本 ：2.1.0.RELEASE

<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.0.RELEASE</version>
		<relativePath />
</parent>

配置步骤

1.配置项 @Configuration SysConfigure

自定义一个@Configuration 配置项
配置异步线程池
例如
/配置核心线程数/
/配置最大线程数/
/配置队列大小/
/活跃时间/
/配置线程池中的线程的名称前缀/
/设置拒绝策略：当pool已经达到max size的时候，如何处理新任务/

package com.xzk6.config;

import com.github.pagehelper.PageHelper;
import com.xzk6.config.async.AsyncTaskProperties;
import com.xzk6.constant.IConstants;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.web.servlet.MultipartConfigFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import javax.servlet.MultipartConfigElement;
import java.util.Properties;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;


@Configuration
@Slf4j
public class SysConfigure {
	
    private final AsyncTaskProperties config;

    public SysConfigure(AsyncTaskProperties config) {
        this.config = config;
    }

	
	@Bean(IConstants.ASYNC_POOL)
	public Executor asyncServiceExecutor() {
		log.info("start asyncServiceExecutor(狗头保命)");
		ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
		
		executor.setCorePoolSize(config.getCorePoolSize());
		
		executor.setMaxPoolSize(config.getMaxPoolSize());
		
		executor.setQueueCapacity(config.getQueueCapacity());
		
        executor.setKeepAliveSeconds(config.getKeepAliveSeconds());
		
		executor.setThreadNamePrefix("xzk6-syncThread-");
		
		
		executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
		
		executor.initialize();
		return executor;
	}

}

异步线程池Bean

线程池参数 AsyncTaskProperties

package com.xzk6.config.async;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;


@Data
@Component
@ConfigurationProperties(prefix = "task.pool")
public class AsyncTaskProperties {

    private int corePoolSize;

    private int maxPoolSize;

    private int keepAliveSeconds;

    private int queueCapacity;
}

2.配置文件 application.yml

task:
  pool:
    # 核心线程池大小
    core-pool-size: 10
    # 最大线程数
    max-pool-size: 30
    # 活跃时间
    keep-alive-seconds: 60
    # 队列容量
    queue-capacity: 3000

3.控制器 Controller

package com.xzk6.test.controller;


import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.xzk6.config.redis.RedisUtil;
import com.xzk6.controller.BaseController;
import com.xzk6.test.entity.Test5;
import com.xzk6.test.service.ITest5Service;
import com.xzk6.utils.PageUtil;
import com.xzk6.utils.ResultUtil;
import com.xzk6.utils.Util;
import com.xzk6.utils.UuidUtil;
import com.xzk6.utils.common.CommonUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import java.util.List;
import java.util.Map;



@Api(description = "测试")
@RestController
@RequestMapping("api/pub/test5")
@Slf4j
public class Test5Controller extends BaseController {

    @Autowired
    private ITest5Service iTest5Service;
    @Autowired
    private RedisUtil redisUtil;

    
    @ApiOperation(value = "查看测试列表(分页)", notes = "查看测试列表(分页)", httpMethod = "POST")
    @ApiImplicitParams({})
    @ResponseBody
    @RequestMapping(value = "/testList", produces = "application/json;charset=utf-8")
    public Object findPageList(HttpServletRequest request,  Test5 bean) throws Exception {
        long timer1 = System.currentTimeMillis();
        String uuid = UuidUtil.get32UUID();
        Map<String, Object> param = Util.getRequestParams( request );
        log.info( "执行流水:开始[" + uuid + "]" + in_pageList + bean );
        Integer page = PageUtil.getPage( param );// 获取页码
        Integer size = PageUtil.getSize( param );// 获取条数
        PageHelper.startPage( page, size );
        List<Map<String, Object>> List = iTest5Service.findList( param );
        
        iTest5Service.test(bean);
        PageInfo<Map<String, Object>> pageInfo = new PageInfo<Map<String, Object>>( List );
        int count = (int) pageInfo.getTotal();
        pageInfo = new PageInfo<Map<String, Object>>( ResultUtil.Listvaluechangenull( List ) );
        log.info( "执行流水:结束[" + uuid + "] 总耗时 " + (System.currentTimeMillis() -timer1) );
        return  CommonUtil.successJson( count,pageInfo.getList() );
    }

}

4.业务接口 Service

package com.xzk6.test.service;

import com.xzk6.test.entity.Test5;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
import java.util.Map;


public interface ITest5Service extends IService<Test5> {

    
    List<Map<String, Object>> findList(Map<String, Object> map) throws Exception;


    
    void test(Test5 bean) throws Exception;

  

}

package com.xzk6.test.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xzk6.constant.IConstants;
import com.xzk6.mapper.test.Test5Mapper;
import com.xzk6.test.entity.Test5;
import com.xzk6.test.service.ITest5Service;
import com.xzk6.utils.UuidUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.Map;


@Service
@Slf4j
public class Test5ServiceImpl extends ServiceImpl<Test5Mapper, Test5> implements ITest5Service {

    
    @Override
    public List<Map<String, Object>> findList(Map<String, Object> map) throws Exception {
        return baseMapper.findList( map );
    }

   
    
    @Async(IConstants.ASYNC_POOL)
    @Override
    @Transactional(rollbackFor = {Exception.class})
    public void test(Test5 bean) throws Exception {
       log.info("进入----异步 "+ bean);
       Thread.sleep(3000);
       log.info("结束----异步");
    }

    

}

核心是 在调用方法加上 @Async
核心是 在启动主类加上 @EnableAsync

package com.xzk6;

import com.github.xiaoymin.swaggerbootstrapui.annotations.EnableSwaggerBootstrapUI;
import com.xzk6.config.Init;
import lombok.extern.slf4j.Slf4j;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.transaction.annotation.EnableTransactionManagement;



@EnableAsync
@SpringBootApplication // boot
@EnableTransactionManagement// 事务
@EnableScheduling // 启用定时器
@EnableSwaggerBootstrapUI // swagger
//@ComponentScan("com.xzk6")
@MapperScan(basePackages = {"com.xzk6.mapper"})
@Slf4j
public class ApiApplication {

    
    public static void main(String[] args) {
        long timer = System.currentTimeMillis();
        SpringApplication springapplication = new SpringApplication( ApiApplication .class );
        ApplicationContext applicationContext = springapplication.run( args );
        log.info( "------------------Bean Nums" + applicationContext.getBeanDefinitionCount() );
        Init.init();// 启动私有服务
        log.info( "服务启动[成功] 耗时:[" + ((System.currentTimeMillis() - timer) / 1000) + " 秒]" );
    }
}

完成！ 是不是很简单 来验证结果

5.结果

瞌睡。睡觉。大家晚安。
我是一个莫得感情努力赚钱的工具人