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>