Design Patterns in Spring Boot

@Service // Singleton by default
public class OrderService {
    private final OrderRepository repository;
    private final PaymentGateway gateway;

    public OrderService(OrderRepository repository, PaymentGateway gateway) {
        this.repository = repository;
        this.gateway = gateway;
    }

    public Order place(OrderRequest req) {
        // Stateless: safe for concurrent access
        Order order = Order.from(req);
        gateway.charge(order.total());
        return repository.save(order);
    }
}

// FactoryBean: Spring calls getObject() to produce the actual bean
@Component
public class NotificationChannelFactoryBean implements FactoryBean<NotificationChannel> {

    @Value("${notification.default-channel}")
    private String channelType;

    @Override
    public NotificationChannel getObject() {
        return switch (channelType) {
            case "sms"   -> new SmsChannel();
            case "email" -> new EmailChannel();
            case "push"  -> new PushChannel();
            default -> throw new IllegalStateException("Unknown channel: " + channelType);
        };
    }

    @Override
    public Class<?> getObjectType() { return NotificationChannel.class; }
}

// Runtime factory: select implementation based on request data
@Component
public class PaymentProcessorFactory {

    private final Map<String, PaymentProcessor> processors;

    public PaymentProcessorFactory(List<PaymentProcessor> list) {
        this.processors = list.stream()
            .collect(Collectors.toMap(PaymentProcessor::method, Function.identity()));
    }

    public PaymentProcessor resolve(String paymentMethod) {
        return Optional.ofNullable(processors.get(paymentMethod))
            .orElseThrow(() -> new UnsupportedPaymentException(paymentMethod));
    }
}

@Service
public class InventoryService {

    @Transactional
    @CacheEvict(value = "stock", key = "#sku")
    public void reduceStock(String sku, int qty) {
        // Proxy chain: CacheEvict advice -> TX advice -> this method
        Item item = itemRepo.findBySku(sku);
        item.reduceBy(qty);
        itemRepo.save(item);
    }
}

@Repository
public class OrderReportRepository {

    private final JdbcTemplate jdbc;

    // You provide: SQL + mapping. Template handles: connection, statement, cleanup, exceptions.
    public List<OrderSummary> findTopOrders(BigDecimal minAmount) {
        return jdbc.query(
            "SELECT id, customer, total FROM orders WHERE total > ? ORDER BY total DESC LIMIT 50",
            (rs, row) -> new OrderSummary(
                rs.getLong("id"),
                rs.getString("customer"),
                rs.getBigDecimal("total")
            ),
            minAmount
        );
    }
}

// TransactionTemplate: programmatic TX control without @Transactional
@Service
public class BulkImportService {

    private final TransactionTemplate txTemplate;

    public ImportResult importBatch(List<Record> records) {
        return txTemplate.execute(status -> {
            int count = 0;
            for (Record r : records) {
                if (!isValid(r)) {
                    status.setRollbackOnly();
                    return ImportResult.failed(count);
                }
                persist(r);
                count++;
            }
            return ImportResult.success(count);
        });
    }
}

public interface ShippingStrategy {
    ShippingCost calculate(Order order);
    String carrier();
}

@Component
public class StandardShipping implements ShippingStrategy {
    public ShippingCost calculate(Order order) {
        return new ShippingCost(order.weight().multiply(RATE_PER_KG), 5);
    }
    public String carrier() { return "STANDARD"; }
}

@Component
public class ExpressShipping implements ShippingStrategy {
    public ShippingCost calculate(Order order) {
        return new ShippingCost(order.weight().multiply(RATE_PER_KG.multiply(TWO)), 2);
    }
    public String carrier() { return "EXPRESS"; }
}

// Context: resolves strategy dynamically
@Service
public class ShippingService {

    private final Map<String, ShippingStrategy> strategies;

    public ShippingService(List<ShippingStrategy> strategyList) {
        this.strategies = strategyList.stream()
            .collect(Collectors.toMap(ShippingStrategy::carrier, Function.identity()));
    }

    public ShippingCost calculateCost(Order order, String carrier) {
        ShippingStrategy strategy = strategies.get(carrier);
        if (strategy == null) throw new UnsupportedCarrierException(carrier);
        return strategy.calculate(order);
    }
}

// Event
public record OrderPlacedEvent(String orderId, String customerId, BigDecimal total) {}

// Publisher -- core domain logic, no knowledge of listeners
@Service
public class OrderService {
    private final ApplicationEventPublisher events;

    @Transactional
    public Order place(OrderRequest req) {
        Order order = orderRepo.save(Order.from(req));
        events.publishEvent(new OrderPlacedEvent(order.id(), req.customerId(), order.total()));
        return order;
    }
}

