Spring_Cloud

说明

Test 模块微服务，将注册到 Nacos，对外提供接口服务；

搭建 Maven 子模块项目

参见 Tool_IDE 创建 alibaba_service_test；

Pom 依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.sfac</groupId>
    <artifactId>spring_cloud_alibaba_test</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring_cloud_alibaba_test</name>
    <description>Demo project for Spring Cloud Test</description>

<parent>
        <artifactId>spring_cloud_alibaba</artifactId>
        <groupId>org.sfac</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>

<dependencies>
        
        <dependency>
            <groupId>org.sfac</groupId>
            <artifactId>spring_cloud_alibaba_entity</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

<dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

<dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            
        </dependency>

<dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>
        
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.4.1</version>
        </dependency>

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

 
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.sfac</groupId>
    <artifactId>spring_cloud_alibaba_test</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring_cloud_alibaba_test</name>
    <description>Demo project for Spring Cloud Test</description>
    <parent>
        <artifactId>spring_cloud_alibaba</artifactId>
        <groupId>org.sfac</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <properties>
        <java.version>11</java.version>
    </properties>
    <dependencies>
        <!-- entity -->
        <dependency>
            <groupId>org.sfac</groupId>
            <artifactId>spring_cloud_alibaba_entity</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!-- nacos-discovery -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!-- mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <!-- <version>5.1.47</version>-->
        </dependency>
        <!-- mybatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>
        <!-- pagehelper -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.4.1</version>
        </dependency>
        <!-- test -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

配置

application.properties

创建 resources 源文件夹：项目右键 ---- properties ---- Java Build Path ---- Source ---- 添加 resources；
resources 下添加 application.properties || application.yml 全局配置文件；
注册应用名不要使用下划线，Feign 不支持下划线格式；

1
# for server server.port=8761 # for nacos discovery spring.application.name=alibaba-service-test spring.cloud.nacos.discovery.server-addr=127.0.0.1:8848
1
# for server
2
server.port=8761
3
4
# for nacos discovery
5
spring.application.name=alibaba-service-test
6
spring.cloud.nacos.discovery.server-addr=127.0.0.1:8848
2

启动类添加 @EnableDiscoveryClient 注解

应用

移植 Test 模块接口；
启动项目；
访问 Nacos 服务列表：http://127.0.0.1:8848/nacos，微服务注册成功；

接口测试：127.0.0.1:8761/api/test/city/1980

Service Module Account

说明

Account 模块微服务，将注册到 Nacos，对外提供接口服务；

搭建 Maven 子模块项目

参见 Tool_IDE 创建 alibaba_service_account；

Pom 依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.sfac</groupId>
    <artifactId>spring_cloud_alibaba_account</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring_cloud_alibaba_account</name>
    <description>Demo project for Spring Boot</description>

<parent>
        <artifactId>spring_cloud_alibaba</artifactId>
        <groupId>org.sfac</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>

<dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

<dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            
        </dependency>

 
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.sfac</groupId>
    <artifactId>spring_cloud_alibaba_account</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring_cloud_alibaba_account</name>
    <description>Demo project for Spring Boot</description>
    <parent>
        <artifactId>spring_cloud_alibaba</artifactId>
        <groupId>org.sfac</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <properties>
        <java.version>11</java.version>
    </properties>
    <dependencies>
        <!-- entity -->
        <dependency>
            <groupId>org.sfac</groupId>
            <artifactId>spring_cloud_alibaba_entity</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!-- nacos-discovery -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!-- mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <!-- <version>5.1.47</version>-->
        </dependency>
        <!-- mybatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>
        <!-- pagehelper -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.4.1</version>
        </dependency>
        <!-- test -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

配置

application.properties

创建 resources 源文件夹：项目右键 ---- properties ---- Java Build Path ---- Source ---- 添加 resources；
resources 下添加 application.properties || application.yml 全局配置文件；
应用注册名不要使用下划线连接，Feign 不支持下划线格式；
1
# for server server.port=8763 # for nacos discovery spring.application.name=alibaba-service-account spring.cloud.nacos.discovery.server-addr=127.0.0.1:8848
1
# for server
2
server.port=8763
3
4
# for nacos discovery
5
spring.application.name=alibaba-service-account
6
spring.cloud.nacos.discovery.server-addr=127.0.0.1:8848
2

启动类添加 @EnableDiscoveryClient 注解；

应用

移植接口；
启动项目；
访问 Nacos 服务列表：http://127.0.0.1:8848/nacos，微服务注册成功；

接口测试：127.0.0.1:8763/api/account/user/1

配置中心

说明

Nacos 除了微服务的注册与发现之外，还将配置中心整合在了一起，我们可以将整个架构体系内的所有配置都集中在 Nacos 中存储；
我们将改造微服务 Service Module Test 和 Service Module Account；

Service Module Account

Pom 依赖

1
 <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId> </dependency>  <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-bootstrap</artifactId> </dependency>
1

2
<dependency>
3
<groupId>com.alibaba.cloud</groupId>
4
<artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
5
</dependency>
6
7

8
<dependency>
9
<groupId>org.springframework.cloud</groupId>
10
<artifactId>spring-cloud-starter-bootstrap</artifactId>
11
</dependency>
2

配置

创建 bootstrap.properties 父上下级配置文件，配置以下部分；

1
# for bootstrap spring.cloud.bootstrap.enabled=true # for server server.port=8004 # for spring spring.application.name=alibaba-service-account spring.profiles.active=dev # for nacos discovery spring.cloud.nacos.discovery.server-addr=127.0.0.1:8848 spring.cloud.nacos.config.server-addr=127.0.0.1:8848 spring.cloud.nacos.config.file-extension=properties
1
# for bootstrap
2
spring.cloud.bootstrap.enabled=true
3
4
# for server
5
server.port=8004
6
7
# for spring
8
spring.application.name=alibaba-service-account
9
spring.profiles.active=dev
10
11
# for nacos discovery
12
spring.cloud.nacos.discovery.server-addr=127.0.0.1:8848
13
spring.cloud.nacos.config.server-addr=127.0.0.1:8848
14
spring.cloud.nacos.config.file-extension=properties
2

Nacos 主页创建微服务配置；

http://127.0.0.1:8848/nacos
配置服务 ---- 配置列表 ---- 新建配置；
Data ID：${prefix}-${spring.profiles.active}.${file-extension}

${prefix} ---- 默认 spring.application.name，也可通过 spring.cloud.nacos.config.prefix 配置；
${spring.profiles.active} ---- 环境，通过 spring.profiles.active 配置，若不配置，则没有 -${spring.profiles.active} 这部分；
${file-extension} ---- 文件后缀，通过 spring.cloud.nacos.config.file-extension 配置；

Group：暂时使用默认；

配置内容

application.properties 中，一部分内容移植到了 bootstrap.properties 中，其余部分移植到此处，本案例没有其余配置，故而新增配置测试项；
1
# for test sfac.name=HymanHu sfac.age=18 sfac.random=${random.value}
1
# for test
2
sfac.name=HymanHu
3
sfac.age=18
4
sfac.random=${random.value}
2

application.properties 更名为 applicationBack.properties；

应用

ConfigController

配置测试接口，添加 @RefreshScope 注解，用于自动刷新；

package com.sfac.alibabaServiceAccount.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * Description: Config Controller
 * @author HymanHu
 * @date 2022-03-05 21:51:19
 */
@RestController
@RequestMapping("/api")
@RefreshScope
public class ConfigController {

@Value("${server.port}")
	private int port;
	@Value("${sfac.name}")
	private String name;
	@Value("${sfac.age}")
	private int age;
	@Value("${sfac.random}")
	private String random;
	
	/**
	 * 127.0.0.1:8004/api/config ---- get
	 */
	@GetMapping("/config")
	public String nacosConfig() {
		StringBuffer sb = new StringBuffer();
		sb.append(port).append("----")
			.append(name).append("----")
			.append(age).append("----")
			.append(random);
		return sb.toString();
	}
}

 
package com.sfac.alibabaServiceAccount.controller;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
 * Description: Config Controller
 * @author HymanHu
 * @date 2022-03-05 21:51:19
 */
@RestController
@RequestMapping("/api")
@RefreshScope
public class ConfigController {
    @Value("${server.port}")
    private int port;
    @Value("${sfac.name}")
    private String name;
    @Value("${sfac.age}")
    private int age;
    @Value("${sfac.random}")
    private String random;
    
    /**
     * 127.0.0.1:8004/api/config ---- get
     */
    @GetMapping("/config")
    public String nacosConfig() {
        StringBuffer sb = new StringBuffer();
        sb.append(port).append("----")
            .append(name).append("----")
            .append(age).append("----")
            .append(random);
        return sb.toString();
    }
}

访问：127.0.0.1:8004/api/config
Nacos 修改对应配置文件内容；
再次访问：127.0.0.1:8004/api/config，配置已经刷新；

Service Module Test

改造方式同上；

Group 方案

如果需要自定义分组名称，则在创建配置时指定分组名即可；
bootstrap.properties 添加 spring.cloud.nacos.config.group=* 配置；

NameSpace 方案

Nacos 创建不同的命名空间，自动生成 id；
bootstrap.properties 添加 spring.cloud.nacos.config.namespace=* 配置；

思考

配置虽能自动刷新，但只是值更新，启动服务用到的配置并未重新初始化；

服务调用

说明

Service Module Account 中的 User 接口调用 Service Module Test 中的 City 接口，实现微服务接口调用；
注册中心无论使用 Eureka Server 还是使用 Nacos，对应用层是没有影响的，这归功于 Spring Cloud Common 的封装，它在服务的注册与发现、客户端负载均衡等方面做了很好的抽象，具体实现由各厂商的中间件完成，应用层依赖于这些接口，不会关注具体的实现，就好比于 JDBC 接口，具体由什么数据库实现，应用层并不关心；
调用方式

RestTemplate
OpenFeign
WebClient：Spring 5 引入的 Spring Reative Web 框架，WebClient 相当于 Reative 版的 RestTemplate；

OpenFeign

Pom 依赖

消费者 Service Module Account；
1
 <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-openfeign</artifactId> </dependency>  <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-loadbalancer</artifactId> </dependency>
1

2
<dependency>
3
<groupId>org.springframework.cloud</groupId>
4
<artifactId>spring-cloud-starter-openfeign</artifactId>
5
</dependency>
6
7

8
<dependency>
9
<groupId>org.springframework.cloud</groupId>
10
<artifactId>spring-cloud-loadbalancer</artifactId>
11
</dependency>
2

配置

启动类添加 @EnableFeignClients 注解；

应用

在 service 包下创建 CityFeignClient 接口，用于调用 Service Module Test 微服务接口；

1
package com.sfac.alibabaServiceAccount.service; import org.alibabaEntity.entity.test.City; import org.springframework.cloud.openfeign.FeignClient; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; /** * Description: City Feign Client * @author HymanHu * @date 2022-03-05 10:57:19 */ @FeignClient(name = "alibaba-service-test") public interface CityFeignClient { @GetMapping("/api/city/{id}") public City getCityById(@PathVariable int id); }
1
package com.sfac.alibabaServiceAccount.service;
2
3
import org.alibabaEntity.entity.test.City;
4
import org.springframework.cloud.openfeign.FeignClient;
5
import org.springframework.web.bind.annotation.GetMapping;
6
import org.springframework.web.bind.annotation.PathVariable;
7
8
/**
9
* Description: City Feign Client
10
* @author HymanHu
11
* @date 2022-03-05 10:57:19
12
*/
13
@FeignClient(name = "alibaba-service-test")
14
public interface CityFeignClient {
15
16
@GetMapping("/api/city/{id}")
17
public City getCityById(@PathVariable int id);
18
}
2

UserServiceImpl

 
package com.sfac.alibabaServiceAccount.service.impl;
import java.time.LocalDateTime;
import org.alibabaEntity.entity.account.User;
import org.alibabaEntity.entity.test.City;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.sfac.alibabaServiceAccount.service.CityFeignClient;
import com.sfac.alibabaServiceAccount.service.UserService;
/**
 * Description: User Service Impl
 * @author HymanHu
 * @date 2022-03-04 20:53:54
 */
@Service
public class UserServiceImpl implements UserService {
    
