Spring_6_SpringBoot_配置属性_整合SSM_SpringBootTest_常用注解_热部署_SpringBootData

SpringBoot 框架

相关概念

**概述：**SpringBoot 设计目的是用来简化 Spring 应用的初始搭建以及开发过程

优点：

• 自动配置（提供约定配置）
• 版本锁定（依赖版本整合）
• 起步依赖（简化依赖配置）
• 辅助功能（内置服务器，…）

创建项目

方式一：自行添加 Springboot 父模块

1. 创建普通 Maven 项目
2. 配置 POM 文件(最简)

<groupId>com.itheima</groupId>
<artifactId>spring-boot-quck-start</artifactId>
<version>1.0-SNAPSHOT</version>

<!-- 1.使用 spring-boot 的父模块 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.5.0</version>
</parent>

<dependencies>
    <!-- 2. 使用 web 的起步依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

3. 定义控制器
4. 创建Spring的启动程序

/**
 * 1.类命名约定：以 Application 结尾
 * 2.这个类应该放在其它所有类的同级包或父包中
 * 3.启动类需要添加注解 @SpringBootApplication
 */
@SpringBootApplication
public class QuickStartApplication
    public static void main(String[] args) {
        //启动Spring的应用程序: 1. 启动类的类名  2. main函数上参数
        SpringApplication.run(QuickStartApplication.class, args);
    }
}

5. 注意：手动创建 SpringBoot 项目时通过 parent 标签来导入 spring-boot-starter-parent 依赖配置实现。

方式二：使用服务商提供的脚手架

1. 选择创建的脚手架，官方脚手架：https://start.spring.io，阿里云脚手架：https://start.aliyun.com 。

2. 选中所需要的依赖，只选择Spring Web即可。

