Spring Boot JPA多数据源示例

转x33g5p2x  于2022-10-06 转载在 Spring  
字(24.4k)|赞(0)|评价(0)|浏览(997)

在本文中，我们将学习如何在一个典型的Spring Boot Web应用程序中配置多个数据源并连接到多个数据库。我们将使用Spring Boot 2.0.5、JPA、Hibernate 5、Thymeleaf和H2数据库来构建一个简单的Spring Boot多数据源Web应用。
我们知道，如果你有一个单一的数据库，Spring Boot的自动配置是开箱即用的，并通过其属性提供大量的定制选项。但如果你的应用要求对应用配置有更多的控制，你可以关闭特定的自动配置，自己配置组件。

在这篇文章中，我们将逐步学习如何在同一个应用程序中使用多个数据库。如果我们需要连接多个数据库，我们需要配置各种Spring Bean，如DataSources、TransactionManagers、EntityManagerFactoryBeans、DataSourceInitializers等，明确配置。

我们将建立什么？

我们将构建一个Spring Boot网络应用，其中security data被存储在一个数据库/模式中，order-related data被存储在另一个数据库/模式中。

让我们看看我们如何在Spring Boot中处理多个数据库，并使用基于Spring Data JPA的应用程序。

使用的工具和技术

  • Spring Boot - 2.0.5.RELEASE
  • JDK - 1.8或更高版本
  • Spring Framework - 5.0.9 RELEASE
  • Spring Data JPA - 2.0.10 RELEASE
  • Hibernate - 5.2.17.Final
  • Maven - 3.2+
  • JPA
  • H2
  • Thymeleaf
  • IDE Eclipse 或 Spring Tool Suite (STS)

创建和导入一个项目

有很多方法可以创建Spring Boot应用程序。最简单的方法是在http://start.spring.io/使用Spring Initializr，它是一个在线Spring Boot应用程序生成器。

看上面的图，我们指定了以下细节。

  • Generate: Maven项目
  • Java Version: 1.8 (默认)
  • Spring Boot:2.0.4
  • Group: net.guards.springboot
  • Artifact: springboot-multiple-datasources
  • Name: springboot-multiple-datasources
  • Description: 一个简单的用户管理应用的Rest API
  • Package Name : net.guards.springboot.springbootmultipledatasources
  • Packaging: jar (这是默认值)
  • Dependencies: Web, JPA, H2, DevTools
    一旦，所有的细节被输入，点击生成项目按钮将生成一个spring boot项目并下载。接下来，解压下载的压缩文件并将其导入你最喜欢的IDE。

项目结构

以下是项目结构 -

pom.xml文件

  1. <?xmlversion="1.0"encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>net.guides.springboot</groupId>
  8.     <artifactId>springboot-multiple-datasources</artifactId>
  9.     <version>0.0.1-SNAPSHOT</version>
  10.     <packaging>jar</packaging>
  12.     <name>springboot-multiple-datasources</name>
  13.     <description>Demo project for Spring Boot</description>
  15.     <parent>
  16.         <groupId>org.springframework.boot</groupId>
  17.         <artifactId>spring-boot-starter-parent</artifactId>
  18.         <version>2.0.5.RELEASE</version>
  19.         <relativePath /> <!-- lookup parent from repository -->
  20.     </parent>
  22.     <properties>
  23.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  24.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  25.         <java.version>1.8</java.version>
  26.     </properties>
  28.     <dependencies>
  29.         <dependency>
  30.             <groupId>org.springframework.boot</groupId>
  31.             <artifactId>spring-boot-starter-test</artifactId>
  32.             <scope>test</scope>
  33.         </dependency>
  34.         <dependency>
  35.             <groupId>org.springframework.boot</groupId>
  36.             <artifactId>spring-boot-devtools</artifactId>
  37.             <optional>true</optional>
  38.         </dependency>
  39.         <dependency>
  40.             <groupId>org.springframework.boot</groupId>
  41.             <artifactId>spring-boot-configuration-processor</artifactId>
  42.             <optional>true</optional>
  43.         </dependency>
  44.         <dependency>
  45.             <groupId>org.springframework.boot</groupId>
  46.             <artifactId>spring-boot-starter-data-jpa</artifactId>   
  47.         </dependency>
  48.         <dependency>
  49.             <groupId>org.springframework.boot</groupId>
  50.             <artifactId>spring-boot-starter-web</artifactId>
  51.         </dependency>
  52.         <dependency>
  53.             <groupId>org.springframework.boot</groupId>
  54.             <artifactId>spring-boot-starter-thymeleaf</artifactId>   
  55.         </dependency> 
  56.         <dependency>
  57.             <groupId>mysql</groupId>
  58.             <artifactId>mysql-connector-java</artifactId>
  59.         </dependency>
  60.         <dependency>
  61.             <groupId>com.h2database</groupId>
  62.             <artifactId>h2</artifactId>
  63.         </dependency>
  64.         </dependencies>
  66.        <build>
  67.            <plugins>
  68.                <plugin>
  69.                    <groupId>org.springframework.boot</groupId>
  70.                    <artifactId>spring-boot-maven-plugin</artifactId>
  71.                </plugin>
  72.            </plugins>
  73.        </build>
  74.    </project>

