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

erghtt

于 2024-04-04 17:30:39 发布

阅读量851

点赞数 8

分类专栏：程序员文章标签： java 开发语言

本文链接：https://blog.csdn.net/erghtt/article/details/137378479

版权

程序员专栏收录该内容

560 篇文章 1 订阅

订阅专栏

文章介绍了如何在SpringBoot项目中使用MutiDataSourceBean类进行多数据源的初始化、配置和动态切换，通过JDBC连接数据库，并展示了如何通过`DynamicDataSourceHolder`来管理不同数据源的切换过程。

摘要由CSDN通过智能技术生成

/**

@Description: 设置数据源类型 @param dataSourceType 数据库类型 @return void @throws

public static void setDataSourceType(String dataSourceType) {

contextHolder.set(dataSourceType);

}

/**

@Description: 获取数据源类型 @param @return String @throws

public static String getDataSourceType() {

return contextHolder.get();

}

/**

@Description: 清除数据源类型 @param @return void @throws

public static void clearDataSourceType() {

contextHolder.remove();

}

用于jdbc连接数据库的类，JdbcPOJO.java:

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里面的多数据源信息是：

顺便说下，这里的id，我项目里面写的是 Source拼接dbName的值（这个就是用于给我们切换数据源的id，规则可以自己修改）：

OK，到这里多数据的整合其实已经完成了，我们来写个接口测试下，看看效果：

@Autowired

MessageboardService messageboardServiceImpl;

@Autowired

JdbcConfigService jdbcConfigServiceImpl;

@RequestMapping(value = “/testDbSource”, produces = “application/json; charset=utf-8”)

public void testDbSource() {

System.out.println(“当前数据源ID：”+DynamicDataSourceHolder.getDataSourceType());

List list1 = jdbcConfigServiceImpl.getList();

System.out.println(“获取结果数：”+list1.size()); //默认是默认连接的数据库

DynamicDataSourceHolder.setDataSourceType(“Source”+“db1”.trim()); //切换到数据源db1

System.out.println(“当前数据源ID：”+DynamicDataSourceHolder.getDataSourceType());
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

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

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

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

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

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

总结

面试难免让人焦虑不安。经历过的人都懂的。但是如果你提前预测面试官要问你的问题并想出得体的回答方式，就会容易很多。

此外，都说“面试造火箭，工作拧螺丝”，那对于准备面试的朋友，你只需懂一个字：刷！

给我刷刷刷刷，使劲儿刷刷刷刷刷！今天既是来谈面试的，那就必须得来整点面试真题，这不花了我整28天，做了份“Java一线大厂高岗面试题解析合集：JAVA基础-中级-高级面试+SSM框架+分布式+性能调优+微服务+并发编程+网络+设计模式+数据结构与算法等”

且除了单纯的刷题，也得需准备一本【JAVA进阶核心知识手册】：JVM、JAVA集合、JAVA多线程并发、JAVA基础、Spring 原理、微服务、Netty与RPC、网络、日志、Zookeeper、Kafka、RabbitMQ、Hbase、MongoDB、Cassandra、设计模式、负载均衡、数据库、一致性算法、JAVA算法、数据结构、加密算法、分布式缓存、Hadoop、Spark、Storm、YARN、机器学习、云计算，用来查漏补缺最好不过。

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！
问你的问题并想出得体的回答方式，就会容易很多。

此外，都说“面试造火箭，工作拧螺丝”，那对于准备面试的朋友，你只需懂一个字：刷！

[外链图片转存中…(img-Svrcrw8B-1712223026922)]

[外链图片转存中…(img-cDGRhkr5-1712223026922)]

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！

erghtt

关注

8
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
SSM 最灵活实现动态切换操作多数据源

面试难免让人焦虑不安。经历过的人都懂的。但是如果你提前预测面试官要问你的问题并想出得体的回答方式，就会容易很多。此外，都说“面试造火箭，工作拧螺丝”，那对于准备面试的朋友，你只需懂一个字：刷！给我刷刷刷刷，使劲儿刷刷刷刷刷！今天既是来谈面试的，那就必须得来整点面试真题，这不花了我整28天，做了份“Java一线大厂高岗面试题解析合集：JAVA基础-中级-高级面试+SSM框架+分布式+性能调优+微服务+并发编程+网络+设计模式+数据结构与算法等”
复制链接

扫一扫