3. 配置POM依赖。

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${spring-boot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

3. SpringBoot项目快速启动。

4. 注意事项：脚手架创建SpringBoot项目时，是通过dependencyManagement标签导入spring-boot-dependencies依赖配置。
   

spring-boot-dependencies 与 spring-boot-starter-parent 差别：

• 继承 spring-boot-starter-parent 其实也算是继承自 spring-boot-dependencies，点开 spring-boot-starter-parent，可以看到 parent 其实也是继承 dependencies，parent里面就增加了一些插件，然后指定了maven编译版本。

起步依赖

• **starter：**SpringBoot 中常见的技术整合依赖搭配，定义了某技术使用的所有依赖坐标，以达到减少依赖配置的目的。
• **parent：**所有SpringBoot项目要继承的依赖，定义了若干个坐标版本号（依赖管理，而非依赖），以达到减少依赖冲突的目的。
• 上述二者配合，使开发时仅需书写groupId、artifactId，而无需指定version。若自行指定version时，需避免版本冲突。

自动配置

分析自动配置（Tomcat为例）：

1. 查看自动配置的spring-boot-autoconfigure的包下的配置文件spring.factories，文件中包含所有Web容器(Tomcat)自动启动的配置类。
2. ServletWebServerFactoryAutoConfiguration中找到Tomcat的启动类。

3. 进入ServerProperties类中查看代码，可以看到端口号的set方法，设置Tomcat的属性值。这个类用来封装服务器启动的属性，类似于一个实体类，用于封装数据的。

public void setPort(Integer port) {
	this.port = port;
}

4. 在ServerProperties类中存在一个静态内部类Tomcat，用于指定Tomcat的属性。
5. 上述所有的属性值都有默认配置，在spring-configuration-metadata.json文件。

{
    "name": "server.port",
    "type": "java.lang.Integer",
    "description": "Server HTTP port.",
    "sourceType": "org.springframework.boot.autoconfigure.web.ServerProperties",
    "defaultValue": 8080
}

SpringBoot 配置

属性配置

• SpringBoot 提供大量约定俗成的配置属性，可以通过在 SpringBoot 配置文件中配置属性及其值，便可覆盖默认配置值。SpringBoot 默认配置文件是 application.properties。
• SpringBoot 官方文档，打开查看附录中的 Application Properties 就可以获取到对应的配置项了。
• 配置属性支持二进制(0b)，八进制(0)，十六进制(0x)，建议字符串标准书写加上引号包裹。

配置文件

SpringBoot中三种常见配置文件格式：

1. application.properties（默认格式）

server.port=80

2. application.yml（主流格式）

server:
  port: 82

3. application.yaml

server:
  port: 82

文件格式配置优先级：

• properties > yml > yaml

文件目录配置优先级：

• classpath:/ < classpath:/config/ < file:./ < file:./config/

全局配置优先级：

• profile配置 > 文件目录优先级 > 文件格式优先级

YAML 配置

概述：

• YAML（YAML Ain’t Markup Language），一种数据序列化格式。
• 优点：
  • 容易阅读。
  • 容易与脚本语言交互。
  • 以数据为核心，重数据轻格式。
• YAML文件扩展名
  • .yml（主流）。
  • .yaml 。

语法规则：

• 大小写敏感

• 属性层级关系使用多行描述，每行结尾使用冒号结束

• 使用缩进表示层级关系，同层级左侧对齐，只允许使用空格（不允许使用Tab键）

• 属性值前面添加空格（属性名与属性值之间使用冒号+空格作为分隔）

• #表示注释

• 数据前面要加空格与冒号隔开

• 数组数据在数据书写位置的下方使用减号作为数据开始符号，每行书写一个数据，减号与数据间空格分隔

  

读取 yml 配置数据：

1. 第一种方式,读取单个数据。

@Value(${enterprise.name})
private String name;

2. 第二种方式，通过 Environment 对象读取。

// Environment中封装了全部配置文件中的数据！
@Autowired
private Environment e;
// 通过Environmen的getProperty方法获取
e.getProperty("enterprise.name")

3. 封装到自定义对象中，SpringBoot 自动完成数据注入，通过 getter、setter。

@Component
@ConfigurationProperties(prefix = "enterprise")
@Data
public class Enterprise {
    private String name;
    private Integer age;
    private String tel;
    private String subject[];
}
// 无 @Component 注解时需在 Spring 配置类上用 @EnableConfigurationProperties 指定被注入类

// 还可把 @ConfigurationProperties 直接定义在 @bean 注解上，注入属性到返回对象中。
@Bean
@ConfigurationProperties(prefix = "enterprise")
public Enterprise enterprise(){
    return new Enterprise();

}

<!-- 当输入 @ConfigurationProperties 注解时，自定义对象封装数据警告解决方案 -->
<!-- 使用 spring-boot-configuration-processor 实现，其作用是生产配置元数据 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

YAML 数据应用：

center:
	dataDir: D:/usr/local/fire/data
    tmpDir: D:/usr/local/fire/tmp
    logDir: D:/usr/local/fire/log
    msgDir: D:/usr/local/fire/msgDir
# 可使用引用格式来定义数据，实则定义变量名后引用变量了，如下：    
baseDir: /usr/local/fire
center:
    dataDir: ${baseDir}/data
    tmpDir: ${baseDir}/tmp
    logDir: ${baseDir}/log
    msgDir: ${baseDir}/msgDir
# 注意事项: 在书写字符串时，若需使用转义字符，需将数据字符串使用双引号括起

多环境配置

yml 文件配置多环境：

#yaml 配置多环境
#环境配置间间隔只能是三个短横，指定多个不同的配置环境和参数。
#使用 spring.profiles.active 指定激活哪个
spring:
profiles:
 active: pro
---
# pro 的配置
spring:
config:
 activate:
   on-profile: pro
server:
port: 80
---
# dev 的配置
spring:
config:
 activate:
   on-profile: dev
server:
port: 81

命令行参数使用多环境：

# 指定哪个配置名
java –jar springboot.jar --spring.profiles.active=test
# 指定具体的参数
java –jar springboot.jar --server.port=88
# 同时指定配置名 端口号
java –jar springboot.jar --server.port=88 --spring.profiles.active=test

Maven 配置多环境：

<profiles>
 <profile>
     <id>dev_env</id>
     <properties>
         <profile.active>dev</profile.active>
     </properties>
     <!-- 默认激活 -->
     <activation>
         <activeByDefault>true</activeByDefault>
     </activation>
 </profile>

 <profile>
     <id>pro_env</id>
     <properties>
         <profile.active>pro</profile.active>
     </properties>
 </profile>

 <profile>
     <id>test_env</id>
     <properties>
         <profile.active>test</profile.active>
     </properties>
 </profile>
</profiles>

<build>
	<resources>
	    <resource>
	        <directory>src/main/resources</directory>
	        <filtering>true</filtering>
	    </resource>
	</resources>
 <plugins>
  <!-- 配置 resources 插件，使用默认替换符${}，无需时配置上面 resources 即可-->
	<!-- 
		<plugin>
         <artifactId>maven-resources-plugin</artifactId>
         <configuration>
             <resources>
                 <resource>
                     <directory>src/main/resources</directory>
                     <filtering>true</filtering>
                 </resource>
             </resources>
             <encoding>utf-8</encoding>
             <useDefaultDelimiters>true</useDefaultDelimiters>
         </configuration>
     </plugin>
	-->
 </plugins>
</build>
<!--原理是在 maven 编译时，将指定文件中的占位符替换为 maven 中指定的属性数据-->

spring:
profiles:
	# SpringBoot 配置文件中引用 Maven 属性
 # active: ${profile.active}
 active: @profile.active@

多模块配置

使用场景：

• 如果在多个模块中都有 application.yml 文件，则会只读取有主启动类中的 yml 文件，不会读取其他模块中的配置文件，例如：A 模块依赖于B模块，在A模块中有一个 application.yml 文件，在 B 模块中有一个 application.yml，如果启动 A 模块中的主启动类，则只会加载 A 模块中的 application.yml 文件，并不会加载 B 模块中的 application.yml 文件。

解决方案：

1. 修改其他模块中的 yml 文件的名字为 application-xxx.yml。
2. 在主启动模块中的 application.yml 中配置如下内容。

spring:
	profiles:
		active: dev
		include: xxx
# SpringBoot 2.4 开始使用 group 属性替代 include 属性
spring:
	profiles:
    	active: dev
        group:
        	"dev": xxx

松散绑定

松散绑定案例：

@Component
@Data
@ConfigurationProperties(prefix = "servers")
public class ServerConfig {
 private String ipAddress;
}

servers:
	ipAddress: 192.168.0.2       # 驼峰模式
	ip_address: 192.168.0.2      # 下划线模式
	ip-address: 192.168.0.2      # 烤肉串模式
	IP_ADDRESS: 192.168.0.2      # 常量模式

松散绑定规则综述：

• 以上 4 种模式最终都可以匹配到 ipAddress 这个属性名。原因是在进行匹配时，配置中的名称要去掉中划线和下划线后，忽略大小写的情况下去与 java 代码中的属性名进行忽略大小写的等值匹配，以上 4 种命名去掉下划线中划线忽略大小写后都是一个词 ipaddress，java 代码中的属性名忽略大小写后也是 ipaddress，这样就可以进行等值匹配了，这就是为什么这 4 种格式都能匹配成功的原因。springboot 官方推荐使用烤肉串模式。
• 松散绑定规则仅针对 springboot 中 @ConfigurationProperties 注解进行属性绑定时有效，对 @Value 注解进行属性映射无效。

计量单位绑定

使用场景：

servers:
	reload: 1
	# reload 的单位是？？？

计量单位绑定方式：

@Component
@Data
@ConfigurationProperties(prefix = "servers")
public class ServerConfig {
 @DurationUnit(ChronoUnit.HOURS)
 private Duration reload;
 @DataSizeUnit(DataUnit.MEGABYTES)
 private DataSize dataSize;
}

API 注解：

• Duration：时间间隔，可通过 @DurationUnit 注解描述时间单位，例如单位为小时（ChronoUnit.HOURS）。
• DataSize：存储空间，可通过 @DataSizeUnit 注解描述存储空间单位，例如单位为MB（DataUnit.MEGABYTES）。

随机属性配置

使用场景：

1. 测试用例的数据固定是不合理的，需使用随机值以确保每次测试的数据都是随机的。
2. 程序中的某项数据的定义需求要求其为随机值。

random 随机属性：

value:
  data1: ${random.int}
  data2: ${random.int(10)}
  data3: ${random.int(5,10)}
  data4: ${random.value}
  data5: ${random.uuid}
  data6: ${random.long}

SpringBoot 整合

整合 JUnit

1. 添加整合 JUnit 起步依赖。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

2. 编写测试类。

// @SpringBootTest(classes = Application.class)
// @SpringBootTest = @RunWith(JUnit4)/@ExtendWith(JUnit5) + @ContextConfiguratio
@SpringBootTest
// 测试完事务回滚
@Transactional 
public class BookTest {
    @Autowired
    private BookService bookService;
    //有Bean注入时，需要指定容器
    //@SpringBootTest(classes = Application.class)
    //或
    //@ContextConfiguration(classes = SpringConfig.class)

    @Test
    @Rollback(value = false) // 取消事务回滚
    public void testSave() {
        bookService.save();
    }
}

整合 SSM-Druid

1. 创建 SpringBoot 工程，编辑 pom 配置。

<parent>
    <artifactId>spring-boot-starter-parent</artifactId>
    <groupId>org.springframework.boot</groupId>
    <version>2.5.0</version>
</parent>

<dependencies>
    <!-- mybatis -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.2.0</version>
    </dependency>

    <!-- 连接池 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.2.8</version>
    </dependency>

    <!-- 测试 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>

    <!-- lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>

    <!-- mysql驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.22</version>
        <scope>runtime</scope>
    </dependency>
</dependencies>

2. 修改 application.yml 文件，设置数据源参数。

# 数据源的配置，可以指定为druid的连接池
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    username: root
    password: root
    url: jdbc:mysql:///ssm_db
    # serverTimezone=Asia/Shanghai 时区，亚洲上海
    # characterEncoding=utf8 字符集
    # useUnicode=true 采用unicode编码格式
    # useSSL=false mysql8要求的安全设置
    type: com.alibaba.druid.pool.DruidDataSource


# 注意事项：SpringBoot版本低于2.4.3(不含)，Mysql驱动版本大于8.0时，需要在url连接串中配置时区，或在MySQL数据库端配置时区解决此问题

mybatis:
  configuration:
	# 显示sql语句
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    map-underscore-to-camel-case: true
    type-aliases-package: com.lxl.pojo

3. 定义数据层接口与映射配置。

@Data
public class Book {
    private Integer id;
    private String type;
    private String name;
    private String description;
}

4. dao 层接口上添加 @Mapper 注解。

@Mapper
public interface BookDao {
    @Select("select * from tbl_book where id=#{id}")
    Book getById(Integer id);
}
// 可在 SpringBoot 的启动类上使用 @MapperScan("com.lxl.dao") 注解批量扫描

5. 启动类要在上一级目录中，并扫描 dao 包下的 Mapper 生成代理对象存入 IOC 容器。

@SpringBootApplication
@EnableWebMvc
@MapperScan("com.lxl.dao")
@ServletComponentScan //扫描配置原始的Servlet服务
@Slf4j
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class);
        log.info("项目启动成功");
    }
}