确保我们在classpath上有JPA、Thymeleaf 和H2启动器。
接下来的步骤非常重要，请看一下。

排除自动配置类

让我们关闭DataSource/JPA的自动配置功能。由于我们要明确配置数据库相关的bean，我们将通过排除AutoConfiguration类来关闭DataSource/JPA的自动配置。

  1. package net.guides.springboot.springbootmultipledatasources;
  3. import org.springframework.boot.SpringApplication;
  5. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
  7. import org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration;
  8. import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration;
  9. import org.springframework.transaction.annotation.EnableTransactionManagement;
  11. @SpringBootApplication(
  12.   exclude = { DataSourceAutoConfiguration.class, 
  13.      HibernateJpaAutoConfiguration.class,
  14.      DataSourceTransactionManagerAutoConfiguration.class })
  15. @EnableTransactionManagement
  16. public class SpringbootMultipleDatasourcesApplication {
  18.     public static void main(String[] args) {
  19.         SpringApplication.run(SpringbootMultipleDatasourcesApplication.class, args);
  20.     }
  21. }

一旦我们关闭了自动配置，我们就需要通过使用@EnableTransactionManagement注解来明确启用TransactionManagement。

配置多个数据源属性

H2数据库配置

让我们来配置H2数据源属性。在application.properties文件中配置安全和订单的数据库连接参数.

  1. debug=true
  3. datasource.security.driver-class-name=org.h2.Driver
  4. datasource.security.url=jdbc:h2:mem:securitydb;DB_CLOSE_DELAY=-1
  5. datasource.security.username=sa
  6. datasource.security.password=
  8. datasource.security.initialize=true
  10. datasource.orders.driver-class-name=org.h2.Driver
  11. datasource.orders.url=jdbc:h2:mem:ordersdb;DB_CLOSE_DELAY=-1
  12. datasource.orders.username=sa
  13. datasource.orders.password=
  15. datasource.orders.initialize=true
  17. spring.jpa.hibernate.ddl-auto=update
  18. spring.jpa.show-sql=true

MySQL数据库配置

我们使用H2数据库来快速建立应用程序，但你也可以在application.properties文件中替换以下配置来使用MySQL数据库进行生产。

注意，我们使用了自定义属性键来配置两个数据源属性。
在下一步，我们将创建一个与安全相关的JPA实体和一个JPA资源库。

