Spring Boot内嵌数据库的使用（H2）

引用 ：https://blog.csdn.net/justlpf/article/details/80269146

Thyemleaf介绍：  https://www.cnblogs.com/wotoufahaiduo/p/11178629.html

Spring FrameWork提供对于SQL数据库提供了非常广泛的支持，从直接使用JdbcTemplate的JDBC到类似Hibernate等完备的ORM技术。Spring Data提供一个额外的功能， 直接从接口创建Repository实现， 并使用约定从你的方法名生成查询。

配置数据源（DataSource）

Java的javax.sql.DataSource接口提供了一个标准的使用数据库连接的方法。 传统做法是， 一个DataSource使用一个URL以及相应的证书去构建一个数据库连接。

内嵌数据库的支持

在开发应用的过程中使用内嵌的内存数据库是非常方便的，很明显，内存数据库不提供数据的持久化存储；当应用启动时你需要填充你的数据库，当应用结束时数据将会丢弃。

Spring Boot可以自动的配置内嵌的H2、HSQL、Derby数据库。你不需要提供任何链接URLs，只需要简单的提供一个你需要使用的内嵌数据库的依赖即可。

如果在测试时要使用内嵌数据库的功能，需要注意在默认情况下无论使用多少个应用上下文在整个测试过程中相同的数据库都是可用复用的。如果想要让每个应用上下文使用隔离的内嵌数据库，应该设置spring.datasource.generate-unique-name为ture。

内嵌数据库的使用

本文通过演示H2内嵌数据库的使用来帮助理解在Spring Boot中如何使用内嵌数据库。

要使用H2内嵌数据库，首先需要添加JPA和H2的依赖，但是我们从数据库读取数据之后，需要展示在页面上，所以需要配置一个模板引擎，本文选择thymeleaf作为我们应用的模板引擎，所以也需要添加对thymeleaf的依赖。

添加之后的pom.xml如下：

1.  
   <?xml version="1.0" encoding="UTF-8"?>
2.  
   <projectxmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3.  
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
4.  
   <modelVersion>4.0.0</modelVersion>
5.  
    
6.  
   <groupId>com.springboot</groupId>
7.  
   <artifactId>demo</artifactId>
8.  
   <version>0.0.1-SNAPSHOT</version>
9.  
   <packaging>jar</packaging>
10.  
     
11.  
    <name>demo</name>
12.  
    <description>Demo project for Spring Boot</description>
13.  
     
14.  
    <parent>
15.  
    <groupId>org.springframework.boot</groupId>
16.  
    <artifactId>spring-boot-starter-parent</artifactId>
17.  
    <version>1.5.9.RELEASE</version>
18.  
    <relativePath/> <!-- lookup parent from repository -->
19.  
    </parent>
20.  
     
21.  
    <properties>
22.  
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
23.  
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
24.  
    <java.version>1.8</java.version>
25.  
    </properties>
26.  
     
27.  
    <dependencies>
28.  
    <dependency>
29.  
    <groupId>org.springframework.boot</groupId>
30.  
    <artifactId>spring-boot-starter-data-jpa</artifactId>
31.  
    </dependency>
32.  
     
33.  
    <dependency>
34.  
    <groupId>org.springframework.boot</groupId>
35.  
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
36.  
    </dependency>
37.  
     
38.  
    <dependency>
39.  
    <groupId>org.springframework.boot</groupId>
40.  
    <artifactId>spring-boot-starter-web</artifactId>
41.  
    </dependency>
42.  
     
43.  
    <dependency>
44.  
    <groupId>com.h2database</groupId>
45.  
    <artifactId>h2</artifactId>
46.  
    <scope>runtime</scope>
47.  
    </dependency>
48.  
     
49.  
    <dependency>
50.  
    <groupId>org.springframework.boot</groupId>
51.  
    <artifactId>spring-boot-starter-test</artifactId>
52.  
    <scope>test</scope>
53.  
    </dependency>
54.  
    </dependencies>
55.  
     
56.  
    <build>
57.  
    <plugins>
58.  
    <plugin>
59.  
    <groupId>org.springframework.boot</groupId>
60.  
    <artifactId>spring-boot-maven-plugin</artifactId>
61.  
    </plugin>
62.  
    </plugins>
63.  
    </build>
64.  
    </project>

• 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

对于我们的示例程序来说，我们需要创建一个实体类，类名我们将其命名为Journal，具体详细信息如下。

1.  
   package com.springboot.domain;
