<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<version>2.2.2.RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-json</artifactId>
<version>2.2.2.RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<version>2.2.2.RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
<version>2.2.2.RELEASE</version>
<scope>compile</scope>
<exclusions>
<exclusion>
<artifactId>tomcat-embed-el</artifactId>
<groupId>org.apache.tomcat.embed</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.2.2.RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.2.RELEASE</version>
<scope>compile</scope>
</dependency>
</dependencies>

https://github.com/spring-projects/spring-boot/tree/v2.1.0.RELEASE/spring-boot-project/spring-bo

ot-starters

https://mvnrepository.com/search?q=starter

Spring Boot 除了提供有上述介绍的 Web 依赖启动器外，还提供了其他许多开发场景的相关依赖，

我们可以打开 Spring Boot 官方文档，搜索 “Starters” 关键字查询场景依赖启动器

列出了 Spring Boot 官方提供的部分场景依赖启动器，这些依赖启动器适用于不同的场景开发，使用时只需要在pox.xml 文件中导入对应的依赖启动器即可。

需要说明的是， Spring Boot 官方并不是针对所有场景开发的技术框架都提供了场景启动器，例如数据库操作框架MyBatis 、阿里巴巴的 Druid 数据源等， Spring Boot 官方就没有提供对应的依赖启动器。为了充分利用Spring Boot 框架的优势，在 Spring Boot 官方没有整合这些技术框架的情况下， MyBatis 、Druid等技术框架所在的开发团队主动与 Spring Boot 框架进行了整合，实现了各自的依赖启动器，例如mybatis-spring-boot-starter、 druid-spring-boot-starter 等。我们在 pom.xml 文件中引入这些第三方的依赖启动器时，切记要配置对应的版本号

2.2 自动配置

概念：能够在我们添加 jar 包依赖的时候，自动为我们配置一些组件的相关配置，我们无需配置或者只需要少量配置就能运行编写的项目

问题： Spring Boot 到底是如何进行自动配置的，都把哪些组件进行了自动配置？

Spring Boot 应用的启动入口是 @SpringBootApplication 注解标注类中的 main() 方法，

@SpringBootApplication ： SpringBoot 应用标注在某个类上说明这个类是 SpringBoot 的主配置

类， SpringBoot 就应该运行这个类的 main() 方法启动 SpringBoot 应用。

下面，查看 @SpringBootApplication 内部源码进行分析 ，核心代码具体如下

@SpringBootApplication
public class SpringbootDemoApplication {
public static void main(String[] args) {
SpringApplication.run(SpringbootDemoApplication.class, args);
}
}

// 自动配置包
@AutoConfigurationPackage
// Spring的底层注解@Import，给容器中导入一个组件；
// 导入的组件是AutoConfigurationPackages.Registrar.class
@Import(AutoConfigurationImportSelector.class)
// 告诉SpringBoot开启自动配置功能，这样自动配置才能生效。
public @interface EnableAutoConfiguration {
String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
// 返回不会被导入到 Spring 容器中的类
Class<?>[] exclude() default {};
// 返回不会被导入到 Spring 容器中的类名
String[] excludeName() default {};
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import({Registrar.class}) // 导入Registrar中注册的组件
public @interface AutoConfigurationPackage {
}

（2） @Import({AutoConfigurationImportSelector.class}) 注解

将 AutoConfigurationImportSelector 这个类导入到 Spring 容器中，

AutoConfigurationImportSelector 可以帮助 Springboot 应用将所有符合条件的 @Configuration

配置都加载到当前 SpringBoot 创建并使用的 IOC 容器 ( ApplicationContext ) 中。

继续研究 AutoConfigurationImportSelector 这个类，通过源码分析这个类中是通过 selectImports 这个方法告诉springboot 都需要导入那些组件：

 深入研究loadMetadata方法