创建JPA实体--用户和地址

  1. /**
  2. * 
  3. */
  4. package net.guides.springboot.springbootmultipledatasources.security.entities;
  6. import java.util.Set;
  8. import javax.persistence.Column;
  9. import javax.persistence.Entity;
  10. import javax.persistence.GeneratedValue;
  11. import javax.persistence.GenerationType;
  12. import javax.persistence.Id;
  13. import javax.persistence.OneToMany;
  14. import javax.persistence.Table;
  16. /**
  17. * @author Ramesh Fadatare
  18. *
  19. */
  20. @Entity
  21. @Table(name="USERS")
  22. public class User
  23. {
  24.     @Id @GeneratedValue(strategy=GenerationType.AUTO)
  25.     private Integer id;
  26.     @Column(nullable=false)
  27.     private String name;
  28.     @Column(nullable=false, unique=true)
  29.     private String email;
  30.     private boolean disabled;
  31.     @OneToMany(mappedBy="user")
  32.     private Set<Address> addresses;
  33.  
  34.     public User()
  35.     {
  36.     }
  38.     public User(Integer id, String name, String email)
  39.     {
  40.         this.id = id;
  41.         this.name = name;
  42.         this.email = email;
  43.     }
  44.     public User(Integer id, String name, String email, boolean disabled)
  45.     {
  46.         this.id = id;
  47.         this.name = name;
  48.         this.email = email;
  49.         this.disabled = disabled;
  50.      }
  51.     public Integer getId()
  52.     {
  53.         return id;
  54.     }
  56.     public void setId(Integer id)
  57.     {
  58.         this.id = id;
  59.     }
  61.     public String getName()
  62.     {
  63.         return name;
  64.     }
  66.     public void setName(String name)
  67.     {
  68.         this.name = name;
  69.     }
  71.     public String getEmail()
  72.     {
  73.         return email;
  74.     }
  76.     public void setEmail(String email)
  77.     {
  78.         this.email = email;
  79.     }
  81.     public boolean isDisabled()
  82.     {
  83.         return disabled;
  84.     }
  86.     public void setDisabled(boolean disabled)
  87.     {
  88.         this.disabled = disabled;
  89.     }
  91.     public Set<Address> getAddresses()
  92.     {
  93.         return addresses;
  94.     }
  96.     public void setAddresses(Set<Address> addresses)
  97.     {
  98.          this.addresses = addresses;
  99.     } 
  100. }

Address.java

  1. package net.guides.springboot.springbootmultipledatasources.security.entities;
  3. import javax.persistence.Column;
  4. import javax.persistence.Entity;
  5. import javax.persistence.GeneratedValue;
  6. import javax.persistence.GenerationType;
  7. import javax.persistence.Id;
  8. import javax.persistence.JoinColumn;
  9. import javax.persistence.ManyToOne;
  10. import javax.persistence.Table;
  12. /**
  13. * @author Ramesh Fadatare
  14. *
  15. */
  16. @Entity
  17. @Table(name="ADDRESSES")
  18. public class Address
  19. {
  20.     @Id @GeneratedValue(strategy=GenerationType.AUTO)
  21.     private Integer id;
  22.     @Column(nullable=false)
  23.     private String city;
  24.     @ManyToOne
  25.     @JoinColumn(name="user_id")
  26.     private User user;
  27.  
  28.     public Integer getId()
  29.     {
  30.         return id;
  31.     }
  32.     public void setId(Integer id)
  33.     {
  34.         this.id = id;
  35.     }
  36.     public String getCity()
  37.     {
  38.         return city;
  39.     }
  40.     public void setCity(String city)
  41.     {
  42.         this.city = city;
  43.     }
  44.     public User getUser()
  45.     {
  46.         return user;
  47.     }
  48.     public void setUser(User user)
  49.     {
  50.         this.user = user;
  51.     } 
  52. }

Spring JPA存储库 - UserRepository.java

  1. /**
  2. * 
  3. */
  4. package net.guides.springboot.springbootmultipledatasources.security.repositories;
  6. import org.springframework.data.jpa.repository.JpaRepository;
  9. import net.guides.springboot.springbootmultipledatasources.security.entities.User;
  11. /**
  12. * @author Ramesh Fadatare
  13. *
  14. */
  15. public interface UserRepository extends JpaRepository<User, Integer>
  16. {
  17.  
  18. }

