JavaEE——Spring Boot入门_怎么在javaee创建一个名称为blog-system的spring boot项目的web模块

Spring Boot 简介

Spring Boot的作用
1：简化Spring应用开发的框架；
2：整个Spring技术栈的一个大整合；
3：J2EE开发的一站式解决方案；
Spring Boot 是 Spring 家族中的一个全新的框架，它用来简化 Spring 应用程序的创建和 开发过程，也可以说 Spring Boot 能简化我们之前采用 SpringMVC + Spring + MyBatis 框架进行开发的过程。 在以往我们采用 SpringMVC + Spring + MyBatis 框架进行开发的时候，搭建和整合三大框架，我们需要做很多工作，比如配置 web.xml，配置 Spring，配置 MyBatis，并将它们整合在 一起等，而 Spring Boot框架对此开发过程进行了革命性的颠覆，完全抛弃了繁琐的 xml 配置过程，采用大量的默认配置简化我们的开发过程。 所以采用 Spring Boot 可以非常容易和快速地创建基于 Spring 框架的应用程序，它让编码变简单了，配置变简单了，部署变简单了，监控变简单了。正因为 Spring Boot 它化繁为简，让开发变得极其简单和快速，所以在业界备受关注。

微服务

单体服务（all in one）

一个项目包含所有功能的应用程序，通常称为单体应用，或单体服务。

微服务

微服务是一种系统架构的设计风格，主旨是将原本复杂的系统拆分成多个独立的小型服务，每个服务维护自身的业务逻辑、数据处理及部署，服务与服务之间通过简单的通信协议进行通信（比如restfulAPI），不要求每个微服务使用同一种编程语言编写。现代开发模式正在从单体服务向微服务转变。
Java 微服务框架普遍用的是 Spring Cloud。微服务将系统拆分成多个小型服务，如果每个小型服务都用SSM搭建，那么多的配置，而且是重复配置和重复的搭建ssm不就麻烦了吗？所以这时候就使用到了Spring Boot来解决SSM搭建应用时候大量的手工配置问题，所以Spring Boot是一个快速搭建应用的框架，解决了SSM大量手工配置，不需要再去配置各种各样的文件了，直接一个Spring Boot构建起来就可以运行了。

Spring Boot特性

1. 能够快速创建基于 Spring 的应用程序
2. 能够直接使用 java main 方法启动内嵌的 Tomcat 服务器运行 Spring Boot 程序，不需要部署 war包文件
3. 提供约定的 starter POM 来简化 Maven 配置，让 Maven 的配置变得简单
4. 自动化配置，根据项目的 Maven 依赖配置，Spring boot 自动配置 Spring、Spring mvc 等
5. 基本可以完全不使用 XML 配置文件，采用注解配置

创建一个Spring Boot工程

1.创建一个工程，如图：


2.创建web模块
先创建一个模块

如图选择：

设置GAV坐标以及pom配置信息

选择 Spring Boot 版本及依赖

设置模块名称、Content Root 路径及模块文件的目录

点击 Finish，如果是第一次创建，在右下角会提示正在下载相关的依赖
项目创建完毕，如下图

入门案例项目结构分析

项目结构

static：存放静态资源，如图片、CSS、JavaScript 等
templates：存放 Web 页面的模板文件
application.properties/application.yml 用于存放程序的各种依赖模块的配置信息，比如Spring、springMVC、Mybatis、Redis 等。默认是空的。
mvn|mvnw|mvnw.cmd：使用脚本操作执行 maven 相关命令，可删除
gitignore：使用版本控制工具 git 的时候，设置一些忽略提交的内容，可删除
Springboot001Application.java：SpringBoot 程序执行的入口，执行该程序中的 main 方法，SpringBoot 就启动了

POM文件解析