6. 测试类中注入 dao 层接口。

@SpringBootTest
class SpringBootMybatisApplicationTest {
    @Autowired
    private BookDao bookDao;

    @Test
    public void testGetById() {
        Book book = bookDao.getById(1);
    }
}

7. 页面的整合，将页面复制到 resources 目录下 static 目录，这是 springboot 默认的静态文件所在的目录。

SpringBoot 注解

• **@SpringBootApplication：**SpringBoot 项目最核心的主键。每个 SpringBoot 启动类上都有，用于引导 SpringBoot 项目启动加载。
• **@ComponentScan：**用于扫描 Spring 的组件，并将其放入 IOC 容器。
• **@Configuration：**声明该类为配置类。
• **@ConditionOnClass：**一般和 @Configuration 注解同时使用，项目中导入了@ConditionOnClass声明的类，@Configuration 中的 @Bean 才会构建。
• **@ControllerAdvice和@RestControllerAdvice：**声明该类为全局异常拦截类。

SpringBoot 装配

启动器介绍

Spring Boot启动器的作用：

• 配置一个启动器它会把整合这个框架或模块的依赖全部导入。
• 每一个启动器都有一个自动配置类，实现自动整合Spring。
• 每一个启动器都有一个属性类，提供了默认的属性配置。

自动装配注解