    @Autowired
    private CityFeignClient cityFeignClient;
    @Override
    public User getUserById(int id) {
        User user = new User();
        user.setId(id);
        user.setUserName("HymanHu");
        user.setPassword("1111");
        user.setCreateDate(LocalDateTime.now());
        City city = cityFeignClient.getCityById(id);
        user.setCity(city);
        return user;
    }
}

访问接口：127.0.0.1:8004/api/user/1

负载均衡

说明：

Spring Cloud 2020 之前版本，默认使用 Netflix Ribbon 作为负载均衡器，Nacos 也集成了 Ribbon（很奇怪为啥没有替换掉），但 Spring Cloud 2020 版本之后推荐使用 Spring Cloud Loadbalancer；
Spring Cloud Loadbalancer 介绍参见 Spring_Cloud；

Loadbalancer

微服务多实例

Service Module Test 启动三个实例：8001、8002、8003；
访问 Nacos 服务列表：http://127.0.0.1:8848/nacos，微服务注册成功；

访问 127.0.0.1:8004/api/user/1，刷新页面可见，OpenFeign 使用轮询方式调用 City 接口；

Service Module Account

Pom 依赖

上一步已引入；

配置

CustomLoadBalancerConfig

package com.sfac.alibabaServiceAccount.config;

import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.loadbalancer.core.RandomLoadBalancer;
import org.springframework.cloud.loadbalancer.core.ReactorLoadBalancer;
import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;
import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.core.env.Environment;

/**
 * Description: Custom LoadBalancer Config
 * - 该类不添加 @configuration 注解，因为该类为 @LoadBalancerClient 的属性准备
 * @author HymanHu
 * @date 2022-03-05 15:55:55
 */
public class CustomLoadBalancerConfig {

@Bean
    ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(
            Environment environment, 
            LoadBalancerClientFactory loadBalancerClientFactory) {
        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
        // 在此也可返回自定义负载均衡器
        return new RandomLoadBalancer(
                loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name);
    }
}

 
package com.sfac.alibabaServiceAccount.config;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.loadbalancer.core.RandomLoadBalancer;
import org.springframework.cloud.loadbalancer.core.ReactorLoadBalancer;
import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;
import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.core.env.Environment;
/**
 * Description: Custom LoadBalancer Config
 * - 该类不添加 @configuration 注解，因为该类为 @LoadBalancerClient 的属性准备
 * @author HymanHu
 * @date 2022-03-05 15:55:55
 */
public class CustomLoadBalancerConfig {
    @Bean
    ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(
            Environment environment, 
            LoadBalancerClientFactory loadBalancerClientFactory) {
        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
        // 在此也可返回自定义负载均衡器
        return new RandomLoadBalancer(
                loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name);
    }
}

启动类添加 @LoadBalancerClient 注解；

 
@LoadBalancerClient(name = "alibaba-service-test", configuration = CustomLoadBalancerConfig.class)

应用

启动 Service Module Account，访问 127.0.0.1:8004/api/user/1，刷新页面可见，OpenFeign 使用随机方式调用 City 接口；

网关

Gateway

在此用另外一个项目的示例做说明。
创建 spring_cloud_gateway 子模块。
Pom 依赖

1
 <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId> </dependency>  <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-gateway</artifactId> </dependency>  <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-openfeign</artifactId> </dependency>  <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-loadbalancer</artifactId> </dependency>
1

2
<dependency>
3
<groupId>com.alibaba.cloud</groupId>
4
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
5
</dependency>
6
7

8
<dependency>
9
<groupId>org.springframework.cloud</groupId>
10
<artifactId>spring-cloud-starter-gateway</artifactId>
11
</dependency>
12
13

14
<dependency>
15
<groupId>org.springframework.cloud</groupId>
16
<artifactId>spring-cloud-starter-openfeign</artifactId>
17
</dependency>
18
19

20
<dependency>
21
<groupId>org.springframework.cloud</groupId>
22
<artifactId>spring-cloud-loadbalancer</artifactId>
23
</dependency>
2

application.properties

1
# for server server.port=8000 nacos.server=192.168.31.13 # for nacos discovery spring.application.name=jianghu-gateway spring.cloud.nacos.discovery.server-addr=${nacos.server}:8848 # Gateway 项目不需要 spring web # 方案一：创建单独 Gateway 项目，不引入 web 依赖 # 方案二：设置该项目非 Web 启动 spring.main.web-application-type=reactive # for gateway route # 默认 false，开启后可以通过 ip:port/服务名称/接口地址进行服务转发 #spring.cloud.gateway.discovery.locator.enabled=true # 把服务名转换为小写，Eureka 中默认都是大写，但 Nacos 不会自动转换，所以也可以不写。 #spring.cloud.gateway.discovery.locator.lower-case-service-id=true spring.cloud.gateway.routes[0].id=account-service spring.cloud.gateway.routes[0].uri=lb://jianghu-account spring.cloud.gateway.routes[0].predicates[0]=Path=/api/account/** spring.cloud.gateway.routes[1].id=common-service spring.cloud.gateway.routes[1].uri=lb://jianghu-common spring.cloud.gateway.routes[1].predicates[0]=Path=/api/common/**
1
# for server
2
server.port=8000
3
nacos.server=192.168.31.13
4
5
# for nacos discovery
6
spring.application.name=jianghu-gateway
7
spring.cloud.nacos.discovery.server-addr=${nacos.server}:8848
8
9
# Gateway 项目不需要 spring web
10
# 方案一：创建单独 Gateway 项目，不引入 web 依赖
11
# 方案二：设置该项目非 Web 启动
12
spring.main.web-application-type=reactive
13
14
# for gateway route
15
# 默认 false，开启后可以通过 ip:port/服务名称/接口地址进行服务转发
16
#spring.cloud.gateway.discovery.locator.enabled=true
17
# 把服务名转换为小写，Eureka 中默认都是大写，但 Nacos 不会自动转换，所以也可以不写。
18
#spring.cloud.gateway.discovery.locator.lower-case-service-id=true
19
spring.cloud.gateway.routes[0].id=account-service
20
spring.cloud.gateway.routes[0].uri=lb://jianghu-account
21
spring.cloud.gateway.routes[0].predicates[0]=Path=/api/account/**
22
spring.cloud.gateway.routes[1].id=common-service
23
spring.cloud.gateway.routes[1].uri=lb://jianghu-common
24
spring.cloud.gateway.routes[1].predicates[0]=Path=/api/common/**
2

启动类

1
package com.sfac.gateway; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.cloud.client.discovery.EnableDiscoveryClient; import org.springframework.cloud.openfeign.EnableFeignClients; /** * Description: Jianghu Gateway Application * @author Jianghu * @date 2022-03-25 20:43:50 */ @SpringBootApplication @EnableDiscoveryClient @EnableFeignClients public class JianghuGatewayApplication { public static void main( String[] args ) { SpringApplication.run(JianghuGatewayApplication.class, args); } }
1
package com.sfac.gateway;
2
3
import org.springframework.boot.SpringApplication;
4
import org.springframework.boot.autoconfigure.SpringBootApplication;
5
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
6
import org.springframework.cloud.openfeign.EnableFeignClients;
7
8
/**
9
* Description: Jianghu Gateway Application
10
* @author Jianghu
11
* @date 2022-03-25 20:43:50
12
*/
13
@SpringBootApplication
14
@EnableDiscoveryClient
15
@EnableFeignClients
16
public class JianghuGatewayApplication {
17

18
public static void main( String[] args ) {
19
SpringApplication.run(JianghuGatewayApplication.class, args);
20
}
21
}
2

测试

http://127.0.0.1:8001/api/common/dictionary/imageType
http://127.0.0.1:8000/api/common/dictionary/imageType

Sentinel

简介

主要特性

两大部分

核心库（Java 客户端）：不依赖任何框架/库，能够运行于所有 Java 运行时环境，同时对 Dubbo / Spring Cloud 等框架也有较好的支持；
控制台（Dashboard）：基于 Spring Boot 开发，打包后可以直接运行，不需要额外的 Tomcat 等应用容器；

文档地址：https://github.com/alibaba/Sentinel/wiki/介绍；
仓库地址：https://github.com/alibaba/Sentinel；

安装与运行

历史版本：https://github.com/alibaba/Sentinel/releases；
下载到本地，CMD 运行

默认 8080 端口运行，可能与其它软件冲突，故选择 9090 端口；
java -jar sentinel-dashboard-1.8.3.jar --server.port=9090

访问：127.0.0.1:9090 sentinel | sentinel；

添加微服务

Service Module Test & Service Module Account，添加方式相同；
Pom 依赖

 
<!-- actuator -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<!-- sentinel -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

配置

上面我们已经开启了 Nacos Config，所以直接在 Nacos 中修改配置；
http://127.0.0.1:8848/nacos，修改对应配置列表；

1
# for sentinel # sentinel dashboard 地址 spring.cloud.sentinel.transport.dashboard=127.0.0.1:9090 # sentinel dashboard 内部通信端口，默认为 8719，如果被占用会自动 +1，直到找到为止 spring.cloud.sentinel.transport.port=8719 # 开启所有监控端点 management.endpoints.web.exposure.include=*
1
# for sentinel
2
# sentinel dashboard 地址
3
spring.cloud.sentinel.transport.dashboard=127.0.0.1:9090
4
# sentinel dashboard 内部通信端口，默认为 8719，如果被占用会自动 +1，直到找到为止
5
spring.cloud.sentinel.transport.port=8719
6
# 开启所有监控端点
7
management.endpoints.web.exposure.include=*
2

实时监控

说明

微服务加入了 Sentienl，在调用服务接口时，就会通过内部通信服务把日志信息发送给 Dashboard 服务，并在页面上展示；

实现

启动 Service Module Test 8001、8002、8003；
启动 Service Module Account 8004；
访问 Nacos 服务列表

访问 Service Module Account 接口；

http://127.0.0.1:8004/api/user/1
http://127.0.0.1:8004/api/config

访问 Sentinel 仪表盘 http://127.0.0.1:9090/#/dashboard/metric/alibaba-service-account，已生成对应的服务；

QBS：表示 1 秒的请求数；
QPS：表示 1 秒的拒绝请求数；

簇点链路

说明

微服务、Api 调用情况，提供流控、熔断、热点、授权等操作；

流量控制

说明

流量控制（Flow Control)，其原理是监控应用流量的 QPS 或并发线程数等指标，当达到指定的阈值时对流量进行控制，以避免被瞬时的流量高峰冲垮，从而保障应用的高可用性；

Service Module Account 实现

对应微服务或接口上添加流控；

/api/user/{id}，当每秒请求的次数超过阈值，那么会直接返回失败的信息；
浏览器快速刷新 http://127.0.0.1:8004/api/user/1，得到被流控的结果；

熔断降级

说明

服务调用中，如果依赖的服务出现了不稳定的情况，请求的响应时间变长，那么调用方的响应时间也会变长，线程会产生堆积，最终可能耗尽线程池，服务本身也变得不可用，Sentinel 在服务出现不稳定情况时，会对让请求快速失败，避免影响到其他资源而导致级联错误，当资源被降级后，在接下来的时间窗口内，对该资源的调用都自动熔断；
降级策略

慢调用比例

在 1000ms 内请求数超过 5 个，且平均响应时间超过 300ms 的请求的比例（超过 300ms 的请求占总请求的比例）大于 0.4，则该资源自动熔断 10s，10s 后根据下一个请求判断是否再次被熔断；

异常比例

在 1000ms 内请求数超过 5 个，且异常的比例（异常的请求占总请求的比例）大于 0.8，则该资源自动熔断 15s，15s 后根据下一个请求判断是否再次被熔断；

异常数

在 1000ms 内请求数超过 5 个，且异常的请求超过 6 个，那么该资源将自动熔断 20s，20s 后根据下一个请求判断是否再次被熔断；

@SentinelResource ---- 降级熔断注解，类似于 @HystrixCommand

value：资源名称，必需项；
blockHandler：指定流控或降级异常时的处理逻辑；

必须是 public 修饰；
返回类型与原方法一致；
参数类型需要和原方法相匹配，并在最后加 BlockException 类型的参数；
默认需和原方法在同一个类中，若希望使用其他类的函数，可配置 blockHandlerClass，并指定 blockHandlerClass 里面的方法；

