【实战教程】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工程
https://i-blog.csdnimg.cn/direct/de20e867d4a14764a61d2ed355c87407.png
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
https://i-blog.csdnimg.cn/direct/9ca69e54292249759b49163604a983c4.png
方式二
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依赖
<!-- 引入freeMarker的依赖包. -->
<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>
https://i-blog.csdnimg.cn/direct/74755bbbfdff4d67b4512af1b66c6e20.png
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依赖
<!--引入thymeleaf的依赖-->
<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文件中加入以下语句： -->
<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文件中加入以下语句： -->
<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>
<!-- 引入freeMarker的依赖包. -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-freemarker</artifactId>
</dependency>
<!--引入thymeleaf的依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<!-- SpringBoot 整合 jdbc 模板框架-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!-- SpringBoot 整合 mysql 驱动类 -->
<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.AppApp类
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文件引入
<!-- springboot 整合mybatis -->
<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);
}
}
https://i-blog.csdnimg.cn/direct/7ad0f5dcd5834b6a8fef9f42f1d0f86a.png
https://i-blog.csdnimg.cn/direct/57c788e2dc43492b86f0f34594bdd70c.png
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>
<!-- springboot 整合mybatis -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.1.1</version>
</dependency>
<!-- SpringBoot 整合 mysql 驱动类 -->
<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 xmlMemberDataSourceConfig.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 xmlorderDataSourceConfig.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插件
https://i-blog.csdnimg.cn/direct/0650b02fd353415eacd8b1306ae477e4.png
2.搜刮Lombok插件即可
https://i-blog.csdnimg.cn/direct/5cc94ef0c9aa433daa7d65345ef7a70c.png
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依赖
<!--SpringBoot热部署配置 -->
<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”
https://i-blog.csdnimg.cn/direct/3fdb45caad7a4bcb8b2451669d455899.png
[*] 组合键：“Shift+Ctrl+Alt+/” ，选择 “Registry” ，选中打勾 “compiler.automake.allow.when.app.running”
https://i-blog.csdnimg.cn/direct/b8e37857da3e4a789d242e0f4c4a36f4.png
新版本的IDEA在这里设置
https://i-blog.csdnimg.cn/direct/aece5a06593b497abc27b21fd8c37772.png
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}
-${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依赖
<!-- 添加lombok依赖 -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
2.在resources包下新建一个log包，在包下建 logback.xml 在里面进行设置(拷贝到里面即可)
<configuration>
<!--本文主要输出日志为控制台日志，系统日志，sql日志，异常日志-->
<!-- %m输出的信息,%p日志级别,%t线程名,%d日期,%c类的全名,,,, -->
<!--控制台-->
<appender name="console" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>%d %p (%file:%line\)- %m%n</pattern>
<charset>UTF-8</charset>
</encoder>
</appender>
<!--系统info级别日志-->
<!--<File> 日志目录，没有会自动创建-->
<!--<rollingPolicy>日志策略，每天简历一个日志文件，或者当天日志文件超过64MB时-->
<!--encoder 日志编码及输出格式-->
<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">
<!-- or whenever the file size reaches 64 MB -->
<maxFileSize>64 MB</maxFileSize>
</timeBasedFileNamingAndTriggeringPolicy>
</rollingPolicy>
<encoder>
<pattern>
%d %p (%file:%line\)- %m%n
</pattern>
<charset>UTF-8</charset>
<!-- 此处设置字符集 -->
</encoder>
</appender>
<!--sql日志-->
<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">
<!-- or whenever the file size reaches 64 MB -->
<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">
<!-- or whenever the file size reaches 64 MB -->
<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>
<!--日志输出级别 -->
<!--All\DEBUG\INFO\WARN\ERROR\FATAL\OFF-->
<!--打印info级别日志，分别在控制台，fileLog，errorFile输出
异常日志在上面由过滤器过滤出ERROR日志打印
-->
<root level="INFO">
<appender-ref ref="fileLog" />
<appender-ref ref="console" />
<appender-ref ref="errorFile" />
</root>
<!--打印sql至sqlFile文件日志-->
<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;
}
}
https://i-blog.csdnimg.cn/direct/f12b17ce16254b5dadff5b0d5a60a82f.png
5.日记级别
ALL 最低品级的，用于打开所有日记记载。
TRACE designates finer-grained informational events than the DEBUG.Since:1.2.12，很低的日记级别，一般不会利用。
DEBUG 指出细粒度信息事件对调试应用程序是非常有帮助的，重要用于开发过程中打印一些运行信息。
INFO 消息在粗粒度级别上突出强调应用程序的运行过程。打印一些你感爱好的大概重要的信息，这个可以用于生产情况中输出程序运行的一些重要信息，但是不能滥用，制止打印过多的日记。
WARN 表明会出现潜在错误的情形，有些信息不是错误信息，但是也要给程序员的一些提示
ERROR 指出固然发生错误事件，但仍然不影响体系的继承运行。打印错误和非常信息，如果不想输出太多的日记，可以利用这个级别。
FATAL 指出每个严重的错误事件将会导致应用程序的退出。这个级别比较高了。重大错误，这种级别你可以直接停止程序了。
OFF 最高品级的，用于关闭所有日记记载。
6.日记目次
https://i-blog.csdnimg.cn/direct/ee8d9eb76bf24e3f8b040be7a580a8e0.png
8.2利用log4j记载日记
日记级别形貌输出源格式TRACE追踪，程序每推进一步可以写入一个TRACE级别的日记，通常用于非常详细的执行流程跟踪。CONSOLESimpleLayoutDEBUG调试，用于记载调试信息，通常是最低级别，帮助开发者理解程序运行情况。FILEHTMLLayoutINFO重要信息，用于记载应用程序运行的关键信息，是利用较为频繁的日记级别。PatternLayoutWARN告诫，记载可能必要注意的信息，这些信息固然不是错误，但可能会导致题目或必要注意的情况。ERROR错误，记载应用程序中的错误信息，这类信息表明应用程序中出现了题目。CONSOLEFATAL致命错误，记载非常严重的错误信息，通常指应用程序无法继承运行下去的情况。FILE机制：如果一条日记信息的级别大于即是设置文件的级别，则记载这条日记信息。输出源：日记可以输出到控制台(CONSOLE)或文件(FILE)。格式：日记输出的格式可以是简单的(SimpleLayout)，HTML表格形式(HTMLLayout)，大概自定义格式(PatternLayout)。 1.Maven依赖
<!-- spring boot start -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<exclusions>
<!-- 排除自带的logback依赖 -->
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<!-- springboot-log4j -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-log4j</artifactId>
<version>1.3.8.RELEASE</version>
</dependency>
<!-- spring boot start -->
这段代码是利用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
https://i-blog.csdnimg.cn/direct/ae6219310e474564b8b4bb72f9b818de.png
https://i-blog.csdnimg.cn/direct/45a094885bfe4fb0b622003086ed4921.png
8.3利用AOP统一处置惩罚Web请求日记
一般项目都是基于AOP实现 大概elk实现的
它可以在我们的方法的前后实现拦截 减少打印日记代码的冗余性的题目
1.Maven依赖
<!-- springboot-aop -->
<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());
}
}
https://i-blog.csdnimg.cn/direct/1ee656783d2747c6bf1e6f3d08af83ab.png
加粗部分一般利用@Scheduled(cron = "0/2 * * * * *") 写法：
https://www.bejson.com/othertools/cron/
可以在此网站中查找双引号中的利用规范
https://i-blog.csdnimg.cn/direct/44bbf76210f14688894caae6a2b6d373.png
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 转换
[*]返回 String，表示跳到某个 view
[*]返回 modelAndView
[*]返回 model + @ResponseBody
全局捕获非常设置类
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.HashMap;
import java.util.Map;
@ControllerAdvice
public class MayiktExceptionHandler {
/**
* 拦截运行异常出现的错误~~~
*/
@ExceptionHandler(RuntimeException.class)
@ResponseBody
public Map<Object, Object> exceptionHandler() {
Map<Object, Object> map = new HashMap<>();
map.put("error", "500");
map.put("msg", "系统出现错误~");
return map;
}
}
没利用之前
https://i-blog.csdnimg.cn/direct/4aa45003bdac426caeafdc9fba27f2fd.png
给用户显示这个页面很不友爱
利用全局捕获非常设置类之后的页面
https://i-blog.csdnimg.cn/direct/ca7b1d9fd4bb41b88b4882a3583450ee.png
9.4发布打包
利用mvn package 打包
进入到项目地点目次 输入 mvn clean package 进行打包等待打包完成
https://i-blog.csdnimg.cn/direct/87e79375a1004affb252958b83b76604.png
显示这个即打包完成
https://i-blog.csdnimg.cn/direct/91581480f3344b638325632054b1e5ef.png
在项目的目次中的 target 包下生成一个java-jar包
https://i-blog.csdnimg.cn/direct/1a3d0b095626419baaa5019d602f40ed.png
利用java –jar 包的全路径地址
https://i-blog.csdnimg.cn/direct/3397f0dffb7942b8b38cb19b19c2508a.png
如果报错没有主清单，在pom文件中新增
<!-- 设置打包主清单属性 -->
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<executions>
<execution>
<goals>
<goal>repackage</goal>
</goals>
</execution>
</executions>
<configuration>
<!-- 启动类 -->
<mainClass>com.zhaoli.App</mainClass>
<excludes>
<exclude>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
</exclude>
<exclude>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</exclude>
</excludes>
</configuration>
</plugin>
</plugins>
</build>
重新打包再运行
https://i-blog.csdnimg.cn/direct/b9b91d226d424c9fa42e38d4cd9f462b.png
启动
https://i-blog.csdnimg.cn/direct/6bdb377aedb84a02a12d354c21382063.png
https://i-blog.csdnimg.cn/direct/2830104f33f047a3a3fbc9f753c98246.png
成功运行
https://i-blog.csdnimg.cn/direct/c8757504eb6d4caaa9e7e3fc5d988b0e.png
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页:
[1]