<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>${spring-boot.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql-connector-java.version}</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>${mybatis.version}</version>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>${mybatis-spring-boot-starter.version}</version>
</dependency>
</dependencies>
</dependencyManagement>

public static final String MAPPER_LOCATION =
"classpath:usermapper/*.xml";

@Primary
@Bean("userDataSource")
@ConfigurationProperties(prefix = "spring.datasource.user")
public DataSource userDataSource() {
return DataSourceBuilder.create().build();
}

@Bean(name = "userTransactionManager")
@Primary
public PlatformTransactionManager userTransactionManager
(@Qualifier("userDataSource") DataSource dataSource) {
return new DataSourceTransactionManager(dataSource);
}

@Primary
@Bean(name = "userSqlSessionFactory")
public SqlSessionFactory userSqlSessionFactory(@Qualifier
("userDataSource") DataSource dataSource) throws Exception {
final SqlSessionFactoryBean sessionFactoryBean
= new SqlSessionFactoryBean();
sessionFactoryBean.setDataSource(dataSource);
sessionFactoryBean.setMapperLocations(new PathMatching
ResourcePatternResolver().getResources
(UserDataSourceConfiguration.MAPPER_LOCATION));
return sessionFactoryBean.getObject();
}

}
@Configuration
@MapperScan(basePackages = "org.datasource.demo1.soulmapper",
sqlSessionFactoryRef = "soulSqlSessionFactory")
public class SoulDataSourceConfiguration {

public static final String MAPPER_LOCATION
= "classpath:soulmapper/*.xml";

@Bean("soulDataSource")
@ConfigurationProperties(prefix = "spring.datasource.soul")
public DataSource soulDataSource() {
return DataSourceBuilder.create().build();
}

@Bean(name = "soulTransactionManager")
public PlatformTransactionManager soulTransaction
Manager(@Qualifier("soulDataSource") DataSource dataSource) {
return new DataSourceTransactionManager(dataSource);
}

@Bean(name = "soulSqlSessionFactory")
public SqlSessionFactory soulSqlSessionFactory
(@Qualifier("soulDataSource") DataSource dataSource)
throws Exception {
final SqlSessionFactoryBean sessionFactoryBean
= new SqlSessionFactoryBean();
sessionFactoryBean.setDataSource(dataSource);
sessionFactoryBean.setMapperLocations(new
PathMatchingResourcePatternResolver().getResources
(SoulDataSourceConfiguration.MAPPER_LOCATION));
return sessionFactoryBean.getObject();
}

}

@Autowired
private AppAuthMapper appAuthMapper;

@Transactional(rollbackFor = Exception.class)
public int getCount() {
int a = appAuthMapper.listCount();
int b = 1 / 0;
return a;
}

}

@SpringBootTest
@RunWith(SpringRunner.class)
public class TestDataSource {

@Autowired
private AppAuthService appAuthService;

@Autowired
private SysUserService sysUserService;

@Test
public void test_dataSource1(){
int b=sysUserService.getCount();
int a=appAuthService.getCount();
}
}

public Connection getConnection(String username,
String password) throws SQLException {
return this.determineTargetDataSource
().getConnection(username, password);
}

if (dataSource == null) {
throw new IllegalStateException("Cannot determine target
DataSource for lookup key [" + lookupKey + "]");
} else {
return dataSource;
}
}

USERDATASOURCE("userDataSource"),

SOULDATASOURCE("soulDataSource");

private String name;

DataSourceType(String name) {
this.name=name;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}
}

@Primary
@Bean(name = "userDataSource")
@ConfigurationProperties(prefix = "spring.datasource.user")
public DataSource userDataSource() {
return DataSourceBuilder.create().build();
}

@Bean(name = "soulDataSource")
@ConfigurationProperties(prefix = "spring.datasource.soul")
public DataSource soulDataSource() {
return DataSourceBuilder.create().build();
}

@Bean(name = "dynamicDataSource")
public DynamicDataSource DataSource(
@Qualifier("userDataSource") DataSource userDataSource,
@Qualifier("soulDataSource") DataSource soulDataSource) {
//targetDataSource 集合是我们数据库和名字之间的映射
Map<Object, Object> targetDataSource = new HashMap<>();
targetDataSource.put(DataSourceType.USERDATASOURCE.
getName(), userDataSource);
targetDataSource.put(DataSourceType.SOULDATASOURCE.
getName(), soulDataSource);
DynamicDataSource dataSource = new DynamicDataSource();
dataSource.setTargetDataSources(targetDataSource);
//设置默认对象
dataSource.setDefaultTargetDataSource(userDataSource);
return dataSource;
}

@Bean(name = "sqlSessionFactory")
public SqlSessionFactory sqlSessionFactory(@Qualifier
("dynamicDataSource") DataSource dynamicDataSource)
throws Exception {
SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
bean.setTransactionFactory(new MultiDataSourceTransactionFactory());
bean.setDataSource(dynamicDataSource);
//设置我们的xml文件路径
bean.setMapperLocations(new PathMatching
ResourcePatternResolver().getResources(
"classpath*:mapper/*.xml"));
return bean.getObject();
}
}

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

public static void set(String name) {
LOCAL_DATASOURCE.set(name);
}

public static String get() {
return LOCAL_DATASOURCE.get();
}

public static void remove() {
LOCAL_DATASOURCE.remove();
}
}

@Override
protected Object determineCurrentLookupKey() {
return DataSourceContext.get();
}

}

@Pointcut("@annotation(org.datasource.demo2.constant.
CurrentDataSource)")
public void dsPointCut() {

}

