Spring Boot学习笔记（未完待续……）

一、前言

1.1 SpringBoot简介

Spring Boot 是 Spring 家族中的一个全新的框架，它用来简化 Spring 应用程序的创建和开发过程，也可以说 Spring Boot 能简化我们之前采用 SpringMVC + Spring + MyBatis 框架进行开发的过程。
Spring Boot 框架对此开发过程进行了革命性的颠覆，完全抛弃了繁琐的 xml 配置过程，采用大量的默认配置简化我们的开发过程。
所以采用 Spring Boot 可以非常容易和快速地创建基于 Spring 框架的应用程序，它让编码变简单了，配置变简单了，部署变简单了，监控变简单了。正因为 Spring Boot 它化繁为简，让开发变得极其简单和快速，所以在业界备受关注。

1.2 Sping Boot特性

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

1.2 Sping Boot 四大核心

1. 自动配置
2. 起步依赖
3. Actuator
4. 命令行界面

二、Sping Boot入门

2.1 项目的创建

2.1.1 IDEA创建spring boot

如果网络不好，采用官方地址加载失败，可以选择使用阿里镜像进行创建。
阿里镜像网址：https://start.aliyun.com

2.1.2 spring boot 打包方式

spring boot默认打包方式为jar，spring boot 内置了tomcat，因此不需要部署，可以直接通过java -jar jar包名

2.1.3 spring boot 起步依赖的选择

在创建spring boot项目时可以选择起步依赖，如果是web项目可以选择Web–>Spring Web。如果还需要其他依赖，也可以直接选中进行添加

2.1.4 spring boot 目录结构

1. static：存放静态资源，如图片、CSS、JavaScript 等
2. templates：存放 Web 页面的模板文件
3. application.properties/application.yml 用于存放程序的各种依赖模块的配置信息，比如 服务端口，数据库连接配置等
4. .mvn|mvnw|mvnw.cmd：使用脚本操作执行 maven 相关命令，国内使用较少，可删除
5. .gitignore：使用版本控制工具 git 的时候，设置一些忽略提交的内容
6. Application.java：SpringBoot 程序执行的入口，执行该程序中的 main 方法，SpringBoot就启动了
   

2.1.5 创建一个 Spring MVC 的 Spring BootController

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

@Controller
public class MyController {
    @RequestMapping(value = "/test")
    @ResponseBody
    public String test() {
        return "test";
    }
}

2.2 项目的分析

2.2.1 项目的配置解释

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

<properties>
 <spring-framework.version>5.0.0.RELEASE</ spring-framework.version >
</properties>

5. @SpringBootApplication 注解是 Spring Boot 项目的核心注解，主要作用是开启Spring 自动配置，如果在 Application 类上去掉该注解，那么不会启动 SpringBoot程序
6. main 方法是一个标准的 Java 程序的 main 方法，主要作用是作为项目启动运行的入口
7. @Controller 及 @ResponseBody等注解和 Spring MVC + Spring + MyBatis 等框架含义相同

2.3 Spring Boot核心配置文件

1. .properties 文件（默认采用该文件）
2. .yml 文件或.yaml
   properties文件优先级高于yml/yaml文件

2.3.1 Spring Boot多环境配置

1. 在实际开发的过程中，我们的项目会经历很多的阶段（开发->测试->上线），每个阶段的配置也会不同，例如：端口、上下文根、数据库等，那么这个时候为了方便在不同的环境之间切换，SpringBoot 提供了多环境配置
2. 为每个环境创建一个配置文件，命名必须以 application-环境标识.properties|yml,然后在application.properties主配置文件中使用spring.profiles.active=（环境标识）激活

2.4 核心配置文件中值的读取

1.有相同前缀之使用@ConfigurationProperties注解
例如：application.properties中定义了

test.name=abc
test.websit=http://www.abc.com

java代码使用@ConfigurationProperties注解读取
使用这个注解需要添加相关依赖“

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

@Component
@ConfigurationProperties(prefix = "test")
public class Abc {

    private String name;

    private String websit;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getWebsit() {
        return websit;
    }

    public void setWebsit(String websit) {
        this.websit = websit;
    }
}

这样操作后，容器里就有了这个对象，我们就直接可以使用了，如下所示：

@Controller
public class IndexController {

    @Autowired
    private School school;

    @Autowired
    private Abc abc;

