SpringCloud#

1
@Bean
2
public RestTemplate restTemplate() {
3
    return new RestTemplate();
4
}

1
@RequiredArgsConstructor
2

3

4
private final RestTemplate restTemplate; // final修饰成员变量，意味着必须初始化

1
ResponseEntity<List<ItemDTO>> response = restTemplate.exchange("http://localhost:8081/items?ids={ids}",
2
        HttpMethod.GET,
3
        null,
4
        new ParameterizedTypeReference<List<ItemDTO>>() {},
5
        Map.of("ids", CollUtil.join(itemIds, ",")));
6
if (!response.getStatusCode().is2xxSuccessful()) {
7
    return;
8
}
9
List<ItemDTO> items = response.getBody();
10
if (CollUtils.isEmpty(items)) {
11
    return;
12
}

1
<!--nacos 服务注册发现-->
2
<dependency>
3
    <groupId>com.alibaba.cloud</groupId>
4
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
5
</dependency>

1
spring:
2
  application:
3
    name: item-service # 服务名称
4
  cloud:
5
    nacos:
6
      server-addr: 192.168.146.131:8848 # nacos地址

1
<!--nacos 服务注册发现-->
2
<dependency>
3
    <groupId>com.alibaba.cloud</groupId>
4
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
5
</dependency>

1
spring:
2
  cloud:
3
    nacos:
4
      server-addr: 192.168.150.101:8848

1
@RequiredArgsConstructor
2
public class
3

4

5
private final DiscoveryClient discoveryClient;
6

7

8

9
// 1.根据服务名称，拉取服务的实例列表
10
List<ServiceInstance> instances = discoveryClient.getInstances("item-service");
11
if (CollUtils.isEmpty(instances)) {
12
    return;
13
}
14
// 2.负载均衡，挑选一个实例
15
ServiceInstance instance = instances.get(RandomUtil.randomInt(instances.size()));
16
// 3.获取实例的IP和端口
17
ResponseEntity<List<ItemDTO>> response = restTemplate.exchange(instance.getUri() + "/items?ids={ids}",
18
        HttpMethod.GET,
19
        null,
20
        new ParameterizedTypeReference<List<ItemDTO>>() {
21
        },
22
        Map.of("ids", CollUtil.join(itemIds, ",")));

1
  <!--openFeign-->
2
  <dependency>
3
      <groupId>org.springframework.cloud</groupId>
4
      <artifactId>spring-cloud-starter-openfeign</artifactId>
5
  </dependency>
6
  <!--负载均衡器-->
7
  <dependency>
8
      <groupId>org.springframework.cloud</groupId>
9
      <artifactId>spring-cloud-starter-loadbalancer</artifactId>
10
  </dependency>

1
@MapperScan("com.hmall.cart.mapper")
2
@SpringBootApplication
3
@EnableFeignClients
4
public class CartApplication {
5
    public static void main(String[] args) {
6
        SpringApplication.run(CartApplication.class, args);
7
    }
8

9
    @Bean
10
    public RestTemplate restTemplate() {
11
        return new RestTemplate();
12
    }
13
}

1
@FeignClient("item-service")
2
public interface ItemClient {
3

4
    @GetMapping("/items")
5
    List<ItemDTO> queryItemByIds(@RequestParam("ids") Collection ids);
6
}

1
@RequiredArgsConstructor
2

3
private final ItemClient itemClient;
4

5

6
Set<Long> itemIds = vos.stream().map(CartVO::getItemId).collect(Collectors.toSet());
7

8
List<ItemDTO> items = itemClient.queryItemByIds(itemIds);
9

10
if (CollUtils.isEmpty(items)) {
11
    return;
12
}

1
<!--OK http 的依赖 -->
2
<dependency>
3
  <groupId>io.github.openfeign</groupId>
4
  <artifactId>feign-okhttp</artifactId>
5
</dependency>

1
feign:
2
  okhttp:
3
    enabled: true # 开启OKHttp功能

1
 <!--open feign-->
2
<dependency>
3
    <groupId>org.springframework.cloud</groupId>
4
    <artifactId>spring-cloud-starter-openfeign</artifactId>
5
</dependency>
6
<!-- load balancer-->
7
<dependency>
8
    <groupId>org.springframework.cloud</groupId>
9
    <artifactId>spring-cloud-starter-loadbalancer</artifactId>
10
</dependency>
11
<!-- swagger 注解依赖 -->
12
<dependency>
13
    <groupId>io.swagger</groupId>
14
    <artifactId>swagger-annotations</artifactId>
15
    <version>1.6.6</version>
16
    <scope>compile</scope>
17
</dependency>

1
  <!--feign模块-->
2
  <dependency>
3
      <groupId>com.heima</groupId>
