2021springboot笔记

1、SpringBoot入门 1-25 26-46

1.1 如何创建一个springboot框架web项目 001

创建一个空项目，然后添加模块Spring Initializr，然后添加相关信息就行了。

1.2 集成springmvc 002

• 使用springboot框架集成springmvc

创建完了之后，就已经集成好了mvc

1.3 核心配置文件application.properties 003

• 使用springboot框架的核心配置文件application.properties

1.4 核心配置文件application.yml或application.yaml 004

• 使用springboot的核心配置文件application.yml或者application.yaml

yml和yaml格式文件都是这

1.5 核心配置.properties和.yaml或者.yml同时存在？005

• springboot框架的核心配置application.properties和application.yaml或者application.yml同时存在？

application.properties优先级大于application.yml

1.6 多环境下核心配置文件的使用（properties） 005

• 多环境下核心配置文件的使用（properties），工作中开发的环境有哪些：开发环境，测试环境，准生产环境，生产环境

1.7 多环境下核心配置文件的使用（yaml或者yml）

• 多环境下核心配置文件的使用（yaml或者yml），工作中开发的环境有哪些：开发环境，测试环境，准生产环境，生产环境

与第6个类似，只是书写语法不同

1.8 @Value 008

• springboot在核心配置文件application.properties自定义配置一个一个获取

使用注解 @Value
配置文件:

对应controller文件：

如果配置文件是 .yml 文件（官方推荐也是这种文件），可以直接配置对象：（并且在.yml文件中，可以使用一些函数，比如${random.int}之类的）

1.9 核心配置文件将自定义配置映射到一个对象 008

• springboot在核心配置文件将自定义配置映射到一个对象

首先配置文件

然后封装一个类：

然后使用@Autowired注入进来使用

注：解决使用@ConfigurationProperties注解出现的警告问题

<!--        解决使用@ConfigurationProperties注解出现的警告问题-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

1.10 SpringBoot集成jsp 010

创建文件夹

打开项目结构


添加依赖：

<!--        引入spring boot内嵌Tomact的解析依赖，不添加解析不了jsp-->
<!--        仅仅只是展示jsp页面，只添加一下一个依赖-->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>

然后在build中添加

    <build>
<!--        SpringBoot项目默认推荐使用的前端引擎是thymeleaf
            现在我们要使用springboot集成jsp，手动指定jsp最后编译的路径
            而且springboot集成jsp编译jsp的路径是springboot规定好的位置
            META-INF/resources
-->
        <resources>
            <resource>
                <!--源文件夹 -->
                <directory>src/main/webapp</directory>
                <!--指定编译到META-INF/resources -->
                <targetPath>META-INF/resources</targetPath>
                <!--指定源文件夹中的哪个资源要编译进行 -->
                <includes>
                    <include>*.*</include>
                </includes>
            </resource>
        </resources>

最后在配置文件中配置视图解析器

# 配置视图解析器
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp

配置完成后，如何使用？
先在webapp中新建jsp文件

然后在controller中使用，（这里是两种使用方法）
特别注意：在这里第二种方法使用时：方法名前不要加注解@ResponseBody
对于下图，如果加了@ResponseBody注解，返回的就是字符串；如果不加@ResponseBody注解，返回的是页面。

2、SpringBoot框架web开发

2.11 SpringBoot集成MyBatis 012

a.添加mybatis依赖，MySQL驱动

<!--MySQL驱动-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

<!--MyBatis整合SpringBoot框架的起步依赖-->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.0.0</version>
</dependency>

b.使用MyBatis提供的逆向工程生成实体bean，映射文件，Dao接口

项目根目录下新建这个 GeneratorMapper.xml

