Какие знаешь основные принципы Spring?

Основные принципы Spring Framework

Spring Framework — один из самых популярных фреймворков для Java разработки. Его успех основан на нескольких фундаментальных принципах, которые делают код более модульным, тестируемым и поддерживаемым.

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

IoC — это принцип, при котором фреймворк управляет созданием и жизненным циклом объектов, а не сам код.

// ❌ Без IoC — тесная связанность
class UserService {
    private DatabaseConnection db;
    
    public UserService() {
        this.db = new DatabaseConnection(); // Создаем сами
    }
}

// ✅ С IoC — Spring управляет объектами
@Service
public class UserService {
    private final DatabaseConnection db;
    
    public UserService(DatabaseConnection db) {
        this.db = db; // Spring инжектирует
    }
}

Преимущества:

• Слабая связанность между компонентами
• Легче тестировать (можно подставить моки)
• Гибкость: можно менять реализацию без изменения кода
• Централизованное управление конфигурацией

2. Dependency Injection (DI) — Инъекция зависимостей

DI — механизм реализации IoC, когда зависимости передаются объекту извне.

// Три способа инъекции в Spring

// 1. Constructor Injection (рекомендуется)
@Component
public class OrderService {
    private final PaymentService paymentService;
    
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

// 2. Setter Injection
@Component
public class InventoryService {
    private ProductRepository repository;
    
    @Autowired
    public void setRepository(ProductRepository repository) {
        this.repository = repository;
    }
}

// 3. Field Injection (не рекомендуется)
@Component
public class NotificationService {
    @Autowired
    private EmailSender emailSender;
}

Best Practice: Constructor Injection — явно показывает зависимости и облегчает тестирование.

3. Слой абстракций

Spring поощряет использование интерфейсов и абстракций вместо конкретных реализаций:

// ✅ Хорошо — зависимость от интерфейса
public interface PaymentProcessor {
    void process(Payment payment);
}

@Service
public class CreditCardProcessor implements PaymentProcessor {
    @Override
    public void process(Payment payment) { /* ... */ }
}

@Service
public class PaymentService {
    private final PaymentProcessor processor;
    
    public PaymentService(PaymentProcessor processor) {
        this.processor = processor;
    }
}

4. Конфигурация через аннотации

Spring позволяет конфигурировать приложение через аннотации вместо XML:

@Configuration
public class AppConfig {
    
    @Bean
    public DatabaseConnection databaseConnection() {
        return new DatabaseConnection(
            "jdbc:mysql://localhost:3306/db",
            "root",
            "password"
        );
    }
    
    @Bean
    public UserRepository userRepository(DatabaseConnection db) {
        return new UserRepository(db);
    }
}

// Или просто через @Component, @Service, @Repository
@Service
public class UserService {
    // Spring сам управляет экземпляром
}

5. Слабая связанность (Loose Coupling)

Компоненты не должны знать друг о друге напрямую:

// ❌ Сильная связанность
class EmailService {
    void sendEmail() {
        SmtpServer server = new SmtpServer(); // Зависит от конкретной реализации
        server.send(...);
    }
}

// ✅ Слабая связанность
@Service
public class EmailService {
    private final MailProvider mailProvider;
    
    public EmailService(MailProvider mailProvider) {
        this.mailProvider = mailProvider;
    }
    
    void sendEmail() {
        mailProvider.send(...);
    }
}

6. Шаблон Strategy и Polymorphism

Spring позволяет переключаться между реализациями в runtime:

// Интерфейс
public interface LoggingStrategy {
    void log(String message);
}

// Различные реализации
@Component("file")
public class FileLogger implements LoggingStrategy {
    @Override
    public void log(String message) { /* файл */ }
}

@Component("database")
public class DatabaseLogger implements LoggingStrategy {
    @Override
    public void log(String message) { /* БД */ }
}

// Использование
@Service
public class ApplicationService {
    private final LoggingStrategy logger;
    
    public ApplicationService(@Qualifier("file") LoggingStrategy logger) {
        this.logger = logger;
    }
}

7. Принцип единственной ответственности (SRP)

Каждый бин должен отвечать за одно:

// ✅ Хорошо — разделение ответственности
@Repository
public class UserRepository {
    // Отвечает за работу с БД
}

@Service
public class UserService {
    // Отвечает за бизнес-логику
}

@RestController
public class UserController {
    // Отвечает за HTTP обработку
}

8. Аспектно-ориентированное программирование (AOP)

Spring позволяет добавлять cross-cutting concerns без изменения основного кода:

@Aspect
@Component
public class LoggingAspect {
    
    @Before("execution(* com.example.service.*.*(..))")  
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("Вызван метод: " + joinPoint.getSignature());
    }
}

// Логирование будет добавлено автоматически
@Service
public class UserService {
    public void createUser(User user) {
        // Логирование происходит автоматически
    }
}

9. Многоуровневая архитектура

Spring поощряет разделение приложения на слои:

Presentation (Controllers)
    ↓
Application (Services)
    ↓
Domain (Business Logic)
    ↓
Infrastructure (Repositories, Database)

// Presentation
@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;
    
    @GetMapping("/{id}")
    public UserDTO getUser(@PathVariable Long id) {
        return userService.findById(id);
    }
}

// Application
@Service
public class UserService {
    private final UserRepository repository;
    
    public UserDTO findById(Long id) {
        return repository.findById(id).map(UserDTO::from).orElse(null);
    }
}

// Infrastructure
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}

10. Декларативная конфигурация

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

// ✅ Декларативная (Spring)
@Transactional
public void transferMoney(User from, User to, double amount) {
    from.setBalance(from.getBalance() - amount);
    to.setBalance(to.getBalance() + amount);
    // Spring автоматически управляет транзакциями
}

// ❌ Императивная
public void transferMoney(User from, User to, double amount) {
    Transaction tx = db.beginTransaction();
    try {
        from.setBalance(from.getBalance() - amount);
        to.setBalance(to.getBalance() + amount);
        tx.commit();
    } catch (Exception e) {
        tx.rollback();
        throw e;
    }
}

Сравнительная таблица принципов