fallback：指定非流控或降级异常时的处理逻辑；

返回类型与原方法一致；
参数类型需要和原方法相匹配，Sentinel 1.6 开始，也可以在方法最后加 Throwable 类型的参数；
默认需和原方法在同一个类中，若希望使用其他类的函数，可配置 fallbackClass，并制定 fallbackClass 里面的方法；

Service Module Account 实现

UserServiceImpl，为接口添加流控和熔断处理代码；

@Service
public class UserServiceImpl implements UserService {

@Autowired
	private UserDao userDao;
	@Autowired
	private TestFeignClient testFeignClient;

@Override
	@SentinelResource(value = "getUserVoByUserIdAndCityId", blockHandler = "blockHandler", fallback = "fallbackHandler")
	public UserVo getUserVoByUserIdAndCityId(int userId, int cityId) {
		if (userId < 0 ) {
			throw new RuntimeException("cdsacadscdascsad");
		}
		UserVo userVo = new UserVo();
		User user = userDao.getUserById(userId);
		BeanUtils.copyProperties(user, userVo);
		City city = testFeignClient.getCityByCityId(cityId);
		userVo.setCity(city);

return userVo;
	}

/**
	 * 流控或降级异常处理逻辑
	 */
	public UserVo blockHandler(int userId, int cityId, BlockException exception) {
		if (exception instanceof FlowException) {
			System.out.println("您被限流了.");
		} else if (exception instanceof DegradeException) {
			System.out.println("您被降级了.");
		} else {
			System.out.println("City 接口不可用.");
		}

return new UserVo();
	}

/**
	 * 非流控或降级异常处理逻辑
	 */
	public UserVo fallbackHandler(int userId, int cityId) {
		System.out.println("发生了非流控、降级异常，被熔断了.");
		return new UserVo();
	}
}

 
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;
    @Autowired
    private TestFeignClient testFeignClient;
    @Override
    @SentinelResource(value = "getUserVoByUserIdAndCityId", blockHandler = "blockHandler", fallback = "fallbackHandler")
    public UserVo getUserVoByUserIdAndCityId(int userId, int cityId) {
        if (userId < 0 ) {
            throw new RuntimeException("cdsacadscdascsad");
        }
        UserVo userVo = new UserVo();
        User user = userDao.getUserById(userId);
        BeanUtils.copyProperties(user, userVo);
        City city = testFeignClient.getCityByCityId(cityId);
        userVo.setCity(city);
        return userVo;
    }
    /**
     * 流控或降级异常处理逻辑
     */
    public UserVo blockHandler(int userId, int cityId, BlockException exception) {
        if (exception instanceof FlowException) {
            System.out.println("您被限流了.");
        } else if (exception instanceof DegradeException) {
            System.out.println("您被降级了.");
        } else {
            System.out.println("City 接口不可用.");
        }
        return new UserVo();
    }
    /**
     * 非流控或降级异常处理逻辑
     */
    public UserVo fallbackHandler(int userId, int cityId) {
        System.out.println("发生了非流控、降级异常，被熔断了.");
        return new UserVo();
    }
}

启动项目，调用接口 http://127.0.0.1:8003/api/account/userVo/1/1890；
访问 Sentinel 微服务下簇点链路，找到 getUserVoByUserIdAndCityId 资源（@SentinelResource 注解配置的资源名），添加流控、熔断等规则；

为该资源配置异常数规则；

为该资源配置流控规则；

测试

快速调用接口 http://127.0.0.1:8003/api/account/userVo/1/1890，页面返回 blockHandler 处理结果；
调用接口 http://127.0.0.1:8003/api/account/userVo/-1/1890，页面返回熔断 fallbackHandler 处理结果；

规则持久化

说明

重启微服务或 Sentinel，配置的规则消失，大量的规则配置并未持久化；
推送模式

Pull 模式：客户端主动向某个规则管理中心定期轮询拉取规则，这个规则中心可以是 RDBMS、文件，甚至是 VCS 等，这样做的方式是简单，缺点是无法及时获取变更；
Push 模式：规则中心统一推送，客户端通过注册监听器的方式时刻监听变化，比如使用 Nacos、Zookeeper 等配置中心，这种方式有更好的实时性和一致性保证；

数据源

SentinelProperties 内部提供了 TreeMap 类型的 DataSource 属性用于配置数据源信息，有多种配置：

文件配置
Nacos 配置
ZooKeeper 配置
Apollo 配置

规则类型：参见 com.alibaba.cloud.sentinel.datasource.RuleType；

Service Module Account 实现

Pom 依赖

 
<!-- sentinel datasource nacos -->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-datasource-nacos</artifactId>
</dependency>

配置

Nacos Config ---- alibaba-service-account-dev.properties

由于版本迭代关系，Wiki 或网上配置不一定适用于所有版本，查看 NacosDataSourceProperties 源码分析配置项；
1
# for sentinel datasource nacos spring.cloud.sentinel.datasource.ds.nacos.server-addr=localhost:8848 spring.cloud.sentinel.datasource.ds.nacos.dataId=alibaba-service-account-sentinel spring.cloud.sentinel.datasource.ds.nacos.groupId=DEFAULT_GROUP spring.cloud.sentinel.datasource.ds.nacos.rule-type=flow
1
# for sentinel datasource nacos
2
spring.cloud.sentinel.datasource.ds.nacos.server-addr=localhost:8848
3
spring.cloud.sentinel.datasource.ds.nacos.dataId=alibaba-service-account-sentinel
4
spring.cloud.sentinel.datasource.ds.nacos.groupId=DEFAULT_GROUP
5
spring.cloud.sentinel.datasource.ds.nacos.rule-type=flow
2

Nacos Config ---- 新建配置

 
[
    {
        "resource": "/api/user/{id}", 
        "limitApp": "default",
        "grade": 1,
        "count": 5,
        "strategy": 0,
        "controlBehavior": 0,
        "clusterMode": false
    }
]

2
resource：资源名，即限流规则的作用对象；
limitApp：流控针对的调用来源，若为 default 则不区分调用来源；
grade：限流阈值类型（QPS 或并发线程数）；0代表根据并发数量来限流，1 代表根据 QPS 来进行流量控制；
count：限流阈值；
strategy：调用关系限流策略；
controlBehavior：流量控制效果（直接拒绝、Warm Up、匀速排队）；
clusterMode：是否为集群模式；

应用

重启 Service Module Account 微服务；
访问接口：http://127.0.0.1:8004/api/user/1；
刷新 Sentinel 流控面板，加载配置的规则；

思考

Sentinel 控制台、Nacos 控制台均可修改规则；
Sentinel 修改规则仅存在于服务的内存中，不会修改 Nacos 中的配置值，重启后恢复原来的值；
Nacos 修改规则后，服务的内存中规则会更新，Nacos 中持久化规则也会更新，重启后依然保持；

Seata

简介

Seata 是一款开源的分布式事务解决方案，致力于在微服务架构下提供高性能和简单易用的分布式事务服务；
资料地址

Seata 项目 Github 地址：https://github.com/seata/seata
Seata 中间件下载地址：https://github.com/seata/seata/releases
Seata 中文官方文档：http://seata.io/zh-cn/
Seata 官方示例：https://github.com/seata/seata-samples

术语

XID（Transaction ID）：全局唯一的事务 ID；
TC (Transaction Coordinator)：事务协调者，维护全局和分支事务的状态，驱动全局事务提交或回滚；
TM (Transaction Manager)：事务管理器，定义全局事务的范围，开始全局事务、提交或回滚全局事务；
RM (Resource Manager)：资源管理器，管理分支事务处理的资源，与 TC 交谈以注册分支事务和报告分支事务的状态，并驱动分支事务提交或回滚；

处理过程

TM 向 TC 申请开启一个全局事务，全局事务创建成功并生成一个全局唯一的 XID；
XID 在微服务调用链路的上下文中传播；
RM 向 TC 注册分支事务，将其纳入 XID 对应全局事务的管辖；
TM 向 TC 发起针 XID 的全局提交或回滚决议；
TC 调度 XID 下管辖的全部分支事务完成提交或回滚请求；

-----------------------------------
一阶段

解析 SQL，得到表、操作类型（insert、update、delete）、查询条件；
查询改变前的数据；
执行增删改操作；
查询改变后的数据；
插入回滚日志：把改变前后的数据和 SQL 信息组成一条回滚日志，插入 undo_log 表中（未查到该数据）；
向 TC 申请全局锁，生成全局唯一事务 ID（XID）；
本地事务提交：业务数据和 undo_log 数据一并提交；
将本地事务提交结果上报给 TC；

二阶段提交

TC 收到微服务本地事务提交成功请求，把请求放到一个异步任务队列中；
异步任务将批量地删除相应 undo_log 记录；

二阶段回滚

TC 收到微服务本地事务提交失败请求，返回一个回滚请求，微服务开启一个本地事务；
微服务通过 XID 找到对应的 undo_log 记录，并生成回滚 SQL；
执行回滚 SQL，提交本地事务；
将回滚操作事务执行结果报告给 TC；

Server 端

下载

https://github.com/seata/seata/releases

文件解读

seata-server-1.4.2/conf/README-zh.md

Server 端建表 Sql、各种方式部署的脚本；
Client 端业务库回滚日志表 Sql、客户端配置等；
配置中心，Seata 在各种注册中心注册，添加配置的脚本；

seata-server-1.4.2/conf/registry.conf

指定事务协调者（TC）的注册中心，提供 file 、nacos 、eureka、redis、zk、consul、etcd3、sofa 方式，由 type 指定，默认 file；

指定事务协调者（TC）的配置文件，提供 file、nacos 、apollo、zk、consul、etcd3 方式，由 type 指定，默认 file；

seata-server-1.4.2/conf/file.conf

指定事务协调者（TC）数据存储位置，提供 file、db、redis 方式，默认 file；

File 方式

DB 方式

DataSource：有三种连接池 druid、dbcp、hikari；
创建 seata 库以及 global_table、branch_table、lock_table 表，建表 sql 参见帮助文档；
将 seata-server-1.4.2/lib/jdbc MySQL 对应版本驱动 jar 拷贝到 seata-server-1.4.2/bin 目录下；

配置

事务协调者（TC）的注册中心、配置文件、数据存储地址

File 方式：是本地文件系统，无需修改配置；
其他方式：根据实际情况配置；

客户端配置应与服务端配置保持一致；

运行

seata-server-1.4.2/bin

seata-server.bat
sh ./seata-server.sh
-------- 启动参数 --------
-p：Seata Server 启动端口，默认 8091；
-h：注册中心 IP
-m：事务日志存储方式，支持 file, db, redis，默认为 file；
-n : 用于指定 seata-server 节点 ID，如 1,2,3…… 默认为 1；
-e : 指定 seata-server 运行环境，如：dev, test 等, 服务启动时会使用 registry-dev.conf 这样的配置；

启动后提示：Server started, listen port: 8091；
因为使用 file 方式，启动后 bin 目录出现了 sessionStore 文件夹，用于存储事务协调者（TC）相关数据；

业务准备

Service Module Test

引入 MySQL、Mybatis，并做相关配置，参见 Spring_Boot 文档；

提供 updateCity 接口：127.0.0.1:8003/api/city，Put 请求，操作 test 数据库 city 表；

Service Module Account

引入 MySQL、Mybatis，并做相关配置，参见 Spring_Boot 文档；
提供 updateUser 接口：127.0.0.1:8004/api/user，Put 请求，Service 层两步操作，其一操作 account 数据库 user 表，其二通过 OpenFeign 调用 updateCity 接口操作 test 数据库 City 表；

模拟场景

调用 updateUser 接口，当远程调用 updateCity 成功后，人为构造异常，通过分布式事务，让 updateCity 回滚数据；

Client 端

Service Module Test

Pom 依赖

 
<!-- seata -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
</dependency>

配置

Seata 客户端配置文件 file.conf、registry.conf；

文件下载地址查看帮助文档，Git 地址为：https://github.com/seata/seata/tree/develop/script/client；
将文件拷贝到项目 src/main/resources 文件夹下；
file.conf

vgroupMapping.default_tx_group = "default"

事务分组配置，是 Seata 的资源逻辑，类似服务实例，在此修改为：
vgroupMapping.test_server_group = "default"
意思是该微服务在 Seata 中注册的事务分组名为：test_server_group；

