utiliser une base H2 persistée avec Spring boot

J'utilise une BDD H2 pour les tests:
https://bitbucket.org/philippegibaul...r40k/src/main/

Pour le serveur:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
package com.calculateur.warhammer.dao.h2;
 
import java.sql.SQLException;
import java.util.logging.Logger;
 
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
 
import org.h2.tools.Server;
 
import com.calculateur.warhammer.base.exception.DAOException;
import com.calculateur.warhammer.base.server.IDatabaseConfiguration;
import com.calculateur.warhammer.base.server.IDatabaseServer;
 
 
/**
 * H2 Databse Server
 * @author phili
 *
 */
public class ServerH2 implements IDatabaseServer{
 
	private static final Logger LOGGER = Logger.getLogger(ServerH2.class.getName());
 
	private final IDatabaseConfiguration configuration;
 
	private Server server;
 
	private boolean isRunning;
 
	public ServerH2(IDatabaseConfiguration configuration) {
		this.configuration = configuration;
		isRunning = false;
	}
 
	@Override
	public void close() throws Exception {
		stopServer();
	}
 
	@Override
	@PostConstruct
	public void startServer() throws DAOException {
		try {
			LOGGER.info("Start H2 Database in port "+configuration.getPort());
			server = Server.createTcpServer("-baseDir",configuration.getUrl(),"-tcpPort", configuration.getPort(), "-tcpAllowOthers").start();
			isRunning = true;
			LOGGER.info("H2 Database start in port "+configuration.getPort());
		} catch (SQLException e) {
			throw new DAOException(e);
		}
	}
 
	@Override
	@PreDestroy
	public void stopServer() throws DAOException {
		if(isRunning) {
			LOGGER.info("Stop H2 Database");
			server.stop();
			isRunning = false;
			LOGGER.info("H2 database stop");
		}
	}
 
}

La configuration:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
package com.calculateur.warhammer.dao.h2;
 
import java.io.File;
import java.io.IOException;
 
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
 
import org.apache.commons.io.FileUtils;
import org.h2.Driver;
 
import com.calculateur.warhammer.base.server.IDatabaseConfiguration;
 
/**
 * La configuration pour une Base de donnée H2
 * 
 * @author phili
 *
 */
public class ConfigurationH2 implements IDatabaseConfiguration {
 
	private static final String USER = "sa";
 
	private static final String USER_PASSWORD = "sa";
 
	private File useFile;
 
	private final File initialFile;
 
	private final File copiedFile;
 
	private final Integer port;
 
	private final String path;
 
	private final String databaseName;
 
	public ConfigurationH2(File initialFile, File copiedFile, Integer port, String path, String databaseName) {
		this.initialFile = initialFile;
		this.copiedFile = copiedFile;
		this.port = port;
		this.path = path;
		this.databaseName = databaseName;
	}
 
	@PostConstruct
	private void init() throws IOException {
		if (copiedFile != null) {
			FileUtils.copyDirectory(initialFile, copiedFile);
			useFile = copiedFile;
		} else {
			useFile = initialFile;
		}
	}
 
	@PreDestroy
	private void destroy() throws IOException {
		if (copiedFile != null && copiedFile.listFiles() != null) {
			for(File file:copiedFile.listFiles()) {
				FileUtils.deleteDirectory(file);
			}
		}
	}
 
	@Override
	public String getUrl() {
		return useFile.getAbsolutePath();
	}
 
	@Override
	public String getJDBCUrl() {
		StringBuilder sb = new StringBuilder("jdbc:h2:file:");
		sb.append(useFile.getAbsolutePath());
		sb.append("/");
		sb.append(path);
		sb.append("/");
		sb.append(databaseName);
		return sb.toString();
	}
 
	@Override
	public String getUser() {
		return USER;
	}
 
	@Override
	public String getPassword() {
		return USER_PASSWORD;
	}
 
	@Override
	public String getPort() {
		return port.toString();
	}
 
	@Override
	public String getClassDriver() {
		return Driver.class.getName();
	}
 
}

La configuration:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
package com.calculateur.warhammer.dao.configuration.general;
 
