├── .gitignore
├── .settings
    └── .gitignore
├── README.md
├── build.gradle
├── pom.xml
└── src
    └── main
        ├── java
            └── com
            │   └── alexbt
            │       └── jpa
            │           ├── JpaController.java
            │           ├── Launcher.java
            │           ├── Model.java
            │           └── ModelJpaRepository.java
        └── resources
            ├── application.properties
            ├── data-h2.sql
            └── schema-h2.sql


/.gitignore:
--------------------------------------------------------------------------------
1 | /target/
2 | /.classpath
3 | /.project
4 | /.idea
5 | /*.iml
6 | /.settings


--------------------------------------------------------------------------------
/.settings/.gitignore:
--------------------------------------------------------------------------------
1 | /org.eclipse.core.resources.prefs
2 | /org.eclipse.jdt.core.prefs
3 | /org.eclipse.m2e.core.prefs
4 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | Spring Boot, Spring Data JPA and Embedded h2
 2 | ---------------------------------------------------
 3 | 
 4 | In almost all of my projects that involves external resources, I try my best to enable the application to fully run without dependencies.
 5 | It's useful to provide a fully working backing 
 6 | This sample project shows how a spring-boot application can be setup with an embedded SQL database over JPA.
 7 | The focus of this project is to show how to configure an embedded database with Spring Boot, however the source code also contains a RestController and a Spring Data Repository.
 8 | 
 9 | 
10 | 
11 | Other sample projects with embedded databases 
12 | ---------------------------------------------------
13 | * [sample-spring-boot-data-mongodb-embedded](https://github.com/alexturcot/sample-spring-boot-data-mongodb-embedded)
14 | * [sample-spring-boot-data-mongodb-embedded-multiple](https://github.com/alexturcot/sample-spring-boot-data-mongodb-embedded-multiple)
15 | * [sample-spring-boot-data-solr-embedded](https://github.com/alexturcot/sample-spring-boot-data-solr-embedded)
16 | * [sample-spring-boot-data-redis-embedded](https://github.com/alexturcot/sample-spring-boot-data-redis-embedded)
17 | * [sample-spring-boot-data-keyvalue-embedded](https://github.com/alexturcot/sample-spring-boot-data-keyvalue-embedded)
18 | * [sample-spring-boot-data-jpa-embedded](https://github.com/alexturcot/sample-spring-boot-data-jpa-embedded)
19 | 
20 | 
21 | Step by step
22 | ---------------------------------------------------
23 | 
24 | **Maven dependencies**
25 | To load an embedded database with Spring Boot, all you really need is to add its maven dependency into your pom. The rest will be taken care of.
26 | In my case I chose h2, so I added the following dependency:
27 | ```
28 | <dependency>
29 |     <groupId>com.h2database</groupId>
30 |     <artifactId>h2</artifactId>
31 | </dependency>
32 | ```
33 | 
34 | **Spring Boot configuration**
35 | ```
36 | spring.datasource.url=jdbc:h2:mem:TEST;MVCC=true;DB_CLOSE_DELAY=-1;MODE=Oracle
37 | spring.datasource.username=sa
38 | spring.datasource.password=
39 | spring.datasource.driver-class-name=org.h2.Driver
40 | spring.datasource.platform=h2
41 | 
42 | spring.datasource.initialize=true
43 | #datasource.schema=
44 | #datasource.data
45 | spring.h2.console.enabled=true
46 | spring.jpa.hibernate.ddl-auto=none
47 | ```
48 | 
49 | * **spring.datasource.***: sets up an in-memory H2 database;
50 | * **spring.datasource.initialize**: tells spring-boot to initialize the database with scripts;
51 | * **datasource.schema**: the schema sql script to load. By default it is schema-${platform}.sql then schema.sql;
52 | * **datasource.data**: the data sql script. By default, it is data-${platform}.sql then data.sql;
53 | * **spring.h2.console.enabled**: allow us to access the memory database from a web interface;
54 | * **spring.jpa.hibernate.ddl-auto**: hibernates also tries to initialize the database. 
55 | When it detects an embedded database, it sets ddl-auto to create-drop and initialize the database with entities annotated with @Table (and also looks for imports.sql). 
56 | This may lead to creating the same table twice. I prefer to stick with Spring Boot magic, so I set this to none
57 | 
58 | **That's it**
59 | 
60 | Assuming you have a Spring Boot entry point, launch it:
61 | ```
62 | @SpringBootApplication
63 | public class Launcher {
64 |     
65 |     public static void main(String[] args){
66 |         new SpringApplicationBuilder() //
67 |         .sources(Launcher.class)//
68 |         .run(args);
69 |     }
70 | }
71 | ```
72 | Then, you can access h2's console at: [localhost:8080/h2-console](http://localhost:8080/h2-console)
73 | Simply type in the url ```jdbc:h2:mem:TEST;MVCC=true;DB_CLOSE_DELAY=-1;MODE=Oracle``` in **JDBC URL** field  
74 | 
75 | It should work, however the database is empty.
76 | 
77 | Now simply add sql script in src/main/resources.
78 | **schema-h2.sql**:
79 | ```
80 | CREATE TABLE MYTABLE
81 | (
82 |     ID NUMBER(19) NOT NULL,
83 |     VAL VARCHAR2(50) NOT NULL,
84 | );
85 | ```
86 | **data-h2.sql**:
87 | ```
88 | INSERT INTO MODEL (ID, VAL) VALUES (1, 'TEST');
89 | ```
90 | If you go back to the h2-console, you should see your data. All that is left to do, is to create your JPARepsitory like you would normally do with Spring Data, spring boot we'll wire it up with a datasource pointing to the embedded database.
91 | 
92 | Get the code - do it
93 | ------------------------
94 | Clone the repository:
95 | 
96 |     $ git clone https://github.com/alexturcot/sample-spring-boot-data-jpa-embedded.git


--------------------------------------------------------------------------------
/build.gradle:
--------------------------------------------------------------------------------
 1 | version='1.0.0-SNAPSHOT'
 2 | group='com.alexbt'
 3 | 
 4 | buildscript {
 5 |     repositories {
 6 |     	mavenCentral()
 7 |     }
 8 |     dependencies {
 9 |         classpath 'io.spring.gradle:dependency-management-plugin:0.6.0.RELEASE',
10 |         		  'org.springframework.boot:spring-boot-gradle-plugin:1.3.6.RELEASE'
11 |     }
12 | }
13 | 
14 | apply plugin: 'spring-boot'
15 | 
16 | allprojects{
17 | 	apply plugin: 'io.spring.dependency-management'
18 | 	apply plugin: 'java'
19 | 	apply plugin: 'eclipse'
20 | 	apply plugin: 'idea'
21 | 	sourceCompatibility = 1.8
22 | 	targetCompatibility = 1.8
23 | 	
24 | 	tasks.withType(JavaCompile) {
25 | 	    options.encoding = 'UTF-8'
26 | 	}
27 | 	
28 | 	dependencyManagement {
29 |     	imports {
30 |         	mavenBom 'io.spring.platform:platform-bom:2.0.6.RELEASE'
31 |     	}
32 | 	}
33 | 	
34 | 	repositories {
35 |     	mavenCentral()
36 |     	maven { url "http://repo.spring.io/release" }
37 | 	}
38 | }
39 | 
40 | dependencies {
41 |     compile 'org.springframework:spring-core',
42 |     		'org.springframework.boot:spring-boot-starter-web',
43 |     		'com.h2database:h2',
44 |     		'org.springframework.boot:spring-boot-starter-data-jpa',
45 |     		'org.springframework.boot:spring-boot-starter',
46 |     		'org.springframework.data:spring-data-rest-webmvc'
47 | }


--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
 1 | <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 2 | 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 3 | 	<modelVersion>4.0.0</modelVersion>
 4 | 
 5 | 	<groupId>com.alexbt</groupId>
 6 | 	<artifactId>sample-spring-boot-data-jpa-embedded</artifactId>
 7 | 	<version>1.0.0-SNAPSHOT</version>
 8 | 	<packaging>jar</packaging>
 9 | 
10 | 	<parent>
11 | 		<groupId>org.springframework.boot</groupId>
12 | 		<artifactId>spring-boot-starter-parent</artifactId>
13 | 		<version>1.3.5.RELEASE</version>
14 | 	</parent>
15 | 
16 | 	<name>test</name>
17 | 	<url>http://maven.apache.org</url>
18 | 
19 | 	<properties>
20 | 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
21 | 		<java.version>1.8</java.version>
22 | 		<maven.compiler.source>${java.version}</maven.compiler.source>
23 | 		<maven.compiler.target>${java.version}</maven.compiler.target>
24 | 	</properties>
25 | 
26 | 	<dependencyManagement>
27 | 		<dependencies>
28 | 			<dependency>
29 | 				<groupId>io.spring.platform</groupId>
30 | 				<artifactId>platform-bom</artifactId>
31 | 				<version>2.0.5.RELEASE</version>
32 | 				<type>pom</type>
33 | 				<scope>import</scope>
34 | 			</dependency>
35 | 		</dependencies>
36 | 	</dependencyManagement>
37 | 
38 | 	<dependencies>
39 | 		<dependency>
40 |         <groupId>org.springframework.data</groupId>
41 |         <artifactId>spring-data-rest-webmvc</artifactId>
42 |     </dependency>
43 | 		<dependency>
44 | 			<groupId>org.springframework.boot</groupId>
45 | 			<artifactId>spring-boot-starter</artifactId>
46 | 		</dependency>
47 | 		<dependency>
48 | 			<groupId>org.springframework.boot</groupId>
49 | 			<artifactId>spring-boot-starter-web</artifactId>
50 | 		</dependency>
51 | 
52 | 		<dependency>
53 | 			<groupId>org.springframework.boot</groupId>
54 | 			<artifactId>spring-boot-starter-data-jpa</artifactId>
55 | 		</dependency>
56 | 		
57 | 		<dependency>
58 | 			<groupId>com.h2database</groupId>
59 | 			<artifactId>h2</artifactId>
60 | 		</dependency>
61 | 
62 | 		<dependency>
63 | 			<groupId>io.spring.platform</groupId>
64 | 			<artifactId>platform-bom</artifactId>
65 | 			<version>2.0.6.RELEASE</version>
66 | 			<type>pom</type>
67 | 			<scope>import</scope>
68 | 		</dependency>
69 | 	</dependencies>
70 | 
71 | 	<build>
72 | 		<plugins>
73 | 			<plugin>
74 | 				<groupId>org.apache.maven.plugins</groupId>
75 | 				<artifactId>maven-jar-plugin</artifactId>
76 | 			</plugin>
77 | 
78 | 			<plugin>
79 | 				<groupId>org.springframework.boot</groupId>
80 | 				<artifactId>spring-boot-maven-plugin</artifactId>
81 | 			</plugin>
82 | 		</plugins>
83 | 	</build>
84 | </project>
85 | 


--------------------------------------------------------------------------------
/src/main/java/com/alexbt/jpa/JpaController.java:
--------------------------------------------------------------------------------
 1 | package com.alexbt.jpa;
 2 | 
 3 | import java.io.IOException;
 4 | 
 5 | import org.springframework.beans.factory.annotation.Autowired;
 6 | import org.springframework.web.bind.annotation.PathVariable;
 7 | import org.springframework.web.bind.annotation.RequestMapping;
 8 | import org.springframework.web.bind.annotation.RequestMethod;
 9 | import org.springframework.web.bind.annotation.RestController;
10 | 
11 | @RestController
12 | @RequestMapping("/jpa")
13 | public class JpaController {
14 | 
15 | 	@Autowired
16 | 	private ModelJpaRepository modelJpaRepository;
17 | 	
18 | 	@RequestMapping(path="/repo", method = RequestMethod.GET)
19 | 	public Iterable<Model> findByRepo() throws IOException {
20 | 		return modelJpaRepository.findAll();
21 | 	}
22 | 	
23 | 	@RequestMapping(value = "/repo/{value}", method = RequestMethod.GET)
24 | 	public void saveByRepo(@PathVariable String value) {
25 | 		Model model = new Model();
26 | 		model.setId(System.currentTimeMillis());
27 | 		model.setValue(value);
28 | 		modelJpaRepository.save(model);
29 | 	}
30 | }
31 | 


--------------------------------------------------------------------------------
/src/main/java/com/alexbt/jpa/Launcher.java:
--------------------------------------------------------------------------------
 1 | package com.alexbt.jpa;
 2 | 
 3 | import org.springframework.boot.autoconfigure.SpringBootApplication;
 4 | import org.springframework.boot.builder.SpringApplicationBuilder;
 5 | import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
 6 | 
 7 | @SpringBootApplication
 8 | @EnableJpaRepositories
 9 | public class Launcher {
10 | 	
11 | 	public static void main(String[] args){
12 | 		new SpringApplicationBuilder() //
13 | 		.sources(Launcher.class)//
14 | 		.run(args);
15 | 	}
16 | }
17 | 


--------------------------------------------------------------------------------
/src/main/java/com/alexbt/jpa/Model.java:
--------------------------------------------------------------------------------
 1 | package com.alexbt.jpa;
 2 | 
 3 | import javax.persistence.Column;
 4 | import javax.persistence.Entity;
 5 | import javax.persistence.GeneratedValue;
 6 | import javax.persistence.Id;
 7 | import javax.persistence.Table;
 8 | 
 9 | 
10 | 
11 | @Entity
12 | @Table(name = "MODEL")
13 | public class Model {
14 | 	
15 | 	@Id
16 | 	@GeneratedValue
17 | 	@Column(name = "ID", nullable = false)
18 | 	private long id;
19 | 	
20 | 	@Column(name = "VAL", nullable = false)
21 | 	private String value;
22 | 	
23 | 	public long getId() {
24 | 		return id;
25 | 	}
26 | 
27 | 	public void setId(long id) {
28 | 		this.id = id;
29 | 	}
30 | 
31 | 	public String getValue() {
32 | 		return value;
33 | 	}
34 | 
35 | 	public void setValue(String value) {
36 | 		this.value = value;
37 | 	}
38 | 
39 | }
40 | 


--------------------------------------------------------------------------------
/src/main/java/com/alexbt/jpa/ModelJpaRepository.java:
--------------------------------------------------------------------------------
1 | package com.alexbt.jpa;
2 | 
3 | import org.springframework.data.jpa.repository.JpaRepository;
4 | 
5 | public interface ModelJpaRepository extends JpaRepository<Model, String> {
6 | }


--------------------------------------------------------------------------------
/src/main/resources/application.properties:
--------------------------------------------------------------------------------
 1 | #server.port=8080
 2 | #server.contextPath=/
 3 | 
 4 | spring.datasource.url=jdbc:h2:mem:TEST;MVCC=true;DB_CLOSE_DELAY=-1;MODE=Oracle
 5 | spring.datasource.username=sa
 6 | spring.datasource.password=
 7 | spring.datasource.driver-class-name=org.h2.Driver
 8 | spring.datasource.platform=h2
 9 | spring.datasource.initialize=true
10 | #datasource.schema=classpath:schema.sql
11 | #datasource.data=classpath:data.sql
12 | #datasource.testdata=classpath:...
13 | 
14 | spring.h2.console.enabled=true
15 | #spring.jpa.show-sql=true
16 | spring.jpa.hibernate.ddl-auto=none
17 | #spring.jpa.properties.hibernate.cache.region.factory_class: org.hibernate.cache.ehcache.SingletonEhCacheRegionFactory
18 | #spring.profiles.include=application-embedded.properties.loaded,ldap.embedded
19 | 


--------------------------------------------------------------------------------
/src/main/resources/data-h2.sql:
--------------------------------------------------------------------------------
1 | INSERT INTO MODEL (ID, VAL) VALUES (1, 'TEST');
2 | 


--------------------------------------------------------------------------------
/src/main/resources/schema-h2.sql:
--------------------------------------------------------------------------------
1 | CREATE TABLE MODEL
2 | (
3 | 	ID NUMBER(19) NOT NULL,
4 | 	VAL VARCHAR2(50) NOT NULL,
5 | );
6 | 


--------------------------------------------------------------------------------