Le programme d'installation H2 en Mode Serveur à l'aide de Java en Fonction de la Configuration

J'ai de printemps XML qui me permet de démarrer H2 base de données en mode serveur à l'aide de la configuration suivante:

<beans profile="test-h2">
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
          destroy-method="close">
        <property name="driverClassName" value="org.h2.Driver"/>
        <property name="url" value="jdbc:h2:target/h2/pps;AUTO_SERVER=TRUE"/>
        <property name="username" value="sa"/>
        <property name="password" value=""/>
    </bean>
    <bean id="entityManagerFactory" parent="entityManagerFactoryCommonParent">
        <property name="jpaProperties">
            <props>
                <prop key="hibernate.hbm2ddl.auto">create-drop</prop>
                <prop key="hibernate.show_sql">true</prop>
            </props>
        </property>
    </bean>

Je veux convertir à java en fonction de la configuration. J'ai paraître un post ici: De démarrage et de configuration en mémoire DB à l'aide de Printemps demandant un peu la même question et j'ai regardé http://docs.spring.io/spring/docs/3.0.x/spring-framework-reference/html/jdbc.html#jdbc-embedded-database-support de Base de données Intégré, mais il ne dit pas comment définir H2 mode à la mode Serveur. C'est à partir du serveur pour que me en "mem".

J'ai le code suivant:

EmbeddedDatabaseBuilder builder = new EmbeddedDatabaseBuilder();

builder.setType(EmbeddedDatabaseType.H2);
builder.setName(DATABASE_NAME);
builder.addScript(H2_SCHEMA);
builder.addScript(H2_TEST);
return builder.build();

Peut-être à l'aide de EmbeddedDatabaseBuilder(ResourceLoader) pourrait fonctionner. Est-ce quelqu'un a un exemple de code pour cela?

OriginalL'auteur yousafsajjad | 2013-11-23

  1. 7

    Voici le code qui va vous permettre de démarrer H2 base de données en mode serveur à l'aide de java printemps de configuration:

    private static final String H2_JDBC_URL_TEMPLATE = "jdbc:h2:%s/target/db/sample;AUTO_SERVER=TRUE";
@Value("classpath:seed-data.sql")
private Resource H2_SCHEMA_SCRIPT;
@Value("classpath:test-data.sql")
private Resource H2_DATA_SCRIPT;
@Value("classpath:drop-data.sql")
private Resource H2_CLEANER_SCRIPT;
@Bean
public DataSource dataSource(Environment env) throws Exception {
return createH2DataSource();
}
@Autowired
@Bean
public DataSourceInitializer dataSourceInitializer(final DataSource dataSource) {
final DataSourceInitializer initializer = new DataSourceInitializer();
initializer.setDataSource(dataSource);
initializer.setDatabasePopulator(databasePopulator());
initializer.setDatabaseCleaner(databaseCleaner());
return initializer;
}
private DatabasePopulator databasePopulator() {
final ResourceDatabasePopulator populator = new ResourceDatabasePopulator();
populator.addScript(H2_SCHEMA_SCRIPT);
populator.addScript(H2_DATA_SCRIPT);
return populator;
}
private DatabasePopulator databaseCleaner() {
final ResourceDatabasePopulator populator = new ResourceDatabasePopulator();
populator.addScript(H2_CLEANER_SCRIPT);
return populator;
}
private DataSource createH2DataSource() {
String jdbcUrl = String.format(H2_JDBC_URL_TEMPLATE, System.getProperty("user.dir"));
JdbcDataSource ds = new JdbcDataSource();       
ds.setURL(jdbcUrl);
ds.setUser("sa");
ds.setPassword("");
return ds;
}
@Bean
public PlatformTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {
JpaTransactionManager transactionManager = new JpaTransactionManager();
transactionManager.setEntityManagerFactory(entityManagerFactory);
return transactionManager;
}
@Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactory(Environment env) throws Exception {
HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
vendorAdapter.setGenerateDdl(Boolean.TRUE);
vendorAdapter.setShowSql(Boolean.TRUE);     
LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
factory.setPersistenceUnitName("sample");
factory.setJpaVendorAdapter(vendorAdapter);
factory.setPackagesToScan("com.sample.model");
factory.setDataSource(dataSource(env));     
factory.setJpaProperties(jpaProperties());
factory.setLoadTimeWeaver(new InstrumentationLoadTimeWeaver());
return factory;
}
Properties jpaProperties() {
Properties props = new Properties();
props.put("hibernate.query.substitutions", "true 'Y', false 'N'");
props.put("hibernate.hbm2ddl.auto", "create-drop");
props.put("hibernate.show_sql", "false");
props.put("hibernate.format_sql", "true");
return props;
}
    A partir de maintenant - cela est exagéré. La même chose peut être fait en quelques lignes. springframework.guru/... je ne suis pas affilié avec l'auteur, en quelque sorte - mais ses instructions certainement travaillé pour moi.

    OriginalL'auteur yousafsajjad

  2. 1

    Je pense que c'est pas possible. Le terme de base de données Intégré comme dans les bases de données qui n'ont pas besoin d'un serveur, et sont intégrés dans une application, donc vous ne devriez pas utiliser EmbeddedDatabase pour cela.

    En h2 de la documentation, le terme "Intégré" est enfatized avec des "Locaux" - (Connexion à un Intégrés (Locales), Base de données), et lorsqu'ils utilisent le "Serveur" ils parlent de connexions à distance où la base de données est gérée par un serveur. Pour renforcer l'idée EmbeddedDataSource interface n'ajoute qu'une seule méthode qui n'est pas présent dans la source de données "shutdown" de l'interface qui est utilisée pour arrêter la base de données généralement lorsque l'application est à l'arrêt, via @Bean(destroyMethod="shutdown") par exemple.

    Voir plus de détails ici:

    http://h2database.com/html/features.html#database_url

    Si est une base de données appelée comme une base de données Incorporée?

    http://docs.spring.io/spring/docs/3.0.x/api/org/springframework/jdbc/datasource/embedded/EmbeddedDatabase.html

    OriginalL'auteur Lucas Oliveira