Какая минимальная структурная единица, оперируемая Spring?

Какая минимальная структурная единица, оперируемая Spring?

Это вопрос о фундаментальных концепциях Spring Framework. Ответ: Bean — это минимальная структурная единица в Spring.

Bean — основа Spring

Bean — это просто Java объект, управляемый Spring контейнером (Application Context). Spring создает его, управляет его жизненным циклом и внедряет зависимости.

Что такое Bean?

Bean — это POJO (Plain Old Java Object), аннотированный специальными метаданными:

// Это обычный Java класс
public class User {
    private String name;
    private String email;
    // getters, setters
}

// Это BEAN (управляется Spring)
@Component
public class UserService {
    private final UserRepository userRepository;
    
    @Autowired // Spring внедрит зависимость
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

Сразу после запуска Spring:

1. Находит класс с @Component
2. Создает экземпляр через конструктор
3. Регистрирует его в Application Context (контейнер Bean)
4. Готов к использованию

Слои структуры Spring

Структурная иерархия в Spring:

Application (приложение)
  ├─ Application Context (контейнер Bean)
  │  ├─ Bean
  │  │  ├─ Компонент 1 (@Component)
  │  │  ├─ Сервис 1 (@Service)
  │  │  ├─ Контроллер 1 (@RestController)
  │  │  └─ Репозиторий 1 (@Repository)
  │  ├─ Bean
  │  └─ ...
  └─ (другие компоненты)

Bean — это атомарная единица, которой Spring может управлять.

Типы Bean

1. По способу создания

// 1. Через аннотацию @Component
@Component
public class SimpleService {
}

// 2. Через @Bean метод в конфигурации
@Configuration
public class AppConfig {
    @Bean
    public UserService userService() {
        return new UserService();
    }
}

// 3. Через фабрику (FactoryBean)
@Component
public class CustomBeanFactory implements FactoryBean<MyService> {
    @Override
    public MyService getObject() {
        return new MyService();
    }
}

2. По специализации

// @Component — базовый
@Component
public class GenericComponent {
}

// @Service — сервис-слой
@Service
public class UserService {
}

// @Repository — доступ к данным
@Repository
public class UserRepository {
}

// @RestController — веб контроллер
@RestController
public class UserController {
}

// @Configuration — конфигурация
@Configuration
public class AppConfig {
}

Все они — просто Bean, но семантически обозначают слой.

Application Context

Application Context — это контейнер, хранящий все Bean.

public class Main {
    public static void main(String[] args) {
        // Создание контекста (Application Context)
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        
        // Получение Bean из контекста
        UserService userService = context.getBean(UserService.class);
        
        // Bean готов к использованию
        userService.createUser("john@example.com");
    }
}

// Или с Spring Boot (контекст создается автоматически)
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
        // Spring создает Application Context сам
    }
}

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

Bean проходит через четкие этапы:

@Component
public class MyBean implements InitializingBean, DisposableBean {
    
    // Этап 1: Создание объекта
    public MyBean() {
        System.out.println("1. Constructor called");
    }
    
    // Этап 2: Установка зависимостей
    @Autowired
    public void setDependency(SomeDependency dep) {
        System.out.println("2. Dependency set");
    }
    
    // Этап 3: Инициализация
    @PostConstruct
    public void init() {
        System.out.println("3. Bean initialized");
    }
    
    // Этап 4: Использование
    public void doSomething() {
        System.out.println("4. Bean is in use");
    }
    
    // Этап 5: Разрушение
    @PreDestroy
    public void cleanup() {
        System.out.println("5. Bean destroyed");
    }
}

Выход консоли при запуске:

1. Constructor called
2. Dependency set
3. Bean initialized
4. Bean is in use
5. Bean destroyed (при завершении приложения)

Структура внутри Bean

Внутри Bean обычно структурируется по слоям:

// Domain layer
public class User { // Не Bean (просто модель данных)
    private UUID id;
    private String email;
}

