当前位置：首页 » 数据仓库 » spring连接多个数据库
扩展阅读
提分平台的账号密码是什么 2023-08-31 22:07:10
webinf下怎么引入js 2023-08-31 21:54:13
堡垒机怎么打开web 2023-08-31 21:54:11

spring连接多个数据库

发布时间: 2022-07-14 20:54:47

A. spring mvc 怎么配置多个库

场景描述：有多个数据库，每个数据库可能分布在不同的mysql instance上面，有多个存储过程，每个存储过程可能分布在不同的数据库中，需要有两个配置文件。

1. mysql 数据库映射：
A.driverClassName=com.mysql.jdbc.Driver
A.url=jdbc:mysql://172.20.7.51:3308/blog
A.username=trappuser
A.password=Opera1!

B.driverClassName=com.mysql.jdbc.Driver
B.url=jdbc:mysql://localhost:3306/wedding
B.username=root
B.password=opera
上面定义的A、B为两个mysql instance的缩写。
2. 存储过程与mysql instance的映射关系：
SP_Get_User=A
GetStocks=B

定义两个模拟存储过程，第一个数据库“SP_Get_User“是在数据库A下面，第二个数据库”GetStocks“是在数据库B下面。
3. 建立自定义的sessionFactory
3.1 xml配置的datasource及sessionFactory如下：
<bean class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close" id="dataSource">
<property name="driverClassName" value="${database.driverClassName}"/>
<property name="url" value="${database.url}"/>
<property name="username" value="${database.username}"/>
<property name="password" value="${database.password}"/>
</bean>

<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<property name="packagesToScan" value="com.xx.assetcommander">
</property>

<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
</props>

</property>
</bean>
此处我们定义的sessionFactory的类型为LocalSessionFactoryBean，它是一个工厂对象，与我们再需要的 SessionFactory不是一回事，我们需要的sessionfactory是org.hibernate.SessionFactory，这个对象可以被第一个sessionFactory的getObject()方法生成。

3.2 由于我们连接的是多个mysql instance， 不方便在xml中配置多个datasource和多个sessionFactory，故可以通过纯java的形式开发，可以使用map来存储存储过程与mysql database的关系，将存储过程的名字和数据库建议关系，这样通过存储过程的名称就能得到数据库的缩写名，通过数据库的缩写名能够找到对应的mysql instance，使用纯java开发的过程类似于xml配置，如下：
ds.setDriverClassName(getDriver());
ds.setUrl(getUrl());
ds.setUsername(getUsername());
ds.setPassword(getPassword());
LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
sessionFactory.setDataSource(ds);
sessionFactory.setPackagesToScan("com.xx.assetcommander");
Properties params = new Properties();
params.setProperty("hibernate.dialect",
"org.hibernate.dialect.MySQLDialect");
params.setProperty("hibernate.show_sql", "true");
sessionFactory.setHibernateProperties(params);

当我们获得可以使用的LocalSessionFactoryBean时候，在调用getObject()获得SessionFactory之前，必须要调用afterPropertiesSet()方法，否则得到的sessionFactory为空。
public Session getDsBySp(String spName) throws IOException {
//get the corresponding mysql database shortname by sp name
String dbName = getDbForSP(str);
//get the corresponding mysql instance connection by mysql database shortname
LocalSessionFactoryBean fB = getDsByDb(dbName);
// don't forget this line or null will be returned when you call getObject() method.
fB.afterPropertiesSet();
return fB.getObject().openSession();
}

注：在tomcat启动时，如果没有配置任何datasource，会出现如下错误：
org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type [javax.persistence.EntityManagerFactory] is defined
故需要配置默认的datasource.
这种方式需要做到不同的数据库instance直接业务的完全独立，不可以出现跨数据库的表join，否则处理难度会增加。
还有就是对于多数据库直接的事务管理如何去处理？

B. 连接两个数据库 spring配置文件怎么配置

配置多个数据源信息，比如dataSource1, dataSource2, dataSource3等等。 自定义一个动态数据源类，同时注入以上这些数据源以及相应的标志，一般用Map区分 利用动态数据源类来拿到相应的数据源操作

C. springboot 中druid怎么连接多个数据库

spring动态配置多数据源，即在大型应用中对数据进行切分，并且采用多个数据库实例进行管理，这样可以有效提高系统的水平伸缩性。
而这样的方案就会不同于常见的单一数据实例的方案，这就要程序在运行时根据当时的请求及系统状态来动态的决定将数据存储在哪个数据库实例中，以及从哪个数据库提取数据。

D. 如何在spring框架中解决多数据源的问题