default.grouplist = "127.0.0.1:8091"

指定 Server 端地址，仅在 registry.type=file 时候起作用，且不支持集群；

若 Server 端事务协调者（TC）配置做了修改，那么 Client 端也需做相同的修改，在此案例中事务协调者（TC）配置均使用 file 方式，所以客户端也无需修改；

Nacos 配置列表 alibaba-service-test-dev.properties；

数据源配置

spring.datasource.url 数据库 JDBC 连接；
spring.datasource.jdbc-url 自定义连接池连接；
因为我们要自定义数据源，故而要使用 jdbc-url 配置，不然会抛出 jdbcUrl is required with driverClassName 错误；

事务分组配置

1
# seata 事务分组配置 spring.cloud.alibaba.seata.tx-service-group=test_server_group
1
# seata 事务分组配置
2
spring.cloud.alibaba.seata.tx-service-group=test_server_group
2
此处的配置应和 Client 端 file.conf 中 service.vgroupMapping 后缀名保持一致；
程序会通过该配置获取事务分组名 test_server_group，然后去 Client 端 file.conf 中的 service.vgroupMapping 配置（老版本 service.vgroup_mapping），取得事务协调者（TC）集群的名称，再构造服务名，然后去注册中心去拉取事务协调者（TC）服务列表；

实例

1
# for data source # mysql 5 #spring.datasource.driver-class-name=com.mysql.jdbc.Driver # mysql 6 + spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver spring.datasource.url=jdbc:mysql://127.0.0.1:3306/main?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=GMT%2B8 spring.datasource.jdbc-url=jdbc:mysql://127.0.0.1:3306/main?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=GMT%2B8 spring.datasource.username=root spring.datasource.password=root # hikari pool spring.datasource.hikari.maximum-pool-size=20 spring.datasource.hikari.minimum-idle=5 spring.datasource.hikari.idle-timeout=180000 spring.datasource.hikari.auto-commit=true # for alibaba seata spring.cloud.alibaba.seata.tx-service-group=test_server_group # for mybatis mybatis.configuration.map-underscore-to-camel-case=true # for sentinel spring.cloud.sentinel.transport.dashboard=127.0.0.1:8005 spring.cloud.sentinel.transport.port=8719 management.endpoints.web.exposure.include=*
1
# for data source
2
# mysql 5
3
#spring.datasource.driver-class-name=com.mysql.jdbc.Driver
4
# mysql 6 +
5
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
6
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/main?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=GMT%2B8
7
spring.datasource.jdbc-url=jdbc:mysql://127.0.0.1:3306/main?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=GMT%2B8
8
spring.datasource.username=root
9
spring.datasource.password=root
10
11
# hikari pool
12
spring.datasource.hikari.maximum-pool-size=20
13
spring.datasource.hikari.minimum-idle=5
14
spring.datasource.hikari.idle-timeout=180000
15
spring.datasource.hikari.auto-commit=true
16
17
# for alibaba seata
18
spring.cloud.alibaba.seata.tx-service-group=test_server_group
19
20
# for mybatis
21
mybatis.configuration.map-underscore-to-camel-case=true
22
23
# for sentinel
24
spring.cloud.sentinel.transport.dashboard=127.0.0.1:8005
25
spring.cloud.sentinel.transport.port=8719
26
management.endpoints.web.exposure.include=*
2

数据源

Seata 通过代理数据源的方式实现分支事务，所以在应用中需要重新配置数据源，注入 io.seata.rm.datasource.DataSourceProxy；
DataSourceProxyConfig

package com.sfac.alibabaServiceTest.config;

import javax.sql.DataSource;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import com.zaxxer.hikari.HikariDataSource;

import io.seata.rm.datasource.DataSourceProxy;

/**
 * Description: Data Source Proxy Config
 * -有警告信息，Pom 导入 spring-boot-configuration-processor
 * @author HymanHu
 * @date 2022-03-09 16:05:58
 */
@Configuration
@EnableTransactionManagement
@MapperScan(
		sqlSessionFactoryRef = "sqlSessionFactory",
		sqlSessionTemplateRef="sqlSessionTemplate",
		basePackages = "com.sfac.alibabaServiceTest.dao")
public class DataSourceProxyConfig {
	
	// hikari config
	@Value("${spring.datasource.hikari.maximum-pool-size}")
	private int maximumPoolSize;
	@Value("${spring.datasource.hikari.minimum-idle}")
	private int minimumIdle;
	@Value("${spring.datasource.hikari.idle-timeout}")
	private long idleTimeout;
	@Value("${spring.datasource.hikari.auto-commit}")
	private boolean autoCommit;
	
	// mybatis config
	@Value("${mybatis.configuration.map-underscore-to-camel-case}")
	private boolean mapUnderscoreToCamelCase;
	
	@Bean(name="hikariDataSource")
	@ConfigurationProperties(prefix = "spring.datasource")
	public HikariDataSource dataSource() {
		HikariDataSource hikariDataSource = new HikariDataSource();
		hikariDataSource.setMaximumPoolSize(maximumPoolSize);
		hikariDataSource.setMinimumIdle(minimumIdle);
		hikariDataSource.setIdleTimeout(idleTimeout);
		hikariDataSource.setAutoCommit(autoCommit);
		return hikariDataSource;
	}

@Bean(name="dataSourceProxy")
	public DataSource dataSourceProxy(@Qualifier("hikariDataSource") DataSource dataSource) {
		return new DataSourceProxy(dataSource);
	}

@Bean(name="sqlSessionFactory")
	public SqlSessionFactory sqlSessionFactoryBean(
			@Qualifier("dataSourceProxy") DataSource dataSourceProxy) throws Exception {
		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
		bean.setDataSource(dataSourceProxy);
		org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
        configuration.setMapUnderscoreToCamelCase(mapUnderscoreToCamelCase);
        bean.setConfiguration(configuration);
		return bean.getObject();
	}
	
	@Bean(name="sqlSessionTemplate")
	public SqlSessionTemplate mainDbSqlSessionTemplate(
            @Qualifier("sqlSessionFactory") SqlSessionFactory sessionfactory) {
        return new SqlSessionTemplate(sessionfactory);
    }
	
	@Bean(name = "mybatisTransactionManager")
	public PlatformTransactionManager transactionManager(
			@Qualifier("dataSourceProxy") DataSource dataSourceProxy) {
		return new DataSourceTransactionManager(dataSourceProxy);
	}
}

 
package com.sfac.alibabaServiceTest.config;
import javax.sql.DataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import com.zaxxer.hikari.HikariDataSource;
import io.seata.rm.datasource.DataSourceProxy;
/**
 * Description: Data Source Proxy Config
 * -有警告信息，Pom 导入 spring-boot-configuration-processor
 * @author HymanHu
 * @date 2022-03-09 16:05:58
 */
@Configuration
@EnableTransactionManagement
@MapperScan(
        sqlSessionFactoryRef = "sqlSessionFactory",
        sqlSessionTemplateRef="sqlSessionTemplate",
        basePackages = "com.sfac.alibabaServiceTest.dao")
public class DataSourceProxyConfig {
    
    // hikari config
    @Value("${spring.datasource.hikari.maximum-pool-size}")
    private int maximumPoolSize;
    @Value("${spring.datasource.hikari.minimum-idle}")
    private int minimumIdle;
    @Value("${spring.datasource.hikari.idle-timeout}")
    private long idleTimeout;
    @Value("${spring.datasource.hikari.auto-commit}")
    private boolean autoCommit;
    
    // mybatis config
    @Value("${mybatis.configuration.map-underscore-to-camel-case}")
    private boolean mapUnderscoreToCamelCase;
    
    @Bean(name="hikariDataSource")
    @ConfigurationProperties(prefix = "spring.datasource")
    public HikariDataSource dataSource() {
        HikariDataSource hikariDataSource = new HikariDataSource();
        hikariDataSource.setMaximumPoolSize(maximumPoolSize);
        hikariDataSource.setMinimumIdle(minimumIdle);
        hikariDataSource.setIdleTimeout(idleTimeout);
        hikariDataSource.setAutoCommit(autoCommit);
        return hikariDataSource;
    }
    @Bean(name="dataSourceProxy")
    public DataSource dataSourceProxy(@Qualifier("hikariDataSource") DataSource dataSource) {
        return new DataSourceProxy(dataSource);
    }
    @Bean(name="sqlSessionFactory")
    public SqlSessionFactory sqlSessionFactoryBean(
            @Qualifier("dataSourceProxy") DataSource dataSourceProxy) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSourceProxy);
        org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
        configuration.setMapUnderscoreToCamelCase(mapUnderscoreToCamelCase);
        bean.setConfiguration(configuration);
        return bean.getObject();
    }
    
    @Bean(name="sqlSessionTemplate")
    public SqlSessionTemplate mainDbSqlSessionTemplate(
            @Qualifier("sqlSessionFactory") SqlSessionFactory sessionfactory) {
        return new SqlSessionTemplate(sessionfactory);
    }
    
    @Bean(name = "mybatisTransactionManager")
    public PlatformTransactionManager transactionManager(
            @Qualifier("dataSourceProxy") DataSource dataSourceProxy) {
        return new DataSourceTransactionManager(dataSourceProxy);
    }
}

回滚日志表 undo_log

参考帮助文档，查找建表 Sql，数据库版本不同，需要修改 sql 语句；

应用

微服务小事务使用 @Transactional 注解，分布式大事务使用 @GlobalTransactional 注解；

 
@Override
@Transactional
public ResultEntity<City> updateCity(City city) {
    cityDao.updateCity(city);
    return new ResultEntity<City>(ResultEntity.ResultStatus.SUCCESS.status, "Update success.", city);
}

Service Module Account

Pom 依赖

同上；

配置

Seata 客户端配置文件 file.conf、registry.conf；

文件下载地址查看帮助文档，Git 地址为：https://github.com/seata/seata/tree/develop/script/client；
将文件拷贝到项目 src/main/resources 文件夹下；
file.conf

vgroupMapping.default_tx_group = "default"

事务分组配置，是 Seata 的资源逻辑，类似服务实例，在此修改为：
vgroupMapping.account_server_group = "default"
意思是该微服务在 Seata 中注册的事务分组名为：account_server_group；

default.grouplist = "127.0.0.1:8091"

指定 Server 端地址，仅在 registry.type=file 时候起作用，且不支持集群；

若 Server 端事务协调者（TC）配置做了修改，那么 Client 端也需做相同的修改，在此案例中事务协调者（TC）配置均使用 file 方式，所以客户端也无需修改；

Nacos 配置列表 alibaba-service-account-dev.properties；

数据源配置

spring.datasource.url 数据库 JDBC 连接；
spring.datasource.jdbc-url 自定义连接池连接；
因为我们要自定义数据源，故而要使用 jdbc-url 配置，不然会抛出 jdbcUrl is required with driverClassName 错误；

事务分组配置

1
# seata 事务分组配置 spring.cloud.alibaba.seata.tx-service-group=account_server_group
1
# seata 事务分组配置
2
spring.cloud.alibaba.seata.tx-service-group=account_server_group
2
此处的配置应和 Client 端 file.conf 中 service.vgroupMapping 后缀名保持一致；
程序会通过该配置获取事务分组名 account_server_group，然后去 Client 端 file.conf 中的 service.vgroupMapping 配置（老版本 service.vgroup_mapping），取得事务协调者（TC）集群的名称，再构造服务名，然后去注册中心去拉取事务协调者（TC）服务列表；

数据源

同上，修改 basePackages = "com.sfac.alibabaServiceAccount.dao"；

回滚日志表 undo_log

同上；

应用

微服务小事务使用 @Transactional 注解，分布式大事务使用 @GlobalTransactional 注解；

 
@Override
@Transactional
@GlobalTransactional
public ResultEntity<User> updateUser(User user) {
    City city = user.getCity();
    if (city != null) {
        cityFeignClient.updateCity(city);
    }
    int i = 1 / 0;
    userDao.updateUser(user);
    return new ResultEntity<User>(ResultEntity.ResultStatus.SUCCESS.status, "Update success.", user);
}

部署测试

启动服务

启动 Nacos；
启动 Sentinel；
启动 Seata Server 端；
Service Module Test 启动三个服务，分别对应 8001、8002、8003 端口；
Service Module Account 启动一个服务，对应 8004 端口；