// Application layer
@Service
public class UserService { // Bean
    private final UserRepository repository;
    private final EmailService emailService;
    
    public User createUser(String email) {
        User user = new User(email);
        repository.save(user);
        emailService.sendWelcome(user);
        return user;
    }
}

// Infrastructure layer
@Repository
public class UserRepository { // Bean
    private final JdbcTemplate jdbcTemplate;
    
    public void save(User user) {
        jdbcTemplate.update("INSERT INTO users...", user.getEmail());
    }
}

// Presentation layer
@RestController
@RequestMapping("/api/users")
public class UserController { // Bean
    private final UserService service;
    
    @PostMapping
    public UserDTO create(@RequestBody CreateUserRequest req) {
        User user = service.createUser(req.getEmail());
        return new UserDTO(user);
    }
}

Каждый слой — это отдельный Bean.

Dependency Injection внутри Bean

Spring внедряет зависимости в Bean:

@Service
public class OrderService { // Это Bean
    // Spring внедрит эти Bean в конструктор
    private final UserRepository userRepository;
    private final PaymentService paymentService;
    private final EmailService emailService;
    
    @Autowired
    public OrderService(
        UserRepository userRepository,      // Bean
        PaymentService paymentService,     // Bean
        EmailService emailService          // Bean
    ) {
        this.userRepository = userRepository;
        this.paymentService = paymentService;
        this.emailService = emailService;
    }
    
    public void processOrder(UUID orderId) {
        // Используем внедренные Bean
        User user = userRepository.findById(orderId);
        paymentService.charge(user);
        emailService.sendConfirmation(user);
    }
}

Управление Bean

Spring контейнер управляет Bean через Application Context:

public class BeanManagementExample {
    public static void main(String[] args) {
        ApplicationContext context = SpringApplication.run(Application.class, args);
        
        // Получение Bean по типу
        UserService userService = context.getBean(UserService.class);
        
        // Получение Bean по имени
        UserService userService2 = (UserService) context.getBean("userService");
        
        // Проверка наличия Bean
        boolean exists = context.containsBean("userService");
        
        // Получение всех Bean определенного типа
        Map<String, UserService> beans = context.getBeansOfType(UserService.class);
        
        // Получение информации о Bean
        String[] beanNames = context.getBeanDefinitionNames();
        System.out.println("Всего Bean в контексте: " + beanNames.length);
    }
}

Scope Bean

Bean может иметь разные scope (область действия):

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

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

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

// Session — один экземпляр на сессию пользователя
@Component
@Scope("session")
public class SessionService {
}

Bean как атомарная единица

Почему Bean — это минимальная структурная единица?

1. Индивидуальное управление: Spring управляет каждым Bean отдельно

// Каждый Bean создается и управляется независимо
@Service // Bean 1
public class ServiceA { }

@Service // Bean 2
public class ServiceB { }

// При старте Spring создает оба, управляет их жизненным циклом

1. Внедрение зависимостей на уровне Bean

// ServiceA зависит от ServiceB (оба Bean)
@Service
public class ServiceA {
    @Autowired
    private ServiceB serviceB; // Зависимость — другой Bean
}

1. Невозможно управлять частями Bean

@Service
public class UserService {
    private UserRepository repo;  // Часть Bean, не управляется Spring
    private EmailService email;   // Часть Bean, не управляется Spring
    // Нельзя получить эти компоненты отдельно из контекста
}

Заключение

Minimal structural unit в Spring — это Bean:

• Простой Java объект
• Создается и управляется Spring
• Может внедрять другие Bean
• Имеет жизненный цикл
• Регистрируется в Application Context
• Может быть одного из нескольких типов (@Component, @Service, @Repository, @RestController)

Всё остальное в Spring строится на базе Bean — контроллеры, сервисы, репозитории, конфигурация. Без Bean нет Spring приложения.