Какой принцип SOLID Spring реализует больше всего?

# Принцип SOLID в Spring Framework

Spring реализует все пять принципов SOLID, но Dependency Inversion (D) и Open/Closed (O) это его фундамент.

SOLID принципы

S Single Responsibility Principle

Каждый класс должен иметь одну причину для изменения.

Spring способствует этому через разделение ответственности:

// Плохо: класс отвечает за расчёты И логирование
public class OrderService {
    public void processOrder(Order order) {
        double total = order.getPrice() * order.getQuantity();
        System.out.println("Order processed: " + total);
    }
}

// Хорошо: разделили ответственность
@Service
public class OrderService {
    private final PricingCalculator calculator;
    private final OrderLogger logger;
    
    public OrderService(PricingCalculator calculator, OrderLogger logger) {
        this.calculator = calculator;
        this.logger = logger;
    }
    
    public void processOrder(Order order) {
        double total = calculator.calculate(order);
        logger.log(order, total);
    }
}

@Component
public class PricingCalculator {
    public double calculate(Order order) {
        return order.getPrice() * order.getQuantity();
    }
}

O Open/Closed Principle

Класс открыт для расширения, но закрыт для модификации.

Spring изящно решает это через интерфейсы:

public interface PaymentProcessor {
    void process(Payment payment) throws PaymentException;
}

@Component
public class StripePaymentProcessor implements PaymentProcessor {
    @Override
    public void process(Payment payment) throws PaymentException {
        System.out.println("Processing via Stripe");
    }
}

@Component
public class PayPalPaymentProcessor implements PaymentProcessor {
    @Override
    public void process(Payment payment) throws PaymentException {
        System.out.println("Processing via PayPal");
    }
}

@Service
public class OrderService {
    private final PaymentProcessor paymentProcessor;
    
    public OrderService(@Qualifier("stripePaymentProcessor") PaymentProcessor paymentProcessor) {
        this.paymentProcessor = paymentProcessor;
    }
    
    public void processOrder(Order order) {
        Payment payment = new Payment(order.getAmount());
        paymentProcessor.process(payment);
    }
}

// Результат: можем добавить новую реализацию PaymentProcessor БЕЗ изменения OrderService

L Liskov Substitution Principle

Объекты подтипов должны корректно заменять объекты базовых типов.

Spring гарантирует это через контрактные интерфейсы:

public interface NotificationService {
    void notify(String message);
}

@Component
public class EmailNotificationService implements NotificationService {
    @Override
    public void notify(String message) {
        System.out.println("Email: " + message);
    }
}

@Component
public class SmsNotificationService implements NotificationService {
    @Override
    public void notify(String message) {
        System.out.println("SMS: " + message);
    }
}

@Service
public class UserService {
    private final NotificationService notification;
    
    public UserService(NotificationService notification) {
        this.notification = notification;
    }
    
    public void registerUser(User user) {
        // Doesn need to care which implementation
        notification.notify("User registered: " + user.getName());
    }
}

I Interface Segregation Principle

Больше специализированных интерфейсов лучше чем один большой.

// Плохо: большой интерфейс
public interface UserService {
    void createUser(User user);
    void updateUser(User user);
    void deleteUser(Long id);
    void sendEmail(String email, String message);
    void generateReport();
}

// Хорошо: разделенные интерфейсы
public interface UserCreationService {
    void createUser(User user);
}

public interface UserDeletionService {
    void deleteUser(Long id);
}

public interface EmailService {
    void sendEmail(String email, String message);
}

@Service
public class UserManagementService implements UserCreationService, UserDeletionService {
    // Реализует только нужные методы
}

@Service
public class UserNotificationService implements EmailService {
    // Реализует только email
}

D Dependency Inversion Principle (Самый важный!)

Зависимости должны направлены на абстракции, не на конкретные реализации.

Это суть Spring Framework!

// Плохо: зависимость от конкретного класса
public class OrderService {
    private MySqlUserRepository userRepository = new MySqlUserRepository();
    private StripePaymentService paymentService = new StripePaymentService();
}

// Хорошо: зависимость от абстракций
public interface UserRepository {
    User findById(Long id);
}

public interface PaymentService {
    void charge(User user, double amount);
}

@Service
public class OrderService {
    private final UserRepository userRepository;
    private final PaymentService paymentService;
    
    // Spring инжектирует зависимости
    public OrderService(UserRepository userRepository, PaymentService paymentService) {
        this.userRepository = userRepository;
        this.paymentService = paymentService;
    }
    
    public void processOrder(Order order) {
        User user = userRepository.findById(order.getUserId());
        paymentService.charge(user, order.getAmount());
    }
}

@Component
public class MySqlUserRepository implements UserRepository {
    @Override
    public User findById(Long id) {
        return new User(id, "John");
    }
}

@Component
public class StripePaymentService implements PaymentService {
    @Override
    public void charge(User user, double amount) {
        System.out.println("Charging " + amount + " via Stripe");
    }
}

Как Spring реализует DI

@Configuration
public class AppConfig {
    @Bean
    public UserRepository userRepository() {
        return new JpaUserRepository();
    }
    
    @Bean
    public PaymentService paymentService() {
        return new StripePaymentService();
    }
    
    @Bean
    public OrderService orderService(UserRepository repo, PaymentService payment) {
        return new OrderService(repo, payment);
    }
}

// Или через аннотации
@Service
public class OrderService {
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private PaymentService paymentService;
}

Вывод

Spring наиболее ярко реализует Dependency Inversion (D), но полностью поддерживает все SOLID принципы.

Dependency Inversion это база Spring Framework. Через Inversion of Control (IoC) контейнер, Spring управляет созданием объектов и их зависимостей, позволяя писать слабо связанный, легко тестируемый и масштабируемый код.

Без этого принципа Spring не был бы Spring!