springmvc jpa 多数据源

已于 2023-07-05 15:54:15 修改
阅读量728 收藏 1
点赞数
分类专栏： SQL ORM 文章标签： spring java 前端
于 2023-04-28 15:59:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hanjun0612/article/details/130426741
版权
ORM 同时被 2 个专栏收录
63 篇文章 0 订阅
订阅专栏
SQL
54 篇文章 0 订阅
订阅专栏

本次使用Mysql 和 sqlServer

一 项目结构

二 properties文件

env.properties(可以不要)

protocol=http

jdbc.properties

# mysql
jdbc.first.driver = com.mysql.cj.jdbc.Driver
jdbc.first.jdbcUrl=jdbc:mysql://localhost:3306/test1
jdbc.first.user=root
jdbc.first.password=root

# sqlserver
jdbc.second.driver= com.microsoft.sqlserver.jdbc.SQLServerDriver
jdbc.second.jdbcUrl= jdbc:sqlserver://localhost;DatabaseName=test2
jdbc.second.user= root
jdbc.second.password= root

jdbc.initialPoolSize=3
jdbc.miniPoolSize=3
jdbc.maxPoolSize=20
jdbc.maxIdleTime=20

#hibernate config
hibernate.dialect = org.hibernate.dialect.MySQLDialect
hibernate.show_sql = false
hibernate.format_sql = true
#hibernate.hbm2ddl.auto =update
hibernate.hbm2ddl.auto =none
hibernate.cache.use_second_level_cache=false
hibernate.cache.use_query_cache=false
hibernate.cache.provider_class=net.sf.ehcache.hibernate.EhCacheProvider
hibernate.cache.region.factory_class=org.hibernate.cache.ehcache.EhCacheRegionFactory

三 配置文件

pom（注意mysql版本，如果和本机不匹配，那么会报错）

<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 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.kintech</groupId>
        <artifactId>kintech.parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <artifactId>kintech.test1</artifactId>
    <packaging>war</packaging>
    <name>kintech.test1 Maven Webapp</name>
    <url>http://maven.apache.org</url>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
        </dependency>
        <!-- hibernate -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
        </dependency>
        <!-- hibernate -->

        <!--  JPA  -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-ehcache</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
        </dependency>
        <!--  JPA  -->

        <!--    Mysql    -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.33</version>
        </dependency>
        <!--    Mysql    -->

        <!--    SQL server    -->
        <dependency>
            <groupId>com.microsoft</groupId>
            <artifactId>microsoft-sqljdbc4</artifactId>
            <version>4.0</version>
        </dependency>
        <!--    SQL server    -->

        <!-- dataSource pool -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
        </dependency>
        <!-- dataSource pool -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>
    <build>
        <finalName>kintech.test1</finalName>
    </build>
</project>

application.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xmlns:context="http://www.springframework.org/schema/context"
	   xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:aop="http://www.springframework.org/schema/aop"
	   xmlns:tx="http://www.springframework.org/schema/tx" xmlns:p="http://www.springframework.org/schema/p"
	   xmlns:cache="http://www.springframework.org/schema/cache"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
                           http://www.springframework.org/schema/context 
                           http://www.springframework.org/schema/context/spring-context-4.3.xsd  
                           http://www.springframework.org/schema/mvc 
                           http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd
                           http://www.springframework.org/schema/aop 
						   http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
						   http://www.springframework.org/schema/tx 
                           http://www.springframework.org/schema/tx/spring-tx-4.3.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd"
	   default-lazy-init="true">

	<!-- 引入属性文件 -->
	<bean
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<list>
				<value>classpath:properties/env.properties</value>
				<value>classpath:properties/jdbc.properties</value>
			</list>
		</property>
	</bean>

	<!-- <context:annotation-config /> -->

	  <!-- 开启自动扫描包 -->
   <context:component-scan base-package="com.kintech" use-default-filters="true" annotation-config="true">
      <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>  
      <context:exclude-filter type="annotation" expression="org.springframework.web.bind.annotation.RestController"/> 
   </context:component-scan>

	<import resource="spring-business.xml"/>

</beans>