创建JPA实体--Order和OrderItem

  1. /**
  2. * 
  3. */
  4. package net.guides.springboot.springbootmultipledatasources.orders.entities;
  6. import java.util.Set;
  9. import javax.persistence.Column;
  10. import javax.persistence.Entity;
  11. import javax.persistence.GeneratedValue;
  12. import javax.persistence.GenerationType;
  13. import javax.persistence.Id;
  14. import javax.persistence.OneToMany;
  15. import javax.persistence.Table;
  17. /**
  18. * @author Ramesh Fadatare
  19. *
  20. */
  21. @Entity
  22. @Table(name="ORDERS")
  23. public class Order
  24. {
  25.     @Id @GeneratedValue(strategy=GenerationType.AUTO)
  26.     private Integer id;
  27.     @Column(nullable=false, name="cust_name")
  28.     private String customerName;
  29.     @Column(nullable=false, name="cust_email")
  30.     private String customerEmail;
  31.  
  32.     @OneToMany(mappedBy="order")
  33.     private Set<OrderItem> orderItems;
  34.  
  35.     public Integer getId() {
  36.         return id;
  37.     }
  38.     public void setId(Integer id) {
  39.         this.id = id;
  40.     }
  41.     public String getCustomerName() {
  42.         return customerName;
  43.     }
  44.     public void setCustomerName(String customerName) {
  45.         this.customerName = customerName;
  46.     }
  47.     public String getCustomerEmail() {
  48.         return customerEmail;
  49.     }
  50.     public void setCustomerEmail(String customerEmail) {
  51.         this.customerEmail = customerEmail;
  52.     }
  53.     public Set<OrderItem> getOrderItems()
  54.     {
  55.         return orderItems;
  56.     }
  57.     public void setOrderItems(Set<OrderItem> orderItems)
  58.     {
  59.         this.orderItems = orderItems;
  60.     }
  61. }

OrderItem.java

  1. package net.guides.springboot.springbootmultipledatasources.orders.entities;
  3. import javax.persistence.Entity;
  4. import javax.persistence.GeneratedValue;
  5. import javax.persistence.GenerationType;
  6. import javax.persistence.Id;
  7. import javax.persistence.JoinColumn;
  8. import javax.persistence.ManyToOne;
  9. import javax.persistence.Table;
  11. /**
  12. * @author Ramesh Fadatare
  13. *
  14. */
  15. @Entity
  16. @Table(name="ORDER_ITEMS")
  17. public class OrderItem
  18. {
  19.     @Id @GeneratedValue(strategy=GenerationType.AUTO)
  20.     private Integer id;
  21.     private String productCode;
  22.     private int quantity;
  23.     @ManyToOne
  24.     @JoinColumn(name="order_id")
  25.     private Order order;
  26.  
  27.     public Integer getId()
  28.     {
  29.         return id;
  30.     }
  31.     public void setId(Integer id)
  32.     {
  33.         this.id = id;
  34.     }
  35.     public String getProductCode()
  36.     {
  37.         return productCode;
  38.     }
  39.     public void setProductCode(String productCode)
  40.     {
  41.         this.productCode = productCode;
  42.     }
  43.     public int getQuantity()
  44.     {
  45.         return quantity;
  46.     }
  47.     public void setQuantity(int quantity)
  48.     {
  49.         this.quantity = quantity;
  50.     }
  51.     public Order getOrder()
  52.     {
  53.         return order;
  54.     }
  55.     public void setOrder(Order order)
  56.     {
  57.         this.order = order;
  58.     } 
  59. }

Spring JPA Repository - OrderRepository.java

  1. /**
  2. * 
  3. */
  4. package net.guides.springboot.springbootmultipledatasources.orders.repositories;
  6. import org.springframework.data.jpa.repository.JpaRepository;
  8. import net.guides.springboot.springbootmultipledatasources.orders.entities.Order;
  10. /**
  11. * @author Ramesh Fadatare
  12. *
  13. */
  14. public interface OrderRepository extends JpaRepository<Order, Integer>{
  16. }

初始化样本数据 - security-data.sql脚本