正常流程

127.0.0.1:8004/api/user 接口 Service 层，去掉 int i = 1 / 0; 代码；
PostMan 请求该接口；

数据库修改成功

异常流程

127.0.0.1:8004/api/user 接口 Service 层，添加 int i = 1 / 0; 代码，人为抛出异常；
PostMan 请求该接口；

数据库数据回滚

控制台日志

Service Module Account

Service Module Test

图片上传

简介

微服务中图片处理最好不要采用 Spring Boot 中本地静态资源的方式，若静态资源只配置在某一个微服务中，那图片也只能在该服务器内，再者，图片地址的多样性和可扩展性，网关不好把控；
我们需要一台图片服务器，使用 Nginx 搭建，公共微服务提供上传图片的接口，图片直接写到图片服务器中，返回该图片的网络访问地址；

图片服务器

下载并安装 Nginx；
/usr/local/nginx/conf/nginx.conf

 
worker_processes  1;
events {
    worker_connections  1024;
}
http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile        on;
    #tcp_nopush     on;
    #keepalive_timeout  0;
    keepalive_timeout  65;
    server {
        listen       8000;
        server_name  localhost;
        location / {
            root   /static;
            #index  index.html index.htm;
            autoindex on;
        }
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
    }
}

规则

开放 8000 端口；
根路径配置到系统 /static 文件夹下，并开启浏览器打开文件夹模式；
上传图片根据“文件类型”、“图片种类”、“文件名”定位，例如：上传为图片类型、profile 种类的图片，文件名为当前的时间戳，那么该图片的访问路径为：http://www.sfac.xyz:8000/images/profile/1650874597429.jpg；
创建 /static 文件夹放置图片；
chmod 777 /static/ -R，为该文件夹设置权限；

图片接口

思路

首先要确定连接图片服务器的协议，ftp:// 协议还是 sftp:// 协议，ftp 协议使用 Apache commons-net 包，sftp 协议使用 jsch 包；
其次需要考虑 Java 连接远程服务器的验证方式，最常见的是用户名和密码方式，但我创建的图片服务器禁用了用户名密码登陆、禁用了 root 登陆，使用其他账户的 RSA 公私匙验证登陆，在这种情况下，客户端采用 sftp 协议 + id_rsa 证书的方式可登陆服务器；
接着需要了解 sftp 包操作服务器的接口；
然后才撸代码；

jianghu_entity

FileType.java

 
package com.sfac.entity.common.resource;
import java.util.Arrays;
import com.fasterxml.jackson.annotation.JsonFormat;
/**
 * Description: File Type
 * -不同类型的文件存放在不同的文件夹中;
 * -命名规则
 * -Type：文件类型区别
 * -Category：同种类型（如图片分类）下功能分类（如个人头像、摘录等）
 * @author JiangHu
 * @date 2022-04-25 09:45:25
 */
@JsonFormat(shape = JsonFormat.Shape.OBJECT)
public enum FileType {
    IMAGE("image", "images"),
    VIDEO("video", "videos"),
    ;
    public String name;
    public String typeFolder;
    
    private FileType(String name, String typeFolder) {
        this.name = name;
        this.typeFolder = typeFolder;
    }
    
    public static FileType getFileTypeByName(String name) {
        return Arrays.stream(FileType.values())
                .filter(item -> item.name.equalsIgnoreCase(name))
                .findFirst()
                .orElse(null);
    }
}

ImageCategory.java

package com.sfac.entity.common.resource;

import java.util.Arrays;

import com.fasterxml.jackson.annotation.JsonFormat;

/**
 * Description: Image Category
 * -命名规则
 * -Type：文件类型区别
 * -Category：同种类型（如图片分类）下功能分类（如个人头像、摘录等）
 * @author JiangHu
 * @date 2022-03-25 14:13:40
 */
@JsonFormat(shape = JsonFormat.Shape.OBJECT)
public enum ImageCategory {
	// 个人主页
	PROFILE("profile", 1000, 1000, 2048),
	// 摘录
	EXCERPT("excerpt", 2000, 1000, 2048),
	// 测试
	TEST("test", 11, 11, 11),
	;
	
	public String name;
	public Integer maxWidth;
	public Integer maxHeight;
	public int maxSize;
	
	private ImageCategory(String name, Integer maxWidth, Integer maxHeight, int maxSize) {
		this.name = name;
		this.maxWidth = maxWidth;
		this.maxHeight = maxHeight;
		this.maxSize = maxSize;
	}

public static ImageCategory getImageCategoryByName(String name) {
		return Arrays.stream(ImageCategory.values())
				.filter(item -> item.name.equalsIgnoreCase(name))
				.findFirst()
				.orElse(null);
	}
	
	public static void main(String[] args) {
		System.out.println(ImageCategory.getImageCategoryByName("profile").maxHeight);
	}
}

 
package com.sfac.entity.common.resource;
import java.util.Arrays;
import com.fasterxml.jackson.annotation.JsonFormat;
/**
 * Description: Image Category
 * -命名规则
 * -Type：文件类型区别
 * -Category：同种类型（如图片分类）下功能分类（如个人头像、摘录等）
 * @author JiangHu
 * @date 2022-03-25 14:13:40
 */
@JsonFormat(shape = JsonFormat.Shape.OBJECT)
public enum ImageCategory {
    // 个人主页
    PROFILE("profile", 1000, 1000, 2048),
    // 摘录
    EXCERPT("excerpt", 2000, 1000, 2048),
    // 测试
    TEST("test", 11, 11, 11),
    ;
    
    public String name;
    public Integer maxWidth;
    public Integer maxHeight;
    public int maxSize;
    
    private ImageCategory(String name, Integer maxWidth, Integer maxHeight, int maxSize) {
        this.name = name;
        this.maxWidth = maxWidth;
        this.maxHeight = maxHeight;
        this.maxSize = maxSize;
    }
    public static ImageCategory getImageCategoryByName(String name) {
        return Arrays.stream(ImageCategory.values())
                .filter(item -> item.name.equalsIgnoreCase(name))
                .findFirst()
                .orElse(null);
    }
    
    public static void main(String[] args) {
        System.out.println(ImageCategory.getImageCategoryByName("profile").maxHeight);
    }
}

FileUtil.java

略；

jianghu_common

 
<!-- Apache 网络工具包，支持 FTP、SMTP、 POP3 等协议 -->
<dependency>
    <groupId>commons-net</groupId>
    <artifactId>commons-net</artifactId>
    <version>3.8.0</version>
</dependency>
<!-- SSH2 的一个纯 Java 实现，连接到一个 SSHD 服务器 -->
<dependency>
    <groupId>com.jcraft</groupId>
    <artifactId>jsch</artifactId>
</dependency>

application.properties

1
# for ftp ftp.address=www.sfac.xyz ftp.port=61234 ftp.userName=hj ftp.password=*** ftp.basePath=/static nginx.port=8000
1
# for ftp
2
ftp.address=www.sfac.xyz
3
ftp.port=61234
4
ftp.userName=hj
5
ftp.password=***
6
ftp.basePath=/static
7
nginx.port=8000
2

id_rsa

将证书拷贝到 src/main/resources 下；

FtpConfigBean

 
package com.sfac.common.config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;
/**
 * Description: Ftp Config
 * 
 * @author Jianghu
 * @date 2022-04-24 16:47:03
 */
@Component
@PropertySource("classpath:application.properties")
public class FtpConfigBean {
    @Value("${ftp.address}")
    private String address;
    @Value("${ftp.port}")
    private int port;
    @Value("${ftp.userName}")
    private String userName;
    @Value("${ftp.password}")
    private String password;
    @Value("${ftp.basePath}")
    private String basePath;
    @Value("${nginx.port}")
    private int nginxPort;
    // 自行添加 get、set 方法
}

FtpUtil

package com.sfac.common.util;

import java.io.IOException;
import java.util.Properties;

import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPReply;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import com.jcraft.jsch.Channel;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;
import com.jcraft.jsch.SftpException;
import com.sfac.common.config.FtpConfigBean;
import com.sfac.entity.common.Result;
import com.sfac.entity.common.resource.FileType;
import com.sfac.entity.common.resource.ImageCategory;
import com.sfac.entity.util.FileUtil;

/**
 * Description: Ftp Util
 * @author Jianghu
 * @date 2022-04-25 09:33:16
 */
