Strangler Fig vs Big-Bang: Choosing the Right Migration Strategy for Java Applications

// SearchApplication.java - new Spring Boot service
@SpringBootApplication
@EnableDiscoveryClient
public class SearchApplication {
    public static void main(String[] args) {
        SpringApplication.run(SearchApplication.class, args);
    }
}

// ProductDocument.java - Elasticsearch document
@Document(indexName = "products")
public class ProductDocument {
    @Id
    private Long id;
    private String name;
    private String description;
    private String category;
    private double price;
    private List<String> tags;
    private double rating;

    // constructors, getters, setters
}

// SearchController.java - REST API for the new service
@RestController
@RequestMapping("/api/v2/search")
public class SearchController {

    private final SearchService searchService;

    public SearchController(SearchService searchService) {
        this.searchService = searchService;
    }

    @GetMapping
    public SearchResponse search(@RequestParam String q,
                                 @RequestParam(defaultValue = "0") int page,
                                 @RequestParam(defaultValue = "20") int size) {
        return searchService.search(q, page, size);
    }

    @PostMapping("/index")
    public void indexProduct(@RequestBody ProductDocument product) {
        searchService.index(product);
    }

    @PostMapping("/index/bulk")
    public void bulkIndex(@RequestBody List<ProductDocument> products) {
        searchService.bulkIndex(products);
    }
}

// SearchService.java - core business logic
@Service
public class SearchService {

    private final ProductSearchRepository repository;
    private final ProductEventPublisher eventPublisher;

    public SearchService(ProductSearchRepository repository,
                         ProductEventPublisher eventPublisher) {
        this.repository = repository;
        this.eventPublisher = eventPublisher;
    }

    public SearchResponse search(String query, int page, int size) {
        Pageable pageable = PageRequest.of(page, size);
        Page<ProductDocument> results = repository
            .findByNameContainingOrDescriptionContaining(query, query, pageable);

        return new SearchResponse(
            results.getContent(),
            results.getTotalElements(),
            results.getTotalPages(),
            results.getNumber()
        );
    }

    @Transactional
    public void index(ProductDocument product) {
        repository.save(product);
        eventPublisher.publishProductIndexed(product.getId());
    }

    @Transactional
    public void bulkIndex(List<ProductDocument> products) {
        repository.saveAll(products);
    }
}

// GatewayConfig.java - in the API gateway
@Configuration
public class GatewayConfig {

    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
            // Route search requests to the new service
            .route("search-service", r -> r
                .path("/api/v2/search/**")
                .uri("lb://search-service"))
            // Everything else goes to the old monolith
            .route("legacy-monolith", r -> r
                .path("/api/**")
                .uri("lb://legacy-monolith"))
            .build();
    }
}

// In the legacy monolith - publish events when product data changes
@Service
public class LegacyProductService {

    private final ProductRepository productRepository;
    private final MessagePublisher messagePublisher;

    public LegacyProductService(ProductRepository productRepository,
                                MessagePublisher messagePublisher) {
        this.productRepository = productRepository;
        this.messagePublisher = messagePublisher;
    }

    @Transactional
    public Product updateProduct(Long id, UpdateProductRequest request) {
        Product product = productRepository.findById(id)
            .orElseThrow(() -> new ProductNotFoundException(id));

        product.setName(request.name());
        product.setDescription(request.description());
        product.setPrice(request.price());
        product.setCategory(request.category());

        Product saved = productRepository.save(product);

        // Publish event for the search service to consume
        messagePublisher.publish(new ProductUpdatedEvent(
            saved.getId(),
            saved.getName(),
            saved.getDescription(),
            saved.getPrice(),
            saved.getCategory()
        ));

        return saved;
    }
}

// Search service consumes the event and updates Elasticsearch
@Component
public class ProductEventConsumer {

    private static final Logger log = LoggerFactory.getLogger(ProductEventConsumer.class);
    private final ProductSearchRepository searchRepository;

    public ProductEventConsumer(ProductSearchRepository searchRepository) {
        this.searchRepository = searchRepository;
    }

    @EventListener
    @Transactional
    public void handleProductUpdated(ProductUpdatedEvent event) {
        log.info("Indexing product {} from event", event.productId());

        ProductDocument document = new ProductDocument(
            event.productId(),
            event.name(),
            event.description(),
            event.category(),
            event.price(),
            List.of(), // tags from another source
            0.0         // rating from another source
        );

        searchRepository.save(document);
    }

