SSM 最灵活实现动态切换操作多数据源

import java.io.Serializable;

public class JdbcPOJO implements Serializable {

private String driverClassName;

private String id;

private String url;

private String username;

private String password;

public String getDriverClassName() {

return driverClassName;

}

public void setDriverClassName(String driverClassName) {

this.driverClassName = driverClassName;

}

public String getId() {

return id;

}

public void setId(String id) {

this.id = id;

}

public String getUrl() {

return url;

}

public void setUrl(String url) {

this.url = url;

}

public String getUsername() {

return username;

}

public void setUsername(String username) {

this.username = username;

}

public String getPassword() {

return password;

}

public void setPassword(String password) {

this.password = password;

}

}

关键的多数据源加载类，MutiDataSourceBean.java：

import com.alibaba.druid.pool.DruidDataSource;

import com.springmvc.util.PropertyUtil;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.BeansException;

import org.springframework.beans.factory.support.DefaultListableBeanFactory;

import org.springframework.context.ApplicationContext;

import org.springframework.context.ApplicationContextAware;

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

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

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

public class MutiDataSourceBean extends AbstractRoutingDataSource implements ApplicationContextAware {

private static Logger log = LoggerFactory.getLogger(MutiDataSourceBean.class);

private static ApplicationContext ac;

private static Map<String, String> buildDataSources = new HashMap();

@Override

public void afterPropertiesSet() {

log.info(“初始化多数据源”);

try {

initailizeMutiDataSource();

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

log.info(“多数据源加入spring容器中成功!”);

super.afterPropertiesSet();

}

@Override

public void setApplicationContext(ApplicationContext ctx) throws BeansException {

// TODO Auto-generated method stub

ac = ctx;

}

private List getServers() {

List list = new ArrayList();

try {

Class.forName(PropertyUtil.getPropery(“jdbc.driverClassName”));

Connection conn = DriverManager.getConnection(PropertyUtil.getPropery(“jdbc.url”).trim(),

PropertyUtil.getPropery(“jdbc.username”).trim(), PropertyUtil.getPropery(“jdbc.password”).trim());

PreparedStatement ps = conn.prepareStatement(

“SELECT id,dbName,url,username,password,driverClassName FROM jdbc_config WHERE status=0”);

ResultSet rs = ps.executeQuery();

while (rs.next()) {

JdbcPOJO obj = new JdbcPOJO();

obj.setId(“Source” + rs.getString(“dbName”));

obj.setUrl(rs.getString(“url”));

obj.setUsername(rs.getString(“username”));

obj.setPassword(rs.getString(“password”));

obj.setDriverClassName(rs.getString(“driverClassName”));

list.add(obj);

}

if (rs != null) {

rs.close();

}

if (ps != null) {

ps.close();

}

if (conn != null) {

conn.close();

}

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return list;

}

public static boolean getSourcesExistsByKey(String key) {

if (buildDataSources.containsKey(key)) {

return true;

} else {

return false;

}

}

private void initailizeMutiDataSource() throws Exception {

List servers = getServers();

DefaultListableBeanFactory acf = (DefaultListableBeanFactory) ac.getAutowireCapableBeanFactory();

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

for (JdbcPOJO obj : servers) {

log.debug(“初始化数据源：{}”,obj.getId());

System.out.println(“数据源加载： ----------”+obj.getId());

DruidDataSource ds = new DruidDataSource();

String id = obj.getId();

ds.setDriverClassName(obj.getDriverClassName());

ds.setUsername(obj.getUsername());

ds.setUrl(obj.getUrl());

ds.setPassword(obj.getPassword());

ds.setInitialSize(Integer.parseInt(PropertyUtil.getPropery(“jdbc.initialSize”).trim()));

ds.setMaxActive(Integer.parseInt(PropertyUtil.getPropery(“jdbc.maxActive”).trim()));

ds.setMinIdle(Integer.valueOf(PropertyUtil.getPropery(“jdbc.minIdle”).trim()));

ds.setMaxWait(Integer.valueOf(PropertyUtil.getPropery(“jdbc.maxWait”).trim()));

ds.setTestOnBorrow(Boolean.parseBoolean(PropertyUtil.getPropery(“jdbc.testOnBorrow”).trim()));

ds.setTestOnReturn(Boolean.parseBoolean(PropertyUtil.getPropery(“jdbc.testOnReturn”).trim()));

ds.setTestWhileIdle(Boolean.parseBoolean(PropertyUtil.getPropery(“jdbc.testWhileIdle”).trim()));

ds.setTimeBetweenEvictionRunsMillis(

Long.valueOf(PropertyUtil.getPropery(“jdbc.timeBetweenEvictionRunsMillis”).trim()));

ds.setMinEvictableIdleTimeMillis(

Long.valueOf(PropertyUtil.getPropery(“jdbc.minEvictableIdleTimeMillis”).trim()));

ds.setRemoveAbandoned(Boolean.parseBoolean(PropertyUtil.getPropery(“jdbc.removeAbandoned”).trim()));

ds.setRemoveAbandonedTimeout(

Integer.valueOf(PropertyUtil.getPropery(“jdbc.removeAbandonedTimeout”).trim()));

ds.setLogAbandoned(Boolean.parseBoolean(PropertyUtil.getPropery(“jdbc.logAbandoned”).trim()));

ds.setPoolPreparedStatements(

Boolean.parseBoolean(PropertyUtil.getPropery(“jdbc.poolPreparedStatements”).trim()));

ds.setMaxOpenPreparedStatements(

Integer.parseInt(PropertyUtil.getPropery(“jdbc.maxOpenPreparedStatements”).trim()));

ds.setFilters(PropertyUtil.getPropery(“jdbc.filters”).trim());

acf.registerSingleton(id, ds);

dsMap.put(id, ds);

buildDataSources.put(id, id);

}

this.setTargetDataSources(dsMap);

// setDefaultTargetDataSource(dsMap.get(“Source”));//设置默认数据源

}

@Override

protected Object determineCurrentLookupKey() {

return DynamicDataSourceHolder.getDataSourceType();

}

@Override

public void setDataSourceLookup(DataSourceLookup dataSourceLookup) {

super.setDataSourceLookup(dataSourceLookup);

}

@Override

public void setDefaultTargetDataSource(Object defaultTargetDataSource) {

super.setDefaultTargetDataSource(defaultTargetDataSource);

}

@Override

public void setTargetDataSources(Map targetDataSources) {

super.setTargetDataSources(targetDataSources);

}

}

简单介绍下上面这个类，项目跑起来后，简单的几步是：

然后读取数据库表jdbc_config里面的多数据源信息是：

先自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以扫码领取！

写在最后

还有一份JAVA核心知识点整理（PDF）：JVM，JAVA集合，JAVA多线程并发，JAVA基础，Spring原理，微服务，Netty与RPC，网络，日志，Zookeeper，Kafka，RabbitMQ，Hbase，MongoDB，Cassandra，设计模式，负载均衡，数据库，一致性哈希，JAVA算法，数据结构，加密算法，分布式缓存，Hadoop，Spark，Storm，YARN，机器学习，云计算…

1nx6-1711460650362)]

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以扫码领取！

写在最后

还有一份JAVA核心知识点整理（PDF）：JVM，JAVA集合，JAVA多线程并发，JAVA基础，Spring原理，微服务，Netty与RPC，网络，日志，Zookeeper，Kafka，RabbitMQ，Hbase，MongoDB，Cassandra，设计模式，负载均衡，数据库，一致性哈希，JAVA算法，数据结构，加密算法，分布式缓存，Hadoop，Spark，Storm，YARN，机器学习，云计算…

[外链图片转存中…(img-nJTFQu07-1711460650362)]

需要更多Java资料的小伙伴可以帮忙点赞+关注，点击传送门，即可免费领取！