ToB企服应用市场:ToB评测及商务社交产业平台

标题: 【实战教程】SpringBoot全面指南：快速上手到项目实战(SpringBoot) [打印本页]

作者: 十念 时间: 2024-10-14 15:59
标题: 【实战教程】SpringBoot全面指南：快速上手到项目实战(SpringBoot)

【实战教程】SpringBoot全面指南：快速上手到项目实战(SpringBoot)

1. SpringBoot先容

1.1 SpringBoot简介

SpringBoot 是一个快速开发的框架, 封装了Maven常用依赖、能够快速的整合第三方框架；简化XML设置，全部采用注解形式，内置Tomcat、Jetty、Undertow，帮助开发者能够实现快速开发，SpringBoot的Web组件默认集成的是SpringMVC框架。
SpringBoot原理先容：

能够帮助开发者实现快速整合第三方框架（原理：Maven依赖封装）
去除xml设置完全采用注解化（原理：Spring体系中内置注解方式）
无需外部Tomcat、内部实现服务器（原理：Java语言支持内嵌入Tomcat服务器）

1.2体系要求

Java1.8及以上
Spring Framework 5.0及以上
本课程采用Java1.8版本、SpringBoot2.1.8版本
1.3 SpringBoot和SpringMVC区别

SpringBoot 是一个快速开发的框架,能够快速的整合第三方框架，简化XML设置，全部采用注解形式，内置Tomcat容器,帮助开发者能够实现快速开发，SpringBoot的Web组件默认集成的是SpringMVC框架。
SpringMVC是控制层。
1.4 SpringBoot和SpringCloud区别

SpringBoot 是一个快速开发的框架,能够快速的整合第三方框架，简化XML设置，全部采用注解形式，内置Tomcat容器,帮助开发者能够实现快速开发，SpringBoot的Web组件默认集成的是SpringMVC框架。
SpringMVC是控制层。
SpringCloud依赖与SpringBoot组件，利用SpringMVC编写Http协议接口，同时SpringCloud是一套完整的微服务办理框架。

2.快速入门

2.1创建一个Maven工程

2.2 pom文件引入依赖

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.8.RELEASE</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>

复制代码

spring-boot-starter-parent作用
在pom.xml中引入spring-boot-start-parent，spring官方的解释叫什么stater poms,它可以提供dependency management,也就是说依赖管理，引入以后在申明其它dependency的时候就不必要version了，后面可以看到。
spring-boot-starter-web作用
springweb 核心组件
2.3 @RestController
@RestController 是由 @Controller(控制层注解)+@ResponBody(数据传输格式为 json 格式)组合而成的
Rest 微服务接口开发中 rest 风格的数据传输格式为 json 格式，采用HTTP协议
在上加上RestController 表示修饰该Controller所有的方法返回JSON格式,直接可以编写
Restful接口
注意该注解是(@RestController )SpringMVC提供的哦！
2.4@EnableAutoConfiguration
该注解:作用在于让 Spring Boot 根据应用所声明的依赖来对 Spring 框架进行自动设置
这个注解告诉Spring Boot根据添加的jar依赖推测你想如何设置Spring。由于spring-boot-starter-web添加了Tomcat和Spring MVC，以是auto-configuration将假定你正在开发一个web应用并相应地对Spring进行设置。
2.5 SpringBoot的3种启动方式
方式一

package com.zhaoli.service;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@EnableAutoConfiguration
public class HelloworldService {
@RequestMapping("/hello")
public String hello() {
return "Hello World!";
}
public static void main(String[] args) {
SpringApplication.run(HelloworldService.class, args);
}
}

复制代码

可以请求本类中的 url
启动主程序，打开欣赏器访问http://127.0.0.1:8080/hello，可以看到页面输出Hello World

方式二

package com.zhaoli.service;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;
@ComponentScan("com.zhaoli.service")//扫包范围
@EnableAutoConfiguration
public class App {
public static void main(String[] args) {
SpringApplication.run(App.class, args);
}
}

复制代码

package com.zhaoli.service;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HellowordService {
@RequestMapping("/hello02")
public String hello02() {
return "Hello 赵立";
}
}

复制代码

可以启动扫包范围下的所有类中的 url
方式三（保举利用）
在启动类上直接加上@SpringBootApplication即可
@SpringBootApplication 被 @Configuration、@EnableAutoConfiguration、@ComponentScan 注解所修饰，换言之 Springboot 提供了统一的注解来替代以上三个注解
扫包范围：在启动类上加上@SpringBootApplication注解,当前包下大概子包下所有的类都可以扫到。

package com.zhaoli.service;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
@SpringBootApplication
public class App {
public static void main(String[] args) {
SpringApplication.run(App.class, args);
}
}

复制代码

3. Web开发

3.1 静态资源访问

在我们开发Web应用的时候，必要引用大量的js、css、图片等静态资源。
默认设置
Spring Boot默认提供静态资源目次位置需置于classpath下，目次名需符合如下规则：

/static
/public
/resources
/META-INF/resources

复制代码

举例：我们可以在src/main/resources/目次下创建static，在该位置放置一个图片文件。启动程序后，实验访问http://localhost:8080/one.png。如能显示图片，设置成功。
微服务项目
前后端分离
前端----vue----前端工程师
后端—springboot–后端工程师
动静分离部署cdn上
cdn 减少带宽距离传输减少自己服务器带宽；
3.2 渲染Web页面

com.zhaoli.controller—视图层渲染我们页面
com.zhaoli.service—业务逻辑层
com.zhaoli.dao—数据库访问层
渲染Web页面
在之前的示例中，我们都是通过@RestController来处置惩罚请求，以是返回的内容为json对象。那么如果必要渲染html页面的时候，要如何实现呢？
模板引擎能够非常好的帮助seo搜刮到该网页
在动态HTML实现上Spring Boot依然可以完美胜任，而且提供了多种模板引擎的默认设置支持，以是在保举的模板引擎下，我们可以很快的上手开发动态网站。
Spring Boot提供了默认设置的模板引擎重要有以下几种：

