Event-driven architecture with Spring Events

package com.example.demo.event;

import com.example.demo.model.User;

import java.time.LocalDateTime;

public class UserRegisteredEvent {
    private final User user;
    private final LocalDateTime timestamp;

    public UserRegisteredEvent(User user) {
        this.user = user;
        this.timestamp = LocalDateTime.now();
    }

    public User getUser() {
        return user;
    }

    public LocalDateTime getTimestamp() {
        return timestamp;
    }
}

package com.example.demo.service;

import com.example.demo.event.UserRegisteredEvent;
import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {

    private final UserRepository userRepository;
    private final ApplicationEventPublisher eventPublisher;

    public UserService(UserRepository userRepository,
                      ApplicationEventPublisher eventPublisher) {
        this.userRepository = userRepository;
        this.eventPublisher = eventPublisher;
    }

    @Transactional
    public User registerUser(User user) {
        User savedUser = userRepository.save(user);

        // Publish event - listeners will handle side effects
        eventPublisher.publishEvent(new UserRegisteredEvent(savedUser));

        return savedUser;
    }
}

package com.example.demo.listener;

import com.example.demo.event.UserRegisteredEvent;
import com.example.demo.service.EmailService;
import com.example.demo.service.AnalyticsService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.event.EventListener;
import org.springframework.core.annotation.Order;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import org.springframework.transaction.event.TransactionalEventListener;
import org.springframework.transaction.event.TransactionPhase;

@Component
public class UserEventListener {

    private static final Logger logger = LoggerFactory.getLogger(UserEventListener.class);

    private final EmailService emailService;
    private final AnalyticsService analyticsService;

    public UserEventListener(EmailService emailService,
                            AnalyticsService analyticsService) {
        this.emailService = emailService;
        this.analyticsService = analyticsService;
    }

    // Executes after transaction commits
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    @Order(1)
    public void sendWelcomeEmail(UserRegisteredEvent event) {
        logger.info("Sending welcome email to: {}", event.getUser().getEmail());
        emailService.sendWelcomeEmail(event.getUser());
    }

    // Async event listener
    @EventListener
    @Async
    @Order(2)
    public void trackRegistration(UserRegisteredEvent event) {
        logger.info("Tracking user registration analytics");
        analyticsService.trackUserRegistration(event.getUser().getId());
    }

    // Synchronous listener
    @EventListener
    @Order(3)
    public void logRegistration(UserRegisteredEvent event) {
        logger.info("User registered: {} at {}",
            event.getUser().getEmail(),
            event.getTimestamp());
    }

    // Conditional listener
    @EventListener(condition = "#event.user.email.endsWith('@company.com')")
    public void handleInternalUser(UserRegisteredEvent event) {
        logger.info("Internal user registered: {}", event.getUser().getEmail());
        // Special handling for internal users
    }
}