Spring Boot 事件和监听

Application Events and Listeners

1、自定义事件和监听

1.1、定义事件

 package com.cjs.boot.event;

 import lombok.Data;
 import org.springframework.context.ApplicationEvent;

 @Data
 public class BlackListEvent extends ApplicationEvent {

     private String address;

     public BlackListEvent(Object source, String address) {
         super(source);
         this.address = address;
     }
 }

1.2、定义监听

 package com.cjs.boot.event;

 import org.springframework.context.ApplicationListener;
 import org.springframework.context.event.EventListener;
 import org.springframework.stereotype.Component;

 public class BlackListListener implements ApplicationListener<BlackListEvent> {

     @Override
     public void onApplicationEvent(BlackListEvent event) {
         System.out.println("监听到BlackListEvent事件: " + event.getAddress());
         try {
             Thread.sleep(2000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
 }

1.3、注册监听

 package com.cjs.boot;

 import com.cjs.boot.event.BlackListListener;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.web.server.ErrorPage;
 import org.springframework.boot.web.server.ErrorPageRegistrar;
 import org.springframework.boot.web.server.ErrorPageRegistry;
 import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.context.annotation.Bean;
 import org.springframework.http.HttpStatus;
 import org.springframework.scheduling.annotation.EnableAsync;

 @SpringBootApplication
 public class CjsSpringbootExampleApplication {

     public static void main(String[] args) {

         SpringApplication springApplication = new SpringApplication(CjsSpringbootExampleApplication.class);
         springApplication.addListeners(new BlackListListener());
         springApplication.run(args);

     }

1.4、发布事件

 package com.cjs.boot.controller;

 import com.cjs.boot.event.BlackListEvent;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;

 @RestController
 @RequestMapping("/activity")
 public class ActivityController {

 //    @Autowired
 //    private ApplicationEventPublisher publisher;

     @Autowired
     private ApplicationContext publisher;

     @GetMapping("/sayHello.json")
     public void sayHello() {

         /**
          * You may register as many event listeners as you wish, but note that by default event listeners receive events synchronously.
          * This means the publishEvent() method blocks until all listeners have finished processing the event.
          */

         BlackListEvent event = new BlackListEvent(this, "abc@126.com");
         publisher.publishEvent(event);
         System.out.println("事件发布成功");
     }

 }

2、基于注解的事件监听

package com.cjs.boot.event;

import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

@Component
public class BlackListListener {

    @EventListener
    public void processBlackListEvent(BlackListEvent event) {
        System.out.println(123);
    }
}

---

package com.cjs.boot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class CjsSpringbootExampleApplication {

    public static void main(String[] args) {
        SpringApplication.run(CjsSpringbootExampleApplication.class, args);
    }

}

3、异步监听

 @EventListener
 @Async
 public void processBlackListEvent(BlackListEvent event) {
     // BlackListEvent is processed in a separate thread
 }

4、应用

 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.event.EventListener;
 import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Component;

 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
 import java.util.concurrent.atomic.AtomicInteger;

 /**
  * 批量送券
  */
 @Slf4j
 @Component
 public class BatchSendCouponListener {

     @Autowired
     private CouponPresentLogService couponPresentLogService;

     @Async
     @EventListener
     public void processBatchSendCouponEvent(BatchSendCouponEvent batchSendCouponEvent) {
         Long cpId = batchSendCouponEvent.getCouponPresentId();
         log.info("收到BatchSendCouponEvent, cpId={}", cpId);
         List<CouponPresentLogEntity> list = couponPresentLogService.selectByPid(cpId);

         handle(cpId, list, 0);
     }

     private void handle(Long cpId, List<CouponPresentLogEntity> list, int times) {
         if (times >= 2) {
             log.info("超过重试次数退出, cpId: {}, 剩余: {}", cpId, list.size());
             return;
         }

         List<Future<CouponPresentLogEntity>> futureList = new ArrayList<>();

         for (CouponPresentLogEntity entity : list) {
             futureList.add(couponPresentLogService.present(entity));
         }

         AtomicInteger count = new AtomicInteger(0);
         //  收集失败的
         List<CouponPresentLogEntity> failList = new ArrayList<>();
         for (Future<CouponPresentLogEntity> future : futureList) {
             try {
                 CouponPresentLogEntity couponPresentLogEntity = future.get();
                 if (couponPresentLogEntity.getStatus() != PresentStatusEnum.SUCCESS.getType().intValue()) {
                     failList.add(couponPresentLogEntity);
                 }
                 count.getAndIncrement();
                 if (count.intValue() >= list.size()) {
                     List<CouponPresentLogEntity> failPresentLogList = couponPresentLogService.selectFailLogByPid(cpId);
                     if (null != failPresentLogList && failPresentLogList.size() > 0) {
                         times++;
                         log.info("第{}次重试, CPID: {}, 总计: {}, 失败: {}", times, cpId, list.size(), failPresentLogList.size());
                         handle(cpId, failPresentLogList, times);
                     }
                 }
             } catch (InterruptedException e) {
                 log.error(e.getMessage(), e);
             } catch (ExecutionException e) {
                 log.error(e.getMessage(), e);
             }
         }
     }

 }

 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.scheduling.annotation.Async;
 import org.springframework.scheduling.annotation.AsyncResult;
 import org.springframework.stereotype.Service;

 import javax.annotation.Resource;
 import java.util.concurrent.*;

 @Service
 @Slf4j
 public class CouponPresentLogServiceImpl implements CouponPresentLogService {

     @Autowired
     private CouponPresentLogDao couponPresentLogDao;
     @Resource
     private CouponSendRpcService couponSendRpcService;

     @Async("myThreadPoolTaskExecutor")
     @Override
     public Future<CouponPresentLogEntity> present(CouponPresentLogEntity entity) {
         try {
             CouponBaseResponse rst = couponSendRpcService.send(entity.getUserId(), entity.getCouponBatchKey(), "1", entity.getVendorId());
             if (null != rst && rst.isSuccess()) {
                 entity.setStatus(PresentStatusEnum.SUCCESS.getType());
                 entity.setFailureReason(PresentStatusEnum.SUCCESS.getName());
             }else {
                 String reason = (null == rst) ? "响应异常" : rst.getMsg();
                 entity.setFailureReason(reason);
                 entity.setStatus(PresentStatusEnum.FAILURE.getType());
             }
         }catch (Exception ex) {
             log.error(ex.getMessage(), ex);
             entity.setFailureReason(ex.getMessage());
             entity.setStatus(PresentStatusEnum.FAILURE.getType());
         }
         couponPresentLogDao.update(entity);

         return new AsyncResult<CouponPresentLogEntity>(entity);
     }

 }

5、统计异步任务执行的进度

利用Future获取执行结果，比如上面的例子中，由于不是直接提交的任务，所以用AsyncResult来返回结果

上面的例子中，一个大任务，然后下面有许多子任务。在主任务中，统计各子任务的执行情况，是成功还是失败，然后统计成功多少，失败多少

也可以这样写：

@Autowired
ThreadPoolTaskExecutor taskExecutor;

Future<Object> future = taskExecutor.submit(new Callable<Object>() {
    @Override
    public Object call() throws Exception {
        return null;
    }
});