Spring Boot自动生成了POM文件，文件内容解析如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<!--
该POM继承了SpringBoot 框架的一个父项目spring-boot-starter-parent，所有自己
开发的 Spring Boot 都必须的继承spring-boot-starter-parent。
父工程的作用是统管理Spring Boot应用里面的所有依赖版本
以后我们导入依赖默认是不需要写版本
-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.6.0</version>
<relativePath/>
</parent>
<!--当前项目的 GAV 坐标-->
<groupId>com.kaifamiao</groupId>
<artifactId>springboot001</artifactId>
<version>0.0.1-SNAPSHOT</version>
<!--maven 项目名称，可以删除-->
<name>springboot001</name>
<!--maven 项目描述，可以删除-->
<description>Demo project for Spring Boot</description>
<!--maven 属性配置，可以在其它地方通过${}方式进行引用-->
<properties>
<java.version>11</java.version>
</properties>
<dependencies>
<!--
SpringBoot 框架 web 项目起步依赖，通过该依赖自动关联其它依赖，不需要我们一
个一个去添加jar包了。
-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--SpringBoot 框架的测试起步依赖，例如：junit 测试-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<!--
SpringBoot 提供的打包编译等插件
这个插件，可以将应用打包成一个可执行的jar包
将这个应用打成jar包，直接使用java -jar的命令进行执行；
-->
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</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

创建Spring MVC Controller

需求：浏览器发送hello请求，服务器接受请求并处理，响应hello spring boot字符串；
在Springboot001Application类所在的包下创建子包controller，在controller包中创建类Hello。

注意：新创建的类一定要位于 Springboot001Application同级目录或者下级目录，否则SpringBoot 加载不到。

package com.ltw.springboot001.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class Hello {
@RequestMapping("/hello")
@ResponseBody
public String hello(){
return "hello spring boot";
}
}
1
2
3
4
5
6
7
8
9
10
11
12

解析：这个Controller就是SpringMVC中的Controller。hello方法返回的字符串被转换为json后响应给客户端。

启动Spring Boot应用

Spring Boot为应用自动创建了Springboot001Application类，该类用于启动Spring Boot应用

/**
* @SpringBootApplication 来标注一个主程序类，说明这是一个Spring Boot应用
*/
@SpringBootApplication
public class Springboot001Application {
public static void main(String[] args) {
// Spring应用启动起来
SpringApplication.run(Springboot001Application.class, args);
}
}
1
2
3
4
5
6
7
8
9
10

在 IDEA 中右键，运行 Springboot001Application类中的 main 方法。

通过在控制台的输出，可以看到启动 SpringBoot 框架，会启动一个内嵌的 tomcat，端 口号为 8080，上下文根为空

使用命令行也可以启动springboot，方法如下
第一步：打包
maven面板中双击生命周期中的package命令，自动打包

打包后的jar文件在target目录中

第二步：启动
打开控制台，进入打包后文件的目录，执行: java -jar xxxx.jar命令，启动spring boot项目

测试入门案例

在浏览器中输入 http://localhost:8080/hello访问

入门案例项目探究

POM文件

父项目
父项目的作用：统一管理jar包的版本

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.6.0</version>
<relativePath/>
</parent>
他的父项目是
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.6.0</version>
</parent>
他来真正管理Spring Boot应用里面的所有依赖版本；
1
2
3
4
5
6
7
8
9
10
11
12
13

以后我们导入依赖默认是不需要写版本；（没有在dependencies里面管理的依赖还是需要声明版本号的）
启动器starter
启动器的作用：导入依赖的jar包

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐web</artifactId>
</dependency>
1
2
3
4

spring-boot-starter是spring-boot启动器，spring‐boot‐starter‐web帮我们导入了web模块正常运行所依赖的jar包；
Spring Boot将所有的功能都抽取出来，做成一个个的starters（启动器），只需要在项目里面引入这些starter 相关功能的所有依赖都会导入进来。要用什么功能就导入什么功能的启动器。

主程序类，主入口类