    @EventListener
    public void handleProductDeleted(ProductDeletedEvent event) {
        log.info("Removing product {} from search index", event.productId());
        searchRepository.deleteById(event.productId());
    }
}

@Component
public class SearchIndexBackfillJob {

    private final ProductRepository productRepository;
    private final SearchService searchService;

    public SearchIndexBackfillJob(ProductRepository productRepository,
                                  SearchService searchService) {
        this.productRepository = productRepository;
        this.searchService = searchService;
    }

    @Scheduled(cron = "0 0 2 * * ?") // Run at 2 AM daily
    @Transactional
    public void backfillMissingProducts() {
        List<Product> products = productRepository.findAll();

        List<ProductDocument> documents = products.stream()
            .map(product -> new ProductDocument(
                product.getId(),
                product.getName(),
                product.getDescription(),
                product.getCategory(),
                product.getPrice(),
                product.getTags(),
                product.getRating()
            ))
            .toList();

        searchService.bulkIndex(documents);

        log.info("Backfill complete: {} products indexed", documents.size());
    }
}

// Shadow traffic filter - in the API gateway
@Component
public class ShadowTrafficFilter implements GlobalFilter {

    private final RestTemplate restTemplate;

    public ShadowTrafficFilter(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        String path = request.getURI().getPath();

        if (path.startsWith("/api/search")) {
            // Forward a copy of the request to the new service (shadow)
            URI shadowUri = URI.create("http://search-service/api/v2/search" +
                request.getURI().getQuery());

            restTemplate.exchange(shadowUri, HttpMethod.GET, null, String.class)
                .subscribe(
                    response -> log.info("Shadow search succeeded: {}", response.getBody()),
                    error -> log.warn("Shadow search failed (expected): {}", error.getMessage())
                );
        }

        return chain.filter(exchange);
    }
}

// Step 1: Database migration script (Flyway)
// V1__initial_schema.sql
//
// CREATE TABLE products (
//     id BIGINT AUTO_INCREMENT PRIMARY KEY,
//     sku VARCHAR(50) NOT NULL UNIQUE,
//     name VARCHAR(200) NOT NULL,
//     description TEXT,
//     quantity INT NOT NULL DEFAULT 0,
//     price DECIMAL(10,2) NOT NULL,
//     created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
//     updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
// );
//
// CREATE TABLE orders (
//     id BIGINT AUTO_INCREMENT PRIMARY KEY,
//     product_id BIGINT NOT NULL,
//     quantity INT NOT NULL,
//     total DECIMAL(10,2) NOT NULL,
//     status VARCHAR(20) NOT NULL DEFAULT 'PENDING',
//     created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
//     FOREIGN KEY (product_id) REFERENCES products(id)
// );

// Step 2: Spring Boot application
@SpringBootApplication
@EnableTransactionManagement
public class InventoryApplication {
    public static void main(String[] args) {
        SpringApplication.run(InventoryApplication.class, args);
    }
}

// Step 3: Entity classes (JPA)
@Entity
@Table(name = "products")
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true, length = 50)
    private String sku;

    @Column(nullable = false, length = 200)
    private String name;

    @Column(columnDefinition = "TEXT")
    private String description;

    @Column(nullable = false)
    private int quantity;

    @Column(nullable = false, precision = 10, scale = 2)
    private BigDecimal price;

    @Column(name = "created_at", updatable = false)
    private LocalDateTime createdAt;

    @Column(name = "updated_at")
    private LocalDateTime updatedAt;

    @PrePersist
    protected void onCreate() {
        createdAt = LocalDateTime.now();
        updatedAt = LocalDateTime.now();
    }

    @PreUpdate
    protected void onUpdate() {
        updatedAt = LocalDateTime.now();
    }

    // constructors, getters, setters
}

// Step 4: Repository layer
@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
    Optional<Product> findBySku(String sku);
    List<Product> findByQuantityLessThan(int threshold);
}

// Step 5: Service layer
@Service
@Transactional
public class InventoryService {

    private final ProductRepository productRepository;
    private final OrderRepository orderRepository;

    public InventoryService(ProductRepository productRepository,
                            OrderRepository orderRepository) {
        this.productRepository = productRepository;
        this.orderRepository = orderRepository;
    }

    public Product addStock(String sku, int quantity) {
        Product product = productRepository.findBySku(sku)
            .orElseThrow(() -> new IllegalArgumentException("Unknown SKU: " + sku));

        product.setQuantity(product.getQuantity() + quantity);
        return productRepository.save(product);
    }