把如下内容填入进去(00处修改位置，0处修改jdbc连接，123处修改包名，4处修改表名 实体类名) GeneratorMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>

    <!-- 00-->
    <!-- 指定连接数据库的 JDBC 驱动包所在位置，指定到你本机的完整路径 -->
    <classPathEntry location="D:\mysql-connector-java-5.1.26.jar"/>
    <!-- 配置 table 表信息内容体，targetRuntime 指定采用 MyBatis3 的版本 -->
    <context id="tables" targetRuntime="MyBatis3">
        <!-- 抑制生成注释，由于生成的注释都是英文的，可以不让它生成 -->
        <commentGenerator>
            <property name="suppressAllComments" value="true" />
        </commentGenerator>
        <!-- 0-->
        <!-- 配置数据库连接信息 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/springboot"
                        userId="root"
                        password="991113">
        </jdbcConnection>
        <!-- 1  实体类-->
        <!-- 生成 model 类，targetPackage 指定 model 类的包名， targetProject 指定
       生成的 model 放在 eclipse 的哪个工程下面-->
        <javaModelGenerator targetPackage="com.hui.liu.model"
                            targetProject="src/main/java">
            <property name="enableSubPackages" value="false" />
            <property name="trimStrings" value="false" />
        </javaModelGenerator>
        <!-- 2  Mapper.xml文件-->
        <!-- 生成 MyBatis 的 Mapper.xml 文件，targetPackage 指定 mapper.xml 文件的
       包名， targetProject 指定生成的 mapper.xml 放在 eclipse 的哪个工程下面 -->
        <sqlMapGenerator targetPackage="com.hui.liu.mapper"
                         targetProject="src/main/java">
            <property name="enableSubPackages" value="false" />
        </sqlMapGenerator>
        <!-- 3  Mapper接口文件-->
        <!-- 生成 MyBatis 的 Mapper 接口类文件,targetPackage 指定 Mapper 接口类的包
       名， targetProject 指定生成的 Mapper 接口放在 eclipse 的哪个工程下面 -->
        <javaClientGenerator type="XMLMAPPER"
                             targetPackage="com.hui.liu.mapper"
                             targetProject="src/main/java">
            <property name="enableSubPackages" value="false" />
        </javaClientGenerator>

		<!-- 4-->
        <!-- 数据库表名及对应的 Java 模型类名 (第一行前后两个分别是 表名 和 实体类名 )-->
        <table tableName="t_student" domainObjectName="Student"
               enableCountByExample="false"
               enableUpdateByExample="false"
               enableDeleteByExample="false"
               enableSelectByExample="false"
               selectByExampleQueryId="false"/>
    </context>
</generatorConfiguration>

在pom文件中添加一个插件

<!--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>

双击此处生成

结果：

c.生成映射文件中都什么意思？

一个对数据库操作的小项目练手 012

Mapper接口这里要加@Mapper注解，service接口实现类这里要加@Service注解
可以对mapper包里的每一个接口都加一个@Mapper注解，也可以直接在启动文件那里加一个总的注解@MapperScan(basePackages = “com.hui.liu.mapper”) 对于参数提示，快捷键ctrl+p
这里注解除了 @Mapper ，可以再加一个 @Repository

也可以只写这一个：

@MapperScan(basePackages="com.hui.liu.mapper")

手动指定文件夹为resources（这是第一种写法，后面还有第二种写法）