/**
* @SpringBootApplication 来标注一个主程序类，说明这是一个Spring Boot应用
*/
@SpringBootApplication
public class Springboot001Application {
public static void main(String[] args) {
//Spring应用启动起来
SpringApplication.run(Springboot001Application.class, args);
}
}
1
2
3
4
5
6
7
8
9
10

@SpringBootApplication注解标注在某个类上，说明这个类是SpringBoot的主配置类，SpringBoot 就应该运行这个类的main方法来启动SpringBoot应用；
将主配置类（@SpringBootApplication标注的类）所在包及下面所有子包里面的所有组件扫描到Spring容器；因此

注意：新创建的类一定要位于 Springboot001Application同级目录或者下级目录，否则SpringBoot 加 载不到。

配置文件、加载顺序

SpringBoot使用一个全局的配置文件，配置文件名是固定的；
application.properties（默认采用该文件）
application.yml

配置文件的作用：修改SpringBoot自动配置的默认值；SpringBoot在底层都给我们自动配置好；

案例：更改springboot默认配置

需求：更改spring boot 端口号为8888，上下文路径为springboot
使用两种方式实现
新建模块，名称：springboot002

方式1：使用application.properties配置文件实现

修改application.properties配置文件

server.port=8888
server.servlet.context-path=/springboot
1
2

启动后测试运行

方式2：使用application.yml配置文件实现

首先注释掉application.properties配置文件

#server.port=8888
#server.servlet.context-path=/springboot
1
2

然后创建application.yml文件，并配置如下

server:
port: 8888
servlet:
context-path: /springboot
1
2
3
4

启动后测试运行

注意：
1：当两种格式配置文件同时存在，properties 配置文件优先级高于yml配置文件；
2：两种配置文件以增量配置的方式改变springboot的默认运行行为；

开启配置文件提示功能

可以导入配置文件处理器，以后编写配置就有提示了

<!‐‐导入配置文件处理器，配置文件进行绑定就会有提示‐‐>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐configuration‐processor</artifactId>
<optional>true</optional>
</dependency>
1
2
3
4
5
6

YAML语法

YAML（YAML Ain’t Markup Language）
yml 是一种 yaml 格式的配置文件，主要采用一定的空格、换行等格式排版进行配置。 yaml 是一种直观的能够被计算机识别的的数据序列化格式，容易被人类阅读，yaml 类 似于 xml，但是语法比 xml 简洁很多，值与前面的冒号配置项必须要有一个空格， yml 后缀也可以使用 yaml 后缀。

多环境配置

在实际开发的过程中，我们的项目会经历很多的阶段（开发->测试->上线），每个阶段 的配置也会不同，例如：端口、上下文路径、数据库等，那么这个时候为了方便在不同的环境之间切换，SpringBoot 提供了多环境配置，具体步骤如下：

properties配置

1.为每个环境创建一个配置文件，命名必须以 application-环境标识.properties

application-dev.properties

#开发环境，端口号8082
server.port=8082
1
2

application-product.properties

#生产环境，端口号8080
server.port=8080
1
2

application-test.properties

#测试环境，端口号8083
server.port=8083
1
2

2.激活核心配置文件

在总配置文件 application.properties 进行环境的激活

#激活开发环境
#spring.profiles.active=dev
#激活生产环境
#spring.profiles.active=product
#激活测试环境
spring.profiles.active=test
1
2
3
4
5
6

yml配置

1.为每个环境创建一个配置文件，命名必须以 application-环境标识.yml

application-dev.yml

#开发环境，端口号8082
server:
port: 8082
1
2
3

application-product.yml

#生产环境，端口号8080
server:
port: 8080
1
2
3

application-test.yml

#测试环境，端口号8083
server:
port: 8083
1
2
3

2.激活核心配置文件

#激活开发环境
spring:
profiles:
active: dev
1
2
3
4

日志框架，日志配置

了解日志