@Component
public class FtpUtil {

@Autowired
	private FtpConfigBean ftpConfigBean;

/**
	 * -上传文件，ftp:// 协议，使用 Apache commons-net 包
	 * -规则：basePath/fileTypeFolder/fileCategoryFolder/fileName
	 * -比如：/static/images/profile/*******.jpg
	 */
	public Result<String> uploadFileByFtp(MultipartFile file, String fileType, 
			String fileCategory, boolean useOriginalName) {

String fileCategoryFolder = "default";
		FileType ft = FileType.getFileTypeByName(fileType);
		switch (ft) {
		case IMAGE:
			ImageCategory imageCategory = ImageCategory.getImageCategoryByName(fileCategory);
			fileCategoryFolder = imageCategory.name;
			break;
		default:
			break;
		}
		// 目标文件夹
		String destFolder = String.format("%s/%s/%s", 
        		ftpConfigBean.getBasePath(),
        		ft.typeFolder,
        		fileCategoryFolder);
		// 文件名
		String fileName = useOriginalName ? 
				file.getOriginalFilename() : 
				String.format("%s.%s", 
		        		System.currentTimeMillis(),
		        		FileUtil.getFileType(file.getOriginalFilename()));
        // 目标文件
        String destFile = String.format("%s/%s", 
				destFolder, 
				fileName);
        // 文件访问路径
        String fileUrl = String.format("%s:%s%s", 
        		ftpConfigBean.getAddress(), 
        		ftpConfigBean.getNginxPort(), 
        		destFile);
        
        FTPClient ftpClient = null;
        try {
        	// FTP 客户端，用户名密码登陆
        	ftpClient = new FTPClient();
			ftpClient.connect(ftpConfigBean.getAddress(), ftpConfigBean.getPort());
			ftpClient.login(ftpConfigBean.getUserName(), ftpConfigBean.getPassword());
			// 获取连接返回状态码
			int replyCode = ftpClient.getReplyCode();
			// 如果返回状态不在 200 ~ 300，则认为连接失败
			if (!FTPReply.isPositiveCompletion(replyCode)) {
				ftpClient.disconnect();
				return new Result<String>(Result.ResultStatus.FAILED.code, "Connect failed.");
			}
			
			// 判断目标文件夹是否存在，不存在则创建
			replyCode = ftpClient.cwd(destFolder);
			if (!FTPReply.isPositiveCompletion(replyCode)) {
				ftpClient.mkd(destFolder);
			}
			
			// 设置上传的路径
			ftpClient.changeWorkingDirectory(destFolder);
			// 修改上传文件的格式为二进制
			ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
			// 上传文件
			if (!ftpClient.storeFile(fileName, file.getInputStream())) {
				return new Result<String>(Result.ResultStatus.FAILED.code, "Upload file failed.");
			}
			
			// 退出登录
			ftpClient.logout();
		} catch (IOException e) {
			e.printStackTrace();
			return new Result<>(Result.ResultStatus.FAILED.code, "Upload file failed.");
		} finally {
			try {
				// 关闭连接
				if (ftpClient.isConnected()) {
					ftpClient.disconnect();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
        
        return new Result<String>(Result.ResultStatus.SUCCESS.code, "Upload file success.", fileUrl);
	}
	
	/**
	 * -上传文件，sftp:// 协议，使用 jsch 包
	 */
	public Result<String> uploadFileBySftp(MultipartFile file, String fileType, 
			String fileCategory, boolean useOriginalName) {
		
		String fileCategoryFolder = "default";
		FileType ft = FileType.getFileTypeByName(fileType);
		switch (ft) {
		case IMAGE:
			ImageCategory imageCategory = ImageCategory.getImageCategoryByName(fileCategory);
			fileCategoryFolder = imageCategory.name;
			break;
		default:
			break;
		}
		// 目标文件夹
		String destFolder = String.format("%s/%s/%s", 
				ftpConfigBean.getBasePath(),
				ft.typeFolder,
				fileCategoryFolder);
		// 文件名
		String fileName = useOriginalName ? 
				file.getOriginalFilename() : 
				String.format("%s.%s", 
					System.currentTimeMillis(),
					FileUtil.getFileType(file.getOriginalFilename()));
		// 目标文件
		String destFile = String.format("%s/%s", 
				destFolder, 
				fileName);
		// 文件访问路径
		String fileUrl = String.format("http://%s:%s/%s/%s/%s", 
				ftpConfigBean.getAddress(), 
				ftpConfigBean.getNginxPort(), 
				ft.typeFolder, 
				fileCategoryFolder, 
				fileName);
		
		ChannelSftp sftp = null;
		Session sshSession = null;
		try {
			// 创建 SFTP、Session 实例
			JSch jsch = new JSch();
			sshSession = jsch.getSession(
					ftpConfigBean.getUserName(), 
					ftpConfigBean.getAddress(), 
					ftpConfigBean.getPort());
			
			// 用户名密码验证方式
//			sshSession.setPassword(ftpConfigBean.getPassword());
			// DSA、RSA 公私匙验证方式，证书带密码
			jsch.addIdentity(FtpUtil.class.getResource("/id_rsa").getPath(), ftpConfigBean.getPassword());
			
			// 配置
			Properties sshConfig = new Properties();
			// SSH 公钥检查机制 no、ask、yes
			sshConfig.put("StrictHostKeyChecking", "no");
			sshSession.setConfig(sshConfig);
			
			// 创建会话连接
			sshSession.connect();
			
			// 开启 SFTP 通道
			Channel channel = sshSession.openChannel("sftp");
			channel.connect();
			sftp = (ChannelSftp) channel;
			
			// 创建目录
			createDir(sftp, destFolder);
			
			// 上传文件
			sftp.put(file.getInputStream(), destFile);
		} catch (JSchException | SftpException | IOException e) {
			e.printStackTrace();
			return new Result<>(Result.ResultStatus.FAILED.code, "Upload file failed.");
		} finally {
			if (sftp != null) {
				sftp.quit();
			}
			if (sshSession != null) {
				sshSession.disconnect();
			}
		}
		
		return new Result<String>(Result.ResultStatus.SUCCESS.code, "Upload file success.", fileUrl);
	}
	
	// 创建文件夹
	private void createDir(ChannelSftp sftp, String destFolder) throws SftpException {
		String[] folders = destFolder.split("/");
		sftp.cd("/");
		for(String folder : folders) {
			if(folder.length() > 0) {
				try {
					sftp.cd(folder);
				} catch (SftpException e) {
					sftp.mkdir(folder);
					sftp.cd(folder);
				}
			}
		}
	}
}

 
package com.sfac.common.util;
import java.io.IOException;
import java.util.Properties;
import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPReply;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;
import com.jcraft.jsch.Channel;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;
import com.jcraft.jsch.SftpException;
import com.sfac.common.config.FtpConfigBean;
import com.sfac.entity.common.Result;
import com.sfac.entity.common.resource.FileType;
import com.sfac.entity.common.resource.ImageCategory;
import com.sfac.entity.util.FileUtil;
/**
 * Description: Ftp Util
 * @author Jianghu
 * @date 2022-04-25 09:33:16
 */
@Component
public class FtpUtil {
    @Autowired
    private FtpConfigBean ftpConfigBean;
    /**
     * -上传文件，ftp:// 协议，使用 Apache commons-net 包
     * -规则：basePath/fileTypeFolder/fileCategoryFolder/fileName
     * -比如：/static/images/profile/*******.jpg
     */
    public Result<String> uploadFileByFtp(MultipartFile file, String fileType, 
            String fileCategory, boolean useOriginalName) {
        String fileCategoryFolder = "default";
        FileType ft = FileType.getFileTypeByName(fileType);
        switch (ft) {
        case IMAGE:
            ImageCategory imageCategory = ImageCategory.getImageCategoryByName(fileCategory);
            fileCategoryFolder = imageCategory.name;
            break;
        default:
            break;
        }
        // 目标文件夹
        String destFolder = String.format("%s/%s/%s", 
                ftpConfigBean.getBasePath(),
                ft.typeFolder,
                fileCategoryFolder);
        // 文件名
        String fileName = useOriginalName ? 
                file.getOriginalFilename() : 
                String.format("%s.%s", 
                        System.currentTimeMillis(),
                        FileUtil.getFileType(file.getOriginalFilename()));
        // 目标文件
        String destFile = String.format("%s/%s", 
                destFolder, 
                fileName);
        // 文件访问路径
        String fileUrl = String.format("%s:%s%s", 
                ftpConfigBean.getAddress(), 
                ftpConfigBean.getNginxPort(), 
                destFile);
        
        FTPClient ftpClient = null;
        try {
            // FTP 客户端，用户名密码登陆
            ftpClient = new FTPClient();
            ftpClient.connect(ftpConfigBean.getAddress(), ftpConfigBean.getPort());
            ftpClient.login(ftpConfigBean.getUserName(), ftpConfigBean.getPassword());
            // 获取连接返回状态码
            int replyCode = ftpClient.getReplyCode();
            // 如果返回状态不在 200 ~ 300，则认为连接失败
            if (!FTPReply.isPositiveCompletion(replyCode)) {
                ftpClient.disconnect();
                return new Result<String>(Result.ResultStatus.FAILED.code, "Connect failed.");
            }
            
            // 判断目标文件夹是否存在，不存在则创建
            replyCode = ftpClient.cwd(destFolder);
            if (!FTPReply.isPositiveCompletion(replyCode)) {
                ftpClient.mkd(destFolder);
            }
            
            // 设置上传的路径
            ftpClient.changeWorkingDirectory(destFolder);
            // 修改上传文件的格式为二进制
            ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
            // 上传文件
            if (!ftpClient.storeFile(fileName, file.getInputStream())) {
                return new Result<String>(Result.ResultStatus.FAILED.code, "Upload file failed.");
            }
            
            // 退出登录
            ftpClient.logout();
        } catch (IOException e) {
            e.printStackTrace();
            return new Result<>(Result.ResultStatus.FAILED.code, "Upload file failed.");
        } finally {
            try {
                // 关闭连接
                if (ftpClient.isConnected()) {
                    ftpClient.disconnect();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
        return new Result<String>(Result.ResultStatus.SUCCESS.code, "Upload file success.", fileUrl);
    }
    
    /**
     * -上传文件，sftp:// 协议，使用 jsch 包
     */
    public Result<String> uploadFileBySftp(MultipartFile file, String fileType, 
            String fileCategory, boolean useOriginalName) {
        
        String fileCategoryFolder = "default";
        FileType ft = FileType.getFileTypeByName(fileType);
        switch (ft) {
        case IMAGE:
            ImageCategory imageCategory = ImageCategory.getImageCategoryByName(fileCategory);
            fileCategoryFolder = imageCategory.name;
            break;
        default:
            break;
        }
        // 目标文件夹
        String destFolder = String.format("%s/%s/%s", 
                ftpConfigBean.getBasePath(),
                ft.typeFolder,
                fileCategoryFolder);
        // 文件名
        String fileName = useOriginalName ? 
                file.getOriginalFilename() : 
                String.format("%s.%s", 
                    System.currentTimeMillis(),
                    FileUtil.getFileType(file.getOriginalFilename()));
        // 目标文件
        String destFile = String.format("%s/%s", 
                destFolder, 
                fileName);
        // 文件访问路径
        String fileUrl = String.format("http://%s:%s/%s/%s/%s", 
                ftpConfigBean.getAddress(), 
                ftpConfigBean.getNginxPort(), 
                ft.typeFolder, 
                fileCategoryFolder, 
                fileName);
        
        ChannelSftp sftp = null;
        Session sshSession = null;
        try {
            // 创建 SFTP、Session 实例
            JSch jsch = new JSch();
            sshSession = jsch.getSession(
                    ftpConfigBean.getUserName(), 
                    ftpConfigBean.getAddress(), 
                    ftpConfigBean.getPort());
            
            // 用户名密码验证方式
//          sshSession.setPassword(ftpConfigBean.getPassword());
            // DSA、RSA 公私匙验证方式，证书带密码
            jsch.addIdentity(FtpUtil.class.getResource("/id_rsa").getPath(), ftpConfigBean.getPassword());
            
            // 配置
            Properties sshConfig = new Properties();
            // SSH 公钥检查机制 no、ask、yes
            sshConfig.put("StrictHostKeyChecking", "no");
            sshSession.setConfig(sshConfig);
            
            // 创建会话连接
            sshSession.connect();
            
            // 开启 SFTP 通道
            Channel channel = sshSession.openChannel("sftp");
            channel.connect();
            sftp = (ChannelSftp) channel;
            
            // 创建目录
            createDir(sftp, destFolder);
            
            // 上传文件
            sftp.put(file.getInputStream(), destFile);
        } catch (JSchException | SftpException | IOException e) {
            e.printStackTrace();
            return new Result<>(Result.ResultStatus.FAILED.code, "Upload file failed.");
        } finally {
            if (sftp != null) {
                sftp.quit();
            }
            if (sshSession != null) {
                sshSession.disconnect();
            }
        }
        
        return new Result<String>(Result.ResultStatus.SUCCESS.code, "Upload file success.", fileUrl);
    }
    
    // 创建文件夹
    private void createDir(ChannelSftp sftp, String destFolder) throws SftpException {
        String[] folders = destFolder.split("/");
        sftp.cd("/");
        for(String folder : folders) {
            if(folder.length() > 0) {
                try {
                    sftp.cd(folder);
                } catch (SftpException e) {
                    sftp.mkdir(folder);
                    sftp.cd(folder);
                }
            }
        }
    }
}

ImageServiceImpl

package com.sfac.common.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import com.sfac.common.service.ImageService;
import com.sfac.common.util.FtpUtil;
import com.sfac.entity.common.Result;
import com.sfac.entity.common.resource.FileType;
import com.sfac.entity.common.resource.ImageCategory;
import com.sfac.entity.util.FileUtil;

/**
 * Description: Image Service Impl
 * @author Jianghu
 * @date 2022-04-24 16:33:03
 */
@Service
public class ImageServiceImpl implements ImageService {
	
	@Autowired
	private FtpUtil ftpUtil;

@Override
	public Result<String> uploadImage(MultipartFile image, String imageCategory, boolean useOriginalName) {
		// 检查图片是否为空
        if (image.isEmpty()) {
            return new Result<>(Result.ResultStatus.FAILED.code, "Image is null.");
        }
        // 检查图片类型
        if (!FileUtil.isImage(image)) {
            return new Result<>(Result.ResultStatus.FAILED.code, "The file is not image.");
        }
        // 检查 imageCategory 是否正确
        ImageCategory category = ImageCategory.getImageCategoryByName(imageCategory);
        if (category == null) {
        	return new Result<>(Result.ResultStatus.FAILED.code, 
        			"The Image Category is error, like profile, excerpt, etc.");
        }
        // 检查图片尺寸大小
        Integer[] imageInfo = FileUtil.getImageInfo(image);
        if (imageInfo[0] > category.maxWidth || 
        		imageInfo[1] > category.maxHeight || 
        		imageInfo[2] > category.maxSize) {
        	return new Result<>(Result.ResultStatus.FAILED.code, 
        			String.format("The %s image do not exceed %d*%d, %dKB.", 
        					category.name, category.maxWidth, 
        					category.maxHeight, category.maxSize));
        }
        
		return ftpUtil.uploadFileBySftp(image, FileType.IMAGE.name, imageCategory, useOriginalName);
	}

}

 
package com.sfac.common.service.impl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import com.sfac.common.service.ImageService;
import com.sfac.common.util.FtpUtil;
import com.sfac.entity.common.Result;
import com.sfac.entity.common.resource.FileType;
import com.sfac.entity.common.resource.ImageCategory;
import com.sfac.entity.util.FileUtil;
/**
 * Description: Image Service Impl
 * @author Jianghu
 * @date 2022-04-24 16:33:03
 */
@Service
public class ImageServiceImpl implements ImageService {
    
    @Autowired
    private FtpUtil ftpUtil;
    @Override
    public Result<String> uploadImage(MultipartFile image, String imageCategory, boolean useOriginalName) {
        // 检查图片是否为空
        if (image.isEmpty()) {
            return new Result<>(Result.ResultStatus.FAILED.code, "Image is null.");
        }
        // 检查图片类型
        if (!FileUtil.isImage(image)) {
            return new Result<>(Result.ResultStatus.FAILED.code, "The file is not image.");
        }
        // 检查 imageCategory 是否正确
        ImageCategory category = ImageCategory.getImageCategoryByName(imageCategory);
        if (category == null) {
            return new Result<>(Result.ResultStatus.FAILED.code, 
                    "The Image Category is error, like profile, excerpt, etc.");
        }
        // 检查图片尺寸大小
        Integer[] imageInfo = FileUtil.getImageInfo(image);
        if (imageInfo[0] > category.maxWidth || 
                imageInfo[1] > category.maxHeight || 
                imageInfo[2] > category.maxSize) {
            return new Result<>(Result.ResultStatus.FAILED.code, 
                    String.format("The %s image do not exceed %d*%d, %dKB.", 
                            category.name, category.maxWidth, 
                            category.maxHeight, category.maxSize));
        }
        
        return ftpUtil.uploadFileBySftp(image, FileType.IMAGE.name, imageCategory, useOriginalName);
    }
}

ImageController

package com.sfac.common.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import com.sfac.common.service.ImageService;
import com.sfac.entity.common.Result;

/**
 * Description: Image Controller
 * @author Jianghu
 * @date 2022-04-25 13:40:09
 */
@RestController
@RequestMapping("/api/common")
public class ImageController {
	
	@Autowired
	private ImageService imageService;
	
	/**
	 * 127.0.0.1/api/common/image/profile?useOriginalName=false ---- post
	 */
	@PostMapping(value = "/image/{imageCategory}", consumes = "multipart/form-data")
	public Result<String> uploadImage(
			@RequestParam MultipartFile file, 
			@PathVariable String imageCategory, 
			@RequestParam(defaultValue = "false", required = false) boolean useOriginalName) {
		return imageService.uploadImage(file, imageCategory, useOriginalName);
	}
}

 
package com.sfac.common.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import com.sfac.common.service.ImageService;
import com.sfac.entity.common.Result;
/**
 * Description: Image Controller
 * @author Jianghu
 * @date 2022-04-25 13:40:09
 */
@RestController
@RequestMapping("/api/common")
public class ImageController {
    
    @Autowired
    private ImageService imageService;
    
    /**
     * 127.0.0.1/api/common/image/profile?useOriginalName=false ---- post
     */
    @PostMapping(value = "/image/{imageCategory}", consumes = "multipart/form-data")
    public Result<String> uploadImage(
            @RequestParam MultipartFile file, 
            @PathVariable String imageCategory, 
            @RequestParam(defaultValue = "false", required = false) boolean useOriginalName) {
        return imageService.uploadImage(file, imageCategory, useOriginalName);
    }
}

验证

启动项目；
Postman 测试

http://www.sfac.xyz:8000/images/profile/1650874597429.jpg

JWT 认证

思路

用户登录微服务生成 JWT 字符串返回前端；
VuexStore 拿到 JWT 后，做如下处理：

在 LocalStorage 中保存为 ToKen（JWT 字符串）、TokenObject（JWT Decode 后的对象）；
在 VuexStore state 中保存 TokenObject；
在 VuexStore getters 中提供 isLogin 方法，判断 TokenObject 是否为空，以及是否过期；

main.js 中 Vue Router 注册全局前置守卫，进行登录验证；
在调用后端接口时，从 LocalStorage 中取出 ToKen，设置在请求头中传给接口；
请求后端接口全部由路由控制，创建过滤器，捕获请求头中的 Token 信息，并做验证，验证通过则真正调用接口，否则返回错误状态码；

后端部分

Entity 项目

说明：Account 微服务和 Gateway 微服务均需要 JWT 依赖，所以将 JWT 放在 Entity 项目中，微服务引入 Entity 即可；
Pom 依赖

 
<!-- jwt -->
<dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>3.18.3</version>
</dependency>

JwtUtil

JWT 工具类；

package com.sfac.entity.util;

import java.util.Date;

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.Claim;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.auth0.jwt.interfaces.JWTVerifier;
import com.sfac.entity.account.User;

/**
 * Description: Jwt Util
 * @author JiangHu
 * @date 2022-04-14 16:53:49
 */
public class JwtUtil {
	// 过期时间，毫秒
	private static final Long EXPIRES_TIME = 1 * 60 * 60 * 1000L;
	public static final String TOKEN_SALT = "JiangHu";

/**
	 * -创建用户令牌
	 */
	public static String createUserToken(User user, long expTime) {
		Date currentDate = new Date();
		Date expDate = new Date(System.currentTimeMillis() + expTime);

return JWT.create().withAudience(user.getId() + "") // 签发对象
				.withIssuedAt(currentDate) // 发行时间
				.withExpiresAt(expDate) // 有效期
				.withClaim("id", user.getId()) // Payload 载荷，可按官方推荐，也可自定义，可有多个
				.sign(Algorithm.HMAC256(user.getId() + TOKEN_SALT)); // 使用 HMAC256 加密算法，生成签名
	}
	
	public static String createUserToken(User user) {
		return createUserToken(user, EXPIRES_TIME);
	}
	
	/**
	 * - 获取令牌中的签发对象
	 */
	public static String getAudience(String token) {
		String audience = null;
		try {
			audience = JWT.decode(token).getAudience().get(0);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return audience;
	}

/**
	 * - 用签发对象验证令牌
	 */
	public static DecodedJWT verifyToken(String token, String secret) {
		DecodedJWT decodedJWT = null;
		try {
			JWTVerifier jWTVerifier = JWT.require(Algorithm.HMAC256(secret + TOKEN_SALT)).build();
			decodedJWT = jWTVerifier.verify(token);
		} catch (Exception e) {
			e.printStackTrace();
		}

return decodedJWT;
	}

/**
	 * - 根据名字获取载荷内容
	 */
	public static Claim getClaimByName(String token, String claimName) {
		return JWT.decode(token).getClaim(claimName);
	}

public static void main(String[] args) {
		User user = new User();
		user.setId(1);
		String token = JwtUtil.createUserToken(user);
		System.out.println(token);
		System.out.println(JwtUtil.verifyToken(token, user.getId() + "").getClaims());
		System.out.println(JwtUtil.verifyToken(token, "2"));
		System.out.println(JwtUtil.getAudience(token));
		System.out.println(JwtUtil.getClaimByName(token, "id"));
	}
}

 
package com.sfac.entity.util;
import java.util.Date;
import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.Claim;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.auth0.jwt.interfaces.JWTVerifier;
import com.sfac.entity.account.User;
/**
 * Description: Jwt Util
 * @author JiangHu
 * @date 2022-04-14 16:53:49
 */
public class JwtUtil {
    // 过期时间，毫秒
    private static final Long EXPIRES_TIME = 1 * 60 * 60 * 1000L;
    public static final String TOKEN_SALT = "JiangHu";
    /**
     * -创建用户令牌
     */
    public static String createUserToken(User user, long expTime) {
        Date currentDate = new Date();
        Date expDate = new Date(System.currentTimeMillis() + expTime);
        return JWT.create().withAudience(user.getId() + "") // 签发对象
                .withIssuedAt(currentDate) // 发行时间
                .withExpiresAt(expDate) // 有效期
                .withClaim("id", user.getId()) // Payload 载荷，可按官方推荐，也可自定义，可有多个
                .sign(Algorithm.HMAC256(user.getId() + TOKEN_SALT)); // 使用 HMAC256 加密算法，生成签名
    }
    
    public static String createUserToken(User user) {
        return createUserToken(user, EXPIRES_TIME);
    }
    
    /**
     * - 获取令牌中的签发对象
     */
    public static String getAudience(String token) {
        String audience = null;
        try {
            audience = JWT.decode(token).getAudience().get(0);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return audience;
    }
    /**
     * - 用签发对象验证令牌
     */
    public static DecodedJWT verifyToken(String token, String secret) {
        DecodedJWT decodedJWT = null;
        try {
            JWTVerifier jWTVerifier = JWT.require(Algorithm.HMAC256(secret + TOKEN_SALT)).build();
            decodedJWT = jWTVerifier.verify(token);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return decodedJWT;
    }
    /**
     * - 根据名字获取载荷内容
     */
    public static Claim getClaimByName(String token, String claimName) {
        return JWT.decode(token).getClaim(claimName);
    }
    public static void main(String[] args) {
        User user = new User();
        user.setId(1);
        String token = JwtUtil.createUserToken(user);
        System.out.println(token);
        System.out.println(JwtUtil.verifyToken(token, user.getId() + "").getClaims());
        System.out.println(JwtUtil.verifyToken(token, "2"));
        System.out.println(JwtUtil.getAudience(token));
        System.out.println(JwtUtil.getClaimByName(token, "id"));
    }
}

Account 微服务

Pom 引入 Entity 项目；
UserServiceImpl

 
@Override
public Result<String> login(User user) {
    User temp = userDao.getUserByUserNameAndPassword(
            user.getUserName(), MD5Util.getMD5(user.getPassword()));
    if (temp == null) {
        return new Result<String>(Result.ResultStatus.FAILED.code, "UserName or Password is error.");
    }
    
    // 创建令牌并返回
    String token = JwtUtil.createUserToken(temp);
    return new Result<String>(Result.ResultStatus.SUCCESS.code, "Login success", token);
}

UserController

 
/**
 * 127.0.0.1/api/account/login ---- post
 */
@PostMapping(value = "/login", consumes = "application/json")
public Result<String> login(@RequestBody User user) {
    return userService.login(user);
}

Gateway 项目

Pom 引入 Entity 依赖；
AuthorizeFilter

自定义全局过滤器；

package com.sfac.gateway.filter;

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.lang3.StringUtils;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;

import com.auth0.jwt.interfaces.DecodedJWT;
import com.sfac.entity.util.JwtUtil;

import reactor.core.publisher.Mono;

/**
 * Description: Authorize Filter
 * @author Jianghu
 * @date 2022-04-15 14:29:49
 */
@Component
public class AuthorizeFilter implements GlobalFilter, Ordered {
	
	public static List<String> PASS_URLS = new ArrayList<String>();
	static {
		PASS_URLS.add("/api/account/login");
		PASS_URLS.add("/api/account/user");
        PASS_URLS.add("/static/.*?");
	};

/**
	 * -过滤器优先级，数值越小优先级越高
	 */
	@Override
	public int getOrder() {
		return 0;
	}

@Override
	public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
		// 获取 Request、Response
		ServerHttpRequest request = exchange.getRequest();
		ServerHttpResponse response = exchange.getResponse();
		
		// 获取 URI，并放行无需权限的接口
		String uri = request.getURI().getPath();
        String result = passUrls.stream()
        //		.filter(item -> item.equals(uri) || uri.startsWith(item))
                .filter(item -> uri.matches(item))
                .findFirst()
                .orElse("");
        if (StringUtils.isNotBlank(result)) {
            return chain.filter(exchange);
        }
		
		// 从请求头中获取 token
		HttpHeaders headers = request.getHeaders();
		String token = headers.getFirst("Token");
		if (StringUtils.isBlank(token)) {
			// 若 token 为空则返回 401
			response.setStatusCode(HttpStatus.UNAUTHORIZED);
			return response.setComplete();
		}
		
		// 获取 token 中签发对象并验证令牌
		String id = JwtUtil.getAudience(token);
		DecodedJWT decodedJWT = JwtUtil.verifyToken(token, id);
		if (decodedJWT == null) {
			response.setStatusCode(HttpStatus.UNAUTHORIZED);
			return response.setComplete();
		}
		
		return chain.filter(exchange);
	}
}

 
package com.sfac.gateway.filter;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.lang3.StringUtils;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.sfac.entity.util.JwtUtil;
import reactor.core.publisher.Mono;
/**
 * Description: Authorize Filter
 * @author Jianghu
 * @date 2022-04-15 14:29:49
 */
@Component
public class AuthorizeFilter implements GlobalFilter, Ordered {
    
    public static List<String> PASS_URLS = new ArrayList<String>();
    static {
        PASS_URLS.add("/api/account/login");
        PASS_URLS.add("/api/account/user");
        PASS_URLS.add("/static/.*?");
    };
    /**
     * -过滤器优先级，数值越小优先级越高
     */
    @Override
    public int getOrder() {
        return 0;
    }
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 获取 Request、Response
        ServerHttpRequest request = exchange.getRequest();
        ServerHttpResponse response = exchange.getResponse();
        
        // 获取 URI，并放行无需权限的接口
        String uri = request.getURI().getPath();
        String result = passUrls.stream()
        //      .filter(item -> item.equals(uri) || uri.startsWith(item))
                .filter(item -> uri.matches(item))
                .findFirst()
                .orElse("");
        if (StringUtils.isNotBlank(result)) {
            return chain.filter(exchange);
        }
        
        // 从请求头中获取 token
        HttpHeaders headers = request.getHeaders();
        String token = headers.getFirst("Token");
        if (StringUtils.isBlank(token)) {
            // 若 token 为空则返回 401
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return response.setComplete();
        }
        
        // 获取 token 中签发对象并验证令牌
        String id = JwtUtil.getAudience(token);
        DecodedJWT decodedJWT = JwtUtil.verifyToken(token, id);
        if (decodedJWT == null) {
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return response.setComplete();
        }
        
        return chain.filter(exchange);
    }
}

前端部分

参见 JavaScript_Vue_Admin_3.x 中 Storage 组件、VuexStore 组件、Request 组件、登陆组件；

资源分级

思路

目标：不同用户访问不同资源。
资源（文档、音频、视频、人物）使用 Grade 属性控制等级；
GateWay 身份验证过滤器中，将用户 ID 设置到请求头中；
Entity 项目新增 ResourceLevel 自定义注解，grade 属性标注资源等级；
方案一

Entity 项目新增 ResourceAop 切面，切入 ResourceLevel 方法，环绕通知中，根据用户 ID 设置 ResourceLevel 注解 grade 值；
微服务接口中，若需要添加资源等级控制，在方法上添加 ResourceLevel 注解，利用反射获取 grade 值，再根据 grade 值到数据库查询资源。

方案二

Entity 项目新增 ResourceAop 切面，切入 ResourceLevel 方法，@AfterReturning 通知，获取用户 ID 以及目标返回对象等级，来设定响应码，并修改返回对象。

网关

AuthorizeFilter.java

 
// 请求头中封装 userId
ServerHttpRequest.Builder requestBuilder = request.mutate();
requestBuilder.headers(item -> item.set(SfacConstant.HEADER_USER_ID, id));
requestBuilder.headers(item -> item.set(SfacConstant.HEADER_USER_TOKEN, token));
exchange = exchange.mutate().request(requestBuilder.build()).build();

Entity 项目

ResourceLevel.java

1
package com.sfac.entity.common.resource; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * Description: ResourceLevel * @author JiangHu * @date 2023-12-13 09:39:14 */ @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface ResourceLevel { int grade() default 1; }
1
package com.sfac.entity.common.resource;
2
3
import java.lang.annotation.ElementType;
4
import java.lang.annotation.Retention;
5
import java.lang.annotation.RetentionPolicy;
6
import java.lang.annotation.Target;
7
8
/**
9
* Description: ResourceLevel
10
* @author JiangHu
11
* @date 2023-12-13 09:39:14
12
*/
13
@Target(ElementType.METHOD)
14
@Retention(RetentionPolicy.RUNTIME)
15
public @interface ResourceLevel {
16

17
int grade() default 1;
18
}
19
2

ResourceAop.java

package com.sfac.entity.config;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.time.LocalDateTime;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import com.sfac.entity.common.SfacConstant;
import com.sfac.entity.common.resource.ResourceGrade;
import com.sfac.entity.common.resource.ResourceLevel;

/**
 * Description: ResourceAop
 * @author JiangHu
 * @date 2023-12-13 09:54:59
 */
@Aspect
@Component
public class ResourceAop {
	
	@Pointcut("@annotation(com.sfac.entity.common.resource.ResourceLevel)")
	@Order(1)
	public void annotationPointCut(){}
	
	/**
	 * - 方案二
	 * - 返回结果通知，获取 userId 和资源 grade，以此做分级处理
	 * @param joinPoint
	 * @param result
	 */
	@SuppressWarnings("rawtypes")
	@AfterReturning(pointcut="annotationPointCut()", returning="result")
	public Object afterMethod(JoinPoint joinPoint, Object result) {
		
		if (result == null) {
			return result;
		}
		
		// 获取 request、response
		ServletRequestAttributes servletRequestAttributes =
				(ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
		HttpServletRequest request = servletRequestAttributes.getRequest();
		HttpServletResponse response = servletRequestAttributes.getResponse();
		
		// 获取 userId
		String userId = request.getHeader(SfacConstant.HEADER_USER_ID);
		
		int grade = 1;
		try {
			// 反射获取 result 对象的 grade 属性值
			Class clazz = result.getClass();
			Field field = clazz.getDeclaredField("grade");
			field.setAccessible(true);
			grade = field.getInt(result);
			
			if (StringUtils.isNotBlank(userId) && !userId.equals("1") && grade > 1) {
				// 设置返回状态码
				response.setStatus(HttpStatus.FORBIDDEN.value());
				
				// 改变返回值，注意不能返回新的对象，只能在原有对象上修改
				Field[] fields = clazz.getDeclaredFields();
				for (Field item : fields) {
					item.setAccessible(true);
					if ("serialVersionUID".equals(item.getName())) {
						continue;
					}
					
					Class cl = item.getType();
					// 判断属性是否是基本类型
					if (!item.getType().isPrimitive()) {
						item.set(result, null);
					} else if (cl.equals(LocalDateTime.class)) {
						item.set(result, null);
					} else if (cl.equals("boolean")) {
						item.set(result, false);
					} else {
						item.set(result, 0);
					} 
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return result;
	}
	
	/**
	 * - 方案一
	 * - 环绕注解通知，@annotation(resourceLevel) ，参数值必须和定义一致
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
//	@Around(value="@annotation(resourceLevel)")
    public Object aroundMethod(ProceedingJoinPoint proceedingJoinPoint, ResourceLevel resourceLevel)
            throws Throwable {
		ServletRequestAttributes servletRequestAttributes =
                (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = servletRequestAttributes.getRequest();
        String userId = request.getHeader(SfacConstant.HEADER_USER_ID);
        // 获取注解参数处理器
        InvocationHandler handler = Proxy.getInvocationHandler(resourceLevel);
        // memberValues 字段存储注解实例的所有属性键值对
        Field memberValuesField = handler.getClass().getDeclaredField("memberValues");
        memberValuesField.setAccessible(true);
        // 获取该实例的所有属性键值对，并修改值
        Map memberValues = (Map) memberValuesField.get(handler);
        if (StringUtils.isNotBlank(userId) && userId.equals("1")) {
        	memberValues.put("grade", ResourceGrade.GRADE_THREE.code);
        } else  {
        	memberValues.put("grade", ResourceGrade.GRADE_ONE.code);
        }
		
        return proceedingJoinPoint.proceed(proceedingJoinPoint.getArgs());
    }

}

 
package com.sfac.entity.config;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.time.LocalDateTime;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import com.sfac.entity.common.SfacConstant;
import com.sfac.entity.common.resource.ResourceGrade;
import com.sfac.entity.common.resource.ResourceLevel;
/**
 * Description: ResourceAop
 * @author JiangHu
 * @date 2023-12-13 09:54:59
 */
@Aspect
@Component
public class ResourceAop {
    
    @Pointcut("@annotation(com.sfac.entity.common.resource.ResourceLevel)")
    @Order(1)
    public void annotationPointCut(){}
    
    /**
     * - 方案二
     * - 返回结果通知，获取 userId 和资源 grade，以此做分级处理
     * @param joinPoint
     * @param result
     */
    @SuppressWarnings("rawtypes")
    @AfterReturning(pointcut="annotationPointCut()", returning="result")
    public Object afterMethod(JoinPoint joinPoint, Object result) {
        
        if (result == null) {
            return result;
        }
        
        // 获取 request、response
        ServletRequestAttributes servletRequestAttributes =
                (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = servletRequestAttributes.getRequest();
        HttpServletResponse response = servletRequestAttributes.getResponse();
        
        // 获取 userId
        String userId = request.getHeader(SfacConstant.HEADER_USER_ID);
        
        int grade = 1;
        try {
            // 反射获取 result 对象的 grade 属性值
            Class clazz = result.getClass();
            Field field = clazz.getDeclaredField("grade");
            field.setAccessible(true);
            grade = field.getInt(result);
            
            if (StringUtils.isNotBlank(userId) && !userId.equals("1") && grade > 1) {
                // 设置返回状态码
                response.setStatus(HttpStatus.FORBIDDEN.value());
                
                // 改变返回值，注意不能返回新的对象，只能在原有对象上修改
                Field[] fields = clazz.getDeclaredFields();
                for (Field item : fields) {
                    item.setAccessible(true);
                    if ("serialVersionUID".equals(item.getName())) {
                        continue;
                    }
                    
                    Class cl = item.getType();
                    // 判断属性是否是基本类型
                    if (!item.getType().isPrimitive()) {
                        item.set(result, null);
                    } else if (cl.equals(LocalDateTime.class)) {
                        item.set(result, null);
                    } else if (cl.equals("boolean")) {
                        item.set(result, false);
                    } else {
                        item.set(result, 0);
                    } 
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        return result;
    }
    
    /**
     * - 方案一
     * - 环绕注解通知，@annotation(resourceLevel) ，参数值必须和定义一致
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
//  @Around(value="@annotation(resourceLevel)")
    public Object aroundMethod(ProceedingJoinPoint proceedingJoinPoint, ResourceLevel resourceLevel)
            throws Throwable {
        ServletRequestAttributes servletRequestAttributes =
                (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = servletRequestAttributes.getRequest();
        String userId = request.getHeader(SfacConstant.HEADER_USER_ID);
        // 获取注解参数处理器
        InvocationHandler handler = Proxy.getInvocationHandler(resourceLevel);
        // memberValues 字段存储注解实例的所有属性键值对
        Field memberValuesField = handler.getClass().getDeclaredField("memberValues");
        memberValuesField.setAccessible(true);
        // 获取该实例的所有属性键值对，并修改值
        Map memberValues = (Map) memberValuesField.get(handler);
        if (StringUtils.isNotBlank(userId) && userId.equals("1")) {
            memberValues.put("grade", ResourceGrade.GRADE_THREE.code);
        } else  {
            memberValues.put("grade", ResourceGrade.GRADE_ONE.code);
        }
        
        return proceedingJoinPoint.proceed(proceedingJoinPoint.getArgs());
    }
}

微服务接口

JianghuCommonApplication.java

启动类添加组件扫描注解：@ComponentScan(basePackages= {"com.sfac.common.*", "com.sfac.entity.*"})

方案一

ElasticSearchServiceImpl.java

根据 grade 进行分类查询。

 
@Override
@ResourceLevel
@SuppressWarnings({ "rawtypes", "unchecked" })
public PageInfo<ElasticSearch> getModelsBySearch(String projectFlag, Search search) {
    // 获取注解值
    int grade = 1;
    try {
        Class clazz = ElasticSearchServiceImpl.class;
        Method method = clazz.getDeclaredMethod("getModelsBySearch", String.class, Search.class);
        ResourceLevel resourceLevel = method.getDeclaredAnnotation(ResourceLevel.class);
        grade = resourceLevel.grade();
    } catch (NoSuchMethodException | SecurityException e) {
        e.printStackTrace();
    }
    …………
}

FTServiceImpl.java

查询资源和 grade 比较，返回错误状态码

 
// 判断资源权限
try {
    Class clazz = FTServiceImpl.class;
    Method method = clazz.getDeclaredMethod("getModelById", int.class, int.class);
    ResourceLevel resourceLevel = method.getDeclaredAnnotation(ResourceLevel.class);
    if (ft.getGrade() > resourceLevel.grade()) {
        ServletRequestAttributes servletRequestAttributes =
                (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletResponse response = servletRequestAttributes.getResponse();
        response.setStatus(HttpStatus.FORBIDDEN.value());
        return null;
    }
} catch (Exception e) {
    e.printStackTrace();
}

方案二

在需要资源分级的方法上添加 @ResourceLevel 注解。

前言

简介

组件

Nacos

简介

安装与应用

Parent Project

Entity Module

Service Module Test