<!--手动指定文件夹为resources,因为mapper在java文件夹，不写这个会找不到的-->
<resources>
    <resource>
        <directory>src/main/java</directory>
        <includes>
            <include>**/*.xml</include>
        </includes>
    </resource>
</resources>

配置文件设置连接数据库的信息

# 配置连接数据库的配置
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=991113

2.12 Mapper映射文件存放位置 015

这里看第二种写法，将xml资源文件，放到resources下面的mapper文件夹（自己创建）
然后再application.properties中指定MyBatis映射文件的路径

# 指定MyBatis映射文件的路径(这里面classpath:指的是resources文件夹)
# (下面这句话的意思就是resources文件夹下mapper文件夹下的所有.xml文件)
mybatis.mapper-locations=classpath:mapper/*.xml
# 下面这个也可以加上,关于别名的(后面是实体类路径)
mybatis.type-aliases-package=com.hui.pojo

2.13-15 11和12的总结

2.16 事务 016

• SpringBoot项目下使用事务

事务是一个完整的功能，也叫做一个完整的业务
事务只跟什么SQL语句有关系？事务只跟DML语句有关系：增删改
DML, DQL, DDL, TCL, DCL

怎么使用事务功能呢？
只需要在相应方法上加上@Transactional注解就行了

2.17 SpringBoot常用注解 017

@RestController注解
@GetMapping(value = “/studentDetail2”)注解
@PostMapping(value = “/insert”)注解
@DeleteMapping(value = “/delete”)注解
@PutMapping(value = “/update”)注解

各个注解用法：

2.18 RESTFul风格 018

2.19 集成Redis 019

a.添加操作redis数据类型的依赖
b.在SpringBoot核心配置文件中添加redis的配置
依赖：

<!--        SpringBoot集成Redis的起步依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

配置信息：

# 设置redis配置信息
spring.redis.host=
spring.redis.port=
spring.redis.password=

注入对象：

    @Autowired
    private RedisTemplate<Object, Object> redisTemplate;

2.20-22 集成Dubbo分布式框架 020 021 022（详细看第8部分）

(类似几个工程间通信)
详细看第8部分，或者看该博客 Dubbo+ZooKeeper.
先创建三个项目，分别是以下三个。

a.接口工程：存放实体bean和业务接口 020 (建立一个maven工程，存放接口)

b.服务提供者：业务接口的实现类并将服务暴露且注册到注册中心，调用数据持久层 021 （一个springboot工程，对接口的实现）

	- 添加依赖（dubbo，注册中心，接口工程）
	- 配置服务提供者核心配置文件

c.服务消费者：处理浏览器客户端发送的请求，从注册中心调用服务提供者所提供的服务 022 （一个spring boot工程，业务的实现）

	- 添加依赖（dubbo，注册中心，接口工程）
	- 配置服务消费者核心配置文件

详细内容：

b.服务提供者：业务接口的实现类并将服务暴露且注册到注册中心，调用数据持久层 021
- 添加依赖（dubbo，注册中心，接口工程）

<!--Dubbo集成SpringBoot框架起步依赖-->
<dependency>
    <groupId>com.alibaba.spring.boot</groupId>
    <artifactId>dubbo-spring-boot-starter</artifactId>
    <version>2.0.0</version>
</dependency>

<!--注册中心-->
<dependency>
    <groupId>com.101tec</groupId>
    <artifactId>zkclient</artifactId>
    <version>0.10</version>
</dependency>

<!--接口工程-->
<dependency>
    <groupId>com.hui.liu</groupId>
    <artifactId>020-springboot-dubbo-interface</artifactId>
    <version>1.0.0</version>
</dependency>

• 配置服务提供者核心配置文件

# 设置内嵌Tomcat端口号
server.port=8080
# 设置上下文根
server.servlet.context-path=/

# 设置dubbo的配置
spring.application.name=021-springboot-dubbo-provider
# 当前工程是一个服务提供者
spring.dubbo.server=true
# 设置注册中心
spring.dubbo.registry=zookeeper://192.168.154.128:2181

c.服务消费者：处理浏览器客户端发送的请求，从注册中心调用服务提供者所提供的服务 022
- 添加依赖（dubbo，注册中心，接口工程）

		同b

	- 配置服务消费者核心配置文件

# 设置内嵌Tomcat端口号
server.port=8080
# 设置上下文根
server.servlet.context-path=/

# 设置dubbo的配置
spring.application.name=021-springboot-dubbo-consumer

# 设置注册中心
spring.dubbo.registry=zookeeper://192.168.154.128:2181

相关注解

在提供者（021提供者工程，实现类需要加注解@Component 和@Service）

在消费者控制层类里面（022消费者工程，加注解@Reference）

在提供者类和消费者类启动类前都要加注解@EnableDubboConfiguration，如图所示：

2.23-25 集成Dubbo，Redis，MyBatis，Spring，SpringMVC，JSP 023 024 025

前面知识的大总和

• a.接口工程：存放实体bean和业务接口
• b.服务提供者：它是一个SpringBoot框架web项目，集成MyBatis,Redis
  – 添加依赖：MyBatis依赖，MySql驱动依赖， Dubbo依赖，zookeeper依赖，接口工程
  – 配置springboot核心配置文件
  – 配置连接数据库
  – 配置连接redis
  – 配置连接dubbo
• c.服务消费者：它是一个SpringBoot框架web项目，集成JSP,dubbo
  – 添加依赖：Dubbo依赖，zookeeper依赖，接口工程，解析JSP页面的依赖
  – 配置SpringBoot核心配置文件
  – 配置视图解析器
  – 配置dubbo

------------------------------------------------------------------------------

2.26 创建非web工程 026 了解即可

跟web项目的区别，就是不用勾选Spring Web
第一种方式：

2.27 创建非web工程2 027 了解即可

• 实现CommandLineRuner,重写run方法

第二种方式：

2.28 关闭工程的启动Logo 了解即可

@SpringBootApplication
public class Application {
	public static void main(String[] args) {
 	SpringApplication springApplication = new SpringApplication(Application.class);
 	//关闭启动 logo 的输出
 	springApplication.setBannerMode(Banner.Mode.OFF);
 	springApplication.run(args);
 	}
}

2.29 修改工程的启动Logo 了解即可

在resource 新建一个 banner.txt ，把内容写进去即可。
可 以 利 用 网 站 生 成 图 标 ： 链接1 或 者链接2。

2.30 拦截器 030

• 1 定义一个拦截器，实现HandlerInterceptor接口

• 2 创建一个配置类（即：在SpringMVC配置文件中使用mvc：interceptors标签）

2.31 使用Servlet 031 032 （了解就行）

• 创建一个servlet它要继承HttpServlet
• 在web.xml配置文件中使用servlet servlet-mapping

a.第一种方式031==> @WebServlet(urlPatterns = “”), @ServletComponentScan(basePackages = “”)


b.第二种方式 032 ===> 通过配置类注册组件

2.33 过滤器Filter 033 034

a.第一种方式：注解方式，使用注解@WebFilter(urlPatterns = “”)， 并在启动类使用注解@ServletComponentScan(basePackages = “”) 033

b.第二种方式：使用配置类的方式 034

2.35 设置字符编码 035 036 （掌握方法二即可）

a.第一种实现方式 035

• 写一个配置类，设置编码格式

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.filter.CharacterEncodingFilter;

@Configuration
public class SystemConfig {

    @Bean
    public FilterRegistrationBean characterEncodingFilterRegistrationBean(){
        //创建字符编码过滤器
        CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
        //设置强制使用指定字符编码
        characterEncodingFilter.setForceEncoding(true);
        //设置指定字符编码
        characterEncodingFilter.setEncoding("utf-8");


        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        //设置字符编码过滤器
        filterRegistrationBean.setFilter(characterEncodingFilter);
        //设置字符编码过滤器路径
        filterRegistrationBean.addUrlPatterns("/*");

        return filterRegistrationBean;
    }
}

• 在配置文件中指定一下

# 关闭springboot的http字符编码支持
# 只有关闭该选项后，spring字符编码过滤器才生效
server.servlet.encoding.enabled=false

• 在servlet中设置浏览器的编码格式

//统一设置浏览器编码格式
resp.setContentType("text/html;character=utf-8");

b.第二种实现方式 036 掌握这个就行

• 在配置文件中写如下内容

# 设置请求相应字符编码
server.servlet.encoding.enabled=true
server.servlet.encoding.force=true
server.servlet.encoding.charset=utf-8

• 在servlet中设置浏览器的编码格式

//统一设置浏览器编码格式
resp.setContentType("text/html;character=utf-8");

2.36 打war包 037

war包端口号和上下文根是以内嵌Tomcat为准
1.在.pom文件中加以下代码
在gva坐标前写

<!--修改打包方式-->
<packaging>war</packaging>

在build中写

<!--指定打war包的字符,  名字可以自己来取-->
<finalName>SpringBootWar</finalName>

在resources中写

<resource>
    <!--源文件夹-->
    <directory>src/main/webapp</directory>
    <!--目标文件夹-->
    <targetPath>META-INF/resources</targetPath>
    <!--包含的文件-->
    <includes>
        <include>**/*.*</include>
    </includes>
