SpringBoot快速入门--基础版（包含整合常用框架、跨域）_java

SpringBoot 概述 SpringBoot 概念

SpringBoot提供了一种快速使用Spring的方式，基于约定优于配置的思想，可以让开发人员不必在配置与逻辑业务之间进行思维的切换，全身心的投入到逻辑业务的代码编写中，从而大大提高了开发的效率，一定程度上缩短了项目周期。2014 年 4 月，Spring Boot 1.0.0 发布。Spring的顶级项目之一(https://spring.io)。

Spring 缺点

1）配置繁琐

虽然Spring的组件代码是轻量级的，但它的配置却是重量级的。一开始，Spring用XML配置，而且是很多 XML配置。Spring 2.5引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显式XML配置。 Spring 3.0引入了基于Java的配置，这是一种类型安全的可重构配置方式，可以代替XML。所有这些配置都代表了开发时的损耗。因为在思考Spring特性配置和解决业务问题之间需要进行思维切换，所以编写配置挤占了编写应用程序逻辑的时间。和所有框架一样，Spring实用，但它要求的回报也不少。

2）依赖繁琐

项目的依赖管理也是一件耗时耗力的事情。在环境搭建时，需要分析要导入哪些库的坐标，而且还需要分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本，随之而来的不兼容问题就会严重阻碍项目的开发进度。

SpringBoot 功能

1）自动配置

Spring Boot的自动配置是一个运行时（更准确地说，是应用程序启动时）的过程，考虑了众多因素，才决定 Spring配置应该用哪个，不该用哪个。该过程是SpringBoot自动完成的。

2）起步依赖

起步依赖本质上是一个Maven项目对象模型（Project Object Model，POM），定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。

3）辅助功能

提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等。

Spring Boot 并不是对 Spring 功能上的增强，而是提供了一种快速使用 Spring 的方式。

小结

SpringBoot提供了一种快速开发Spring项目的方式，而不是对Spring功能上的增强。

Spring的缺点：

配置繁琐
依赖繁琐

SpringBoot功能：

自动配置
起步依赖：依赖传递
辅助功能

SpringBoot 快速构建案例：需求

搭建SpringBoot工程，定义HelloController.hello()方法，返回"Hello SpringBoot!”。

案例：实现步骤

① 创建Spring Initializr项目

② 定义Controller

package com.aiw.hello.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @RequestMapping("/hello")
    public String hello() {
        return "Hello SpringBoot!";
    }

}

③ 启动测试

小结

SpringBoot在创建项目时，使用jar的打包方式。
SpringBoot的引导类，是项目入口，运行main方法就可以启动项目。
使用SpringBoot和Spring构建的项目，业务代码编写方式完全一样。

SpringBoot 起步依赖原理分析 1） spring-boot-starter-parent

主要定义版本信息，这样在pom.xml中引入依赖不用指定版本

依次点击spring-boot-starter-parent->spring-boot-dependencies，进入spring-boot-dependencies-2.6.7.pom

如搜索starter-web：

如搜索mysql：

如搜索tomcat：

也可以修改默认版本号，在pom.xml添加如下：

<properties>
    <java.version>17java.version>
    
    <mysql.version>5.1.40mysql.version>
properties>

此处修改mysql版本为5.1.40，不再是默认8.0.28版本

2） spring-boot-starter-web

点击spring-boot-starter-web进入到spring-boot-starter-web-2.6.7.pom

包含如下依赖：

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-webartifactId>
    <version>5.3.19version>
    <scope>compilescope>
dependency>
<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-webmvcartifactId>
    <version>5.3.19version>
    <scope>compilescope>
dependency>

小结

在spring-boot-starter-parent中定义了各种技术的版本信息，组合了一套最优搭配的技术版本。
在各种starter中，定义了完成该功能需要的坐标合集，其中大部分版本信息来自于父工程。
我们的工程继承parent，引入starter后，通过依赖传递，就可以简单方便获得需要的jar包，并且不会存在版本冲突等问题。

SpringBoot 配置配置文件分类

SpringBoot是基于约定的，所以很多配置都有默认值，但如果想使用自己的配置替换默认配置的话，就可以使用 application.properties或者application.yml（application.yaml）进行配置。

properties：
```
server.port=8080
```
yml：
```
server:
  port: 666
```
yml/yaml中，键和值之间有个空格

小结

SpringBoot提供了2种配置文件类型：properteis和yml/yaml
默认配置文件名称：application
在同一级目录下优先级为：properties > yml > yaml

YAML

YAML全称是 YAML Ain’t Markup Language 。YAML是一种直观的能够被电脑识别的的数据数据序列化格式，并且容易被人类阅读，容易和脚本语言交互的，可以被支持YAML库的不同的编程语言程序导入，比如： C/C++, Ruby, Python, Java, Perl, C#, PHP 等。YML文件是以数据为核心的，比传统的xml方式更加简洁。

YAML文件的扩展名可以使用.yml或者.yaml。

properties:

server.port=8080
server.address=127.0.0.1

xml:

<server>
    <port>8080port>
    <address>127.0.0.1address>
server>

yml:

