Springboot通过自定义注解的方式实现mysql多数据源

介绍

在项目开发的过程中经常会使用数据库的主从架构，主库读写从库只读。一些查询接口往往只需要查询从库就可以从而可以降低主库的压力，这个时候我们就需要根据不同的接口使用不同的数据源。本文的主要内容就是通过自定义注解的方式实现类，方法等多级结构切换数据源。从而做到接口读写分离。

自定义注解

package com.dynamicDataSource.dynamicDataSource.annotations;

import java.lang.annotation.*;

/**
 * @Description: 切换数据源注解 可以用于类或者方法级别 方法级别优先级 > 类级别  注意:请不要再事务内使用此注解，会导致切换不生效
 */
@Target({ElementType.METHOD,ElementType.TYPE,ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataSource{
    //默认主数据源
    String value() default "master";
}

定义切面

1.类切面定义 ，支持注解加到类上；

package com.dynamicDataSource.dynamicDataSource.aspects;

import com.dynamicDataSource.dynamicDataSource.annotations.DataSource;
import com.dynamicDataSource.dynamicDataSource.dynamic.DynamicDataSourceContextHolder;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * @Description: 类上使用注解处理
 */
@Slf4j
@Aspect
@Order(1)
@Component
public class DynamicDataSourceAspect {

    @Pointcut("@within(com.dynamicDataSource.dynamicDataSource.annotations.DataSource)")
    public void pointCut() {
    }

    /**
     * 类切面
     *
     * @param point
     */
    @Before("pointCut()")
    public void changeDataSource(JoinPoint point) {
        DataSource datasource = (DataSource) point.getSignature().getDeclaringType().getAnnotation(DataSource.class);
        String dsId = "master";
        if (null != datasource.value()) {
            dsId = datasource.value();
        }
        if (DynamicDataSourceContextHolder.containsDataSource(dsId)) {
//            log.info("使用数据源-- {} *** {}", dsId, point.getSignature());
            DynamicDataSourceContextHolder.setDataSourceRouterKey(dsId);
        } else {
            log.info("数据源[{}]不存在，使用默认数据源 > {}", dsId, point.getSignature());
            DynamicDataSourceContextHolder.setDataSourceRouterKey("master");
        }
    }

    @After("pointCut()")
    public void restoreDataSource() {
        DynamicDataSourceContextHolder.removeDataSourceRouterKey();
    }

}

2.方法切面定义 ，支持注解加到方法上；

package com.dynamicDataSource.dynamicDataSource.aspects;

import com.dynamicDataSource.dynamicDataSource.annotations.DataSource;
import com.dynamicDataSource.dynamicDataSource.dynamic.DynamicDataSourceContextHolder;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * @Description: 方法上使用注解处理
 */
@Slf4j
@Aspect
@Order(2)
@Component
public class DynamicDataSourceAspectMethod {

    /**
     * 方法切面
     *
     * @param point
     */
    @Before("@annotation(ds)")
    public void changeDataSource(JoinPoint point, DataSource ds) throws Throwable {
        String dsId = ds.value();
        if (DynamicDataSourceContextHolder.dataSourceIds.contains(dsId)) {
            if (!dsId.equals(DynamicDataSourceContextHolder.getDataSourceRouterKey())) {
                DynamicDataSourceContextHolder.setDataSourceRouterKey(dsId);
            }
//            log.debug("Use DataSource :{} >", dsId, point.getSignature());
        } else {
            log.info("数据源[{}]不存在，使用默认数据源 >{}", dsId, point.getSignature());
            DynamicDataSourceContextHolder.setDataSourceRouterKey(dsId);
        }
    }

    @After("@annotation(ds)")
    public void restoreDataSource(DataSource ds) {
        DynamicDataSourceContextHolder.removeDataSourceRouterKey();
    }
}

需要注意使用 @Order(2) 注解来调整切面的优先级，里面数值越大优先级越高 上见面配置就是方法上指定的数据源优先于类上指定的数据源

动态注册数据源

package com.dynamicDataSource.dynamicDataSource.dynamic;

import com.dynamicDataSource.dynamicDataSource.enums.DataSourceEnum;
import com.zaxxer.hikari.HikariDataSource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.GenericBeanDefinition;
import org.springframework.boot.context.properties.bind.Bindable;
import org.springframework.boot.context.properties.bind.Binder;
import org.springframework.boot.context.properties.source.ConfigurationPropertyName;
import org.springframework.boot.context.properties.source.ConfigurationPropertyNameAliases;
import org.springframework.boot.context.properties.source.ConfigurationPropertySource;
import org.springframework.boot.context.properties.source.MapConfigurationPropertySource;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.util.StringUtils;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @Description: 动态注册数据源
 */
@Slf4j
public class DynamicDataSourceRegister implements ImportBeanDefinitionRegistrar, EnvironmentAware {

    /**
     * 配置上下文 获取配置文件
     */
    private Environment evn;

    private final static ConfigurationPropertyNameAliases aliases = new ConfigurationPropertyNameAliases();

    /**
     * 由于部分数据源配置不同，所以在此处添加别名，避免切换数据源出现某些参数无法注入的情况
     */
    static {
        aliases.addAliases("url", new String[]{"url"});
        aliases.addAliases("username", new String[]{"username"});
    }

    /**
     * 存储注册的数据源
     */
    private Map<String, DataSource> dataSourceMap = new HashMap<>();

    /**
     * 参数绑定工具
     */
    private Binder binder;


    @Override
    public void setEnvironment(Environment environment) {
        log.info("开始注册数据源");
        this.evn = environment;
        //绑定配置器
        binder = Binder.get(evn);
    }

    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
        //获取所有的数据源
        Map config, defaultDataSourceProperties;
        defaultDataSourceProperties = binder.bind("spring.datasource.master", Map.class).get();
        //获取数据源类型
        String type = evn.getProperty("spring.datasource.master.type");
        Class<? extends DataSource> clazz = getDataSourceType(type);
        //绑定默认数据源参数 也就是主数据源
        DataSource dataSource, defaultDataSource = bind(clazz, defaultDataSourceProperties);
        DynamicDataSourceContextHolder.dataSourceIds.add(DataSourceEnum.MASTER.getDataSource());
        log.info("注册默认的数据源成功!");

        //获取其它数据源
        if (binder.bind("spring.datasource.cluster", Bindable.listOf(Map.class)).isBound()) {
            List<Map> configs = binder.bind("spring.datasource.cluster", Bindable.listOf(Map.class)).get();
            for (int i = 0; i < configs.size(); i++) {
                config = configs.get(i);
                clazz = getDataSourceType((String) config.get("type"));
                defaultDataSourceProperties = config;
                //绑定参数
                dataSource = bind(clazz, defaultDataSourceProperties);
                //获取数据源的key,判断是哪个数据源
                String key = (String) config.get("key");
                dataSourceMap.put(key, dataSource);
                //数据源上下文，用于管理数据源与记录已经注册的数据源的key
                DynamicDataSourceContextHolder.dataSourceIds.add(key);
                log.info("注册 {} 数据源成功!", key);
            }
        }

        GenericBeanDefinition define = new GenericBeanDefinition();
        // 设置bean的类型，此处DynamicRoutingDataSource是继承AbstractRoutingDataSource的实现类
        define.setBeanClass(DynamicRoutingDataSource.class);
        // 需要注入的参数
        MutablePropertyValues mpv = define.getPropertyValues();
        // 添加默认数据源
        mpv.add("defaultTargetDataSource", defaultDataSource);
        // 添加其他数据源
        mpv.add("targetDataSources", dataSourceMap);
        // 将该bean注册为datasource，不使用springboot自动生成的datasource
        beanDefinitionRegistry.registerBeanDefinition("datasource", define);
        log.info("注册数据源成功，一共注册{}个数据源", dataSourceMap.keySet().size() + 1);
    }

    /**
     * 通过字符串获取数据源class对象
     *
     * @param typeStr
     * @return
     */
    private Class<? extends DataSource> getDataSourceType(String typeStr) {
        Class<? extends DataSource> type;
        try {
            if (StringUtils.hasLength(typeStr)) {
                // 字符串不为空则通过反射获取class对象
                type = (Class<? extends DataSource>) Class.forName(typeStr);
            } else {
                // 默认为hikariCP数据源，与springboot默认数据源保持一致
                type = HikariDataSource.class;
            }
            return type;
        } catch (Exception e) {
            //无法通过反射获取class对象的情况则抛出异常，该情况一般是写错了，所以此次抛出一个runtimeexception
            throw new IllegalArgumentException("can not resolve class with type: " + typeStr);
        }
    }

    /**
     * 绑定参数，以下三个方法都是参考DataSourceBuilder的bind方法实现的，目的是尽量保证我们自己添加的数据源构造过程与springboot保持一致
     *
     * @param result
     * @param properties
     */
    private void bind(DataSource result, Map properties) {
        ConfigurationPropertySource source = new MapConfigurationPropertySource(properties);
        Binder binder = new Binder(new ConfigurationPropertySource[]{source.withAliases(aliases)});
        // 将参数绑定到对象
        binder.bind(ConfigurationPropertyName.EMPTY, Bindable.ofInstance(result));
    }

    private <T extends DataSource> T bind(Class<T> clazz, Map properties) {
        ConfigurationPropertySource source = new MapConfigurationPropertySource(properties);
        Binder binder = new Binder(new ConfigurationPropertySource[]{source.withAliases(aliases)});
        // 通过类型绑定参数并获得实例对象
        return binder.bind(ConfigurationPropertyName.EMPTY, Bindable.of(clazz)).get();
    }

    /**
     * @param clazz
     * @param sourcePath 参数路径，对应配置文件中的值，如: spring.datasource
     * @param 
     * @return
     */
    private <T extends DataSource> T bind(Class<T> clazz, String sourcePath) {
        Map properties = binder.bind(sourcePath, Map.class).get();
        return bind(clazz, properties);
    }
}

通过对去配置文件里配置的数据库信息，实现多数据源的注册

获取数据源上下文

package com.dynamicDataSource.dynamicDataSource.dynamic;

import lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;
import java.util.List;

/**
 * @Description: 数据源上下文
 */
@Slf4j
public class DynamicDataSourceContextHolder {

    /**
     * 存储已经注册的数据源key
     */
    public static List<String> dataSourceIds = new ArrayList<>();

    /**
     * 线程内私有变量
     */
    private static final ThreadLocal<String> HOLDER = new ThreadLocal<>();

    public static String getDataSourceRouterKey(){
        return HOLDER.get();
    }

    public static void setDataSourceRouterKey (String dataSourceRouterKey) {
        HOLDER.set(dataSourceRouterKey);
//        log.info("切换至 {} 数据源", dataSourceRouterKey);
    }

    /**
     * 设置数据源之前一定要先移除
     */
    public static void removeDataSourceRouterKey () {
        HOLDER.remove();
    }

    /**
     * 判断指定DataSrouce当前是否存在
     *
     * @param dataSourceId
     * @return
     */
    public static boolean containsDataSource(String dataSourceId){
        return dataSourceIds.contains(dataSourceId);
    }
}

通过此类修改当前线程的数据源，从而实现多数据源动态切换；

动态数据源路由

package com.dynamicDataSource.dynamicDataSource.dynamic;

import com.dynamicDataSource.dynamicDataSource.enums.DataSourceEnum;
import lombok.extern.slf4j.Slf4j;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

/**
 * @Description: 动态数据源路由
 */
@Slf4j
public class DynamicRoutingDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        String dataSourceName = DynamicDataSourceContextHolder.getDataSourceRouterKey();
        if (dataSourceName == null) {
            dataSourceName = DataSourceEnum.MASTER.getDataSource();
        }
        log.info("当前数据源是: {}", dataSourceName);
        return dataSourceName;
    }
}

