design patterns in spring boot

// 1. Định nghĩa Interface chung
public interface PaymentStrategy {
   PaymentResult process(PaymentRequest request);
   String getType(); // Discriminator để phân loại
}
 
// 2. Các Implementations cụ thể
@Component
public class CreditCardPayment implements PaymentStrategy {
   @Override
   public PaymentResult process(PaymentRequest request) { /* Logic thẻ tín dụng */ }
   @Override
   public String getType() { return "CREDIT_CARD"; }
}
 
@Component
public class BankTransferPayment implements PaymentStrategy {
   @Override
   public PaymentResult process(PaymentRequest request) { /* Logic chuyển khoản */ }
   @Override
   public String getType() { return "BANK_TRANSFER"; }
}
 
// 3. Factory - Nơi Spring tự động gom tất cả các bean implement PaymentStrategy
@Component
@RequiredArgsConstructor
public class PaymentStrategyFactory {
   private final List<PaymentStrategy> strategies;
 
   public PaymentStrategy getStrategy(String type) {
       return strategies.stream()
           .filter(s -> s.getType().equals(type))
           .findFirst()
           .orElseThrow(() -> new UnsupportedPaymentException(type));
   }
}
 
// 4. Lớp Service sử dụng - Hoàn toàn không biết về các implementation chi tiết
@Service
@RequiredArgsConstructor
public class PaymentService {
   private final PaymentStrategyFactory factory;
 
   public PaymentResult pay(String type, PaymentRequest request) {
       return factory.getStrategy(type).process(request);
   }
}

// Abstract base class quy định luồng thực thi chuẩn
public abstract class AbstractDataImporter<T> {
 
   // Đánh dấu final để ngăn subclass phá vỡ luồng chuẩn
   public final ImportResult execute(InputStream input) {
       List<T> records = parse(input);
       List<T> validated = records.stream()
           .filter(this::validate)
           .toList();
       int saved = persist(validated);
       postProcess(validated);
 
       return new ImportResult(records.size(), saved);
   }
 
   // Các bước bắt buộc subclass phải tự định nghĩa
   protected abstract List<T> parse(InputStream input);
   protected abstract boolean validate(T record);
 
   // Các bước có sẵn implementation mặc định (Hook methods)
   // (repository: giả định được truyền vào qua constructor của lớp cha)
   protected int persist(List<T> records) {
       return repository.saveAll(records).size();
   }
 
   protected void postProcess(List<T> records) {
       // Default là không làm gì cả
   }
}
 
// Concrete implementation
@Component
public class CsvUserImporter extends AbstractDataImporter<UserDTO> {
   @Override
   protected List<UserDTO> parse(InputStream input) { /* Logic đọc CSV */ }
 
   @Override
   protected boolean validate(UserDTO user) {
       return user.getEmail() != null && StringUtils.hasText(user.getName());
   }
}

// Event class
public class OrderCompletedEvent extends ApplicationEvent {
   @Getter
   private final Order order;
 
   public OrderCompletedEvent(Object source, Order order) {
       super(source);
       this.order = order;
   }
}
 
// Publisher - Tập trung vào core business, không quan tâm ai lắng nghe
@Service
@RequiredArgsConstructor
public class OrderService {
   private final ApplicationEventPublisher publisher;
 
   @Transactional
   public Order complete(UUID orderId) {
       Order order = findAndComplete(orderId);
       // Bắn event ra ngoài
       publisher.publishEvent(new OrderCompletedEvent(this, order));
       return order;
   }
}
 
// Listeners - Xử lý các side-effects độc lập
@Component
public class InventoryListener {
   @EventListener
   public void onOrderCompleted(OrderCompletedEvent event) {
       decrementStock(event.getOrder().getItems());
   }
}
 
// Đảm bảo tính nhất quán dữ liệu: Chỉ trigger khi Transaction gốc đã commit thành công
@Component
public class AnalyticsListener {
   @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
   public void onOrderCompleted(OrderCompletedEvent event) {
       trackConversion(event.getOrder());
   }
}

// Abstract Factory - Phù hợp cho việc khởi tạo một "họ" các đối tượng liên quan
public interface StorageFactory {
   FileWriter createWriter();
   FileReader createReader();
   FileDeleter createDeleter();
}
 
// Khởi tạo bean dựa trên cấu hình môi trường
@Component
@ConditionalOnProperty(name = "storage.type", havingValue = "s3")
public class S3StorageFactory implements StorageFactory {
   public FileWriter createWriter() { return new S3Writer(); }
   public FileReader createReader() { return new S3Reader(); }
   public FileDeleter createDeleter() { return new S3Deleter(); }
}

// HTTP Filter chain — mỗi filter decorate request/response
@Component
@Order(1)
public class RequestTracingFilter extends OncePerRequestFilter {
   @Override
   protected void doFilterInternal(HttpServletRequest request,
           HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
       String traceId = extractOrGenerate(request);
       MDC.put("traceId", traceId);
       try {
           chain.doFilter(request, response); // delegate to next
       } finally {
           MDC.clear();
       }
   }
}
 
