java如何配置Spring引导以使用两个数据库？
我正在使用弹簧靴2。X使用Hibernate 5连接不同服务器上的两个不同MySQL数据库（Bar和Foo）。我试图从REST控制器中的方法列出实体的所有信息（自身属性和@OneToMany和@ManyToOne关系）
为此，我遵循了一些教程，因此，我能够获得我的@Primary数据库（Foo）的所有信息，但是，在检索@OneToMany集时，我的辅助数据库（Bar）总是出现异常。如果将@Primary注释交换到Bar数据库，则可以从Bar数据库获取数据，但不能从Foo数据库获取数据。有办法解决这个问题吗
这是我得到的一个例外：
...w.s.m.s.DefaultHandlerExceptionResolver :
Failed to write HTTP message: org.springframework.http.converter.HttpMessageNotWritableException:
Could not write JSON document: failed to lazily initialize a collection of role:
com.foobar.bar.domain.Bar.manyBars, could not initialize proxy - no Session (through reference chain: java.util.ArrayList[0]-com.foobar.bar.domain.Bar["manyBars"]);
nested exception is com.fasterxml.jackson.databind.JsonMappingException:
failed to lazily initialize a collection of role:
com.foobar.bar.domain.Bar.manyBars, could not initialize proxy - no Session (through reference chain: java.util.ArrayList[0]->com.foobar.bar.domain.Bar["manyBars"])
我的申请书。特性：
# MySQL DB - "foo"
spring.datasource.url=jdbc:mysql://XXX:3306/foo?currentSchema=public
spring.datasource.username=XXX
spring.datasource.password=XXX
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
# MySQL DB - "bar"
bar.datasource.url=jdbc:mysql://YYYY:3306/bar?currentSchema=public
bar.datasource.username=YYYY
bar.datasource.password=YYYY
bar.datasource.driver-class-name=com.mysql.jdbc.Driver
# JPA
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=none
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
My@Primary数据源配置：
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(entityManagerFactoryRef = "entityManagerFactory",
transactionManagerRef = "transactionManager",
basePackages = {"com.foobar.foo.repo"})
public class FooDbConfig {
@Primary
@Bean(name = "dataSource")
@ConfigurationProperties(prefix = "spring.datasource")
public DataSource dataSource() {
return DataSourceBuilder.create().build();
}
@Primary
@Bean(name = "entityManagerFactory")
public LocalContainerEntityManagerFactoryBean entityManagerFactory(
EntityManagerFactoryBuilder builder, @Qualifier("dataSource") DataSource dataSource) {
return builder
.dataSource(dataSource)
.packages("com.foobar.foo.domain")
.persistenceUnit("foo")
.build();
}
@Primary
@Bean(name = "transactionManager")
public PlatformTransactionManager transactionManager(
@Qualifier("entityManagerFactory") EntityManagerFactory entityManagerFactory) {
return new JpaTransactionManager(entityManagerFactory);
}
}
我的辅助数据源配置：
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(entityManagerFactoryRef = "barEntityManagerFactory",
transactionManagerRef = "barTransactionManager", basePackages = {"com.foobar.bar.repo"})
public class BarDbConfig {
@Bean(name = "barDataSource")
@ConfigurationProperties(prefix = "bar.datasource")
public DataSource dataSource() {
return DataSourceBuilder.create().build();
}
@Bean(name = "barEntityManagerFactory")
public LocalContainerEntityManagerFactoryBean barEntityManagerFactory(
EntityManagerFactoryBuilder builder, @Qualifier("barDataSource") DataSource dataSource) {
return builder
.dataSource(dataSource)
.packages("com.foobar.bar.domain")
.persistenceUnit("bar")
.build();
}
@Bean(name = "barTransactionManager")
public PlatformTransactionManager barTransactionManager(
@Qualifier("barEntityManagerFactory") EntityManagerFactory barEntityManagerFactory) {
return new JpaTransactionManager(barEntityManagerFactory);
}
}
REST控制器类：
@RestController
public class FooBarController {
private final FooRepository fooRepo;
private final BarRepository barRepo;
@Autowired
FooBarController(FooRepository fooRepo, BarRepository barRepo) {
this.fooRepo = fooRepo;
this.barRepo = barRepo;
}
@RequestMapping("/foo")
public List<Foo> listFoo() {
return fooRepo.findAll();
}
@RequestMapping("/bar")
public List<Bar> listBar() {
return barRepo.findAll();
}
@RequestMapping("/foobar/{id}")
public String fooBar(@PathVariable("id") Integer id) {
Foo foo = fooRepo.findById(id);
Bar bar = barRepo.findById(id);
return foo.getName() + " " + bar.getName() + "!";
}
}
Foo/Bar存储库：
@Repository
public interface FooRepository extends JpaRepository<Foo, Long> {
Foo findById(Integer id);
}
@Repository
public interface BarRepository extends JpaRepository<Bar, Long> {
Bar findById(Integer id);
}
@Primary数据源的实体。第二个数据源的实体相同（仅更改类名）：
@Entity
@Table(name = "foo")
public class Foo {
@Id
@GeneratedValue(strategy = IDENTITY)
@Column(name = "id", unique = true, nullable = false)
private Integer id;
@Column(name = "name")
private String name;
@OneToMany(fetch = FetchType.LAZY, mappedBy = "foo")
@JsonIgnoreProperties({"foo"})
private Set<ManyFoo> manyFoos = new HashSet<>(0);
// Constructors, Getters, Setters
}
@Entity
@Table(name = "many_foo")
public class ManyFoo {
@Id
@GeneratedValue(strategy = IDENTITY)
@Column(name = "id", unique = true, nullable = false)
private Integer id;
@Column(name = "name")
private String name;
@ManyToOne(fetch = FetchType.LAZY)
@JsonIgnoreProperties({"manyFoos"})
private Foo foo;
// Constructors, Getters, Setters
}
最后，我的应用程序主要包括：
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
需要注意的是，解决方案应该保留两个数据库的Lazy属性，以保持最佳性能
编辑1:如果两个目录（MySQL术语中的“数据库”）位于同一个数据库（“服务器”）中，Rick James解决方案可以工作
当目录（MySQL数据库）位于不同的数据库（服务器）中时，问题仍然存在，并且试图保留该属性
非常感谢
# 1 楼答案
*在Hibernate&；JPA。错误是因为在实体管理器（hibernate speak中的会话）关闭时，Jackson试图序列化OneToMany。因此，无法检索惰性集合
默认情况下，带JPA的Spring Boot为主EM提供
OpenEntityManagerInViewFilter。这允许只读DB访问，但默认情况下仅适用于主EM你有3个选择：
1）您可以添加连接获取，例如How does the FetchMode work in Spring Data JPA
2）可以为非主要实体管理器添加OpenEntityManager视图过滤器，并将其添加到上下文中
请注意，这意味着一个挑战，对于每个Bar和Foo实例，您的应用程序将返回数据库以检索OneToMany。这部分不是为Bar工作，而是为Foo工作。这意味着一个可伸缩性问题（有些人称之为N+1问题），对于每个foo和bar，您都会运行一个额外的查询，对于数量不多的foo和bar，查询速度会变慢
3）另一种选择是让你的收藏在Bar和Foo上变得更加迫切（见此https://docs.oracle.com/javaee/7/api/javax/persistence/OneToMany.html#fetch ），但如果你担心可伸缩性，则需要仔细分析这一点
我建议选择#1
# 2 楼答案
同一台服务器上有两个数据库（又名“目录”）只使用一个连接。然后引用如下：
只要有一个简单的表名，就使用这种语法
不同的服务器
如果数据不在同一台机器上，就会变得混乱。有几个想法：
FEDERATEDX引擎