    @RequestMapping(value = "/say")
    public @ResponseBody String say() {


        return "school.name="+school.getName()+"-----school.websit="+school.getWebsit() + "====abc.name"+abc.getName()+"===abc.websit="+abc.getWebsit();
    }
}

2.没有相同前缀使用@Value注解
例如：application.properties中定义了

school.name=bjpowernode
websit=http://www.bjpowernode.com

java代码中可以通过@Value读取对应的值

@Controller
public class IndexController {

    @Value("${school.name}")
    private String schoolName;

    @Value("${websit}")
    private String websit;

    @RequestMapping(value = "/say")
    public @ResponseBody String say() {
        return "Hello:" + schoolName + ":" + websit;
    }
}

2.5 Spring Boot中使用JSP

2.5.1导入tomcat

因为Spring Boot内嵌了tomcat，但是Spring Boot 内嵌的tomcat不能解析JSP文件，因此需要导入tomcat依赖

        <!--引入SpringBoot内嵌Tomcat对jsp的解析依赖,不添加解析不了jsp-->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>

2.5.2编译jsp到指定的目录下

在Spring Booot中使用sjsp编译jsp的路径是springboot规定好的位置META-INF/resources

  <build>

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


        <plugins>
            <!--SpringBoot项目编译打包的插件-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

如果不加就会报以下的信息:

2.5.3 在主配置文件中添加视图解析器

spring.mvc.view.suffix=.jsp
spring.mvc.view.prefix=/

2.6 Spring Boot中集成Mybatis

2.6.1修改pom文件

因为要集成Mybatis,所以需要导入Mybatis的依赖

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

因为要需要连接数据库，因此也要导入MySql驱动依赖

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

