JPA: créer EntityManagerFactory de propriétés

je suis en utilisant JPA dans un BOCAL-Projet et utilisé le persistence.xml pour l'installation de mon EntityManager.

Mais depuis l'persistence.xml est à l'intérieur du BOCAL après la construction, il est très compliqué pour l'utilisateur de modifier les paramètres par la suite. Donc, je suis à la recherche d'une solution où je peux configurer ma connexion sur un propertyfile qui est chargé lors de l'exécution.

Je suis tombé sur cette solution sur le web:

Map properties = new HashMap();

//Configure the internal EclipseLink connection pool
properties.put(JDBC_DRIVER, "oracle.jdbc.OracleDriver");
properties.put(JDBC_URL, "jdbc:oracle:thin:@localhost:1521:ORCL");
properties.put(JDBC_USER, "user-name");
properties.put(JDBC_PASSWORD, "password");

Persistence.createEntityManagerFactory("unit-name", properties);

Qui est la solution que je cherchais, mais il me manque une chose: Dans mon persistence.xml j'ai aussi déclarer un nom de schéma sur un fichier de mappage:

persistence.xml:

<persistence version="2.0" ...>
  <persistence-unit name="jpa" transaction-type="RESOURCE_LOCAL">
    <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
    <class>...</class>
    <exclude-unlisted-classes>true</exclude-unlisted-classes>
    <properties>
      <property name="javax.persistence.jdbc.url" value="..."/>
      <property name="javax.persistence.jdbc.password" value="..."/>
      <property name="javax.persistence.jdbc.driver" value="oracle.jdbc.OracleDriver"/>
      <property name="javax.persistence.jdbc.user" value="..."/>
    </properties>
    <mapping-file>META-INF/orm.xml</mapping-file>
  </persistence-unit>
</persistence>

orm.xml:

<entity-mappings ...>
 <persistence-unit-metadata>
  <persistence-unit-defaults>
   <schema>SCHEMA_NAME</schema>
  </persistence-unit-defaults>
 </persistence-unit-metadata>
</entity-mappings>

Donc ma question c'est en gros: Est-il une propriété que je peux utiliser pour définir le schéma au moment de l'exécution, tout comme je le fais avec les autres propriétés?

Ou est-il même une meilleure solution?

Merci d'avance!

OriginalL'auteur Sebastian | 2013-08-01

  1. 2

    Passer à java config. Ensuite, vous pouvez facilement injecter les valeurs de propriété par permettra à l'autowiring Environnement

    Cet exemple est extrêmement basique. Mais en général, si vous savez comment faire la configuration xml vous pouvez mapper directement sur le Java config

    contextConfig.java

    /**
 * Spring Context configuration.
 */
@ComponentScan(basePackages = { "com.example" })
@PropertySource({ "classpath:common.properties" })
@Configuration
@Import(JpaConfig.class)
public class ContextConfig extends WebMvcConfigurerAdapter {
    /**
     * This bean is needed because Spring when you use xml config to load property files the bean is automatically
     * created... when you use @PropertySource then not so much
     * @return new bean
     */
    @Bean
    public PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
        return new PropertySourcesPlaceholderConfigurer();
    }
}

    jpaConfig.java

    @Configuration
@EnableJpaRepositories("com.example.repository")
public class JpaConfig {
@Autowired
private Environment env;
/**
* Create the fooDataSource Bean.
* @return fooDataSource Bean
*/
@Bean
public BasicDataSource fooDataSource() {
BasicDataSource basicDataSource = new BasicDataSource();
basicDataSource.setDriverClassName(env.getProperty("cfg_foo.driver.name"));
basicDataSource.setUrl(env.getProperty("cfg_foo.jdbc.url"));
basicDataSource.setUsername(env.getProperty("cfg_foo.username"));
basicDataSource.setPassword(env.getProperty("cfg_foo.password"));
basicDataSource.setPoolPreparedStatements(Boolean.valueOf(env.getProperty("cfg_foo.poolPreparedStatements")));
basicDataSource.setInitialSize(Integer.valueOf(env.getProperty("cfg_foo.poolInitialSize")));
basicDataSource.setMaxActive(Integer.valueOf(env.getProperty("cfg_foo.poolMaxActive")));
basicDataSource.setMaxIdle(Integer.valueOf(env.getProperty("cfg_foo.poolMaxIdle")));
basicDataSource.setValidationQuery("SELECT '1'");
return basicDataSource;
}
/**
* Create the hibernateJpaVendorAdapter Bean.
* @return hibernateJpaVendorAdapter Bean
*/
@Bean
public HibernateJpaVendorAdapter hibernateJpaVendorAdapter() {
HibernateJpaVendorAdapter adapter = new HibernateJpaVendorAdapter();
adapter.setDatabasePlatform("org.hibernate.dialect.MySQLDialect");
adapter.setShowSql(Boolean.valueOf(env.getProperty("show.sql")));
adapter.setGenerateDdl(Boolean.valueOf(env.getProperty("format.sql")));
return adapter;
}
/**
* Create the entityManagerFactory Bean.
* @return entityManagerFactory Bean
*/
@Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
LocalContainerEntityManagerFactoryBean entityManagerFactory = new LocalContainerEntityManagerFactoryBean();
entityManagerFactory.setPersistenceUnitName("foo");
entityManagerFactory.setDataSource(fooDataSource());
entityManagerFactory.setJpaVendorAdapter(hibernateJpaVendorAdapter());
entityManagerFactory.setPackagesToScan("com.example.repository");
return entityManagerFactory;
}
}
    Pourriez-vous fournir un exemple ou un lien vers plus d'informations?
    J'ai ajouté un exemple de base de ma réponse. Espérons que cela aide 🙂
    Merci pour cet exemple, c'est plus clair maintenant ce qui vous ment. Mais nous n'utilisons pas de Printemps pour ce projet, et je ne pouvais pas voir où vous configurez le schéma? (ai-je raté quelque chose?)
    Oh... excuses. Je n'ai aucune idée de comment faire cela sans Printemps

    OriginalL'auteur Leon

  2. 0

    Je ne sais pas si ses une meilleure solution, mais vous pouvez annoter vos entités JPA w/le schéma souhaité 

    @Entity
@Table(name = "Foo", schema = "Bar")
    Ne serait-il pas coder en dur le schéma de sorte que l'utilisateur ne peut pas le changer?
    Il n'. Éviter ce genre de codage en dur.

    OriginalL'auteur Shmil The Cat

  3. 0

    META-INF/orm.xml est le nom par défaut, et si le fichier existe, il sera utilisé s'il a été spécifié dans l'unité de persistance ou non. Si le fichier de mappage dans le persistence.xml a un autre nom, puis le nom par défaut n'est pas utilisé.

    À l'utilisation de plusieurs incompatible base de données de fournisseurs, tels que SQL Server et Oracle, il est possible d'avoir plusieurs persistance des unités dans le persistence.xml, et de sélectionner le bon appareil au moment de l'exécution. Si le mappage de fichiers sont nommés avec les noms par défaut, chaque unité peut avoir son propre fichier de mappage ou pas du tout.

    OriginalL'auteur Jonathan Rosenne