问：你开发的电子商务系统，在用户集中高并发访问期间发生丢单，你又该如何快速、准确地进行定位分析和解决呢？
答：查阅日志找出问题，解决问题。日志对一个系统运行状况的记录是是否重要的，是一个系统的重要模块。
问：那么日志应该记录什么呢？
答： 时间- 线程名 - 日志等级 -日志输出位置（全类名，可以精确到方法名）:日志信息
例如:

2021-01-01 11:49:20.296-[Thread-initRedis21504][INFO]-
com.ltw.LoginController.initLogInfo:ycdl[User] is logining
1
2

问：如何对不同的日志信息进行等级划分？
答：日志等级通常分为六种：TRACE、DEBUG、INFO、WARN、ERROR、FATAL。依次从低到高，在开发过程中哪些信息需要设置为哪种等级有赖于开发者的自己判断。

紧急错误 fatal，表示需要立即被处理的系统级错误，这属于最严重的日志级别

错误 error，影响到程序正常运行、当前请求正常运行的异常情况，如
资源依赖加载失败导致程序无法启动代码抛出未处理的异常，导致程序终止

警告 warn，应该出现但是不影响程序、当前请求正常运行的异常情况，一般打在有容错机制的时候出现的错误情况，如请求参数未按照预定格式传入，系统资源占用达到警戒线

信息 info，记录程序运行的信息，如流程步骤、调用参数、调用结果等，如调用第三方服务时，info信息是十分必要的，因为我们很难追溯到第三方模块发生的问题对于复杂的业务逻辑，需要记录程序的运行流程，检测程序是否按正常逻辑执行

调试 debug，用于开发调试代码，可以记录想要知道的全部信息，但是不能一直出现在生产环境，需要通过开关控制或者在上线前移除调试日志

追踪 trace，特别详细的系统运行完成信息，一般不要出现在生产环境

抽象层框架有：
JCL（Jakarta Commons Logging）
SLF4j（Simple Logging Facade for Java）
jboss-logging

实现层框架有：
Log4j
JUL（java.util.logging）
Log4j2
Logback

一般使用日志框架时，选择一个抽象层框架，再选择一个实现层框架，一起使用。日志记录方法的调用，不应该来直接调用实现层日志的方法，而是调用抽象层日志的方法；

SpringBoot选用的是 SLF4j和logback组合，顺便告诉你SpringBoot底层的Spring框架默认用的是JCL框架。

日志记录模板

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class UserService {
Logger logger = LoggerFactory.getLogger(UserService.class);
public void save(User user){
logger.info("日志内容");
}
}
1
2
3
4
5
6
7
8

Spring boot默认日志

SpringBoot选用的是 SLF4j和logback组合作为默认日志框架。
spring boot默认已经配置好了日志。
当我们启动spring boot框架时，在控制台就输出了spring boot默认配置的日志，如下图：

解决spring boot与引入的其他框架日志冲突问题

spring boot如果需要引入其他框架（如spring框架），其他框架中也有默认的日志框架，导致日志框架冲突，怎么办呢？
办法是所有框架统一使用spring boot的SLF4J框架。
例如

1. SpringBoot选用的是 SLF4j和logback组合
2. SpringBoot底层的Spring框架默认用的是JCL框架
3. 如此一来导致JCL与SLF4j冲突
4. 解决冲突的办法是排除spring框架的默认日志，不过这个任务springboot已经帮我们完成了

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring‐core</artifactId>
<exclusions>
<exclusion>
<groupId>commons‐logging</groupId>
<artifactId>commons‐logging</artifactId>
</exclusion>
</exclusions>
</dependency>
1
2
3
4
5
6
7
8
9
10

spring boot中使用日志

由于spring boot已经配置好了日志框架，我们在spring boot中可以直接使用spring boot配置好的日志。

第一步：创建日志记录器

记录日志首先创建日志记录器，由日志记录器负责具体记录日志。

//日志记录器logger
Logger logger = LoggerFactory.getLogger(类名.class);
1
2