</resource>
<!--mybatis 的 mapper.xml-->
<resource>
    <directory>src/main/java</directory>
    <includes>
        <include>**/*.xml</include>
    </includes>
</resource>
<!--src/main/resources 下的所有配置文件编译到 classes 下面去-->
<resource>
    <directory>src/main/resources</directory>
    <includes>
        <include>**/*.*</include>
    </includes>
</resource>

2.在入口类中继承SpringBootServletInitializer类

在Meven中双击package即可

2.37 打jar包 038

jar包端口号和上下文根就是springboot核心配置文件中设置的值
自带打包插件这里加上这个版本号

build里面可以指定打包的名字

然后就可以在Maven中双击package进行打包了

将生成的.jar文件，可以放到任何位置，使用下面命令就可以执行

java -jar 包名.jar

Windows后台运行的jar包怎么关闭？
如果后台启动怎样找到对应服务。
查看所有端口占用情况

netstat -ano

服务的端口查询进程的PID

netstat -ano | findstr “8900”

查看PID对应的服务名称

tasklist | findstr “PID号”

kill这个服务

taskkill /f /t /im javaw.exe

2.39 集成logback日志 039

在resources下新建文件 logback-spring.xml，内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<!-- 日志级别从低到高分为
TRACE < DEBUG < INFO < WARN < ERROR < FATAL，
如果设置为 WARN，则低于 WARN 的信息都不会输出 -->
<!--
scan:当此属性设置为 true 时，配置文件如果发生改变，将会被重新加载，默认值为true
-->
<!-- scanPeriod:设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认
单位是毫秒。当 scan 为 true 时，此属性生效。默认的时间间隔为 1 分钟。 -->
<!-- debug:当此属性设置为 true 时，将打印出 logback 内部日志信息，实时查看 logback
运行状态。默认值为 false。通常不打印 -->
<configuration scan="true" scanPeriod="10 seconds">
    <!-- 1 ..  输出到->控制台<-  -->
    <appender name="CONSOLE"
              class="ch.qos.logback.core.ConsoleAppender">
        <!--此日志 appender 是为开发使用，只配置最底级别， 控制台输出的日志级别是大
       于或等于此级别的日志信息-->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>debug</level>
        </filter>
        <encoder>
            <Pattern>%date [%-5p] [%thread] %logger{60} [%file : %line] %msg%n</Pattern>
            <!-- 设置字符集 -->
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <!-- 2 .. 日志输出到->文件<-  下面File表示输出的文件位置，fileNamePattern可以把之前的打包-->
    <appender name="FILE"
              class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!--<File>/home/log/stdout.log</File>-->
        <File>D:/log/stdout.log</File>
        <encoder>
            <pattern>%date [%-5p] %thread %logger{60} [%file : %line] %msg%n</pattern>
        </encoder>
        <rollingPolicy
                class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 添加.gz 历史日志会启用压缩 大大缩小日志文件所占空间 -->

            <!--<fileNamePattern>/home/log/stdout.log.%d{yyyy-MM-dd}.log</fileNamePattern>-->

            <fileNamePattern>D:/log/stdout.log.%d{yyyy-MM-dd}.log</fileNamePattern>
            <maxHistory>30</maxHistory><!-- 保留 30 天日志 -->
        </rollingPolicy>
    </appender>

    <!--  3 .. 可以全局的对日志进行打印，也可以对特定的包进行日志打印，这里就是指定特定的包进行日志打印  -->
    <logger name="com.abc.springboot.mapper" level="DEBUG" />

    <!--  4 .. 上面写了两个附加器，只有在这里引用才有效果  -->
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
<!--        <appender-ref ref="FILE"/>-->
    </root>
