How does the RuoYi framework implement Bean dependency injection without explicitly writing DataSource implementation class?

RuoYi framework clever Bean dependency injection: no explicit DataSource implementation class required

The RuoYi framework is known for its concise code and efficient development experience. However, beginners may be confused about how it implements Bean dependency injection without explicitly writing the DataSource implementation class. This article will clarify the mechanism behind the RuoYi framework by analyzing the code.

Many developers often encounter errors of "cannot automatically assemble, cannot find a bean of 'datasource' type" when imitating the RuoYi framework's com.ruoyi.framework.config.MybatisConfig . This is because they try to inject DataSource objects directly, and the RuoYi framework does not directly define the implementation class of DataSource.

The core of RuoYi framework is to cleverly utilize the dependency injection mechanism and @Configuration annotation of the Spring framework. It does not omit the definition of DataSource, but delegates the creation and configuration of DataSource to the configuration class DruidConfig.java .

Let's dive into the key code of DruidConfig.java :

 /**
 * Druid Multi-Data Source Configuration*
 * @author ruoyi
 */
@Configuration
public class DruidConfig {
    @Bean
    @ConfigurationProperties("spring.datasource.druid.master")
    public DataSource masterDataSource(DruidProperties druidProperties) {
        DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
        return druidProperties.dataSource(dataSource);
    }

    @Bean
    @ConfigurationProperties("spring.datasource.druid.slave")
    @ConditionalOnProperty(prefix = "spring.datasource.druid.slave", name = "enabled", havingValue = "true")
    public DataSource slaveDataSource(DruidProperties druidProperties) {
        DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
        return druidProperties.dataSource(dataSource);
    }

    @Bean(name = "dynamicDataSource")
    @Primary
    public DynamicDataSource dataSource(DataSource masterDataSource) {
        Map<object object> targetDataSources = new HashMap();
        targetDataSources.put(DataSourceType.MASTER.name(), masterDataSource);
        setDataSource(targetDataSources, DataSourceType.SLAVE.name(), "slaveDataSource");
        return new DynamicDataSource(masterDataSource, targetDataSources);
    }
    // ...
}</object>

The @Configuration annotation marks DruidConfig as a Spring configuration class. The @Bean annotation indicates that the method will create a bean and register it into the Spring container. masterDataSource and slaveDataSource methods create the master data source and slave data source beans respectively, and read the configuration information from the configuration file through the @ConfigurationProperties annotation. @ConditionalOnProperty annotation ensures that the Bean from the data source is created only when enabled in the configuration file. Finally, dataSource method integrates the master and slave data source to create a dynamic data source bean.

When DataSource type bean needs to be injected, the Spring container will automatically find and inject the registered masterDataSource or dynamicDataSource Bean. Therefore, the RuoYi framework does not have the implementation of DataSource , but hides the creation and configuration of DataSource in DruidConfig class through Spring's dependency injection mechanism and configuration classes, thereby keeping the code concise. Developers only need to declare that they need to inject a Bean of DataSource type, and the Spring container will automatically complete the dependency injection.

The above is the detailed content of How does the RuoYi framework implement Bean dependency injection without explicitly writing DataSource implementation class?. For more information, please follow other related articles on the PHP Chinese website!