读取当前数据源，可以设置默认数据源;

启动类修改

项目启动类通过@Import注解引入DynamicDataSourceRegister类，让项目启动时执行扫描多数据源的逻辑

@Import(DynamicDataSourceRegister.class)

注解使用

package com.dynamicDataSource.dynamicDataSource.service.impl;

import com.dynamicDataSource.dynamicDataSource.annotations.DataSource;
import com.dynamicDataSource.dynamicDataSource.dao.SysUserDao;
import com.dynamicDataSource.dynamicDataSource.entity.SysUserDO;
import com.dynamicDataSource.dynamicDataSource.service.DemoService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Description:
 */
@Service
@Slf4j
@DataSource("slave1")//类级别注解 加上此注解当前类的所有方法都会走指定的slave1数据源
public class DemoServiceImpl implements DemoService {

    @Autowired
    private SysUserDao sysUserDao;

    @Override
    public List<SysUserDO> getSysUserList() {
        log.info("-> 获取用户列表");
        return sysUserDao.select(SysUserDO.builder()
                .removeFlag(Boolean.FALSE)
                .build());
    }

    @Override
    @DataSource()//方法级别注解 加上此注解当前方法优先于类上指定的数据源slave1,执行master数据源,等同于@DataSource("master")
    public List<SysUserDO> getSysUserList1() {
        log.info("-> 获取用户列表1");
        return sysUserDao.select(SysUserDO.builder()
                .removeFlag(Boolean.FALSE)
                .build());
    }
}

结束

注意： 以上方式实现的说数据源方式不支持事务，且不支持多线程
代码地址
https://github.com
https://gitee.com

以上仅个人观点，如有错误，还望指正。