实现自动装配的两点:

1. 注解: @SpringBootApplication。
2. run方法: SpringApplication.run()，运行spring应用(创建spring容器)。

@SpringBootApplication 注解组成：

• @SpringBootConfiguration 【作用: 定义配置类】

• @EnableAutoConfiguration 【作用: 启用自动配置】

• @ComponentScan 【作用: 组件扫描】

@EnableAutoConfiguration 注解组成：

• @Import(AutoConfigurationImportSelector.class)：
  • AutoConfigurationImportSelector 类中利用getAutoConfigurationEntry(annotationMetadata)方法给容器中批量导入一些组件。
  • 调用List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes)获取到所有需要导入到容器中的配置类。
  • 利用工厂加载Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader)得到所有的组件。
  • 从 META-INF/spring.factories 位置来加载一个文件。默认扫描我们当前系统里面所有 META-INF/spring.factories 位置的文件。
• @AutoConfigurationPackage注解作用：
  • @Import(AutoConfigurationPackages.Registrar.class) 给容器中导入一系列组件。
  • 指定了默认的包规则。
• @ComponentScan 注解作用：
  • 配置组件扫描的指令。提供了类似与<context:component-scan>标签的作用。
  • 通过 basePackageClasses 或者 basePackages 属性来指定要扫描的包。如果没有指定这些属性，那么将从声明这个注解的类所在的包开始，扫描包及子包。

