1、概述
1.1、介绍
Spring 诞生时是 Java 企业版（Java Enterprise Edition，JEE，也称 J2EE）的轻量级代替品。无需开发重量级的 Enterprise JavaBean（EJB），Spring 为企业级Java 开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单的Java 对象（Plain Old Java Object，POJO）实现了 EJB 的功能。
1.2、配置演变过程
（1）第一阶段：xml配置
在Spring 1.x时代，使用Spring开发满眼都是xml配置的Bean，随着项目的扩大，我们需要把xml配置文件放到不同的配置文件里，那时需要频繁的在开发的类和配置文件之间进行切换
（2）第二阶段：注解配置
在Spring 2.x 时代，随着JDK1.5带来的注解支持，Spring提供了声明Bean的注解（例如@Component、@Service），大大减少了配置量。主要使用的方式是应用的基本配置（如数据库配置）用xml，业务配置用注解。
（3）第三阶段：java配置
Spring 3.0 引入了基于 Java 的配置能力，这是一种类型安全的可重构配置方式，可以代替 XML。我们目前刚好处于这个时代，Spring4.x和Spring Boot都推荐使用Java配置。
（4）第四阶段：SpringBoot
Spring Boot 简化了基于Spring的应用开发，只需要“run”就能创建一个独立的、生产级别的Spring应用。Spring Boot为Spring平台及第三方库提供开箱即用的设置（提供默认设置），这样我们就可以简单的开始。多数Spring Boot应用只需要很少的Spring配置。
- 注意事项：可以使用SpringBoot创建java应用，并使用java –jar 启动它，或者采用传统的war部署方式。
- Spring Boot 主要目标是：
- 为所有 Spring 的开发提供一个从根本上更快的入门体验
- 开箱即用，但通过自己设置参数，即可快速摆脱这种方式。
- 提供了一些大型项目中常见的非功能性特性，如内嵌服务器、安全、指标，健康检测、外部化配置等
- 绝对没有代码生成，也无需 XML 配置。
2、项目架构
2.1、项目架构搭建
- pojo包：表示一个很普通的对象，不需要实现什么接口，没有任何的逻辑，有的只是属性，和空参构造函数还有getter/setter方法，其实就是获取和设置每一个属性值的方法。
- dao层：表示数据访问层，其中包含了你对数据库的所有操作，所以只要是你有对象要对数据库进行操作，都把这些方法放在dao层里，最好先写一个抽象类（interface）来封装所有的方法。
- 新建一个impl文件夹（implement）即来实现这个抽象类
- service层：处理完数据访问层，就应该处理对应的系统业务逻辑，同理也可以先构造一个抽象类，
- 新建一个impl文件夹：实现这个抽象类里面的方法。
- controller层次：在web包下面新建controller包，所以这肯定是要和前端页面打交道的。接收用户提交请求的代码，所以该层是会调用service里面的接口来实现业务流程。
2.2、POJO文件夹 - 创建相关实体类
- 业务需求：用户查看课程章节下的视频。
// 1、定义章节实体类
public class Chapter;
// 2、定义用户实体类
public class User;
// 3、定义视频实体类
public class Video implements Serializable;2.3、DAO文件夹 - 静态数据调用接口
- 业务需求：用户登录数据和视频播放数据
// 1、模拟静态用户数据
public class UserMapper(){};
// 2、模拟静态视频数据
public class VideoMapper(){};3、GET请求实战 - 查询功能实现
- 业务需求：用户查询课程的视频列表
3.1、DAO文件夹 - 定义读取数据
public class VideoMapper {
private static Map<Integer, Video> videoMap = new HashMap<>();
static {
videoMap.put(5,new Video(5,"小滴课堂面试专题第一季，300道大厂连环问"));
}
// 定义数据接口
public List<Video> listVideo(){
List<Video> list = new ArrayList<>();
list.addAll(videoMap.values());
return list;
}
}3.2、Service文件夹 - 实现数据的业务逻辑处理
public interface VideoService {
List<Video> listVideo();
}
@Service
public class VideoServiceImpl implements VideoService {
@Autowired
private VideoMapper videoMapper;
@Override
public List<Video> listVideo() {
return videoMapper.listVideo();
}
}3.3、Controller文件夹 - 读取数据
@RestController
@RequestMapping("/api/v1/pub/video")
public class VideoController {
@Autowired
private VideoService videoService;
//@RequestMapping(value = "list",method = RequestMethod.GET)
@GetMapping("list")
public JsonData list() throws JsonProcessingException {
List<Video> list = videoService.listVideo();
return JsonData.buildSuccess(list);
}
}- 统一接口返回工具类
public class JsonData3.4、启动项目
http://localhost:8080/api/v1/pub/video/list
4、POST请求实战
- 业务场景：表单提交，用户注册登录。
4.1、Controller文件夹 - 读取数据
@RestController
@RequestMapping("api/v1/pub/user")
public class UserController {
@Autowired
public UserService userService;
/**
* 登录接口
* @param user
* @return
*/
@PostMapping("login")
public JsonData login(@RequestBody User user){
System.out.println("user=" + user.toString());
String token = userService.login(user.getUsername(), user.getPwd());
return token !=null ? JsonData.buildSuccess(token) : JsonData.buildError("账号密码错误");
}
}4.2、Service文件夹 - 实现数据的业务逻辑处理
public interface UserService {
String login(String username, String pwd);
List<User> listUser();
}
// 定义用户注册登录逻辑
@Service
public class UserServiceImpl implements UserService {
private static Map<String, User> sessionMap = new HashMap<>();
@Autowired
private UserMapper userMapper;
@Override
public String login(String username, String pwd) {
User user = userMapper.login(username,pwd);
if(user==null){
return null;
}else {
String token = UUID.randomUUID().toString();
System.out.println(token);
sessionMap.put(token,user);
return token;
}
}
@Override
public List<User> listUser() {
return userMapper.listUser();
}
}4.3、DAO文件夹 - 定义读取用户数据接口
@Repository
public class UserMapper {
private static Map<String , User> userMap = new HashMap<>();
static {
userMap.put("jack",new User(1,"jack","123"));
userMap.put("xdclass-lw",new User(2,"xdclass-lw","123456"));
userMap.put("tom",new User(3,"tom","123456789"));
}
// 比对用户名是否存在 & 用户密码是否正确
public User login(String username, String pwd){
User user = userMap.get(username);
if(user == null){
return null;
}
if(user.getPwd().equals(pwd)){
return user;
}
return null;
}
public List<User> listUser(){
List<User> list = new ArrayList<>();
list.addAll(userMap.values());
return list;
}
}4.4、启动项目查询结果
（1）POST注册用户
http://localhost:8080/api/v1/pub/user/login
（2）SET查询用户
http://localhost:8080/api/v1/pub/user/list
4.5、POST的数组提交
- 业务需求：新增视频json对象，章数组提交。
- 业务场景：json对象映射，数组对象提交接口开发。
@RestController
@RequestMapping("/api/v1/pub/video")
public class VideoController {
......
@PostMapping("save_video_chapter")
public JsonData saveVideoChapter(@RequestBody Video video){
System.out.println(video.toString());
return JsonData.buildSuccess(video);
}
}- 调试运行
http://localhost:8080/api/v1/pub/video/save_video_chapter
5、SpringBoot定制JSON字段
5.1、JavaBean序列化为json常见框架
（1）性能：Jackson > FastJson > Gson > Json-lib 同个结构
（2）特点：空间换时间，时间换空间
5.2、jsckjson处理相关自动
（1）指定字段不返回：@JsonIgnore
（2）指定⽇期格式：@JsonFormat(pattern=“yyyy-MM-dd hh:mm:ss”,locale=“zh”,timezone=“GMT+8”)
（3）空字段不返回：@JsonInclude(Include.NON_NULL)
（4）指定别名：@JsonPropert
5.3、实战案例
（1）业务实现：过滤⽤户敏感信息。
@RestController
@RequestMapping("api/v1/pub/user")
public class UserController {
......
/**
* 列出全部用户
* @return
*/
@GetMapping("list")
public JsonData listUser(){
return JsonData.buildSuccess(userService.listUser());
}
}
// 过滤密码字段，即不返回密码
public class User {
......
@JsonIgnore
private String pwd;
}（2）业务需求：视频创建时间返回⾃定义格式；
// 指定返回时间格式
public class Video implements Serializable {
......
@JsonProperty("create_time")
@JsonFormat(pattern="yyyy-MM-dd hh:mm:ss",locale="zh",timezone="GMT+8")
private Date createTime;
}（3）业务需求：空字段不返回
// 指定返回时间格式
public class Video implements Serializable {
......
@JsonInclude(JsonInclude.Include.NON_NULL)
private List<Chapter> chapterList;
}6、SpringBoot中的配置文件
6.1、SpringBoot的配置文件形式
（1）常⻅的配置⽂件格式
xml、properties、json、yaml（2）Springboot⾥⾯常⽤xx.yml
- YAML（Yet Another Markup Language）
- 写 YAML 要⽐写 XML 快得多(⽆需关注标签或引号) 使⽤空格 Space 缩进表示分层，不同层次 之间的缩进可以使⽤不同的空格数⽬
- 注意：key后⾯的冒号，后⾯⼀定要跟⼀个空格,树状结构 xml、properties、json、yaml
server:
port: 8080 //设置启动端⼝号为8080
house:
family:
name: Doe
parents:
- John
- Jane
children:
- Paul
- Mark
- Simone
address:
number: 34
street: Main Street
city: Nowheretown
zipcode: 12345（3）Springboot⾥⾯常⽤ xx.properties（推荐）
- Key=Value格式
- 语法简单，不容易出错
server.port=8082
#session失效时间，30m表示30分钟
server.servlet.session.timeout=30m
# Maximum number of connections that the server accepts and processes at
any given time.
server.tomcat.max-connections=10000
# Maximum size of the HTTP post content.
server.tomcat.max-http-post-size=2MB
server.tomcat.max-http-form-post-size=2MB
# Maximum amount of worker threads
server.tomcat.max-threads=2006.2、SpringBoot注解配置⽂件映射属性和实体类实战
配置⽂件加载
（1）⽅式⼀
- ①Controller上⾯配置 @PropertySource({“classpath:resource.properties”})
- ②增加属性 @Value(“${test.name}”) private String name;
（2）⽅式⼆：实体类配置⽂件
- ①添加 @Component 注解；
- ②使⽤ @PropertySource 注解指定配置⽂件位置；
- ③使⽤ @ConfigurationProperties 注解，设置相关属性；
- ④必须 通过注⼊IOC对象Resource 进来 ， 才能在类中使⽤获取的配置⽂件值。
- @Autowired private ServerSettings serverSettings;
6.3、properties文件配置实战案例
- properties文件
#微信支付的appid
wxpaay.appid=w18434343
#支付密钥
wxpay.sercret=dasjdkj1k
#微信支付商户号
wx.mechid=128138- 配置文件注入
@RestController
@RequestMapping("api/v1/test")
@PropertySource({"classpath:pay.properties"})
public class TestController {
@Value("${wxpaay.appid}")
private String payAppid;
@Value("${wxpaay.appid}")
private String paySecret;
@GetMapping("get_conf")
public JsonData testConfig(){
Map<String,String> map = new HashMap<>();
map.put("payappid",payAppid);
map.put("paysecret",paySecret);
return JsonData.buildSuccess(map);
}
}- 运行结果
http://localhost:8080/api/v1/test/get_conf
7、单元测试
- 单元测试：完成最小的软件设计单元验证工作，目标是确保模块被正确编码。
7.1、单元测试概述
（1）单元测试依赖
<!--springboot程序测试依赖，如果是⾃动创建项⽬默认添加-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency（2）单元测试相关注解
序号 | 注解 | 概述 |
1 | @Runwith(SpringRunner.class) | 底层用junit |
2 | @SpringBootTest(Class=入口类) | 启动整个SpringBoot工程 |
3 | before | |
4 | test | |
5 | after | |
6 | TestCase.assertXXX | 断言，判断程序结果是否符合预期 |
7.2、入门案例
- 含义：选中测试类执行哪个测试类，选中所有测试类，则会先后执行。
@RunWith(SpringRunner.class)
@SpringBootTest(classes={HeimaApplication.class})
class HeimaApplicationTests {
@Before
void testOne() {
System.out.println("测试Before");
}
@Test
void testTwo() {
System.out.println("测试Two");
}
@Test
void testThree() {
System.out.println("测试Three");
}
@After
void testFour() {
System.out.println("测试After");
}
}- 验证结果
7.3、实战案例之调用Controller-Service层接口
（1）Controller层接口单元测试
@RunWith(SpringRunner.class) //底层用junit SpringJUnit4ClassRunner
@SpringBootTest(classes={DemoProjectApplication.class})//启动整个springboot工程
public class UserTest {
@Autowired
private UserController userController;
@Test
public void loginTest(){
User user = new User();
user.setUsername("jack");
user.setPwd("1234");
JsonData jsonData = userController.login(user);
System.out.println(jsonData.toString());
// 断言:判断Code状态码是否为1
TestCase.assertEquals(0,jsonData.getCode());
}
}- 验证结果
（2）Service层接口测试
@RunWith(SpringRunner.class) //底层用junit SpringJUnit4ClassRunner
@SpringBootTest(classes={DemoProjectApplication.class})//启动整个springboot工程
public class VideoTest {
@Autowired
private VideoService videoService;
@Before
public void testOne(){
System.out.println("这个是测试 before");
}
@Test
public void testVideoList(){
List<Video> videoList = videoService.listVideo();
TestCase.assertTrue(videoList.size()>0);
}
}- 验证结果
8、SpringBoot全局异常处理
- 本质：在SpringBoot自带异常上进行封装返回JSON数据/页面使用户可读异常
8.1、全局异常处理概述
（1）引入案例
- Contoller异常逻辑
@RestController
@RequestMapping("api/v1/test")
@PropertySource({"classpath:pay.properties"})
public class TestController {
@GetMapping("list")
public JsonData testExt(){
int i = 1/0;
return JsonData.buildSuccess("");
}
}- 测试结果
- 说明事项：
（2）全局异常介绍
- 配置全局异常应用场景：1/0、空指针等
- 配置好处：统一的错误页面或错误码、对用户更友好
（3）配置方式
- 第一步：类添加注解
- 返回异常页面：@ControllerAdvice，如果需要返回json数据，则⽅法需要加@ResponseBody
- 返回异常JSON数据：@RestControllerAdvice, 默认返回json数据，⽅法不需要加@ResponseBody
- 第二步：方法添加处理器
- 捕获全局异常,处理所有不可知的异常，@ExceptionHandler(value=Exception.class)
8.2、全局异常处理 - 返回JSON数据
①添加自定义异常处理器
/**
* 标记这个是一个异常处理类
*/
@RestControllerAdvice
public class CustomExtHandler {
@ExceptionHandler(value = Exception.class)
JsonData handlerException(Exception e, HttpServletRequest request){
return JsonData.buildError("服务端出问题了", -2);
}
}②Contoller异常逻辑
@RestController
@RequestMapping("api/v1/test")
@PropertySource({"classpath:pay.properties"})
public class TestController {
@GetMapping("list")
public JsonData testExt(){
int i = 1/0;
return JsonData.buildSuccess("");
}
}③测试结果
8.2、全局异常处理 - 返回页面
（1）概述
- 返回自定义异常界面，需要引入thymeleaf依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>（2）实战案例
①自定义异常处理类
/**
* 标记这个是一个异常处理类
*/
//@RestControllerAdvice
@ControllerAdvice
public class CustomExtHandler {
@ExceptionHandler(value = Exception.class)
Object handlerException(Exception e, HttpServletRequest request){
ModelAndView modelAndView = new ModelAndView();
modelAndView.setViewName("error.html");
System.out.println(e.getMessage());
modelAndView.addObject("msg",e.getMessage());
return modelAndView;
}
}②自定义html.xml文件
<!DOCTYPE html>
<html xmlns:th="http://www/thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
欢迎学习 这个是自定义异常界面
<p th:text="${msg}"> </p>
</body>
</html>③测试结果
9、SpringBoot过滤器和拦截器
- 本质：拦截器和过滤器都是AOP思想体现，都可以实现权限检查、日志记录
context-param （由外到内）
-->listener（监听器）
-->filter（过滤器）
-->Servlet
-->interceptor(拦截器)
-->Controller(控制器)8.1、过滤器介绍
过滤器是在**web应用启动的时候初始化一次**, 在web应用停止的时候销毁，可以**对请求的URL进行过滤,** **对敏感词过滤**，挡在拦截器的外层- 执行顺序
- ①用户/服务器请求/返回servlet或者html会先经过Filter
- ②执行Filter过滤代码，进行终端或者放行浏览器
- 应用场景
- 浏览器对服务器的请求：先经过过滤器，再到达服务器。
- 服务器对浏览器的响应：先经过过滤器，最后响应给浏览器。
8.2、过滤器实战
- 创建自定义过滤器方式：使⽤Servlet3.0的注解进⾏配置步骤如下
第一步：启动类⾥⾯增加 @ServletComponentScan，进⾏扫描
第二步：新建⼀个Filter类，继承Filter并实现相关方法，并实现对应的接⼝
第三步：@WebFilter 标记⼀个类为filter，被spring进⾏扫描
- urlPatterns：拦截规则，⽀持正则
- 处理逻辑：控制chain.doFilter的⽅法的调⽤，来实现是否通过放⾏ ，不放⾏，web应⽤resp.sendRedirect(“/index.html”) 或者 返回json字符串
- 实战案例
①启动类⾥⾯增加 @ServletComponentScan
@SpringBootApplication
@ServletComponentScan
public class DemoProjectApplication {
public static void main(String[] args) {
SpringApplication.run(DemoProjectApplication.class, args);
}
}②新建所需要拦截URL，即对应Controller类
@RestController
@RequestMapping("api/v1/pri/order")
public class VideoOrderController {
@RequestMapping("save")
public JsonData saveOrder(){
return JsonData.buildSuccess("下单成功");
}
}③新建Filter类，拦截对应的URL
@WebFilter(urlPatterns = "/api/v1/pri/*", filterName = "loginFilter")
public class LoginFilter implements Filter {
/**
* 容器加载的时候
* @param filterConfig
* @throws ServletException
*/
@Override
public void init(FilterConfig filterConfig) throws ServletException {
System.out.println("init LoginFilter======");
}
// 过滤处理逻辑;
/**
* 容器销毁的时候
*/
@Override
public void destroy() {
System.out.println("destroy LoginFilter======");
}
}- 测试结果：无结果显示
- IDEA响应结果
8.3、拦截器介绍
Interceptor 在AOP（Aspect-Oriented Programming）中用于在某个方法或字段被访问之前，进行拦截然后在之前或之后加入某些操作。比如日志，安全等。一般拦截器方法都是通过动态代理的方式实现。可以通过它来进行权限验证，或者判断用户是否登陆，或者是像12306 判断当前时间是否是购票时间。
- 拦截器执行流程：在 preHandle 中如果返回 false，那么后续的流程将不被执行，这可能也是拦截器命名的由来。
8.4、拦截器实战
（1）第一步：定义拦截器配置类实现WebMvcConfigurer类
（2）第二步：自定义拦截器：HandlerInterceptor
①preHandle：调用Controller某个方法之前
②postHandle：Controller之后调用，视图渲染之前，如果控制器Controller出现了异常，则不会执行此方法
③afterCompletion：不管有没有异常，这个afterCompletion都会被调用，用于资源清理。
（3）第三步：将自定义拦截器配置到拦截器配置类中。
- 实战案例
①拦截器配置类：用于注册拦截器
/**
* 拦截器配置类
*/
@Configuration
class CustomWebMvcConfigurer implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
}
}②自定义拦截器
class LoginIntercepter implements HandlerInterceptor {
private static final ObjectMapper objectMapper = new ObjectMapper();
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("LoginIntercepter preHandle =====");
String token = request.getHeader("token");
if(StringUtils.isEmpty(token)){
token = request.getParameter("token");
}
if(!StringUtils.isEmpty(token)){
//判断token是否合法
User user = UserServiceImpl.sessionMap.get(token);
if(user!=null){
return true;
}else {
JsonData jsonData = JsonData.buildError("登录失败，token无效",-2);
String jsonStr = objectMapper.writeValueAsString(jsonData);
renderJson(response,jsonStr);
return false;
}
}else {
JsonData jsonData = JsonData.buildError("未登录",-3);
String jsonStr = objectMapper.writeValueAsString(jsonData);
renderJson(response,jsonStr);
return false;
}
//return HandlerInterceptor.super.preHandle(request,response,handler);
}
private void renderJson(HttpServletResponse response,String json){
response.setContentType("application/json");
response.setCharacterEncoding("UTF-8");
try(PrintWriter writer = response.getWriter()){
writer.print(json);
}catch (Exception e){
e.printStackTrace();
}
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("LoginIntercepter postHandle =====");
HandlerInterceptor.super.postHandle(request,response,handler,modelAndView);
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("LoginIntercepter afterCompletion =====");
HandlerInterceptor.super.afterCompletion(request,response,handler,ex);
}
}③在拦截器配置类中添加拦截器
/**
* 拦截器配置类
*/
@Configuration
class CustomWebMvcConfigurer implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(getLoginInterceptor()).addPathPatterns("/api/v1/pri/**");
registry.addInterceptor(new TwoIntercepter()).addPathPatterns("/api/v1/pri/**");
WebMvcConfigurer.super.addInterceptors(registry);
}
@Bean
public LoginIntercepter getLoginInterceptor(){
return new LoginIntercepter();
}
}- 验证结果
8.5、过滤器和拦截器区别
- 主要区别：
过滤器 | 拦截器 | |
关注点 | web请求 | Action（部分web请求） |
实现方式 | 函数回调 | 动态代理 |
级别 | 系统级 | 非系统级 |
深度 | Servlet前后 | 方法前后 |
（1）触发时机
- 过滤器：只能在请求的前后使用
- 拦截器：可以详细到每个方法。
（2）实现原理
- 过滤器：回调函数实现，通过Servlet容器回调完成
- 拦截器：基于反射实现，通过动态代理完成
（3）生命周期
- 过滤器：由Servlet容器管理
- 拦截器：由IOC容器来管理
（4）应用场景
- 过滤器：可以拿到原始的http请求，但是拿不到你请求的控制器和请求控制器中的方法的信息，筛选出request中的部分
- 登录验证：判断用户是否登录。
- 权限验证：判断用户是否有权限访问资源，如校验token
- 日志记录：记录请求操作日志（用户ip，访问时间等），以便统计请求访问量。
- 性能监控：监控请求处理时长等
- 拦截器：可以拿到你请求的控制器和方法，却拿不到请求方法的参数。，主要用于安全方面，比如终止一些流程
- （1）过滤敏感词汇（防止sql注入）
- （2）设置字符编码
- （3）URL级别的权限访问控制
- （4）压缩响应信息
10、SpringBoot整合模板引擎thymeleaf和Fk
10.1、Starter & 模板引擎介绍
（1）Starter介绍
starter主要简化依赖⽤的，spring-boot-starter-web->⾥⾯包含多种依赖 查看 pom⽂件 spring-boot-starter-parent -> spring-boot-dependencies ⾥⾯综合的 很多依赖包
（2）常见模板引擎
①JSP（后端渲染，消耗性能）
Java Server Pages 动态⽹⻚技术，由应⽤服务器中的JSP引擎来编译和执⾏，再将⽣成的整个页面返回给客户端，不再使用。
②Freemarker
FreeMarker Template Language（FTL） ⽂件⼀般保存为 xxx.ftl，严格依赖MVC模式，不依赖Servlet容器（不占⽤JVM内存）。
③Thymeleaf (主推)
轻量级的模板引擎（复杂逻辑业务的不推荐，解析DOM或者XML会占⽤多的内存） ，可以直接在浏览器中打开且正确显示模板⻚⾯ 直接是html结尾，直接编辑xdlcass.net/user/userinfo.html。
10.2、Springboot引入Freemarker模板引擎
（1）pom文件添加依赖
<!-- 引⼊freemarker模板引擎的依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-freemarker</artifactId>
</dependency>（2）application文件中配置Freemarker
# 是否开启thymeleaf缓存,本地为false，⽣产建议为true
spring.freemarker.cache=false
spring.freemarker.charset=UTF-8
spring.freemarker.allow-request-override=false
spring.freemarker.check-template-location=true
#类型
spring.freemarker.content-type=text/html
spring.freemarker.expose-request-attributes=true
spring.freemarker.expose-session-attributes=true
#⽂件后缀
spring.freemarker.suffix=.ftl
#路径
spring.freemarker.template-loader-path=classpath:/templates/（3）建立文件夹
1)src/main/resources/templates/fm/user/
2)建⽴⼀个index.ftl
3)user⽂件夹下⾯建⽴⼀个user.html
- HTML文件内容如下
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
这是freemaker整合index.html页面
<h1>payAppid ${setting.payAppid}</h1>
<h1>paySecret ${setting.paySecret}</h1>
</body>
</html>（4）创建调用测试类
@Controller
@RequestMapping("freemaker")
class FreemakerController {
@Autowired
private WXConfig wxConfig;
@GetMapping("test")
public String index(ModelMap modelMap){
modelMap.addAttribute("setting",wxConfig);
//不用加后缀，因为配置文件里面已经指定了后缀
return "user/fm/index";
}
}- 测试结果
10.3、Springboot引入Thymeleaf模板引擎
（1）官网地址
https://www.thymeleaf.org/doc/articles/thymeleaf3migration.html（2）pom文件添加thymeleaf依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>（3）application文件添加thymeleaf配置
#开发时关闭缓存,不然没法看到实时⻚⾯
spring.thymeleaf.cache=false
spring.thymeleaf.mode=HTML5
#前缀
spring.thymeleaf.prefix=classpath:/templates/
#编码
spring.thymeleaf.encoding=UTF-8
#类型
spring.thymeleaf.content-type=text/html
#名称的后缀
spring.thymeleaf.suffix=.html（4）建立文件夹
1)src/main/resources/templates/tl/
2)建⽴⼀个index.html
（5）创建调用测试类
@Controller
@RequestMapping("tpl")
class TemplateController {
@Autowired
private WXConfig wxConfig;
@GetMapping("thymeleaf")
public String index2(ModelMap modelMap){
modelMap.addAttribute("setting",wxConfig);
//不用加后缀，因为配置文件里面已经指定了后缀
return "tl/index";
}
}- 测试结果
11、SpringBoot使用slf4j进行日志管理
11.1、slf4j介绍
只需要按统一的方式写记录日志的代码，而无需关心日志是通过哪个日志系统，以什么风格输出的。因为它们取决于部署项目时绑定的日志系统。例如，在项目中使用了 slf4j 记录日志，并且绑定了 log4j（即导入相应的依赖），则日志会以 log4j 的风格输出；后期需要改为以 logback 的风格输出日志，只需要将 log4j 替换成 logback 即可，不用修改项目中的代码。这对于第三方组件的引入的不同日志系统来说几乎零学习成本，况且它的优点不仅仅这一个而已，还有简洁的占位符的使用和日志级别的判断
- 使用方式：直接使用 LoggerFactory 创建即可
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class Test {
private static final Logger logger = LoggerFactory.getLogger(Test.class);
// ……
}11.2、 application.yml 中对日志的配置
logging:
config: logback.xml
level:
com.itcodai.course03.dao: trace（1）logging.config 是用来指定项目启动的时候，读取哪个配置文件，这里指定的是日志配置文件是根路径下的 logback.xml 文件，关于日志的相关配置信息，都放在 logback.xml 文件中了。
（2）logging.level 是用来指定具体的 mapper 中日志的输出级别，上面的配置表示 com.itcodai.course03.dao 包下的所有 mapper 日志输出级别为 trace，会将操作数据库的 sql 打印出来，开发时设置成 trace 方便定位问题，在生产环境上，将这个日志级别再设置成 error 级别即可。
常用的日志级别按照从高到低依次为：ERROR、WARN、INFO、DEBUG。11.3、logback.xml配置文件解析
（1）定义日志输出格式和存储路径
<configuration>
<property name="LOG_PATTERN" value="%date{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n" />
<property name="FILE_PATH" value="D:/logs/course03/demo.%d{yyyy-MM-dd}.%i.log" />
</configuration>- 首先定义一个格式，**命名为 “LOG_PATTERN”，**该格式中 %date 表示日期，%thread 表示线程名，%-5level 表示级别从左显示5个字符宽度，%logger{36} 表示 logger 名字最长36个字符，%msg 表示日志消息，%n 是换行符。
- 然后再定义一下名为 “FILE_PATH” 文件路径，日志都会存储在该路径下。%i 表示第 i 个文件，当日志文件达到指定大小时，会将日志生成到新的文件里，这里的 i 就是文件索引，日志文件允许的大小可以设置，下面会讲解。这里需要注意的是，不管是 windows 系统还是 Linux 系统，日志存储的路径必须要是绝对路径。
（2）定义控制台输出
<configuration>
<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<!-- 按照上面配置的LOG_PATTERN来打印日志 -->
<pattern>${LOG_PATTERN}</pattern>
</encoder>
</appender>
</configuration>- 使用节点设置个控制台输出（
class="ch.qos.logback.core.ConsoleAppender"）的配置，定义为 “CONSOLE”。使用上面定义好的输出格式（LOG_PATTERN）来输出，使用${}引用进来即可。
（3）定义日志文件相关参数
<configuration>
<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!-- 按照上面配置的FILE_PATH路径来保存日志 -->
<fileNamePattern>${FILE_PATH}</fileNamePattern>
<!-- 日志保存15天 -->
<maxHistory>15</maxHistory>
<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
<!-- 单个日志文件的最大，超过则新建日志文件存储 -->
<maxFileSize>10MB</maxFileSize>
</timeBasedFileNamingAndTriggeringPolicy>
</rollingPolicy>
<encoder>
<!-- 按照上面配置的LOG_PATTERN来打印日志 -->
<pattern>${LOG_PATTERN}</pattern>
</encoder>
</appender>
</configuration>- 使用 定义一个名为 “FILE” 的文件配置，主要是配置日志文件保存的时间、单个日志文件存储的大小、以及文件保存的路径和日志的输出格式。
（4）定义日志输出级别
<configuration>
<logger name="com.itcodai.course03" level="INFO" />
<root level="INFO">
<appender-ref ref="CONSOLE" />
<appender-ref ref="FILE" />
</root>
</configuration>- 使用 来定义一下项目中默认的日志输出级别，这里定义级别为 INFO，然后针对 INFO 级别的日志，使用 引用上面定义好的控制台日志输出和日志文件的参数。这样 logback.xml 文件中的配置就设置完了。
12、SpringBoot的定时任务和异步任务
12.1、定时任务
- 定时任务场景：定时消息提醒、订单通知
（1）相关注解
序号 | 注解 | 备注 |
1 | @EnableScheduling | 作用在启动类上，开启基于注解的定时任务 |
2 | @Component | 表示该类被容器扫描 |
3 | @Scheduled | 作用在方法上，表示该方法为定时方法 |
（2）入门案例
- 定时任务
@Component
public class ScheduledServiceImpl {
@Scheduled(fixedRate = 2000) // 每 4 秒执行一次
public void hello(){
System.out.println("hello ... ");
}
}- 启动类开启定时任务
@SpringBootApplication(scanBasePackages = "com.springboot.heima")
@EnableScheduling // 启动定时任务
public class HeimaApplication {
public static void main(String[] args) {
SpringApplication.run(HeimaApplication.class, args);
}
}- 验证结果
（3）多种定时表达式
序号 | 任务表达式 | 备注 |
1 | cron=“*/1 * * * * *” | 定时任务表达式 |
2 | fixedRate | 定时多久执⾏⼀次（上⼀次开始执⾏时间点后xx秒再次执⾏） |
3 | fixedDelay | 上⼀次执⾏结束时间点后xx秒再次执⾏ |
- 在线cron表达式生成器：https://cron.qqe2.com/
每隔5秒执行一次:*/5 * * * * ?
每隔1分钟执行一次:0 */1 * * * ?
每天23点执行一次:0 0 23 * * ?
每天凌晨1点执行一次:0 0 1 * * ?
每月1号凌晨1点执行一次:0 0 1 1 * ?
每月最后一天23点执行一次:0 0 23 L * ?
每周星期天凌晨1点实行一次:0 0 1 ? * L
在26分、29分、33分执行一次:0 26,29,33 * * * ?
每天的0点、13点、18点、21点都执行一次:0 0 0,13,18,21 * * ?12.2、异步任务
- 异步任务场景：处理Log、发送邮件短信等
（1）相关注解
序号 | 注解 | 备注 |
1 | @EnableAsync | 作用在启动类上，开启基于注解的异步任务 |
2 | @Component | 表示该类被容器扫描 |
3 | @Async | 作用在方法上，说明该方法是异步方法；作用在类上，表示该类的所有方法都是异步方法 |
（2）入门案例
- 异步任务定义
@Component
public class AsyncServiceImpl {
@Async
public Future<String> execTaskA() throws InterruptedException {
System.out.println("TaskA开始");
long star = new Date().getTime();
Thread.sleep(5000);
long end = new Date().getTime();
System.out.println("TaskA结束，耗时毫秒数：" + (end - star));
return new AsyncResult<>("TaskA结束");
}
@Async
public Future<String> execTaskB() throws InterruptedException {
System.out.println("TaskB开始");
long star = new Date().getTime();
Thread.sleep(3000);
long end = new Date().getTime();
System.out.println("TaskB结束，耗时毫秒数：" + (end - star));
return new AsyncResult<>("TaskB结束");
}
@Async
public Future<String> execTaskC() throws InterruptedException {
System.out.println("TaskC开始");
long star = new Date().getTime();
Thread.sleep(4000);
long end = new Date().getTime();
System.out.println("TaskC结束，耗时毫秒数：" + (end - star));
return new AsyncResult<>("TaskC结束");
}
}- 启动类添加异步注解
@SpringBootApplication(scanBasePackages = "com.springboot.heima")
@EnableScheduling // 启动定时任务
@EnableAsync // 启动异步任务
public class HeimaApplication {
public static void main(String[] args) {
SpringApplication.run(HeimaApplication.class, args);
}
}- 进行异步测试
@RunWith(SpringRunner.class)
@SpringBootTest(classes={HeimaApplication.class})
class AsyncTaskApplicationTests {
// 重点：异步任务封装到类⾥⾯，不能直接写到Controller
@Autowired
AsyncServiceImpl asyncTask;
@Test
public void testAsyncTask() throws InterruptedException {
long star = new Date().getTime();
System.out.println("任务开始，当前时间" +star );
Future<String> taskA = asyncTask.execTaskA();
Future<String> taskB = asyncTask.execTaskB();
Future<String> taskC = asyncTask.execTaskC();
//间隔一秒轮询 直到 A B C 全部完成
while (true) {
if (taskA.isDone() && taskB.isDone() && taskC.isDone()) {
break;
}
Thread.sleep(1000);
}
long end = new Date().getTime();
System.out.println("任务结束，当前时间" + end);
System.out.println("总耗时："+(end-star));
}
}- 验证结果
（3）注意事项
- 要把异步任务封装到类⾥⾯，不能直接写到Controller
- 增加Future 返回结果 AsyncResult(“task执⾏完成”)
- 如果需要拿到结果 需要判断全部的 task.isDone()
12.3、异步任务 & 自定义线程池
- 业务场景：为异步任务规划自定义线程池
（1）默认线程池
- 线程池作用：
- ①防止资源占用无限的扩张
- ②调用过程省去资源的创建和销毁所占用的时间
在springboot配置文件中加入上面的配置，即可实现ThreadPoolTaskExecutor 线程池，如果没有配置线程池的话，springboot会自动配置一个ThreadPoolTaskExecutor 线程池到bean当中。
# 核心线程数
spring.task.execution.pool.core-size=8
# 最大线程数
spring.task.execution.pool.max-size=16
# 空闲线程存活时间
spring.task.execution.pool.keep-alive=60s
# 是否允许核心线程超时
spring.task.execution.pool.allow-core-thread-timeout=true
# 线程队列数量
spring.task.execution.pool.queue-capacity=100
# 线程关闭等待
spring.task.execution.shutdown.await-termination=false
spring.task.execution.shutdown.await-termination-period=
# 线程名称前缀
spring.task.execution.thread-name-prefix=task-（2）自定义线程池
- 业务场景：我们希望将系统内的一类任务放到一个线程池，另一类任务放到另外一个线程池，所以使用Spring Boot自带的任务线程池就捉襟见肘了。
// 创建一个线程池配置类TaskConfiguration,并配置一个任务线程池对象taskExecutor
@Configuration
public class TaskConfiguration {
@Bean("taskExecutor")
public Executor taskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(10);
executor.setMaxPoolSize(20);
executor.setQueueCapacity(200);
executor.setKeepAliveSeconds(60);
executor.setThreadNamePrefix("taskExecutor-");
executor.setRejectedExecutionHandler(new CallerRunsPolicy());
return executor;
}
}
（3）实战案例 - 使用自定义线程池改造上个案例
- 自定义线程池
@Configuration
public class TaskConfiguration {
@Bean("taskExecutor")
public Executor taskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(10);
executor.setMaxPoolSize(20);
executor.setQueueCapacity(200);
executor.setKeepAliveSeconds(60);
executor.setThreadNamePrefix("taskExecutor-");
executor.setRejectedExecutionHandler(new CallerRunsPolicy());
return executor;
}
}- 使用自定义线程进行异步任务
@Component
public class AsyncServiceImpl {
@Async("taskExecutor")
public Future<String> execTaskA() throws InterruptedException {
System.out.println("TaskA开始");
long star = new Date().getTime();
Thread.sleep(5000);
long end = new Date().getTime();
System.out.println("TaskA结束，耗时毫秒数：" + (end - star) + Thread.currentThread().getName());
return new AsyncResult<>("TaskA结束");
}
@Async("taskExecutor")
public Future<String> execTaskB() throws InterruptedException {
System.out.println("TaskB开始");
long star = new Date().getTime();
Thread.sleep(3000);
long end = new Date().getTime();
System.out.println("TaskB结束，耗时毫秒数：" + (end - star) + Thread.currentThread().getName());
return new AsyncResult<>("TaskB结束");
}
@Async("taskExecutor")
public Future<String> execTaskC() throws InterruptedException {
System.out.println("TaskC开始");
long star = new Date().getTime();
Thread.sleep(4000);
long end = new Date().getTime();
System.out.println("TaskC结束，耗时毫秒数：" + (end - star) + Thread.currentThread().getName());
return new AsyncResult<>("TaskC结束");
}
}- 验证结果
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
