Как конфигурировать Spring с помощью Java Based Configuration

Java-based конфигурация в Spring

Java-based конфигурация — это современный и гибкий способ конфигурирования Spring приложений, полностью заменяющий XML конфигурацию. Этот подход дает полный контроль, лучшую поддержку IDE и типизацию.

Основной принцип

Вместо XML файлов вы создаете Java классы с аннотацией @Configuration, где определяете бины и их зависимости.

Базовая конфигурация

1. Создание @Configuration класса

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Service;

@Configuration
public class AppConfig {
    
    // Определение бина
    @Bean
    public UserService userService() {
        return new UserService(userRepository());
    }
    
    @Bean
    public UserRepository userRepository() {
        return new UserRepository();
    }
}

2. Использование @Bean с зависимостями

@Configuration
public class AppConfig {
    
    // Способ 1: Внедрение через параметр метода
    @Bean
    public UserService userService(UserRepository userRepository) {
        return new UserService(userRepository);
    }
    
    @Bean
    public UserRepository userRepository(DataSource dataSource) {
        return new UserRepository(dataSource);
    }
    
    // Spring автоматически разрешит зависимости
}

3. Конфигурация с DataSource и Database

import javax.sql.DataSource;
import org.springframework.context.annotation.Bean;
import com.zaxxer.hikari.HikariDataSource;

@Configuration
public class DatabaseConfig {
    
    @Bean
    public DataSource dataSource() {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl("jdbc:postgresql://localhost:5432/mydb");
        dataSource.setUsername("postgres");
        dataSource.setPassword("password");
        dataSource.setMaximumPoolSize(20);
        return dataSource;
    }
    
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

4. Конфигурация с Environment переменными

import org.springframework.core.env.Environment;
import org.springframework.beans.factory.annotation.Autowired;

@Configuration
public class AppConfig {
    
    @Autowired
    private Environment env;
    
    @Bean
    public DataSource dataSource() {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl(env.getProperty("spring.datasource.url"));
        dataSource.setUsername(env.getProperty("spring.datasource.username"));
        dataSource.setPassword(env.getProperty("spring.datasource.password"));
        return dataSource;
    }
}

5. Использование @Value для экспресс-доступа

import org.springframework.beans.factory.annotation.Value;

@Configuration
public class AppConfig {
    
    @Value("${spring.datasource.url}")
    private String dbUrl;
    
    @Value("${spring.datasource.username}")
    private String dbUsername;
    
    @Bean
    public DataSource dataSource() {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl(dbUrl);
        dataSource.setUsername(dbUsername);
        return dataSource;
    }
}

Продвинутые техники

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

import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;

@Configuration
public class CacheConfig {
    
    @Bean
    @ConditionalOnProperty(name = "cache.enabled", havingValue = "true")
    public CacheManager cacheManager() {
        return new EhCacheCacheManager();
    }
    
    @Bean
    @ConditionalOnMissingBean
    public CacheManager defaultCacheManager() {
        return new NoOpCacheManager();
    }
}

2. Профилированная конфигурация

// Development конфигурация
@Configuration
@Profile("dev")
public class DevConfig {
    @Bean
    public DataSource dataSource() {
        // Development БД (локальная)
        return createDataSource("jdbc:h2:mem:testdb");
    }
}

// Production конфигурация
@Configuration
@Profile("prod")
public class ProdConfig {
    @Bean
    public DataSource dataSource() {
        // Production БД (RDS, AWS)
        return createDataSource("jdbc:postgresql://prod-db.aws.com");
    }
}

3. Bean Lifecycle callbacks

@Configuration
public class AppConfig {
    
    @Bean(initMethod = "init", destroyMethod = "destroy")
    public UserService userService() {
        return new UserService();
    }
}

public class UserService {
    public void init() {
        System.out.println("UserService инициализирована");
    }
    
