一、前言
1.1 SpringBoot简介
Spring Boot 是 Spring 家族中的一个全新的框架,它用来简化 Spring 应用程序的创建和开发过程,也可以说 Spring Boot 能简化我们之前采用 SpringMVC + Spring + MyBatis 框架进行开发的过程。
Spring Boot 框架对此开发过程进行了革命性的颠覆,完全抛弃了繁琐的 xml 配置过程,采用大量的默认配置简化我们的开发过程。
所以采用 Spring Boot 可以非常容易和快速地创建基于 Spring 框架的应用程序,它让编码变简单了,配置变简单了,部署变简单了,监控变简单了。正因为 Spring Boot 它化繁为简,让开发变得极其简单和快速,所以在业界备受关注。
1.2 Sping Boot特性
- 能够快速创建基于 Spring 的应用程序
- 能够直接使用 java main 方法启动内嵌的 Tomcat 服务器运行 Spring Boot 程序,不需要部署 war 包文件
- 提供约定的 starter POM 来简化 Maven 配置,让 Maven 的配置变得简单
- 自动化配置,根据项目的 Maven 依赖配置,Spring boot 自动配置 Spring、Spring mvc
- 提供了程序的健康检查等功能
- 基本可以完全不使用 XML 配置文件,采用注解配置
1.2 Sping Boot 四大核心
- 自动配置
- 起步依赖
- Actuator
- 命令行界面
二、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 目录结构
- static:存放静态资源,如图片、CSS、JavaScript 等
- templates:存放 Web 页面的模板文件
- application.properties/application.yml 用于存放程序的各种依赖模块的配置信息,比如 服务端口,数据库连接配置等
- .mvn|mvnw|mvnw.cmd:使用脚本操作执行 maven 相关命令,国内使用较少,可删除
- .gitignore:使用版本控制工具 git 的时候,设置一些忽略提交的内容
- 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 项目的配置解释
- Spring Boot 的父级依赖 spring-boot-starter-parent 配置之后,当前的项目就是 Spring Boot 项目
- spring-boot-starter-parent 是一个 Springboot 的父级依赖,开发 SpringBoot 程序都需要继承该父级项目,它用来提供相关的 Maven 默认依赖,使用它之后,常用的 jar包依赖可以省去 version 配置
- Spring Boot 提供了哪些默认 jar 包的依赖,可查看该父级依赖的 pom 文件
- 如果不想使用某个默认的依赖版本,可以通过 pom.xml 文件的属性配置覆盖各个依赖项,比如覆盖 Spring 版本
<properties>
<spring-framework.version>5.0.0.RELEASE</ spring-framework.version >
</properties>
- @SpringBootApplication 注解是 Spring Boot 项目的核心注解,主要作用是开启Spring 自动配置,如果在 Application 类上去掉该注解,那么不会启动 SpringBoot程序
- main 方法是一个标准的 Java 程序的 main 方法,主要作用是作为项目启动运行的入口
- @Controller 及 @ResponseBody等注解和 Spring MVC + Spring + MyBatis 等框架含义相同
2.3 Spring Boot核心配置文件
- .properties 文件(默认采用该文件)
- .yml 文件或.yaml
properties文件优先级高于yml/yaml文件
2.3.1 Spring Boot多环境配置
- 在实际开发的过程中,我们的项目会经历很多的阶段(开发->测试->上线),每个阶段的配置也会不同,例如:端口、上下文根、数据库等,那么这个时候为了方便在不同的环境之间切换,SpringBoot 提供了多环境配置
- 为每个环境创建一个配置文件,命名必须以 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 本身提供的事务管理
- 在入口类中使用注解 @EnableTransactionManagement 开启事务支持
- 在访问数据库的 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使用原则
- 增 post 请求、删 delete 请求、改 put 请求、查 get 请求
- 请求路径不要出现动词
- 分页、排序等操作,不需要使用斜杠传参数
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