स्प्रिंग बूट ऑटो-कॉन्फ़िगरेशन कैसे काम करता है

की दुनिया में दीप विसर्जन स्प्रिंग बूट @Conditional एनोटेशन की अच्छी तरह से विकसित उदाहरण के साथ मोंगो और MySQL डेटाबेस का उपयोग वर्ग कार्यान्वयन ।

मेरी पोस्ट में “ स्प्रिंग बूट क्यों? "स्प्रिंग बूट एप्लिकेशन के निर्माण की समीक्षा की गई, जिसमें से आप शायद ही समझ सकते हैं कि पर्दे के पीछे क्या चल रहा है। शायद आप स्प्रिंग बूट ऑटो-कॉन्फ़िगरेशन जादू को समझना चाहते हैं।

इससे पहले, आपको वसंत के बारे में @Conditional एनोटेशन के बारे में सीखना चाहिए , जो सभी स्प्रिंग बूट ऑटो-कॉन्फ़िगरेशन जादू पर निर्भर करता है।

अन्वेषण @Conditional सुविधाएँ

वसंत के आधार पर अनुप्रयोगों को विकसित करते समय, आपको सेम घटकों को सशर्त रूप से पंजीकृत करने की आवश्यकता हो सकती है।

उदाहरण के लिए, आप डेटासोर्स बीन को पंजीकृत कर सकते हैं जो कि डीईवी डेटाबेस को इंगित करता है जब एप्लिकेशन स्थानीय रूप से शुरू होता है, और उत्पादन वातावरण में काम करते समय किसी अन्य प्रोडक्शन डेटाबेस को इंगित करता है।

आप डेटाबेस कनेक्शन सेटिंग्स को गुण फ़ाइल में स्थानांतरित कर सकते हैं और पर्यावरण से मेल खाने वाली फ़ाइल का उपयोग कर सकते हैं, लेकिन जब भी आपको एक अलग वातावरण निर्दिष्ट करने और एप्लिकेशन बनाने की आवश्यकता होती है, तो आपको कॉन्फ़िगरेशन को बदलना होगा।

इस समस्या को हल करने के लिए, स्प्रिंग 3.1 ने प्रोफाइल (प्रोफ़ाइल) की अवधारणा पेश की । आप एक ही प्रकार की कई बीन्स को पंजीकृत कर सकते हैं और उन्हें एक या अधिक प्रोफाइल के साथ जोड़ सकते हैं। जब आप एप्लिकेशन शुरू करते हैं, तो आप सक्रिय प्रोफाइल से जुड़े आवश्यक प्रोफाइल और घटकों को सक्रिय कर सकते हैं, और केवल इन प्रोफाइल को पंजीकृत किया जाएगा।

@Configuration
public class AppConfig
{
     @Bean
     @Profile("DEV")
     public DataSource devDataSource() {
        ...
     }

     @Bean
     @Profile("PROD")
     public DataSource prodDataSource() {
        ...
     }
}

फिर आप सिस्टम प्रॉपर्टी - Dspring.profiles.active = DEV का उपयोग करके सक्रिय प्रोफ़ाइल निर्दिष्ट कर सकते हैं ।

यह दृष्टिकोण सरल मामलों के लिए काम करता है, जैसे सक्रिय प्रोफाइल के आधार पर घटक पंजीकरण को सक्षम या अक्षम करना। लेकिन अगर आप कुछ सशर्त तर्क के आधार पर बीन घटकों को पंजीकृत करना चाहते हैं, तो प्रोफ़ाइल दृष्टिकोण ही पर्याप्त नहीं है।

bean- Spring, Spring 4 @Conditional. @Conditional, , .

, , :

• classpath
• Spring bean ApplicationContext
• /

, , .

, Spring's @Conditional.

, UserDAO . UserDAO, JdbcUserDAO, MySQL, MongoUserDAO, MongoDB.

JdbcUserDAO MongoUserDAO System Property, , dbType.

: java -jar myapp.jar -DdbType = MySQL, JdbcUserDAO. , : java -jar myapp.jar -DdbType = MONGO, MongoUserDAO.

JdbcUserDAO MongoUserDAO UserDAO :