LoggerFactory是日志记录器工厂类，负责创建日志记录器
在getLogger()方法中传入哪个类的元数据，就记录哪个类的日志

第二步：记录器记录日志

在测试类中输出日志

import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class Springboot006ApplicationTests {
//日志记录器
Logger logger = LoggerFactory.getLogger(getClass());
@Test
void contextLoads() {
try}
//记录器记录日志和日志级别
logger.trace("跟踪运行轨迹日志");
logger.debug("调试日志");
logger.info("信息日志");
logger.warn("警告日志");
}catch(Exception e){
logger.error("错误日志");
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

运行测试类，输出信息如下

在开发中，我们使用日志记录器就可以记录开发中的日志信息了。
观察日志结果，只看到了info，warn，error级别的日志输出。
spring boot默认输出info级别的日志，当输出info级别日志时，高于info级别的日志都会输出。

第三步：确定日志输出级别

调整日志输出级别，需要在application.properties配置文件中配置输出级别。
application.properties中配置日志输出级别

#com.ltw包下的类输出trace级别的日志
logging.level.com.ltw=trace
1
2

配置了com.ltw包下的类输出级别为trace

发现高于trace级别的日志都输出了。

在application.properties中将Mapper接口所在的包设置日志输出级别为info
logging.level.com.kaifamiao.mapper=info
就实现了在spring boot中输出mybatis的sql语句
1
2
3

配置日志输出的位置

默认日志输出到了控制台，控制台的日志清空后就不见了，那你以后维护系统时就查不到日志了。
在application.properties配置文件中可以配置日志输出到文件中，以永久保存日志。

#日志文件保存到当前项目根目录下的springboot006.log文件中
logging.file.name=springboot006.log
1
2

再次测试，在项目的根目录下生成一个名称为springboot006.log的日志文件，打开该文件，里面记录的日志如下：

还可以指定日志文件的绝对路径，修改application.properties配置文件，设置日志文件存储在D:/springboot006.log

#日志文件保存到d:/springboot006.log
logging.file.name=d:/springboot006.log
1
2

还可以使用logging.file.path指定日志文件存储的位置

#此设置将日志文件保存到当前项目根目录下的springboot/log目录下，
#文件名是springboot指定的默认文件名，为spring.log
logging.file.path=springboot/log
1
2
3

如果logging.file.path和logging.file.name同时设置，
logging.file.name配置生效，
logging.file.path不生效。

提示：
日志输出到控制台：适合于开发模式
日志输出到文件，适合于生产模式

指定日志配置文件

Spring Boot 官方推荐优先使用logback-spring.xml文件名作为你的日志配置文件，并且放在src/main/resources 目录下。

spring boot自动加载logback-spring.xml配置文件，并按照该配置文件输出日志。
logback-spring.xml配置文件参考代码

<?xml version="1.0" encoding="UTF-8"?>
<!--
scan：当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true。
scanPeriod：设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒.当
scan为true时，此属性生效。默认的时间间隔为1分钟。
debug：当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认
值为false。
-->
<configuration scan="false" scanPeriod="60 seconds" debug="false">
<!-- 定义日志的根目录 -->
<property name="LOG_HOME" value="app/log" />
<!-- 定义日志文件名称 -->
<property name="appName" value="springboot"></property>
<!-- ch.qos.logback.core.ConsoleAppender 表示控制台输出 -->
<appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
<!--此日志 appender 是为开发使用，只配置最底级别，控制台输出的日志级别是大
于或等于此级别的日志信息-->
<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
<level>debug</level>
</filter>
<!--
日志输出格式：
%d表示日期时间，
%thread表示线程名，
%-5level：级别从左显示5个字符宽度
%logger{50} 表示logger名字最长50个字符，否则按照句点分割。
%msg：日志消息，
%n是换行符
-->
<layout class="ch.qos.logback.classic.PatternLayout">
<springProfile name="dev">
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ---> [%thread] --->
%-5level %logger{50} - %msg%n</pattern>
</springProfile>
<springProfile name="!dev">
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} === [%thread] ===
%-5level %logger{50} - %msg%n</pattern>
</springProfile>
</layout>
</appender>
<!-- 滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件 -->
<appender name="appLogAppender"
class="ch.qos.logback.core.rolling.RollingFileAppender">
<!-- 指定日志文件的名称 -->
<file>${LOG_HOME}/${appName}.log</file>
<!--
当发生滚动时，决定 RollingFileAppender 的行为，涉及文件移动和重命名
TimeBasedRollingPolicy： 最常用的滚动策略，它根据时间来制定滚动策略，既负责滚
动也负责出发滚动。
-->
<rollingPolicy
class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!--
滚动时产生的文件的存放位置及文件名称 %d{yyyy-MM-dd}：按天进行日志滚动
%i：当文件大小超过maxFileSize时，按照i进行文件滚动
-->
<fileNamePattern>${LOG_HOME}/${appName}-%d{yyyy-MM-dd}-
%i.log</fileNamePattern>
<!--
可选节点，控制保留的归档文件的最大数量，超出数量就删除旧文件。假设设置每天滚
动，
且maxHistory是365，则只保存最近365天的文件，删除之前的旧文件。注意，删除旧
文件是，
那些为了归档而创建的目录也会被删除。
-->
<MaxHistory>365</MaxHistory>
<!--
当日志文件超过maxFileSize指定的大小是，根据上面提到的%i进行日志文件滚动 注
意此处配置SizeBasedTriggeringPolicy是无法实现按文件大小进行滚动的，必须配置
timeBasedFileNamingAndTriggeringPolicy
-->
<timeBasedFileNamingAndTriggeringPolicy
class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
<maxFileSize>100MB</maxFileSize>
</timeBasedFileNamingAndTriggeringPolicy>
</rollingPolicy>
<!-- 日志输出格式： -->
<layout class="ch.qos.logback.classic.PatternLayout">
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [ %thread ] - [ %-5level ]
[ %logger{50} : %line ] - %msg%n</pattern>
</layout>
</appender>
<!--
logger主要用于存放日志对象，也可以定义日志类型、级别
name：表示匹配的logger类型前缀，也就是包的前半部分
level：要记录的日志级别，包括 TRACE < DEBUG < INFO < WARN < ERROR
additivity：作用在于children-logger是否使用 rootLogger配置的appender进行
输出，
false：表示只用当前logger的appender-ref，
true：表示当前logger的appender-ref和rootLogger的appender-ref都有效
-->
<!--单个定义-->
<logger name="com.kaifamiao.mapper" level="debug"></logger>
<!-- 结果
appender trace trace
root trace
appender trace debug
root debug
appender trace debug
root 空 如果root没有值默认root级别是debug
appender debug info
root info
-->
<root level="INFO">
<appender-ref ref="stdout" />
<appender-ref ref="appLogAppender" />
</root>
</configuration>
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
103
104
105
106
107
108