business.xml（注意扫描路径 packagesToScan   jpa:repositories base-package）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:p="http://www.springframework.org/schema/p" xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
                           http://www.springframework.org/schema/context 
                           http://www.springframework.org/schema/context/spring-context-4.3.xsd  
                           http://www.springframework.org/schema/mvc 
                           http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd
                           http://www.springframework.org/schema/aop 
						   http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
						   http://www.springframework.org/schema/tx 
                           http://www.springframework.org/schema/tx/spring-tx-4.3.xsd http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd"
       default-lazy-init="true">

    <!--mysql 配置数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
        <property name="driverClass" value="${jdbc.first.driver}" />  <!--数据库连接驱动-->
        <property name="jdbcUrl" value="${jdbc.first.jdbcUrl}" />     <!--数据库地址-->
        <property name="user" value="${jdbc.first.user}" />   <!--用户名-->
        <property name="password" value="${jdbc.first.password}" />   <!--密码-->
        <property name="maxPoolSize" value="${jdbc.maxPoolSize}" />      <!--最大连接数-->
        <property name="minPoolSize" value="${jdbc.miniPoolSize}" />       <!--最小连接数-->
        <property name="initialPoolSize" value="${jdbc.initialPoolSize}" />      <!--初始化连接池内的数据库连接-->
        <property name="maxIdleTime" value="${jdbc.maxIdleTime}" />  <!--最大空闲时间-->
    </bean>

    <!--  hibernate  -->
    <!--配置session工厂-->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="packagesToScan" value="com.kintech.test1.model" />
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop> <!--hibernate根据实体自动生成数据库表-->
                <prop key="hibernate.dialect">${hibernate.dialect}</prop>   <!--指定数据库方言-->
                <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>     <!--在控制台显示执行的数据库操作语句-->
                <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>     <!--在控制台显示执行的数据哭操作语句（格式）-->
                <prop key="hibernate.cache.use_second_level_cache">${hibernate.cache.use_second_level_cache}</prop>
                <prop key="hibernate.cache.use_query_cache">${hibernate.cache.use_query_cache}</prop>  <!-- 查询缓存 -->
                <prop key="hibernate.cache.provider_class">${hibernate.cache.provider_class}</prop>
                <prop key="hibernate.cache.region.factory_class">${hibernate.cache.region.factory_class}</prop>
                <prop key="hibernate.allow_update_outside_transaction">true</prop>
            </props>
        </property>
    </bean>

    <!--  JPA mysql  -->
    <!-- JPA实体管理器工厂 -->
    <bean id="entityManagerFactory" name="jpaEntityManagerFactory"
          class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="jpaVendorAdapter" ref="hibernateJpaVendorAdapter" />
        <!-- 加入定制化包路径 -->
        <property name="packagesToScan" value="com.kintech.test1.model.first" />

        <property name="jpaProperties">
            <props>
                <prop key="hibernate.current_session_context_class">thread</prop>
                <prop key="hibernate.hbm2ddl.auto">none</prop><!-- validate/update/create -->
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>

                <!-- 建表的命名规则 -->
                <prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>

            </props>
        </property>
    </bean>

    <!-- 设置JPA实现厂商的特定属性 -->
    <bean id="hibernateJpaVendorAdapter"
          class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
        <property name="databasePlatform" value="${hibernate.dialect}"/>
    </bean>

    <!-- Jpa 事务配置 -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>

    <!-- Spring Data Jpa配置 -->
    <jpa:repositories base-package="com.kintech.test1.dao.first"  transaction-manager-ref="transactionManager" entity-manager-factory-ref="entityManagerFactory"/>

    <!-- 使用annotation定义事务 -->
    <tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" />
    <!--  JPA mysql  -->


    <!-- JPA sqlserver -->
    <bean id="sqlserverDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
        <property name="driverClass" value="${jdbc.second.driver}" />  <!--数据库连接驱动-->
        <property name="jdbcUrl" value="${jdbc.second.jdbcUrl}" />     <!--数据库地址-->
        <property name="user" value="${jdbc.second.user}" />   <!--用户名-->
        <property name="password" value="${jdbc.second.password}" />   <!--密码-->
        <property name="maxPoolSize" value="${jdbc.maxPoolSize}" />      <!--最大连接数-->
        <property name="minPoolSize" value="${jdbc.miniPoolSize}" />       <!--最小连接数-->
        <property name="initialPoolSize" value="${jdbc.initialPoolSize}" />      <!--初始化连接池内的数据库连接-->
        <property name="maxIdleTime" value="${jdbc.maxIdleTime}" />  <!--最大空闲时间-->
    </bean>

    <!-- 整合sqlserverjpa -->
    <bean id="sqlserverEntityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="sqlserverDataSource"></property>
        <property name="packagesToScan" value="com.kintech.test1.model.second"></property>
        <property name="persistenceUnitName" value="sqlserverdb"></property>
        <property name="jpaVendorAdapter" ref="hibernateJpaVendorAdapter2" />
        <property name="jpaProperties">
            <props>
                <!--设置外连接抓取树的最大深度 -->
                <prop key="hibernate.max_fetch_depth">3</prop>
                <prop key="hibernate.jdbc.fetch_size">18</prop>
                <prop key="hibernate.jdbc.batch_size">10</prop>
                <!-- 自动建表类型 validate|create|create-drop|update -->
                <!-- <prop key="hibernate.hbm2ddl.auto">validate</prop> -->
                <!-- 是否显示SQL -->
                <prop key="hibernate.show_sql">false</prop>
                <!-- 显示SQL是否格式化 -->
                <prop key="hibernate.format_sql">false</prop>
                <!-- 关闭二级缓存 -->
                <prop key="hibernate.cache.provider_class">org.hibernate.cache.NoCacheProvider</prop>
                <!-- 关闭实体字段映射校验 -->
                <prop key="javax.persistence.validation.mode">none</prop>
            </props>
        </property>
    </bean>
    <!-- 设置JPA实现厂商的特定属性 -->
    <bean id="hibernateJpaVendorAdapter2"
          class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
        <property name="databasePlatform" value="org.hibernate.dialect.SQLServerDialect"/>
    </bean>
    <bean id="sqlservertransactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="sqlserverEntityManagerFactory" />
        <qualifier value="sqlserverEM"/>
    </bean>
    <jpa:repositories base-package="com.kintech.test1.dao.second"  transaction-manager-ref="sqlservertransactionManager" entity-manager-factory-ref="sqlserverEntityManagerFactory"/>
    <tx:annotation-driven transaction-manager="sqlservertransactionManager" proxy-target-class="false"/>
    <!-- JPA sqlserver -->