创建SQL脚本来初始化样本数据。在src/main/resources文件夹中创建security-data.sql脚本，用样本数据初始化USERS表。

  1. delete from addresses;
  2. delete from users;
  4. insert into users(id, name, email,disabled) values(1,'John Cena','john@gmail.com', false);
  5. insert into users(id, name, email,disabled) values(2,'Salman Khan','salman@gmail.com', false);
  6. insert into users(id, name, email,disabled) values(3,'Amitr Khan','amir@gmail.com', true);
  8. insert into addresses(id,city,user_id) values(1, 'Pune',1);
  9. insert into addresses(id,city,user_id) values(2, 'Landon',1);
  10. insert into addresses(id,city,user_id) values(3, 'Newyork',2);
  11. insert into addresses(id,city,user_id) values(4, 'Mumbai',3);
  12. insert into addresses(id,city,user_id) values(6, 'Washington',3);

初始化样本数据 - orders-data.sql脚本

在src/main/resources文件夹中创建orders-data.sql脚本，用样本数据初始化ORDERS表。

  1. delete from order_items;
  2. delete from orders;
  4. insert into orders(id, cust_name, cust_email) values(1,'John Cena','john@gmail.com');
  5. insert into orders(id, cust_name, cust_email) values(2,'Salman Khan','salman@gmail.com');
  6. insert into orders(id, cust_name, cust_email) values(3,'Amir Khan','amir@gmail.com');
  8. insert into order_items(id, productcode,quantity,order_id) values(1,'order item1', 2, 1);
  9. insert into order_items(id, productcode,quantity,order_id) values(2,'order item2', 1, 1);
  10. insert into order_items(id, productcode,quantity,order_id) values(3,'order item3', 5, 1);
  11. insert into order_items(id, productcode,quantity,order_id) values(4,'order item4', 2, 2);
  12. insert into order_items(id, productcode,quantity,order_id) values(5,'order item5', 1, 2);

创建安全数据源配置 - SecurityDataSourceConfig.java

创建SecurityDataSourceConfig.java配置类。我们将通过连接SecurityDataSourceConfig.java中的安全数据库来配置Spring Bean，如DataSource、TransactionManager、EntityManagerFactoryBean和DataSourceInitializer。

  1. package net.guides.springboot.springbootmultipledatasources.config;
  3. import java.util.Properties;
  5. import javax.persistence.EntityManagerFactory;
  6. import javax.sql.DataSource;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
  10. import org.springframework.boot.context.properties.ConfigurationProperties;
  11. import org.springframework.boot.jdbc.DataSourceBuilder;
  12. import org.springframework.context.annotation.Bean;
  13. import org.springframework.context.annotation.Configuration;
  14. import org.springframework.core.env.Environment;
  15. import org.springframework.core.io.ClassPathResource;
  16. import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
  17. import org.springframework.jdbc.datasource.init.DataSourceInitializer;
  18. import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator;
  19. import org.springframework.orm.jpa.JpaTransactionManager;
  20. import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
  21. import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
  22. import org.springframework.transaction.PlatformTransactionManager;
  24. /**
  25. * @author Ramesh Fadatare
  26. * 
  27. */
  28. @Configuration
  29. @EnableJpaRepositories(
  30.   basePackages = "net.guides.springboot.springbootmultipledatasources.security.repositories",
  31.         entityManagerFactoryRef = "securityEntityManagerFactory",
  32.         transactionManagerRef = "securityTransactionManager"
  33. )
  34. public class SecurityDataSourceConfig
  35. {
  36.        @Autowired
  37.        private Environment env;
  38.   
  39.        @Bean
  40.        @ConfigurationProperties(prefix="datasource.security")
  41.        public DataSourceProperties securityDataSourceProperties() {
  42.            return new DataSourceProperties();
  43.        }
  44.     
  45.        @Bean
  46.        public DataSource securityDataSource() {
  47.             DataSourceProperties securityDataSourceProperties = securityDataSourceProperties();
  48.             return DataSourceBuilder.create()
  49.            .driverClassName(securityDataSourceProperties.getDriverClassName())
  50.            .url(securityDataSourceProperties.getUrl())
  51.            .username(securityDataSourceProperties.getUsername())
  52.            .password(securityDataSourceProperties.getPassword())
  53.            .build();
  54.        }
  55.     
  56.        @Bean
  57.        public PlatformTransactionManager securityTransactionManager()
  58.        {
  59.            EntityManagerFactory factory = securityEntityManagerFactory().getObject();
  60.            return new JpaTransactionManager(factory);
  61.        }
  63.        @Bean
  64.        public LocalContainerEntityManagerFactoryBean securityEntityManagerFactory()
  65.        {
  66.            LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
  67.            factory.setDataSource(securityDataSource());
  68.            factory.setPackagesToScan(new String[]{"net.guides.springboot.springbootmultipledatasources.security.entities"});
  69.            factory.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
  70.         
  71.            Properties jpaProperties = new Properties();
  72.            jpaProperties.put("hibernate.hbm2ddl.auto", env.getProperty("spring.jpa.hibernate.ddl-auto"));
  73.            jpaProperties.put("hibernate.show-sql", env.getProperty("spring.jpa.show-sql"));
  74.            factory.setJpaProperties(jpaProperties);
  75.         
  76.            return factory;
  77.        }
  78.     
  79.        @Bean
  80.        public DataSourceInitializer securityDataSourceInitializer() 
  81.        {
  82.            DataSourceInitializer dataSourceInitializer = new DataSourceInitializer();
  83.            dataSourceInitializer.setDataSource(securityDataSource());
  84.            ResourceDatabasePopulator databasePopulator = new ResourceDatabasePopulator();
  85.            databasePopulator.addScript(new ClassPathResource("security-data.sql"));
  86.            dataSourceInitializer.setDatabasePopulator(databasePopulator);
  87.            dataSourceInitializer.setEnabled(env.getProperty("datasource.security.initialize", Boolean.class, false));
  88.            return dataSourceInitializer;
  89.        }   
  90. }