Thymeleaf
FreeMarker
Velocity
Groovy
Mustache
Spring Boot发起利用这些模板引擎，制止利用JSP，若一定要利用JSP将无法实现Spring Boot的多种特性，具体可见后文：支持JSP的设置
当你利用上述模板引擎中的任何一个，它们默认的模板设置路径为：src/main/resources/templates。当然也可以修改这个路径，具体如何修改，可在后续各模板引擎的设置属性中查询并修改。

3.3 YML与Properties用法

SpringBoot支持两种设置方式,一种是properties文件,一种是yml。(都是在resources目次下)
利用yml可以减少设置文件的重复性。
例如：application.properties设置

test.name=zhaoli
test.age=21

复制代码

例如：application.yml设置

test:
name: zhaoli
age: 20

复制代码

在企业中application.yml方式用的是比较多的；

package com.zhaoli.service;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class MayiktPropertiesService {
@Value("${mayikt.name}")
private String name;
@Value("${mayikt.age}")
private String age;
@RequestMapping("/getProperties")
public String getProperties(){
return name+"---------"+age;
}
}

复制代码

3.4利用Freemarker模板引擎渲染web视图

1.Maven依赖

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-freemarker</artifactId>
</dependency>

复制代码

2.后端代码

package com.zhaoli.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import java.util.Map;
@Controller
public class FreemarkerIndexController {
@RequestMapping("/freemarkerIndex")
public String freemarkerIndex(Map<String,String> result){
//转发到页面展示数据
result.put("name","赵立");
return "freemarkerIndex";
}
}

复制代码

3.前端代码
在src/main/resources/创建一个templates文件夹,用来存 *.ftl

<!DOCTYPE html>
<html>
<head lang="en">
<meta charset="UTF-8"/>
<title></title>
</head>
<body>
${name}
</body>
</html>

复制代码

4.Freemarker其他用法
Freemarker设置
新建application.yml文件 (加粗提示对应的设置可以进行修改)

spring:
##Freemarker配置
http:
encoding:
force: true
### 模版引擎编码为UTF-8
charset: UTF-8
freemarker:
allow-request-override: false
cache: false
check-template-location: true
charset: UTF-8
content-type: text/html; charset=utf-8
expose-request-attributes: false
expose-session-attributes: false
expose-spring-macro-helpers: false
## 模版文件结尾.ftl
suffix: .ftl
## 模版文件目录
template-loader-path: classpath:/templates

复制代码

*.ftl 文件中利用符号替换方法
符号替换为（条件判定）>gt 大概 <#if(x>y)>>=gte 大概 <#if(x>=y)><lt 大概 <#if(x<y)><=lte 大概 <#if(x<=y)> 判定条件用法
com.zhaoli.controller.FreemarkerIndexController

@RequestMapping("/freemarkerIndex02")
public String freemarkerIndex02(Map<String, Object> result) {
//转发到页面展示数据
result.put("name", "赵立");
//0为男 1为女
result.put("sex", "0");
result.put("age", 21);
return "freemarkerIndex02";
}

复制代码

freemarkerIndex02.ftl

<!DOCTYPE html>
<html>
<head lang="en">
<meta charset="UTF-8"/>
<title></title>
</head>
<body>
${name}
<#if sex=='0'>
男
<#elseif sex='1'>
女
<#else >
其他
</#if>
<#if age gt 17>
已经成年了
<#else >
没成年
</#if>
</body>
</html>

复制代码

list集合
com.zhaoli.controller.FreemarkerIndexController