// Service decorator — add caching/logging/retry around existing service
@Component
@Primary
@RequiredArgsConstructor
public class CachedUserService implements UserService {
   // Spring bỏ qua chính bean này khi tìm UserService để inject (self reference),
   // nên delegate là implementation gốc. Có nhiều implementation khác thì cần thêm @Qualifier.
   private final UserService delegate; // original implementation
   private final Cache cache;
 
   @Override
   public User findById(UUID id) {
       return cache.get(id, () -> delegate.findById(id));
   }
}

// Handler interface
public interface ValidationHandler {
   ValidationResult validate(Document document);
   int getOrder();
}
 
// Các Validator cụ thể
@Component
@Order(1)
public class SizeValidator implements ValidationHandler {
   public ValidationResult validate(Document doc) {
       if (doc.getSize() > MAX_SIZE) return ValidationResult.fail("File quá lớn");
       return ValidationResult.ok();
   }
   public int getOrder() { return 1; }
}
 
@Component
@Order(2)
public class MimeTypeValidator implements ValidationHandler {
   public ValidationResult validate(Document doc) {
       if (!ALLOWED_TYPES.contains(doc.getMimeType())) return ValidationResult.fail("Định dạng không hợp lệ");
       return ValidationResult.ok();
   }
   public int getOrder() { return 2; }
}
 
// Executor quản lý chuỗi
@Component
public class ValidationChain {
   private final List<ValidationHandler> handlers;
 
   public ValidationChain(List<ValidationHandler> handlers) {
       this.handlers = handlers.stream()
           .sorted(Comparator.comparingInt(ValidationHandler::getOrder))
           .toList();
   }
 
   public ValidationResult validate(Document document) {
       for (ValidationHandler handler : handlers) {
           ValidationResult result = handler.validate(document);
           // Dừng chuỗi ngay lập tức nếu có một handler báo lỗi (Short-circuit)
           if (result.isFailed()) return result;
       }
       return ValidationResult.ok();
   }
}

// Standard builder, immutable
@Value
@Builder
public class SearchCriteria {
   private String keyword;
   @Builder.Default
   private int page = 0;
   @Builder.Default
   private int size = 20;
   private String sortBy;
   private SortDirection direction;
}
 
// Usage
SearchCriteria criteria = SearchCriteria.builder()
   .keyword("report")
   .page(2)
   .sortBy("createdDate")
   .build();
 
// Builder with inheritance (ví dụ này dùng @Data nên vẫn mutable)
@SuperBuilder
public abstract class BaseEntity {
   private UUID id;
   private LocalDateTime createdAt;
}
 
@SuperBuilder
@Data
public class Product extends BaseEntity {
   private String name;
   private BigDecimal price;
}

// JPA Specification — composable query predicates
public class ProductSpecifications {
 
   public static Specification<Product> hasName(String name) {
       return (root, query, cb) ->
           name == null ? null : cb.like(cb.lower(root.get("name")), "%" + name.toLowerCase() + "%");
   }
 
   public static Specification<Product> hasCategory(String category) {
       return (root, query, cb) ->
           category == null ? null : cb.equal(root.get("category"), category);
   }
 
   public static Specification<Product> priceBetween(BigDecimal min, BigDecimal max) {
       return (root, query, cb) -> {
           if (min == null && max == null) return null;
           if (min != null && max != null) return cb.between(root.get("price"), min, max);
           if (min != null) return cb.greaterThanOrEqualTo(root.get("price"), min);
           return cb.lessThanOrEqualTo(root.get("price"), max);
       };
   }
}
 
// Usage — compose dynamically
public Page<Product> search(ProductSearchRequest req, Pageable pageable) {
   // Specification.where(...) bị deprecated ở Spring Data JPA 3.5; allOf(...) dùng được từ 3.0 tới 4.x
   Specification<Product> spec = Specification.allOf(
       ProductSpecifications.hasName(req.getName()),
       ProductSpecifications.hasCategory(req.getCategory()),
       ProductSpecifications.priceBetween(req.getMinPrice(), req.getMaxPrice()));
 
   return productRepo.findAll(spec, pageable);
}

// Interface
public interface NotificationSender {
   void send(String message, String recipient);
}
 
// Null object — does nothing, safe to call
@Component("noOpNotification")
public class NoOpNotificationSender implements NotificationSender {
   @Override
   public void send(String message, String recipient) {
       // intentionally empty — silent no-op
   }
}
 
// Usage — inject default khi channel không configured
@Service
public class AlertService {
   private final NotificationSender sender;
 
   public AlertService(@Value("${alert.channel:noop}") String channel,
                       Map<String, NotificationSender> senders) {
       this.sender = senders.getOrDefault(channel, senders.get("noOpNotification"));
   }
}