Что такое обращение к бину?

Обращение к бину в Spring

Обращение к бину — это процесс получения экземпляра управляемого объекта (бина) из контейнера Spring. Бины — это объекты, которыми управляет фреймворк Spring, а не приложение.

Что такое бин?

Бин (Bean) — это объект, создаваемый и управляемый контейнером Spring. Вместо того чтобы вручную создавать объекты с помощью new, Spring сам создаёт, конфигурирует и уничтожает бины.

// Обычный объект (без Spring)
UserService service = new UserService();

// Бин в Spring (создаёт и управляет Spring)
@Component
public class UserService {
    // ...
}

Способы обращения к бинам

1. Автоматическое внедрение (Dependency Injection) — @Autowired

Это самый простой и рекомендуемый способ:

@Service
public class UserService {
    private final UserRepository userRepository;
    
    // Конструктор для внедрения зависимости
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

@RestController
public class UserController {
    private final UserService userService;
    
    // Spring автоматически создаст UserService и внедрит его
    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }
    
    @GetMapping("/users/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        return ResponseEntity.ok(userService.findUser(id));
    }
}

2. Field Injection — прямое внедрение в поле

@RestController
public class UserController {
    @Autowired
    private UserService userService;
    
    // userService автоматически внедрён
}

Этот способ менее рекомендуется, так как усложняет тестирование.

3. Setter Injection — внедрение через setter

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

4. Метод обращения к ApplicationContext напрямую

Для редких случаев, когда нужен динамический доступ:

@Component
public class BeanAccessor {
    @Autowired
    private ApplicationContext applicationContext;
    
    // Получить бин по типу
    public UserService getUserService() {
        return applicationContext.getBean(UserService.class);
    }
    
    // Получить бин по имени
    public UserService getUserServiceByName() {
        return (UserService) applicationContext.getBean("userService");
    }
    
    // Проверить наличие бина
    public boolean hasUserService() {
        return applicationContext.containsBean("userService");
    }
}

Создание бинов

Способ 1: @Component и его производные

// Автоматическая регистрация как бина
@Component
public class MyComponent {
    // ...
}

// Или более специализированные аннотации
@Service      // Для бизнес-логики
public class UserService {
    // ...
}

@Repository   // Для работы с данными
public class UserRepository {
    // ...
}

@Controller   // Для контроллеров (устаревший способ)
public class UserController {
    // ...
}

Способ 2: @Bean в @Configuration классе

@Configuration
public class AppConfig {
    
    // Явно определяем бин
    @Bean
    public UserService userService() {
        return new UserService(userRepository());
    }
    
    @Bean
    public UserRepository userRepository() {
        return new UserRepository();
    }
    
    // С параметрами
    @Bean
    public DataSource dataSource(
        @Value("${db.url}") String url,
        @Value("${db.user}") String user) {
        return new DataSource(url, user);
    }
}

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

@Component
public class UserService implements InitializingBean, DisposableBean {
    
    // 1. Конструктор
    public UserService() {
        System.out.println("1. Конструктор вызван");
    }
    
    // 2. Установка свойств (setter injection)
    @Autowired
    public void setRepository(UserRepository repo) {
        System.out.println("2. Setter вызван");
    }
    
    // 3. Инициализация
    @PostConstruct
    public void init() {
        System.out.println("3. Init вызван");
    }
    
    // 4. Использование бина
    public void doSomething() {
        System.out.println("4. Бин используется");
    }
    
    // 5. Уничтожение
    @PreDestroy
    public void cleanup() {
        System.out.println("5. Cleanup вызван");
    }
}

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

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

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

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

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

Квалификация бинов (если есть несколько реализаций)

// Интерфейс
public interface UserRepository {
    User findById(Long id);
}

// Первая реализация
@Component
@Qualifier("sqlUserRepository")
public class SqlUserRepository implements UserRepository {
    @Override
    public User findById(Long id) {
        // реализация
    }
}

// Вторая реализация
@Component
@Qualifier("mongoUserRepository")
public class MongoUserRepository implements UserRepository {
    @Override
    public User findById(Long id) {
        // реализация
    }
}

// Использование нужной реализации
@Service
public class UserService {
    @Autowired
    @Qualifier("sqlUserRepository")
    private UserRepository repository;
}

Примеры обращения к бину

Пример 1: Стандартное использование

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

Пример 2: Динамическое обращение

@Component
public class ServiceFactory {
    
    @Autowired
    private ApplicationContext context;
    
    public void processUser(Long userId) {
        // Получить бин динамически
        UserService service = context.getBean(UserService.class);
        service.process(userId);
    }
}

Пример 3: Optional бины

@Service
public class NotificationService {
    
    private final Optional<EmailService> emailService;
    
    public NotificationService(Optional<EmailService> emailService) {
        this.emailService = emailService;
    }
    
    public void notify(String message) {
        // Проверить наличие бина
        emailService.ifPresent(service -> service.send(message));
    }
}

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