public interface UserDAO
{
    List<String> getAllUserNames();
}
public class JdbcUserDAO implements UserDAO
{
    @Override
    public List<String> getAllUserNames()
    {
          System.out.println("**** Getting usernames from RDBMS *****");
          return Arrays.asList("Siva","Prasad","Reddy");
    }
}
public class MongoUserDAO implements UserDAO
{
    @Override
    public List<String> getAllUserNames()
    {
          System.out.println("**** Getting usernames from MongoDB *****");
          return Arrays.asList("Bond","James","Bond");
    }
}

Condition MySQLDatabaseTypeCondition, , System Property dbType «MYSQL» :

public class MySQLDatabaseTypeCondition implements Condition
{
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata metadata)
    {
        String enabledDBType = System.getProperty("dbType");
        return (enabledDBType != null && enabledDBType.equalsIgnoreCase("MYSQL"));
    }
}

Condition MongoDBDatabaseTypeCondition, , System Property dbType «MONGODB» :

public class MongoDBDatabaseTypeCondition implements Condition
{
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata metadata)
    {
        String enabledDBType = System.getProperty("dbType");
        return (enabledDBType != null && enabledDBType.equalsIgnoreCase("MONGODB"));
    }
}

bean- JdbcUserDAO MongoUserDAO, @Conditional :

@Configuration
public class AppConfig
{
    @Bean
    @Conditional(MySQLDatabaseTypeCondition.class)
    public UserDAO jdbcUserDAO(){
        return new JdbcUserDAO();
    }

    @Bean
    @Conditional(MongoDBDatabaseTypeCondition.class)
    public UserDAO mongoUserDAO(){
        return new MongoUserDAO();
    }
}

: java -jar myapp.jar -DdbType = MYSQL, bean- JdbcUserDAO.

System property: -DdbType = MONGODB, bean- MongoUserDAO.

, System Property.

, bean- MongoUserDAO , classpath Java MongoDB "com.mongodb.Server", , bean- JdbcUserDAO.

Condition MongoDB "com.mongodb.Server" :

public class MongoDriverPresentsCondition implements Condition
{
    @Override
    public boolean matches(ConditionContext conditionContext,AnnotatedTypeMetadata metadata)
    {
        try {
            Class.forName("com.mongodb.Server");
            return true;
        } catch (ClassNotFoundException e) {
            return false;
        }
    }
}

public class MongoDriverNotPresentsCondition implements Condition
{
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata metadata)
    {
        try {
            Class.forName("com.mongodb.Server");
            return false;
        } catch (ClassNotFoundException e) {
            return true;
        }
    }
}

, bean- classpath.

bean- MongoUserDAO, Spring- UserDAO .

Condition, , - bean- , :

public class UserDAOBeanNotPresentsCondition implements Condition
{
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata metadata)
    {
         UserDAO userDAO = conditionContext.getBeanFactory().getBean(UserDAO.class);
         return (userDAO == null);
    }
}

bean- MongoUserDAO, app.dbType = MONGO?

Condition :

public class MongoDbTypePropertyCondition implements Condition
{
    @Override
    public boolean matches(ConditionContext conditionContext,
    AnnotatedTypeMetadata metadata)
    {
        String dbType = conditionContext.getEnvironment()
                            .getProperty("app.dbType");
        return "MONGO".equalsIgnoreCase(dbType);
    }
}

Condition. Condition . Condition MYSQL MongoDB DatabaseType :

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Conditional(DatabaseTypeCondition.class)
public @interface DatabaseType
{
    String value();
}

DatabaseTypeCondition, DatabaseType :

public class DatabaseTypeCondition implements Condition
{
    @Override
    public boolean matches(ConditionContext conditionContext,
 AnnotatedTypeMetadata metadata)
    {
        Map<String, Object> attributes = metadata.getAnnotationAttributes(DatabaseType.class.getName());
        String type = (String) attributes.get("value");
        String enabledDBType = System.getProperty("dbType","MYSQL");
        return (enabledDBType != null && type != null && enabledDBType.equalsIgnoreCase(type));
    }
}

@DatabaseType :

@Configuration
@ComponentScan
public class AppConfig
{
    @Bean
    @DatabaseType("MYSQL")
    public UserDAO jdbcUserDAO(){
        return new JdbcUserDAO();
    }

    @Bean
    @DatabaseType("MONGO")
    public UserDAO mongoUserDAO(){
        return new MongoUserDAO();
    }
}

DatabaseType dbType , , .