server:
    port: 8080
    address: 127.0.0.1

简洁，以数据为核心

基本语法

大小写敏感
数据值前边必须有空格，作为分隔符
使用缩进表示层级关系
缩进时不允许使用Tab键，只允许使用空格（各个系统 Tab对应的空格数目可能不同，导致层次混乱）
缩进的空格数目不重要，只要相同层级的元素左侧对齐即可
# 表示注释，从这个字符一直到行尾，都会被解析器忽略

server:
    port: 8080
    address: 127.0.0.1
name: abc

数据格式

对象(map)：键值对的集合

person:
	name: zhangsan
# 行内写法
person: {name: zhangsan}

数组：一组按次序排列的值

address:
    - beijing
    - shanghai
# 行内写法
address: [beijing,shanghai]

纯量：单个的、不可再分的值

msg1: 'hello \n world' # 单引忽略转义字符
msg2: "hello \n world" # 双引识别转义字符

参数引用

name: lisi
person:
	name: ${name} # 引用上边定义的name值

小结

1）配置文件类型

properties：和以前一样
yml/yaml：注意空格

2） yaml：简洁，以数据为核心

基本语法
- 大小写敏感
- 数据值前边必须有空格，作为分隔符
- 使用空格缩进表示层级关系，相同缩进表示同一级
数据格式
- 对象
- 数组: 使用 “- ”表示数组每个元素
- 纯量
参数引用
- ${key}

读取配置文件内容 1） @Value

测试：

// 纯量
@Value("${msg1}")
private String msg1;

// 对象
@Value("${person.name}")
private String name;

@Value("${person.age}")
private Integer age;

// 数组
@Value("${address[0]}")
private String address;

输出：

System.out.println(msg1);

System.out.println(name);
System.out.println(age);

System.out.println(address);

2） Environment

包名：org.springframework.core.env

测试：

@Autowired
private Environment env;

输出：

// 纯量
System.out.println(env.getProperty("msg1"));
// 对象
System.out.println(env.getProperty("person.name"));
// 数组
System.out.println(env.getProperty("address[0]"));

3） @ConfigurationProperties

创建Person类

package com.aiw.hello.pojo;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "person")
public class Person {
    private String name;
    private Integer age;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

测试：

@Autowired
private Person person;

输出：

System.out.println(person);

可以添加配置处理器，这样写自定义配置的时候有提示，在pom.xml中添加：
<dependency>
 <groupId>org.springframework.bootgroupId>
 <artifactId>spring-boot-configuration-processorartifactId>
 <optional>trueoptional>
dependency>
引入依赖之后，重新构建项目（Ctrl+F9），再写自定义配置时，就有提示了

profile

我们在开发Spring Boot应用时，通常同一套程序会被安装到不同环境，比如：开发、测试、生产等。其中数据库地址、服务器端口等等配置都不同，如果每次打包时，都要修改配置文件，那么非常麻烦。profile功能就是来进行动态配置切换的。

1） profile配置方式

多profile文件方式

新建三个配置文件：

application-dev.properties
```
server.port=999
```
application-pro.properties
```
server.port=888
```
application-test.properties
```
server.port=777
```
在application.properties设置如下：
```
spring.profiles.active=dev
```
启动项目，如下：

yml多文档方式

新建application.yml

---
server:
  port: 999

spring:
  profiles: dev
---
server:
  port: 888

spring:
  profiles: pro

---
server:
  port: 777

spring:
  profiles: test

修改application.properties

spring.profiles.active=pro

启动项目，如下：

2） profile激活方式

配置文件

如上，使用spring.profiles.active=dev来激活
虚拟机参数

编辑配置，填入vm选项，如下：

启动项目，如下：
命令行参数

在编辑配置里面，点击修改选项，勾选程序实参，并填入如下：

启动项目，如下：

将项目打包成jar包，在Maven处点击package：

运行如下：

使用cmd打开E:\IdeaProjects\SpringBoot\profile\target，输入如下命令：java -jar profile-0.0.1-SNAPSHOT.jar --spring.profiles.active=pro

小结

1） profile是用来完成不同环境下，配置动态切换功能的。

2） profile配置方式

多profile文件方式：提供多个配置文件，每个代表一种环境。
- application-dev.properties/yml 开发环境
- application-test.properties/yml 测试环境
- application-pro.properties/yml 生产环境
yml多文档方式：
- 在yml中使用 — 分隔不同配置

3） profile激活方式

配置文件：再配置文件中配置：spring.profiles.active=dev
虚拟机参数：在VM options 指定：-Dspring.profiles.active=dev
命令行参数：java –jar xxx.jar --spring.profiles.active=dev

内部配置加载顺序

Springboot程序启动时，会从以下位置加载配置文件：

file:./config/：当前项目下的/config目录下
file:./ ：当前项目的根目录
classpath:/config/：classpath的/config目录
classpath:/ ：classpath的根目录

加载顺序为上文的排列顺序，高优先级配置的属性会生效

外部配置加载顺序

通过官网查看外部属性加载顺序： https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html

1）命令行方式

将项目使用Maven打包成jar包，并在jar包位置打开cmd，复制‪E:\IdeaProjects\application.properties到任意目录，此处放在‪E:\IdeaProjects\application.properties

此处使用了项目外部的配置，如端口号使用的是外部配置的端口号

2）置于同级目录

将application.properties放到项目被打包成jar的目录，使其位于同级；即配置文件和jar包同一级目录会被自动读取

重新在cmd运行，不带参数

在项目jar包的同级目录下，新建一个config目录，将配置文件放于此目录，也会被自动读取

config目录比根目录优先级高

整合JUnit ① 搭建SpringBoot工程

使用Spring Initializr快速构建空项目

② 引入junit依赖

在pom.xml中引入：

<dependency>
    <groupId>junitgroupId>
    <artifactId>junitartifactId>
    <scope>testscope>
dependency>

③ 编写Service类

创建UserService和

package com.example.junit.service;

import org.springframework.stereotype.Service;

@Service
public class UserService {