自动装配原理

Spring Boot自动配置原理:

• SpringApplication 会寻找 META-INF/spring.factories 文件，读取其中以EnableAutoConfiguration 为 key 的所有类的名称, 这些类就是提前写好的自动配置类。
• 这些配置类不一定全部生效，因为有 @ConditionalOnXxx 注解，满足一定条件才会生效， 通过自动配置类的 @bean 注解所在的方法创建对应的对象。
• 我们可以通过配置 application.yml 或 application.properties 文件，来覆盖自动配置中的默认属性。

SpringBoot 热部署

1. 导入开发者工具对应的坐标。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
</dependency>

2. 配置文件中添加参与热部署的文件。

spring:
  devtools:
    restart:
      # 设置不参与热部署的文件或文件夹，以下为默认值
      exclude: 
		- /META-INF/resources
		- /resources
		- /static
		- /public
		- /templates

3. 手动构建项目，可以使用快捷键 CTRL + F9。

4. 自动构建项目，配置 IDEA 启动自动构建。

SpringBoot 测试

测试属性/参数

测试临时属性配置：

// properties 属性为当前测试用例添加临时的属性配置
@SpringBootTest(properties = {"test.prop=testValue1"})
public class PropTest {
 @Value("${test.prop}")
 private String prop;

 @Test
 void testProperties(){
     System.out.println(prop);
 }
}

测试临时参数配置：

// args 属性为当前测试用例添加临时的命令行参数
@SpringBootTest(args={"--test.prop=testValue2"})
public class PropTest {
 @Value("${test.prop}")
 private String prop;

 @Test
 void testProperties(){
     System.out.println(prop);
 }
}

测试模拟 Web

1. 测试类中启用 web 环境，配置 Mock 模拟设置。

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
//开启虚拟MVC调用
@AutoConfigureMockMvc
public class WebTest {	
}
// MOCK：根据当前设置确认是否启动web环境，例如使用了Servlet的API就启动web环境，属于适配性的配置
// DEFINED_PORT：使用自定义的端口作为web服务器端口
// RANDOM_PORT：使用随机端口作为web服务器端口
// NONE：不启动web环境

2. 注入虚拟调用的对象MockMVC，创建虚拟请求，并调用测试的 API 接口。

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
//开启虚拟MVC调用
@AutoConfigureMockMvc
public class WebTest {
    @Test
    void testWeb(@Autowired MockMvc mvc) throws Exception {
		// 创建虚拟请求，当前访问 localhost:8080/book
		MockHttpServletRequestBuilder builder = MockMvcRequestBuilders.get("/books");
		// 执行对应的请求
		mvc.perform(builder);

		// 设定预期值与真实值进行比较
		// 成功测试通过，失败测试报异常

         // 设置响应状态码预计值 200，进行匹配
		StatusResultMatchers status = MockMvcResultMatchers.status();
		ResultMatcher ok = status.isOk();
		action.andExpect(ok);

         // 设置响应头预计值，进行匹配
		HeaderResultMatchers header = MockMvcResultMatchers.header();
		ResultMatcher contentType = header.string("Content-Type", "application/json");
		action.andExpect(contentType);

		// 设置 JSON 格式响应结果，进行匹配
		ContentResultMatchers content = MockMvcResultMatchers.content();
		ResultMatcher result = content.json("{\"id\":1,\"name\":\"book1\"}");
		action.andExpect(result);
    }
}

SpringBoot Data

数据源

springboot 提供的嵌数据源技术：

• HikariCP：默认内置数据源使用。
• Tomcat DataSource：HikartCP 坐标排除掉后默认使用 Tomcat 提供的 DataSource。
• Commons DBCP：既不使用 HikartCP 也不使用Tomcat DataSource 时默认使用 Commons DBCP。