我们的项目需要连接多个数据库，而且不同的客户在每次访问中根据需要会去访问不同的数据库。我们以往 在 spring 和 hibernate 框架中总是配置一个数据源在 我们的项目中遇到这样一个问题：如何让 sessionFactory 在执 行数据持久化的时候，更准确说是实例变量， sessionFactory 在整个项目中只有一 个对象.springframework，通过它来动态切换数据源 。同时在配置文件中将sessionFactory的dataSource属性由原来的某个具体的dataSource改为MultiDataSource，根据客户的需求能够动态切换不同的数据源，同时，我们又希望使用 dataSource 的 sessionFactory 根本就感觉不到这样的变 化。 Decorator 模式就正是解决这个问题的设计模式。
首先写一个 Decorator 类，我取名叫 MultiDataSource.commons。当我们使用 Decorator 的时候与原类完全一样，当 Decorator 的某些功能却已经修改为了我们需要修改的功 能。如图：

E. Spring中如何配置多个数据库连接

<!-- 数据源配置,使用应用内的DBCP数据库连接池 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<!-- Connection Info -->
<property name="driverClassName" value="${jdbc.driver}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />

<!-- Connection Pooling Info -->
<property name="maxIdle" value="${dbcp.maxIdle}" />
<property name="maxActive" value="${dbcp.maxActive}" />
<property name="defaultAutoCommit" value="false" />
<property name="timeBetweenEvictionRunsMillis" value="3600000" />
<property name="minEvictableIdleTimeMillis" value="3600000" />
</bean>
然后 写个application.properties文件
配置多个数据库的jdbc.driver.....等等

F. 如何用连接池，Hibernate，Spring连多个SQL数据库

1：在proxool-conf.xml中配置两个数据库连接池
<proxool>
<alias>dataSource_ksmaeaII</alias>
<driver-url>jdbc:jtds:sqlserver://192.10.110.192:1433;databaseName=ksmaeaII</driver-url>
<driver-class>net.sourceforge.jtds.jdbc.Driver</driver-class>
<driver-properties>
<property name="user" value="sa" />
<property name="password" value="" />
</driver-properties>
<maximum-new-connections>100</maximum-new-connections>
<prototype-count>1</prototype-count>
<maximum-connection-count>400</maximum-connection-count>
<minimum-connection-count>20</minimum-connection-count>
<house-keeping-test-sql>select getdate()</house-keeping-test-sql>
</proxool>

<proxool>
<alias>ds1</alias>
<driver-url>jdbc:jtds:sqlserver://192.10.110.192:1433;databaseName=ksmaeaIIdbmove</driver-url>
<driver-class>net.sourceforge.jtds.jdbc.Driver</driver-class>
<driver-properties>
<property name="user" value="sa" />
<property name="password" value="" />
</driver-properties>
<maximum-new-connections>100</maximum-new-connections>
<prototype-count>1</prototype-count>
<maximum-connection-count>400</maximum-connection-count>
<minimum-connection-count>20</minimum-connection-count>
<house-keeping-test-sql>select getdate()</house-keeping-test-sql>
</proxool>