    public Order createOrder(String sku, int quantity) {
        Product product = productRepository.findBySku(sku)
            .orElseThrow(() -> new IllegalArgumentException("Unknown SKU: " + sku));

        if (product.getQuantity() < quantity) {
            throw new InsufficientStockException(
                "Insufficient stock for SKU " + sku +
                ". Available: " + product.getQuantity() +
                ", requested: " + quantity);
        }

        product.setQuantity(product.getQuantity() - quantity);
        productRepository.save(product);

        Order order = new Order(product, quantity,
            product.getPrice().multiply(BigDecimal.valueOf(quantity)));
        return orderRepository.save(order);
    }
}

// Step 6: Controller
@Controller
@RequestMapping("/inventory")
public class InventoryController {

    private final InventoryService inventoryService;

    public InventoryController(InventoryService inventoryService) {
        this.inventoryService = inventoryService;
    }

    @GetMapping
    public String listProducts(Model model) {
        model.addAttribute("products", productRepository.findAll());
        return "inventory/list";
    }

    @PostMapping("/add-stock")
    public String addStock(@RequestParam String sku,
                           @RequestParam int quantity) {
        inventoryService.addStock(sku, quantity);
        return "redirect:/inventory";
    }
}

// In the legacy monolith
@Entity
@Table(name = "products")
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private String description;
    private double price;

    // ... other fields
}

// Outbox table stores events in the same database transaction
@Entity
@Table(name = "outbox_events")
public class OutboxEvent {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String aggregateType; // e.g., "Product"

    @Column(nullable = false)
    private String aggregateId;   // e.g., "123"

    @Column(nullable = false)
    private String eventType;     // e.g., "ProductUpdated"

    @Column(columnDefinition = "jsonb", nullable = false)
    private String payload;       // JSON of the event data

    @Column(nullable = false)
    private LocalDateTime createdAt;

    @Column(nullable = false)
    private boolean published = false;
}

// Service that writes to both the entity table and the outbox in one transaction
@Service
public class ProductService {

    private final ProductRepository productRepository;
    private final OutboxEventRepository outboxRepository;

    public ProductService(ProductRepository productRepository,
                          OutboxEventRepository outboxRepository) {
        this.productRepository = productRepository;
        this.outboxRepository = outboxRepository;
    }

    @Transactional
    public Product updateProduct(Long id, UpdateProductRequest request) {
        Product product = productRepository.findById(id)
            .orElseThrow(() -> new ProductNotFoundException(id));

        product.setName(request.name());
        product.setDescription(request.description());
        product.setPrice(request.price());

        Product saved = productRepository.save(product);

        // Write to outbox in the SAME transaction
        OutboxEvent event = new OutboxEvent();
        event.setAggregateType("Product");
        event.setAggregateId(String.valueOf(saved.getId()));
        event.setEventType("ProductUpdated");

        // Serialize event payload
        try {
            ObjectMapper mapper = new ObjectMapper();
            event.setPayload(mapper.writeValueAsString(Map.of(
                "productId", saved.getId(),
                "name", saved.getName(),
                "description", saved.getDescription(),
                "price", saved.getPrice()
            )));
        } catch (JsonProcessingException e) {
            throw new RuntimeException("Failed to serialize outbox event", e);
        }

        event.setCreatedAt(LocalDateTime.now());
        outboxRepository.save(event);

        return saved;
    }
}

// Outbox poller - publishes pending events to the message broker
@Component
public class OutboxPoller {

    private final OutboxEventRepository outboxRepository;
    private final MessagePublisher messagePublisher;

    public OutboxPoller(OutboxEventRepository outboxRepository,
                        MessagePublisher messagePublisher) {
        this.outboxRepository = outboxRepository;
        this.messagePublisher = messagePublisher;
    }

    @Scheduled(fixedDelay = 1000) // Poll every second
    @Transactional
    public void publishPendingEvents() {
        List<OutboxEvent> pendingEvents = outboxRepository
            .findByPublishedFalseOrderByCreatedAtAsc();

        for (OutboxEvent event : pendingEvents) {
            try {
                messagePublisher.publish(event.getEventType(), event.getPayload());
                event.setPublished(true);
                outboxRepository.save(event);
            } catch (Exception e) {
                log.error("Failed to publish outbox event {}: {}",
                    event.getId(), e.getMessage());
                // Will retry on next poll
            }
        }
    }
}