    public void addUser(){
        System.out.println("add user");
    }

}

④ 添加测试类、测试方法和相关注解

• @RunWith(SpringRunner.class)

• @SpringBootTest

package com.example.junit;

import com.example.junit.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserServiceTest {
    @Autowired
    private UserService userService;

    @Test
    public void testAddUser() {
        userService.addUser();
    }

}

包名相同不需要为@SpringBootTest指定属性，若不同包，需要指定classes = 启动类.class

最新版不需要@RunWith注解

⑤ 测试运行

整合Redis ① 搭建SpringBoot工程

使用Spring Initializr快速构建，并勾选如下依赖：

② 引入redis依赖

使用Spring Initializr勾选redis依赖，即可自动引入，也可以手动在pom.xml引入：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-data-redisartifactId>
dependency>

③ 修改测试类、添加测试方法

package com.aiw.redis;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

@SpringBootTest
class RedisApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void testSet() {
        // 存入数据
        redisTemplate.boundValueOps("name").set("zhangsan");
    }

    @Test
    public void testGet() {
        // 获取数据
        Object name = redisTemplate.boundValueOps("name").get();
        System.out.println(name);
    }

}

④ 启动redis

找到redis目录，双击redis-server.exe即可启动；redis端口默认为6379

⑤ 测试运行

依次运行testSet()、testGet()

在application.yml中可以配置如下属性：
spring:
redis:
 host: localhost # redis的主机ip，默认
 port: 6379 # redis的端口，默认
 password: # redis的密码，默认为空
redis其它配置信息，参考官网Common Application Properties (spring.io)

整合MyBatis ① 搭建SpringBoot工程

使用Spring Initializr快速构建，并勾选如下依赖：

② 引入mybatis、mysql依赖

使用Spring Initializr勾选mybatis、mysql依赖，即可自动引入，也可以手动在pom.xml引入：

<dependency>
    <groupId>org.mybatis.spring.bootgroupId>
    <artifactId>mybatis-spring-boot-starterartifactId>
    <version>2.2.2version>
dependency>

<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
    <scope>runtimescope>
dependency>

虽说高版本mysql驱动兼容低版本，但是此处任采用自定义驱动版本，不使用默认的8.0+版本；个人装的是mysql5.0+版本，故在pom.xml中添加如下：

<properties>
    <java.version>17java.version>
    
    <mysql.version>5.1.40mysql.version>
properties>

③ 创建表

④ 创建POJO类

为简化实体类代码，此处使用Lombok，在pom.xml引入Lombok依赖和在IDEA中安装Lombok插件（IDEA高版本自带）

<dependency>
    <groupId>org.projectlombokgroupId>
    <artifactId>lombokartifactId>
    <optional>trueoptional>
dependency>

创建User实体类

package com.aiw.mybatis.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private Integer id;
    private String username;
    private String password;
    private Integer age;
    private String sex;
    private String email;
}

⑤ 配置信息

在application.yml中添加如下：

spring:
  # 配置数据源信息
  datasource:
    # 配置连接数据库的各个信息
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8&useSSL=false
    username: root
    password: 123456

mysql5.0+和mysql8.0+连接数据库的驱动名不同：

mysql5.0+：com.mysql.jdbc.Driver

mysql8.0+：com.mysql.cj.jdbc.Driver

⑥ 使用纯注解

创建Mapper

package com.aiw.mybatis.mapper;

import com.aiw.mybatis.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.util.List;

@Mapper
public interface UserMapper {
    @Select("select * from t_user")
    public List<User> selectAll();
}

在主程序上添加@MapperScan注解是一样效果，此时需去掉Mapper接口上的@Mapper注解：

@MapperScan("com.aiw.mybatis.mapper")
@SpringBootApplication
public class MybatisApplication {

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

}

修改测试类

package com.aiw.mybatis;

import com.aiw.mybatis.mapper.UserMapper;
import com.aiw.mybatis.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
class MybatisApplicationTests {
    @Autowired(required = false)
    private UserMapper userMapper;

    @Test
    public void testSelectAll() {
        List<User> users = userMapper.selectAll();
        users.forEach(System.out::println);
    }

}

测试运行

⑦ 使用xml

创建Mapper

package com.aiw.mybatis.mapper;

