`

JPA 配置多数据源

 
阅读更多

1. META-INF/persistence.xml

 

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd" version="2.0">
  <persistence-unit name="localdb" transaction-type="RESOURCE_LOCAL">
      <provider>org.hibernate.ejb.HibernatePersistence</provider>
      <properties>
         <property name="hibernate.dialect" value="org.hibernate.dialect.SQLServerDialect"/>
         <property name="hibernate.connection.driver_class" value="net.sourceforge.jtds.jdbc.Driver"/>
         <property name="hibernate.connection.username" value="sa"/>
         <property name="hibernate.connection.password" value="123"/>
         <property name="hibernate.connection.url" value="jdbc:jtds:sqlserver://localhost:1433/CollectionDB;instance="/>
         <property name="hibernate.max_fetch_depth" value="3"/>
         <property name="hibernate.format_sql" value="false" />
         <property name="hibernate.hbm2ddl.auto" value="none"/>
         <property name="javax.persistence.validation.mode" value="none"/>
         <!-- validate -->
      </properties>     
  </persistence-unit>
  <persistence-unit name="remotedb" transaction-type="RESOURCE_LOCAL">
      <provider>org.hibernate.ejb.HibernatePersistence</provider>
      <properties>
         <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/>
         <property name="hibernate.connection.driver_class" value="org.gjt.mm.mysql.Driver"/>
         <property name="hibernate.connection.username" value="root"/>
         <property name="hibernate.connection.password" value="123"/>
         <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/futures?useUnicode=true&amp;characterEncoding=UTF-8"/>
         <property name="hibernate.max_fetch_depth" value="3"/>
         <property name="hibernate.format_sql" value="false" />
         <property name="hibernate.hbm2ddl.auto" value="none"/>
         <property name="javax.persistence.validation.mode" value="none"/>
      </properties>
  </persistence-unit>
</persistence>

 

2. spring-jpa-hibernate.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:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-3.2.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
	http://www.springframework.org/schema/tx
	http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">

	<!-- scan all beans and inject dependence -->
	<context:component-scan base-package="com.myproject" />
	<bean id="defaultPersistenceUnitManager"
		class="org.springframework.orm.jpa.persistenceunit.DefaultPersistenceUnitManager">
		<property name="persistenceXmlLocation" value="classpath:META-INF/persistence.xml" />
		<!-- comment dataSourceLooup to use jndi -->
		<property name="dataSourceLookup">
			<bean
				class="org.springframework.jdbc.datasource.lookup.BeanFactoryDataSourceLookup" />
		</property>
	</bean>
	
	<!-- 整合localjpa -->
	<bean id="localEntityManagerFactory"
		class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="persistenceUnitManager" ref="defaultPersistenceUnitManager"></property>
		<property name="persistenceUnitName" value="localdb"></property>
		<property name="jpaVendorAdapter">
			<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
				<property name="showSql" value="false"></property>
				<property name="database" value="SQL_SERVER"></property>
			</bean>
		</property>
	</bean>
	<bean id="localtransactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="localEntityManagerFactory" />
		<qualifier value="localEM" />
	</bean>
	<tx:annotation-driven transaction-manager="localtransactionManager"
		proxy-target-class="false" />
	
	<!-- 整合remotejpa -->
	<bean id="remoteEntityManagerFactory"
		class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="persistenceUnitManager" ref="defaultPersistenceUnitManager"></property>
		<property name="persistenceUnitName" value="remotedb"></property>
		<property name="jpaVendorAdapter">
			<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
				<property name="showSql" value="false"></property>
				<property name="database" value="MYSQL"></property>
			</bean>
		</property>
	</bean>
	<bean id="remotetransactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="remoteEntityManagerFactory" />
		<qualifier value="remoteEM" />
	</bean>
	<tx:annotation-driven transaction-manager="remotetransactionManager"
		proxy-target-class="false" />
</beans>

 

 

3. StockAccountEntity.java

package com.myproject.example.vo;

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

@Entity
@Table(name = "stockaccount", schema = "")
@SuppressWarnings("serial")

public class StockAccountEntity implements java.io.Serializable {
	@Id
	@Column(name ="ID",nullable=false,length=40)
	private java.lang.String id;
	
	@Column(name ="USERNAME",nullable=true,length=40)
	private java.lang.String username;
	

	public java.lang.String getId(){
		return this.id;
	}


	public void setId(java.lang.String id){
		this.id = id;
	}

	
	public java.lang.String getUsername(){
		return this.username;
	}


	public void setUsername(java.lang.String username){
		this.username = username;
	}
}

 

 

 

4. StockAccountDao.java

package com.myproject.example.dao;

import java.util.List;

import com.myproject.example.dao.common.MyCriteriaBuilder;
import com.myproject.example.vo.StockAccountEntity;

public interface StockAccountDao {
	public List<StockAccountEntity> query(MyCriteriaBuilder cb, int maxResult);
	
	public void update(StockAccountEntity entity);
	
	public void insert(StockAccountEntity entity);
	
	public void delete(StockAccountEntity entity);

	public StockAccountEntity queryById(int id);
}

 

5.StockAccountDaoBean.java

package com.myproject.example.dao.jpa;

import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

import org.springframework.stereotype.Repository;

import com.myproject.example.dao.StockAccountDao;
import com.myproject.example.dao.common.MyCriteriaBuilder;
import com.myproject.example.vo.StockAccountEntity;


@Repository
public class StockAccountDaoBean implements StockAccountDao{
	
	@PersistenceContext(unitName="localdb")
	EntityManager em;
	
	@Override
	public List query(MyCriteriaBuilder cb, int maxResult) {
		String hql = "select a from StockAccountEntity a" + cb.getCriteriaString();
		Query q = em.createQuery(hql);
		for(String key : cb.getCriteriaParams().keySet()){
			q.setParameter(key, cb.getCriteriaParams().get(key));
		}
		if(maxResult!=0) 
			q.setMaxResults(maxResult);
		return q.getResultList();
	}
	
	@Override
	public void update(StockAccountEntity entity) {
		em.merge(entity);
	}
	
	@Override
	public void insert(StockAccountEntity entity) {
		em.persist(entity);
	}
	
	@Override
	public void delete(StockAccountEntity entity) {
		em.remove(entity);
	}

	@Override
	public StockAccountEntity queryById(int id) {
		return em.find(StockAccountEntity.class, id);
	}
}

 

6.StockAccountService.java

package com.myproject.example.service;

import java.util.Date;
import java.util.List;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.myproject.example.dao.StockCashFlowDao;
import com.myproject.example.dao.common.MyCriteria;
import com.myproject.example.dao.common.MyCriteriaBuilder;
import com.myproject.example.vo.StockCashFlowEntity;

@Service
@Transactional(value="localEM")
public class StockAccountService {

	@Resource
	private StockAccountDao stockAccountDaoBean; 
	
	public List<StockAccountEntity> queryByTradecodeTradedate(String tradeCode, Date lastTradeDate, Date tradeDate){
		MyCriteriaBuilder accountCB = new MyCriteriaBuilder();
		cashFlowCB.put(MyCriteria.Type_Equil, "tradecode", tradeCode);
		cashFlowCB.put(MyCriteria.Type_Bigger, "tradedate", "tradedate1", lastTradeDate);
		cashFlowCB.put(MyCriteria.Type_SmallerEquil, "tradedate", "tradedate2", tradeDate);
		List<StockAccountEntity> cashFlowList =  stockAccountDaoBean.query(accountCB, 0);
		return accountList;
	}
}

 

 

分享到：
| Mysql 导入导出数据库
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    springboot+jpa配置多数据源.zip

    首先，`springboot+jpa配置多数据源.zip`这个压缩包可能包含了一个示例项目，用于演示如何在Spring Boot中集成JPA并配置多个数据源。JPA是Java平台上的ORM（Object-Relational Mapping）标准，它简化了与关系型...

    Spring Boot使用spring-data-jpa配置Mysql多数据源

    在Spring Boot应用中，使用`spring-data-jpa`来配置MySQL多数据源是一项常见的需求，尤其是在构建大型分布式系统时，为了实现数据隔离、负载均衡或读写分离等目的。本教程将详细介绍如何在Spring Boot项目中配置多个...

    Spring Boot+Jpa多数据源配置Demo（支持不同数据库）

    Spring Boot结合JPA（Java Persistence API）和JdbcTemplate，为开发者提供了灵活且强大的多数据源配置能力。本示例将详细介绍如何在Spring Boot项目中实现这样的配置，以支持不同类型的数据库。 首先，我们要理解...

    springmvc +shiro+querydsl+jpa框架多数据源配置详细说明

    在 hopsuncms\WebRoot\WEB-INF\conf\custom-component.xml 文件中配置数据源信息。该文件用于存储数据源信息，如数据源名称、驱动程序等。配置示例如下： ``` ${database.url}"/&gt; ${database.username}"/&gt; ${...

    使用springboot + JPA / MyBatis 实现多数据源动态切换

    本教程将详细讲解如何使用Spring Boot结合JPA或MyBatis框架实现多数据源的动态切换。 **一、Spring Boot与JPA** 1. **Spring Boot简介**：Spring Boot是Spring Framework的一个模块，旨在简化Spring应用的初始搭建...

    springBoot Jpa多数据源配置.rar

    在Spring Boot中，我们可以使用`DataSource` bean来配置数据源。 对于多数据源配置，我们需要创建至少两个`DataSource` bean，每个对应一个不同的数据库。通常，我们会为每个数据源创建一个配置类，例如`...

    spring3+springmvc+jpa+hibernate多数据源

    "spring3+springmvc+jpa+hibernate多数据源"是一个示例项目，它演示了如何在一个应用中集成Spring 3、Spring MVC、JPA 2.0以及Hibernate，以实现对多个数据源的支持。下面将详细介绍这些技术及其集成的关键点。 **...

    各种数据源配置之Spring+JPA配置BoneCP数据源

    总结起来，配置Spring+JPA与BoneCP数据源涉及的关键知识点包括：Spring框架、JPA、BoneCP连接池、数据库驱动、依赖管理、Spring配置、实体类、Repository接口以及Spring Boot的启动配置。理解并熟练掌握这些知识点，...

    springboot+JPA 多数据源配置

    通过以上步骤，你就可以在Spring Boot项目中成功配置并使用JPA进行多数据源操作了。这种方式允许你灵活地管理不同数据库的数据，对于复杂的分布式系统和多租户应用特别有用。在实际开发中，还可能需要考虑数据源的...

    SpringBoot操作多数据源（JPA+JdbcTemplate）

    在Spring Boot中配置多数据源，我们需要创建两个或更多的数据源配置，每个数据源对应一个数据库。以下是一个基本的配置示例： ```yaml spring: datasource: primary: url: jdbc:mysql://localhost:3306/db1 ...

    springboot 配置多数据源

    2. **配置数据源** 在`application.yml`或`application.properties`文件中，为每个数据源创建单独的配置，例如两个数据源`db1`和`db2`： ```yaml spring: datasource: db1: url: jdbc:mysql://localhost:3306...

    springboot-多数据源配置 -mybatis-jpa

    在Spring Boot应用中，多...接下来，我们要配置数据源事务管理器。Spring Boot默认使用`DataSourceTransactionManager`，但我们需要为每个数据源创建一个实例： ```java @Bean(name = "primaryTransactionManager") ...

    SpringMVC配置多数据源实战

    在SpringMVC框架中配置多数据源是一项常见的需求，尤其在大型企业级应用中，由于业务的复杂性，往往需要连接不同的数据库以满足不同模块的需求。以下将详细讲解如何实现这一功能。 首先，理解数据源（DataSource）...

    详解基于Spring Boot与Spring Data JPA的多数据源配置

    在传统的单数据源配置中，我们通常使用Spring的Annotation在代码内部直接配置数据源，例如使用@Configuration和@Bean注解来配置数据源和实体管理工厂。以下是一个简单的单数据源配置代码： ```java @Configuration ...

    MongoDB 配置多数据源

    // 类似地配置数据源2 } ``` 这样，我们就可以在不同的Repository中使用`@Autowired`的`MongoTemplate`来操作不同的数据源了。例如，`DataSource1Repo`和`DataSource2Repo`可以分别处理`datasource1`和`datasource...

    SpringBoot+JPA+JTA(可选)+JdbcTemplate多数据源配置源码

    本资源包含了两个子项目，分别进行了springboot+jpa+jdbcTemplate的多数据源独立事务配置和jta分布式事务配置，并针对不同的情况编写了事务配置测试接口，还演示了JPA的domain一对多自动生成数据库表且不生成数据库...

    springboot+mysql+jpa多数据源操作源码

    本项目"springboot+mysql+jpa多数据源操作源码"旨在提供一个示例，帮助开发者了解如何在Spring Boot环境中配置和管理多个数据源。 首先，我们需要理解Spring Boot的自动配置特性。Spring Boot通过`@...

    SpringBoot+gradle+mybatis多数据源动态配置

    本项目结合了SpringBoot、Gradle和MyBatis，旨在实现多数据源的动态配置，这对于处理多个数据库或者分库分表的场景尤其有用。以下是对这个项目的详细解析： **SpringBoot** SpringBoot是由Pivotal团队提供的全新...

    spring+jpa+atomikos多数据源

    2. 配置数据源：为每个数据库创建单独的数据源，如DataSource bean，分别配置连接信息（URL、用户名、密码等）。 3. 配置事务管理器：使用Atomikos的UserTransaction和TransactionManager，配置JTA事务管理器，以...

    springboot多数据源配置

    总之，Spring Boot的多数据源配置涉及多个层面，包括依赖管理、配置类、数据源对象创建、JPA实体管理工厂、事务管理器以及业务代码中的数据源选择。通过合理配置，我们可以轻松地实现对多个数据库的管理和操作。

Magicbox
Global site tag (gtag.js) - Google Analytics