java基于mybatis的多数据源配置，手写版。坑太多了，看了源码才知道原因！！！！！帮大家避坑

雪花花️

已于 2022-07-04 14:15:07 修改

阅读量389

点赞数

分类专栏： java 文章标签： mybatis 数据库

于 2022-07-04 14:09:34 首次发布

本文链接：https://blog.csdn.net/limitaol/article/details/123831603

版权

java 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

拯救老项目！！！

1.首先，多数据源是肯定可以配置不同数据库的

2.上代码

sprinboot手写版，我用的两个库oracle和kingbase

用法：不加默认走ds

@TargetDataSource("admin")

具体实现层就是简单的mvc结构，不写了

3.核心代码，可直接使用

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.stereotype.Component;

/**
 * 切换数据源
 */
@Aspect
@Slf4j
@Component
public class DynamicDataSourceAspect {

    @Before("@annotation(targetDataSource)")
    public void changeDataSource(JoinPoint point, TargetDataSource targetDataSource) throws Throwable {
        String dsId = targetDataSource.value();
        if (!DynamicDataSourceContextHolder.containsDataSource(dsId)) {
            log.info("数据源(" + dsId + ")不存在-" + point.getSignature());
        } else {
            log.info("使用数据源(" + dsId + ")-" + point.getSignature());
            DynamicDataSourceContextHolder.setDataSourceType(targetDataSource.value());
        }
    }

  @After("@annotation(targetDataSource)")
    public void restoreDataSource(JoinPoint point, TargetDataSource targetDataSource) {
          log.info("恢复数据源-" + point.getSignature());
        DynamicDataSourceContextHolder.clearDataSourceType();
    }

}

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

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

/**
 * @version 1.0
 * @desc:
 * @author: lx
 * @date: 2022-07-02
 */
public class DynamicDataSourceContextHolder extends AbstractRoutingDataSource{
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();
    public static List<String> dataSourceIds = new ArrayList<>();

    public static void setDataSourceType(String dataSourceType) {
        contextHolder.set(dataSourceType);
    }

    public static String getDataSourceType() {
        return contextHolder.get();
    }

    public static void clearDataSourceType() {
        contextHolder.remove();
    }

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

    @Override
    protected Object determineCurrentLookupKey() {
        return getDataSourceType();
    }
}


import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.GenericBeanDefinition;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.bind.RelaxedDataBinder;
import org.springframework.boot.bind.RelaxedPropertyResolver;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.convert.ConversionService;
import org.springframework.core.convert.support.DefaultConversionService;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.stereotype.Component;

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

/**
 * 动态数据源注册
 *
 * @version 1.0
 * @desc:
 * @author: lx
 * @date: 2022-07-01
 */
/**
 *  动态数据源注册
 *  启动动态数据源请在启动类中 添加 @Import(DynamicDataSourceRegister.class)
 */
