spring基于@Async实现方法异步解耦

1.在启动类上加入@EnableAsyn注解

@CrossOrigin
@EnableTransactionManagement
@SpringBootApplication
@EnableSwagger2Doc
@EnableGlobalMethodSecurity(securedEnabled=true,prePostEnabled = true)
@EnableCaching
@EnableAsync
public class PartStockApplication {
    public static void main (String[] args)
    {
        SpringApplication.run(PartStockApplication.class,args);
    }

}

2实现方法的异步解耦

需要注意的是，因为@Async注解的实现是基于Spring的AOP，而AOP的实现是基于动态代理模式实现的。就会出现有可能因为调用方法的是对象本身而不是代理对象，因为没有经过Spring容器。所以会出现没有实现异步的情况

      1.先创建一个component类(直接用this会出现不是异步的情况，通过获取类的代理类来解决不是调用spring容器中的该类中的方法)

@Component
public class TestTask {
    @Autowired
    private PartsService partsService;
    @Autowired
    private PositionService positionService;
    @Autowired
    private SpringUtils springContextUtil;

    @Async
    public Future<List<PartVo>> doTaskOneCallback() throws Exception {
        TestTask testTask =springContextUtil.getBean(TestTask.class);
        List<PartVo> partList = testTask.getPartList();
        return new AsyncResult<List<PartVo>>(partList);
    }

    @Async
    public Future<List<CategoryVo>> doTaskTwoCallback() throws Exception {
        TestTask testTask = springContextUtil.getBean(TestTask.class);
        List<CategoryVo> categoryList = testTask.getCategoryList();
        return new AsyncResult<List<CategoryVo>>(categoryList);
    }


    public  List<PartVo> getPartList() throws InterruptedException {
        System.out.println("开始查询零件");
        long start=System.currentTimeMillis();
        List<PartVo> partsList=partsService.selectAll();
        sleep(6000);
        long end=System.currentTimeMillis();
        System.out.println("零件查询完成耗时"+(end-start)+"毫秒");
        return partsList;
    }
    public List<CategoryVo> getCategoryList() throws InterruptedException {
        System.out.println("获取特殊的四级类目开始");
        long start=System.currentTimeMillis();
        int status=1;
        int type=2;
        List<CategoryVo> list=positionService.selectAll(status,type);
        List<CategoryVo> lists=new ArrayList<>();
        List<CategoryVo> treeOne=list.stream().filter(item->{
            return item.getParentId()==0;
        }).collect(Collectors.toList());
        List<CategoryVo> treeNotOne=list.stream().filter(item->{
            return item.getParentId()!=0;
        }).collect(Collectors.toList());
        treeOne.forEach(item->{
            treeSet(item,treeNotOne);
        });
        treeSets(lists,treeOne);
        sleep(5000);
        long end=System.currentTimeMillis();
        System.out.println("获取特殊的四级类目耗时"+(end-start)+"毫秒");
        return lists;
    }
    public void  treeSet(CategoryVo categoryVo,List<CategoryVo> categoryVoList){
        List<CategoryVo> list=new ArrayList<>();
        categoryVoList.forEach(item->{
            if(categoryVo.getId().equals(item.getParentId())){
                item.setName(categoryVo.getName()+"/"+item.getName());
                list.add(item);
                treeSet(item,categoryVoList);
            }
        });
        if(!list.isEmpty()){
            categoryVo.setChildren(list);
        }
    }

    public void  treeSets(List<CategoryVo> categoryVoList,List<CategoryVo> treeOne){
        treeOne.forEach(item->{
            if(item.getChildren()!=null){
                treeSets(categoryVoList,item.getChildren());
            }else{
                categoryVoList.add(item);
            }
        });
    }

}

测试类（1个是同步代码块一个是实现了异步）

@RestController
@RequestMapping("test")
@CrossOrigin
public class TestController {
    @Autowired
    private TestTask testTask;

    @PostMapping(value = {"testAsync"})
    public List<PartVo>  main() throws Exception {
        long start=System.currentTimeMillis();

        Future<List<PartVo>> stringFuture = testTask.doTaskOneCallback();
        Future<List<CategoryVo>> stringFuture1 = testTask.doTaskTwoCallback();
        List<PartVo> partsList = stringFuture.get();


        List<CategoryVo> categoryList = stringFuture1.get();

        while (!stringFuture.isDone() || !stringFuture1.isDone() ) {
            sleep(100);
        }
//        List<CategoryVo> categoryList = this.getCategoryList();
//        List<PartVo> partsList = this.getPartList();

        Map<String, List<CategoryVo>> collect = categoryList.stream().collect(Collectors.groupingBy(CategoryVo::getName, Collectors.toList()));
//        Map<String, CategoryVo> collect = lists.stream().collect(Collectors.toMap(CategoryVo::getName, CategoryVo->CategoryVo));
        for(PartVo part:partsList) {
            if (collect.get(part.getPCategoryId()) != null) {
                part.setPCId(collect.get(part.getPCategoryId()).get(0).getId());
            }
        }
//        partsService.updatePCId(partsList);
        long end=System.currentTimeMillis();
        System.out.println("任务全部完成，总耗时：" + (end - start) + "毫秒");
        return partsList;
    }




    @PostMapping("partVerse")
    @Transactional
    public List<PartVo> test() throws InterruptedException {
        long start2=System.currentTimeMillis();
        List<PartVo> partsList=testTask.getPartList();
        List<CategoryVo> lists = testTask.getCategoryList();

        Map<String, List<CategoryVo>> collect = lists.stream().collect(Collectors.groupingBy(CategoryVo::getName, Collectors.toList()));
//        Map<String, CategoryVo> collect = lists.stream().collect(Collectors.toMap(CategoryVo::getName, CategoryVo->CategoryVo));
        for(PartVo part:partsList) {
            if (collect.get(part.getPCategoryId()) != null) {
                part.setPCId(collect.get(part.getPCategoryId()).get(0).getId());
            }
        }
//        partsService.updatePCId(partsList);
        long end2=System.currentTimeMillis();
        System.out.println("任务全部完成，总耗时：" + (end2 - start2) + "毫秒");
        return partsList;

    }
}

结果 同步代码块

实现异步以后的结果