解析：
每个一< appender>标签表示一种日志的输出位置，本例配置了两个日志输出位置
< appender-ref ref=“stdout” />配置了日志输出到控制台
< appender-ref ref=“appLogAppender” />配置了日志输出到文件
< root level=“INFO”>配置的是默认输出级别INFO

Web开发

模板引擎

模板引擎作用：
（1）将html和数据绑定
（2）实现前后端分离。前后分离要求前端是非编译型的模板，因此非编译型的模板有取代编译型的模板的趋势。JSP是编译型的，Thymeleaf是非编译型的模板。

springboot支持的模板引擎
JSP
Velocity
Freemarker
Thymeleaf（spring boot推荐的模板引擎）

前端使用jsp模板

新建模块，名称：springboot003
由于springboot默认支持的模板是thymeleaf，因此jsp作为模板引擎时需要手动设置，设置内容如下：

1. 导入相关jar包
2. 创建webapp目录
3. 设置webapp部署目录
4. 设置视图前缀和后缀
5. 编写控制器类
6. 编写jsp文件

第一步：导入相关jar包

（1）导入springboot内嵌的 Tomcat 对 JSP 的解析包

<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
</dependency>
1
2
3
4

（2）导入servlet-api 的jar包

<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
</dependency>
1
2
3
4