4
      <artifactId>hm-api</artifactId>
5
      <version>1.0.0</version>
6
  </dependency>

1
@EnableFeignClients(basePackages = "com.hmall.api.client")
2
public class CartApplication {}

1
@EnableFeignClients(clients = {ItemClient.class})
2
public class CartApplication {}

1
import feign.Logger;
2
import org.springframework.context.annotation.Bean;
3

4
public class DefaultFeignConfig {
5
    @Bean
6
    public Logger.Level feignLogLevel(){
7
        return Logger.Level.FULL;
8
    }
9
}

1
@FeignClient(value = "item-service", configuration = DefaultFeignConfig.class)

1
@EnableFeignClients(defaultConfiguration = DefaultFeignConfig.class)

1
22:18:52:730 DEBUG 9844 --- [nio-8082-exec-1] com.hmall.api.client.ItemClient          : [ItemClient#queryItemByIds] <--- HTTP/1.1 200  (1280ms)
2
22:18:52:730 DEBUG 9844 --- [nio-8082-exec-1] com.hmall.api.client.ItemClient          : [ItemClient#queryItemByIds] connection: keep-alive
3
22:18:52:730 DEBUG 9844 --- [nio-8082-exec-1] com.hmall.api.client.ItemClient          : [ItemClient#queryItemByIds] content-type: application/json
4
22:18:52:730 DEBUG 9844 --- [nio-8082-exec-1] com.hmall.api.client.ItemClient          : [ItemClient#queryItemByIds] date: Fri, 09 May 2025 14:18:52 GMT
5
22:18:52:730 DEBUG 9844 --- [nio-8082-exec-1] com.hmall.api.client.ItemClient          : [ItemClient#queryItemByIds] keep-alive: timeout=60
6
22:18:52:730 DEBUG 9844 --- [nio-8082-exec-1] com.hmall.api.client.ItemClient          : [ItemClient#queryItemByIds] transfer-encoding: chunked
7
22:18:52:730 DEBUG 9844 --- [nio-8082-exec-1] com.hmall.api.client.ItemClient          : [ItemClient#queryItemByIds]
8
22:18:52:732 DEBUG 9844 --- [nio-8082-exec-1] com.hmall.api.client.ItemClient          : [ItemClient#queryItemByIds] [{"id":"100000006163","name":"巴布豆(BOBDOG)柔薄悦动婴儿拉拉裤XXL码80片(15kg以上)","price":67100,"stock":10000,"image":"https://m.360buyimg.com/mobilecms/s720x720_jfs/t23998/350/2363990466/222391/a6e9581d/5b7cba5bN0c18fb4f.jpg!q70.jpg.webp","category":"拉拉裤","brand":"巴布豆","spec":"{}","sold":11,"commentCount":33343434,"isAD":false,"status":2}]
9
22:18:52:732 DEBUG 9844 --- [nio-8082-exec-1] com.hmall.api.client.ItemClient          : [ItemClient#queryItemByIds] <--- END HTTP (371-byte body)

1
 <dependencies>
2
    <!--common-->
3
    <dependency>
4
        <groupId>com.heima</groupId>
5
        <artifactId>hm-common</artifactId>
6
        <version>1.0.0</version>
7
    </dependency>
8
    <!--网关-->
9
    <dependency>
10
        <groupId>org.springframework.cloud</groupId>
11
        <artifactId>spring-cloud-starter-gateway</artifactId>
12
    </dependency>
13
    <!--nacos discovery-->
14
    <dependency>
15
        <groupId>com.alibaba.cloud</groupId>
16
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
17
    </dependency>
18
    <!--负载均衡-->
19
    <dependency>
20
        <groupId>org.springframework.cloud</groupId>
21
        <artifactId>spring-cloud-starter-loadbalancer</artifactId>
22
    </dependency>
23
</dependencies>
24
<build>
25
    <finalName>${project.artifactId}</finalName>
26
    <plugins>
27
        <plugin>
28
            <groupId>org.springframework.boot</groupId>
29
            <artifactId>spring-boot-maven-plugin</artifactId>
30
        </plugin>
31
    </plugins>
32
</build>

1
@SpringBootApplication
2
public class GatewayApplication {
3
    public static void main(String[] args) {
4
        SpringApplication.run(GatewayApplication.class, args);
5
    }
6
}

1
server:
2
  port: 8080
3
spring:
4
  application:
5
    name: gateway
6
  cloud:
7
    nacos:
8
      server-addr: 192.168.150.101:8848
9
    gateway:
10
      routes:
11
        - id: item # 路由规则id，自定义，唯一
12
          uri: lb://item-service # 路由的目标服务，lb代表负载均衡，会从注册中心拉取服务列表
13
          predicates: # 路由断言，判断当前请求是否符合当前规则，符合则路由到目标服务
14
            - Path=/items/**,/search/** # 这里是以请求路径作为判断规则
15
        - id: cart
16
          uri: lb://cart-service
17
          predicates:
18
            - Path=/carts/**
19
        - id: user
20
          uri: lb://user-service
21
          predicates:
22
            - Path=/users/**,/addresses/**
23
        - id: trade
24
          uri: lb://trade-service
25
          predicates:
26
            - Path=/orders/**
27
        - id: pay
28
          uri: lb://pay-service
29
          predicates:
30
            - Path=/pay-orders/**

1
@Component
2
public class JwtTool {
3
    private final JWTSigner jwtSigner;
4

5
    public JwtTool(KeyPair keyPair) {
6
        this.jwtSigner = JWTSignerUtil.createSigner("rs256", keyPair);
7
    }
8

9
    /**
10
     * 创建 access-token
11
     *
12
     * @param
13
     * @return access-token
14
     */
15
    public String createToken(Long userId, Duration ttl) {
16
        // 1.生成jws
17
        return JWT.create()
18
                .setPayload("user", userId)
19
                .setExpiresAt(new Date(System.currentTimeMillis() + ttl.toMillis()))
20
                .setSigner(jwtSigner)
21
                .sign();
22
    }
23

24
    /**
25
     * 解析token
26
     *
27
     * @param token token
28
     * @return 解析刷新token得到的用户信息
29
     */
30
    public Long parseToken(String token) {
31
        // 1.校验token是否为空
32
        if (token == null) {
33
            throw new UnauthorizedException("未登录");
34
        }
35
        // 2.校验并解析jwt
36
        JWT jwt;
37
        try {
38
            jwt = JWT.of(token).setSigner(jwtSigner);
39
        } catch (Exception e) {
40
            throw new UnauthorizedException("无效的token", e);
41
        }
42
        // 2.校验jwt是否有效
43
        if (!jwt.verify()) {
44
            // 验证失败
45
            throw new UnauthorizedException("无效的token");
46
        }
47
        // 3.校验是否过期
48
        try {
49
            JWTValidator.of(jwt).validateDate();
50
        } catch (ValidateException e) {
51
            throw new UnauthorizedException("token已经过期");
52
        }
53
        // 4.数据格式校验
54
        Object userPayload = jwt.getPayload("user");
55
        if (userPayload == null) {
56
            // 数据为空
57
            throw new UnauthorizedException("无效的token");
58
        }
59

60
        // 5.数据解析
61
        try {
62
           return Long.valueOf(userPayload.toString());
63
        } catch (RuntimeException e) {
64
            // 数据格式有误
65
            throw new UnauthorizedException("无效的token");
66
        }
67
    }
68
}

1
antPathMatcher.match("/user/*.json", "/user/profile.json"); // true
2
antPathMatcher.match("/**/*.html", "/pages/home/index.html"); // true

1
@Component
2
@RequiredArgsConstructor
3
@Slf4j
4
public class AuthGlobalFilter implements GlobalFilter, Ordered {
5

6
    private final AuthProperties authProperties;
7
    private final JwtTool jwtTool;
8
    private final AntPathMatcher antPathMatcher = new AntPathMatcher();
9

10
    @Override
11
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
12
        ServerHttpRequest request = exchange.getRequest();
13
        if (isExculed(request.getPath().toString())) {
14
            return chain.filter(exchange);
15
        }
16
        String token = null;
17
        List<String> headers = request.getHeaders().get("authorization");
18
        if (headers != null && !headers.isEmpty()) {
19
            token = headers.get(0);
20
        }
21
        Long userId = null;
22
        try {
23
            userId = jwtTool.parseToken(token);
24
        } catch (UnauthorizedException e) {
25
            ServerHttpResponse response = exchange.getResponse();
26
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
27
            return response.setComplete();
28
        }
29
        // 传递用户信息
30
        String userInfo = userId.toString();
31
        ServerWebExchange serverWebExchange = exchange.mutate()  // mutate就是对下游请求做更改
32
                .request(builder -> builder.header("user-info", userInfo))
33
                .build();
34
        log.info("userId:{}", userId);
35

36
        return chain.filter(serverWebExchange);
37
    }
38

39
    private boolean isExculed(String string) {
40
        for (String excludePath : authProperties.getExcludePaths()) {
41
            if (antPathMatcher.match(excludePath, string)) {
42
                return true;
43
            }
44
        }
45
        return false;
46
    }
47

48
    @Override
49
    public int getOrder() {
50
        return 0;
51
    }
52
}

1
public class DefaultFeignConfig {
2
    @Bean
3
    public Logger.Level feignLogLevel() {
4
        return Logger.Level.FULL;
5
    }
6

7
    @Bean
8
    public RequestInterceptor userInfoRequestInterceptor() {
9
        return new RequestInterceptor() {
10
            @Override
11
            public void apply(RequestTemplate requestTemplate) {
12
                Long userId = UserContext.getUser();
13
                if (userId != null) {
14
                    requestTemplate.header("user-info", userId.toString());
15
                }
16
            }
17
        };
18
    }
19
}

1
@EnableFeignClients(basePackages = "com.hmall.api.client", defaultConfiguration = DefaultFeignConfig.class)
2
public class TradeApplication {}

1
  <!--nacos配置管理-->
2
  <dependency>
3
      <groupId>com.alibaba.cloud</groupId>
4
      <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
5
  </dependency>
6
  <!--读取bootstrap文件-->
7
  <dependency>
8
      <groupId>org.springframework.cloud</groupId>
9
      <artifactId>spring-cloud-starter-bootstrap</artifactId>
10
  </dependency>

1
spring:
2
  application:
3
    name: cart-service # 服务名称
4
  profiles:
5
    active: dev
6
  cloud:
7
    nacos:
8
      server-addr: 192.168.146.131:8848 # nacos地址
9
      config:
10
        file-extension: yaml # 文件后缀名
11
        shared-configs: # 共享配置
12
          - dataId: shared-jdbc.yaml # 共享mybatis配置
13
          - dataId: shared-log.yaml # 共享日志配置
14
          - dataId: shared-swagger.yaml # 共享日志配置

1
server:
2
  port: 8082
3
feign:
4
  okhttp:
5
    enabled: true # 开启OKHttp连接池支持
6
hm:
7
  swagger:
8
    title: 购物车服务接口文档
9
    package: com.hmall.cart.controller
10
  db:
11
    database: hm-cart

1
@Service
2
@RequiredArgsConstructor
3
public class CartServiceImpl extends ServiceImpl<CartMapper, Cart> implements ICartService {}
4

5
private final CartProperties cartProperties;

1
  private void checkCartsFull(Long userId) {
2
        int count = lambdaQuery().eq(Cart::getUserId, userId).count().intValue();
3
        if (count >= cartProperties.getMaxItems()) {
4
            throw new BizIllegalException(StrUtil.format("用户购物车课程不能超过{}", cartProperties.getMaxItems()));
5
        }
6
    }

1
[服务名]-[spring.active.profile].[后缀名]

1
 <!--nacos配置管理-->
2
<dependency>
3
    <groupId>com.alibaba.cloud</groupId>
4
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
5
</dependency>
6
<!--读取bootstrap文件-->
7
<dependency>
8
    <groupId>org.springframework.cloud</groupId>
9
    <artifactId>spring-cloud-starter-bootstrap</artifactId>
10
</dependency>

1
@Slf4j
2
@Component
3
@RequiredArgsConstructor
4
public class DynamicRouteLoader {
5

6
    private final NacosConfigManager nacosConfigManager;
7
    private final RouteDefinitionWriter writer;
8

9
    private final String dataId = "gateway-routes.json";
10
    private final String group = "DEFAULT_GROUP";
11

12
    private final Set<String> routeIds = new HashSet<>();
13

14
    @PostConstruct
15
    public void initRouteConfigListener() throws NacosException {
16
        // 项目启动时，先拉取一次配置，并添加配置监听器
17
        String configInfo = nacosConfigManager.getConfigService()
18
                .getConfigAndSignListener(dataId, group, 5000, new Listener() {
19
                    @Override
20
                    public Executor getExecutor() {
21
                        return null;
22
                    }
23

24
                    @Override
25
                    public void receiveConfigInfo(String configInfo) {
26
                        // 2.监听到配置变更，更新路由表
27
                        updateConfigInfo(configInfo);
28
                    }
29
                });
30
        // 3.第一次读取到配置，也需要更新到路由表
31
        updateConfigInfo(configInfo);
32
    }
33

34
    public void updateConfigInfo(String configInfo) {
35
        log.debug("监听到路由配置信息：{}", configInfo);
36
        // 1.解析配置信息，转为RouteDefinition
37
        List<RouteDefinition> routeDefinitionList = JSONUtil.toList(configInfo, RouteDefinition.class);
38
        // 删除旧的路由表
39
        for (String routeId : routeIds) {
40
            writer.delete(Mono.just(routeId));
41
        }
42
        routeIds.clear();
43
        // 2.更新路由表
44
        for (RouteDefinition routeDefinition : routeDefinitionList) {
45
            // 更新路由表
46
            writer.save(Mono.just(routeDefinition)).subscribe();
47
            // 记录路由id，便于下一次更新时删除
48
            routeIds.add(routeDefinition.getId());
49
        }
50
    }
51
}