持久层

JdbcTemplate：

• JdbcTemplate 是 Spring 提供的一套 JDBC 模板框架，利用 AOP 技术来解决直接使用 JDBC 时大量重复代码的问题。JdbcTemplate 虽然没有 MyBatis 那么灵活，但是比直接使用 JDBC 要方便很多。
• Spring Boot 中对 JdbcTemplate 提供了自动化配置 JdbcTemplateAutoConfiguration。

使用步骤：

1. 导入 jdbc starter 对应的坐标 。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!-- 
	spring-boot-starter-jdbc 中提供了 spring-jdbc, 
	另外还加入了数据库驱动依赖和数据库连接池依赖。
-->

2. 配置数据源属性。

spring:
  datasource:
    username: root
    password: '0723'
    url: jdbc:mysql://localhost:3306/jdbc_test
    driver-class-name: com.mysql.cj.jdbc.Driver

3. 自动装配JdbcTemplate对象，实现持久化操作。

@Repository
public class BookDao {
	@Autowired
	JdbcTemplate jdbcTemplate;

	// 添加一个对象
	public int addBook(Book book) {
	    return jdbcTemplate.update(
	        "INSERT INTO book (name,author) VALUES (?, ?)",
	        book.getName(), 
	        book.getAuthor()
	    );
	}

	// 添加多个对象
	public int addBooks(List<Book> books) {
	    ArrayList<Object[]> datas = new ArrayList<>();
	    for(Book book:books){
	        datas.add(new Object[]{book.getName(),book.getAuthor()})
	    }
	    return jdbcTemplate.batchUpdate(
	        "INSERT INTO book (name,author) VALUES (?, ?)",
	        datas
	    );
	}

	// 更新一个对象
	public int updateBook(Book book) {
	    return jdbcTemplate.update(
	        "UPDATE book SET name=?, author=? WHERE id=?",
	        book.getName(),
	        book.getAuthor(), 
	        book.getId()
	    );
	}

	// 删除一个对象
	public int deleteBookById(Integer id) {
	    return jdbcTemplate.update("DELETE FROM book WHERE id=?", id);
	}

	// 查询一个对象
	public Book getBookById(Integer id) {
	    return jdbcTemplate.queryForObject(
	        "select * FROM book WHERE id=?",
	        new BeanPropertyRowMapper<>(Book.class), 
	        id
	    );
	}

	// 查询多个对象
	public List<Book> getAllBooks() {
	    return jdbcTemplate.query(
	        "select * FROM book",
	        new BeanPropertyRowMapper<>(Book.class)
	    );
	}

    // 使用 jdbcTemplate 完成 jdbc 原生查询
    public Book getBookByIdUseJDBC(Integer id){
		User user = jdbcTemplate.execute(sql, new PreparedStatementCallback<User>() {
		    @Override
		    public User doInPreparedStatement(PreparedStatement ps) throws SQLException, DataAccessException {
		        User user = null;
		        ps.setInt(1, 5);
		        ResultSet rs = ps.executeQuery();
		        if (rs.next()) {
		            user = new User();
		            user.setId(rs.getInt("id"));
		            user.setRealName(rs.getString("real_name"));
		            user.setAge(rs.getInt("age"));
		        }
		        return user;
		    }
		});
        return user;
    }
}

数据库

springboot 提供了内置数据库：

• H2
• HSQL
• Derby

使用 H2 内嵌数据库：

1. 导入 H2 和 web 坐标。

<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
</dependency
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

2. 通过配置开启 H2 数据库控制台访问程序，并设置数据源配置。

spring:
  h2:
    console:
      enabled: true
      path: /h2
  datasource:
    url: jdbc:h2:~/test
    hikari:
      driver-class-name: org.h2.Driver
      username: sa
      password: 123456
datasource:
  url: jdbc:h2:~/test 
  # jdbc:h2:~/test 用户目录下创建数据库数据
  # jdbc:h2:file:./test 文件路径下创建数据库数据
  # jdbc:h2:mem:test 内存创建数据库数据
  hikari:
    driver-class-name: org.h2.Driver
    username: sa
    password: 123456
# datasource 的配置信息会作为 H2 数据库的初始化信息。

3. 使用 JdbcTemplate 访问 H2 数据库。