@RequestMapping("/freemarkerIndex03")
public String freemarkerIndex03(Map<String, Object> result) {
//转发到页面展示数据
List<String> userLists = new ArrayList<>();
userLists.add("zl");
userLists.add("fj");
userLists.add("lfc");
userLists.add("ywq");
result.put("userList",userLists);
return "freemarkerIndex03";

复制代码

freemarkerIndex03.ftl

<!DOCTYPE html>
<html>
<head lang="en">
<meta charset="UTF-8"/>
<title></title>
</head>
<body>
<#list userList as user>
${user}
</#list>
</body>
</html>

复制代码

3.5 利用thymeleaf渲染Web页面

1 .什么是thymeleaf
thymeleaf是一款用于渲染XML/XHTML/HTML5内容的模板引擎，类似JSP，Velocity，FreeMaker等，它也可以轻易的与Spring MVC等Web框架进行集成作为Web应用的模板引擎。
2.Maven依赖

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

复制代码

3.设置文件新增
新建application.yml文件

###ThymeLeaf配置
spring:
thymeleaf:
#prefix：指定模板所在的目录
prefix: classpath:/templates/
#check-tempate-location: 检查模板路径是否存在
check-template-location: true
#cache: 是否缓存，开发模式下设置为false，避免改了模板还要重启服务器，线上设置为true，可以提高性能。
cache: true
suffix: .html
encoding: UTF-8
mode: HTML5

复制代码

4.案例代码
com.zhaoli.entity.UserEntity

package com.zhaoli.entity;
public class UserEntity {
private String userName;
private Integer age;
}

复制代码

com.zhaoli.controller.ThymeleafController

package com.zhaoli.controller;
import com.zhaoli.entity.UserEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import java.util.Map;
@Controller
public class ThymeleafController {
@RequestMapping("/thymeleaf")
public String thymeleaf(Map<String, Object> result) {
result.put("user", new UserEntity("赵立", 20));
return "thymeleaf";
}
}

复制代码

在src/main/resources/创建一个templates文件夹,用来存 *html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>Show User</title>
</head>
<body>
<table>
姓名:<span th:text="${user.userName}"></span>
年龄:<span th:text="${user.age}"></span>
</table>
</body>
</html>

复制代码

5.高级写法
循环语句：
com.zhaoli.entity.UserEntity 同上
com.zhaoli.controller.ThymeleafController

@RequestMapping("/thymeleaf02")
public String thymeleaf02(Map<String, Object> result) {
List<UserEntity> userLists = new ArrayList<>();
userLists.add(new UserEntity("赵立", 21));
userLists.add(new UserEntity("fj", 20));
result.put("userList", userLists);
return "thymeleaf02";
}

复制代码

thymeleaf02.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>Show User</title>
</head>
<body>
<table>
<ul th:each="user:${userList}">
<li th:text="${user.userName}"></li>
<li th:text="${user.age}"></li>
</ul>
</table>
</body>
</html>

复制代码

If判定：

<span th:if="${user.age>17}">已经成年啦</span>
<span th:if="${user.age<17}">未成年</span>

复制代码

详细可以更多语法可以查看https://www.thymeleaf.org/documentation.html

4.数据库访问

4.1 springboot整合利用JdbcTemplate

1.pom文件引入

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.8.RELEASE</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-freemarker</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.21</version>
</dependency>
</dependencies>

复制代码

2.application.yml新增设置

##springboot整合使用JdbcTemplate
datasource:
url: jdbc:mysql://localhost:3306/mayikt_springboot?serverTimezone=UTC&useSSL=false
username: root
password: 20020806
driver-class-name: com.mysql.jdbc.Driver

复制代码

3.数据库表布局

CREATE TABLE `users` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(32) NOT NULL COMMENT '用户名称',
`age` int(11) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

复制代码

4.案例代码
com.zhaoli.entity.UserEntity

public class MayiktUserEntity {
private Integer id;
private String userName;
private Integer age;
}

复制代码

com.zhaoli.service.UserService

package com.zhaoli.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class UserService {
@Autowired
private JdbcTemplate jdbcTemplate;
/**
* 插入数据到 users 表
*/
@RequestMapping("/inserUser")
public String inserUser(String userName, Integer age) {
int update = jdbcTemplate.update("INSERT INTO users VALUES(null,?,?);", userName, age);
return update > 0 ? "success" : "fail";
}
}

复制代码

com.zhaoli.App App类

package com.zhaoli;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class App {
public static void main(String[] args) {
SpringApplication.run(App.class, args);
}
}

复制代码

4.2 springboot整合利用mybatis

1.pom文件引入

<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.1.1</version>
</dependency>

复制代码

2.application.yml 新增设置

##springboot整合使用mybatis
datasource:
url: jdbc:mysql://localhost:3306/mayikt_springboot?serverTimezone=UTC&useSSL=false
username: root
password: 20020806
driver-class-name: com.mysql.jdbc.Driver

复制代码

3.案例代码
数据库表布局同上
com.zhaoli.entity.UserEntity 同上
com.zhaoli.mapper.UserMapper 接口

package com.zhaoli.mapper;
import com.zhaoli.entity.MayiktUserEntity;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
public interface UserMapper {
@Insert("INSERT INTO users VALUES(null,#{userName},#{age});")
int insertUser(@Param("userName") String userName, @Param("age")Integer age);
@Select("SELECT id,name AS userName,age FROM users WHERE id=#{id};")
MayiktUserEntity selectByUserId(@Param("id")Integer id);
}

复制代码

com.zhaoli.service.UserService

package com.zhaoli.service;
import com.zhaoli.entity.MayiktUserEntity;
import com.zhaoli.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class UserService {
@Autowired
private UserMapper userMapper;
/**
* mybatis 查询
*/
@RequestMapping("/mybatisfinbyId")
public MayiktUserEntity mybatisfinbyId(Integer id){
return userMapper.selectByUserId(id);
}
/**
* mybatis 插入
*/
@RequestMapping("/mybatisInser")
public String mybatisInser(String userName, Integer age) {
int inser = userMapper.insertUser(userName, age);
return inser > 0 ? "success" : "fail";
}
}

复制代码

com.zhaoli.App App类

package com.zhaoli;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
@MapperScan("com.zhaoli.mapper")//将 mapper 包下的类、接口注入到ioc 容器中
public class App {
public static void main(String[] args) {
SpringApplication.run(App.class, args);
}
}

复制代码

4.3 springboot整合多数据源

1.Maven相关依赖

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.8.RELEASE</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.1.1</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.18</version>
</dependency>
</dependencies>

复制代码

2.数据库表布局

CREATE TABLE `users` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(32) NOT NULL COMMENT '用户名称',
`age` int(11) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;
CREATE TABLE `order_number` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`order_name` varchar(255) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

复制代码

3.设置文件中新增两个数据源

resources.application.yml
spring:
datasource:
###会员数据库
member:
jdbc-url: jdbc:mysql://localhost:3306/user?serverTimezone=UTC&useSSL=false
username: root
password: root
driver-class-name: com.mysql.jdbc.Driver
###订单数据库
order:
jdbc-url: jdbc:mysql://localhost:3306/order?serverTimezone=UTC&useSSL=false
username: root
password: root
driver-class-name: com.mysql.jdbc.Driver

复制代码

备注：如果是SpringBoot2设置多数据源，报如下错误：
jdbcUrl is required with driverClassName.大概Cause: java.lang.IllegalArgumentException: dataSource or dataSourceClassName or jdbcUrl is required.] with root cause
办理方案：
spring.datasource.url 和spring.datasource.driverClassName，换成
spring.datasource.jdbc-url和spring.datasource.driver-class-name
4.数据库数据源相关设置
会员数据源