</configuration>

添加依赖：

<!-- 日志的依赖 -->
<!--@Slf4j 自动化日志对象-->
<dependency>
	<groupId>org.projectlombok</groupId>
	<artifactId>lombok</artifactId>
	<version>1.18.2</version>
</dependency>

在setting中Plugins中安装 lombok插件

在某个类上直接写 @Slf4j 注解

接下来就可以使用了，如下图（根据logback-spring.xml指定的等级，显示出的日志内容也不同，比如比指定等级低的等级不显示）：

3. Thymeleaf

3.40 集成Thymeleaf 040

Thymeleaf 简介：

新建工程的时候，多勾选这个选项

生成的pom文件就会多一个依赖

使用：（注意：新建的html文件，要放到resources文件夹下的templates文件夹下）

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

3.41 集成Thymeleaf，实时更新界面，不必重启 041

如果想实时更新界面，html内容以修改，前端界面也修改，而不用重启工程：
1.核心配置文件中配置：

#设置thymeleaf模板引擎的缓存，设置为false关闭，默认为true开启（为了改变页面，实时更新）
spring.thymeleaf.cache=false

#设置thymeleaf模板引擎的前/后缀 (可选项)
spring.thymeleaf.prefix=classpath:/templates/
spring.thymeleaf.suffix=.html

2.做出如下更改

3.42 Thymeleaf表达式-标准变量和选择变量表达式，042

1.标准变量表达式
语法 ：${…}
说明：标准变量表达式用于访问容器（tomcat）上下文环境中的变量，功能和 EL 中的 ${} 相同。Thymeleaf 中的变量表达式使用 ${变量名} 的方式获取 Controller 中 model 其中的数据。
举例：

2. 还有 选择变量表达式（星号表达式），但是不推荐，了解即可，如下图：

3.路径表达式
th:xxx="@{}"
例如：th:href="@{}"
对于没有参数的举例（对于绝对路径：与传统方法基本没有区别，对于相对路径：路径表达式有优点。）

对于有参数的例子：

对于RESTful风格，使用字符串拼接就行了。

对于其他应用场景下使用路径表达式，，如js,img,form等：
js,img:

form表单：

3.43 thymeleaf中的th:each循环 043

补充知识start：如果实体类写完不想写get，set等等方法，只需要在实体类前加一个@Data注解，方法如下：
1.先确保有Lombok插件

2.pom文件中添加依赖

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

3.实体类前加注解@Data

可以查看：

注意： 此时自动添加的除了get、set方法等，对于构造方法来说，只自动添加了一个无参的构造方法，可以通过以下注解，再添加有参的构造方法（自己手动添加也可以）（由于只添加有参的构造方法，无参的方法会默认被替掉而只剩下有参的构造方法，所以添加有参构造方法之后，再通过 @NoArgsConstructor 注解添加无参的构造方法）
@AllArgsConstructor
@NoArgsConstructor

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

有参无参的构造方法添加完成，如下图所示：

补充知识end
循环List:

循环Map: 基本跟List一样

循环Array: 跟List一模一样

3.44 thymeleaf中选择语句 if、unless、switch-case 044

3.45 thymeleaf中内敛表达式 044

内敛文本
先在标签上加上 th:inline=“text” ，在内部就可以使用[[${xxx}]]来使用了（缺点：没有提示）
例如：

<div th:inline="text">
    数据:[[${user}]]
</div>

内敛脚本 在js代码中使用后台传过来的值
先在script标签上加上 th:inline=“javascript”，在内部就可以使用[[${xxx}]]来使用了。

3.46 thymeleaf中字面量，字符串拼接，数学运算，表达式基本对象，表达式功能对象 044

几种字面量（文本字面量，数字字面量，boolean字面量，null字面量）:

字符串拼接:
举例：

<span th:text="'共' + ${totalRows} + '条' + ${totalPage} + '页，当前第' + ${currentPage} + '页，首页 上一页 下一页 尾页'">共120条12页，当前第1页，首页 上一页 下一页 尾页</span>

<h3>使用更优雅的方式拼接字符串：|要拼接字符串的内容|（推荐这种方式，但是这两种方式都行）</h3>

<span th:text="|共${totalRows}条${totalPage}页，当前第${currentPage}页，首页 上一页 下一页 尾页|">共120条12页，当前第1页，首页 上一页 下一页 尾页</span>