请注意，你已经通过使用@ConfigurationProperties(prefix="datasource.security")和DataSourceBuilder流畅的API来创建DataSource Bean，将datasource.security.* properties填充到DataSourceProperties中。

在创建LocalContainerEntityManagerFactoryBean Bean时，你已经配置了名为net.guides.springboot.springbootmultipledatasources.security.entities的包来扫描JPA实体。你已经配置了DataSourceInitializer Bean来初始化来自security-data.sql的样本数据。
最后，我们通过使用@EnableJpaRepositories注解来启用Spring Data JPA支持。由于我们将有多个EntityManagerFactory和TransactionManager豆，我们通过指向各自的豆名来配置entityManagerFactoryRef和transactionManagerRef的豆ID。我们还配置了basePackages属性，以指示在哪里寻找Spring Data JPA的仓库（包）。

创建安全数据源配置 - OrdersDataSourceConfig.java

创建OrdersDataSourceConfig.java配置类。与SecurityDataSourceConfig.java类似，你将创建OrdersDataSourceConfig.java，但将其指向订单数据库。

  1. package net.guides.springboot.springbootmultipledatasources.config;
  3. import java.util.Properties;
  5. import javax.persistence.EntityManagerFactory;
  6. import javax.sql.DataSource;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
  10. import org.springframework.boot.context.properties.ConfigurationProperties;
  11. import org.springframework.boot.jdbc.DataSourceBuilder;
  12. import org.springframework.context.annotation.Bean;
  13. import org.springframework.context.annotation.Configuration;
  14. import org.springframework.core.env.Environment;
  15. import org.springframework.core.io.ClassPathResource;
  16. import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
  17. import org.springframework.jdbc.datasource.init.DataSourceInitializer;
  18. import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator;
  19. import org.springframework.orm.jpa.JpaTransactionManager;
  20. import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
  21. import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
  22. import org.springframework.transaction.PlatformTransactionManager;
  24. /**
  25. * @author Ramesh Fadatare
  26. * 
  27. */
  28. @Configuration
  29. @EnableJpaRepositories(
  30.     basePackages = "net.guides.springboot.springbootmultipledatasources.orders.repositories",
  31.     entityManagerFactoryRef = "ordersEntityManagerFactory",
  32.     transactionManagerRef = "ordersTransactionManager"
  33. )
  34. public class OrdersDataSourceConfig {
  36.     @Autowired
  37.     private Environment env;
  39.     @Bean
  40.     @ConfigurationProperties(prefix = "datasource.orders")
  41.     public DataSourceProperties ordersDataSourceProperties() {
  42.         return new DataSourceProperties();
  43.     }
  45.     @Bean
  46.     public DataSource ordersDataSource() {
  47.         DataSourceProperties primaryDataSourceProperties = ordersDataSourceProperties();
  48.         return DataSourceBuilder.create()
  49.             .driverClassName(primaryDataSourceProperties.getDriverClassName())
  50.             .url(primaryDataSourceProperties.getUrl())
  51.             .username(primaryDataSourceProperties.getUsername())
  52.             .password(primaryDataSourceProperties.getPassword())
  53.             .build();
  54.     }
  56.     @Bean
  57.     public PlatformTransactionManager ordersTransactionManager() {
  58.         EntityManagerFactory factory = ordersEntityManagerFactory().getObject();
  59.         return new JpaTransactionManager(factory);
  60.     }
  62.     @Bean
  63.     public LocalContainerEntityManagerFactoryBean ordersEntityManagerFactory() {
  64.         LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
  65.         factory.setDataSource(ordersDataSource());
  66.         factory.setPackagesToScan(new String[] {
  67.             "net.guides.springboot.springbootmultipledatasources.orders.entities"
  68.         });
  69.         factory.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
  71.         Properties jpaProperties = new Properties();
  72.         jpaProperties.put("hibernate.hbm2ddl.auto", env.getProperty("spring.jpa.hibernate.ddl-auto"));
  73.         jpaProperties.put("hibernate.show-sql", env.getProperty("spring.jpa.show-sql"));
  74.         factory.setJpaProperties(jpaProperties);
  76.         return factory;
  78.     }
  80.     @Bean
  81.     public DataSourceInitializer ordersDataSourceInitializer() {
  82.         DataSourceInitializer dataSourceInitializer = new DataSourceInitializer();
  83.         dataSourceInitializer.setDataSource(ordersDataSource());
  84.         ResourceDatabasePopulator databasePopulator = new ResourceDatabasePopulator();
  85.         databasePopulator.addScript(new ClassPathResource("orders-data.sql"));
  86.         dataSourceInitializer.setDatabasePopulator(databasePopulator);
  87.         dataSourceInitializer.setEnabled(env.getProperty("datasource.orders.initialize", Boolean.class, false));
  88.         return dataSourceInitializer;
  89.     }
  90. }

