Spring Boot集成Mybatis双数据源

这里用到了Spring Boot + Mybatis + DynamicDataSource配置动态双数据源，可以动态切换数据源实现数据库的读写分离。

添加依赖

加入Mybatis启动器，这里添加了Druid连接池、Oracle数据库驱动为例。

<dependency>

    <groupId>org.mybatis.spring.boot</groupId>

    <artifactId>mybatis-spring-boot-starter</artifactId>

</dependency>

<dependency>

    <groupId>com.alibaba</groupId>

    <artifactId>druid</artifactId>

</dependency>

<dependency>

    <groupId>com.oracle</groupId>

    <artifactId>ojdbc6</artifactId>

</dependency>

添加启动类

@EnableMybatis

@EnableTransactionManagement

@SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })

public class Application {

    public static void main(String[] args) {

        SpringApplication.run(ServiceApplication.class, args);

    }

}

@SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })：

这里用到了双数据源，需要排除数据源的自动配置，如果只有一个数据源用Spring Boot的自动配置就行。

@EnableTransactionManagement：开启事务支持。

@EnableMybatis：开启Mybatis功能

@Target(ElementType.TYPE)

@Retention(RetentionPolicy.RUNTIME)

@Documented

@Import(MybatisConfig.class)

public @interface EnableMybatis {

}

Mybatis配置类

@Configuration

@MapperScan(basePackages = DSConfig.BASE_PACKAGES)

public class MybatisConfig implements DSConfig {

    @Primary

    @Bean

    public DynamicDataSource dynamicDataSource(@Qualifier(DB_MASTER) DataSource master,

            @Qualifier(DB_SLAVE) DataSource slave) {

        Map<Object, Object> dsMap = new HashMap<>();

        dsMap.put(DB_MASTER, master);

        dsMap.put(DB_MASTER, slave);

        DynamicDataSource dynamicDataSource = new DynamicDataSource();

        dynamicDataSource.setDefaultTargetDataSource(master);

        dynamicDataSource.setTargetDataSources(dsMap);

        return dynamicDataSource;

    }

    @Bean

    public PlatformTransactionManager transactionManager(DynamicDataSource dynamicDataSource) {

        return new DataSourceTransactionManager(dynamicDataSource);

    }

    @Bean

    public SqlSessionFactory sqlSessionFactory(DynamicDataSource dynamicDataSource)

            throws Exception {

        SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();

        sessionFactory.setDataSource(dynamicDataSource);

        sessionFactory.setMapperLocations(

                ((ResourcePatternResolver) new PathMatchingResourcePatternResolver())

                        .getResources(DSConfig.MAPPER_LOCATIONS));

        return sessionFactory.getObject();

    }

}

DSConfig常量类：

public interface DSConfig {

    String DS_PREFIX = "spring.datasource";

    String DS_ACTIVE = "active";

    String DB_MASTER = "db-master";

    String DB_SLAVE = "db-slave";

    String DRUID = "druid";

    String DRUID_MONITOR_USERNAME = "spring.druid.username";

    String DRUID_MONITOR_PASSWORD = "spring.druid.password";

    String DRUID_MONITOR_URL = "/druid/*";

    String DRUID_FILTER_EXCLUSIONS = "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*";

    String DRUID_FILTER_URL = "/*";

    String BASE_PACKAGES = "com.example.**.mapper";

    String MAPPER_LOCATIONS = "mapper/**/*.xml";

}

连接池配置类

Druid连接池的自动配置类：

@Configuration

@Import({ PropertiesConfig.class })

@ConditionalOnClass(DruidDataSource.class)

@ConditionalOnProperty(prefix = DSConfig.DS_PREFIX, value = DSConfig.DS_ACTIVE, havingValue = DSConfig.DRUID)

public class DruidAutoConfig implements DSConfig {

    private Logger logger = LoggerUtils.getLogger(this);

    @Bean(name = DB_MASTER, initMethod = "init", destroyMethod = "close")

    public DataSource dataSourceMaster(DruidMasterProperties masterProperties) throws SQLException {

        logger.debug("master properties: {}", masterProperties.toString());

        DruidDataSource dds = new DruidDataSource();

        dds.setDriverClassName(masterProperties.getDriverClassName());

        dds.setUrl(masterProperties.getUrl());

        dds.setUsername(masterProperties.getUsername());

        dds.setPassword(masterProperties.getPassword());

        dds.setInitialSize(masterProperties.getInitialSize());

        dds.setMinIdle(masterProperties.getMinIdle());

        dds.setMaxActive(masterProperties.getMaxActive());

        dds.setMaxWait(masterProperties.getMaxWait());

        dds.setTimeBetweenEvictionRunsMillis(masterProperties.getTimeBetweenEvictionRunsMillis());

        dds.setMinEvictableIdleTimeMillis(masterProperties.getMinEvictableIdleTimeMillis());

        dds.setValidationQuery(masterProperties.getValidationQuery());

        dds.setTestOnBorrow(masterProperties.isTestOnBorrow());

        dds.setTestWhileIdle(masterProperties.isTestWhileIdle());

        dds.setTestOnReturn(masterProperties.isTestOnReturn());

        dds.setPoolPreparedStatements(masterProperties.isPoolPreparedStatements());

        dds.setMaxPoolPreparedStatementPerConnectionSize(

                masterProperties.getMaxPoolPreparedStatementPerConnectionSize());

        dds.setFilters(masterProperties.getFilters());

        return dds;

    }

    @Bean(name = DB_SLAVE, initMethod = "init", destroyMethod = "close")