数学运算：
相关运算符：
三元运算：表达式?”正确结果”:”错误结果”
算术运算：+ , - , * , / , %
关系比较:：> , < , >= , <= ( gt , lt , ge , le )
相等判断：== , != ( eq , ne )
举例：

<h3>三元运算符</h3>
<div th:text="${sex eq 1 ? '男' : '女'}"></div>

<h3>算数运算</h3>
20+5=<span th:text="20+5"></span><br/>
20-5=<span th:text="20-5"></span><br/>
20*5=<span th:text="20*5"></span><br/>
20/5=<span th:text="20/5"></span><br/>
20/5=<span th:text="20%3"></span><br/>

<h3>关系比较</h3>
5>2为<span th:if=" 5 gt 2">真</span><br/>
5<2为<span th:unless=" 5 lt 2">假</span><br/>
1>=1为<span th:if=" 1 ge 1">真</span><br/>
1<=1为<span th:if=" 1 le 1">真</span><br/>

<h3>相等判断</h3>
<span th:if="${sex == 1}">男</span>

表达式基本对象
模板引擎提供了一组内置的对象，这些内置的对象可以直接在模板中使用，这些对象由
#号开始引用，我们比较常用的内置对象
#session:

#request:

<h3>从Session中获取值 的三种方式</h3>
<span th:text="${#session.getAttribute('data')}"></span><br/>
<span th:text="${#httpSession.getAttribute('data')}"></span><br/>
<span th:text="${session.data}"></span><br/>