创建UserOrdersService.java

  1. package net.guides.springboot.springbootmultipledatasources.services;
  3. import java.util.List;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Service;
  8. import org.springframework.transaction.annotation.Transactional;
  10. import net.guides.springboot.springbootmultipledatasources.orders.entities.Order;
  11. import net.guides.springboot.springbootmultipledatasources.orders.repositories.OrderRepository;
  12. import net.guides.springboot.springbootmultipledatasources.security.entities.User;
  13. import net.guides.springboot.springbootmultipledatasources.security.repositories.UserRepository;
  15. /**
  16. * @author Ramesh Fadatare
  17. *
  18. */
  19. @Service
  20. public class UserOrdersService
  21. {
  22.     @Autowired
  23.     private OrderRepository orderRepository;
  24.  
  25.     @Autowired
  26.     private UserRepository userRepository;
  27.  
  28.     @Transactional(transactionManager="securityTransactionManager")
  29.     public List<User> getUsers()
  30.     {
  31.         return userRepository.findAll();
  32.     }
  33.  
  34.     @Transactional(transactionManager="ordersTransactionManager")
  35.     public List<Order> getOrders()
  36.     {
  37.         return orderRepository.findAll();
  38.     }
  39. }

创建HomeController.java

  1. packagenet.guides.springboot.springbootmultipledatasources.controllers;
  3. importorg.springframework.beans.factory.annotation.Autowired;
  5. importorg.springframework.stereotype.Controller;
  6. importorg.springframework.ui.Model;
  7. importorg.springframework.web.bind.annotation.RequestMapping;
  8. importorg.springframework.web.bind.annotation.RequestMethod;
  10. importnet.guides.springboot.springbootmultipledatasources.services.UserOrdersService;
  12. /*** @author Ramesh Fadatare**/@ControllerpublicclassHomeController{
  13.     @AutowiredprivateUserOrdersServiceuserOrdersService;
  14.  
  15. @RequestMapping(value={"/", "/app/users"}, method=RequestMethod.GET)
  16.     publicStringgetUsers(Modelmodel)
  17.     {
  18.         model.addAttribute("users", userOrdersService.getUsers());
  19.         model.addAttribute("orders", userOrdersService.getOrders());
  20.   
  21.         return"users";
  22.     }
  23. }