 AutoConfigurationImportSelector类 getAutoConfigurationEntry方法

protected AutoConfigurationEntry
getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
AnnotationMetadata annotationMetadata) {
//判断EnabledAutoConfiguration注解有没有开启,默认开启
if (!isEnabled(annotationMetadata)) {
return EMPTY_ENTRY;
}
//获得注解的属性信息
AnnotationAttributes attributes = getAttributes(annotationMetadata);
//获取默认支持的自动配置类列表
List<String> configurations =
getCandidateConfigurations(annotationMetadata, attributes);
//去重
configurations = removeDuplicates(configurations);
//去除一些多余的配置类，根据EnabledAutoConfiguratio的exclusions属性进行排除
Set<String> exclusions = getExclusions(annotationMetadata, attributes);
checkExcludedClasses(configurations, exclusions);
configurations.removeAll(exclusions);
//根据pom文件中加入的依赖文件筛选中最终符合当前项目运行环境对应的自动配置类
configurations = filter(configurations, autoConfigurationMetadata);
//触发自动配置导入监听事件
fireAutoConfigurationImportEvents(configurations, exclusions);
return new AutoConfigurationEntry(configurations, exclusions);
}

深入 getCandidateConfigurations 方法

这个方法中有一个重要方法 loadFactoryNames ，这个方法是让 SpringFactoryLoader 去加载一些组件的名字。

 继续点开loadFactory方法