import com.aiw.mybatis.pojo.User;
import org.apache.ibatis.annotations.Select;

import java.util.List;

public interface UserXmlMapper {
    public List<User> selectAll();
}

创建映射文件，路径为src/main/resources/mapper/UserMapper.xml


DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.aiw.mybatis.mapper.UserXmlMapper">
    <select id="selectAll" resultType="User">
        select * from t_user
    select>
mapper>

有关MyBatis使用XML更多 *** 作，参考前期博客：MyBatis

在主程序上添加@MapperScan注解

@MapperScan("com.aiw.mybatis.mapper")
@SpringBootApplication
public class MybatisApplication {

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

}

在application.yml添加配置属性

mybatis:
#  config-location: classpath:mybatis-config.xml # mybatis核心配置文件路径
  mapper-locations: classpath:mapper/*.xml  # mapper映射文件路径
  type-aliases-package: com.aiw.mybatis.pojo # 实体类所在包，指定别名

修改测试类

package com.aiw.mybatis;

import com.aiw.mybatis.mapper.UserXmlMapper;
import com.aiw.mybatis.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
class MybatisApplicationTests {

    @Autowired(required = false)
    private UserXmlMapper userXmlMapper;

    @Test
    public void testSelectAll2() {
        List<User> users = userXmlMapper.selectAll();
        users.forEach(System.out::println);
    }

}

测试运行

整合MyBatis Plus ① 搭建SpringBoot工程

使用Spring Initializr快速构建空项目

② 引入mybatis-plus、mysql依赖

在pom.xml中引入：


<dependency>
    <groupId>com.baomidougroupId>
    <artifactId>mybatis-plus-boot-starterartifactId>
    <version>3.5.1version>
dependency>

<dependency>
    <groupId>org.projectlombokgroupId>
    <artifactId>lombokartifactId>
    <optional>trueoptional>
dependency>

<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
    <scope>runtimescope>
dependency>

指定MySQL默认版本，故在pom.xml中添加如下：

<properties>
    <java.version>17java.version>
    
    <mysql.version>5.1.40mysql.version>
properties>

③ 创建表

④ 创建POJO类

package com.aiw.mybatisplus.pojo;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@TableName("t_user")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
    private Integer sex;
    @TableField("is_deleted")
    @TableLogic
    private Integer isDeleted;
}

⑤ 配置信息

在application.yml中添加如下：

spring:
  # 配置数据源信息
  datasource:
    # 配置数据源类型
    type: com.zaxxer.hikari.HikariDataSource
    # 配置连接数据库的各个信息
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatis_plus?characterEncoding=utf-8&useSSL=false
    username: root
    password: 123456

MyBatis Plus其它配置信息，参考官网使用配置 | MyBatis-Plus (baomidou.com)

⑥ 添加mapper

package com.aiw.mybatisplus.mapper;

import com.aiw.mybatisplus.pojo.User;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

public interface UserMapper extends BaseMapper<User> {
}

BaseMapper是MyBatis-Plus提供的模板mapper，其中包含了基本的CRUD方法，泛型为 *** 作的实体类型

MyBatis Plus更多 *** 作，参考前期博客：MyBatis-Plus

⑦ 启动类

在主程序上添加@MapperScan注解

@MapperScan("com.aiw.mybatisplus.mapper")
@SpringBootApplication
public class MybatisPlusApplication {

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

}

在Spring Boot启动类中添加@MapperScan注解，扫描mapper包

实际上在mapper接口上面加个@Mapper注解也能做到

⑧ 测试

修改测试类，如下：

package com.aiw.mybatisplus;

import com.aiw.mybatisplus.mapper.UserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class MybatisPlusApplicationTests {
    @Autowired(required = false)
    private UserMapper userMapper;

    @Test
    public void testSelectList() {
        userMapper.selectList(null).forEach(System.out::println);
    }

}

整合Thymeleaf ① 搭建SpringBoot工程

使用Spring Initializr快速构建，并勾选如下依赖：

② 引入thymeleaf依赖

使用Spring Initializr勾选spring web、thymeleaf依赖，即可自动引入，也可以手动在pom.xml引入：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-thymeleafartifactId>
dependency>
<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-webartifactId>
dependency>

③ 配置信息

在application.yml中添加如下：

spring:
  thymeleaf:
    prefix: classpath:templates/ # 默认路径
    suffix: .html # 后缀
    mode: HTML5 # 模式，支持HTML5 HTML XML TEXT JAVASCRIPT
    cache: false # 缓存，开发时关闭缓存,不然没法看到实时页面
    encoding: UTF-8 # 编码，默认UTF-8
    servlet:
      content-type: text/html # 内容类别,可不用配置

④ 创建控制器

package com.aiw.thymeleaf.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class ThymeleafController {

    @RequestMapping("/")
    public ModelAndView thymeleaf() {
        ModelAndView mv = new ModelAndView("index");    // 设置视图名称
        mv.addObject("name", "Hello Thymeleaf");    // 设置视图数据
        return mv;
    }

}

域对象共享数据，更多方式参考前期博客：SpringMVC–域对象共享数据

⑤ 创建视图

在 templates 目录下创建 index.html 文件，代码如下：

DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>SpringBoot整合Thymeleaf小案例title>
head>
<body>
    <h1 th:text="${name}">h1>
body>
html>

⑥ 测试

启动成功后，访问：http://localhost:8080/ 即可看到效果如下：

整合Logback/Log4j2

Spring Boot默认使用Logback作为日志框架。若使用其它日志框架，首先排除Spring Boot自带的Logback

Logback ① 搭建SpringBoot工程

使用Spring Initializr快速构建空项目

② 引入logback依赖

由于logback为Spring Boot默认日志框架，故无需引入依赖

③ 配置信息

Logback默认配置步骤：

尝试在 classpath 下查找文件 logback-test.xml；
如果文件不存在，则查找文件 logback.xml；
如果两个文件都不存在，logback 用 BasicConfigurator 自动对自己进行配置，这会导致记录输出到控制台

在application.yml中添加如下：

logging:
  config: classpath:logback-test.xml  # logback默认配置文件名

④ logback配置文件

在resources目录下新建logback-test.xml配置文件


<configuration scan="true" scanPeriod="2 seconds" debug="false">
    
    <property name="LOG_PATH" value="./logs" />
    <property name="LOG_HISTORY_PATH" value="./logs/history" />
    
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level ${PID:-} --- [%t] %logger{50} - %msg%npattern>
        encoder>
    appender>

    
    <appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        
        <File>${LOG_PATH}/info.logFile>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            
            <fileNamePattern>${LOG_PATH}/info-%d{yyyy-MM-dd}.%i.logfileNamePattern>
            
            <maxHistory>30maxHistory>
            
            <maxFileSize>100MBmaxFileSize>
        rollingPolicy>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level ${PID:-} --- [%t] %logger{50} - %msg%npattern>
        encoder>
    appender>

    
    <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>ERRORlevel>
        filter>
        <File>${LOG_PATH}/error.logFile>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>${LOG_PATH}/error-%d{yyyy-MM-dd}.%i.logfileNamePattern>
            <maxHistory>30maxHistory>
            <maxFileSize>100MBmaxFileSize>
        rollingPolicy>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level ${PID:-} --- [%t] %logger{50} - %msg%npattern>
        encoder>
    appender>

    <appender name="fileAppender" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${LOG_HISTORY_PATH}/project-id-execution-detail-info.logfile>
        <encoder>
            <charset>UTF-8charset>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} %-5level ${PID:-} --- [%t] %logger{50} - %msg%npattern>
        encoder>
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>INFOlevel>
        filter>
    appender>

    
    <root level="INFO">
        <appender-ref ref="STDOUT" />
        <appender-ref ref="INFO_FILE" />
        <appender-ref ref="ERROR_FILE" />
    root>

configuration>

⑤ 测试方式一

不使用lombok插件，直接使用。修改测试类，如下：

package com.aiw.logback;


import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class LogbackApplicationTests {

    private static final Logger logger= LoggerFactory.getLogger(LogbackApplicationTests.class);

    @Test
    public void LogbackTest() {
        logger.info("Info level log message");
        logger.debug("Debug level log message");
        logger.error("Error level log message");
    }

}

运行结果：

方式二

使用lombok插件，简化代码。在pom.xml引入Lombok依赖和在IDEA中安装Lombok插件（IDEA高版本自带）


<dependency>
    <groupId>org.projectlombokgroupId>
    <artifactId>lombokartifactId>
    <optional>trueoptional>
dependency>

在需要打印日志的类上添加@Slf4j注解，然后通过log.输出日志。修改测试类，如下：

package com.aiw.logback;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@Slf4j
@SpringBootTest
class LogbackApplicationTests {

    @Test
    public void LogbackTest() {
        log.info("Info level log message");
        log.debug("Debug level log message");
        log.error("Error level log message");
    }

}

运行结果：

Log4j2 ① 搭建SpringBoot工程

使用Spring Initializr快速构建空项目

② 引入log4j2依赖

引入依赖时，需要首先排除Spring Boot自带的Logback，然后在添加log4j2的依赖；pom.xml中部分修改如下：

<dependencies>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starterartifactId>
        
        <exclusions>
            <exclusion>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-loggingartifactId>
            exclusion>
        exclusions>
    dependency>

    
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-log4j2artifactId>
    dependency>

    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-testartifactId>
        <scope>testscope>
        
        <exclusions>
            <exclusion>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-loggingartifactId>
            exclusion>
        exclusions>
    dependency>
dependencies>

③ 配置信息

在application.yml中添加如下：

logging:
  config: classpath:log4j2-spring.xml # log4j2默认配置文件名

④ log4j2配置文件

在resources目录下新建log4j2-spring.xml配置文件




<configuration monitorInterval="5">
    

    
    <Properties>
        
        
        <property name="LOG_PATTERN" value="%date{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n" />
        
        
        <property name="FILE_PATH" value="logs/log.log" />
        
        <property name="FILE_NAME" value="learn" />
    Properties>

    <appenders>

        <console name="Console" target="SYSTEM_OUT">
            
            <PatternLayout pattern="${LOG_PATTERN}"/>
            
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
        console>

        
        <File name="Filelog" fileName="${FILE_PATH}/test.log" append="false">
            <PatternLayout pattern="${LOG_PATTERN}"/>
        File>

        
        <RollingFile name="RollingFileInfo" fileName="${FILE_PATH}/info.log" filePattern="${FILE_PATH}/${FILE_NAME}-INFO-%d{yyyy-MM-dd}_%i.log.gz">
            
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            Policies>
            
            <DefaultRolloverStrategy max="15"/>
        RollingFile>

        
        <RollingFile name="RollingFileWarn" fileName="${FILE_PATH}/warn.log" filePattern="${FILE_PATH}/${FILE_NAME}-WARN-%d{yyyy-MM-dd}_%i.log.gz">
            
            <ThresholdFilter level="warn" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            Policies>
            
            <DefaultRolloverStrategy max="15"/>
        RollingFile>

        
        <RollingFile name="RollingFileError" fileName="${FILE_PATH}/error.log" filePattern="${FILE_PATH}/${FILE_NAME}-ERROR-%d{yyyy-MM-dd}_%i.log.gz">
            
            <ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            Policies>
            
            <DefaultRolloverStrategy max="15"/>
        RollingFile>

    appenders>

    
    
    <loggers>

        
        <logger name="org.mybatis" level="info" additivity="false">
            <AppenderRef ref="Console"/>
        logger>
        
        
        <Logger name="org.springframework" level="info" additivity="false">
            <AppenderRef ref="Console"/>
        Logger>

        <root level="info">
            <appender-ref ref="Console"/>
            <appender-ref ref="Filelog"/>
            <appender-ref ref="RollingFileInfo"/>
            <appender-ref ref="RollingFileWarn"/>
            <appender-ref ref="RollingFileError"/>
        root>
    loggers>

configuration>

⑤ 测试方式一

不使用lombok插件，直接使用。修改测试类，如下：

package com.aiw.log4j2;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class Log4j2ApplicationTests {
    private static final Logger logger= LogManager.getLogger(Log4j2ApplicationTests.class);

    @Test
    public void Log4j2Test() {
        logger.info("Info level log message");
        logger.debug("Debug level log message");
        logger.error("Error level log message");
    }

}

运行结果：

方式二

使用lombok插件，简化代码。在pom.xml引入Lombok依赖和在IDEA中安装Lombok插件（IDEA高版本自带）


<dependency>
    <groupId>org.projectlombokgroupId>
    <artifactId>lombokartifactId>
    <optional>trueoptional>
dependency>

在需要打印日志的类上添加@Slf4j注解，然后通过log.输出日志。修改测试类，如下：

package com.aiw.log4j2;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@Slf4j
@SpringBootTest
class Log4j2ApplicationTests {

    @Test
    public void Log4j2Test() {
        log.info("Info level log message");
        log.debug("Debug level log message");
        log.error("Error level log message");
    }

}

运行结果：

整合Jackson/FastJson/Gson

Spring Boot默认使用Jackson作为Json解析技术框架；若使用其它两种，首先排除Spring Boot自带的Jackson

Jackson ① 搭建SpringBoot工程

使用Spring Initializr快速构建，并勾选如下依赖：

② 引入jackson依赖

使用Spring Initializr勾选spring web、lombok依赖，即可自动引入，也可以手动在pom.xml引入：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-webartifactId>
dependency>

<dependency>
    <groupId>org.projectlombokgroupId>
    <artifactId>lombokartifactId>
    <optional>trueoptional>
dependency>

③ 创建POJO类

为简化实体类代码，此处使用Lombok，在pom.xml引入Lombok依赖和在IDEA中安装Lombok插件（IDEA高版本自带）

<dependency>
    <groupId>org.projectlombokgroupId>
    <artifactId>lombokartifactId>
    <optional>trueoptional>
dependency>

创建Book实体类

package com.aiw.jackson.pojo;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Book {
    private String name;
    private String author;
    @JsonIgnore
    private Double price;
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private Date publishDate;
}

@JsonIgnore：转换json的时候忽略此属性

@JsonFormat(pattern = “yyyy-MM-dd HH:mm:ss”)：对该属性的值进行格式化

④ 创建控制器

package com.aiw.jackson.controller;

import com.aiw.jackson.pojo.Book;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;

@RestController
public class BookController {

    @RequestMapping(value = "/book", method = RequestMethod.POST)
    public Book book() {
        return new Book("Java", "Aiw", 16.0, new Date());
    }

}

⑤ 测试

启动项目，使用ApiPost进行测试接口，如下：

FastJson

fastjson是阿里巴巴的一个开源JSON解析框架，是目前JSON解析速度最快的开源框架。

① 搭建SpringBoot工程

使用Spring Initializr快速构建，并勾选如下依赖：

② 引入fastjson依赖

需要首先排除Spring Boot自带的Jackson，再引入fastjson依赖，pom.xml中部分修改如下：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-webartifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-jsonartifactId>
        exclusion>
    exclusions>
dependency>

<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>fastjsonartifactId>
    <version>1.2.80version>
dependency>

③ 创建配置类方式一：返回新的HttpMessageConverter

package com.aiw.fastjson.config;

import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;

import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;

@Configuration
public class FastJsonConfig {
    @Bean
    public FastJsonHttpMessageConverter fastJsonHttpMessageConverter() {
        FastJsonHttpMessageConverter converter = new FastJsonHttpMessageConverter();
        List<MediaType> supportedMediaTypes = new ArrayList<>();
        supportedMediaTypes.add(MediaType.APPLICATION_JSON);
        supportedMediaTypes.add(MediaType.APPLICATION_ATOM_XML);
        supportedMediaTypes.add(MediaType.APPLICATION_FORM_URLENCODED);
        supportedMediaTypes.add(MediaType.APPLICATION_OCTET_STREAM);
        supportedMediaTypes.add(MediaType.APPLICATION_PDF);
        supportedMediaTypes.add(MediaType.APPLICATION_RSS_XML);
        supportedMediaTypes.add(MediaType.APPLICATION_XHTML_XML);
        supportedMediaTypes.add(MediaType.APPLICATION_XML);
        supportedMediaTypes.add(MediaType.IMAGE_GIF);
        supportedMediaTypes.add(MediaType.IMAGE_JPEG);
        supportedMediaTypes.add(MediaType.IMAGE_PNG);
        supportedMediaTypes.add(MediaType.TEXT_EVENT_STREAM);
        supportedMediaTypes.add(MediaType.TEXT_HTML);
        supportedMediaTypes.add(MediaType.TEXT_MARKDOWN);
        supportedMediaTypes.add(MediaType.TEXT_PLAIN);
        supportedMediaTypes.add(MediaType.TEXT_XML);
        converter.setSupportedMediaTypes(supportedMediaTypes);
        //自定义配置...
        com.alibaba.fastjson.support.config.FastJsonConfig config = new com.alibaba.fastjson.support.config.FastJsonConfig();
        config.setCharset(StandardCharsets.UTF_8);
        config.setDateFormat("yyyy-MM-dd HH:mm:ss");
        converter.setFastJsonConfig(config);
        converter.setDefaultCharset(StandardCharsets.UTF_8);
        return converter;
    }
}

方式二：实现WebMvcConfigurer接口

package com.aiw.fastjson.config;

import com.alibaba.fastjson.support.config.FastJsonConfig;
import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        FastJsonHttpMessageConverter converter = new FastJsonHttpMessageConverter();
        List<MediaType> supportedMediaTypes = new ArrayList<>();
        supportedMediaTypes.add(MediaType.APPLICATION_JSON);
        supportedMediaTypes.add(MediaType.APPLICATION_ATOM_XML);
        supportedMediaTypes.add(MediaType.APPLICATION_FORM_URLENCODED);
        supportedMediaTypes.add(MediaType.APPLICATION_OCTET_STREAM);
        supportedMediaTypes.add(MediaType.APPLICATION_PDF);
        supportedMediaTypes.add(MediaType.APPLICATION_RSS_XML);
        supportedMediaTypes.add(MediaType.APPLICATION_XHTML_XML);
        supportedMediaTypes.add(MediaType.APPLICATION_XML);
        supportedMediaTypes.add(MediaType.IMAGE_GIF);
        supportedMediaTypes.add(MediaType.IMAGE_JPEG);
        supportedMediaTypes.add(MediaType.IMAGE_PNG);
        supportedMediaTypes.add(MediaType.TEXT_EVENT_STREAM);
        supportedMediaTypes.add(MediaType.TEXT_HTML);
        supportedMediaTypes.add(MediaType.TEXT_MARKDOWN);
        supportedMediaTypes.add(MediaType.TEXT_PLAIN);
        supportedMediaTypes.add(MediaType.TEXT_XML);
        converter.setSupportedMediaTypes(supportedMediaTypes);
        //自定义配置...
        FastJsonConfig config = new FastJsonConfig();
        config.setCharset(StandardCharsets.UTF_8);
        config.setDateFormat("yyyy-MM-dd HH:mm:ss");
        converter.setFastJsonConfig(config);
        converter.setDefaultCharset(StandardCharsets.UTF_8);
        // SpringBoot 2.0.1版本中加载WebMvcConfigurer的顺序发生了变动，
        // 故需使用converters.add(0, converter)指定FastJsonHttpMessageConverter在converters内的顺序
        // 否则在SpringBoot 2.0.1及之后的版本中将优先使用Jackson处理。
        converters.add(0, converter);
    }

}

FastJson2.0以上版本无法使用该配置类，暂未知

④ 创建POJO类

package com.aiw.fastjson.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Book {
    private String name;
    private String author;
    private Double price;
    private Date publishDate;
}

⑤ 创建控制器

package com.aiw.fastjson.controller;

import com.aiw.fastjson.pojo.Book;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;

@RestController
public class BookController {

    @RequestMapping(value = "/book", method = RequestMethod.POST)
    public Book book() {
        return new Book("PHP", "Aiw", 11.0, new Date());
    }

}

⑥ 测试

启动项目，使用ApiPost进行测试接口，如下：

Gson

Gson是Google的一个开源JSON解析框架。

① 搭建SpringBoot工程

使用Spring Initializr快速构建，并勾选如下依赖：

② 引入gson依赖

需要首先排除Spring Boot自带的Jackson，再引入gson依赖，pom.xml中部分修改如下：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-webartifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-jsonartifactId>
        exclusion>
    exclusions>
dependency>


<dependency>
    <groupId>com.google.code.gsongroupId>
    <artifactId>gsonartifactId>
dependency>

③ 创建配置类方式一：返回新的HttpMessageConverter

package com.aiw.gson.config;

import com.google.gson.GsonBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.json.GsonHttpMessageConverter;

import java.lang.reflect.Modifier;

@Configuration
public class GsonConfig {
    @Bean
    public GsonHttpMessageConverter gsonHttpMessageConverter() {
        //Spring提供了Gson的转换器对象
        GsonHttpMessageConverter converter = new GsonHttpMessageConverter();
        //创建Gson的构建器，通过构建器设置Gson的相关设置
        GsonBuilder gsonBuilder = new GsonBuilder();
        //设置Gson转化时间的格式
        gsonBuilder.setDateFormat("yyyy-MM-dd HH:mm:ss");
        //Gson解析时，它将会过滤被protected修饰的属性
        gsonBuilder.excludeFieldsWithModifiers(Modifier.PROTECTED);
        //创建Gson对象，并传递给转化器
        converter.setGson(gsonBuilder.create());
        return converter;
    }
}

方式二：实现WebMvcConfigurer接口

package com.aiw.gson.config;

import com.google.gson.GsonBuilder;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.GsonHttpMessageConverter;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import java.lang.reflect.Modifier;
import java.util.List;

public class WebConfig implements WebMvcConfigurer {
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        //Spring提供了Gson的转换器对象
        GsonHttpMessageConverter converter = new GsonHttpMessageConverter();
        //创建Gson的构建器，通过构建器设置Gson的相关设置
        GsonBuilder gsonBuilder = new GsonBuilder();
        //设置Gson转化时间的格式
        gsonBuilder.setDateFormat("yyyy-MM-dd HH:mm:ss");
        //Gson解析时，它将会过滤被protected修饰的属性
        gsonBuilder.excludeFieldsWithModifiers(Modifier.PROTECTED);
        //创建Gson对象，并传递给转化器
        converter.setGson(gsonBuilder.create());
        converters.add(0, converter);
    }
}

方式二设置日期格式在实际测试中并未生效，暂未知原因；推荐使用方式一

④ 创建POJO类

package com.aiw.gson.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Book {
    private String name;
    private String author;
    private Double price;
    private Date publishDate;
}

⑤ 创建控制器

package com.aiw.gson.controller;

import com.aiw.gson.pojo.Book;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;

@RestController
public class BookController {

    @RequestMapping(value = "/book", method = RequestMethod.POST)
    public Book book() {
        return new Book("Python", "Aiw", 9.0, new Date());
    }

}

⑥ 测试

启动项目，使用ApiPost进行测试接口，如下：

解决跨域方式一：返回新的CorsFilter（全局跨域）

package com.aiw.cors.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;

import java.util.Arrays;


@Configuration
public class CorsConfig {
    @Bean
    public CorsFilter corsFilter() {
        //1. 添加 CORS配置信息
        CorsConfiguration config = new CorsConfiguration();
        //放行哪些原始域
        config.addAllowedOrigin("*");
        //放行哪些请求方式
        config.addAllowedMethod("*");
        //放行哪些原始请求头部信息
        config.addAllowedHeader("*");
        //暴露哪些头部信息
        config.addExposedHeader("*");
        //2. 添加映射路径
        UrlBasedCorsConfigurationSource corsConfigurationSource = new UrlBasedCorsConfigurationSource();
        corsConfigurationSource.registerCorsConfiguration("/**",config);
        //3. 返回新的CorsFilter
        return new CorsFilter(corsConfigurationSource);
    }
}

方式二：实现WebMvcConfigurer接口（全局跨域）

package com.aiw.cors.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                .allowedHeaders("*")
                .allowedOrigins("*")
                .exposedHeaders("*")
                .allowedMethods("*")
                .maxAge(3600);  // 默认为 1800 秒
    }
}

方式三：使用注解 @CrossOrigin（局部跨域）

① 在控制器上添加@CrossOrigin注解，那么该控制器下的所有方法都支持跨域。

package com.aiw.cors.controller;

import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@CrossOrigin
@RestController
public class CorsController {
    @RequestMapping(value = "/cors", method = RequestMethod.POST)
    public String test() {
        return "test cors";
    }
}

② 直接在相应的请求方法上添加@CrossOrigin注解，那么该方法则支持跨域。

package com.aiw.cors.controller;

import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class CorsController {
    @CrossOrigin
    @RequestMapping(value = "/cors", method = RequestMethod.POST)
    public String test() {
        return "test cors";
    }
}

参考博客：SpringBoot解决跨域的5种方式

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/868476.html

SpringBoot快速入门--基础版（包含整合常用框架、跨域）

发表评论

评论列表（0条）