@Around("dsPointCut()")
public Object around(ProceedingJoinPoint point)
throws Throwable {
MethodSignature signature = (MethodSignature)
point.getSignature();

Method method = signature.getMethod();

CurrentDataSource dataSource = method.get
Annotation(CurrentDataSource.class);

if (Objects.nonNull(dataSource)) {
System.out.println("切换数据源为" +
dataSource.value().getName());
DataSourceContext.set(dataSource.value().getName());
}

try {
return point.proceed();
} finally {
// 销毁数据源 在执行方法之后
System.out.println("销毁数据源"
+ dataSource.value().getName());
DataSourceContext.remove();
}
}

}

private final DataSource dataSource;

private ConcurrentMap<String, Connection> concurrentMap;

private boolean autoCommit;

public MultiDataSourceTransaction(DataSource dataSource) {
this.dataSource = dataSource;
concurrentMap = new ConcurrentHashMap<>();
}

@Override
public Connection getConnection() throws SQLException {
String databaseIdentification = DataSourceContext.get();
if (StringUtils.isEmpty(databaseIdentification)) {
databaseIdentification = DataSourceType.
USERDATASOURCE.getName();
}
//获取数据源
if (!this.concurrentMap.containsKey(databaseIdentification)) {
try {
Connection conn = this.dataSource.getConnection();
autoCommit=false;
conn.setAutoCommit(false);
this.concurrentMap.put(databaseIdentification, conn);
} catch (SQLException ex) {
throw new CannotGetJdbcConnectionException
("Could bot get JDBC otherConnection", ex);
}
}
return this.concurrentMap.get(databaseIdentification);
}

@Override
public void commit() throws SQLException {
for (Connection connection : concurrentMap.values()) {
if (!autoCommit) {
connection.commit();
}
}
}

@Override
public void rollback() throws SQLException {
for (Connection connection : concurrentMap.values()) {
connection.rollback();
}
}

@Override
public void close() throws SQLException {
for (Connection connection : concurrentMap.values()) {
DataSourceUtils.releaseConnection(connection, this.dataSource);
}
}

@Override
public Integer getTimeout() throws SQLException {
return null;
}
}

public class MultiDataSourceTransactionFactory
extends SpringManagedTransactionFactory {
@Override

public Transaction newTransaction(DataSource
dataSource, TransactionIsolationLevel level, boolean autoCommit) {
return new MultiDataSourceTransaction(dataSource);
}
}

/**
* 默认dataSource
*/
private DataSource defaultDataSource;

/**
* 数据源map
*/
private Map<String, DataSource> dataSourcesMap
= new HashMap<>();

@Override
public void setEnvironment(Environment environment) {
initConfig(environment);
}

private void initConfig(Environment env) {
//读取配置文件获取更多数据源
String dsNames = env.getProperty("spring.datasource.names");
for (String dsName : dsNames.split(",")) {
HikariConfig hikariConfig = new HikariConfig();
hikariConfig.setPoolName(dsName);
hikariConfig.setDriverClassName(env.getProperty
("spring.datasource." + dsName.trim() + ".driver-class-name"));
hikariConfig.setJdbcUrl(env.getProperty("spring.
datasource." + dsName.trim() + ".jdbc-url"));
hikariConfig.setUsername(env.getProperty("spring.
datasource." + dsName.trim() + ".username"));
hikariConfig.setPassword(env.getProperty("spring.
datasource." + dsName.trim() + ".password"));
hikariConfig.setConnectionTimeout(Long.parseLong
(Objects.requireNonNull(env.getProperty("spring.
datasource." + dsName.trim() + ".hikari.connection-timeout"))));
hikariConfig.setMinimumIdle(Integer.parseInt
(Objects.requireNonNull(env.getProperty("spring.
datasource." + dsName.trim() + ".hikari.minimum-idle"))));
hikariConfig.setMaximumPoolSize(Integer.parseInt
(Objects.requireNonNull(env.getProperty("spring.
datasource." + dsName.trim() + ".hikari.maximum-pool-size"))));
hikariConfig.setConnectionInitSql("SELECT 1");
HikariDataSource dataSource = new HikariDataSource(hikariConfig);
if (dataSourcesMap.size() == 0) {
defaultDataSource = dataSource;
}
dataSourcesMap.put(dsName, dataSource);
}
}

@Override
public void registerBeanDefinitions(AnnotationMetadata
importingClassMetadata, BeanDefinitionRegistry registry) {

Map<Object, Object> targetDataSources = new HashMap<Object, Object>();
//添加其他数据源
targetDataSources.putAll(dataSourcesMap);
//创建DynamicDataSource
GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
beanDefinition.setBeanClass(DynamicDataSource.class);
beanDefinition.setSynthetic(true);
MutablePropertyValues mpv = beanDefinition.getPropertyValues();
//defaultTargetDataSource 和 targetDataSources
属性是 AbstractRoutingDataSource的两个属性Map
mpv.addPropertyValue("defaultTargetDataSource", defaultDataSource);
mpv.addPropertyValue("targetDataSources", targetDataSources);
//注册
registry.registerBeanDefinition("dataSource", beanDefinition);
}

}

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

@Autowired
private DataSource dynamicDataSource;

@Bean(name = "sqlSessionFactory")
public SqlSessionFactory sqlSessionFactory()
throws Exception {
SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
bean.setTransactionFactory(new MultiDataSource
TransactionFactory());
bean.setDataSource(dynamicDataSource);
//设置我们的xml文件路径
bean.setMapperLocations(new PathMatching
ResourcePatternResolver().getResources(
"classpath*:mapper/*.xml"));
return bean.getObject();
}
}