spring cloud内容汇总(各个功能模块、启动、部署)的详细过程

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

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
@Configuration
public class AppConfig {
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

restTemplate.getForObject(url, String.class);
// getForObject(String url, Class<T> responseType)：发起 GET 请求，并返回响应体。

restTemplate.postForObject(url, request, MyResponseObject.class);
// postForObject(String url, Object request, Class<T> responseType)：发起 POST 请求，将请求体发送给指定 URL，并返回响应体。

restTemplate.put(url, request);
// put(String url, Object request)：发起 PUT 请求，将请求体发送到指定 URL。

restTemplate.delete(url);
// delete(String url)：发起 DELETE 请求。

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
@EnableFeignClients  // 启用 Feign 客户端
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
@FeignClient(name = "account-service")  // 指定服务名称, 这里是指注册到naocs的服务名
public interface AccountClient {
    @GetMapping("/account/balance")
    String getBalance(@RequestParam("userId") String userId);
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class OrderController {
    @Autowired
    private AccountClient accountClient;
    @RequestMapping("/order/test")
    public String createOrder(String userId) {
        // 调用 Feign 客户端方法
        String balance = accountClient.getBalance(userId);
        return "Account balance: " + balance;
    }
}

<packaging>pom</packaging>
<dependencyManagement>
       <dependencies>
           <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-dependencies -->
           <dependency>
               <groupId>org.springframework.cloud</groupId>
               <artifactId>spring-cloud-dependencies</artifactId>
               <version>2023.0.3</version>
               <type>pom</type>
               <scope>import</scope>
           </dependency>
           <!-- https://mvnrepository.com/artifact/com.alibaba.cloud/spring-cloud-alibaba-dependencies -->
           <dependency>
               <groupId>com.alibaba.cloud</groupId>
               <artifactId>spring-cloud-alibaba-dependencies</artifactId>
               <version>2023.0.1.3</version>
               <type>pom</type>
               <scope>import</scope>
           </dependency>
       </dependencies>
   </dependencyManagement>

<parent>
    <groupId>com.cloud</groupId>
    <artifactId>learnCloudAlibaba</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <relativePath>../pom.xml</relativePath>
</parent>
<!-- 下面这个是我根项目的pom文件的内容, 要确保上面子项目中 parent 中的 groupid artifactId version 跟下面 根项目的一致-->
<!--    <groupId>com.cloud</groupId>-->
<!--    <artifactId>learnCloudAlibaba</artifactId>-->
<!--    <version>0.0.1-SNAPSHOT</version>-->

<!-- Nacos 服务注册和发现 -->
 <dependency>
     <groupId>com.alibaba.cloud</groupId>
     <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
 </dependency>

spring.cloud.nacos.discovery.server-addr=localhost:8848

.\startup.cmd -m standalone
# localhost:8848/nacos 进行访问, 默认账号密码都是 nacos

spring.cloud.nacos.discovery.namespace=命名空间id # 指定命令空间, 不同空间下的实例不可互相访问
spring.cloud.nacos.discovery.group=DEFAULT_GROUP # 默认是DEFAULT_GROUP，指定group，不同group下的实例不可互相访问
spring.cloud.nacos.discovery.cluster-name=BeiJing # 指定当前实例是哪个集群，一般按照地区划分，讲请求发送距离近的实例
spring.cloud.loadbalancer.nacos.enabled=true # 开启 优先向跟当前发送请求的实例 在同一集群的实例发送请求
spring.cloud.nacos.discovery.weight=1 # 当前实例的权值，权值在1-100，默认是1，权值越大越容易接收请求，一般给配置高的服务器权值高一些

CREATE DATABASE nacos_config;

mysql> use nacos_config;
Database changed
mysql> source D:\kafka\nacos\conf\mysql-schema.sql

server.port=8848 
spring.datasource.platform=mysql
spring.sql.init.platform=mysql
### Count of DB:
db.num=1
db.url.0=jdbc:mysql://127.0.0.1:3306/nacos_cofig?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
db.user.0=root
db.password.0=password

172.20.10.2:8848 # 前面是ip地址，内网的或是公网的
172.20.10.2:8860
172.20.10.2:8870

.\startup.cmd -m cluster

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

spring.cloud.loadbalancer.configurations=default

@Configuration
public class AppConfig {
    @Bean
    @LoadBalanced  // 启用 RestTemplate 的负载均衡
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

@Autowired
private RestTemplate restTemplate;
public String callService() {
    // 使用服务名代替实际地址
    return restTemplate.getForObject("http://module2/api/v1/data", String.class);
}

@Autowired
    RestTemplate restTemplate;
    @GetMapping("/test")
    public String test() {
        String module2 = restTemplate.getForObject("http://module2/api/test", String.class);
        String module3 = restTemplate.getForObject("http://module3/api/test", String.class);
        return module2 + "\n" + module3;
    }

@GetMapping("/api/test")
    public String test() {
        System.out.println("module2 test");
        return "module2 test";
    }

@GetMapping("/api/test")
    public String test() {
        System.out.println("module3 test");
        return "module3 test";
    }

@Configuration
public class DefaultLoadBalancerConfig {
    @Bean
    ReactorLoadBalancer<ServiceInstance> roundRobinLoadBalancer(Environment environment,
                                                                LoadBalancerClientFactory loadBalancerClientFactory) {
        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME); // 获取负载均衡器名称
        return new RoundRobinLoadBalancer(loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name);
    }
}

@Configuration
public class RandomLoadBalancerConfig {
    @Bean
        // 定义一个Bean
    ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(Environment environment, // 注入环境变量
                                                            LoadBalancerClientFactory loadBalancerClientFactory) { // 注入负载均衡器客户端工厂
        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME); // 获取负载均衡器的名称
        // 创建并返回一个随机负载均衡器实例
        return new RandomLoadBalancer(loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name);
    }
}

// module2 使用默认，module3 使用随机
@Configuration
@LoadBalancerClients({
        @LoadBalancerClient(value = "module2", configuration = RandomLoadBalancerConfig.class),
        @LoadBalancerClient(value = "module3", configuration = DefaultLoadBalancerConfig.class)
})
public class AppConfig {
    @Bean
    @LoadBalanced  // 启用 RestTemplate 的负载均衡
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