2：要连几个库就配置几个hibernate.cfg.xml,下面我配置两个数据库为例
创建hibernate.cfg.xml:里面写第一个数据库的映射文件（本地数据库），如<mapping
resource="com/wisoft/datachange/data/hibernate//SbInfApply.hbm.xml" />
创建hibernate.cfg1.xml:里面写第二个数据库的映射文件（前置库，别人的数据库），如<mapping
resource="com/wisoft/datachange/data/hibernate//InfApply.hbm.xml" />
3：创建一个类，继承HibernateDaoSupport。（直接拷过去就能直接用，我的第二个数据库就是用了这里面的factory1,第一个数据库用了Hibernate原来的factory,如果要连多个库，则多创建几个factory）
package com.wisoft.datachange.data;
import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
public class DebugBean extends HibernateDaoSupport {
private SessionFactory factory1;
// private SessionFactory factory2;
protected HibernateTemplate hibernateTemplate1;
// protected HibernateTemplate hibernateTemplate2;

public void setFactory1(SessionFactory factory1) {
this.factory1 = factory1;
}
// public void setFactory2(SessionFactory factory2) {
// this.factory2 = factory2;
// }

public SessionFactory getFactory1() {
return factory1;
}
// public SessionFactory getFactory2() {
// return factory2;
// }
protected HibernateTemplate createHibernateTemplate(SessionFactory sessionFactory) {
return super.createHibernateTemplate(sessionFactory);
}
protected void initDao() throws Exception {
hibernateTemplate1 = super.createHibernateTemplate(factory1);
// hibernateTemplate2 = super.createHibernateTemplate(factory2);
super.initDao();
}
}
4：编写自己的测试BO：在BO里注入DAO,如下
public class InfApplyBO implements IInfApplyBO {
private IInfApplyDAO myInfApplyDAO;
public IInfApplyDAO getMyInfApplyDAO() {
return myInfApplyDAO;
}
public void setMyInfApplyDAO(IInfApplyDAO myInfApplyDAO) {
this.myInfApplyDAO = myInfApplyDAO;
}
//底下编写自己的业务代码
//用this.myInfApplyDAO直接调用Dao层的方法，由DAO对数据库进行操作
}
5：编写自己的测试DAO：继承DebugBean如下
public class MyInfApplyDAO extends DebugBean implements IInfApplyDAO {
//对数据库的操作均可写在这里，可以直接用模版save
//如要对第一个数据库操作，只需this.getHibernateTemplate().find(hql);
//如要对第二个数据库操作，只需hibernateTemplate1.save（obj）;就行
//注意：在对数据库操作之前不要忘了写applicationContext.xml的配置文件，看第6步
}
6：写applicationContext.xml的配置文件
<!--对第一个数据库连接池的配置-->
<bean id="dataSource_ksmaeaII" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>org.logicalcobwebs.proxool.ProxoolDriver</value>
</property>
<property name="url">
<value>proxool.dataSource_ksmaeaII</value>
</property>
</bean>

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref bean="dataSource_ksmaeaII" />
</property>
<property name="lobHandler" ref="lobHandler" />
<property name="configLocation">
<value>classpath:hibernate.cfg.xml</value>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.SQLServerDialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.AllowCreate">true</prop>
<prop key="hibernate.connection.release_mode">auto</prop>
<prop key="hibernate.default_schema">dbo</prop>
</props>
</property>
</bean>

<!--对第二个数据库连接池的配置-->
<bean id="ds1" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>org.logicalcobwebs.proxool.ProxoolDriver</value>
</property>
<property name="url">
<value>proxool.ds1</value>
</property>
</bean>

<bean id="sessionFactory1" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref bean="ds1" />
</property>
<property name="lobHandler" ref="lobHandler" />
<property name="configLocation">
<value>classpath:hibernate1.cfg.xml</value>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.SQLServerDialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.AllowCreate">true</prop>
</props>
</property>
</bean>
<!--配置事务-->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref local="sessionFactory" />
</property>
</bean>

<bean id="transactionManager1" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="sessionFactory1"/>
</property>
</bean>

<!--工厂模版-->
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
<property name="sessionFactory" ref="sessionFactory" />
</bean>

<bean id="txProxyTemplate" abstract="true" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager" ref="transactionManager" />
<property name="transactionAttributes">
<props>
<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="write">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="makeWorkNoOfDep">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>

<bean id="nativeJdbcExtractor" class="org.springframework.jdbc.support.nativejdbc." lazy-init="true" />
<bean id="lobHandler" class="org.springframework.jdbc.support.lob.DefaultLobHandler">
<!-- <property name="nativeJdbcExtractor">
<ref bean="nativeJdbcExtractor" />
</property> -->
</bean>
<bean id="debugbean" class="com.wisoft.datachange.data.DebugBean" abstract="true">
<property name="sessionFactory" ref="sessionFactory" />
<property name="factory1" ref="sessionFactory1" />
<!-- <property name="factory2" ref="sessionFactory2" />-->
</bean>

<bean id="myInfApplyDAO"
class="com.wisoft.datachange.data.hibernate.MyInfApplyDAO" parent="debugbean" >
</bean>

<bean id="InfApplyBO" parent="txProxyTemplate">
<property name="target">
<bean class="com.wisoft.datachange.bo.impl.InfApplyBO">
<property name="myInfApplyDAO" ref="myInfApplyDAO" />
</bean>
</property>
</bean>

到此，数据库就连起来啦\(^o^)/~

G. 在spring文件中如何配置连接多个数据库，如下是已经配置了一个数据库，如何加另外的数据库

..一般我是
吧xml
配置文件
不同
功能
配在
不同的
xml文件
里面。这样看的清楚写。用哪个就在
xml文件里面
调用另外的xml文件就可以了。

H. 怎么在一个spring里面配置多个数据库连接池

gitchat学术分享，动态数据源，附带源码

阅读全文

与spring连接多个数据库相关的内容

本站内容整理源于互联网，如有问题请联系解决。
Copyright design: www.gotrillian.com since 2022