{"id":231775,"date":"2025-01-09T05:16:33","date_gmt":"2025-01-09T13:16:33","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/java\/?p=231775"},"modified":"2025-01-09T05:16:33","modified_gmt":"2025-01-09T13:16:33","slug":"mwa-pattern-strangler-fig","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/java\/mwa-pattern-strangler-fig\/","title":{"rendered":"MWA pattern: Strangler Fig"},"content":{"rendered":"

\"Strangler<\/a><\/p>\n

Author\u2019s Note: After announcing the Modern Web App (MWA) pattern (https:\/\/devblogs.microsoft.com\/java\/introducing-the-modern-web-app-mwa-pattern-for-java<\/a>), we now focus on one of its many pattens – the Strangler Fig pattern. This pattern incrementally modernizes a legacy Java application by \u201cstrangling\u201d targeted areas and replacing them with new microservices or minimal web apps. We\u2019ll explore an example showing how to integrate this approach and smoothly transition from a monolith to modern microservices.<\/p>\n

\n

MWA pattern: Strangler Fig<\/h1>\n<\/div>\n
\n

Introduction<\/h2>\n<\/div>\n

In today’s fast-paced technological landscape, modernizing Java applications is crucial for achieving scalability, maintainability, and performance. Legacy systems often struggle to keep up with the demands of modern users and evolving business requirements. By adopting modern architectural patterns, organizations can ensure their applications remain competitive and capable of handling increased workloads.<\/p>\n

\n

The Strangler Fig Pattern: A Strategy for Incremental Modernization<\/h2>\n<\/div>\n

As applications age, the tools, technologies, and architectures they rely on can become outdated. Introducing new features can increase complexity, making these systems harder to maintain and evolve. Completely rewriting a complex system is often a massive and risky undertaking. The\u00a0Strangler Fig Pattern<\/strong>\u00a0offers a solution by allowing you to incrementally migrate a legacy system. This is achieved by gradually replacing specific pieces of functionality with new applications and services.<\/p>\n

Inspired by the strangler fig tree that grows around and eventually replaces its host, this pattern involves creating a fa\u00e7ade that intercepts requests to the backend legacy system. The fa\u00e7ade routes these requests either to the legacy application or the new services. This approach enables existing features to be migrated gradually, while consumers continue using the same interface, unaware of the changes happening behind the scenes.<\/p>\n

By gradually replacing the legacy system’s features, the new system eventually encompasses all functionalities, allowing you to safely decommission the old system.<\/p>\n

Read Martin Fowler’s original article on the Strangler Fig Application\u00a0here<\/a>.<\/em><\/p>\n

\n

Example<\/h3>\n<\/div>\n

Next let’s look at a typical use case where the Strangler Fig pattern would make a good fit. Imagine you’re migrating a\u00a0\/customer<\/code>\u00a0endpoint from a legacy system to a modernized architecture. You can deploy a router that directs requests to either the old or new implementation based on specific conditions.<\/p>\n

\n

Java Code Example<\/h4>\n<\/div>\n
\n
@<\/span>RestController<\/span>\r\n@<\/span>RequestMapping<\/span>(\"\/api\"<\/span>)\r\npublic<\/span> class<\/span> CustomerRouterController<\/span> {\r\n    private<\/span> final<\/span> LegacyCustomerService<\/span> legacyService<\/span>;\r\n    private<\/span> final<\/span> ModernCustomerService<\/span> modernService<\/span>;\r\n\r\n    public<\/span> CustomerRouterController<\/span>(LegacyCustomerService<\/span> legacyService<\/span>, ModernCustomerService<\/span> modernService<\/span>) {\r\n        this<\/span>.legacyService<\/span> = legacyService<\/span>;\r\n        this<\/span>.modernService<\/span> = modernService<\/span>;\r\n    }\r\n\r\n    @<\/span>GetMapping<\/span>(\"\/customer\"<\/span>)\r\n    public<\/span> ResponseEntity<\/span><Customer<\/span>> getCustomer<\/span>(@<\/span>RequestParam<\/span> String<\/span> id<\/span>) {\r\n        if<\/span> (isModernCustomer<\/span>(id<\/span>)) {\r\n            Customer<\/span> customer<\/span> = modernService<\/span>.getCustomerById<\/span>(id<\/span>);\r\n            return<\/span> ResponseEntity<\/span>.ok<\/span>(customer<\/span>);\r\n        }\r\n        Customer<\/span> customer<\/span> = legacyService<\/span>.getCustomerById<\/span>(id<\/span>);\r\n        return<\/span> ResponseEntity<\/span>.ok<\/span>(customer<\/span>);\r\n    }\r\n\r\n    private<\/span> boolean<\/span> isModernCustomer<\/span>(String<\/span> id<\/span>) {\r\n        \/\/ Logic to determine if the request should be routed to the modern service<\/span>\r\n        return<\/span> id<\/span>.startsWith<\/span>(\"MODERN_\"<\/span>);\r\n    }\r\n}<\/pre>\n<\/div>\n
This example uses a centralized router to direct requests based on specific criteria, such as the format of the customer ID. It enables both legacy and modern systems to coexist during the transition period. Follow these steps to run the Spring Boot example demonstrating the Strangler Fig pattern.<\/p>\n
\n
Prerequisites<\/h3>\n<\/div>\n
Ensure you have the following tools installed:<\/p>\n