Question

我正在使用 Spring Boot 2.X 与 Hibernate 5 连接两个不同的MySQL数据库（Bar和Foo）在不同的服务器上。我试图从REST控制器中的方法列出实体的所有信息（自己的属性和@OneToMany和@ManyToOne关系）。

我已经按照几个教程来完成这项工作，因此，我能够获取@Primary数据库（Foo）的所有信息，但是，在检索时，我总是得到我的辅助数据库（Bar）的例外@OneToMany集。如果我将@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"])

我的application.properties：

# 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

我的@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 Controller类：

@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：如果两个目录（＆＃34;数据库＆＃34;在MySQL术语中）都在同一个数据库中（＆＃34;服务器＆＃34;），Rick James解决方案可以正常运行!!

当目录（MySQL数据库）位于不同的数据库（服务器）中时，问题仍然存在，并且尝试将Lazy保留为属性

非常感谢。

Answer 1

*默认情况下，ToMany Collections在Hibernate＆amp; JPA。错误是因为当实体管理器（也就是hibernate-speak中的会话）关闭时，Jackson正在尝试序列化OneToMany。因此，无法检索惰性集合。

默认情况下，使用JPA的Spring Boot为主EM提供OpenEntityManagerInViewFilter。这允许只读数据库访问，但默认情况下仅适用于主EM。

您有3个选项：

1）您可以添加联接提取，例如How does the FetchMode work in Spring Data JPA

2）您可以为非主要实体管理器添加OpenEntityManagerInViewFilter并将其添加到您的上下文中。

请注意，这意味着一个挑战，对于每个Bar和Foo实例，您的应用程序将返回数据库以检索OneToMany。这是不适用于Bar的部分，但适用于Foo。这意味着可扩展性问题（一些人称之为N + 1问题），对于每个foo和bar，你运行一个额外的查询，这对于非平凡数量的Foos和Bars来说会变慢。

3）另一种方法是让你的收藏品在Bar and Foo上得到预期（见https://docs.oracle.com/javaee/7/api/javax/persistence/OneToMany.html#fetch--），但如果可扩展性是一个关注点，则需要仔细分析。

我建议选项＃1。

Answer 2

同一台服务器上的两个数据库（又名“目录”）？只使用一个连接。然后参考：

Foo.table1
Bar.table2

在任何有简单表名的地方使用该语法。

不同的服务器

如果数据不在同一台机器上，它会变得混乱。一些想法：

从每个目录中获取数据，然后在应用程序代码中进行操作。该框架可能没有钩子同时对两个服务器做任何事情。
使用MariaDB及其FEDERATEDX引擎。

如何配置Spring启动以使用两个数据库？

2 个答案: