Open closed principle is the most simple one in the list of software design principles I understand. "Open for extension, close for modification" - the idea seems quite straightforward. Let's create an example about validation. We have a service which provides the feature to send message to recipients. The message's type could be SMS, Email, and Telegram, etc. Here is the structure of these message types. Obviously, each message type has its own validation logic. SMSMessage must have valid recipient's phone number, EmailMessage must have valid receipient's email address, for example. We need a class to handle the validation and it might look like this. ( ) MessageValidator emailValidator; ( ) MessageValidator smsValidator; ( ) MessageValidator telegramValidator; { isValid = ; (msg SMSMessage) { isValid = smsValidator.validate(msg); } (msg EmailMessage) { isValid = emailValidator.validate(msg); } (msg TelegramMessage) { isValid = telegramValidator.validate(msg); } } @Autowired @Qualifier "Email" private @Autowired @Qualifier "SMS" private @Autowired @Qualifier "Telegram" private @Override public void processMessage (Message msg) boolean false if instanceof else if instanceof else if instanceof //do other processing When a new message type comes in, you have to change this class again to support the new type. This approach violate the open closed principle. To deal with this, we use the ServiceLocatorFactoryBean provided by Spring framework to support the new validation without changing the existing code, we only need to create more classes to handle the validation logic of the new message type. As you can see the code fragment below has been incredibly shortened. MessageValidatorFactory msgValidatorFactory; { isValid = msgValidatorFactory.getMsgValidator(msg.getType()).validate(msg); } @Autowired private @Override public void processMessage (Message msg) boolean //do other processing { ; } public interface MessageValidatorFactory MessageValidator getMsgValidator (String msgType) { ( ) { ServiceLocatorFactoryBean factoryBean = ServiceLocatorFactoryBean(); factoryBean.setServiceLocatorInterface(MessageValidatorFactory.class); factoryBean; } } @Configuration public class BeanConfigs @Bean "validatorFactory" FactoryBean public serviceLocatorFactoryBean () new return The configuration merely help to lookup the bean by beanId such as , , Email SMS Telegram ( ) { { ; } } @Component "Email" public class EmailMessageValidator implements MessageValidator @Override public boolean validate (Message m) //logic for validation return false ( ) { { ; } } @Component "SMS" public class SMSMessageValidator implements MessageValidator @Override public boolean validate (Message m) //logic for validation return false ( ) { { ; } } @Component "Telegram" public class TelegramMessageValidator implements MessageValidator @Override public boolean validate (Message m) //logic for validation return false By this approach, your code will look much cleaner and become easier to maintain, mitigate the impact to the old features when implementing new feature. Cheers
