Что делает модуль Spring Core?

Что делает Spring Core

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

Основные функции Spring Core

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

Spring Core управляет созданием и жизненным циклом объектов приложения. Вместо того чтобы код сам создавал зависимости, Spring делает это автоматически:

// БЕЗ Spring — Вы создаете зависимости сами
public class UserService {
    private UserRepository userRepository;
    
    public UserService() {
        this.userRepository = new UserRepositoryImpl(); // Жесткая зависимость
    }
}

// С Spring Core — зависимости внедряются автоматически
@Service
public class UserService {
    private final UserRepository userRepository;
    
    // Spring автоматически создает и внедряет экземпляр
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

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

Spring Core позволяет внедрять зависимости через конструктор, setter или аннотации. Это делает код слабо связанным и легко тестируемым:

// Конструктор инъекция (рекомендуется)
@Service
public class OrderService {
    private final UserRepository userRepository;
    private final EmailService emailService;
    
    public OrderService(UserRepository userRepository, EmailService emailService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
    }
}

// Setter инъекция
@Service
public class PaymentService {
    private PaymentGateway paymentGateway;
    
    @Autowired
    public void setPaymentGateway(PaymentGateway gateway) {
        this.paymentGateway = gateway;
    }
}

// Field инъекция (не рекомендуется для тестирования)
@Service
public class NotificationService {
    @Autowired
    private MailSender mailSender;
}

3. Управление Bean контейнером

Bean — это объект, управляемый Spring. Spring Core содержит контейнер, который управляет всеми бинами приложения:

// Создание Bean
@Configuration
public class AppConfig {
    
    // Явное определение Bean через метод
    @Bean
    public UserRepository userRepository() {
        return new UserRepositoryImpl();
    }
    
    @Bean
    public UserService userService(UserRepository userRepository) {
        return new UserService(userRepository);
    }
}

// ИЛИ автоматическое через аннотации
@Repository
public class UserRepositoryImpl implements UserRepository {
    // Spring автоматически создаст Bean
}

@Service
public class UserService {
    // Spring автоматически создаст Bean и внедрит зависимость
    private final UserRepository userRepository;
    
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

4. Жизненный цикл Bean

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

public interface InitializingBean {
    void afterPropertiesSet() throws Exception; // Вызывается после инициализации
}

public interface DisposableBean {
    void destroy() throws Exception; // Вызывается при уничтожении
}

// ИЛИ через аннотации
@Service
public class DatabaseConnection {
    
    @PostConstruct
    public void connect() {
        // Вызывается после создания Bean
        System.out.println("Подключение к БД");
    }
    
    @PreDestroy
    public void disconnect() {
        // Вызывается перед уничтожением Bean
        System.out.println("Отключение от БД");
    }
}

5. Scopes (области видимости) Bean

// Singleton (по умолчанию) — один экземпляр на все приложение
@Service
public class UserService {
    // один экземпляр на всё приложение
}

// Prototype — новый экземпляр при каждом запросе
@Service
@Scope("prototype")
public class RequestHandler {
    // новый экземпляр каждый раз
}

// Request — один экземпляр на HTTP запрос
@Component
@Scope("request")
public class RequestContext {
    // один на запрос
}

6. Автоматическое сканирование компонентов (Component Scanning)

@SpringBootApplication
@ComponentScan(basePackages = "com.example.app")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

// Spring автоматически найдет все компоненты с аннотациями:
// @Component, @Service, @Repository, @Controller, @RestController

7. Aspect-Oriented Programming (AOP)

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

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

Основные компоненты Spring Core

Преимущества Spring Core

✓ Слабая связанность — компоненты слабо зависят друг от друга ✓ Тестируемость — легко создавать unit-тесты с mock-объектами ✓ Переиспользуемость кода — компоненты можно использовать в разных контекстах ✓ Конфигурируемость — можно менять реализацию без изменения кода ✓ Автоматизация — Spring автоматически управляет жизненным циклом объектов

Spring Core — это основа, которая делает разработку на Java более гибкой, тестируемой и maintainable.