SpringBoot使用异步Spring Event事件

适用场景

原始的业务方法中,加入新的业务逻辑,这两部分需要进行解耦 .同时新逻辑还要支持事务
比如,支付成功之后,需要对订单进行状态修改

实现步骤

1.定义事件携带的消息对象

package com.charm.study.common;
import lombok.Data;
import java.math.BigDecimal;

/**
 * @Description: 订单消息
 **/
@Data
public class OrderMessage {
    private Long orderId;
    private String orderSn;
    private BigDecimal money;
}

2.定义Spring事件对象

package com.charm.study.common;
import org.springframework.context.ApplicationEvent;

/**
 * @Description: 自定义事件
 **/
public class OrderEvent extends ApplicationEvent {
    private OrderMessage orderMessage;

    public OrderEvent(Object source, OrderMessage orderMessage) {
        super(source);
        this.orderMessage = orderMessage;
    }

    public OrderMessage getOrderMessage() {
        return orderMessage;
    }
    public void setOrderMessage(OrderMessage orderMessage) {
        this.orderMessage = orderMessage;
    }
}

3.定义消息发布者

可以在其他服务实现类，比如说支付服务PayServiceImpl注入OrderPublisher，在支付成功的方法里面，通过调用orderPublisher调用publishOrderEvent方法，进行后续的事件监听逻辑处理，进行支付和后续的订单状态修改的逻辑解耦.

需要注意:
如果,事件监听者那里是异步监听的话,这里的方法调用就会异步立马返回; 反之,同步调用的话,这里会同步阻塞,事件监听里面的handleEvent

package com.charm.study.common;

import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Component;

/**
 * @Description: 消息发布者
 **/
@Component
@Slf4j
public class OrderPublisher {
    @Autowired
    private ApplicationEventPublisher publisher;
    
    public void publishOrderEvent(OrderMessage orderMessage) {
        log.info("待发布事件,包含的订单消息:{}", JSON.toJSONString(orderMessage));
		//需要注意，如果事件监听是同步监听的话，这里会同步阻塞，直到后面OrderListener.handleEvent(OrderEvent event) 执行完，才会进行下一步返回
		//如果事件监听是异步的话，这里会直接快速返回，后面OrderAsyncListener.handleEvent(OrderEvent event),会进行异步的执行
        publisher.publishEvent(new OrderEvent(this,orderMessage));
    }
}

4.定义事件监听者

4.1 进行同步监听

package com.charm.study.common;

import com.charm.study.service.OrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.event.EventListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * @Description: 同步监听
 **/
@Component
@Slf4j
public class OrderListener {
    @Resource
    private OrderService orderService;
    @EventListener
    public void handleEvent(OrderEvent event) {
        log.info("同步>>>>>>>>事件监听到了......");
        orderService.updateOrderOther(event.getOrderMessage());
        log.info("同步>>>>>>>>事件监听结束了");
    }
}

4.2 进行异步监听

package com.charm.study.common;

import com.charm.study.service.OrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.event.EventListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * @Description: 异步监听者
 **/
@Component
@Slf4j
public class OrderAsyncListener {
    @Resource
    private OrderService orderService;

    /**
     * 1.@Async是用来实现异步监听的,同时需要Springboot启动类上面加@EnableAsync
     * 2.@Async("taskExecutor")是使用自定义线程池,创建线程执行handleEvent逻辑
     * 3.也可以直接使用@Async注解,则使用的是Spring默认的线程池SimpleAsyncTaskExecutor
     * 4.如果需要有事务的话,需要@Transactional事务注解加到的ShareGiftServic实现类的的updateOrderOther方法上,不能在这里加
     */
    @Async("taskExecutor") 
    @EventListener
    public void handleEvent(OrderEvent event) {
        log.info("异步>>>>>>>>事件监听到了......");
        orderService.updateOrderOther(event.getOrderMessage());
        log.info("异步>>>>>>>>事件监听结束了");
    }
}

启动类,支持异步方法执行

package com.charm.study;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;

@SpringBootApplication
@EnableAsync //支持异步方法执行
public class PromoteApplication {
    public static void main(String[] args) {
        SpringApplication.run(PromoteApplication.class, args);
    }
}

订单服务实现类

package com.charm.study.service.impl;

import com.charm.study.common.OrderMessage;
import com.charm.study.common.OrderPublisher;
import com.charm.study.dao.OrderDao;
import com.charm.study.domain.Order;
import com.charm.study.service.OrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

/**
 * @Description: 订单服务接口实现类
 **/
@Service
@Slf4j
public class OrderServiceImpl implements OrderService {
    @Resource
    private OrderDao orderDao;
    
    @Override
    @Transactional //方法支持事务
    public void updateOrderOther(OrderMessage orderMessage) {
        //todo... 新加的其他处理处理逻辑

    }

正文结束