对多个数据源使用OpenEntityManagerInViewFilter

让我们来看看如何使用OpenEntityManagerInViewFilter在渲染视图时启用JPA实体LAZY关联集合的懒惰加载，你需要注册OpenEntityManagerInViewFilter豆。

  1. /**
  2. * 
  3. */
  4. package net.guides.springboot.springbootmultipledatasources.config;
  6. import org.springframework.context.annotation.Bean;
  8. import org.springframework.context.annotation.Configuration;
  9. import org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter;
  10. import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
  12. /**
  13. * @author Ramesh Fadatare
  14. * 
  15. */
  16. @Configuration
  17. public class WebMvcConfig extends WebMvcConfigurerAdapter
  18. {
  19.  
  20.     @Bean
  21.     public OpenEntityManagerInViewFilter securityOpenEntityManagerInViewFilter()
  22.     {
  23.         OpenEntityManagerInViewFilter osivFilter = new OpenEntityManagerInViewFilter();
  24.         osivFilter.setEntityManagerFactoryBeanName("securityEntityManagerFactory");
  25.         return osivFilter;
  26.     }
  27.  
  28.     @Bean
  29.     public OpenEntityManagerInViewFilter ordersOpenEntityManagerInViewFilter()
  30.     {
  31.         OpenEntityManagerInViewFilter osivFilter = new OpenEntityManagerInViewFilter();
  32.         osivFilter.setEntityManagerFactoryBeanName("ordersEntityManagerFactory");
  33.         return osivFilter;
  34.     }
  35. }

由于我们正在建立一个Web应用程序，所以该方法返回 users.html 视图。

创建Thymeleaf页面 - users.html

  1. <!DOCTYPE html>
  2. <html xmlns="http://www.w3.org/1999/xhtml" 
  3.    xmlns:th="http://www.thymeleaf.org">
  4.       
  5.       <head>
  6.         <title>SpringBoot</title>
  7.     </head>
  8.     <body>
  9.     <div style="width: 20%; float:left">
  10.      <h1>Users</h1>
  11.      <hr/>
  12.      <div th:each="user : ${users}">
  13.       <h2>Name: <span th:text="${user.name}">Name</span></h2>
  14.       <h4>Addresses</h4>
  15.       <div th:each="addr : ${user.addresses}">
  16.        <p th:text="${addr.city}">City</p>
  17.       </div> 
  18.      </div>
  19.      </div>
  20.      <div style="width: 80%; float:right">
  21.      <h1>Orders</h1>
  22.      <hr/>
  23.      <div th:each="order : ${orders}">
  24.       <h2>Customer Name: <span th:text="${order.customerName}">customerName</span></h2>
  25.       <h4>Order Items</h4>
  26.       <div th:each="item : ${order.orderItems}">
  27.        <p th:text="${item.productCode}">productCode</p>
  28.       </div> 
  29.      </div>
  30.      </div>
  31.     </body>
  32.     
  33. </html>

运行一个应用程序

SpringbootMultipleDatasourcesApplication.java是一个入口点，所以在你的IDE中右击并选择运行，将在8080端口启动嵌入式tomcat服务器。

在浏览器中点击http://localhost:8080/链接将在浏览器中显示以下网页。

输出

就这样，我完成了一个带有多个数据源的Spring Boot Web应用程序的开发。

在我的GitHub仓库下载这个例子的源代码：https://github.com/RameshMF/springboot-jpa-multiple-datasources

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://www.javaguides.net/2018/09/spring-boot-jpa-multiple-data-sources-example.html

内容来源于网络，如有侵权，请联系作者删除！

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com