// Listeners -- independently deployed, independently testable
@Component
public class EmailNotificationListener {
    @EventListener
    public void handle(OrderPlacedEvent event) {
        emailService.sendOrderConfirmation(event.customerId(), event.orderId());
    }
}

@Component
public class InventoryReserveListener {
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void handle(OrderPlacedEvent event) {
        inventoryService.reserveItems(event.orderId());
    }
}

@Component
public class AnalyticsListener {
    @Async
    @EventListener
    public void handle(OrderPlacedEvent event) {
        analytics.track("order_placed", Map.of("total", event.total()));
    }
}

public interface OrderProcessor {
    OrderResult process(Order order);
}

@Component("coreOrderProcessor")
public class CoreOrderProcessor implements OrderProcessor {
    public OrderResult process(Order order) {
        // actual business logic
        return orderRepo.save(order).toResult();
    }
}

@Component
@Primary
public class MetricsOrderProcessor implements OrderProcessor {

    private final OrderProcessor delegate;
    private final MeterRegistry metrics;

    public MetricsOrderProcessor(
            @Qualifier("coreOrderProcessor") OrderProcessor delegate,
            MeterRegistry metrics) {
        this.delegate = delegate;
        this.metrics = metrics;
    }

    @Override
    public OrderResult process(Order order) {
        Timer.Sample sample = Timer.start(metrics);
        try {
            OrderResult result = delegate.process(order);
            sample.stop(metrics.timer("order.process", "status", "success"));
            return result;
        } catch (Exception e) {
            sample.stop(metrics.timer("order.process", "status", "error"));
            throw e;
        }
    }
}

// BeanPostProcessor: Spring's internal decorator mechanism
@Component
public class ProfilingBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (bean.getClass().isAnnotationPresent(Profiled.class)) {
            // Return a proxy that adds timing around every method
            return createTimingProxy(bean);
        }
        return bean;
    }
}

// Spring's WebClient builder -- immutable once built
@Bean
public WebClient paymentClient() {
    return WebClient.builder()
        .baseUrl("https://api.payments.com")
        .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
        .defaultHeader("X-Api-Key", apiKey)
        .filter(retryFilter())
        .filter(loggingFilter())
        .codecs(c -> c.defaultCodecs().maxInMemorySize(2 * 1024 * 1024))
        .build();
}

// SecurityFilterChain builder
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    return http
        .csrf(csrf -> csrf.disable())
        .sessionManagement(s -> s.sessionCreationPolicy(STATELESS))
        .authorizeHttpRequests(auth -> auth
            .requestMatchers("/api/public/**").permitAll()
            .requestMatchers("/api/admin/**").hasRole("ADMIN")
            .anyRequest().authenticated()
        )
        .oauth2ResourceServer(oauth -> oauth.jwt(Customizer.withDefaults()))
        .build();
}

// Custom builder for domain objects
public class SearchQuery {
    private final String keyword;
    private final List<String> categories;
    private final BigDecimal minPrice;
    private final BigDecimal maxPrice;
    private final SortOrder sort;
    private final int page;
    private final int size;

    private SearchQuery(Builder builder) {
        this.keyword = builder.keyword;
        this.categories = List.copyOf(builder.categories);
        this.minPrice = builder.minPrice;
        this.maxPrice = builder.maxPrice;
        this.sort = builder.sort;
        this.page = builder.page;
        this.size = builder.size;
    }

    public static Builder builder(String keyword) {
        return new Builder(keyword);
    }

    public static class Builder {
        private final String keyword;
        private List<String> categories = List.of();
        private BigDecimal minPrice = BigDecimal.ZERO;
        private BigDecimal maxPrice = BigDecimal.valueOf(Long.MAX_VALUE);
        private SortOrder sort = SortOrder.RELEVANCE;
        private int page = 0;
        private int size = 20;

        private Builder(String keyword) { this.keyword = keyword; }

        public Builder categories(List<String> c) { this.categories = c; return this; }
        public Builder priceRange(BigDecimal min, BigDecimal max) {
            this.minPrice = min; this.maxPrice = max; return this;
        }
        public Builder sort(SortOrder s) { this.sort = s; return this; }
        public Builder page(int p) { this.page = p; return this; }
        public Builder size(int s) { this.size = s; return this; }
        public SearchQuery build() { return new SearchQuery(this); }
    }
}

// Adapting a legacy payment gateway to your clean interface
public interface PaymentGateway {
    PaymentResult charge(String customerId, Money amount);
    PaymentResult refund(String transactionId, Money amount);
}

// Legacy SDK with incompatible interface
public class LegacyStripeSDK {
    public Map<String, Object> createCharge(String token, long amountCents, String currency) { ... }
    public Map<String, Object> createRefund(String chargeId, long amountCents) { ... }
}

// Adapter: bridges legacy SDK to your interface
@Component
public class StripePaymentAdapter implements PaymentGateway {