, , , @Conditional.

Spring Boot @Conditional bean- .

Condition, SpringBoot org.springframework.boot.autoconfigure spring-boot-autoconfigure-{version}.jar.

Spring Boot @Conditional , .

?

, .

Spring Boot AutoConfiguration

Spring Boot — @EnableAutoConfiguration. , , @SpringBootApplication, , , :

@Configuration
@EnableAutoConfiguration
@ComponentScan
public class Application
{

}

@EnableAutoConfiguration Spring ApplicationContext , .

Spring Boot AutoConfiguration spring-boot-autoconfigure-{version}.jar, .

AutoConfiguration @Configuration, Spring, @EnableConfigurationProperties .

, org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration.

@Configuration
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
@EnableConfigurationProperties(DataSourceProperties.class)
@Import({ Registrar.class, DataSourcePoolMetadataProvidersConfiguration.class })
public class DataSourceAutoConfiguration 
{
    ...
    ...
    @Conditional(DataSourceAutoConfiguration.EmbeddedDataSourceCondition.class)
    @ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
    @Import(EmbeddedDataSourceConfiguration.class)
    protected static class EmbeddedConfiguration {

    }

    @Configuration
    @ConditionalOnMissingBean(DataSourceInitializer.class)
    protected static class DataSourceInitializerConfiguration {
        @Bean
        public DataSourceInitializer dataSourceInitializer() {
        return new DataSourceInitializer();
        }
    }

    @Conditional(DataSourceAutoConfiguration.NonEmbeddedDataSourceCondition.class)
    @ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
    protected static class NonEmbeddedConfiguration {
        @Autowired
        private DataSourceProperties properties;

        @Bean
        @ConfigurationProperties(prefix = DataSourceProperties.PREFIX)
        public DataSource dataSource() {
            DataSourceBuilder factory = DataSourceBuilder
                    .create(this.properties.getClassLoader())
                    .driverClassName(this.properties.getDriverClassName())
                    .url(this.properties.getUrl()).username(this.properties.getUsername())
                    .password(this.properties.getPassword());
            if (this.properties.getType() != null) {
                factory.type(this.properties.getType());
            }
            return factory.build();
        }
    }
    ...
    ...
    @Configuration
    @ConditionalOnProperty(prefix = "spring.datasource", name = "jmx-enabled")
    @ConditionalOnClass(name = "org.apache.tomcat.jdbc.pool.DataSourceProxy")
    @Conditional(DataSourceAutoConfiguration.DataSourceAvailableCondition.class)
    @ConditionalOnMissingBean(name = "dataSourceMBean")
    protected static class TomcatDataSourceJmxConfiguration {
        @Bean
        public Object dataSourceMBean(DataSource dataSource) {
        ....
        ....
        }
    }
    ...
    ...
}

DataSourceAutoConfiguration @ConditionalOnClass({DataSource.class,EmbeddedDatabaseType.class}), , bean- DataSourceAutoConfiguration , DataSource.class EmbeddedDatabaseType.class classpath.

@EnableConfigurationProperties(DataSourceProperties.class), application.properties DataSourceProperties.

@ConfigurationProperties(prefix = DataSourceProperties.PREFIX)
public class DataSourceProperties implements BeanClassLoaderAware, EnvironmentAware, InitializingBean {

    public static final String PREFIX = "spring.datasource";
    ...
    ...
    private String driverClassName;
    private String url;
    private String username;
    private String password;
    ...
    //setters and getters
}

, spring.datasource.*, DataSourceProperties.

spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=secret
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

bean-, SpringBoot, @ConditionalOnMissingBean, @ConditionalOnClass @ConditionalOnProperty ..

bean- ApplicationContext, .

spring-boot-autoconfigure-{version}.jar, :

• org.springframework.boot.autoconfigure.web.DispatcherServletAutoConfiguration
• org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration
• org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration
• org.springframework.boot.autoconfigure.jackson.JacksonAutoConfigurationetc, इत्यादि।

मुझे उम्मीद है कि अब आपको समझ में आ जाएगा कि कैसे स्प्रिंग बूट ऑटोकॉन्फिगरेशन @ ऑटोकैड्यूअल फीचर्स के साथ-साथ विभिन्न ऑटोकॉन्फिगरेशन वर्गों का उपयोग करके काम करता है ।