Для чего нужен Bean в Spring?

# Bean в Spring Framework

BEAN — это объект, управляемый контейнером Spring. Это одна из ключевых концепций фреймворка.

Что такое Bean?

Bean — это обычный Java объект, экземпляр которого создаёт и управляет Spring контейнер, а не программист вручную через new.

// Без Spring (управляем сами)
UserService userService = new UserService();

// С Spring (Bean — Spring управляет)
@Component
public class UserService { /* ... */ }

Назначение Bean

1. Управление жизненным циклом — Spring создаёт объект, инициализирует, удаляет
2. Внедрение зависимостей (DI) — автоматическое связывание зависимостей
3. Конфигурация — одна конфигурация для всего приложения
4. Переиспользование — один Bean используется многими компонентами
5. AOP — применение cross-cutting concerns (логирование, транзакции)

Способы создания Bean

1. Аннотация @Component

@Component
public class UserRepository {
    public List<User> findAll() { /* ... */ }
}

Spring автоматически создаст Bean и зарегистрирует его.

2. @Service, @Repository, @Controller

Это специализированные @Component для разных слоёв:

@Repository // для data access слоя
public class UserRepository { /* ... */ }

@Service    // для business logic слоя
public class UserService { /* ... */ }

@Controller // для web layer
public class UserController { /* ... */ }

@RestController // REST endpoints
public class UserRestController { /* ... */ }

3. @Configuration и @Bean

@Configuration
public class AppConfig {
    @Bean
    public UserRepository userRepository() {
        return new UserRepository();
    }
    
    @Bean
    public UserService userService(UserRepository repo) {
        return new UserService(repo); // DI автоматически
    }
}

4. XML конфигурация (устаревает)

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

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

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

@Service
public class UserService {
    private final UserRepository userRepository;
    private final EmailService emailService;
    
    // Constructor injection (предпочтительно)
    public UserService(UserRepository userRepository, EmailService emailService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
    }
    
    public void registerUser(String email) {
        // Spring автоматически создал и внедрил зависимости
        userRepository.save(new User(email));
        emailService.sendWelcomeEmail(email);
    }
}

@Service
public class EmailService { /* ... */ }

@Repository
public class UserRepository { /* ... */ }

Bez Spring пришлось бы вручную:

// Без DI
UserRepository repo = new UserRepository();
EmailService email = new EmailService();
UserService service = new UserService(repo, email); // вручную привязываем

Scope Bean

Spring может создать Bean разными способами:

1. Singleton (по умолчанию)

@Component
// или
@Bean
@Scope("singleton")
public class ConfigService { /* ... */ }

Один экземпляр на всё приложение. Потокобезопасен.

2. Prototype

@Component
@Scope("prototype")
public class RequestData { /* ... */ }

Новый экземпляр каждый раз при запросе.

3. Request (Web)

@Component
@Scope("request")
public class UserContext { /* ... */ }

Новый экземпляр на каждый HTTP запрос.

4. Session (Web)

@Component
@Scope("session")
public class UserSession { /* ... */ }

Один экземпляр на сессию пользователя.

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

@Component
public class MyBean implements InitializingBean, DisposableBean {
    
    @PostConstruct
    public void initialize() {
        System.out.println("Bean создан и инициализирован");
    }
    
    @PreDestroy
    public void cleanup() {
        System.out.println("Bean удаляется");
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
        // инициализация
    }
    
    @Override
    public void destroy() throws Exception {
        // очистка ресурсов
    }
}

Практический пример

// 1. Определяем компоненты
@Repository
public class BookRepository {
    public List<Book> findAll() { return Arrays.asList(...); }
}

@Service
public class BookService {
    private final BookRepository repo;
    
    public BookService(BookRepository repo) { // DI
        this.repo = repo;
    }
    
    public List<Book> getAllBooks() {
        return repo.findAll();
    }
}

@RestController
@RequestMapping("/api/books")
public class BookController {
    private final BookService service;
    
    public BookController(BookService service) { // DI
        this.service = service;
    }
    
    @GetMapping
    public ResponseEntity<List<Book>> getBooks() {
        return ResponseEntity.ok(service.getAllBooks());
    }
}

// 2. Spring автоматически создал все Bean и связал их
// 3. Когда приходит HTTP запрос, BookController получает BookService
// 4. BookService получает BookRepository
// 5. Всё работает!

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

1. Слабая связанность — компоненты зависят от интерфейсов, не от конкретных реализаций
2. Тестируемость — легко подменить Bean на mock для тестов
3. Гибкость — изменить реализацию без изменения кода
4. Централизованная конфигурация — вся логика связывания в одном месте
5. Переиспользование — один Bean используется везде

Основное правило

Bean — это управляемый Spring объект. Вместо того чтобы вручную создавать объекты и связывать их зависимости, это делает Spring контейнер. Это облегчает разработку, тестирование и поддержку приложений.