Что такое Spring Core?

# Что такое Spring Core?

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

Основная задача Spring Core

Spring Core обеспечивает:

1. Инверсию управления (IoC) — контейнер управляет жизненным циклом объектов
2. Внедрение зависимостей (DI) — автоматическое связывание компонентов
3. Управление бинами — создание, конфигурирование и предоставление объектов
4. Аспектно-ориентированное программирование (AOP) — кросс-функциональная логика

IoC контейнер (Inversion of Control)

Замест того, чтобы ваш код создавал объекты и управлял их зависимостями, Spring контейнер делает это за вас:

// Без Spring — вы управляете объектами
public class OrderService {
    private UserRepository userRepository = new UserRepository();
    private PaymentService paymentService = new PaymentService();
    
    public void processOrder(Order order) {
        // логика
    }
}

// С Spring — контейнер управляет объектами
@Service
public class OrderService {
    private UserRepository userRepository;  // Spring инжектирует
    private PaymentService paymentService;  // Spring инжектирует
    
    public OrderService(UserRepository userRepository, PaymentService paymentService) {
        this.userRepository = userRepository;
        this.paymentService = paymentService;
    }
    
    public void processOrder(Order order) {
        // логика
    }
}

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

DI — это главный механизм Spring Core. Зависимости могут быть внедрены несколькими способами:

1. Через конструктор (рекомендуемый способ)

@Service
public class UserService {
    private UserRepository userRepository;
    
    // Spring автоматически вызовет этот конструктор
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    public User getUserById(Long id) {
        return userRepository.findById(id);
    }
}

2. Через setter

@Service
public class UserService {
    private UserRepository userRepository;
    
    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

3. Через поле (аннотация)

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
}

Определение бинов

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

1. Через аннотации

@Component      // Универсальный компонент
@Service        // Сервис бизнес-логики
@Repository     // Слой доступа к данным
@Controller     // Контроллер (для web)
public class UserService {
}

@Configuration
public class AppConfig {
    @Bean
    public UserRepository userRepository() {
        return new UserRepository();
    }
}

2. Через XML конфигурацию (устаревший способ)

<bean id="userRepository" class="com.example.UserRepository"/>
<bean id="userService" class="com.example.UserService">
    <constructor-arg ref="userRepository"/>
</bean>

Жизненный цикл бина

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

@Component
public class UserRepository implements InitializingBean, DisposableBean {
    
    @PostConstruct
    public void init() {
        System.out.println("Инициализация репозитория");
    }
    
    @PreDestroy
    public void cleanup() {
        System.out.println("Очистка ресурсов");
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
        // Вызывается после установки всех свойств
    }
    
    @Override
    public void destroy() throws Exception {
        // Вызывается при завершении
    }
}

Области видимости (Scopes)

Spring Core предоставляет разные области видимости бинов:

@Component
@Scope("singleton")     // Один экземпляр на всё приложение (по умолчанию)
public class SingletonService { }

@Component
@Scope("prototype")     // Новый экземпляр при каждом запросе
public class PrototypeService { }

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

@Component
@Scope("session")       // Один экземпляр на HTTP сессию
public class SessionService { }

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

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("Метод завершён");
    }
    
    @Around("execution(* com.example.service.*Service.*(..))")  // Вокруг
    public Object measure(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed();  // Вызов оригинального метода
        long time = System.currentTimeMillis() - start;
        System.out.println("Время выполнения: " + time + "ms");
        return result;
    }
}

Практический пример полного цикла

// 1. Определяем интерфейс (абстракция)
public interface UserRepository {
    User findById(Long id);
}

// 2. Реализуем
@Repository
public class UserRepositoryImpl implements UserRepository {
    @Override
    public User findById(Long id) {
        return new User(id, "John");
    }
}

// 3. Используем в сервисе
@Service
public class UserService {
    private UserRepository userRepository;
    
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    public User getUserInfo(Long id) {
        return userRepository.findById(id);
    }
}

// 4. Используем в контроллере
@RestController
@RequestMapping("/api/users")
public class UserController {
    private UserService userService;
    
    public UserController(UserService userService) {
        this.userService = userService;
    }
    
    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.getUserInfo(id);
    }
}

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

1. Слабая связанность — компоненты слабо связаны благодаря DI
2. Тестируемость — легко подменять зависимости в тестах
3. Переиспользование — бины можно использовать в разных местах
4. Гибкость — легко менять реализацию без изменения кода
5. Управление ресурсами — Spring управляет созданием и уничтожением объектов

Вывод

Spring Core — это не просто фреймворк, это фундамент, на котором построено всё остальное в Spring экосистема (Spring MVC, Spring Data, Spring Security и т.д.). Понимание Spring Core критически важно для эффективной разработки на Java.