2.  
   import java.text.ParseException;
3.  
   import java.text.SimpleDateFormat;
4.  
   import java.util.Date;
5.  
   import javax.persistence.Entity;
6.  
   import javax.persistence.GeneratedValue;
7.  
   import javax.persistence.GenerationType;
8.  
   import javax.persistence.Id;
9.  
   import javax.persistence.Transient;
10.  
     
11.  
    @Entity
12.  
    public classJournal{
13.  
    @Id
14.  
    @GeneratedValue(strategy=GenerationType.AUTO)
15.  
    private Long id;
16.  
    private String title;
17.  
    private Date created;
18.  
    private String summary;
19.  
    @Transient
20.  
    private SimpleDateFormat format = new SimpleDateFormat("MM/dd/yyyy");
21.  
    publicJournal(String title, String summary, String date) throws ParseException{
22.  
    this.title = title;
23.  
    this.summary = summary;
24.  
    this.created = format.parse(date);
25.  
    }
26.  
     
27.  
    Journal(){}
28.  
     
29.  
    public Long getId() {
30.  
    return id;
31.  
    }
32.  
    publicvoidsetId(Long id) {
33.  
    this.id = id;
34.  
    }
35.  
    public String getTitle() {
36.  
    return title;
37.  
    }
38.  
    publicvoidsetTitle(String title) {
39.  
    this.title = title;
40.  
    }
41.  
    public Date getCreated() {
42.  
    return created;
43.  
    }
44.  
     
45.  
    publicvoidsetCreated(Date created) {
46.  
    this.created = created;
47.  
    }
48.  
     
49.  
    public String getSummary() {
50.  
    return summary;
51.  
    }
52.  
     
53.  
    publicvoidsetSummary(String summary) {
54.  
    this.summary = summary;
55.  
    }
56.  
     
57.  
    public String getCreatedAsShort(){
58.  
    return format.format(created);
59.  
    }
60.  
     
61.  
    public String toString(){
62.  
    StringBuilder value = new StringBuilder("JournalEntry(");
63.  
    value.append("Id: ");
64.  
    value.append(id);
65.  
    value.append(",Title: ");
66.  
    value.append(title);
67.  
    value.append(",Summary: ");
68.  
    value.append(summary);
69.  
    value.append(",Created: ");
70.  
    value.append(getCreatedAsShort());
71.  
    value.append(")");
72.  
    return value.toString();
73.  
    }
74.  
    }

• 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

在上面的代码片段中，因为使用了JPA技术，所以你需要使用@Entity, @Id和@GeneratedValue注解，因此这个类被标记作为JPA实体并且能够被持久化到数据库中。你也可以看到，在我们的代码中也使用了@Transient注解，这个注解表示JPA引擎不会持久化被注解的属性，因为上面的代码片中被@Transient注解的属性仅仅只是用来格式化日期。这个类有两个构造函数，一个没有参数，JPA引擎需要这个构造函数，另外一个构造函数需要用来填充数据库的参数。

我们覆盖（override）了一个toString方法，主要用来打印记录。

接下来，我们需要为数据创建一个持久化机制，那么我们就需要使用Spring Data JPA技术了，创建一个接口，继承JpaRepository接口。代码如下。

1.  
   package com.springboot.repository;
2.  
   import com.springboot.domain.Journal;
3.  
   import org.springframework.data.jpa.repository.JpaRepository;
4.  
    
5.  
   public interfaceJournalRepositoryextendsJpaRepository<Journal,Long> {
6.  
   }

• 1
• 2
• 3
• 4
• 5
• 6

上面的代码片所展示的是Spring Data Repository JPA技术，要使用这项技术只需要继承JpaRepository接口即可。JpaRepository是一个标记接口，允许Spring Data Repository引擎识别它并提供必要的代理类来实现基本的CRUD (Create, Read, Update, Delete) 和一些自定义的方法。你可以通过一些类似于findByTitleLike、findBySummary、findByTitleAndSummaryIgnoringCase等等命名约定去实现你的方法。默认情况下，这些方法所实现的功能都会被设置成一个事务。JpaRepository也有一些非常便捷的操作可以对数据进行排序和分页的操作。

接下来，我们需要创建一个Web controller。

1.  
   package com.springboot.web;
2.  
   import com.springboot.repository.JournalRepository;
3.  
   import org.springframework.beans.factory.annotation.Autowired;
4.  
   import org.springframework.stereotype.Controller;
5.  
   import org.springframework.ui.Model;