public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable
ClassLoader classLoader) {
//获取出入的键
String factoryClassName = factoryClass.getName();
return
(List)loadSpringFactories(classLoader).getOrDefault(factoryClassName,
Collections.emptyList());
}
private static Map<String, List<String>> loadSpringFactories(@Nullable
ClassLoader classLoader) {
MultiValueMap<String, String> result =
(MultiValueMap)cache.get(classLoader);
if (result != null) {
return result;
} else {
try {
//如果类加载器不为null，则加载类路径下spring.factories文件，将其中设置的
配置类的全路径信息封装 为Enumeration类对象
Enumeration<URL> urls = classLoader != null ?
classLoader.getResources("META-INF/spring.factories") :
ClassLoader.getSystemResources("META-INF/spring.factories");
LinkedMultiValueMap result = new LinkedMultiValueMap();
//循环Enumeration类对象，根据相应的节点信息生成Properties对象，通过传入的
键获取值，在将值切割为一个个小的字符串转化为Array，方法result集合中
while(urls.hasMoreElements()) {
URL url = (URL)urls.nextElement();
UrlResource resource = new UrlResource(url);
Properties properties =
PropertiesLoaderUtils.loadProperties(resource);
Iterator var6 = properties.entrySet().iterator();
while(var6.hasNext()) {
Entry<?, ?> entry = (Entry)var6.next();
String factoryClassName =
((String)entry.getKey()).trim();
String[] var9 =
StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
int var10 = var9.length;
for(int var11 = 0; var11 < var10; ++var11) {
String factoryName = var9[var11];
result.add(factoryClassName, factoryName.trim());
}
}
}
cache.put(classLoader, result);
return result;

public final class SpringFactoriesLoader {
public static final String FACTORIES_RESOURCE_LOCATION = "METAINF/spring.factories";
}

它其实是去加载一个外部的文件，而这文件是在

 

@EnableAutoConfiguration 就是从 classpath 中搜寻 META-INF/spring.factories 配置文件，并将其中

org.springframework.boot.autoconfigure.EnableutoConfiguration 对应的配置项通过反射（ Java

Refletion ）实例化为对应的标注了 @Configuration 的 JavaConfig 形式的配置类，并加载到 IOC 容器中 以刚刚的项目为例，在项目中加入了 Web 环境依赖启动器，对应的 WebMvcAutoConfiguration 自动配置类就会生效，打开该自动配置类会发现，在该配置类中通过全注解配置类的方式对Spring MVC 运行所需环境进行了默认配置，包括默认前缀、默认后缀、视图解析器、MVC 校验器等。而这些自动配置类的本质是传统Spring MVC 框架中对应的 XML 配置文件，只不过在 Spring Boot 中以自动配置类的形式进行了预先配置。因此，在Spring Boot 项目中加入相关依赖启动器后，基本上不需要任何配置就可以运行程序，当然，我们也可以对这些自动配置类中默认的配置进行更改

总结

因此 springboot 底层实现自动配置的步骤是：

1. springboot 应用启动；

2. @SpringBootApplication 起作用；

3. @EnableAutoConfiguration ；

4. @AutoConfigurationPackage ：这个组合注解主要是

@Import(AutoConfigurationPackages.Registrar.class) ，它通过将 Registrar 类导入到容器中，而

Registrar 类作用是扫描主配置类同级目录以及子包，并将相应的组件导入到 springboot 创建管理的

容器中；

5. @Import(AutoConfigurationImportSelector.class) ：它通过将 AutoConfigurationImportSelector

类导入到容器中， AutoConfigurationImportSelector 类作用是通过 selectImports 方法执行的过程

中，会使用内部工具类 SpringFactoriesLoader ，查找 classpath 上所有 jar 包中的 META

INF/spring.factories 进行加载，实现将配置类信息交给 SpringFactory 加载器进行一系列的容器创

建过程

3. @ComponentScan 注解

@ComponentScan 注解具体扫描的包的根路径由 Spring Boot 项目主程序启动类所在包位置决定，

在扫描过程中由前面介绍的 @AutoConfigurationPackage 注解进行解析，从而得到 Spring Boot 项目主程序启动类所在包的具体位置

总结：

@SpringBootApplication 的注解的功能就分析差不多了， 简单来说就是 3 个注解的组合注解：

|- @SpringBootConfiguration
|- @Configuration //通过javaConfig的方式来添加组件到IOC容器中
|- @EnableAutoConfiguration
|- @AutoConfigurationPackage //自动配置包，与@ComponentScan扫描到的添加到IOC
|- @Import(AutoConfigurationImportSelector.class) //到METAINF/spring.factories中定义的bean添加到IOC容器中
|- @ComponentScan //包扫描

3. SpringBoot 数据访问

3.1 Spring Boot 整合 MyBatis

MyBatis 是一款优秀的持久层框架， Spring Boot 官方虽然没有对 MyBatis 进行整合，但是 MyBatis

团队自行适配了对应的启动器，进一步简化了使用 MyBatis 进行数据的操作

因为 Spring Boot 框架开发的便利性，所以实现 Spring Boot 与数据访问层框架（例如 MyBatis ）的

整合非常简单，主要是引入对应的依赖启动器，并进行数据库相关参数设置即可

基础环境搭建：

（ 1 ）数据准备

在 MySQL 中，先创建了一个数据库 springbootdata ，然后创建了两个表 t_article 和 t_comment 并

向表中插入数据。其中评论表 t_comment 的 a_id 与文章表 t_article 的主键 id 相关联

# 创建数据库
CREATE DATABASE springbootdata;
# 选择使用数据库
USE springbootdata;
# 创建表t_article并插入相关数据
DROP TABLE IF EXISTS t_article;
CREATE TABLE t_article (
id int(20) NOT NULL AUTO_INCREMENT COMMENT '文章id',
title varchar(200) DEFAULT NULL COMMENT '文章标题',
content longtext COMMENT '文章内容',
PRIMARY KEY (id)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
INSERT INTO t_article VALUES ('1', 'Spring Boot基础入门', '从入门到精通讲解...');
INSERT INTO t_article VALUES ('2', 'Spring Cloud基础入门', '从入门到精通讲
解...');
# 创建表t_comment并插入相关数据
DROP TABLE IF EXISTS t_comment;
CREATE TABLE t_comment (
id int(20) NOT NULL AUTO_INCREMENT COMMENT '评论id',
content longtext COMMENT '评论内容',
author varchar(200) DEFAULT NULL COMMENT '评论作者',
a_id int(20) DEFAULT NULL COMMENT '关联的文章id',
PRIMARY KEY (id)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
INSERT INTO t_comment VALUES ('1', '很全、很详细', 'lucy', '1');
INSERT INTO t_comment VALUES ('2', '赞一个', 'tom', '1');
INSERT INTO t_comment VALUES ('3', '很详细', 'eric', '1');
INSERT INTO t_comment VALUES ('4', '很好，非常详细', '张三', '1');
INSERT INTO t_comment VALUES ('5', '很不错', '李四', '2');

（ 2 ）创建项目，引入相应的启动器

（ 3 ）编写与数据库表 t_comment 和 t_article 对应的实体类 Comment 和 Article

public class Comment {
private Integer id;
private String content;
private String author;
private Integer aId;
}

public class Article {
private Integer id;
private String title;
private String content;
}

（ 4 ）编写配置文件

        （1）在application.properties 配置文件中进行数据库连接配置

# MySQL数据库连接配置
spring:
datasource:
url: jdbc:mysql://localhost:3306/springbootdata?
serverTimezone=UTC&characterEncoding=UTF-8
username: root
password: wu7787879

注解方式整合 Mybatis

需求：实现通过 ID 查询 Comment 信息

（ 1 ）创建一个对 t_comment 表数据操作的接口 CommentMapper

public interface CommentMapper {
@Select("SELECT * FROM t_comment WHERE id =#{id}")
public Comment findById(Integer id);
}

（ 2 ）在 Spring Boot 项目启动类上添加 @MapperScan("xxx") 注解

@SpringBootApplication
@MapperScan("com.lagou.mapper")
public class Springboot02MybatisApplication {
public static void main(String[] args) {
SpringApplication.run(Springboot02MybatisApplication.class, args);
}
}

（ 3 ）编写测试方法

@RunWith(SpringRunner.class)
@SpringBootTest
class SpringbootPersistenceApplicationTests {
@Autowired
private CommentMapper commentMapper;
@Test
void contextLoads() {
Comment comment = commentMapper.findById(1);
System.out.println(comment);
}
}

打印结果：

控制台中查询的 Comment 的 aId 属性值为 null ，没有映射成功。这是因为编写的实体类 Comment

中使用了驼峰命名方式将 t_comment 表中的 a_id 字段设计成了 aId 属性，所以无法正确映射查询结果。

为了解决上述由于驼峰命名方式造成的表字段值无法正确映射到类属性的情况，可以在 Spring Boot 全局 配置文件application.properties 中添加开启驼峰命名匹配映射配置，示例代码如下

#开启驼峰命名匹配映射
mybatis:
configuration:
map-underscore-to-camel-case: true

打印结果：

配置文件的方式整合 MyBatis

第一、二步骤使用 Free Mybatis plugin 插件生成

（ 1 ）创建一个用于对数据库表 t_article 数据操作的接口 ArticleMapper

@Mapper
public interface ArticleMapper {
public Article selectArticle(Integer id);
}

（ 2 ）创建 XML 映射文件

resources 目录下创建一个统一管理映射文件的包 mapper ，并在该包下编写与 ArticleMapper 接口方

应的映射文件 ArticleMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.lagou.mapper.ArticleMapper">
<select id="selectArticle" resultType="Article">
select * from Article
</select>
</mapper>

（ 3 ）配置 XML 映射文件路径

在项目中编写的 XML 映射文件， Spring Boot 并无从知晓，所以无法扫描到该自定义编写的 XML 配置文 件，还必须在全局配置文件application.properties 中添加 MyBatis 映射文件路径的配置，同时需要添加实体类别名映射路径，示例代码如下

mybatis:
#配置MyBatis的xml配置文件路径
mapper-locations: classpath:mapper/*.xml
#配置XML映射文件中指定的实体类别名路径
type-aliases-package: com.lagou.base.pojo

（ 4 ）编写单元测试进行接口方法测试

@Autowired
private ArticleMapper articleMapper;
@Test
void contextLoads2() {
Article article = articleMapper.selectByPrimaryKey(1);
System.out.println(article);
}

打印结果：

3.2 Spring Boot 整合 Redis

（ 1 ）添加 Redis 依赖包

在项目的 pom.xml 中添加如下：

<!-- redis依赖包 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

（ 2 ）配置 Redis 数据库连接

在 application.properties 中配置 redis 数据库连接信息，如下：

#redis配置
#Redis服务器地址
spring.redis.host=127.0.0.1
#Redis服务器连接端口
spring.redis.port=6379
#Redis数据库索引（默认为0）
spring.redis.database=0
#连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=50
#连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=3000
#连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=20
#连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=2
#连接超时时间（毫秒）
spring.redis.timeout=5000

（ 3 ）编写 Redis 操作工具类

将 RedisTemplate 实例包装成一个工具类，便于对 redis 进行数据操作。

package com.lagou.utils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;
@Component
public class RedisUtils {
@Autowired
private RedisTemplate redisTemplate;
/**
* 读取缓存
*
* @param key
* @return
*/
public Object get(final String key) {
return redisTemplate.opsForValue().get(key);
}
/**
* 写入缓存
*/
public boolean set( String key, Object value) {
boolean result = false;
try {
redisTemplate.opsForValue().set(key, value,1, TimeUnit.DAYS);
result = true;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
/**
* 更新缓存
*/
public boolean getAndSet(final String key, String value) {
boolean result = false;
try {
redisTemplate.opsForValue().getAndSet(key, value);
result = true;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
/**
* 删除缓存
*/
public boolean delete(final String key) {
boolean result = false;
try {
redisTemplate.delete(key);
result = true;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
}

（ 4 ）测试

写一个测试用例类来完成对 redis 的整合

@RunWith(SpringRunner.class)
@SpringBootTest
class Springboot02MybatisApplicationTests {
@Autowired
private RedisUtils redisUtils;
@Autowired
private CommentMapper commentMapper;
@Test
public void setRedisData() {
redisUtils.set("article_1",articleMapper.selectByPrimaryKey(1));
System.out.println("success");
}
@Test
public void getRedisData() {
Article article = (Article) redisUtils.get("article_1");
System.out.println(article);
}

4. SpringBoot 视图技术

4.1 支持的视图技术

前端模板引擎技术的出现，使前端开发人员无需关注后端业务的具体实现，只关注自己页面的呈现效果即可，并且解决了前端代码错综复杂的问题、实现了前后端分离开发。Spring Boot 框架对很多常用的模板引擎技术（如：FreeMarker 、 Thymeleaf 、 Mustache 等）提供了整合支持

Spring Boot 不太支持常用的 JSP 模板，并且没有提供对应的整合配置，这是因为使用嵌入式 Servlet 容器的Spring Boot 应用程序对于 JSP 模板存在一些限制 ：

在 Jetty 和 Tomcat 容器中， Spring Boot 应用被打包成 war 文件可以支持 JSP 。但 Spring Boot 默认使

用嵌入式 Servlet 容器以 JAR 包方式进行项目打包部署，这种 JAR 包方式不支持 JSP 。

如果使用 Undertow 嵌入式容器部署 Spring Boot 项目，也不支持 JSP 模板。（ Undertow 是红帽公

司开发的一款基于 NIO 的高性能 Web 嵌入式服务器）

Spring Boot 默认提供了一个处理请求路径 “/error” 的统一错误处理器，返回具体的异常信息。使用

JSP 模板时，无法对默认的错误处理器进行覆盖，只能根据 Spring Boot 要求在指定位置定制错误页

面。

上面对 Spring Boot 支持的模板引擎进行了介绍，并指出了整合 JSP 模板的一些限制。接下来，对其

中常用的 Thymeleaf 模板引擎进行介绍，并完成与 Spring Boot 框架的整合实现

4.2 Thymeleaf

Thymeleaf 是一种现代的基于服务器端的 Java 模板引擎技术，也是一个优秀的面向 Java 的 XML 、

XHTML 、 HTML5 页面模板，它具有丰富的标签语言、函数和表达式，在使用 Spring Boot 框架进行页面设计时，一般会选择Thymeleaf 模板

4.2.1 Thymeleaf 语法

常用标签

在 HTML 页面上使用 Thymeleaf 标签， Thymeleaf 标签能够动态地替换掉静态内容，使页面动态展示。

为了大家更直观的认识 Thymeleaf ，下面展示一个在 HTML 文件中嵌入了 Thymeleaf 的页面文件，示例代码如下：

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<link rel="stylesheet" type="text/css" media="all"
href="../../css/gtvg.css" th:href="@{/css/gtvg.css}" />
<title>Title</title>
</head>
<body>
<p th:text="${hello}">欢迎进入Thymeleaf的学习</p>
</body>
</html>

上述代码中， “xmlns:th=" http://www.thymeleaf.org "“ 用于引入 Thymeleaf 模板引擎标签，使用关键字 “th”标注标签是 Thymeleaf 模板提供的标签，其中， “th:href” 用于引入外联样式文件， “th:text” 用于动态显示标签文本内容。

除此之外， Thymeleaf 模板提供了很多标签，接下来，通过一张表罗列 Thymeleaf 的常用标签

th ：标签	说明
th:insert	布局标签，替换内容到引入的文件
th:replace	页面片段包含（类似 JSP 中的 include 标签）
th:each	元素遍历（类似 JSP 中的 c:forEach 标签）
th:if	条件判断，如果为真
th:unless	条件判断，如果为假
th:switch	条件判断，进行选择性匹配
th:case	条件判断，进行选择性匹配
th:value	属性值修改，指定标签属性值
th:href	用于设定链接地址
th:src	用于设定链接地址
th:text	用于指定标签显示的文本内容

标准表达式

Thymeleaf 模板引擎提供了多种标准表达式语法，在正式学习之前，先通过一张表来展示其主要语法及说明

说明	表达式语法
变量表达式	${...}
选择变量表达式	*{...}
消息表达式	#{...}
链接 URL 表达式	@{...}
片段表达式	~{...}

1 ．变量表达式 ${...}

变量表达式 ${...} 主要用于获取上下文中的变量值，示例代码如下：

<p th:text="${title}">这是标题</p>

示例使用了 Thymeleaf 模板的变量表达式 ${...} 用来动态获取 P 标签中的内容，如果当前程序没有启动或者当前上下文中不存在title 变量，该片段会显示标签默认值 “ 这是标题 ” ；如果当前上下文中存在 title 变量并且程序已经启动，当前P 标签中的默认文本内容将会被 title 变量的值所替换，从而达到模板引擎页面数据动态替换的效果

同时， Thymeleaf 为变量所在域提供了一些内置对象，具体如下所示

# ctx：上下文对象
# vars：上下文变量
# locale：上下文区域设置
# request：（仅限Web Context）HttpServletRequest对象
# response：（仅限Web Context）HttpServletResponse对象
# session：（仅限Web Context）HttpSession对象
# servletContext：（仅限Web Context）ServletContext对象

结合上述内置对象的说明，假设要在 Thymeleaf 模板引擎页面中动态获取当前国家信息，可以使用

#locale 内置对象，示例代码如下

The locale country is: <span th:text="${#locale.country}">US</span>.

上述代码中，使用 th:text="${#locale.country}" 动态获取当前用户所在国家信息，其中标签内默认

内容为 US （美国），程序启动后通过浏览器查看当前页面时， Thymeleaf 会通过浏览器语言设置来识别当前用户所在国家信息，从而实现动态替换

2 ．选择变量表达式 *{...}

选择变量表达式和变量表达式用法类似，一般用于从被选定对象而不是上下文中获取属性值，如果

没有选定对象，则和变量表达式一样，示例代码如下

<div th:object="${book}">
<p>titile: <span th:text="*{title}">标题</span>.</p>
</div>

*{title} 选择变量表达式获取当前指定对象 book 的 title 属性值。

3 ．消息表达式 #{...}

消息表达式 #{...} 主要用于 Thymeleaf 模板页面国际化内容的动态替换和展示，使用消息表达式 #{...}

进行国际化设置时，还需要提供一些国际化配置文件。

4 ．链接表达式 @{...}

链接表达式 @{...} 一般用于页面跳转或者资源的引入，在 Web 开发中占据着非常重要的地位，并且使用也非常频繁，示例代码如下：

<a th:href="@{http://localhost:8080/order/details(orderId=${o.id})}">view</a>
<a th:href="@{/order/details(orderId=${o.id},pid=${p.id})}">view</a>

上述代码中，链接表达式 @{...} 分别编写了绝对链接地址和相对链接地址。在有参表达式中，需要

按照 @{ 路径 ( 参数名称 = 参数值，参数名称 = 参数值 ...)} 的形式编写，同时该参数的值可以使用变量表达式来传递动态参数值

5 ．片段表达式 ~{...}

片段表达式 ~{...} 用来标记一个片段模板，并根据需要移动或传递给其他模板。其中，最常见的用法是使用th:insert 或 th:replace 属性插入片段，示例代码如下：

<div th:insert="~{thymeleafDemo::title}"></div>

上述代码中，使用 th:insert 属性将 title片段模板引用到该 标签中。 thymeleafDemo 为模板名称， Thymeleaf 会自动查找 “/resources/templates/” 目录下的 thymeleafDemo 模板， title 为片段名称

4.2.2 基本使用

（1） Thymeleaf 模板基本配置

首先 在 Spring Boot 项目中使用 Thymeleaf 模板，首先必须保证引入 Thymeleaf 依赖，示例代码如

下：

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

其次，在全局配置文件中配置 Thymeleaf 模板的一些参数。一般 Web 项目都会使用下列配置，示例代码如：

spring.thymeleaf.cache = true ＃启用模板缓存
spring.thymeleaf.encoding = UTF_8 ＃模板编码
spring.thymeleaf.mode = HTML5 ＃应用于模板的模板模式
spring.thymeleaf.prefix = classpath:/templates/ ＃指定模板页面存放路径
spring.thymeleaf.suffix = .html ＃指定模板页面名称的后缀

上述配置中， spring.thymeleaf.cache 表示是否开启 Thymeleaf 模板缓存，默认为 true ，在开发过

程中通常会关闭缓存，保证项目调试过程中数据能够及时响应； spring.thymeleaf.prefix 指定了

Thymeleaf 模板页面的存放路径，默认为 classpath:/templates/ ； spring.thymeleaf.suffix 指定了

Thymeleaf 模板页面的名称后缀，默认为 .html

（2）静态资源的访问

开发 Web 应用时，难免需要使用静态资源。 Spring boot 默认设置了静态资源的访问路径。

使用 Spring Initializr 方式创建的 Spring Boot 项目，默认生成了一个 resources 目录，在 resources 目录中新建public 、 resources 、 static 三个子目录下， Spring boot 默认会挨个从 public 、 resources 、 static 里面查找静态资源

4.2.3 完成数据的页面展示

1. 创建 Spring Boot 项目，引入 Thymeleaf 依赖

2. 编写配置文件

打开 application.properties 全局配置文件，在该文件中对 Thymeleaf 模板页面的数据缓存进行设置

# thymeleaf页面缓存设置（默认为true），开发中方便调试应设置为false，上线稳定后应保持默认
true
spring.thymeleaf.cache=false

使用 “spring.thymeleaf.cache=false” 将 Thymeleaf 默认开启的缓存设置为了 false ，用来关闭模板页面缓存

3. 创建 web 控制类

在项目中创建名为 com.lagou.controller 的包，并在该包下创建一个用于前端模板页面动态数据替

换效果测试的访问实体类 LoginController

@Controller
public class LoginController {
/**
* 获取并封装当前年份跳转到登录页login.html
*/
@RequestMapping("/toLoginPage")
public String toLoginPage(Model model){
model.addAttribute("currentYear",
Calendar.getInstance().get(Calendar.YEAR));
return "login";
}

toLoginPage() 方法用于向登录页面 login.html 跳转，同时携带了当前年份信息 currentYear 。

4 ．创建模板页面并引入静态资源文件

在 “classpath:/templates/” 目录下引入一个用户登录的模板页面 login.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1,shrinkto-fit=no">
<title>用户登录界面</title>
<link th:href="@{/login/css/bootstrap.min.css}" rel="stylesheet">
<link th:href="@{/login/css/signin.css}" rel="stylesheet">
</head>
<body class="text-center">
<!-- 用户登录form表单 -->
<form class="form-signin">
<img class="mb-4" th:src="@{/login/img/login.jpg}" width="72" height="72">
<h1 class="h3 mb-3 font-weight-normal">请登录</h1>
<input type="text" class="form-control"
th:placeholder="用户名" required="" autofocus="">
<input type="password" class="form-control"
th:placeholder="密码" required="">
<div class="checkbox mb-3">
<label>
<input type="checkbox" value="remember-me"> 记住我
</label>
</div>
<button class="btn btn-lg btn-primary btn-block" type="submit" >登录</button>
<p class="mt-5 mb-3 text-muted">© <span
th:text="${currentYear}">2019</span>-<span
th:text="${currentYear}+1">2020</span></p>
</form>
</body>
</html>

通过 “xmlns:th=" http://www.thymeleaf.org "” 引入了 Thymeleaf 模板标签；

使用 “th:href” 和 “th:src” 分别引入了两个外联的样式文件和一个图片；

使用 “th:text” 引入了后台动态传递过来的当前年份 currentYear

5 ．效果测试

可以看出，登录页面 login.html 显示正常，在文件 4-3 中使用 “th:*” 相关属性引入的静态文件生效，

并且在页面底部动态显示了当前日期 2019-2020 ，而不是文件中的静态数字 2019-2020 。这进一步说明了Spring Boot 与 Thymeleaf 整合成功，完成了静态资源的引入和动态数据的显示

5. SpringBoot 实战演练

实战技能补充： lombok

<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
<!--只在编译阶段生效-->
<scope>provided</scope>
</dependency>

需求：实现用户的 CRUD 功能

（ 1 ）创建 springboot 工程

（ 2 ）导入 pom.xml

<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.3</version>
</dependency>

（ 3 ） User 实体类编写

@Data
public class User implements Serializable {
private Integer id;
private String username;
private String password;
private String birthday;
private static final long serialVersionUID = 1L;
}

（ 4 ） UserMapper 编写及 Mapper 文件

public interface UserMapper {
int deleteByPrimaryKey(Integer id);
int insert(User record);
int insertSelective(User record);
User selectByPrimaryKey(Integer id);
int updateByPrimaryKeySelective(User record);
int updateByPrimaryKey(User record);
List<User> queryAll();
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.base.mapper.UserMapper">
<resultMap id="BaseResultMap" type="com.example.base.pojo.User">
<id column="id" jdbcType="INTEGER" property="id" />
<result column="username" jdbcType="VARCHAR" property="username" />
<result column="password" jdbcType="VARCHAR" property="password" />
<result column="birthday" jdbcType="VARCHAR" property="birthday" />
</resultMap>
<sql id="Base_Column_List">
id, username, password, birthday
</sql>
<select id="selectByPrimaryKey" parameterType="java.lang.Integer"
resultMap="BaseResultMap">
select
<include refid="Base_Column_List" />
from user
where id = #{id,jdbcType=INTEGER}
</select>
<select id="queryAll" resultType="com.example.base.pojo.User">
select <include refid="Base_Column_List" />
from user
</select>
.......
</mapper>

（ 5 ） UserService 接口及实现类编写

package com.lagou.service.impl;
import com.lagou.mapper.UserMapper;
import com.lagou.pojo.User;
import com.lagou.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class UserServiceImpl implements UserService {
@Autowired
private UserMapper userMapper;
@Override
public List<User> queryAll() {
return userMapper.queryAll();
}
@Override
public User findById(Integer id) {
return userMapper.selectByPrimaryKey(id);
}
@Override
public void insert(User user) {
//userMapper.insert(user); //将除id所有的列都拼SQL
userMapper.insertSelective(user); //只是将不为空的列才拼SQL
}
@Override
public void deleteById(Integer id) {
userMapper.deleteByPrimaryKey(id);
}
@Override
public void update(User user) {
userMapper.updateByPrimaryKeySelective(user);
}
}

（ 6 ） UserController 编写

package com.lagou.controller;
import com.lagou.pojo.User;
import com.lagou.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.yaml.snakeyaml.events.Event;
import java.util.List;
@RestController
@RequestMapping("/user")
public class UserController {
@Autowired
private UserService userService;
/**
* restful格式进行访问
* 查询：GET
* 新增: POST
* 更新：PUT
* 删除: DELETE
*/
/**
* 查询所有
* @return
*/
@GetMapping("/query")
public List<User> queryAll(){
return userService.queryAll();
}
/**
* 通过ID查询
*/
@GetMapping("/query/{id}")
public User queryById(@PathVariable Integer id){
return userService.findById(id);
}
/**
* 删除
* @param id
* @return
*/
@DeleteMapping("/delete/{id}")
public String delete(@PathVariable Integer id){
userService.deleteById(id);
return "删除成功";
}
/**
* 新增
* @param user
* @return
*/
@PostMapping("/insert")
public String insert(User user){
userService.insert(user);
return "新增成功";
}
/**
* 修改
* @param user
* @return
*/
@PutMapping("/update")
public String update(User user){
userService.update(user);
return "修改成功";
}
}

（ 8 ） application.yml

##服务器配置
server:
port: 8090
servlet:
context-path: /
##数据源配置
spring:
datasource:
name: druid
type: com.alibaba.druid.pool.DruidDataSource
url: jdbc:mysql://localhost:3306/springbootdata?characterEncoding=utf-
8&serverTimezone=UTC
username: root
password: wu7787879
#整合mybatis
mybatis:
mapper-locations: classpath:mapper/*Mapper.xml #声明Mybatis映射文件所在的位置

（ 9 ）启动类

@SpringBootApplication
//使用的Mybatis,扫描com.lagou.mapper
@MapperScan("com.lagou.mapper")
public class Springbootdemo5Application {
public static void main(String[] args) {
SpringApplication.run(Springbootdemo5Application.class, args);
}
}

（ 10 ）使用 Postman 测试

 

 

6. Spring Boot 项目部署

需求：将 Spring Boot 项目使用 maven 指令打成 jar 包并运行测试

分析：

1. 需要添加打包组件将项目中的资源、配置、依赖包打到一个 jar 包中；可以使用 maven 的

package ；

2. 部署： java -jar 包名

步骤实现：

添加打包组件

<build>
<plugins>
<!-- 打jar包时如果不配置该插件，打出来的jar包没有清单文件 -->
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>

部署运行

java -jar 包名