@Configuration
@MapperScan(basePackages = "com.zhaoli.member.mapper", sqlSessionFactoryRef = "memberSqlSessionFactory")
public class MemberDataSourceConfig {
/**
* 将会员db注册到容器中
*
* @return
*/
@Bean(name = "memberDataSource")
@ConfigurationProperties(prefix = "spring.datasource.member")
public DataSource memberDataSource() {
return DataSourceBuilder.create().build();
}
/**
* 将会员SqlSessionFactory注册到容器中
*
* @param dataSource
* @return
* @throws Exception
*/
@Bean(name = "memberSqlSessionFactory")
public SqlSessionFactory memberSqlSessionFactory(@Qualifier("memberDataSource") DataSource dataSource) throws Exception {
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
sqlSessionFactoryBean.setDataSource(memberDataSource());
return sqlSessionFactoryBean.getObject();
}
/**
* 创建会员管理器
*
* @param dataSource
* @return
*/
@Bean(name = "memberTransactionManager")
public DataSourceTransactionManager memberTransactionManager(@Qualifier("memberDataSource") DataSource dataSource) {
return new DataSourceTransactionManager(dataSource);
}
/**
* 创建订单sqlSesion模版
*
* @param sqlSessionFactory
* @return
* @throws Exception
*/
@Bean(name = "memberSqlSessionTemplate")
public SqlSessionTemplate menberSqlSessionTemplate(
@Qualifier("memberSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
return new SqlSessionTemplate(sqlSessionFactory);
}
}

复制代码

订单数据源

@Configuration
@MapperScan(basePackages = "com.zhaoli.order.mapper", sqlSessionFactoryRef = "orderSqlSessionFactory")
public class OrderDataSourceConfig {
/**
* 将订单db注册到容器中
*
* @return
*/
@Bean(name = "orderDataSource")
@ConfigurationProperties(prefix = "spring.datasource.order")
public DataSource orderDataSource() {
return DataSourceBuilder.create().build();
}
/**
* 将订单SqlSessionFactory注册到容器中
*
* @param dataSource
* @return
* @throws Exception
*/
@Bean(name = "orderSqlSessionFactory")
public SqlSessionFactory orderSqlSessionFactory(@Qualifier("orderDataSource") DataSource dataSource) throws Exception {
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
sqlSessionFactoryBean.setDataSource(orderDataSource());
return sqlSessionFactoryBean.getObject();
}
/**
* 创建订单管理器
*
* @param dataSource
* @return
*/
@Bean(name = "orderTransactionManager")
public DataSourceTransactionManager orderTransactionManager(@Qualifier("orderDataSource") DataSource dataSource) {
return new DataSourceTransactionManager(dataSource);
}
/**
* 创建订单sqlSesion模版
*
* @param sqlSessionFactory
* @return
* @throws Exception
*/
@Bean(name = "orderSqlSessionTemplate")
public SqlSessionTemplate menberSqlSessionTemplate(
@Qualifier("orderSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
return new SqlSessionTemplate(sqlSessionFactory);
}
}

复制代码

5.创建分包Mapper
会员mapper

public interface MemberMapper {
@Insert("insert into users values(null,#{name},#{age});")
public int addUser(@Param("name") String name, @Param("age") Integer age);
}

复制代码

订单mapper

public interface OrderMapper {
@Insert("insert into order_number values(null,#{number});")
int inserOrder(@Param("number") String number);
}

复制代码

6.启动项目

@SpringBootApplication
public class App{
public static void main(String[] args) {
SpringApplication.run(App.class);
}
}

复制代码

5.事务管理

5.1 Springboot整合事务管理

springboot默认集成事务,只重要在方法上加上@Transactional即可
5.2 SpringBoot分布式事务管理

利用springboot+jta+atomikos 分布式事物Transactional管理
1.多数据源分布式事务案例

@Service
public class MemberService {
@Autowired
private MemberMapper memberMapper;
@Autowired
private OrderMapper orderMapper;
@Transactional(transactionManager = "memberTransactionManager")
public int addUser(String userName, Integer age) {
int result = memberMapper.addUser(userName, age);
orderMapper.inserOrder(userName);
int j = 1 / age;
return result;
}
}

复制代码

2.Maven相关依赖

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jta-atomikos</artifactId>
</dependency>

复制代码

3.新增设置文件信息

spring:
datasource:
###会员数据库
member:
url: jdbc:mysql://localhost:3306/user?serverTimezone=UTC&useSSL=false
username: root
password: root
borrowConnectionTimeout: 30
loginTimeout: 30
maintenanceInterval: 60
maxIdleTime: 60
maxLifetime: 20000
maxPoolSize: 25
minPoolSize: 3
uniqueResourceName: orderDatasource
###订单数据库
order:
url: jdbc:mysql://localhost:3306/order?serverTimezone=UTC&useSSL=false
username: root
password: root
borrowConnectionTimeout: 30
loginTimeout: 30
maintenanceInterval: 60
maxIdleTime: 60
maxLifetime: 20000
maxPoolSize: 25
minPoolSize: 3
uniqueResourceName: memberDatasource

复制代码

4.读取设置文件信息

@ConfigurationProperties(prefix = "spring.datasource.member")
@Data
public class MemberConfig {
private String url;
private String userName;
private String passWord;
private int minPoolSize;
private int maxPoolSize;
private int maxLifetime;
private int borrowConnectionTimeout;
private int loginTimeout;
private int maintenanceInterval;
private int maxIdleTime;
private String testQuery;
private String uniqueResourceName;
}

复制代码

@ConfigurationProperties(prefix = "spring.datasource.order")
@Data
public class OrderConfig {
private String url;
private String userName;
private String passWord;
private int minPoolSize;
private int maxPoolSize;
private int maxLifetime;
private int borrowConnectionTimeout;
private int loginTimeout;
private int maintenanceInterval;
private int maxIdleTime;
private String testQuery;
private String uniqueResourceName;
}

复制代码

5.创建多数据源

@Configuration
@MapperScan(basePackages = "com.zhaoli.member.mapper", sqlSessionTemplateRef = "memberSqlSessionTemplate")
public class MemberDataSourceConfig {
//@Configuration xml MemberDataSourceConfig.xml
/**
* 创建我们的DataSource
*/
@Bean("memberDataSource")
public DataSource memberDataSource(MemberConfig memberConfig) throws SQLException {
// 1.创建MysqlXADataSource
MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
mysqlXaDataSource.setUrl(memberConfig.getUrl());
mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
mysqlXaDataSource.setPassword(memberConfig.getPassWord());
mysqlXaDataSource.setUser(memberConfig.getUserName());
mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
// 2.将本地事务注册到创 Atomikos全局事务
AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
xaDataSource.setXaDataSource(mysqlXaDataSource);
xaDataSource.setUniqueResourceName(memberConfig.getUniqueResourceName());
xaDataSource.setMinPoolSize(memberConfig.getMinPoolSize());
xaDataSource.setMaxPoolSize(memberConfig.getMaxPoolSize());
xaDataSource.setMaxLifetime(memberConfig.getMaxLifetime());
xaDataSource.setBorrowConnectionTimeout(memberConfig.getBorrowConnectionTimeout());
xaDataSource.setLoginTimeout(memberConfig.getLoginTimeout());
xaDataSource.setMaintenanceInterval(memberConfig.getMaintenanceInterval());
xaDataSource.setMaxIdleTime(memberConfig.getMaxIdleTime());
xaDataSource.setTestQuery(memberConfig.getTestQuery());
return xaDataSource;
}
/**
* 创建我们的SqlSessionFactory
*/
@Bean(name = "memberSqlSessionFactory")
public SqlSessionFactory memberSqlSessionFactory(@Qualifier("memberDataSource") DataSource dataSource) throws Exception {
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
sqlSessionFactoryBean.setDataSource(dataSource);
return sqlSessionFactoryBean.getObject();
}
/**
* 创建订单sqlSesion模版
*/
@Bean(name = "memberSqlSessionTemplate")
public SqlSessionTemplate memberSqlSessionTemplate(
@Qualifier("memberSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
return new SqlSessionTemplate(sqlSessionFactory);
}
}

复制代码

@Configuration
@MapperScan(basePackages = "com.zhaoli.order.mapper", sqlSessionTemplateRef = "orderSqlSessionTemplate")
public class OrderDataSourceConfig {
//@Configuration xml orderDataSourceConfig.xml
/**
* 创建我们的DataSource
*/
@Bean("orderDataSource")
public DataSource orderDataSource(OrderConfig orderConfig) throws SQLException {
// 1.创建MysqlXADataSource
MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
mysqlXaDataSource.setUrl(orderConfig.getUrl());
mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
mysqlXaDataSource.setPassword(orderConfig.getPassWord());
mysqlXaDataSource.setUser(orderConfig.getUserName());
mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
// 2.将本地事务注册到创 Atomikos全局事务
AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
xaDataSource.setXaDataSource(mysqlXaDataSource);
xaDataSource.setUniqueResourceName(orderConfig.getUniqueResourceName());
xaDataSource.setMinPoolSize(orderConfig.getMinPoolSize());
xaDataSource.setMaxPoolSize(orderConfig.getMaxPoolSize());
xaDataSource.setMaxLifetime(orderConfig.getMaxLifetime());
xaDataSource.setBorrowConnectionTimeout(orderConfig.getBorrowConnectionTimeout());
xaDataSource.setLoginTimeout(orderConfig.getLoginTimeout());
xaDataSource.setMaintenanceInterval(orderConfig.getMaintenanceInterval());
xaDataSource.setMaxIdleTime(orderConfig.getMaxIdleTime());
xaDataSource.setTestQuery(orderConfig.getTestQuery());
return xaDataSource;
}
/**
* 创建我们的SqlSessionFactory
*/
@Bean(name = "orderSqlSessionFactory")
public SqlSessionFactory orderSqlSessionFactory(@Qualifier("orderDataSource") DataSource dataSource) throws Exception {
SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
sqlSessionFactoryBean.setDataSource(dataSource);
return sqlSessionFactoryBean.getObject();
}
//
// /**
// * 创建会员管理器
// */
// @Bean(name = "orderTransactionManager")
// public DataSourceTransactionManager orderTransactionManager(@Qualifier("orderDataSource") DataSource dataSource) {
// return new DataSourceTransactionManager(dataSource);
// }
/**
* 创建订单sqlSesion模版
*/
@Bean(name = "orderSqlSessionTemplate")
public SqlSessionTemplate orderSqlSessionTemplate(
@Qualifier("orderSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
return new SqlSessionTemplate(sqlSessionFactory);
}
}

复制代码

如果多数据源利用事务报错的话
cted single matching bean but found 2: memberTransactionManager,orderTransactionManager
@Transactional(transactionManager = "memberTransactionManager")
明确指定利用那个事务管理器即可
6.启动加载设置
@EnableConfigurationProperties({OrderConfig.class, MemberConfig.class})

6.整合热部署

6.1 Spring Boot集成lombok让代码更简便

1.必要安装Idea整合整合Lombok插件

2.搜刮Lombok插件即可

3.点击install然后，安装成功之后，点击重启idea 即可。
整合lombok注意事项

必要在idea中安装lombok插件；-----没有做
引入到lombok依赖；
加上了注解，根本就没有生成get和set方法。

原理：
现实上在开发写代码的时候是不必要写get和set方法，但是在编译class文件中，帮你自动生成好这样get和set方法放入到class文件中。
4.添加lombok依赖

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

复制代码

5.打印日记
//App 是类的名称，在那个类中用就写那个类
private static Logger log = Logger.getLogger(App.class);
直接在类上加上@Slf4j 就不用写上面这行代码
6.其他特性
注解形貌@Data自动生成getter/setter方法，toString()方法，equals()方法，hashCode()方法，不带参数的构造方法。@NonNull制止NullPointerException，确保非空对象引用。@CleanUp自动管理必要关闭的资源，无需手动在finally块中调用close()方法。@Setter自动生成setter方法。@Getter自动生成getter方法。@ToString自动生成toString()方法。@EqualsAndHashCode从对象的字段生成hashCode()和equals()方法的实现。@NoArgsConstructor自动生成无参构造方法。@RequiredArgsConstructor根据final或@NotNull修饰的属性自动生成构造方法。@AllArgsConstructor自动生成包含所有属性的构造方法。@Value用于注解不可变的final类。@Builder自动生成复杂对象的构造器API。@SneakyThrows捕获并隐藏检查型非常，需谨慎利用。@Synchronized将方法或代码块标记为同步的，保证线程安全。@Getter(lazy=true)耽误加载属性值，仅实用于Java 8及以上版本。@Log支持不同的日记框架，例如利用@Log4j注解引入Log4j日记对象。 6.2 Spring Boot整合热部署框架

1.什么是热部署
修改java类或页面大概静态文件，不必要手动重启
原理：类加载器
恰当于本地开发情况
2. Maven依赖

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>

复制代码

3. Idea工具设置

`“File” -> “Settings” -> “Build,Execution,Deplyment” -> “Compiler”，选中打勾 “Build project automatically”
组合键：“Shift+Ctrl+Alt+/” ，选择 “Registry” ，选中打勾 “compiler.automake.allow.when.app.running”

新版本的IDEA在这里设置

4.结果演示
按住保存键，自动帮我实现重启项目

7.整合设置文件

1. 在springboot整合设置文件，分成两大类：
application.properties
application.yml
大概是
Bootstrap.properties
Bootstrap.yml
相对于来说yml文件格式写法更加精简，减少设置文件的冗余性。
2. 加载次序：
bootstrap.yml 先加载 application.yml后加载
bootstrap.yml 用于应用程序上下文的引导阶段。
bootstrap.yml 由父Spring ApplicationContext加载。
3.区别：
bootstrap.yml 和 application.yml 都可以用来设置参数。
bootstrap.yml 用来程序引导时执行，应用于更加早期设置信息读取。可以理解成体系级别的一些参数设置，这些参数一般是不会变动的。一旦bootStrap.yml 被加载，则内容不会被覆盖。
application.yml 可以用来定义应用级别的，应用程序特有设置信息，可以用来设置后续各个模块中需利用的公共参数等。
分布式设置中心：
Properties在线转换yml格式网址：https://www.toyaml.com/index.html
7.1利用@value注解和@ConfigurationProperties注解

@value注解

@Value("${test.name}")//可以获取到配置文件中对应的值
private String name;

复制代码

@ConfigurationProperties注解
Maven依赖

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>

复制代码

com.zhaoli.entity

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Component
@ConfigurationProperties(prefix = "test")
public class TestUserEntity {
private String addres;
private String age;
private String name;
//省略了get set toString
}

复制代码

设置文件

test:
addres: www.zhaoli.com
age: 22
name: test

复制代码

com.zhaoli.service

@Autowired
private TestUserEntity userEntity;
@RequestMapping("/getNameAndAgeAddres")
public String getNameAndAgeAddres() {
return userEntity.toString();
}

复制代码

7.2设置文件占位符

在SpringBoot的设置文件中，我们可以利用SpringBoot提供的的一些随机数
${random.value}、${random.int}、${random.long}
${random.int(10)}表示获取10以内的随机数、${random.int[1024,65536]}
-${app.name:默认值} 来制定找不到属性时的默认值
7.3多情况设置和核心设置

resources.templates.application.yml 里面指定读取文件的名称

spring:
profiles:
active: （dev或者test或者prd）

复制代码

application-dev.yml：开发情况
application-test.yml：测试情况
application-prd.yml：生产情况
核心设置

server:
## 设定端口号
port: 8081
servlet:
## 设置 springboot 项目访问路径
context-path: /mayikt
Springboot 默认的情况下整合tomcat容器

复制代码

8.日记管理

8.1利用logback记载日记

Springboot 已经默认帮你整合好了logback
日记输出文件在当前项目路径log文件夹下
1.Maven依赖

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

复制代码

2.在resources包下新建一个log包，在包下建 logback.xml 在里面进行设置(拷贝到里面即可)

<configuration>
<appender name="console" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>%d %p (%file:%line\)- %m%n</pattern>
<charset>UTF-8</charset>
</encoder>
</appender>
<appender name="fileLog"
class="ch.qos.logback.core.rolling.RollingFileAppender">
<File>log/file/fileLog.log</File>
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<fileNamePattern>log/file/fileLog.log.%d.%i</fileNamePattern>
<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
<maxFileSize>64 MB</maxFileSize>
</timeBasedFileNamingAndTriggeringPolicy>
</rollingPolicy>
<encoder>
<pattern>
%d %p (%file:%line\)- %m%n
</pattern>
<charset>UTF-8</charset>
</encoder>
</appender>
<appender name="sqlFile"
class="ch.qos.logback.core.rolling.RollingFileAppender">
<File>log/sql/sqlFile.log</File>
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<fileNamePattern>log/sql/sqlFile.log.%d.%i</fileNamePattern>
<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
<maxFileSize>64 MB</maxFileSize>
</timeBasedFileNamingAndTriggeringPolicy>
</rollingPolicy>
<encoder>
<pattern>
%d %p (%file:%line\)- %m%n
</pattern>
<charset>UTF-8</charset>
</encoder>
</appender>
<appender name="errorFile"
class="ch.qos.logback.core.rolling.RollingFileAppender">
<File>log/error/errorFile.log</File>
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<fileNamePattern>log/error/errorFile.%d.log.%i</fileNamePattern>
<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
<maxFileSize>64 MB</maxFileSize>
</timeBasedFileNamingAndTriggeringPolicy>
</rollingPolicy>
<encoder>
<pattern>
%d %p (%file:%line\)- %m%n
</pattern>
<charset>UTF-8</charset>
</encoder>
<!--
日志都在这里过滤出 error
使用 try {}catch (Exception e){} 的话异常无法写入日志，可以在catch里用logger.error()方法手动写入日志
-->
<filter class="ch.qos.logback.classic.filter.LevelFilter">
<level>ERROR</level>
<onMatch>ACCEPT</onMatch>
<onMismatch>DENY</onMismatch>
</filter>
</appender>
<!--打印info级别日志，分别在控制台，fileLog，errorFile输出
异常日志在上面由过滤器过滤出ERROR日志打印
-->
<root level="INFO">
<appender-ref ref="fileLog" />
<appender-ref ref="console" />
<appender-ref ref="errorFile" />
</root>
<logger name="com.dolphin.mapper" level="DEBUG" additivity="false">
<appender-ref ref="console" />
<appender-ref ref="sqlFile" />
</logger>
</configuration>

复制代码

3.在 resources 目次下的 application.yml 文件内新增 application 设置

###指定读取logback配置文件
logging:
config: classpath:log/logback.xml

复制代码

4.测试案例

@RestController
@Slf4j
public class MyIndexService {
/**
* 演示打印日志
*/
@RequestMapping("/getNameAndAge")
public String getNameAndAge(String name,Integer age){
log.info("name:{},age:{}",name,age);
return name+","+age;
}
}

复制代码

5.日记级别
ALL 最低品级的，用于打开所有日记记载。
TRACE designates finer-grained informational events than the DEBUG.Since:1.2.12，很低的日记级别，一般不会利用。
DEBUG 指出细粒度信息事件对调试应用程序是非常有帮助的，重要用于开发过程中打印一些运行信息。
INFO 消息在粗粒度级别上突出强调应用程序的运行过程。打印一些你感爱好的大概重要的信息，这个可以用于生产情况中输出程序运行的一些重要信息，但是不能滥用，制止打印过多的日记。
WARN 表明会出现潜在错误的情形，有些信息不是错误信息，但是也要给程序员的一些提示
ERROR 指出固然发生错误事件，但仍然不影响体系的继承运行。打印错误和非常信息，如果不想输出太多的日记，可以利用这个级别。
FATAL 指出每个严重的错误事件将会导致应用程序的退出。这个级别比较高了。重大错误，这种级别你可以直接停止程序了。
OFF 最高品级的，用于关闭所有日记记载。
6.日记目次

8.2利用log4j记载日记

日记级别形貌输出源格式TRACE追踪，程序每推进一步可以写入一个TRACE级别的日记，通常用于非常详细的执行流程跟踪。CONSOLESimpleLayoutDEBUG调试，用于记载调试信息，通常是最低级别，帮助开发者理解程序运行情况。FILEHTMLLayoutINFO重要信息，用于记载应用程序运行的关键信息，是利用较为频繁的日记级别。PatternLayoutWARN告诫，记载可能必要注意的信息，这些信息固然不是错误，但可能会导致题目或必要注意的情况。ERROR错误，记载应用程序中的错误信息，这类信息表明应用程序中出现了题目。CONSOLEFATAL致命错误，记载非常严重的错误信息，通常指应用程序无法继承运行下去的情况。FILE机制：如果一条日记信息的级别大于即是设置文件的级别，则记载这条日记信息。输出源：日记可以输出到控制台(CONSOLE)或文件(FILE)。格式：日记输出的格式可以是简单的(SimpleLayout)，HTML表格形式(HTMLLayout)，大概自定义格式(PatternLayout)。 1.Maven依赖

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-log4j</artifactId>
<version>1.3.8.RELEASE</version>
</dependency>

复制代码

这段代码是利用Maven构建项目时，添加spring-boot-starter依赖的一种方式，而且通过exclusions排除了其中的logback依赖。
当你利用类似的设置时，spring-boot-starter依赖会被添加到项目中，而且排除了 spring-boot-starter-logging。这样，你可以根据自己的需求选择恰当的日记框架进行利用
这个排除logback依赖的操作可以用来替换其他的日记框架，大概利用自定义的日记框架进行日记的输出
2.新建log4j设置文件
在 resources 目次下新建文件log4j.properties
记得根据自己的项目修改里面的日记输出路径

#log4j.rootLogger=CONSOLE,info,error,DEBUG
log4j.rootLogger=DEBUG,error,CONSOLE,info
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n
log4j.logger.info=info
log4j.appender.info=org.apache.log4j.DailyRollingFileAppender
log4j.appender.info.layout=org.apache.log4j.PatternLayout
log4j.appender.info.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n
log4j.appender.info.datePattern='.'yyyy-MM-dd
log4j.appender.info.Threshold = info
log4j.appender.info.append=true
log4j.appender.info.File=E:/code/log/info.log
log4j.logger.error=error
log4j.appender.error=org.apache.log4j.DailyRollingFileAppender
log4j.appender.error.layout=org.apache.log4j.PatternLayout
log4j.appender.error.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n
log4j.appender.error.datePattern='.'yyyy-MM-dd
log4j.appender.error.Threshold = error
log4j.appender.error.append=true
log4j.appender.error.File=E:/code/log/error.log
log4j.logger.DEBUG=DEBUG
log4j.appender.DEBUG=org.apache.log4j.DailyRollingFileAppender
log4j.appender.DEBUG.layout=org.apache.log4j.PatternLayout
log4j.appender.DEBUG.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n
log4j.appender.DEBUG.datePattern='.'yyyy-MM-dd
log4j.appender.DEBUG.Threshold = DEBUG
log4j.appender.DEBUG.append=true
log4j.appender.DEBUG.File=E:/code/log/dubug.log

复制代码

log4j代码
private static final Logger logger = LoggerFactory.getLogger(IndexController.class);
3.application

# 指定log4j.properties配置文件路径
logging:
config: classpath:log4j.properties

复制代码

8.3利用AOP统一处置惩罚Web请求日记

一般项目都是基于AOP实现大概elk实现的
它可以在我们的方法的前后实现拦截减少打印日记代码的冗余性的题目
1.Maven依赖

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>

复制代码

2.AOP切面相关设置(直接拷贝即可)

package com.zhaoli.aop;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import java.util.Enumeration;
@Aspect
@Component
@Slf4j
public class WebLogAspect {
// private static final Logger logger = LoggerFactory.getLogger(WebLogAspect.class);
/**
* 切入点
* com.zhaoli.controller.* 拦截该包下的所有类
* com.zhaoli.controller.*.* 拦截该包下的所有类中的所有方法
* (..)所有的方法参数
*/
@Pointcut("execution(public * com.zhaoli.controller.*.*(..))")
public void webLog() {
}
/**
* 前置通知请求方法之前做拦截
*/
@Before("webLog()")
public void doBefore(JoinPoint joinPoint) throws Throwable {
// 接收到请求，记录请求内容
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = attributes.getRequest();
// 记录下请求内容
log.info("URL : " + request.getRequestURL().toString());
log.info("HTTP_METHOD : " + request.getMethod());
log.info("IP : " + request.getRemoteAddr());
Enumeration<String> enu = request.getParameterNames();
while (enu.hasMoreElements()) {
String name = (String) enu.nextElement();
log.info("name:{},value:{}", name, request.getParameter(name));
}
}
/**
* 目标方法请求之后打印(响应)信息
*/
@AfterReturning(returning = "ret", pointcut = "webLog()")
public void doAfterReturning(Object ret) throws Throwable {
// 处理完请求，返回内容
log.info("RESPONSE : " + ret);
}
}

复制代码

9.其他内容

9.1利用@Scheduled创建定时任务

在Spring Boot的主类(App类即启动类)中加入@EnableScheduling注解，启用定时任务的设置
package com.zhaoli.task;

import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
@Component
@Slf4j
public class ScheduledTasks {
/**
* 每隔三秒执行到 taskService()
*/
@Scheduled(fixedRate = 3000)
public void taskService(){
log.info("<<定时任务执行>>"+System.currentTimeMillis());
}
}

复制代码

加粗部分一般利用@Scheduled(cron = "0/2 * * * * *") 写法：
https://www.bejson.com/othertools/cron/
可以在此网站中查找双引号中的利用规范

9.2利用@Async实现异步调用

在 Spring Boot 应用的主类(App类即启动类)上添加 @EnableAsync 注解，用于启用 Spring 的异步执行功能。
必要执行异步方法上加入 @Async
具体来说，@Async 注解用于告诉 Spring 框架将被注解的方法放入一个任务执行器（Task Executor）中执行，而不是利用调用线程进行同步执行。任务执行器负责管理执行异步任务的线程池大概其他执行策略。
异步应用场景
@Async现实就是多线程封装的
异步线程执行方法有可能会非常消耗cpu的资源，以是大的项目发起利用
Mq异步实现。
整合线程池
异步注解设置类
com.zhaoli.config.ThreadPoolConfig (设置线程池，可直接拷贝)

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.TaskExecutor;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.ThreadPoolExecutor;
@Configuration
@EnableAsync
public class ThreadPoolConfig {
/**
* 每秒需要多少个线程处理?
* tasks/(1/taskcost)
*/
private int corePoolSize = 3;
/**
* 线程池维护线程的最大数量
* (max(tasks)- queueCapacity)/(1/taskcost)
*/
private int maxPoolSize = 3;
/**
* 缓存队列
* (coreSizePool/taskcost)*responsetime
*/
private int queueCapacity = 10;
/**
* 允许的空闲时间
* 默认为60
*/
private int keepAlive = 100;
@Bean
public TaskExecutor taskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
// 设置核心线程数
executor.setCorePoolSize(corePoolSize);
// 设置最大线程数
executor.setMaxPoolSize(maxPoolSize);
// 设置队列容量
executor.setQueueCapacity(queueCapacity);
// 设置允许的空闲时间（秒）
//executor.setKeepAliveSeconds(keepAlive);
// 设置默认线程名称
executor.setThreadNamePrefix("thread-");
// 设置拒绝策略rejection-policy：当pool已经达到max size的时候，如何处理新任务
// CALLER_RUNS：不在新线程中执行任务，而是有调用者所在的线程来执行
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
// 等待所有任务结束后再关闭线程池
executor.setWaitForTasksToCompleteOnShutdown(true);
return executor;
}
}

复制代码

代码案例
@Async("taskExecutor") 是一个Spring框架中的注解，用于将方法标记为异步执行的方法。

import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
@Slf4j
@Component
public class MemberServiceAsync {
@Async("taskExecutor") //指定线程池名称
public String smsAsync() {
log.info(">02<");
try {
log.info(">正在发送短信..<");
Thread.sleep(3000);
} catch (Exception e) {
}
log.info(">03<");
return "短信发送完成!";
}
}

复制代码

注意失效题目
注意：如果异步注解写当前自己类，有可能aop会失效，无法拦截注解，最终导致异步注解失效，必要经过代理类调用接口；
以是必要将异步的代码单独抽取成一个类调用接口。
9.3全局捕获非常

@ExceptionHandler 表示拦截非常
@ControllerAdvice 是 controller 的一个辅助类，最常用的就是作为全局非常处置惩罚的切面类
@ControllerAdvice 可以指定扫描范围
@ControllerAdvice 约定了几种可行的返回值，如果是直接返回 model 类的话，必要利用 @ResponseBody 进行 json 转换