    public void destroy() {
        System.out.println("UserService удалена");
    }
}

4. @Import для композиции конфигураций

// Главная конфигурация
@Configuration
@Import({DatabaseConfig.class, SecurityConfig.class, CacheConfig.class})
public class AppConfig {
    // Основные бины
}

// Отдельные конфигурации
@Configuration
public class DatabaseConfig {
    @Bean
    public DataSource dataSource() { ... }
}

@Configuration
public class SecurityConfig {
    @Bean
    public SecurityManager securityManager() { ... }
}

Spring Boot: application.properties/yml

# application.properties
spring.datasource.url=jdbc:postgresql://localhost:5432/mydb
spring.datasource.username=postgres
spring.datasource.password=secret
spring.jpa.hibernate.ddl-auto=validate
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQL10Dialect
spring.cache.type=redis
spring.redis.host=localhost
spring.redis.port=6379

# application.yml
spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydb
    username: postgres
    password: secret
  jpa:
    hibernate:
      ddl-auto: validate
    properties:
      hibernate:
        dialect: org.hibernate.dialect.PostgreSQL10Dialect
  cache:
    type: redis
  redis:
    host: localhost
    port: 6379

Использование @ConfigurationProperties

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "app")
public class AppProperties {
    private String name;
    private String version;
    private DatabaseConfig database;
    
    // Getters and setters
    public static class DatabaseConfig {
        private String url;
        private String username;
        private int maxPoolSize;
        // Getters and setters
    }
}

// application.properties
// app.name=MyApp
// app.version=1.0.0
// app.database.url=jdbc:postgresql://...
// app.database.username=postgres
// app.database.max-pool-size=20

Полный практический пример: Spring Boot приложение

@Configuration
@EnableTransactionManagement
@EnableCaching
public class ApplicationConfig {
    
    // Конфигурация DataSource
    @Bean
    public DataSource dataSource(
            @Value("${spring.datasource.url}") String url,
            @Value("${spring.datasource.username}") String username,
            @Value("${spring.datasource.password}") String password) {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        dataSource.setMaximumPoolSize(20);
        return dataSource;
    }
    
    // Конфигурация JPA/Hibernate
    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(
            DataSource dataSource) {
        LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
        em.setDataSource(dataSource);
        em.setPackagesToScan("com.example.domain");
        
        JpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
        em.setJpaVendorAdapter(vendorAdapter);
        
        Properties props = new Properties();
        props.put("hibernate.dialect", "org.hibernate.dialect.PostgreSQL10Dialect");
        props.put("hibernate.format_sql", "true");
        em.setJpaProperties(props);
        
        return em;
    }
    
    // Конфигурация Transaction Manager
    @Bean
    public PlatformTransactionManager transactionManager(
            EntityManagerFactory entityManagerFactory) {
        return new JpaTransactionManager(entityManagerFactory);
    }
    
    // Конфигурация Services
    @Bean
    public UserService userService(UserRepository userRepository) {
        return new UserService(userRepository);
    }
    
    // Конфигурация Caching
    @Bean
    public CacheManager cacheManager() {
        return new ConcurrentMapCacheManager("users", "posts");
    }
}

Сравнение: XML vs Java-based

<!-- XML конфигурация (старый подход) -->
<bean id="userService" class="com.example.UserService">
    <constructor-arg ref="userRepository"/>
</bean>

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

// Java-based конфигурация (современный подход)
@Configuration
public class AppConfig {
    @Bean
    public UserService userService(UserRepository userRepository) {
        return new UserService(userRepository);
    }
    
    @Bean
    public UserRepository userRepository(DataSource dataSource) {
        return new UserRepository(dataSource);
    }
}

Преимущества Java-based конфигурации

1. Типизация: IDE помощь и рефакторинг
2. Гибкость: Полная мощь Java логики
3. Тестируемость: Легко создавать тестовые конфигурации
4. Современность: Стандарт в современных Spring приложениях
5. Рефакторинг: IDE поддерживает безопасный рефакторинг

Java-based конфигурация — это стандартный подход в современной Spring разработке, обеспечивающий лучший контроль и производительность при разработке.