How to Implement Design Patterns in Spring Boots Application

In a Spring Boot web project, design patterns are essential to create a maintainable, scalable, and testable application. Below are some common design patterns and how you can implement them in a Spring Boot project:
Singleton PatternThe Singleton pattern ensures a class has only one instance and provides a global point of access to it. In Spring, beans are singleton by default.
For Example :
@Service public class MyService { // Spring automatically makes this bean a singleton }
Factory Pattern
The Factory pattern is used to create objects without specifying the exact class of object that will be created.

For Example :
@Component public class ShapeFactory { public Shape getShape(String shapeType) { if (shapeType == null) { return null; } if (shapeType.equalsIgnoreCase("CIRCLE")) { return new Circle(); } else if (shapeType.equalsIgnoreCase("RECTANGLE")) { return new Rectangle(); } return null; } } Usage in a Controller
@RestController @RequestMapping("/shapes") public class ShapeController { private final ShapeFactory shapeFactory; public ShapeController(ShapeFactory shapeFactory) { this.shapeFactory = shapeFactory; } @GetMapping("/{type}") public String getShape(@PathVariable String type) { Shape shape = shapeFactory.getShape(type); return shape != null ? shape.draw() : "Shape not found"; } }
Prototype Pattern
The Prototype pattern is used to create a new instance of a class by copying or cloning an existing instance. 

For Example :
@Component @Scope("prototype") public class MyPrototypeBean { // This bean will be a new instance each time it's requested } @RestController public class MyController { private final MyPrototypeBean prototypeBean; public MyController(MyPrototypeBean prototypeBean) { this.prototypeBean = prototypeBean; } @GetMapping("/prototype") public String usePrototype() { return prototypeBean.toString(); } }
Adapter Pattern
The Adapter pattern allows incompatible interfaces to work together. In a Spring Boot project, it can be used to integrate third-party libraries. 

For Example :Suppose you have an external logging service that doesn't fit directly into your logging system.
public interface LogAdapter { void logMessage(String message); } public class ExternalLogServiceAdapter implements LogAdapter { private ExternalLogService externalLogService; public ExternalLogServiceAdapter(ExternalLogService externalLogService) { this.externalLogService = externalLogService; } @Override public void logMessage(String message) { externalLogService.log(message); } } Usage: @Service public class MyService { private final LogAdapter logAdapter; public MyService(LogAdapter logAdapter) { this.logAdapter = logAdapter; } public void performTask() { logAdapter.logMessage("Task performed"); } }
Decorator Pattern
The Decorator pattern is used to add behavior to individual objects without affecting the behavior of other objects from the same class.
Example:

public interface Car { String assemble(); } public class BasicCar implements Car { @Override public String assemble() { return "Basic Car."; } } public class CarDecorator implements Car { protected Car car; public CarDecorator(Car car) { this.car = car; } @Override public String assemble() { return this.car.assemble(); } } public class SportsCar extends CarDecorator { public SportsCar(Car car) { super(car); } @Override public String assemble() { return super.assemble() + " Adding features of Sports Car."; } }
Observer Pattern
The Observer pattern allows an object to notify other objects when its state changes.
Example:

public interface Observer { void update(String message); } public class EmailNotificationObserver implements Observer { @Override public void update(String message) { System.out.println("Email Notification: " + message); } } public class EventPublisher { private List<Observer> observers = new ArrayList<>(); public void addObserver(Observer observer) { observers.add(observer); } public void notifyObservers(String message) { for (Observer observer : observers) { observer.update(message); } } } Usage in a Service:

@Service public class NotificationService { private final EventPublisher eventPublisher; public NotificationService(EventPublisher eventPublisher) { this.eventPublisher = eventPublisher; eventPublisher.addObserver(new EmailNotificationObserver()); } public void notifyUsers(String message) { eventPublisher.notifyObservers(message); } }
Template Method Pattern
The Template Method pattern defines the skeleton of an al algorithm in a method, deferring some steps to subclasses.
Example:

public abstract class OrderProcessor { public final void processOrder() { selectItem(); payment(); deliver(); } protected abstract void selectItem(); protected abstract void payment(); protected void deliver() { System.out.println("Order delivered"); } } public class OnlineOrder extends OrderProcessor { @Override protected void selectItem() { System.out.println("Item selected online"); } @Override protected void payment() { System.out.println("Payment made online"); } } Usage:

@RestController public class OrderController { @GetMapping("/order") public String processOrder() { OrderProcessor orderProcessor = new OnlineOrder(); orderProcessor.processOrder(); return "Order processed"; } }
Conclusion: Design patterns are critical in developing well-structured, maintainable, and flexible Spring Boot applications. They help in decoupling components, reusing code, and making the application easier to understand and extend. By leveraging these patterns in your Spring Boot project, you can achieve better code organization and more effective application design.