文章目录

• 0、他人笔记
• 1、入门案例
• • 1.1、创建一个新的 Module，选择类型为 Spring Initializr
  • 1.2、指定 GAV 及 pom 配置信息
  • 1.4、选择 Spring Boot 版本及依赖
  • 1.5、修改 Content Root 路径及文件所在目录
  • 1.6、对 POM.xml 文件进行解释
  • 1.7、对 SpringBoot 项目结构进行说明
  • 1.8、创建一个 Spring MVC 的 Spring BootController
  • 1.9、在 IDEA 中右键，运行 Application 类中的 main 方法
  • 1.10、 在浏览器中输入 http://localhost:8080/springBoot/say 访问
  • 1.11、入门案例分析
• 2、SpringBootController里面的用法
• • SpringBoot 中常用注解@Controller/@RestController/@RequestMapping/@SpringBootApplication介绍
  • @RequestMapping与@GetMapping和@PostMapping等新注释
  • @PathVariable注解使用
  • @RequestParam注解使用
• 3、Spring Boot 自定义配置
• • 3.1、 @Value
  • 3.2、@ConfigurationProperties
  • Spring注解@Component、@Repository、@Service、@Controller区别
  • • @component
    • @ConfigurationProperties
    • @Autowired用法
• 4、 Spring Boot 前端使用 JSP
• • 4.1、在 pom.xml 文件中配置以下依赖项
  • 4.2、 在 pom.xml 的 build 标签中要配置以下信息
  • 4.3、在 application.properties 文件配置 Spring MVC 的视图展示为 jsp，这里相当于 Spring MVC 的配置
  • 4.4、 在 com.abc.springboot.controller 包下创建 JspController 类，并 编写代码
  • 4.5、在 src/main 下创建一个 webapp 目录，然后在该目录下新建 index.jsp 页面
  • 4.6、在 jsp 中获取 Controller 传递过来的数据
  • 4.7、重新运行 Application，通过浏览器访问测试
• 5、SpringBoot 工程下使用 Mybatis 反向工程
• • 5.1、SpringBoot 工程下使用 Mybatis 反向工程
  • 5.2、根据项目及表的情况，修改 GeneratorMapper.xml 配置
  • 5.3、在 pom.xml 文件中添加 mysql 反向工程依赖
  • 5.4、双击红色选中命令，生成相关文件
  • 5.5、对生成的StudentMapper.xml进行分析
