SpringBoot使用ApplicationEvent&Listener完成业务解耦

下面将详细讲解“SpringBoot使用ApplicationEvent&Listener完成业务解耦”的完整攻略。

什么是ApplicationEvent&Listener？

ApplicationEvent 和 ApplicationListener 是 Spring framework 为我们提供的一种应用级别的事件和监听机制，通过这种机制我们可以自己定义事件，当事件触发时监听器收到通知，从而做出相应的响应。

如何使用ApplicationEvent&Listener？

步骤一：定义事件

首先，我们需要定义一个事件，这个事件需要继承 ApplicationEvent 类。

public class CustomEvent extends ApplicationEvent {
    private String message;

    public CustomEvent(Object source, String message) {
        super(source);
        this.message = message;
    }

    public String getMessage() {
        return message;
    }
}

步骤二：定义监听器

接下来，我们需要定义一个监听器，这个监听器需要实现 ApplicationListener 接口，监听器必须注册到 ApplicationContext 中。

@Component
public class CustomEventListener implements ApplicationListener<CustomEvent> {
    @Override
    public void onApplicationEvent(CustomEvent event) {
        System.out.println("CustomEventListener received message: " + event.getMessage());
    }
}

步骤三：触发事件

最后，在需要触发事件的地方，我们使用 ApplicationContext 发布我们自己定义的事件，监听器会接收到这个事件并做出响应。

@RestController
@RequestMapping("/event")
public class CustomEventController {

    @Autowired
    private ApplicationContext context;

    @GetMapping("/publish")
    public String publishEvent(@RequestParam String message) {
        context.publishEvent(new CustomEvent(this, message));
        return "Event published!";
    }
}

示例应用一

考虑这样一种场景：用户完成注册操作后需要给用户发送一封注册成功邮件。

首先，定义一个事件：

public class RegisterSuccessEvent extends ApplicationEvent {
    private RegisterForm registerForm;

    public RegisterSuccessEvent(Object source, RegisterForm registerForm) {
        super(source);
        this.registerForm = registerForm;
    }

    public RegisterForm getRegisterForm() {
        return registerForm;
    }
}

接着，定义一个邮件发送监听器：

@Component
public class EmailSender implements ApplicationListener<RegisterSuccessEvent> {

    @Override
    public void onApplicationEvent(RegisterSuccessEvent event) {
        RegisterForm registerForm = event.getRegisterForm();
        // 发送邮件的业务逻辑
        System.out.println("Send email to " + registerForm.getEmail() + " successfully！");
    }
}

最后，在注册成功的地方发布注册成功事件：

@Component
public class RegisterService {
    @Autowired
    private ApplicationContext context;

    public void register(RegisterForm registerForm) {
        // 保存注册信息
        context.publishEvent(new RegisterSuccessEvent(this, registerForm));
    }
}

示例应用二

再考虑另一个例子：当订单支付成功后需要发送短信通知用户。

首先，定义一个事件：

public class PaymentSuccessEvent extends ApplicationEvent {
    private Order order;

    public PaymentSuccessEvent(Object source, Order order) {
        super(source);
        this.order = order;
    }

    public Order getOrder() {
        return order;
    }
}

然后，定义一个短信通知监听器：

@Component
public class SmsSender implements ApplicationListener<PaymentSuccessEvent> {

    @Override
    public void onApplicationEvent(PaymentSuccessEvent event) {
        Order order = event.getOrder();
        // 发送短信的业务逻辑
        System.out.println("Send SMS to " + order.getUser().getMobile() + " successfully！");
    }
}

最后，在支付成功的地方发布支付成功事件：

@Component
public class PaymentService {

    @Autowired
    private ApplicationContext context;

    public void pay(Order order) {
        // 支付业务逻辑
        context.publishEvent(new PaymentSuccessEvent(this, order));
    }
}

至此，我们就成功的实现了应用级别的事件和监听机制，达到了业务解耦的目的。

总结

利用 Spring 的事件和监听机制，我们可以打造一个高度灵活的应用程序，在应用程序中组织各种业务逻辑，使得应用程序具有更高的可扩展、可维护性，逐步实现从单体应用向微服务架构转型的目标。