@Slf4j
@Component
public class DynamicDataSourceRegister
		implements ImportBeanDefinitionRegistrar, EnvironmentAware {

		private static final Logger logger = LoggerFactory.getLogger(DynamicDataSourceRegister.class);
		private ConversionService conversionService = new DefaultConversionService();
		private PropertyValues dataSourcePropertyValues;

		// 如配置文件中未指定数据源类型，使用该默认值
		private static final Object DATASOURCE_TYPE_DEFAULT = "com.alibaba.druid.pool.DruidDataSource";

		// 数据源
		private DataSource defaultDataSource;
		private Map<String, DataSource> customDataSources = new HashMap<>();

		private static String DB_NAME = "names";
		private static String DB_DEFAULT_VALUE = "jdbc"; //配置文件中前缀
		private String defaultDbname = JDBCEnum.DEFAULTDATASOURCE;

		//加载多数据源配置
		@Override
		public void setEnvironment(Environment env) {
			initDefaultDataSource(env);
			initCustomDataSources(env);
		}

		//初始化主数据源
		private void initDefaultDataSource(Environment env) {
			// 读取主数据源
			RelaxedPropertyResolver propertyResolver = new RelaxedPropertyResolver(env, DB_DEFAULT_VALUE+"."+JDBCEnum.DEFAULTDATASOURCE+".");
			Map<String, Object> dsMap = new HashMap<>();
			dsMap.put("type", propertyResolver.getProperty("type"));
			dsMap.put("driverClassName", propertyResolver.getProperty("driverClassName"));
			dsMap.put("url", propertyResolver.getProperty("url"));
			dsMap.put("username", propertyResolver.getProperty("username"));
			dsMap.put("password", propertyResolver.getProperty("password"));

			defaultDataSource = buildDataSource(dsMap);
			customDataSources.put(defaultDbname,defaultDataSource);//默认数据源放到动态数据源里
			dataBinder(defaultDataSource, env);
		}


		//为DataSource绑定更多数据
		private void dataBinder(DataSource dataSource, Environment env) {
			RelaxedDataBinder dataBinder = new RelaxedDataBinder(dataSource);
			//dataBinder.setValidator(new LocalValidatorFactory().run(this.applicationContext));
			dataBinder.setConversionService(conversionService);
			dataBinder.setIgnoreNestedProperties(false);//false
			dataBinder.setIgnoreInvalidFields(false);//false
			dataBinder.setIgnoreUnknownFields(true);//true
			if (dataSourcePropertyValues == null) {
				Map<String, Object> rpr = new RelaxedPropertyResolver(env, DB_DEFAULT_VALUE+"."+JDBCEnum.DEFAULTDATASOURCE).getSubProperties(".");
				Map<String, Object> values = new HashMap<String, Object>(rpr);
				// 排除已经设置的属性
				values.remove("type");
				values.remove("driverClassName");
				values.remove("url");
				values.remove("username");
				values.remove("password");
				dataSourcePropertyValues = new MutablePropertyValues(values);
			}
			dataBinder.bind(dataSourcePropertyValues);
		}

		//初始化更多数据源
		private void initCustomDataSources(Environment env) {
			// 读取配置文件获取更多数据源，也可以通过defaultDataSource读取数据库获取更多数据源
			RelaxedPropertyResolver propertyResolver = new RelaxedPropertyResolver(env,DB_DEFAULT_VALUE+".");
			String dsPrefixs = propertyResolver.getProperty(DB_NAME);
			for (String dsPrefix : dsPrefixs.split(",")) {// 多个数据源
				Map<String, Object> dsMap = propertyResolver.getSubProperties(dsPrefix + ".");
				DataSource ds = buildDataSource(dsMap);
				customDataSources.put(dsPrefix, ds);
				dataBinder(ds, env);
			}
		}

		@Override
		public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
			Map<Object, Object> targetDataSources = new HashMap<Object, Object>();
			// 将主数据源添加到更多数据源中
			targetDataSources.put("dataSource", defaultDataSource);
			DynamicDataSourceContextHolder.dataSourceIds.add("dataSource");
			// 添加更多数据源
			targetDataSources.putAll(customDataSources);
			for (String key : customDataSources.keySet()) {
				DynamicDataSourceContextHolder.dataSourceIds.add(key);
			}

			// 创建DynamicDataSource
			GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
			beanDefinition.setBeanClass(DynamicDataSourceContextHolder.class);
			beanDefinition.setSynthetic(true);
			MutablePropertyValues mpv = beanDefinition.getPropertyValues();
			mpv.addPropertyValue("defaultTargetDataSource", defaultDataSource);
			mpv.addPropertyValue("targetDataSources", targetDataSources);
			registry.registerBeanDefinition("dataSource", beanDefinition);

			logger.info("Dynamic DataSource Registry");
		}

		//创建DataSource
		@SuppressWarnings("unchecked")
		public DataSource buildDataSource(Map<String, Object> dsMap) {
			try {
				Object type = dsMap.get("type");
				if (type == null)
					type = DATASOURCE_TYPE_DEFAULT;// 默认DataSource

				Class<? extends DataSource> dataSourceType;
				dataSourceType = (Class<? extends DataSource>) Class.forName((String) type);

				String driverClassName = dsMap.get("driverClassName").toString();
				String url = dsMap.get("url").toString();
				String username = dsMap.get("username").toString();
				String password = dsMap.get("password").toString();

				DataSourceBuilder factory = DataSourceBuilder.create().driverClassName(driverClassName).url(url)
						.username(username).password(password).type(dataSourceType);
				return factory.build();
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			}
			return null;
		}
	}