因为java目录下默认不会把xml文件编译到target目录下，因此需要手动指定文件夹为resources

		<!--手动指定文件夹为resources-->
		<resources>
			<resource>
				<directory>src/main/java</directory>
				<includes>
					<include>**/*.xml</include>
				</includes>
			</resource>
		</resources>

2.6.2将Mapper接口加入到spring容器中

代码示例：

@Mapper
public interface StudentMapper {
    Student selectByPrimaryKey(Integer id);
}

或者使用另一种方法，在启动类上加@MapperScan

@SpringBootApplication
@MapperScan("com.example.mybatistest.mapper")
public class MybatistestApplication {

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

}

2.6.3 编写controller

@Controller
public class StudentController {
    @Autowired
    private StudentService studentService;

    @RequestMapping(value = "/student")
    public @ResponseBody
    Object student(Integer id) {

        Student student = studentService.queryStudentById(id);

        return student;
    }
}

2.6.4 配置核心配置文件，配置数据源等

application.properties示例：

server.port=8080
server.servlet.context-path=/mybatis
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp
#设置连接数据库的配置
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/springdb?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=123456

2.6.5 接口和映射文件存放不在同一个目录下

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

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

2.7 Spring Boot中使用事务

Spring Boot 使用事务非常简单，底层依然采用的是 Spring 本身提供的事务管理

1. 在入口类中使用注解 @EnableTransactionManagement 开启事务支持
2. 在访问数据库的 Service 方法上添加注解 @Transactional 即可
   代码示例：

@SpringBootApplication
@MapperScan(basePackages = "com.bjpowernode.springboot.mapper")
@EnableTransactionManagement    //开启事务(可选项,这个可以不写。写了更好)
public class Application {

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

}

service代码：

@Service
public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentMapper studentMapper;

    @Transactional //这个注解必须写，写了就是开启了事务
    @Override
    public int updateStudentById(Student student) {

        //修改成功
        int i = studentMapper.updateByPrimaryKeySelective(student);

        //失败
        int a = 10/0;

        return i;
    }
}

2.7 Spring Boot中MVC相关注解

2.7.1 @RestController

是 @Controller 与@ResponseBody 的组合注解
如果一个 Controller 类添加了@RestController，那么该 Controller 类下的所有方法都相当
于添加了@ResponseBody 注解,用于返回字符串或 json 数据
示例代码：

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

2.7.2 请求注解

1.通用注解：
@RequestMapping（常用）支持 Get 请求，也支持 Post 请求
2.特殊注解：
@GetMapping（RequestMapping 和 Get 请求方法的组合，只支持 Get 请求，Get 请求主要用于查询操作）
@PostMapping（RequestMapping 和 Post 请求方法的组合，只支持 Post 请求，Post 请求主要用户新增数据）
@PutMapping（RequestMapping 和 Put 请求方法的组合，只支持 Put 请求，Put 通常用于修改数据）
@DeleteMapping（RequestMapping 和 Delete 请求方法的组合，只支持 Delete 请求，通常用于删除数据）

2.8 Spring Boot 实现 RESTful

2.8.1 认识 RESTFul

REST（英文：Representational State Transfer，简称 REST）
一种互联网软件架构设计的风格，但它并不是标准，它只是提出了一组客户端和服务器，交互时的架构理念和设计原则，基于这种理念和原则设计的接口可以更简洁，更有层次，REST这个词，是 Roy Thomas Fielding 在他 2000 年的博士论文中提出的。任何的技术都可以实现这种理念，如果一个架构符合 REST 原则，就称它为 RESTFul 架 构。
比如我们要访问一个 http 接口：http://localhost:8080/boot/order?id=1021&status=1
采用 RESTFul 风格则 http 地址为：http://localhost:8080/boot/order/1021/1

2.8.2 Spring Boot中使用RESTFul

常见注解：
1.@PathVariable获取 url 中的数据该注解是实现 RESTFul 最主要的一个注解
2.@GetMapping、@PostMapping、@PutMapping、@DeleteMapping
代码示例：

@PostMapping(value = "/springBoot/student/{name}/{age}")
 public Object addStudent(@PathVariable("name") String name,
 @PathVariable("age") Integer age) {
 Map<String,Object> retMap = new HashMap<String, Object>();
 retMap.put("name",name);
 retMap.put("age",age);
 return retMap;
 }

2.8.3 Spring Boot中使用RESTFul解决产生的冲突

解决冲突的两种方式：改路径，改请求方式
该路径代码示例：

@GetMapping(value = "/springBoot/order/{id}/{status}")
//修改请求路径
@GetMapping(value = "/springBoot/{id}/order/{status}")

该请求方式示例：

@GetMapping(value = "/springBoot/{status}/order/{id}")
//修改请求方式，改为post请求
@PostMapping(value = "/springBoot/{status}/order/{id}")

2.8.4 RESTFul使用原则

1. 增 post 请求、删 delete 请求、改 put 请求、查 get 请求
2. 请求路径不要出现动词
3. 分页、排序等操作，不需要使用斜杠传参数

2.9 Spring Boot 使用Redis

2.9.1 修改pom，引入redis启动依赖

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

2.9.2 修改核心配置文件，Redis连接配置

#配置 redis 连接信息
spring.redis.host=192.168.92.134
spring.redis.port=6379
spring.redis.password=123456

2.9.3 RedisTemplate类的使用

配置了上面的步骤，Spring Boot 将自动配置 RedisTemplate，在需要操作 redis 的类中注入 redisTemplate 即可。
ps:注意：Spring Boot 帮我们注入 RedisTemplate 类，泛型里面只能写 <String, String>、<Object, Object>或者什么都不写
代码示例：

@Service
public class StudentServiceImpl implements StudentService {
 @Autowired
 private StudentMapper studentMapper;
 @Autowired
 private RedisTemplate<Object,Object> redisTemplate;
 @Override
 public Long queryAllStudentCount() {
 //设置 redisTemplate 对象 key 的序列化方式
 redisTemplate.setKeySerializer(new StringRedisSerializer());
 //从 redis 缓存中获取总人数
 Long allStudentCount = (Long) 
redisTemplate.opsForValue().get("allStudentCount");
 //判断是否为空
 if (null == allStudentCount) {
allStudentCount = studentMapper.selectAllStudentCount();
redisTemplate.opsForValue().set("allStudentCount",allStudentCount,15, 
TimeUnit.SECONDS);
 }
 return allStudentCount;
 } }

2.10 Spring Boot 使用Dubbo

搭建项目结构，创建三个项目

按照 Dubbo 官方开发建议，创建一个接口项目，该项目只定义接口和 model 类，然后创建一个服务消费项目以及一个服务提供项目

2.10.1 接口项目

①. 创建一个普通的maven工程

②. 创建实体类

③. 创建接口类

2.10.2 服务提供项目

①. 修改pom文件

导入dobbu起步依赖：

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

因为需要zookeeper 作为注册中心，需加入 zookeeper 的客户端依赖

<!--Zookeeper 客户端依赖-->
<dependency>
 <groupId>com.101tec</groupId>
 <artifactId>zkclient</artifactId>
 <version>0.10</version>
</dependency>

加入 MyBatis 和 MySQL 依

<!--MyBatis 集成 SpringBoot 框架起步依赖-->
<dependency>
 <groupId>org.mybatis.spring.boot</groupId>
 <artifactId>mybatis-spring-boot-starter</artifactId>
 <version>2.0.1</version>
</dependency>
<!--MySQL 数据库驱动-->
<dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
</dependency>

加入接口依赖

<!--Dubbo 接口工程-->
<dependency>
 <groupId>com.abc.springboot</groupId>
 <artifactId>017-springboot-dubbo-interface</artifactId>
 <version>1.0.0</version>
</dependency>

②. 修改核心配置文件

核心配置文件中 dubbo配置

#配置 dubbo 的服务提供者信息
#服务提供者应用名称(必须写，且不能重复)
spring.application.name=springboot-dubbo-provider
#设置当前工程为服务提供者
spring.dubbo.server=true
#设置注册中心
spring.dubbo.registry=zookeeper://localhost:2181

完整配置文件

#设置内嵌 Tomcat 端口号
server.port=8090
#设置上下文根
server.servlet.context-path=/ #配置数据源
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/springboot?useUnico
de=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&us
eLegacyDatetimeCode=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=123456
#配置 dubbo 的服务提供者信息
#服务提供者应用名称(必须写，且不能重复)
spring.application.name=springboot-dubbo-provider
#设置当前工程为服务提供者
spring.dubbo.server=true
#设置注册中心
spring.dubbo.registry=zookeeper://localhost:2181

③. 编写 Dubbo 的接口实现类

2.10.3 服务消费项目

待续……

2.11 Spring Boot 创建普通项目（非Web项目）

2.11.1 直接在 main 方法中，根据 SpringApplication.run()方法获取返回的 Spring 容器对象，再获取业务 bean 进行调用

代码示例：

@SpringBootApplication
public class Application2{
	@Resource
	private TestService testService;
	public static void main(String[] args) {
		ConfigurableApplicationContext run = SpringApplication.run(Application2.class, args);
		TestService bean = run.getBean(TestService.class);
		bean.test();
	}
}

2.11.2 实现CommandLineRunner接口，实现run方法

run方法会在springboot启动完后自动调用，因此可以在这个方法调用自动注入的对象，这个时候已经完成了容器的自动注入
代码示例：

@SpringBootApplication
public class Application implements CommandLineRunner{
	@Resource
	private TestService testService;
	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
	}

	@Override
	public void run(String... args) throws Exception {
		testService.test();

	}
}

2.11.3 修改启动logo

①代码关闭启动logo

@SpringBootApplication
public class Application2{
	@Resource
	private TestService testService;
	public static void main(String[] args) {
		SpringApplication springApplication = new SpringApplication(Application2.class);
		springApplication.setBannerMode(Banner.Mode.OFF);
		springApplication.run();

	}
}

②修改logo
在 src/main/resources 放入 banner.txt 文件，该文件名字不能随意，文件中的内容就是要输出
的 logo

2.12 Spring Boot 使用拦截器

2.12.1 编写拦截器类并实现HandlerInterceptor接口

preHandle
调用时间：Controller方法处理之前
postHandle
调用前提：preHandle返回true
调用时间：Controller方法处理完之后，DispatcherServlet进行视图的渲染之前，也就是说在这个方法中你可以对ModelAndView进行操作
执行顺序：链式Intercepter情况下，Intercepter按照声明的顺序倒着执行。
afterCompletion
调用前提：preHandle返回true
调用时间：DispatcherServlet进行视图的渲染之后
多用于清理资源

代码示例：

public class UserInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        Integer code = (Integer) request.getSession().getAttribute("code");
        if (null == code) {
            response.sendRedirect(request.getContextPath() + "/user/error");
            return false;
        }
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion");

    }
}

2.12.2 编写对应的配置类

@Configuration  //定义此类为配置文件(即相当于之前的xml配置文件)
public class InterceptorConfig implements WebMvcConfigurer {

    //mvc:interceptors
    @Override
    public void addInterceptors(InterceptorRegistry registry) {

        //要拦截user下的所有访问请求,必须用户登录后才可访问,
        // 但是这样拦截的路径中有一些是不需要用户登录也可访问的
        String[] addPathPatterns = {
            "/user/**"
        };

        //要排除的路径,排除的路径说明不需要用户登录也可访问
        String[] excludePathPatterns = {
            "/user/out", "/user/error","/user/login"
        };

        //mvc:interceptor bean class=""
        registry.addInterceptor(new UserInterceptor()).addPathPatterns(addPathPatterns).excludePathPatterns(excludePathPatterns);
    }
}

2.13 Spring Boot 使用Servlet

2.13.1 编写Servlet类并继承HttpServlet，并使用@WebServlet("")进行配置注解

@WebServlet("/servlet") //采用第一种方式的时候加，在启动类上加ServletComponentScan注解
public class Myservelet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().print("Hello,SpringBoot Servlet!");
        resp.getWriter().flush();
        resp.getWriter().close();
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req,resp);
    }
}

2.13.2 启用Servlet

在springboot中启用Servlet有两种方式，分别为ServletComponentScan注解或编写配置类。以下分别进行演示
①方法一：使用ServletComponentScan注解（PS:在自己编写的Servlet类上加上WebServlet注解）
在 主 应 用 程 序 Application 类 上 添 加@ServletComponentScan(“这里面填写servlet所在的路径”)
②方法二：编写配置类(PS:这种方法不需要加WebServlet注解）
代码示例：

@Configuration  //该注解将此类定义为配置类(相当一个xml配置文件)
public class ServletConfig {

    //@Bean是一个方法级别上的注解,主要用在配置类里
    //相当于一个
    // <beans>
    //      <bean id="" class="">
    // </beans>
    @Bean
    public ServletRegistrationBean myServletRegistrationBean() {
        ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new MyServlet(),"/myservlet");

        return servletRegistrationBean;
    }
}

2.14 Spring Boot 使用Filter

2.14.1 创建一个 Filer并实现Filter接口，并添加WebFilter注解（Ps:WebFilter注解只有使用第一种方式启动才需要加）

代码示例：

@WebFilter(urlPatterns = "/springboot/myFilter")
public class MyFilter implements Filter {
 @Override
 public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, 
FilterChain filterChain) throws IOException, ServletException {
 System.out.println("-------------您已进入过滤器---------------");
 filterChain.doFilter(servletRequest,servletResponse);
 } }

2.14.2 启用Filer的两种方式

①方法一：使用ServletComponentScan注解（PS:在自己编写的Filter 类上加上WebFilter注解）
在 主 应 用 程 序 Application 类 上 添 加@ServletComponentScan(“这里面填写Filter 所在的路径”)
②方法二：编写配置类(PS:这种方法不需要加WebFilter注解）
配置类代码：

@Configuration  //定义此类为配置类
public class FilterConfig {

    @Bean
    public FilterRegistrationBean myFilterRegistrationBean() {

        //注册过滤器
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new MyFilter());

        //添加过滤路径
        filterRegistrationBean.addUrlPatterns("/user/*");

        return filterRegistrationBean;
    }
}

2.15 Spring Boot 设置字符编码

spring boot设置字符编码一共有两种方式，一种为编写配置类的方式，另一种为修改application.properties文件来实现

2.15.1 编写配置类的方式

代码示例

@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;
    }
}

PS:这种方式还需要修改application.properties中关闭springboot的http字符编码支持才能生效。
PS:在 servlet 中添加 response.setContextType(“text/html;charset=utf-8”)指定浏览器编码方式

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

2.15.2 修改application.properties的方式

#设置请求响应的字符编码
spring.http.encoding.enabled=true
spring.http.encoding.force=true
spring.http.encoding.charset=UTF-8

*application.properties常见配置

1. 内嵌tomcat 端口号

server.port=8080

2. 上下文路径

server.servlet.context-path=/

3. 视图解析器

spring.mvc.view.suffix=.jsp
spring.mvc.view.prefix=/

4.Mybatis数据库连接配置

#设置连接数据库的配置
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/springdb?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=123456

5.指定Mybatis映射文件位置

#指定MyByBatis映射文件的路径，这个配置只有接口和映射文件不在同一个包的情况下，才需要指定
mybatis.mapper-locations=classpath:mapper/*.xml

6.Redis连接配置

#配置 redis 连接信息
spring.redis.host=192.168.92.134
spring.redis.port=6379
spring.redis.password=123456

7.Spring Boot 设置字符编码

#设置请求响应的字符编码
spring.http.encoding.enabled=true
spring.http.encoding.force=true
spring.http.encoding.charset=UTF-8