• 6、Spring Boot 集成 MyBatis
• • 6.1、创建一个新的 SpringBoot 的 Module
  • 6.2在 pom.xml 中添加相关 jar 依赖
  • 6.3、在 Springboot 的核心配置文件 application.properties 中配 置数据源
  • 6.4、开发代码 ➢ 使用 Mybatis 反向工程生成接口、映射文件以及实体 bean，具体步骤参见目录5
  • 6.5、 在 web 包下创建 StudentController 并编写代码
  • 6.6、在service 包下创建 service 接口并编写代码
  • 6.7、在 service.impl 包下创建 service 接口并编写代码
  • spring注解@Service注解的使用
  • 6.8、在pom.xml文件中指定资源文件夹（这个前题是Studentmapper.xml文件在src/main/java路径下）
  • 6.9、在 Mybatis 反向工程生成的 StudentMapper 接口上加一个 Mapper 注解
  • 6.10、DAO 其它开发方式（替换6.9）
  • 6.11、启动 Application 应用，浏览器访问测试运行
  • 6.12、将接口和映射文件分开(区别于6.8）
• 7、Spring Boot 事务支持
• • 7.1、在 StudentController 中添加更新学生的方法
  • 7.2、在 StudentService 接口中添加更新学生方法
  • 7.3、在 StudentServiceImpl 接口实现类中对更新学生方法进 行实现，并构建一个异常，同时在该方法上加@Transactional 注解
  • 7.4、启动 Application，通过浏览器访问进行测试
• 8、Spring Boot 下的 Spring MVC
• • 8.1、 @Controller
  • 8.2、 @RestController
  • 8.3、@RequestMapping（常用）
  • 8.4 、@GetMapping
  • 8.5、 @PostMapping
  • 8.6 、@PutMapping
  • 8.7、 @DeleteMapping
  • 8.8、Http 接口请求工具 Postman 介绍
• 9、Spring Boot 使用拦截器
• • 9.1、创建一个 SpringBoot 框架 Web 项目
  • 9.2、 实现一个登录拦截器
  • 9.3、 创建一个控制层
  • 9.4、@Configuration 定义配置类-拦截器
• 10、 SpringBoot 集成 logback 日志
• • 10.1、使用该功能步骤
  • 10.2、创建 SpringBoot 框架 web 项目
  • 10.3、通过 MyBatis 逆向工程生成 DAO
  • 10.4、手动指定资源文件夹
  • 10.5 编写 StudentController
  • • @Slf4j
  • 10.6 编写 StudentService 接口及实现类
  • 10.7 数据持久层
  • 10.8、日志文件
  • 10.9 Application 启动类
  • 10.10、启动测试
• 11、SpringBoot 集成 Thymeleaf 模板
• • 11.1 项目名称：037-springboot-thymeleaf-first
  • 11.2 在 Spring boot 的核心配置文件 application.properties 中对 Thymeleaf 进行配置、
  • 11.3 创建 ThymeleafControlle 去映射到模板页面（和 SpringMVC 基 本一致）
  • 11.4 在 src/main/resources 的 templates 下新建一个 index.html 页 面用于展示数据
  • 11.5 启动程序，浏览器访问 http://localhost:8080/index
• 12 Thymeleaf 的表达式
• • 12.1 项目名称：038-springboot-thymeleaf-expression
  • 12.2、 标准变量表达式
  • html中的span、div标签
  • 12.3、URL 表达式
  • 12.4 Thymeleaf 的常见属性
  • • 12.4.1、th:action
    • 12.4.2、th:method
    • 12.4.3、th:name
    • 12.4.4、 th:attr
    • 12.4.5、th:text
    • 12.4.6、th:object
    • 12.4.7、th:onclick
    • 12.4.8、th:style
    • 12.4.9、th:each
    • 12.4.10、 th:if
    • 12.4.11、 th:unless
    • 12.4.12、th:switch/th:case
    • 12.4.13、th:inline
  • 12.5 Thymeleaf 字面量
  • • 12.5.1 文本字面量
    • 12.5.2 数字字面量
    • 12.5.3 boolean 字面量
    • 12.5.4 null 字面量
    • 12.5.5 Thymeleaf 字符串拼接
  • 12.6 Thymeleaf 运算符
  • 12.7 Thymaleaf 表达式基本对象
• 13、综合案例
• • 13.0、Dubbo与SpringBoot的集成以及创建多模块项目时遇到的坑
  • 13.1、父工程创建
  • 13.2、各层的情况
  • • 13.2.3、parent文件
    • 13.2.4、consumer文件
    • 对@Reference 、@Resource和@Autowired的简单理解
    • 13.2.3、interface
    • 13.2.4、provider
  • 13.3DAO层，Service层，Controller层、View层

0、他人笔记

SpringBoot2核心技术与响应式编程基于SpringBoot2.3与2.4版本

SpringBootWeb模块的默认规则研究

Spring Boot 2 学习笔记（1 / 2）

Spring Boot 2 学习笔记（2 / 2）

1、入门案例

1.1、创建一个新的 Module，选择类型为 Spring Initializr

1.2、指定 GAV 及 pom 配置信息

1.4、选择 Spring Boot 版本及依赖

会根据选择的依赖自动添加起步依赖并进行自动配置

1.5、修改 Content Root 路径及文件所在目录

1.6、对 POM.xml 文件进行解释

<?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><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.3.4.RELEASE</version><relativePath/> <!-- lookup parent from repository --></parent><groupId>com.bjpowernode.springboot</groupId><artifactId>003-springboot-contextpath-port</artifactId><version>0.0.1-SNAPSHOT</version><properties><java.version>1.8</java.version></properties><dependencies><!--SpringBoot框架web项目起步依赖--><!--SpringBoot 框架 web 项目起步依赖，通过该依赖自动关联其它依赖，不需要我们一个一个去添加了
--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency></dependencies><build><plugins><!--SpringBoot项目编译打包的插件--><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>

1.7、对 SpringBoot 项目结构进行说明

➢ .mvn|mvnw|mvnw.cmd：使用脚本操作执行 maven 相关命令，国内使用较少，可删
除
➢ .gitignore：使用版本控制工具 git 的时候，设置一些忽略提交的内容
➢ static|templates：后面模板技术中存放文件的目录
➢ application.properties：SpringBoot 的配置文件，很多集成的配置都可以在该文件中
进行配置，例如：Spring、springMVC、Mybatis、Redis 等。目前是空的
➢ Application.java：SpringBoot 程序执行的入口，执行该程序中的 main 方法，SpringBoot
就启动了

1.8、创建一个 Spring MVC 的 Spring BootController

SpringBootController 类所在包：com.bjpowernode.springboot.web
注意：新创建的类一定要位于 Application 同级目录或者下级目录，否则 SpringBoot 加
载不到。

package com.bjpowernode.springboot.web;import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;@Controller
public class SpringBootController {@RequestMapping(value = "/say")public @ResponseBody Object index(){return "Hello SpringBoot!";}
}

1.9、在 IDEA 中右键，运行 Application 类中的 main 方法

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

1.10、 在浏览器中输入 http://localhost:8080/springBoot/say 访问

1.11、入门案例分析

➢ Spring Boot 的父级依赖 spring-boot-starter-parent 配置之后，当前的项目就是 Spring
Boot 项目
➢ spring-boot-starter-parent 是一个 Springboot 的父级依赖，开发 SpringBoot 程序都需
要继承该父级项目，它用来提供相关的 Maven 默认依赖，使用它之后，常用的 jar
包依赖可以省去 version 配置
➢ Spring Boot 提供了哪些默认 jar 包的依赖，可查看该父级依赖的 pom 文件
➢ 如果不想使用某个默认的依赖版本，可以通过 pom.xml 文件的属性配置覆盖各个
依赖项，比如覆盖 Spring 版本

5.0.0.RELEASE

➢ @SpringBootApplication 注解是 Spring Boot 项目的核心注解，主要作用是开启
Spring 自动配置，如果在 Application 类上去掉该注解，那么不会启动 SpringBoot
程序
➢ main 方法是一个标准的 Java 程序的 main 方法，主要作用是作为项目启动运行的入
口
➢ @Controller 及 @ResponseBody 依然是我们之前的 Spring MVC，因为 Spring Boot
的里面依然是使用我们的 Spring MVC + Spring + MyBatis 等框架

2、SpringBootController里面的用法

SpringBoot 中常用注解@Controller/@RestController/@RequestMapping/@SpringBootApplication介绍

@Controller/@RestController/@RequestMapping介绍

@SpringBootApplication：这是一个Springboot的应用

@RequestMapping与@GetMapping和@PostMapping等新注释

@RequestMapping与@GetMapping和@PostMapping等新注释

@PathVariable注解使用

@PathVariable注解使用

@RequestParam注解使用

@RequestParam注解使用

3、Spring Boot 自定义配置

在 SpringBoot 的核心配置文件中，除了使用内置的配置项之外，我们还可以在自定义配
置，然后采用如下注解去读取配置的属性值

3.1、 @Value

@Value
（11） @Value 注解
A、 项目名称：007-springboot-custom-configuration
用于逐个读取 application.properties 中的配置
案例演示
➢ 在核心配置文件 applicatin.properties 中，添加两个自定义配置项 school.name 和
website。在 IDEA 中可以看到这两个属性不能被 SpringBoot 识别，背景是桔色的

application.yml 格式配置文件

在 SpringBootController 中定义属性，并使用@Value 注解或者自定义配置值，并对其方法进行测试

重新运行 Application，在浏览器中进行测试

3.2、@ConfigurationProperties

Spring注解@Component、@Repository、@Service、@Controller区别

Spring注解@Component、@Repository、@Service、@Controller区别

@component

@component

@component

@ConfigurationProperties

@ConfigurationProperties

@Autowired用法

@Autowired用法

项目名称：008-springboot-custom-configuration
将整个文件映射成一个对象，用于自定义配置项比较多的情况
案例演示
➢ 在 com.abc.springboot.config 包下创建 ConfigInfo 类，并为该类加上 Component 和
ConfigurationProperties 注解，并在 ConfigurationProperties 注解中添加属性 prefix，
作用可以区分同名配置

package com.bjpowernode.springboot.model;import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;@Component  //将此类加载到spring容器中
@ConfigurationProperties(prefix = "school")
public class School {private String name;private String website;public String getName() {return name;}public void setName(String name) {this.name = name;}public String getWebsite() {return website;}public void setWebsite(String website) {this.website = website;}
}

application.properties 配置文件

在 SpringBootController 中利用@Autowired注入school 配置类

package com.bjpowernode.springboot.web;import com.bjpowernode.springboot.model.City;
import com.bjpowernode.springboot.model.School;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;@Controller
public class IndexController {@Autowiredprivate School school;@Autowiredprivate City city;@RequestMapping(value = "/school")public @ResponseBody Object school(){return "school.name="+school.getName()+",school.website="+school.getWebsite();}@RequestMapping(value = "/city")public @ResponseBody Object city(){return "city.name="+city.getName()+",city.website="+city.getWebsite();}
}

4、 Spring Boot 前端使用 JSP

4.1、在 pom.xml 文件中配置以下依赖项

<!--引入 Spring Boot 内嵌的 Tomcat 对 JSP 的解析包，不加解析不了 jsp 页面-->
<!--如果只是使用 JSP 页面，可以只添加该依赖-->
<dependency><groupId>org.apache.tomcat.embed</groupId><artifactId>tomcat-embed-jasper</artifactId>
</dependency>
<!--如果要使用 servlet 必须添加该以下两个依赖-->
<!-- servlet 依赖的 jar 包-->
<dependency><groupId>javax.servlet</groupId><artifactId>javax.servlet-api</artifactId>
</dependency>
<dependency><groupId>javax.servlet.jsp</groupId><artifactId>javax.servlet.jsp-api</artifactId><version>2.3.1</version>
</dependency>
<!--如果使用 JSTL 必须添加该依赖-->
<!--jstl 标签依赖的 jar 包 start-->
<dependency><groupId>javax.servlet</groupId><artifactId>jstl</artifactId>
</dependency>

4.2、 在 pom.xml 的 build 标签中要配置以下信息

SpringBoot 要求 jsp 文件必须编译到指定的 META-INF/resources 目录下才能访问，否则
访问不到。其实官方已经更建议使用模板技术（后面会讲模板技术）

        <!--SpringBoot框架集成jsp，指定jsp文件编译的路径META-INF/resources--><resources><resource><!--指定源文件路径--><directory>src/main/webapp</directory><!--指定编译的路径--><targetPath>META-INF/resources</targetPath><includes><!--指定要把哪些文件编译进去，**表示 webapp 目录及子目录，*.*表示所有文件--><include>*.*</include></includes></resource></resources>

4.3、在 application.properties 文件配置 Spring MVC 的视图展示为 jsp，这里相当于 Spring MVC 的配置

#SpringBoot 核心配置文件
#指定内嵌 Tomcat 端口号
server.port=8090
#配置 SpringMVC 视图解析器
#其中：/ 表示目录为 src/main/webapp
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp

如果使用application.yml 格式的配置文件，其配置文件应该为如下配置

#SpringBoot 核心配置文件
#指定内嵌 Tomcat 端口号
server:port: 8090servlet:context-path: /
#配置 SpringMVC 视图解析器
#其中：/ 表示目录为 src/main/webapp
spring:mvc:view:prefix: /suffix: .jsp

集成完毕之后，剩下的步骤和我们使用 Spring MVC 一样

4.4、 在 com.abc.springboot.controller 包下创建 JspController 类，并 编写代码

@Controller
public class SpringBootController {@RequestMapping(value = "/springBoot/jsp")public String jsp(Model model) {model.addAttribute("data","SpringBoot 前端使用 JSP 页面！");return "index";}
}

4.5、在 src/main 下创建一个 webapp 目录，然后在该目录下新建 index.jsp 页面

如果在webapp目录下右键，没有创建jsp的选项，可以在Project Structure中指定webapp
为 Web Resource Directory

4.6、在 jsp 中获取 Controller 传递过来的数据

index.jsp在如下位置

4.7、重新运行 Application，通过浏览器访问测试

5、SpringBoot 工程下使用 Mybatis 反向工程

项目名称：010-springboot-web-mybatis

通过 SpringBoot +MyBatis 实现对数据库学生表的查询操作
数据库参考：springboot.sql 脚本文件
文件如下：

drop table if exists t_student;
create table t_student 
(id                   int(10)                        not null auto_increment,name                 varchar(20)                    null,age                  int(10)                        null,constraint PK_T_STUDENT primary key clustered (id)
);insert into t_student(name,age) values("zhangsan",25);
insert into t_student(name,age) values("lisi",28);
insert into t_student(name,age) values("wangwu",23);
insert into t_student(name,age) values("Tom",21);
insert into t_student(name,age) values("Jck",55);
insert into t_student(name,age) values("Lucy",27);
insert into t_student(name,age) values("zhaoliu",75);

5.1、SpringBoot 工程下使用 Mybatis 反向工程

拷贝 Mybatis 反向工程配置文件到项目的根目录下
新建目录：GeneratorMapper.xml

5.2、根据项目及表的情况，修改 GeneratorMapper.xml 配置

DOCTYPE generatorConfigurationPUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN""http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration><classPathEntry location="D:\course\dev\repository\mysql\mysql-connector-java\8.0.21\mysql-connector-java-8.0.21.jar"/><context id="tables" targetRuntime="MyBatis3"><commentGenerator><property name="suppressAllComments" value="true"/>commentGenerator><jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"connectionURL="jdbc:mysql://localhost:3306/springboot?serverTimezone=Asia/Shanghai"userId="root"password="990325">jdbcConnection><javaModelGenerator targetPackage="com.bjpowernode.springboot.model"targetProject="src/main/java"><property name="enableSubPackages" value="false"/><property name="trimStrings" value="false"/>javaModelGenerator><sqlMapGenerator targetPackage="com.bjpowernode.springboot.mapper"targetProject="src/main/java"><property name="enableSubPackages" value="false"/>sqlMapGenerator><javaClientGenerator type="XMLMAPPER"targetPackage="com.bjpowernode.springboot.mapper" targetProject="src/main/java"><property name="enableSubPackages" value="false"/>javaClientGenerator><table tableName="t_student" domainObjectName="Student"enableCountByExample="false"enableUpdateByExample="false"enableDeleteByExample="false"enableSelectByExample="false"selectByExampleQueryId="false"/>context>
generatorConfiguration>

5.3、在 pom.xml 文件中添加 mysql 反向工程依赖

<plugin><groupId>org.mybatis.generatorgroupId><artifactId>mybatis-generator-maven-pluginartifactId><version>1.3.6version><configuration><configurationFile>GeneratorMapper.xmlconfigurationFile><verbose>trueverbose><overwrite>trueoverwrite>configuration>
plugin>

5.4、双击红色选中命令，生成相关文件

结果如下：
将会自动产生mapper文件和model文件

5.5、对生成的StudentMapper.xml进行分析

DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjpowernode.springboot.mapper.StudentMapper"><resultMap id="BaseResultMap" type="com.bjpowernode.springboot.model.Student">


<id column="id" jdbcType="INTEGER" property="id" /><result column="name" jdbcType="VARCHAR" property="name" /><result column="age" jdbcType="INTEGER" property="age" />resultMap><sql id="Base_Column_List">id, name, agesql><select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">select <include refid="Base_Column_List" />from t_studentwhere id = #{id,jdbcType=INTEGER}select><delete id="deleteByPrimaryKey" parameterType="java.lang.Integer">delete from t_studentwhere id = #{id,jdbcType=INTEGER}delete><insert id="insert" parameterType="com.bjpowernode.springboot.model.Student">insert into t_student (id, name, age)values (#{id,jdbcType=INTEGER}, #{name,jdbcType=VARCHAR}, #{age,jdbcType=INTEGER})insert><insert id="insertSelective" parameterType="com.bjpowernode.springboot.model.Student">insert into t_student<trim prefix="(" suffix=")" suffixOverrides=","><if test="id != null">id,if><if test="name != null">name,if><if test="age != null">age,if>trim><trim prefix="values (" suffix=")" suffixOverrides=","><if test="id != null">#{id,jdbcType=INTEGER},if><if test="name != null">#{name,jdbcType=VARCHAR},if><if test="age != null">#{age,jdbcType=INTEGER},if>trim>insert><update id="updateByPrimaryKeySelective" parameterType="com.bjpowernode.springboot.model.Student">update t_student<set><if test="name != null">name = #{name,jdbcType=VARCHAR},if><if test="age != null">age = #{age,jdbcType=INTEGER},if>set>where id = #{id,jdbcType=INTEGER}update><update id="updateByPrimaryKey" parameterType="com.bjpowernode.springboot.model.Student">update t_studentset name = #{name,jdbcType=VARCHAR},age = #{age,jdbcType=INTEGER}where id = #{id,jdbcType=INTEGER}update>mapper>

6、Spring Boot 集成 MyBatis

6.1、创建一个新的 SpringBoot 的 Module

6.2在 pom.xml 中添加相关 jar 依赖

<dependency><groupId>mysqlgroupId><artifactId>mysql-connector-javaartifactId>dependency><dependency><groupId>org.mybatis.spring.bootgroupId><artifactId>mybatis-spring-boot-starterartifactId><version>2.0.0version>dependency>

6.3、在 Springboot 的核心配置文件 application.properties 中配 置数据源

注意根据自己数据库的信息修改以下内容

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=990325

6.4、开发代码 ➢ 使用 Mybatis 反向工程生成接口、映射文件以及实体 bean，具体步骤参见目录5

6.5、 在 web 包下创建 StudentController 并编写代码

package com.bjpowernode.springboot.web;import com.bjpowernode.springboot.model.Student;
import com.bjpowernode.springboot.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;/*** @Author ljm* @Date 2021/8/23 21:44* @Version 1.0*/
@RestController
public class studentcontroller {@Autowiredprivate StudentService studentService;@RequestMapping(value = "say")public Student queryById(Integer id){//调用业务层的方法Student student = studentService.queryById(id);return student;}
}

6.6、在service 包下创建 service 接口并编写代码

package com.bjpowernode.springboot.service;import com.bjpowernode.springboot.model.Student;/*** @Author ljm* @Date 2021/8/23 21:48* @Version 1.0*/
public interface StudentService {//查询详情Student queryById(Integer id);
}

6.7、在 service.impl 包下创建 service 接口并编写代码

package com.bjpowernode.springboot.service.impl;import com.bjpowernode.springboot.mapper.StudentMapper;
import com.bjpowernode.springboot.model.Student;
import com.bjpowernode.springboot.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;/*** @Author ljm* @Date 2021/8/23 21:49* @Version 1.0*/
@Service
public class StudentServiceImpl implements StudentService {@Autowiredprivate StudentMapper studentMapper;@Overridepublic Student queryById(Integer id) {return studentMapper.selectByPrimaryKey(id);}
}

spring注解@Service注解的使用

spring注解@Service注解的使用

6.8、在pom.xml文件中指定资源文件夹（这个前题是Studentmapper.xml文件在src/main/java路径下）

默认情况下，Mybatis 的 xml 映射文件不会编译到 target 的 class 目录下，所
以我们需要在 pom.xml 文件中配置 resource

<resources><resource><directory>src/main/javadirectory><includes><include>**/*.xmlinclude>includes>resource>resources>

6.9、在 Mybatis 反向工程生成的 StudentMapper 接口上加一个 Mapper 注解

package com.bjpowernode.springboot.mapper;import com.bjpowernode.springboot.model.Student;
import org.apache.ibatis.annotations.Mapper;@Mapper
public interface StudentMapper {int deleteByPrimaryKey(Integer id);int insert(Student record);int insertSelective(Student record);Student selectByPrimaryKey(Integer id);int updateByPrimaryKeySelective(Student record);int updateByPrimaryKey(Student record);
}

6.10、DAO 其它开发方式（替换6.9）

在 运 行 的 主 类 上 添 加 注 解 包 扫 描
@MapperScan(“com.abc.springboot.mapper”)
注释掉 StudentMapper 接口上的@Mapper 注解

在运行主类 Application 上加@MapperScan(“com.abc.springboot.mapper”)

SpringBoot集成MyBatis，最主要的是两个注解@Mapper，@Mapperscan
@Mapper需要在每一个Mapper接口类上添加，作用扫描dao接口
@Mapperscan是在SpringBoot启动入口类上添加的，它是扫描所有的包

6.11、启动 Application 应用，浏览器访问测试运行

6.12、将接口和映射文件分开(区别于6.8）

因为 SpringBoot 不能自动编译接口映射的 xml 文件，还需要手动在 pom 文件中指定，
所以有的公司直接将映射文件直接放到 resources 目录下
➢ 在 resources 目录下新建目录 mapper 存放映射文件，将 StudentMapper.xml 文件移
到 resources/mapper 目录下

6.8结构
6.12移动后结构

在 application.properties 配置文件中指定映射文件的位置，这个配置只有接口和映
射文件不在同一个包的情况下，才需要指定

# 指定 Mybatis 映射文件的路径
mybatis.mapper-locations=classpath:mapper/*.xml

无须再配置 resource

关于Mapper映射文件存放的位置的写法有以下两种：
1，将Mapper接口和Mapper映射文件存放到src/main/java同一目录下，还需要在pom文件中手动指定资源文件夹路径resources
2·将Mapper接口和Mapper映射文件分开存放Mapper接口类存放到src/main/java目录下Mapper映射文件存放到resources（类路径）
在springboot核心配置文件中指定mapper映射文件存放到位置

7、Spring Boot 事务支持

Spring Boot 使用事务非常简单，底层依然采用的是 Spring 本身提供的事务管理
➢ 在入口类中使用注解 @EnableTransactionManagement 开启事务支持
➢ 在访问数据库的 Service 方法上添加注解 @Transactional 即可
通过 SpringBoot +MyBatis 实现对数据库学生表的更新操作，在 service 层的方法中构建
异常，查看事务是否生效
项目名称：012-springboot-web-mybatis-transacation
该项目是在 章节6 的基础上添加新增方法，在新增方法中进行案例的演示

7.1、在 StudentController 中添加更新学生的方法

@RequestMapping(value = "/springboot/modify")
public @ResponseBody Object modifyStudent() {int count = 0;try {Student student = new Student();student.setId(1);student.setName("Jack");student.setAge(33);count = studentService.modifyStudentById(student);} catch (Exception e) {e.printStackTrace();return "fail";}return count;
}

7.2、在 StudentService 接口中添加更新学生方法

/**
* 根据学生标识更新学生信息
* @param student
北京动力节点 www.bjpowernode.com
40
* @return
*/
int modifyStudentById(Student student);

7.3、在 StudentServiceImpl 接口实现类中对更新学生方法进 行实现，并构建一个异常，同时在该方法上加@Transactional 注解

@Override
@Transactional //添加此注解说明该方法添加的事务管理
public int update(Student student) {int updateCount = studentMapper.updateByPrimaryKeySelective(student);System.out.println("更新结果：" + updateCount);//在此构造一个除数为 0 的异常，测试事务是否起作用int a = 10/0;return updateCount;
}

在Application类上加@EnableTransactionManagement
开启事务支持
@EnableTransactionManagement 可选，但是业务方法上必须添加@Transactional 事务才生效

@SpringBootApplication
@MapperScan(basePackages = "com.abc.springboot.mapper")
@EnableTransactionManagement //开启事务支持(可选项，但@Transactional 必须添加)
public class Application {

7.4、启动 Application，通过浏览器访问进行测试

8、Spring Boot 下的 Spring MVC

Spring Boot 下的 Spring MVC 和之前的 Spring MVC 使用是完全一样的，主要有以下注解

8.1、 @Controller

Spring MVC 的注解，处理 http 请求

8.2、 @RestController

Spring 4 后新增注解，是@Controller 注解功能的增强
是 @Controller 与@ResponseBody 的组合注解
如果一个 Controller 类添加了@RestController，那么该 Controller 类下的所有方法都相当
于添加了@ResponseBody 注解
用于返回字符串或 json 数据
案例：
➢ 创建 MyRestController 类，演示@RestController 替代@Controller + @ResponseBody

@RestController
public class MyRestController {@Autowiredprivate StudentService studentService;@RequestMapping("/boot/stu")public Object stu(){return studentService.getStudentById(1);}
}

➢ 启动应用，浏览器访问测试

8.3、@RequestMapping（常用）

支持 Get 请求，也支持 Post 请求

8.4 、@GetMapping

RequestMapping 和 Get 请求方法的组合
只支持 Get 请求
Get 请求主要用于查询操作

8.5、 @PostMapping

RequestMapping 和 Post 请求方法的组合
只支持 Post 请求
Post 请求主要用户新增数据

8.6 、@PutMapping

RequestMapping 和 Put 请求方法的组合
只支持 Put 请求
Put 通常用于修改数据

8.7、 @DeleteMapping

RequestMapping 和 Delete 请求方法的组合
只支持 Delete 请求
通常用于删除数据

8.8、Http 接口请求工具 Postman 介绍

因为通过浏览器输入地址，默认发送的只能是 get 请求，通过 Postman 工具，可以模拟
发送不同类型的请求，并查询结果，在安装的时候，有些机器可能会需要安装 MicroSort .NET
Framework

9、Spring Boot 使用拦截器

9.1、创建一个 SpringBoot 框架 Web 项目

9.2、 实现一个登录拦截器

package com.bjpowernode.springboot.interceptor;import com.bjpowernode.springboot.model.User;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;public class UserInterceptor implements HandlerInterceptor {@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {//拦截的规则//从session中获取用户的信息User user = (User) request.getSession().getAttribute("user");//判断用户是否为空if (null == user){response.sendRedirect(request.getContextPath() + "/user/page/login");return false;}return true;}@Overridepublic void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {}@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {}
}

9.3、 创建一个控制层

package com.bjpowernode.springboot.web;import com.bjpowernode.springboot.model.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;import javax.servlet.http.HttpServletRequest;@RestController
public class IndexController {/*** 无需用户登录* @return*/@RequestMapping(value = "/index")public String index(){return "INDEX";}/*** 无需用户登录* @return*/@RequestMapping(value = "/user/page/login")public String loginPage(){return "Login Page";}@RequestMapping(value = "/user/login")public String login(HttpServletRequest request){User user = new User();user.setId(1);user.setUsername("lisi");request.getSession().setAttribute("user",user);return "Logged";}/*** 需要用户是登录状态* @return*/@RequestMapping(value = "/user/center")public String center(){return "User Center";}
}

9.4、@Configuration 定义配置类-拦截器

在 项 目 中 创 建 一 个 config 包，创建 一 个 配 置 类 SystemConfig， 并 实 现
WebMvcConfigurer 接口， 覆盖接口中的 addInterceptors 方法，并为该配置类添加
@Configuration 注解，标注此类为一个配置类，让 Spring Boot 扫描到，这里的操作就相当
于 SpringMVC 的注册拦截器 ，@Configuration 就相当于一个 applicationContext-mvc.xml

package com.bjpowernode.springboot.config;import com.bjpowernode.springboot.interceptor.UserInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;@Configuration  //只要类上加@Configuration，就说明此类为一个配置类，就相当于一个xml配置文件
public class SystemConfig implements WebMvcConfigurer {@Overridepublic void addInterceptors(InterceptorRegistry registry) {//定义要拦截的路径String[] addPathPatterns = {"/user/**"};//排除不需要拦截的路径String[] excludePathPatterns = {"/user/page/login","/user/login"};registry.addInterceptor(new UserInterceptor()).addPathPatterns(addPathPatterns).excludePathPatterns(excludePathPatterns);}
}

10、 SpringBoot 集成 logback 日志

10.1、使用该功能步骤

项目名称：036-springboot-logback

10.2、创建 SpringBoot 框架 web 项目

10.3、通过 MyBatis 逆向工程生成 DAO

添加mysql和mybatis集成springboot依赖

        <dependency><groupId>mysqlgroupId><artifactId>mysql-connector-javaartifactId>dependency><dependency><groupId>org.mybatis.spring.bootgroupId><artifactId>mybatis-spring-boot-starterartifactId><version>2.0.0version>dependency>

将逆向生成文件放到项目根目录

DOCTYPE generatorConfigurationPUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN""http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration><classPathEntry location="D:\course\dev\repository\mysql\mysql-connector-java\8.0.21\mysql-connector-java-8.0.21.jar"/><context id="tables" targetRuntime="MyBatis3"><commentGenerator><property name="suppressAllComments" value="true"/>commentGenerator><jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"connectionURL="jdbc:mysql://localhost:3306/springboot?serverTimezone=Asia/Shanghai"userId="root"password="990325">jdbcConnection><javaModelGenerator targetPackage="com.bjpowernode.springboot.model"targetProject="src/main/java"><property name="enableSubPackages" value="false"/><property name="trimStrings" value="false"/>javaModelGenerator><sqlMapGenerator targetPackage="com.bjpowernode.springboot.mapper"targetProject="src/main/java"><property name="enableSubPackages" value="false"/>sqlMapGenerator><javaClientGenerator type="XMLMAPPER"targetPackage="com.bjpowernode.springboot.mapper" targetProject="src/main/java"><property name="enableSubPackages" value="false"/>javaClientGenerator><table tableName="t_student" domainObjectName="Student"enableCountByExample="false"enableUpdateByExample="false"enableDeleteByExample="false"enableSelectByExample="false"selectByExampleQueryId="false"/>context>
generatorConfiguration>

在 pom.xml 文件 -> build -> plugins 中添加插件

<!--mybatis 代码自动生成插件-->
<plugin><groupId>org.mybatis.generator</groupId><artifactId>mybatis-generator-maven-plugin</artifactId><version>1.3.6</version><configuration><!--配置文件的位置--><configurationFile>GeneratorMapper.xml</configurationFile><verbose>true</verbose><overwrite>true</overwrite></configuration>
</plugin>

双击生成
配置application.proprietary

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=990325

10.4、手动指定资源文件夹

在build下面配置
默认情况下，Mybatis 的 xml 映射文件不会编译到 target 的 class 目录下，所
以我们需要在 pom.xml 文件中配置 resource

        <resources><resource><directory>src/main/javadirectory><includes><include>**/*.xmlinclude>includes>resource>resources>

10.5 编写 StudentController

@Slf4j

@Slf4j

package com.bjpowernode.springboot.web;import com.bjpowernode.springboot.service.StudentService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;/*** @Author ljm* @Date 2021/8/25 11:58* @Version 1.0*/
@RestController
@Slf4j
public class StudentController {@Autowiredprivate StudentService studentService;@RequestMapping(value = "/count")public String studentCount(){log.info("我是卷王");Integer studentCount = studentService.queryStudentCount();return "学生人数是："+studentCount;}
}

10.6 编写 StudentService 接口及实现类

package com.bjpowernode.springboot.service;/*** @Author ljm* @Date 2021/8/25 12:01* @Version 1.0*/
public interface StudentService {Integer queryStudentCount();}

package com.bjpowernode.springboot.service.impl;import com.bjpowernode.springboot.mapper.StudentMapper;
import com.bjpowernode.springboot.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;/*** @Author ljm* @Date 2021/8/25 12:02* @Version 1.0*/
@Service
public class StudentServiceImpl implements StudentService {@Autowiredprivate StudentMapper studentMapper;@Overridepublic Integer queryStudentCount() {return studentMapper.selectStudentCount();}
}

10.7 数据持久层

StudentMapper.java

    //获取学生总人数Integer selectStudentCount();

StudentMapper.xml

  <select id="selectStudentCount" resultType="java.lang.Integer">select count(*) from  t_studentselect>

10.8、日志文件

Spring Boot 官方推荐优先使用带有 -spring 的文件名作为你的日志配置（如使用
logback-spring.xml ，而不是 logback.xml），命名为 logback-spring.xml 的日志配置文件。
默认的命名规则，并且放在 src/main/resources 下如果你即想完全掌控日志配置，但又不想
用 logback.xml 作为 Logback 配置的名字，application.yml 可以通过 logging.config 属性指定自
定义的名字：

logging.config=classpath:logging-config.xml

（1） 我们一般针对 DAO 的包进行 DEBUG 日志设置：

<logger name="com.abc.springboot.mapper" level="DEBUG" />

这样的话，只打印 SQL 语句：

代码里打印日志
之前我们大多数时候自己在每个类创建日志对象去打印信息，比较麻烦：

private static final Logger logger = LoggerFactory.getLogger(StudentServiceImpl.class);
logger.error("xxx");

现在可以直接在类上通过 @Slf4j 标签去声明式注解日志对象
在 pom.xml 中添加依赖

<dependency><groupId>org.projectlombokgroupId><artifactId>lombokartifactId><version>1.18.2version>
dependency>

logback-spring.xml

<configuration scan="true" scanPeriod="10 seconds"><appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender"><filter class="ch.qos.logback.classic.filter.ThresholdFilter"><level>debuglevel>filter><encoder><Pattern>%date [%-5p] [%thread] %logger{60} [%file : %line] %msg%nPattern><charset>UTF-8charset>encoder>appender><appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender"><File>D:/log/stdout.logFile><encoder><pattern>%date [%-5p] %thread %logger{60} [%file : %line] %msg%npattern>encoder><rollingPolicyclass="ch.qos.logback.core.rolling.TimeBasedRollingPolicy"><fileNamePattern>D:/log/stdout.log.%d{yyyy-MM-dd}.logfileNamePattern><maxHistory>30maxHistory>rollingPolicy>appender><logger name="com.bjpowernode.springboot.mapper" level="DEBUG"/><root level="INFO"><appender-ref ref="CONSOLE"/><appender-ref ref="FILE"/>root>
configuration>

10.9 Application 启动类

**@MapperScan(basePackages = “com.bjpowernode.springboot.mapper”)**用于扫描mapper包

package com.bjpowernode.springboot;import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication
@MapperScan(basePackages = "com.bjpowernode.springboot.mapper")
public class Application {public static void main(String[] args) {SpringApplication.run(Application.class, args);}}

10.10、启动测试

11、SpringBoot 集成 Thymeleaf 模板

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

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

11.1 项目名称：037-springboot-thymeleaf-first

创建 Spring Boot 项目,添加 web 和 Thymeleaf 依赖

new module


按照这种方式创建后，pom.xml 文件下会自动添加如下依赖

<dependency><groupId>org.springframework.bootgroupId><artifactId>spring-boot-starter-thymeleafartifactId>
dependency>

<dependency><groupId>org.springframework.bootgroupId><artifactId>spring-boot-starter-webartifactId>
dependency>

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

#thymeleaf 页面的缓存开关，默认 true 开启缓存
#建议在开发阶段关闭 thymeleaf 页面缓存，目的实时看到页面
spring.thymeleaf.cache=false

下面的配置可有可无，没有也可以工作，因为基本 Thymeleaf 的配置都有默认值

前缀：
#thymeleaf 模版前缀,默认可以不写
spring.thymeleaf.prefix=classpath:/templates/
后缀：
#thymeleaf 模版后缀,默认可以不写
spring.thymeleaf.suffix=.html

如果仅仅将spring.thymeleaf.cache设置成false
再刷新没有任何效果
需要接下来修改项目的configuration

所有说关闭缓存需要两步，第一在application.properties中设置spring.thymeleaf.cache设置成false，第二
在启动入口类上把configuration修改为update resources

11.3 创建 ThymeleafControlle 去映射到模板页面（和 SpringMVC 基 本一致）

@Controller
public class ThymeleafController {@RequestMapping(value = "/thymeleaf/index")public String index(Model model) {model.addAttribute("data","SpringBoot 成功集成 Thymeleaf 模版！");return "index";}
}

11.4 在 src/main/resources 的 templates 下新建一个 index.html 页 面用于展示数据

HTML 页面的元素中加入以下属性：

DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head><meta charset="UTF-8"><title>SpringBoot 集成 Thymeleaftitle>
head>
<body ><span th:text="${data}">span><span th:text="${data}">span><p th:text="${data}">p><div th:text="${data}">div>
body>
html>

11.5 启动程序，浏览器访问 http://localhost:8080/index

右键->查看页面源代码

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

12 Thymeleaf 的表达式

12.1 项目名称：038-springboot-thymeleaf-expression

（1） 创建 SpringBoot 的 web 项目并使用模版引擎


（2）pom.xml 中应该有如下两个依赖

<dependency><groupId>org.springframework.bootgroupId><artifactId>spring-boot-starter-thymeleafartifactId>
dependency>

<dependency><groupId>org.springframework.bootgroupId><artifactId>spring-boot-starter-webartifactId>

#设置 thymeleaf 页面缓存失效
spring.thymeleaf.cache=false
#thymeleaf 模版前缀，默认值,可选项
spring.thymeleaf.prefix=classpath:/templates/
#thymeleaf 模版后缀，默认值,可选项
spring.thymeleaf.suffix=.html

@Data
public class User {private Integer id;private String name;private String phone;private String address;
}

@Controller
public class ThymeleafController {@RequestMapping(value = "/thymeleaf/index")public String index(Model model) {model.addAttribute("data","SpringBoot 集成 Thymeleaf 模版!");return "index";}
//另一种写法@RequestMapping(value = "/index1")public ModelAndView index1(){ModelAndView mv = new ModelAndView();//添加视图名称mv.setViewName("index");mv.addObject("data","Spring");return mv;}}

DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head><meta charset="UTF-8"><title>Thymeleaf'Indextitle>
head>
<body>
<span th:text="${data}">span>
body>
html>

@RequestMapping(value = "/thymeleaf/user")
public String user(Model model) {User user = new User();user.setId(1);user.setName("张三");user.setPhone("13700000000");user.setAddress("北京市亦庄经济开发区");model.addAttribute("user",user);return "user";
}

DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head><meta charset="UTF-8"><title>展示用户对象信息title>
head>
<body>
<h2>展示 User 用户信息：h2>
用户编号：<span th:text="${user.id}">span><br/>
用户姓名：<span th:text="${user.name}">span><br/>
用户手机号：<span th:text="${user.phone}">span><br/>
用户地址：<span th:text="${user.address}">span><br/>
body>
html>

<h2>展示 User 用户信息（星号表达式,仅在 div 范围内有效）：h2>
<div th:object="${user}">用户编号：<span th:text="*{id}">span><br/>用户姓名：<span th:text="*{name}">span><br/>用户手机号：<span th:text="*{phone}">span><br/>用户地址：<span th:text="*{address}">span><br/>