</beans>

springmvc-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
                           http://www.springframework.org/schema/context 
                           http://www.springframework.org/schema/context/spring-context-4.3.xsd  
                           http://www.springframework.org/schema/mvc 
                           http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd
                           http://www.springframework.org/schema/aop 
						   http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
						   http://www.springframework.org/schema/tx 
                           http://www.springframework.org/schema/tx/spring-tx-4.3.xsd"
                           default-lazy-init="true" >
	
	
	<!-- 默认的注解映射的支持 -->
	<mvc:annotation-driven />
	<!--静态资源映射  -->
	<mvc:default-servlet-handler />

	<!-- 扫描Controller -->
	<context:component-scan base-package="com.kintech" use-default-filters="false">
		<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller" />
		<context:include-filter type="annotation" expression="org.springframework.web.bind.annotation.RestController" />
	</context:component-scan>
	
	
	 <!-- 引入属性文件 -->					
	<bean
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<list>
				<value>classpath:properties/env.properties</value>
			</list>
		</property>
	</bean>
</beans>

四 创建实体类和Dao

搞完上面的，基本就差不多了。这里就准备测试了。

（mysql和sqlserver的Model,service,dao都分包创建）

Model创建

model.first

package com.kintech.test1.model.first;


import com.fasterxml.jackson.annotation.JsonProperty;
import javax.persistence.*;


@Entity
@Table(name = "user",catalog = "test1")
public class User implements java.io.Serializable  {
    private static final long serialVersionUID = 6693634101527860224L;

    @JsonProperty("id")
    private Integer id;

    @JsonProperty("name")
    private String name;

    @JsonProperty("schoolId")
    private Integer schoolId;


    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public Integer getId() {
        return this.id;
    }
    public void setId(Integer id) {
        this.id = id;
    }

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

    public Integer getSchoolId() {
        return this.schoolId;
    }
    public void setSchoolId(Integer schoolId) {
        this.schoolId = schoolId;
    }



}

model.second

package com.kintech.test1.model.second;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;


@Entity
@Table(name="company"
        ,catalog="logisoft.dbo"
)
@Data
@AllArgsConstructor
@NoArgsConstructor
public class HK_GicaCompany implements java.io.Serializable {
    private String logi_company_id;
    @Id
    private String company_code;
    private String key_code;
    private String short_name;
    private String long_name;

}

Dao创建

增删改，记得加上@Transactional  （dao还需要@Modifying）

dao.first

package com.kintech.test1.dao.first;

import com.kintech.test1.model.first.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserTestDao extends JpaRepository<User,Integer> {
}

dao.second