<h3>#request的使用</h3>
<script type="text/javascript" th:inline="javascript">
    // 比如要拼成 http://localhost:8080/index1
    //1...获取请求路径
    //获取协议名称      http
    var scheme = [[${#request.getScheme()}]];

    //获取服务器名称    localhost
    var serverName = [[${#request.getServerName()}]];

    //获取服务器端口号  8080
    var serverPort = [[${#request.getServerPort()}]];

    //获取上下文根 
    var contextPath = [[${#request.getContextPath()}]];

    var allPath = scheme + "://" + serverName + ":" + serverPort + contextPath;
    alert("路径=" + allPath);

    
    //2...获取请求路径
    var requestURL = [[${#httpServletRequest.requestURL}]]; //请求的路径
    var queryString = [[${#httpServletRequest.queryString}]]; // 传递的参数
    
    //进行拼接
    var requestAddress = queryString == null?requestURL: requestURL+"?"+queryString;
    // alert("requestURL=" + requestURL);
    // alert("queryString=" + queryString);
    alert("请求路径=" + requestAddress)

</script>

表达式功能对象
模板引擎提供的一组功能性内置对象，可以在模板中直接使用这些对象提供的功能方法，工作中常使用的数据类型，如集合，时间，数值，可以使用 Thymeleaf 的提供的功能性对象来处理它们。
内置功能对象前都需要加#号，内置对象一般都以 s 结尾。
官方手册：链接

#dates: java.util.Date 对象的实用方法：
<span th:text="${#dates.format(curDate, 'yyyy-MM-dd HH:mm:ss')}"></span>
#calendars: 和 dates 类似, 但是 java.util.Calendar 对象；
#numbers: 格式化数字对象的实用方法；
#strings: 字符串对象的实用方法： contains, startsWith, prepending/appending 等；
#objects: 对 objects 操作的实用方法；
#bools: 对布尔值求值的实用方法；
#arrays: 数组的实用方法；
#lists: list 的实用方法，比如<span th:text="${#lists.size(datas)}"></span>
#sets: set 的实用方法；
#maps: map 的实用方法；
#aggregates: 对数组或集合创建聚合的实用方法；

举例：

4. 国际化与安全

4.1 国际化

• 1.配置、写配置文件。
  
  
  
  
  
  
• 2.然后在核心配置文件application.properties中指定国际化的配置文件位置：

# 国际化配置文件的真实位置
spring.messages.basename=i18n.login

• 3.在每个html界面中的标签修改为如下类似的形式：（th:xx=#{}）

<h1 th:text="#{login.tip}"></h1>

• 4.在html中添加转换请求
  

• 5.写一个类
  

• 6.在配置类中注入bean
  

4.2 SpringSecurity(安全)

在web开发中，安全是第一位的！之前学过过滤器，拦截器之类的。
不是功能性需求。
shiro、SpringSecurity:很像，除了类和名字不一样。

• 功能权限
• 访问权限
• 菜单权限
• …拦截器，过滤器：大量的原生代码~ 冗余

3.2.1 SpringSecurity环境搭建

• 1.导入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
    <groupId>org.thymeleaf</groupId>
    <artifactId>thymeleaf-spring5</artifactId>
</dependency>
<dependency>
    <groupId>org.thymeleaf.extras</groupId>
    <artifactId>thymeleaf-extras-java8time</artifactId>
</dependency>

• 2.写一个配置类

import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

// AOP
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    // 链式编程
    // 授权
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // 首页所有人可以访问，功能页只有对应有权限的人才能访问
        // 请求授权的规则
        http.authorizeRequests()
                .antMatchers("/").permitAll()   // 首页所有人可以访问
                .antMatchers("/level1/**").hasRole("vip1")  // level1下，VIP1权限的人可以访问，以下类推
                .antMatchers("/level2/**").hasRole("vip2");

        // 没有权限默认会到登录界面，需要开启登录的界面  默认跳到/login请求
        http.formLogin();
        // 开启注销功能  默认请求/logout文件
        http.logout();
     }

//    @Autowired
//    private DataSource dataSource;
    // 认证
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        // 在内存中读    new BCryptPasswordEncoder()是密码的加密规则
        auth.inMemoryAuthentication().passwordEncoder(new BCryptPasswordEncoder())
                .withUser("huige").password(new BCryptPasswordEncoder().encode("123456")).roles("vip1")
                .and()
                .withUser("root").password(new BCryptPasswordEncoder().encode("123456")).roles("vip1","vip2");

        // 正常应该从数据库中读
//        UserBuilder users = User.withDefaultPasswordEncoder();
//        auth.jdbcAuthentication().dataSource(dataSource).withDefaultSchema()
//                .withUser(users.username("user").password("password").roles("USER"))
//                .withUser(users.username("admin").password("password").roles("USER","ADMIN"));
    }
}

4.3 Shiro

5. Swagger

• 号称世界上最流行的Api框架
• RestFul Api 文档在线自动生成工具=>Api文档与API定义同步更新
• 直接运行，可以在线测试API接口
• 支持多种语言：（Java，php）

5.1 SpringBoot集成Swagger

• 1.新建一个SpringBoot的web项目
• 2.导入依赖

<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>2.9.2</version>
</dependency>
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.9.2</version>
</dependency>

• 3.编写一个Hello工程
• 4.写一个配置类，开启Swagger2

@Configuration
@EnableSwagger2 //开启Swagger2
public class SwaggerConfig {

}

• 5.访问 http://localhost:8080/swagger-ui.html 即可
  

5.2 配置Swagger

Swagger的bean实例Docket;

@Configuration
@EnableSwagger2 //开启Swagger2
public class SwaggerConfig {

    // 配置了swagger的Docket的Bean实例
    @Bean
    public Docket docket(){
        return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo());
    }
    //配置Swagger信息=apiInfo
    private ApiInfo apiInfo(){
        return new ApiInfo("辉哥的SwaggerAPI文档",   //标题
                "描述信息",             // 描述信息
                "1.0",                     // 版本
                "urn:tos",      // 团队信息
                new Contact("辉哥", "url", "123456@126.com"),    // 作者信息
                "Apache 2.0",
                "http://www.apache.org/licenses/LICENSE-2.0",
                new ArrayList());
    }
}

5.3 Swagger配置扫描接口及开关

Docket.select

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.bind.annotation.GetMapping;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

import java.util.ArrayList;

@Configuration
@EnableSwagger2 //开启Swagger2
public class SwaggerConfig {

    // 配置了swagger的Docket的Bean实例
    @Bean
    public Docket docket(){
        return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo())
                // 是否启动swagger,关于swagger的开关
                .enable(false)
                .select()
                //  .basePackage("com.hui.controller")   设置扫描的包
                //  .any()   扫描全部
                //  .none()  全部都不扫描
                //  .withClassAnnotation(RequestMapping.class)  扫描类上的注解,参数是一个注解的反射对象
                //  .withMethodAnnotation(GetMapping.class)  扫描方法上的注解,参数是一个注解的反射对象
                .apis(RequestHandlerSelectors.withMethodAnnotation(GetMapping.class))
                //  paths() 过滤什么路径，只扫面请求路径带有hui的请求
                .paths(PathSelectors.ant("/hui/**"))
                .build(); //工厂模式
    }
    //配置Swagger信息=apiInfo
    private ApiInfo apiInfo(){
        return new ApiInfo("辉哥的SwaggerAPI文档",   //标题
                "描述信息",             // 描述信息
                "1.0",                     // 版本
                "urn:tos",      // 团队信息
                new Contact("辉哥", "url", "123456@126.com"),    // 作者信息
                "Apache 2.0",
                "http://www.apache.org/licenses/LICENSE-2.0",
                new ArrayList());
    }
}

5.4 只希望Swagger在生产环境中使用，在发布的时候不使用

配置文件多写几个，application.properties(application-dev.properties,application-test.properties等等，在主配置文件中写上使用哪一套配置，然后在SwaggerConfig类中拿到使用的配置。判断是不是指定的配置，如果是则使用，否则不适用。

5.5 分组

使用.groupName()指定分组。

效果如图：

设置多个分组：多写几个Bean：

5.6 接口注释

• 1.实体类：
  
  效果：
  
• 2.控制层
  

效果：

• 3.在该网页可以对请求进行测试
  
  

5.7 总结:

1.我们可以通过Swagger给一些比较难理解的属性或者接口，增加注释信息。
2.接口文档实时更新。
3.可以在线测试。

6.异步任务

在需要异步执行的方法前加@Async注解，然后在SpringBoot启动类前加注解@EnableAsync就可以了。

7. 定时任务

先在SpringBoot启动类前加注解@EnableScheduling，然后在业务逻辑这里写上@Scheduled注解，并用cron表达式作为参数。

8. Dubbo+ZooKeeper

8.1 ZooKeeper安转（注册中心）

• 1.下载地址: zookeeper-3.4.14.tar.gz.(windows、linux都可以用)

• 2.下载之后，进行解压，如图所示：
  

• 3.进入bin目录下，双击服务端运行。
  

启动成功：

然后双击客户端（如下连接成功）：

注意： 如果双击服务端闪退，解决办法是先将zkServer.cmd用记事本打开，最后一行加一个pause，然后再双击运行，查看报错信息。


然后就去更改配置：（这个文件里面有客户端端口号等配置信息）

• 4.在客户端zkCli.cmd进行一些测试
  比如输入 create -e … 、get 、 ls /：
  

8.2 dubbo-admin安装

注意： dubbo-admin是一个监控管理后台（可视化界面）,查看我们注册了哪些服务，哪些服务被消费了。（也可以不要）

• 1.Dubbo-admin下载地址: Dubbo-admin.
• 2.解压完成之后
  
• 3.在项目目录下对项目进行打包dubbo-admin，命令如下

mvn clean package -Dmaven.test.skip=true

打包成功：

在dubbo-admin路径下生成jap包：

• 4.执行jap包(执行前要保证ZooKeeper运行了)
  
• 5.进行可视化访问（用户名、密码默认都是root）
  端口号是7001，可以去该项目的.properties配置文件中更改.
  
  

8.3 进行SpringBoot整合

8.3.1 新建两个SpringBoot项目

这里分别叫provider-server、consumer-server了,分别是服务提供者和服务消费者

8.3.2 编写provider-server

• 1.在service层写一个卖票的业务：

TicketService接口：

public interface TicketService {
    public String getTicket();
}

TicketService实现类：

@Component  //实用Dubbo之后，尽量不要使用@Service注解
public class TicketServiceImpl implements TicketService {
    @Override
    public String getTicket() {
        return "卖票卖票";
    }
}

• 2.在配置文件中改端口号为8081(为了和消费者区分，消费者8082)，并配置如下信息：

server.port=8081	# 这个不重要，为了让两个项目都跑起来

# 服务应用名字
dubbo.application.name=provider-server
# 注册中心地址
dubbo.registry.address=zookeeper://127.0.0.1:2181
# 哪些服务要被注册
dubbo.scan.base-packages=com.hui.service

• 3.增加依赖

<!--导入依赖：Dubbo + zookeeper-->
<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-spring-boot-starter</artifactId>
    <version>2.7.3</version>
</dependency>


<!--zkclient,用github的-->
<dependency>
    <groupId>com.github.sgroschupf</groupId>
    <artifactId>zkclient</artifactId>
    <version>0.1</version>
</dependency>

<!--日志会冲突，解决冲突-->
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-framework</artifactId>
    <version>2.12.0</version>
</dependency>
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-recipes</artifactId>
    <version>2.12.0</version>
</dependency>
<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.4.14</version>
    <exclusions>
        <exclusion>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </exclusion>
    </exclusions>
</dependency>

• 4.运行起来（保证zookeeper是运行着嘞）
  
  启动之后，可以看到dubbo-admin中多了多了一个连接：
  

8.3.3 编写consumer-server

• 1.导入依赖，类似于8.2.1中第3步。

• 2.在配置文件中改端口号为8082，还有其他配置

server.port=8082

# 消费者取拿服务需要暴漏自己的名字
dubbo.application.name=consumer-server
# 注册中心的地址
dubbo.registry.address=zookeeper://127.0.0.1:2181

• 3.写一个UserService类实现用户买票业务

import com.alibaba.dubbo.config.annotation.Reference;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    // 想拿到provider-server提供的票
    @Reference  // 方式一：引用pom坐标，方式二：也可以定义路径相同的接口名
    TicketService ticketService;

    public void buyTicket(){
        String ticket = ticketService.getTicket();
        System.out.println("在注册中心拿到"+ticket);
    }
}

• 4.编写测试类：

@SpringBootTest
class ConsumerServerApplicationTests {
    @Autowired
    UserService userService;
    @Test
    void contextLoads() {
        userService.buyTicket();
    }
}

• 5.运行成功：