Какие принципы предоставляет Spring

Принципы, которые предоставляет Spring Framework

Spring это не просто фреймворк для dependency injection. Это философия разработки, основанная на нескольких ключевых принципах. Разберём их подробно.

1. Inversion of Control (IoC) - Инверсия управления

Обычно твой код управляет объектами - создаёт их, инициализирует, вызывает методы.

с Spring контроль передаётся фреймворку:

// Без Spring - ты создаёшь объекты
public class OrderService {
    private UserRepository userRepository;
    private PaymentService paymentService;
    
    public OrderService() {
        // Ты сам создаёшь зависимости
        this.userRepository = new UserRepositoryImpl();
        this.paymentService = new PaymentServiceImpl();
    }
}

// С Spring - Spring создаёт объекты
@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;
    }
}

Плюсы IoC

✅ Слабая связанность - OrderService не знает про конкретную реализацию

✅ Легче тестировать - можешь внедрить mock

✅ Гибкость - можешь менять реализацию без изменения кода

2. Dependency Injection (DI) - Внедрение зависимостей

Это способ реализации IoC. Spring внедряет зависимости вместо того чтобы объекты сами их искали.

// Constructor Injection
@Service
public class UserService {
    private final UserRepository repository;
    
    public UserService(UserRepository repository) {
        this.repository = repository;  // Spring передаёт
    }
}

// Field Injection (less preferred)
@Service
public class UserService {
    @Autowired  // Spring внедрит сюда
    private UserRepository repository;
}

// Setter Injection
@Service
public class UserService {
    private UserRepository repository;
    
    @Autowired
    public void setRepository(UserRepository repository) {
        this.repository = repository;
    }
}

Best Practice: Constructor Injection потому что:

• Явно видны зависимости
• Объект полностью инициализирован после конструктора
• Можно делать final переменные

3. Aspect-Oriented Programming (AOP) - Аспектно-ориентированное программирование

AOP позволяет "вокруг" твоего кода выполнить дополнительную логику.

// Твой код
@Service
public class PaymentService {
    @Transactional  // AOP Spring внедрит логику транзакций
    public void processPayment(Payment payment) {
        // Spring автоматически:
        // 1. Начнёт транзакцию
        // 2. Выполнит твой код
        // 3. Закоммитит или откатит
    }
}

// Кастомный аспект
@Aspect
@Component
public class LoggingAspect {
    @Around("@annotation(Monitored)")  // Для методов с @Monitored
    public Object logMethodExecution(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("Начало: " + joinPoint.getSignature());
        long start = System.currentTimeMillis();
        
        Object result = joinPoint.proceed();  // Выполняем метод
        
        long duration = System.currentTimeMillis() - start;
        System.out.println("Конец за " + duration + "ms");
        
        return result;
    }
}

// Использование
@Service
public class UserService {
    @Monitored  // Автоматически логируется
    public void createUser(User user) {
        // ...
    }
}

Примеры AOP в Spring

Транзакции:

@Transactional
public void saveUser(User user) {  // Spring управляет транзакцией
    userRepository.save(user);
}

Логирование:

@Aspect
public class LoggingAspect {
    @Before("execution(* com.example.service..*(..))")  // Перед методами service
    public void logBefore(JoinPoint joinPoint) {
        logger.info("Calling: " + joinPoint.getSignature());
    }
}

Кэширование:

@Service
public class UserService {
    @Cacheable("users")  // Spring кэширует результат
    public User findById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

Security:

@Service
public class SensitiveService {
    @PreAuthorize("hasRole('ADMIN')")  // Spring проверит права
    public void deleteAllUsers() {
        userRepository.deleteAll();
    }
}

4. SOLID принципы (Spring их пропагандирует)

S - Single Responsibility Principle

Kaждый класс должен иметь одну ответственность:

// ❌ Плохо - class делает всё
@Service
public class UserService {
    public void createUser(User user) { }         // Бизнес логика
    public void validateEmail(String email) { }  // Валидация
    public void sendEmail(String email) { }      // Отправка email
    public void logActivity(String action) { }   // Логирование
}

// ✅ Хорошо - разбили по классам
@Service
public class UserService {  // Только управление пользователями
    private final UserValidator validator;
    private final EmailService emailService;
    
    public void createUser(User user) {
        validator.validate(user);  // Делегируем валидацию
        emailService.sendWelcome(user.getEmail());  // Делегируем email
    }
}

O - Open/Closed Principle

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

// Интерфейс - открыт для расширения
public interface PaymentProcessor {
    void process(Payment payment);
}

// Разные реализации
@Component
public class CreditCardProcessor implements PaymentProcessor {
    @Override
    public void process(Payment payment) { }
}

@Component
public class PayPalProcessor implements PaymentProcessor {
    @Override
    public void process(Payment payment) { }
}

// Service не нужно менять при добавлении нового процессора
@Service
public class PaymentService {
    private final PaymentProcessor processor;
    