package com.kintech.test1.dao.second;

import com.kintech.test1.model.second.HK_GicaCompany;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Repository
public interface HK_GicaCompanyDao extends JpaRepository<HK_GicaCompany,String> {

    @Transactional(readOnly = true)
    @Query(value = "select top 10 * from company where status='Y' "
            ,nativeQuery = true)
    List<HK_GicaCompany> get10();
}

五 测试


import com.kintech.test1.dao.first.UserTestDao;
import com.kintech.test1.dao.second.HK_GicaCompanyDao;
import com.kintech.test1.model.first.User;
import com.kintech.test1.model.second.HK_GicaCompany;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;


/**
 * @author Tyler
 * @date 2022/7/7
 */


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:spring/applicationContext.xml"})
public class TylerTest {
    @Autowired
    UserTestDao userDao;
    @Autowired
    HK_GicaCompanyDao hk_gicaCompanyDao;

    @Test
    public void test1() throws Exception {
        List<User> userList= userDao.findAll();
        System.out.println("mysql user表 : "+ userList.size());
        List<HK_GicaCompany> list = hk_gicaCompanyDao.get10();
        System.out.println("sqlserver company表 : "+ list.size());
    }
}

结果：

正怒月神
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
【Spring】SpringMVC整合JPA
简约人生的博客
05-09 2万+
这篇文章是在SpringMVC的基础上对数据持久层JPA的整合，实现了应用层和数据库的数据交互。在整合JPA前，请先参照下面第一篇博文搭建好SpringMVC框架。一. 和本篇博文相关的一些基础知识请参考下面几篇博文： SpringMVC框架的搭建和配置详解请参考：http://blog.csdn.net/jianyuerensheng/article/details/51258942。 JPA的O
springmvc多数据源连接
11-06
spring，springmvc动态数据库的连接，该代码是以oracle数据库为例，动态的切换数据库。
Spring MVC的多数据库连接
weixin_46141446的博客
05-07 1248
首先，这个东西我找了好多文章，怕忘记，现在做出总结 我们先搭建一个Spring MVC项目 我用的是IDEA工具，搭建的时候使用的是Maven框架，就是我选中这个 下一步就好了，第一个是名字，第二个是存放的路径 ...
springmvc配置shardingsphere，多数据源
最新发布
weixin_40086375的博客
04-25 1424
网上搜索shardingsphere配置教程，绝大部分都是使用springboot来配置，但是在springmvc架构中配置很少，唯一看到的一个篇章需要收费，便通过官方文档以及查询相关资料，终于完成了该篇文章。注意：在该文章中，使用了多数据源配置，因为不是所有表都需要分表，由于shardingsphere对部分sql语法不支持，为了不影响不分表的sql能正常执行，减少代码修改，在执行sql时切换数据源。该配置文件包含分库分表数据源配置，分库分表策略规则。
玩转spring mvc(四)---在spring MVC中整合JPA
weixin_30530939的博客
02-05 115
关于在Spring MVC中整合JPA是在我的上一篇关于spring mvc基本配置基础上进行的，所以大家先参考一下我的上一篇文章：http://blog.csdn.net/u012116457/article/details/43528111 接下来是需要新添加的一些文件： jdbc.properties： jdbc.driverClassName=com.mysql.jd...
SpringMVC配置多个数据源
weixin_45338060的博客
04-22 1658
多数据源，说白了，就是多数据库。 想要实现多数据库查询，只需简单四步即可实现！ 但这种实现方式有缺点，不能够实时切换数据库。有时间我会补一篇，通过AOP实现数据库切换的博客，通过aop+注解实现比较好。 第一步：配置 jdbc.properties； 1 # MySQL 2 #============================================================================ 3 jdbc.mysql.driver=com.mysql..
spring3+springmvc+jpa+hibernate多数据源
03-21
"spring3+springmvc+jpa+hibernate多数据源"是一个示例项目，它演示了如何在一个应用中集成Spring 3、Spring MVC、JPA 2.0以及Hibernate，以实现对多个数据源的支持。下面将详细介绍这些技术及其集成的关键点。 **...
SpringMVC配置多数据源实战
01-09
在SpringMVC框架中配置多数据源是一项常见的需求，尤其在大型企业级应用中，由于业务的复杂性，往往需要连接不同的数据库以满足不同模块的需求。以下将详细讲解如何实现这一功能。 首先，理解数据源（DataSource）...
详解基于Spring Boot与Spring Data JPA的多数据源配置
08-30
基于Spring Boot与Spring Data JPA的多数据源配置 Spring Boot作为当前最流行的Java Web框架之一，提供了许多实用的功能和配置项，然而，在实际项目中，我们经常会遇到多数据源配置的问题，例如在一个项目中需要...
springmvc +shiro+querydsl+jpa框架多数据源配置详细说明
06-01
Spring MVC + Shiro + QueryDSL + JPA 框架多数据源配置详细说明 Spring MVC + Shiro + QueryDSL + JPA 框架多数据源配置是当前 Web 应用程序中常见的技术栈组合。该技术栈组合可以提供强大的安全认证、数据查询和...
spring springmvc jpa配置文件
02-28
总结来说，配置Spring、Spring MVC和JPA涉及多个XML文件，包括Spring的bean定义、Spring MVC的调度配置以及JPA的数据源和实体配置。理解并正确配置这些元素对于构建基于Java的Web应用至关重要，因为它们定义了组件...
Spring MVC配置双数据源实现一个java项目同时连接两个数据库的方法
08-30
主要给大家介绍了关于Spring MVC如何配置双数据源实现一个java项目同时连接两个数据库的相关资料，文中通过示例代码介绍的非常详细，对大家具有一定的参考学习价值，需要的朋友们下面来一起看看吧。
SpringMVC实现数据库连接--jdbcTemplate
04-03
主要使用Spring MVC框架，实现jdbcTemplate核心组件，利用注解，实现与数据库的连接
springMVC、spring、jpa、springData整合
12-25
spring4.1.0已经正式发布了，整合一下使用spring mvc和springData和jpa的使用。 内含有详细的注释解释和完整的JAR包资源，导入工程即可使用，方便学习。
Spring Boot+Jpa多数据源配置Demo（支持不同数据库）
04-11
Spring Boot+Jpa多数据源配置Demo，可同时支持多种数据库，不同数据库，同时支持不同数据库的JdbcTemplate
spring springmvc jpa整合
liu289747235的专栏
01-01 609
github：https://github.com/leelun/ssjpa.git 1 配置项目需要依赖包（pom.xml） &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http...
springMvc中配置多个数据源
weixin_30263277的博客
07-24 449
首先声明，我采用的是myBatis连接的数据库哈 1. 我们需要在配置数据库相关信息, 如果有多个数据库，复制一份下面的配置，修改DBPool1 名字和driver-url ，user, password jdbc-mysql.proxool.alias=DBPool1 jdbc-mysql.proxool.driver-class=com.mysql.jdbc.Driver jdbc...
Spring SpringMVC JPA整合配置
metjoyful的博客
09-26 4456
1. 三大框架 ssh struts spring hibernate Struts2 Spring Hibernate ssm(目前最流行的框架) SpringMVC Spring MyBatis ssj(Spring springMvc jpa) Struts2 Spring JPA(过时) SpringMVC Spring JPA（今天集成的框架） SpringMVC Spri...
springmvc动态数据源
08-18
对于在Spring MVC中实现动态数据源的需求，你可以使用Spring框架提供的AbstractRoutingDataSource类来实现。 首先，你需要创建一个继承自AbstractRoutingDataSource的类，例如DynamicDataSource。在DynamicDataSource中，你可以重写determineCurrentLookupKey()方法，根据需要的数据源标识动态地选择对应的数据源。 下面是一个简单的示例： ```java public class DynamicDataSource extends AbstractRoutingDataSource { @Override protected Object determineCurrentLookupKey() { // 根据需要的数据源标识，返回对应的数据源名称 // 例如使用ThreadLocal来保存数据源标识 return DataSourceContextHolder.getDataSource(); } } ``` 然后，在Spring配置文件中，你需要配置DynamicDataSource作为数据源，并设置其目标数据源。 ```xml <bean id="dataSource" class="com.example.DynamicDataSource"> <property name="targetDataSources"> <map> <!-- 配置多个数据源 --> <entry key="dataSource1" value-ref="dataSource1"/> <entry key="dataSource2" value-ref="dataSource2"/> </map> </property> <property name="defaultTargetDataSource" ref="dataSource1"/> </bean> ``` 最后，你可以在代码中通过调用DataSourceContextHolder.setDataSource("dataSource1")来切换数据源。这里的"dataSource1"是你配置的数据源标识。 这样，当你在Spring MVC中进行数据库操作时，AbstractRoutingDataSource会根据当前线程中保存的数据源标识选择对应的数据源进行操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值