Plusieurs jpa:des dépôts en xml de config, comment configurer avec @EnableJPARepositories à l'aide de Spring java config?

J'ai créé un "minime" multiples de la source de données du projet pour m'aider à travailler sur la façon de le faire. Il y a 7 classes Java et d'autres config, donc je ne publierons que les principaux extraits de cette réponse. Vous pouvez obtenir la totalité du projet à partir de GitHub: https://github.com/gratiartis/multids-demo

La démo met en place deux entités JPA:

@Entity public class Foo { /* Constructors, fields and accessors/mutators */ }
@Entity public class Bar { /* Constructors, fields and accessors/mutators */ }

Associés avec ceux-ci, nous allons créer deux référentiels. Grâce à l'awesomeness de Printemps de Données, nous pouvons obtenir de nous-mêmes quelques-unes assez complet dépôts purement en définissant des interfaces qui s'étendent JpaRepository:

public interface FooRepository extends JpaRepository<Foo, Long> {}
public interface BarRepository extends JpaRepository<Bar, Long> {}

Maintenant, nous devons nous assurer que chacun de ces cartes à une table dans sa propre base de données.

Pour y parvenir, nous aurons besoin de deux gestionnaires de l'entité, dont chacune a une autre source de données. Cependant, au Printemps de Java config @Configuration classe, nous pouvons seulement avoir un @EnableJpaRepositories d'annotation et de chaque annotation ne peut que faire référence à l'un EntityManagerFactory. Pour atteindre cet objectif, nous avons créer deux @Configuration classes: FooConfig et BarConfig.

Chacun de ces @Configuration des classes de définir une source de données basée sur un intégré à la base de données HSQL:

@Bean(name = "fooDataSource")
public DataSource dataSource() {
    return new EmbeddedDatabaseBuilder()
            .setName("foodb").setType(EmbeddedDatabaseType.HSQL).build();
}
@Bean(name = "barDataSource")
public DataSource dataSource() {
    return new EmbeddedDatabaseBuilder()
            .setName("bardb").setType(EmbeddedDatabaseType.HSQL).build();
}

@Bean(name = "barEntityManagerFactory")
public EntityManagerFactory entityManagerFactory() {
    LocalContainerEntityManagerFactoryBean lef = 
            new LocalContainerEntityManagerFactoryBean();
    lef.setDataSource(dataSource());
    lef.setJpaVendorAdapter(jpaVendorAdapter);
    lef.setPackagesToScan("com.sctrcd.multidsdemo.domain.bar");
    lef.setPersistenceUnitName("barPersistenceUnit");
    lef.afterPropertiesSet();
    return lef.getObject();
}
@Bean(name = "fooEntityManagerFactory")
public EntityManagerFactory entityManagerFactory() {
    LocalContainerEntityManagerFactoryBean lef = 
            new LocalContainerEntityManagerFactoryBean();
    lef.setDataSource(dataSource());
    lef.setJpaVendorAdapter(jpaVendorAdapter);
    lef.setPackagesToScan("com.sctrcd.multidsdemo.domain.foo");
    lef.setPersistenceUnitName("fooPersistenceUnit");
    lef.afterPropertiesSet();
    return lef.getObject();
}

Chaque configuration doit définir un EntityManagerFactory, comme ci-dessus, qui renvoie à sa propre source de données() @Bean méthode. Il définit également un chemin d'accès à l' @Entity beans qu'il gère. Vous devez vous assurer que @Entity beans de différentes sources de données sont dans des packages différents.

À ce stade, il est intéressant de noter que si chacune de ces configurations utilise la valeur par défaut dénominations clé de la persistance des haricots (c'est à dire entityManagerFactory), puis au Printemps de voir qu'il y a deux haricots avec l'EntityManager interface, qui ont tous deux le même nom. Donc, l'un sera choisi. Cela conduit à des erreurs telles que:

Not an managed type: class com.sctrcd.multidsdemo.domain.bar.Bar

Ceci peut être vu dans la branche du projet de démonstration ici: https://github.com/gratiartis/multids-demo/tree/1-unnamed-entitymanager-beans

C'est parce que dans cet exemple, le Printemps a câblé les haricots relatives à la "foodb" de la base de données, et le Bar n'est pas une entité dans la base de données. Malheureusement, le BarRepository a été câblé avec les Foo gestionnaire d'entités.

Nous résoudre ce problème en nommant tous nos haricots dans chacun de config de la classe. c'est à dire

@Bean(name = "fooDataSource") public DataSource dataSource() { .. }
@Bean(name = "fooEntityManager") public EntityManager entityManager() { .. }

À ce stade, si vous exécutez les tests dans le projet, vous pourriez voir des avertissements tels que:

 No bean named 'entityManagerFactory' is defined.

C'est parce que ... roulement de tambour ... nous n'avons pas de EntityManagerFactory avec le nom par défaut "entityManagerFactory". Nous avons appelé "fooEntityManagerFactory" et un autre appelé "barEntityManagerFactory". Le printemps est à la recherche de quelque chose avec un nom par défaut, nous avons donc besoin de demander le fil des choses différemment.

Comme il s'avère, ce n'est incroyablement simple à faire. Nous avons juste besoin de mettre le bon références dans le @EnableJpaRepositories annotation pour chaque @classe de Configuration.

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        entityManagerFactoryRef = "fooEntityManagerFactory", 
        transactionManagerRef = "fooTransactionManager",
        basePackages = {"com.sctrcd.multidsdemo.integration.repositories.foo"})
public class FooConfig {
    //...
}

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        entityManagerFactoryRef = "barEntityManagerFactory", 
        transactionManagerRef = "barTransactionManager",
        basePackages = { "com.sctrcd.multidsdemo.integration.repositories.bar" })
public class BarConfig {
    //...
}

Comme vous pouvez le voir, chacun de ces @EnableJpaRepositories annotations définit nommé EntityManagerFactory et PlatformTransactionManager. Ils définissent également les dépôts doivent être câblés avec les haricots. Dans l'exemple, j'ai mis les dépôts dans la base de données des paquets spécifiques. Il est également possible de définir chaque référentiel par nom, par l'ajout de includeFilters à l'annotation, mais en séparant les dépôts de base de données, je crois que les choses finissent plus lisible.

À ce stade, vous devriez avoir une application de travail à l'aide de Printemps, référentiels de Données pour gérer les entités dans deux bases de données distinctes. Hésitez pas à attraper le projet à partir du lien ci-dessus et exécuter les tests pour voir ce qui se passe. J'espère que cette réponse est utile à plus de gens, que j'ai passé une bonne quantité de temps de travail pour faire de ce aussi proprement que possible avec aussi peu de code que je pouvais gérer. Toutes les idées pour l'amélioration de la réponse ou de démonstration du projet sont les bienvenus.