6.  
   import org.springframework.web.bind.annotation.RequestMapping;
7.  
    
8.  
   @Controller
9.  
   public class JournalController {
10.  
    @Autowired
11.  
    JournalRepository repo;
12.  
     
13.  
    @RequestMapping("/")
14.  
    public String index(Model model){
15.  
    model.addAttribute("journal", repo.findAll());
16.  
    return "index";
17.  
    }
18.  
    }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18

@Controller注解、@Autowired注解、@RequestMapping注解我们不在详细介绍，如果使用过Spring MVC开发过应用，这些注解基本都已经了如指掌。在我们的index方法中，有一个Model类的参数，他用来添加一个名为journal的属性值，该属性的值通过调用JournalRepository接口repo.findAll() 获取。JournalRepository继承自JpaRepository，所以该接口有很多不同的默认方法，findAll方法就是其中之一。该方法返回数据库中所有的实体。

接下来我们需要构建模板文件，在src/main/resources/templates目录下，需要创建一个index.html文件并写入如下内容。

1.  
   <!DOCTYPE html>
2.  
   <htmllang="en"xmlns:th="http://www.thymeleaf.org">
3.  
   <head>
4.  
   <metacharset="utf-8"></meta>
5.  
   <metahttp-equiv="Content-Type"content="text/html"></meta>
6.  
   <title>Spring Boot Journal</title>
7.  
   <linkrel="stylesheet"type="text/css"media="all"href="css/bootstrap.min.css"></link>
8.  
   </head>
9.  
   <body>
10.  
    <h1>Spring Boot Journal</h1>
11.  
    <ulclass="timeline">
12.  
    <divth:each="entry,status : ${journal}">
13.  
    <lith:attr="class=${status.odd}?'timeline-inverted':''">
14.  
    <divclass="tl-circ"></div>
15.  
    <divclass="timeline-panel">
16.  
    <divclass="tl-heading">
17.  
    <h4><spanth:text="${entry.title}">TITLE</span></h4>
18.  
    <p><smallclass="text-muted"><iclass="glyphicon glyphicon-time"></i>
19.  
    <spanth:text="${entry.createdAsShort}">CREATED</span></small></p>
20.  
    </div>
21.  
    <divclass="tl-body">
22.  
    <p><spanth:text="${entry.summary}">SUMMARY</span></p>
23.  
    </div>
24.  
    </div>
25.  
    </li>
26.  
    </div>
27.  
    </ul>
28.  
    </body>
29.  
    </html>

• 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

注意：在static目录下新建一个css目录，添加bootstrap.min.css文件，该文件自行到bootstrap去下载。

现在，就剩下最重要的一步，构建数据和实现应用入口。代码如下;

1.  
   package com.springboot;
2.  
    
3.  
   import com.springboot.domain.Journal;
4.  
   import com.springboot.repository.JournalRepository;
5.  
   import org.springframework.beans.factory.InitializingBean;
6.  
   import org.springframework.boot.SpringApplication;
7.  
   import org.springframework.boot.autoconfigure.SpringBootApplication;
8.  
   import org.springframework.context.annotation.Bean;
9.  
    
10.  
    @SpringBootApplication
11.  
    public class DemoApplication {
12.  
     
13.  
    @Bean
14.  
    InitializingBean saveData(JournalRepository repo){
15.  
    return ()->{
16.  
    repo.save(new Journal("Get to know Spring Boot","Today I will learn Spring Boot","01/01/2016"));
17.  
    repo.save(new Journal("Simple Spring Boot Project","I will do my first Spring Boot Project","01/02/2016"));
18.  
    repo.save(new Journal("Spring Boot Reading","Read more about Spring Boot","02/01/2016"));
19.  
    repo.save(new Journal("Spring Boot in the Cloud","Spring Boot using Cloud Foundry","03/01/2016"));
20.  
    };
21.  
    }
22.  
     
23.  
    public static void main(String[] args) {
24.  
    SpringApplication.run(DemoApplication.class, args);
25.  
    }
26.  
    }

• 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

注意：这里要提及的一点就是saveData方法返回的是一个InitializingBean，这个特殊的类在Spring引擎创建序列化实例时会被调用。在本示例中，这个方法将会在应用完成运行的过程中被执行。

以上基本所有工作已经完成，点击Intellij IDEA的运行按钮运行应用，应用运行成功之后在浏览器输入http://localhost:8080，如果程序不出错，将会出现如下的结果;