    private final LegacyStripeSDK stripe;
    private final CustomerTokenResolver tokenResolver;

    @Override
    public PaymentResult charge(String customerId, Money amount) {
        String token = tokenResolver.resolve(customerId);
        Map<String, Object> response = stripe.createCharge(
            token, amount.toCents(), amount.currency().getCode()
        );
        return mapToResult(response);
    }

    @Override
    public PaymentResult refund(String transactionId, Money amount) {
        Map<String, Object> response = stripe.createRefund(transactionId, amount.toCents());
        return mapToResult(response);
    }

    private PaymentResult mapToResult(Map<String, Object> raw) {
        return new PaymentResult(
            (String) raw.get("id"),
            "succeeded".equals(raw.get("status")) ? Status.SUCCESS : Status.FAILED
        );
    }
}

// Order validation chain -- e-commerce example
public interface OrderValidationHandler {
    void validate(Order order, OrderContext context);
    int priority();
}

@Component
public class InventoryCheckHandler implements OrderValidationHandler {
    public void validate(Order order, OrderContext ctx) {
        for (LineItem item : order.items()) {
            if (!inventoryService.isAvailable(item.sku(), item.qty())) {
                ctx.reject("Item " + item.sku() + " out of stock");
                return; // halt chain via context flag
            }
        }
    }
    public int priority() { return 10; }
}

@Component
public class FraudCheckHandler implements OrderValidationHandler {
    public void validate(Order order, OrderContext ctx) {
        if (ctx.isRejected()) return; // skip if already rejected
        FraudScore score = fraudEngine.evaluate(order);
        if (score.isHigh()) {
            ctx.reject("Fraud risk too high: " + score.value());
        }
    }
    public int priority() { return 20; }
}

@Component
public class CreditCheckHandler implements OrderValidationHandler {
    public void validate(Order order, OrderContext ctx) {
        if (ctx.isRejected()) return;
        if (!walletService.hasSufficientFunds(order.customerId(), order.total())) {
            ctx.reject("Insufficient funds");
        }
    }
    public int priority() { return 30; }
}

@Service
public class OrderValidationPipeline {

    private final List<OrderValidationHandler> handlers;

    public OrderValidationPipeline(List<OrderValidationHandler> handlers) {
        this.handlers = handlers.stream()
            .sorted(Comparator.comparingInt(OrderValidationHandler::priority))
            .toList();
    }

    public OrderContext validate(Order order) {
        OrderContext ctx = new OrderContext();
        for (OrderValidationHandler handler : handlers) {
            handler.validate(order, ctx);
            if (ctx.isRejected()) break;
        }
        return ctx;
    }
}

public interface OrderRepository extends JpaRepository<Order, UUID> {

    // Derived query -- Spring generates SQL from method name
    List<Order> findByCustomerIdAndStatusOrderByCreatedAtDesc(String customerId, OrderStatus status);

    // Custom JPQL
    @Query("SELECT o FROM Order o WHERE o.total > :minTotal AND o.createdAt > :since")
    List<Order> findLargeRecentOrders(@Param("minTotal") BigDecimal minTotal,
                                      @Param("since") LocalDateTime since);

    // Projection
    @Query("SELECT new com.app.dto.OrderSummary(o.id, o.total, o.status) FROM Order o WHERE o.customerId = :cid")
    List<OrderSummary> findSummariesByCustomer(@Param("cid") String customerId);

    // Modifying query
    @Modifying
    @Query("UPDATE Order o SET o.status = :status WHERE o.id = :id")
    int updateStatus(@Param("id") UUID id, @Param("status") OrderStatus status);
}

// Custom repository implementation for complex queries
public interface OrderRepositoryCustom {
    Page<Order> searchOrders(OrderSearchCriteria criteria, Pageable pageable);
}

@Repository
public class OrderRepositoryCustomImpl implements OrderRepositoryCustom {

    private final EntityManager em;

    public Page<Order> searchOrders(OrderSearchCriteria criteria, Pageable pageable) {
        CriteriaBuilder cb = em.getCriteriaBuilder();
        CriteriaQuery<Order> query = cb.createQuery(Order.class);
        Root<Order> root = query.from(Order.class);

        List<Predicate> predicates = new ArrayList<>();
        if (criteria.status() != null) {
            predicates.add(cb.equal(root.get("status"), criteria.status()));
        }
        if (criteria.minTotal() != null) {
            predicates.add(cb.greaterThan(root.get("total"), criteria.minTotal()));
        }
        query.where(predicates.toArray(Predicate[]::new));

        // Execute with pagination
        List<Order> results = em.createQuery(query)
            .setFirstResult((int) pageable.getOffset())
            .setMaxResults(pageable.getPageSize())
            .getResultList();

        return new PageImpl<>(results, pageable, countTotal(criteria));
    }
}