В чем различие конфигурации основанной на аннотациях и на коде

Различие конфигурации на аннотациях vs код

В Spring есть два основных подхода к конфигурации: декларативный (аннотации) и программный (Java код).

Конфигурация на аннотациях (@Component, @Bean)

Определение: Вы помечаете классы аннотациями, и Spring сам создаёт бины и внедряет зависимости.

// @Component — упрощённо
@Component
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    public User findUser(String id) {
        return userRepository.findById(id);
    }
}

@Component
public class UserController {
    @Autowired
    private UserService userService;  // Автоматически внедрится
    
    @GetMapping("/users/{id}")
    public User getUser(@PathVariable String id) {
        return userService.findUser(id);
    }
}

// Так же работает с @Service, @Repository
@Service
public class OrderService { ... }

@Repository
public class OrderRepository { ... }

// @Bean для конкретных объектов
@Configuration
public class AppConfig {
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
    
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

Как это работает:

1. Spring сканирует пакеты (@ComponentScan)
2. Находит классы с аннотациями
3. Создаёт экземпляры (бины)
4. Внедряет зависимости где нужны

Конфигурация на коде (Java Config)

Определение: Вы явно определяете бины в Java классе через методы с @Bean.

@Configuration
public class AppConfig {
    // Вручную создаём бины
    
    @Bean
    public UserRepository userRepository() {
        return new PostgresUserRepository();
    }
    
    @Bean
    public UserService userService(UserRepository repo) {
        // Зависимость внедряется как параметр
        return new UserService(repo);
    }
    
    @Bean
    public UserController userController(UserService service) {
        return new UserController(service);
    }
    
    @Bean
    public DataSource dataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:postgresql://localhost/db");
        config.setUsername("user");
        config.setPassword("password");
        return new HikariDataSource(config);
    }
}

Как это работает:

1. Spring видит @Configuration
2. Вызывает методы с @Bean
3. Результат становится бином в контексте
4. Параметры методов — внедряемые зависимости

Основные различия

Примеры различий

1. Условная конфигурация

На аннотациях (сложно):

@Component
@ConditionalOnProperty(name = "payment.provider", havingValue = "stripe")
public class StripePaymentService {
    // ...
}

@Component
@ConditionalOnProperty(name = "payment.provider", havingValue = "paypal")
public class PayPalPaymentService {
    // ...
}

На Java Config (понятнее):

@Configuration
public class PaymentConfig {
    @Bean
    @ConditionalOnProperty(name = "payment.provider", havingValue = "stripe")
    public PaymentService stripePayment() {
        return new StripePaymentService();
    }
    
    @Bean
    @ConditionalOnProperty(name = "payment.provider", havingValue = "paypal")
    public PaymentService paypalPayment() {
        return new PayPalPaymentService();
    }
}

2. Конфигурация третьих библиотек

На аннотациях (невозможно):

// Не можем аннотировать класс JdbcTemplate (не наш код!)
@Autowired
private JdbcTemplate jdbcTemplate;  // Как это появилось?

На Java Config (правильно):

@Configuration
public class Config {
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

3. Сложная логика инициализации

На аннотациях (невозможно):

@Component
public class DatabaseConnection {
    @PostConstruct
    public void init() {
        // Очень ограниченный способ
    }
}

На Java Config (просто):

@Configuration
public class Config {
    @Bean
    public DatabaseConnection dbConnection() throws Exception {
        // Вся логика инициализации в методе
        Connection conn = DriverManager.getConnection(url);
        conn.setAutoCommit(true);
        conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
        return new DatabaseConnection(conn);
    }
}

4. Зависимости от переменных окружения

На аннотациях:

@Component
public class ApiClient {
    @Value("${api.url}")
    private String apiUrl;
    
    @Value("${api.key}")
    private String apiKey;
}

На Java Config:

@Configuration
public class Config {
    @Bean
    public ApiClient apiClient(
        @Value("${api.url}") String apiUrl,
        @Value("${api.key}") String apiKey
    ) {
        return new ApiClient(apiUrl, apiKey);
    }
}

Best Practices

1. Используй аннотации для своего кода

@Service
public class UserService {
    @Autowired
    private UserRepository repo;  // Просто и понятно
}

2. Используй Java Config для третьих библиотек

@Configuration
public class Config {
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
    
    @Bean
    public DataSource dataSource() {
        // Конфигурация БД
    }
}

3. Комбинируй оба подхода

// AppConfig.java
@Configuration
@ComponentScan(basePackages = "com.example.app")
public class AppConfig {
    @Bean
    public DataSource dataSource() { ... }
}

// UserService.java
@Service
public class UserService {
    @Autowired
    private DataSource dataSource;  // Из Java Config
}

4. Для сложной логики используй Java Config

@Configuration
public class FeatureToggleConfig {
    @Bean
    public PaymentService paymentService(Environment env) {
        String provider = env.getProperty("payment.provider");
        
        if ("stripe".equals(provider)) {
            return new StripePaymentService();
        } else if ("paypal".equals(provider)) {
            return new PayPalPaymentService();
        } else {
            throw new IllegalStateException("Unknown payment provider");
        }
    }
}

Тестирование

На аннотациях (нужен контекст):

@SpringBootTest
class UserServiceTest {
    @Autowired
    private UserService userService;  // Нужен полный контекст
    
    @Test
    void testFindUser() {
        // Тест
    }
}

На Java Config (можем мокировать):

class UserServiceTest {
    private UserService userService;
    private UserRepository mockRepo = mock(UserRepository.class);
    
    @BeforeEach
    void setUp() {
        userService = new UserService(mockRepo);  // Инъекция вручную
    }
    
    @Test
    void testFindUser() {
        // Тест без контекста Spring
    }
}

Вывод

Используй аннотации когда:

• Конфигурируешь собственные компоненты
• Нужна простота и скорость разработки
• Логика простая

Используй Java Config когда:

• Конфигурируешь третьи библиотеки
• Нужна сложная логика инициализации
• Нужна условная конфигурация
• Нужна большая гибкость
• Нужно легко тестировать

Рекомендация: Комбинируй оба подхода — аннотации для своего кода, Java Config для библиотек и сложной логики.