import org.springframework.context.annotation.Import;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author li
 */
@Target({java.lang.annotation.ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Import({DynamicDataSourceRegister.class})
public @interface EnableDynamicDataSource {
}

public enum JDBCEnum {
    OTHERTDATASOURCEADMIN("admin"),
    DEFAULTDATASOURCEDIRECTORY("directory");

    private String name;
    public static   final String DEFAULTDATASOURCE = "ds";
    public String getName() {
        return name;
    }

    JDBCEnum(String admin) {
        this.name = admin;
    }
}


import java.lang.annotation.*;

/**
 *  @author: lx
 * 在方法上使用，用于指定使用哪个数据源
 */
@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TargetDataSource {
    String value() default JDBCEnum.DEFAULTDATASOURCE;
}

4.相关配置

DemoApplication!!!这块配置很重要

import com.lx.demo.common.ds.EnableDynamicDataSource;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * @author lx
 */
@MapperScan("com.lx.demo.mapper")
@EnableAspectJAutoProxy(proxyTargetClass = true)
//多数据源增加
@EnableDynamicDataSource
//禁止默认spring 数据源
@SpringBootApplication(exclude = {
        DataSourceAutoConfiguration.class
})
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.lx</groupId>
    <artifactId>demo1</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.7.RELEASE</version>
        <relativePath/>
    </parent>
    <dependencies>
        <!-- druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.16</version>
        </dependency>
        <!-- mybatis配置 -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--   war-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.16</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
        </dependency>
        <!-- ORACLE -->
        <dependency>
            <groupId>com.oracle</groupId>
            <artifactId>ojdbc6</artifactId>
            <version>11.2.0.3</version>
        </dependency>
        <dependency>
            <groupId>com.kingbase8</groupId>
            <artifactId>kingbase8</artifactId>
            <version>8.6.0</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

2.application.properties

server.port=8080

#配置多数据源必须在这里增加数据源
jdbc.defaultname=ds
jdbc.names=admin
#默认数据源名称务必不要修改
jdbc.ds.type=com.alibaba.druid.pool.DruidDataSource
jdbc.ds.driverClassName=com.kingbase8.Driver
jdbc.ds.url=jdbc:kingbase8://ip:54321/XYWZ
jdbc.ds.username=xx
jdbc.ds.password=xx
jdbc.ds.initialSize=5
jdbc.ds.minIdle=10
jdbc.ds.maxActive=100
jdbc.ds.validationQuery=SELECT 1 FROM DUAL
jdbc.ds.maxWait=60000
jdbc.ds.poolPreparedStatements=true
jdbc.ds.filters=stat,log4j


jdbc.admin.type=com.alibaba.druid.pool.DruidDataSource
jdbc.admin.driverClassName=oracle.jdbc.OracleDriver
jdbc.admin.url=jdbc:oracle:thin:@ip:1521/orcl
jdbc.admin.username=xx
jdbc.admin.password=xx
jdbc.admin.initialSize=5
jdbc.admin.minIdle=10
jdbc.admin.maxActive=100
jdbc.admin.validationQuery=SELECT 1 FROM DUAL
jdbc.admin.maxWait=60000
jdbc.admin.poolPreparedStatements=true
jdbc.admin.filters=stat,log4j
logging.level.com.baomidou=debug
#mybatis
mybatis.mapper-locations=classpath:mapper/*.xml
mybatis.typeAliasesPackage=com.lx.model