import javax.sql.DataSource;
 
import org.hibernate.dialect.H2Dialect;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.JpaVendorAdapter;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.PlatformTransactionManager;
 
import com.calculateur.warhammer.base.server.IDatabaseConfiguration;
import com.calculateur.warhammer.base.server.IDatabaseServer;
import com.calculateur.warhammer.dao.h2.ConfigurationH2;
import com.calculateur.warhammer.dao.h2.ServerH2;
 
/**
 * Une classe abstraite pour la configuration avec la BDD H2
 * @author phili
 *
 */
@ComponentScan(basePackages = {"com.calculateur.warhammer.dao.dao","com.calculateur.warhammer.dao.dao.applicable"})
public abstract class AbstractConfigurationH2 {
 
	/**
         * 
         * @return Retourne la configuration de la BDD H2
         */
	@Bean(name = "configurationH2")
	protected abstract ConfigurationH2 getConfigurationH2();
 
	/**
         * 
         * @return Vrai si Hibernate show SQL
         */
	protected abstract boolean isShowSQL();
 
	/**
         * 
         * @return Vrai si le sclema doit être créé
         */
	protected abstract boolean isCreateSchema();
 
	@Bean(name = "serverH2")
	public IDatabaseServer getServerH2() {
		return new ServerH2(getConfigurationH2());
	}
 
	@Bean(name = "localContainerEntityManagerFactoryBean")
	public LocalContainerEntityManagerFactoryBean getLocalContainerEntityManagerFactoryBean() {
		LocalContainerEntityManagerFactoryBean bean = new LocalContainerEntityManagerFactoryBean();
		bean.setDataSource(getDataSource());
		bean.setPackagesToScan("com.calculateur.warhammer.entity.entity");
		bean.setJpaVendorAdapter(getJpaVendorAdapter());
		return bean;
	}
 
	@Bean(name = "jpaVendorAdapter")
	public JpaVendorAdapter getJpaVendorAdapter() {
		HibernateJpaVendorAdapter adapter = new HibernateJpaVendorAdapter();
		adapter.setShowSql(isShowSQL());
		adapter.setDatabasePlatform(H2Dialect.class.getName());
		adapter.setGenerateDdl(isCreateSchema());
		return adapter;
	}
 
	@Bean(name = "dataSource")
	public DataSource getDataSource() {
		IDatabaseConfiguration conf = getConfigurationH2();
		DataSourceBuilder<?> builder = DataSourceBuilder.create();
		builder.driverClassName(conf.getClassDriver());
		builder.url(conf.getJDBCUrl());
		builder.username(conf.getUser());
		builder.password(conf.getPassword());
 
		return builder.build();
	}
 
	@Bean(name = "transactionManager")
	public PlatformTransactionManager getTransactionManager() {
		JpaTransactionManager transactionManager
        = new JpaTransactionManager();
      transactionManager.setEntityManagerFactory(
        getLocalContainerEntityManagerFactoryBean().getObject() );
      return transactionManager;
	}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
package com.calculateur.warhammer.dao.configuration;
 
import java.io.File;
import org.springframework.context.annotation.Configuration;
 
import com.calculateur.warhammer.dao.configuration.general.AbstractConfigurationH2;
import com.calculateur.warhammer.dao.h2.ConfigurationH2;
 
@Configuration
public class ConfigurationTestBDDH2 extends AbstractConfigurationH2{
 
	@Override
	protected ConfigurationH2 getConfigurationH2() {
		return new ConfigurationH2(getFolderDatabase(), getFolderCopy(), ConfigurationH2Test.PORT, ConfigurationH2Test.DATABASE_PATH,
				ConfigurationH2Test.DATABASE_SCHEMA);
	}
 
	@Override
	protected boolean isShowSQL() {
		return false;
	}
 
	@Override
	protected boolean isCreateSchema() {
		return false;
	}
 
	private File getFolderDatabase() {
		return new File(ConfigurationH2Test.PATH_FOLDER_BASE_DB);
	}
 
	private File getFolderCopy() {
		return new File(ConfigurationH2Test.PATH_FOLDER_COPY_DB);
	}
 
}