    public void pay(Payment payment) {
        processor.process(payment);  // Works с любым процессором
    }
}

L - Liskov Substitution Principle

Дочерний класс должен быть заменяем родительским:

public interface Repository<T> {
    void save(T entity);
    T findById(Long id);
}

// Все эти можно использовать вместо Repository<User>
public class UserRepository implements Repository<User> { }
public class CachedUserRepository implements Repository<User> { }
public class AsyncUserRepository implements Repository<User> { }

I - Interface Segregation Principle

Много специализированных интерфейсов лучше одного общего:

// ❌ Плохо - один большой интерфейс
public interface UserManagement {
    void createUser(User user);
    void updateUser(User user);
    void deleteUser(Long id);
    void sendEmail(String email);
    void logActivity(String action);
    void generateReport();
}

// ✅ Хорошо - много специализированных
public interface UserRepository {
    void save(User user);
    void update(User user);
    void delete(Long id);
}

public interface EmailService {
    void send(String email);
}

public interface ActivityLogger {
    void log(String action);
}

D - Dependency Inversion Principle

Зависимости от абстракций, не от конкретных реализаций:

// ❌ Плохо - зависим от конкретного класса
public class OrderService {
    private MySQLUserRepository userRepository = new MySQLUserRepository();
}

// ✅ Хорошо - зависим от интерфейса
@Service
public class OrderService {
    private final UserRepository userRepository;  // Интерфейс
    
    public OrderService(UserRepository userRepository) {
        this.userRepository = userRepository;  // Spring внедрит реализацию
    }
}

5. DRY - Don't Repeat Yourself

Spring помогает избежать дублирования кода:

// ❌ Плохо - дублируешь логику транзакций
public void createUser(User user) {
    try {
        connection.setAutoCommit(false);
        userRepository.save(user);
        connection.commit();
    } catch (Exception e) {
        connection.rollback();
    }
}

// ✅ Хорошо - Spring управляет транзакциями
@Transactional
public void createUser(User user) {
    userRepository.save(user);
}

6. KISS - Keep It Simple, Stupid

Spring упрощает код:

// ❌ Без Spring - много boilerplate
public class ConnectionPool {
    private static ConnectionPool instance;
    
    private ConnectionPool() { }
    
    public static synchronized ConnectionPool getInstance() {
        if (instance == null) {
            instance = new ConnectionPool();
        }
        return instance;
    }
}

// ✅ С Spring - просто аннотация
@Component
public class ConnectionPool { }

// Использование
@Service
public class UserService {
    private final ConnectionPool pool;
    
    public UserService(ConnectionPool pool) {  // Spring внедрит
        this.pool = pool;
    }
}

7. Convention over Configuration

Spring следует конвенциям, минимум конфигурации:

// ❌ Много конфигурации (XML)
<bean id="userService" class="com.example.UserService">
    <constructor-arg ref="userRepository"/>
</bean>

// ✅ Конвенции и аннотации (современный Spring)
@Service
public class UserService {
    private final UserRepository userRepository;
    
    public UserService(UserRepository userRepository) {  // Spring сам найдёт
        this.userRepository = userRepository;
    }
}

8. Don't call us, we'll call you (Hollywood Principle)

Spring управляет жизненным циклом объектов:

@Service
public class UserService implements InitializingBean, DisposableBean {
    
    @PostConstruct  // Spring вызовет после создания Bean
    public void init() {
        System.out.println("Инициализация");
    }
    
    @PreDestroy  // Spring вызовет перед удалением Bean
    public void destroy() {
        System.out.println("Очистка");
    }
}

// Или с аннотациями
@Configuration
public class AppConfig {
    @Bean(initMethod = "init", destroyMethod = "destroy")
    public UserService userService() {
        return new UserService();
    }
}

Вывод

Spring пропагандирует следующие принципы:

1. IoC/DI - фреймворк управляет объектами
2. AOP - разделение кроссирующих concerns
3. SOLID - чистая архитектура
4. DRY - нет дублирования
5. KISS - простота кода
6. Convention over Configuration - минимум конфигурации
7. Hollywood Principle - Spring управляет жизненным циклом

Эти принципы делают код более:

• Читаемым
• Тестируемым
• Поддерживаемым
• Масштабируемым
• Гибким