（3）导入jsp-api的jar包

<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>javax.servlet.jsp-api</artifactId>
<version>2.3.1</version>
</dependency>
1
2
3
4
5

（4）导入jstl的jar包

<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
</dependency>
1
2
3
4

第二步：创建webapp资源目录

在 src/main 下创建一个 webapp 目录
以在File>Project Structure中指定webapp 为 Web Resource Directory

第三步：设置webapp部署的位置

SpringBoot 要求 jsp 文件必须编译到指定的 META-INF/resources 目录下才能访问，否则 访问不到。

<resources>
<resource>
<!--源文件位置-->
<directory>src/main/webapp</directory>
<!--指定编译到 META-INF/resources，该目录不能随便写-->
<targetPath>META-INF/resources</targetPath>
<!--指定要把哪些文件编译进去，**表示 webapp 目录及子目录，*.*表示所有文件-->
<includes>
<include>**/*.*</include>
</includes>
</resource>
</resources>
1
2
3
4
5
6
7
8
9
10
11
12

第四步：配置视图前后缀

配置jsp的前后缀，相当于springmvc里的视图解析器。
在application.properties中配置

#配置端口号和上下文路径
server.port=9090
server.servlet.context-path=/
#配置 SpringMVC 视图解析器。其中：/ 表示目录为 src/main/webapp
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp
1
2
3
4
5
6

在yml中配置

#配置端口号和上下文路径
server:
port: 9090
servlet:
context-path: /
#配置 SpringMVC 视图解析器,其中：/ 表示目录为 src/main/webapp
spring:
mvc:
view:
prefix: /
suffix: .jsp
1
2
3
4
5
6
7
8
9
10
11

第五步：编写控制器

@Controller
public class Hello {
@RequestMapping("/hello")
public String hello(Model model){
model.addAttribute("message","hello spring boot");
return "hello";
}
}
1
2
3
4
5
6
7
8

第六步：编写jsp文件

在webapp目录下创建hello.jsp文件

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
${message}
</body>
</html>
1
2
3
4
5
6
7
8
9

第七步：启动并测试

前端使用Thymeleaf模板

认识thymeleaf

Thymeleaf 是一个流行的模板引擎，该模板引擎采用 Java 语言开发。

模板引擎是一个技术名词，是跨领域跨平台的概念，在 Java 语言体系下有模板引擎， 在 C#、PHP 语言体系下也有模板引擎，甚至在 JavaScript 中也会用到模板引擎技术，Java 生 态下的模板引擎有Thymeleaf 、Freemaker、Velocity、Beetl（国产） 等。

Thymeleaf 对网络环境不存在严格的要求，既能用于 Web 环境下，也能用于非 Web 环 境下。在非Web 环境下，他能直接显示模板上的静态数据；在 Web 环境下，它能像 Jsp 一 样从后台接收数据并替换掉模板上的静态数据。它是基于HTML 的，以 HTML 标签为载体， Thymeleaf 要寄托在 HTML 标签下实现。

SpringBoot 集成了 Thymeleaf 模板技术，并且 Spring Boot 官方也推荐使用 Thymeleaf 来 替代 JSP技术，Thymeleaf 是另外的一种模板技术，它本身并不属于 Spring Boot，Spring Boot 只是很好地集成这种模板技术，作为前端页面的数据展示，在过去的 Java Web 开发中，我 们往往会选择使用 Jsp 去完成页面的动态渲染，但是 jsp 需要翻译编译运行，效率低。

第一步：引入thymeleaf

新建模块，名称：springboot004
选择Spring Web模块
选择Thymeleaf模块

按照这种方式创建后，pom.xml 文件下会自动引入thymeleaf和web依赖

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
1
2
3
4
5
6
7
8

第二步：配置Thymeleaf

在 Spring boot 的核心配置文件 application.properties 中对 Thymeleaf 进行配置

配置前缀

#thymeleaf 模版前缀,默认可以不写
spring.thymeleaf.prefix=classpath:/templates/
1
2

配置后缀

#thymeleaf 模版后缀,默认可以不写
spring.thymeleaf.suffix=.html
1
2

注意： Springboot 使 用 thymeleaf 作 为 视 图 展 示 ， 约 定 将 模 板 文 件 放 置 在src/main/resource/templates 目录下，静态资源放置在 src/main/resource/static 目录下

第四步：使用thymeleaf

（1）创建控制器

@Controller
public class Hello {
@RequestMapping("/hello")
public String hello(Model model){
model.addAttribute("name","thymeleaf");
model.addAttribute("age","20");
return "index";
}
}
1
2
3
4
5
6
7
8
9

（2）创建index.html文件
在 src/main/resources 的 templates 下新建一个 index.html 页面用于展示数据
（3）导入thymeleaf的名称空间
在index.html页面中导入命名空间

<html lang="en" xmlns:th="http://www.thymeleaf.org">
1

（4）使用thymeleaf显示数据

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1 th:text="${name}">时迁</h1>
<h1 th:text="${age}">30</h1>
</body>
</html>
1
2
3
4
5
6
7
8
9
10
11

解析：

1. 命名空间th用于从后台获取数据并渲染到界面上
2. th:text="" 是 Thymeleaf 的一个属性，用于文本的显示
   本例中
   th:text="$ {name}“将覆盖< h1>标签中的值时迁
   th:text=”$ {age}"将覆盖< h1>标签中的值30
   （5）运行测试
   
   右键->查看页面源代码
   

thymeleaf缓存问题

首先重新启动Spring Boot，测试/hello，运行下面代码，观察运行结果。

<body>
<h1 th:text="${name}">时迁</h1>
<h1 th:text="${age}">30</h1>
</body>
1
2
3
4

现在向页面中添加一个年龄新行

<body>
<h1 th:text="${name}">时迁</h1>
<h1 th:text="${age}">30</h1>
<h1 th:text="${age}">30</h1>
</body>
1
2
3
4
5

刷新/hello页面，数据没有更新，原因是Thymeleaf显示的是缓存数据。
重写启动SpringBoot应用，再次刷新页面，数据更新了。
如果每次修改的html页面都要重新启动SpringBoot显得太麻烦。
通过以下两步解决刷新问题

提示：在开发模式下建议关闭缓存，在生产模式下建议开启缓存

第一步：关闭缓存

#thymeleaf 页面的缓存开关，默认 true 开启缓存
#建议在开发阶段关闭 thymeleaf 页面缓存，否则刷新页面时不会获取最新数据，而是使用缓存的数据。在生产阶段开启缓存
spring.thymeleaf.cache=false
1
2
3

第二步：设置update操作


设置后重新启动SpringBoot应用
然后刷新/hello页面，显示了最新数据
现在再添加一行显示年龄

<body>
<h1 th:text="${name}">时迁</h1>
<h1 th:text="${age}">30</h1>
<h1 th:text="${age}">30</h1>
<h1 th:text="${age}">30</h1>
</body>
1
2
3
4
5
6

然后刷新页面，缓存没有了，页面数据更新了。

提示：如果不禁用缓存，就需要每次更新页面后要重新启动Spring boot。
提示：手动也可以清除浏览器缓存，对于chrome浏览器，使用快捷键ctrl+shift+del，或者在菜单中执行清除浏览数据

关于Thymeleaf的语法规则，在下一篇博客里面Thymeleaf语法规则