Spring Boot提供了一套强大的事件发布和监听机制，允许不同部分的应用程序相互通信。本文将在Spring Boot应用程序中使用事件监听和处理，通过一个用户活动跟踪系统的案例，展示事件驱动架构在现代应用程序中的应用。

肖哥弹架构 跟大家“弹弹” Spring Boot，需要代码关注

欢迎 点赞，点赞，点赞。

关注公号Solomon肖哥弹架构获取更多精彩内容

历史热点文章

场景：

用户活动跟踪系统需要记录用户的关键行为，并在用户执行特定操作时触发相应的处理逻辑，如积分更新、日志记录或发送通知。

使用技术点：
  1. 事件发布：在Spring Boot中发布自定义事件。
  2. 事件监听：使用@EventListener注解监听事件。
  3. 应用程序事件：Spring的ApplicationEvent类及其子类。
工作流程图：

代码：
创建自定义事件：
    import org.springframework.context.ApplicationEvent;

    public class UserActivityEvent extends ApplicationEvent {
        private String userId;
        private String activity;

        public UserActivityEvent(Object source, String userId, String activity) {
            super(source);
            this.userId = userId;
            this.activity = activity;
        }

        public String getUserId() {
            return userId;
        }

        public String getActivity() {
            return activity;
        }
    }
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
发布事件：
    import org.springframework.stereotype.Component;

    @Component
    public class EventPublisher {

        private final ApplicationEventPublisher publisher;

        @Autowired
        public EventPublisher(ApplicationEventPublisher publisher) {
            this.publisher = publisher;
        }

        public void publishUserActivityEvent(String userId, String activity) {
            publisher.publishEvent(new UserActivityEvent(this, userId, activity));
        }
    }
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
业务逻辑服务类（UserService）
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    private final EventPublisher eventPublisher;
    private final UserPonitRepository userPointRepository; // 假设积分仓库

    @Autowired
    public UserService(EventPublisher eventPublisher, UserPonitRepository userPointRepository) {
        this.eventPublisher = eventPublisher;
        this.userPointRepository = userPointRepository;
    }

    // 检查用户状态并更新积分
    public void checkUserStatusAndUpdatePoints(String userId, String activity) {
        // 假设这里有逻辑来检查用户状态
        boolean isActive = isUserActive(userId);

        if (isActive) {
            // 用户活跃，更新积分
            updatePoints(userId, activity);
            
            // 发布用户活动事件
            eventPublisher.publishUserActivityEvent(userId, activity);
        } else {
            // 用户不活跃，处理不活跃逻辑
        }
    }

    private boolean isUserActive(String userId) {
        // 这里应该有检查用户状态的逻辑
        return true; // 假设总是返回活跃状态
    }

    private void updatePoints(String userId, String activity) {
        // 这里应该有更新用户积分的逻辑
        // 根据用户行为来增加积分
        int pointsToAdd = calculatePointsForActivity(activity);
        User user = userPointRepository.findById(userId).orElseThrow();
        user.addPoints(pointsToAdd);
        userPointRepository.save(user);
    }

    private int calculatePointsForActivity(String activity) {
        // 根据活动类型返回不同的积分数
        return 10; // 假设每种活动增加10积分
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.
  • 46.
  • 47.
  • 48.
  • 49.
  • 50.
监听事件：
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.event.EventListener;
    import org.springframework.stereotype.Component;

    @Component
    public class UserActivityListener {

        private final UserService userService;

        @Autowired
        public UserActivityListener(UserService userService) {
            this.userService = userService;
        }

        @EventListener
        public void handleUserActivityEvent(UserActivityEvent event) {
            String userId = event.getUserId();
            String activity = event.getActivity();

            // 委托UserService来处理用户活动
            userService.checkUserStatusAndUpdatePoints(userId, activity);
        }
    }
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
触发事件：
    @RestController
    public class UserController {

        @Autowired
        private UserService userService;

        @PostMapping("/user/performActivity")
        public String userPerformActivity(@RequestParam String userId, @RequestParam String activity) {
            // 委托UserService来检查用户状态并更新积分
            userService.checkUserStatusAndUpdatePoints(userId, activity);

            return "User activity processed";
        }
    }
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
启动类（Application）
@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
结论：

Spring Boot的事件发布和监听机制为构建响应式和可扩展的应用程序提供了一种有效的方式。通过使用事件，应用程序的不同部分可以以松耦合的方式进行通信，使得系统更加灵活和易于维护。在用户活动跟踪系统中，事件监听和处理机制可以有效地记录和响应用户的关键行为，从而提供个性化的用户体验和业务逻辑。