    public DataSource dataSourceSlave(DruidSlaveProperties slaveProperties) throws SQLException {

        logger.debug("slave properties: {}", slaveProperties.toString());

        DruidDataSource dds = new DruidDataSource();

        dds.setDriverClassName(slaveProperties.getDriverClassName());

        dds.setUrl(slaveProperties.getUrl());

        dds.setUsername(slaveProperties.getUsername());

        dds.setPassword(slaveProperties.getPassword());

        dds.setInitialSize(slaveProperties.getInitialSize());

        dds.setMinIdle(slaveProperties.getMinIdle());

        dds.setMaxActive(slaveProperties.getMaxActive());

        dds.setMaxWait(slaveProperties.getMaxWait());

        dds.setTimeBetweenEvictionRunsMillis(slaveProperties.getTimeBetweenEvictionRunsMillis());

        dds.setMinEvictableIdleTimeMillis(slaveProperties.getMinEvictableIdleTimeMillis());

        dds.setValidationQuery(slaveProperties.getValidationQuery());

        dds.setTestOnBorrow(slaveProperties.isTestOnBorrow());

        dds.setTestWhileIdle(slaveProperties.isTestWhileIdle());

        dds.setTestOnReturn(slaveProperties.isTestOnReturn());

        dds.setPoolPreparedStatements(slaveProperties.isPoolPreparedStatements());

        dds.setMaxPoolPreparedStatementPerConnectionSize(

                slaveProperties.getMaxPoolPreparedStatementPerConnectionSize());

        dds.setFilters(slaveProperties.getFilters());

        return dds;

    }

    @Bean

    public ServletRegistrationBean druidServletRegistrationBean(EnvConfig env) {

        String username = env.getStringValue(DSConfig.DRUID_MONITOR_USERNAME);

        String password = env.getStringValue(DSConfig.DRUID_MONITOR_PASSWORD);

        return new ServletRegistrationBean(new DruidStatViewServlet(username, password),

                DSConfig.DRUID_MONITOR_URL);

    }

    @Bean

    public FilterRegistrationBean druidFilterRegistrationBean() {

        WebStatFilter wsf = new WebStatFilter();

        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();

        filterRegistrationBean.setFilter(wsf);

        filterRegistrationBean.setUrlPatterns(Arrays.asList(DSConfig.DRUID_FILTER_URL));

        filterRegistrationBean.setInitParameters(

                Collections.singletonMap("exclusions", DSConfig.DRUID_FILTER_EXCLUSIONS));

        return filterRegistrationBean;

    }

}

根据类路径下有DruidDataSource这个类即有Druid这个jar包和配置文件中spring.datasource.active=druid才开启对Druid连接池的自动配置。

导入的配置文件：

@Configuration

@ComponentScan(basePackages = "com.example.common.config.properties")

public class PropertiesConfig {

}

DruidMasterProperties、DruidSlaveProperties属性文件读取的配置省略。

连接池监控配置类：

public class DruidStatViewServlet extends StatViewServlet {

    private static final long serialVersionUID = 1L;

    private String username;

    private String password;

    @Override

    public String getInitParameter(String name) {

        if ("loginUsername".equals(name)) {

            return username;

        }

        if ("loginPassword".equals(name)) {

            return password;

        }

        return super.getInitParameter(name);

    }

    public DruidStatViewServlet(String username, String password) {

        super();

        this.username = username;

        this.password = password;

    }

    public String getUsername() {

        return username;

    }

    public String getPassword() {

        return password;

    }

}

在META-INF/spring.factories中加入Druid自动配置映射：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\

com.example.common.config.ds.DruidAutoConfig

切换数据源

切换数据源注解：

@Target(ElementType.METHOD)

@Retention(RetentionPolicy.RUNTIME)

@Documented

public @interface DS {

    String value() default DSConfig.DB_MASTER;

}

动态数据源类：

public class DynamicDataSource extends AbstractRoutingDataSource {

    private final Logger logger = LoggerUtils.getLogger(this);

    @Override

    protected Object determineCurrentLookupKey() {

        logger.debug("当前数据源为{}", DataSourceContextHolder.getDS());

        return DataSourceContextHolder.getDS();

    }

}

动态数据源AOP实现类：

@Aspect

@Component

public class DynamicDataSourceAspect {

    @Before("@annotation(DS)")

    public void beforeSwitchDS(JoinPoint point) {

        Class<?> className = point.getTarget().getClass();

        String methodName = point.getSignature().getName();

        Class<?>[] argClass = ((MethodSignature) point.getSignature()).getParameterTypes();

        String dataSource = DataSourceContextHolder.DEFAULT_DS;

        try {

            Method method = className.getMethod(methodName, argClass);

            if (method.isAnnotationPresent(DS.class)) {

                DS annotation = method.getAnnotation(DS.class);

                dataSource = annotation.value();

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

        DataSourceContextHolder.setDS(dataSource);

    }

    @After("@annotation(DS)")

    public void afterSwitchDS(JoinPoint point) {

        DataSourceContextHolder.clearDS();

    }

}

绑定当前线程数据源类：

public class DataSourceContextHolder {

    public static final String DEFAULT_DS = DSConfig.DB_MASTER;

    private static final ThreadLocal<String> DS_HOLDER = new ThreadLocal<>();

    public static void setDS(String dbType) {

        DS_HOLDER.set(dbType);

    }

    public static String getDS() {

        return (DS_HOLDER.get());

    }

    public static void clearDS() {

        DS_HOLDER.remove();

    }

}