 server:
   port: 7091
 spring:
   application:
     name: seata-server
 logging:
   config: classpath:logback-spring.xml
   file:
     path: ${log.home:${user.home}/logs/seata}
   extend:
     logstash-appender:
       destination: 127.0.0.1:4560
     kafka-appender:
       bootstrap-servers: 127.0.0.1:9092
       topic: logback_to_logstash
 console:
   user:
     username: seata
     password: seata
 seata:
   config:
     # support: nacos, consul, apollo, zk, etcd3
     type: nacos
     nacos:
       server-addr: 127.0.0.1:8848
       namespace:
       group: SEATA_GROUP
       username: nacos
       password: nacos
   registry:
     # support: nacos, eureka, redis, zk, consul, etcd3, sofa
     type: nacos
     nacos:
       application: seata-server
       server-addr: 127.0.0.1:8848
       group: SEATA_GROUP
       namespace:
       cluster: default
       username: nacos
       password: nacos
   store:
     # support: file 、 db 、 redis 、 raft
     mode: db
   db:
       datasource: druid
       db-type: mysql
       driver-class-name: com.mysql.jdbc.Driver
       url: jdbc:mysql://127.0.0.1:3306/seata?rewriteBatchedStatements=true
       user: mysql
       password: mysql
       min-conn: 10
       max-conn: 100
       global-table: global_table
       branch-table: branch_table
       lock-table: lock_table
       distributed-lock-table: distributed_lock
       query-limit: 1000
       max-wait: 5000
   #  server:
   #    service-port: 8091 #If not configured, the default is '${server.port} + 1000'
   security:
     secretKey: SeataSecretKey0c382ef121d778043159209298fd40bf3850a017
     tokenValidityInMilliseconds: 1800000
     ignore:
       urls: /,/**/*.css,/**/*.js,/**/*.html,/**/*.map,/**/*.svg,/**/*.png,/**/*.jpeg,/**/*.ico,/api/v1/auth/login,/metadata/v1/**

sh bin/seata-server.sh

<dependency>
   <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
    <exclusions>
        <exclusion>
            <groupId>io.seata</groupId>
            <artifactId>seata-spring-boot-starter</artifactId>
        </exclusion>
    </exclusions>
</dependency>

seata:
  registry:
    type: nacos
    nacos:
      server-addr: localhost:8848
      namespace: ""
      group: SEATA_GROUP # 组名  跟我们之前配置的seata的配置文件的是对应的
      application: seata-server # 服务名 跟我们之前配置的seata的配置文件的是对应的
  tx-service-group: default_tx_group
  service:
    vgroup-mapping:
      default_tx_group: default
  data-source-proxy-mode: AT

@GlobalTransactional(name = "your-global-tx-name", rollbackFor = Exception.class)
public void yourMethod() {
    // Your business logic
}

@RestController
public class CreateOrderController {
    @Autowired
    OrderMapper orderMapper;
    @Autowired
    RestTemplate restTemplate;
    @RequestMapping("/order/test")
    @GlobalTransactional(name = "create-order", rollbackFor = Exception.class)
    public String createOrder(@RequestParam String userId,
                              @RequestParam String commodityCode,
                              @RequestParam Integer count,
                              @RequestParam Integer money
    ) {
        // 创建订单
        Order order = new Order(null, userId, commodityCode, count, money);
        orderMapper.insert(order);
        // 扣除账户余额
        Map<String, String> mp1 = new HashMap<>();
        mp1.put("userId", userId);
        mp1.put("money", money.toString());
        String resp1 = restTemplate.postForObject("http://localhost:8001/account/test", mp1, String.class);
        // 减去用户购买商品数量，更新库存
        Map<String, String> mp2 = new HashMap<>();
        mp2.put("commodityCode", commodityCode);
        mp2.put("count", count.toString());
        String resp2 = restTemplate.postForObject("http://localhost:8003/storage/test", mp2, String.class);
        if ("ok".equals(resp1) && "ok".equals(resp2)) {
            return "ok";
        }
        return "error";
    }
}

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

spring.cloud.sentinel.transport.dashboard=localhost:8888

@SentinelResource(value = "myResource", blockHandler = "handleBlock")
public String someMethod() {
    // 你的业务逻辑
    return "Hello, Sentinel!";
}
// 流控或熔断时的处理方法
public static String handleBlock(BlockException ex) {
    return "Service is currently unavailable due to high traffic. Please try again later.";
}

@SentinelResource(value = "myResource", fallback = "fallbackMethod")
public String someMethod() {
    // 可能会抛出异常的业务逻辑
    throw new RuntimeException("Something went wrong");
}
// 降级方法
public static String fallbackMethod(Throwable ex) {
    return "Service is temporarily unavailable due to internal error. Please try again later.";
}

@SentinelResource(value = "myResource", blockHandler = "handleBlock", blockHandlerClass = BlockHandler.class)
public String someMethod() {
    // 业务逻辑
    return "Hello, Sentinel!";
}
// 自定义流控处理类
public class BlockHandler {
    public static String handleBlock(BlockException ex) {
        return "Service is temporarily unavailable due to traffic control.";
    }
}

@SentinelResource(value = "myResource", fallback = "fallbackMethod", fallbackClass = FallbackHandler.class)
public String someMethod() {
    // 业务逻辑
    throw new RuntimeException("Something went wrong");
}
// 自定义降级处理类
public class FallbackHandler {
    public static String fallbackMethod(Throwable ex) {
        return "Service is temporarily unavailable due to an error.";
    }
}

# 关闭Context收敛，这样被监控方法可以进行不同链路的单独控制
spring.cloud.sentinel.web-context-unify: false
# 比如我 /test1 和 /test2 接口下都调用了 test 方法，那么我可以在sentinel 控制台中分别对 /test1 和 /test2 的 test 进行设置

@RestController
public class TestController {
    @Autowired
    RestTemplate restTemplate;
    @Autowired
    MyService myService;
    @GetMapping("/test1")
    public String test1() {
        return myService.test();
    }
    @GetMapping("/test2")
    public String test2() {
        return myService.test();
    }
}
// ------------------------
@Service
public class MyService {
    @SentinelResource("mytest")	// 标记方法
    public String test() {
        return "test";
    }
}

@RestController
public class TestController {
    @GetMapping("/test1")
    public String test1() {
        return test();
    }
    @SentinelResource("mytest")
    public String test() {
        return "test";
    }
}

@RequestMapping("/blockPage")
    public String blockPage() {
        return "blockPage";
    }

# 用于设置当 流控 或 熔断 触发时，返回给用户的 阻塞页面
spring.cloud.sentinel.block-page=/blockPage

@Service
public class MyService {
    @SentinelResource(value = "mytest", blockHandler = "test2")
    public String test(int id) {
        return "test";
    }
    public String test2(int id, BlockException ex) {
        return "test 限流了 " + id;
    }
}

@Service
public class MyService {
    @SentinelResource(value = "mytest", fallback = "except", exceptionsToIgnore = IOException.class)
    public String test(int id) {
        throw new RuntimeException("hello world");
    }
// 注意参数, 必须是跟 test 的参数列表相同, 然后可以多加一个获取异常的参数
    public String except(int id, Throwable ex) { 
        System.out.println("hello = " + ex.getMessage());
        return ex.getMessage();
    }
}

@GetMapping("/test1")
@SentinelResource(value = "test1")
public String test1(@RequestParam(required = false) String name, @RequestParam(required = false) String age) {
    return name + " " + age;
}

<dependency>
   <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-tracing</artifactId>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-tracing-bridge-brave</artifactId>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-observation</artifactId>
</dependency>
<dependency>
    <groupId>io.zipkin.reporter2</groupId>
    <artifactId>zipkin-reporter-brave</artifactId>
</dependency>
<!-- 使用feign的话加入下面这个依赖 -->
<!--        <dependency>-->
<!--            <groupId>io.github.openfeign</groupId>-->
<!--            <artifactId>feign-micrometer</artifactId>-->
<!--        </dependency>-->

management:
  zipkin:
    tracing:
      endpoint: http://localhost:9411/api/v2/spans
  tracing:
    sampling:
      probability: 1.0 #采样率默认0.1(10次只能有一次被记录)，值越大手机越及时

<!-- gateway 依赖 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<!-- 需要基于注册中心转发请求的话，加上 nacos 依赖 -->
<dependency>
   <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!-- 如果用到 lb: 的话需要在引入getaway的pom中引入loadbalancer -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

spring:
  application:
    name: gateway
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
    gateway:
      # 配置路由，这里是一个列表，每一项都包含很多信息
      routes:
        - id: module1 # 路由名称(nacos中的服务名)
          uri: lb://module1 # 路由地址，lb表示使用负载均衡到微服务，也可以使用http正常转发
          predicates: # 路由规则，决定哪些请求会被路由
            - Path=/test1/** # 请求的路径匹配规则
          filters: # 向请求头中添加 test=hello world
            - AddRequestHeader=test, hello world
server:
  port: 8002

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.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
@Component
public class AddHeaderGlobalFilter implements GlobalFilter, Ordered {
   @Override
   public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
       return chain.filter(exchange);
   }
   @Override
   public int getOrder() {
       return 1;
   }
}

package com.cloud.gateway.config;
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.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
@Component
public class AddHeaderGlobalFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 获取请求的 headers
        HttpHeaders headers = exchange.getRequest().getHeaders();
        // 打印原始请求头
        System.out.println("Request Headers: " + headers);
        // 为请求添加一个新的头部
        exchange.getRequest().mutate()
                .header("test", "hello world") // 添加请求头
                .build();
        // 继续传递到下一个过滤器
        return chain.filter(exchange);
    }
    @Override
    public int getOrder() {
        return 1;
    }
}

import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
@Component
public class AuthFilter  extends AbstractGatewayFilterFactory<AuthFilter.Config> {
    public AuthFilter () {
        super(Config.class);
    }
    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            System.out.println("AuthFilter"); 
            // 下面实现自己的逻辑
            String token = exchange.getRequest().getHeaders().getFirst("token");
            if (token == null || !token.equals(config.getToken())) {
                exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
                return exchange.getResponse().setComplete();
            }
            return chain.filter(exchange);  // 继续处理链中的其他过滤器
        };
    }
    public static class Config {
        private String token;
        public String getToken() {
            return token;
        }
        public void setToken(String token) {
            this.token = token;
        }
    }
}

spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://USER-SERVICE
          predicates:
            - Path=/users/**
          filters:
            - AuthFilter  # 这里引用自定义的局部过滤器

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

spring:
  application:
 	 name: module1 
  profiles:
     active: dev 
  cloud:
    nacos:
      config:
        server-addr: localhost:8848 # 服务地址
        file-extension: yaml

@RestController
@RefreshScope
public class TestNacosConfigController {
    @Value("${test}") 		// 获取到 test 的值
    private String test;
    @GetMapping("/nacos/config")
    public String nacosConfig() {
        return test;
    }
}

@RestController
@RefreshScope
public class TestController {
    @Value("${test}")
    private String test;
    @GetMapping("/nacos/config")
    public String getConfig() {
        return test;
    }
}

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

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    <version>2023.0.1.2</version>
</dependency>