Spring Cloud学习（二）

已于 2023-12-16 17:36:23 修改
阅读量670 收藏
点赞数 1
分类专栏： 云 文章标签： spring cloud 学习 java
于 2022-06-05 00:40:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_35086453/article/details/125123865
版权

一、学习内容

        springCloudAlibaba架构搭建，初步掌握springCloudAlibaba的运用，主要参考官方文档https://spring.io/projects/spring-cloud-alibaba#learn，参考版本为2.2.7.RELEASE

二、使用架构

        服务注册和发现：nacos
        服务调用：openfeign
        负载均衡：ribbon
        资源监听、熔断以及降级：sentinel
        网关路由：zuul(建议使用gateway)
        项目资源配置：config

三、创建项目，目录结构

        服务提供者为provider1，服务消费者为consumer1，client和server两个模块分别是spirngCloud学习（一）的Admin客服端和服务端，本章主要介绍provider1和consumer1。

 四、引入依赖

  •  父模块依赖
<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>springcloud</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.5.RELEASE</version>
    </parent>
    <modules>
        <module>client</module>
        <module>server</module>
        <module>provider1</module>
        <module>consumer1</module>
        <module>redismq</module>
    </modules>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <maven.compiler.source>13</maven.compiler.source>
        <maven.compiler.target>13</maven.compiler.target>
        <spring.lombok.version>1.18.16</spring.lombok.version>
        <fastjson.alibaba.version>2.0.2</fastjson.alibaba.version>
        <spring.admin.version>2.2.1</spring.admin.version>
        <spring.cloud.version>Hoxton.SR12</spring.cloud.version>
        <spring.cloud.alibaba.version>2.2.7.RELEASE</spring.cloud.alibaba.version>
    </properties>
    <dependencies>
        <!-- web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <!-- war时 移除内嵌的tomcat -->
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-tomcat</artifactId>
                </exclusion>
                <!-- 移除logback -->
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
            <scope>compile</scope>
            <exclusions>
                <!-- 移除logback -->
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <!-- 如果使用war打包则加入tomcat支持 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>compile</scope>
        </dependency>
        <!-- 使用log4j2日志 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
        </dependency>
        <!-- lombok工具 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <scope>provided</scope>
        </dependency>
        <!-- fastjson工具 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
        </dependency>
    </dependencies>

    <!-- 依赖管理声明 -->
    <dependencyManagement>
        <dependencies>
            <!-- 申明admin父模块 -->
            <dependency>
                <groupId>de.codecentric</groupId>
                <artifactId>spring-boot-admin-dependencies</artifactId>
                <version>${spring.admin.version}</version>
                <type>pom</type> <!-- 继承父模块 -->
                <scope>import</scope><!-- 声明导入父模块的依赖，默认使用父模块的依赖版本 -->
            </dependency>
            <!-- 声明spring-cloud父模块-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring.cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- 声明spring-cloud alibaba父模块-->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring.cloud.alibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- fastjson工具 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>${fastjson.alibaba.version}</version>
            </dependency>
            <!-- lombok工具 -->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${spring.lombok.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>
  • provider1服务提供者模块依赖
<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>provider1</artifactId>
    <packaging>jar</packaging>

    <dependencies>
        <!-- actuator更好的暴露接口供nacos使用 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
            <exclusions>
                <!-- 移除logback -->
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- nacos客服端，用户nacos服务注册和发现 -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!-- nacos-config 使用nacos配置管理项目静态资源配置 -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>
    </dependencies>
</project>
  • consumer1服务消费端依赖
<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>consumer1</artifactId>
    <packaging>jar</packaging>

    <dependencies>
        <!-- actuator 更好的暴露接口 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
            <exclusions>
                <!-- 移除logback -->
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- nacos -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!-- openfeign 用于远程服务的调用 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <!-- nacos-config 监听拉取nacos服务配置-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>
        <!-- sentinel 服务端sentinel组件，主要用于流控熔断，数据加载内存，支持不同数据源持久化，如拉取模式：Consul, Eureka，推送模式：ZooKeeper, Redis, Nacos, Apollo, etcd；
             支持sentinel-dashboard仪表盘管理 -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        </dependency>
        <!-- datasource-nacos 推模式：使用 Nacos 配置规则-->
        <dependency>
            <groupId>com.alibaba.csp</groupId>
            <artifactId>sentinel-datasource-nacos</artifactId>
            <scope>compile</scope>
        </dependency>
        <!-- sentinel与zuul关联 -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-sentinel-gateway</artifactId>
        </dependency>
        <!-- netflix-zuul  -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
        </dependency>
    </dependencies>

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

五、provider1服务提供者项目代码

  • ReqLogPrintConfig类：用于请求响应日志打印管理
package com.spring.cloud.provider1.demon.config;

import lombok.extern.slf4j.Slf4j;
import org.apache.catalina.connector.RequestFacade;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.Arrays;
import java.util.Enumeration;

@Aspect
@Component
@Slf4j
public class ReqLogPrintConfig {

    @Pointcut("execution(* com.spring.cloud.provider1.demon.controller.*.*(..))")
    public void logPointCut() {
    }

    @Before("logPointCut()")
    public void beforeRequest(JoinPoint joinPoint) {
        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = requestAttributes.getRequest();
        log.info("请求地址：{}", request.getRequestURL().toString());
        log.info("请求方式：{}", request.getMethod());
        log.info("请求主类：{}", joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
        log.info("请求参数：{}", Arrays.toString(getParameterString(joinPoint.getArgs(), request)));
    }

    @AfterReturning(pointcut = "logPointCut()", returning = "result")
    public void afterRequest(Object result) {
        log.info("result: {}", result);
    }

    @Around("logPointCut()")
    public Object aroundRequest(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        Object proceed = pjp.proceed();
        long end = System.currentTimeMillis();
        double div = 1000;
        log.info("请求耗时：{}", (end - start) / div + "s");
        return proceed;
    }

    private Object[] getParameterString(Object[] args, HttpServletRequest req) {
        if (args != null) {
            Object[] resultParams = new Object[args.length];
            for (int i = 0; i < args.length; i++) {
                if (args[i] instanceof RequestFacade) {
                    StringBuffer sb = new StringBuffer("HttpServletRequest(");
                    boolean addDelimeter = false;

                    Enumeration<String> parameters = req.getParameterNames();
                    while (parameters.hasMoreElements()) {
                        String parameter = (String) parameters.nextElement();
                        if (addDelimeter) {
                            sb.append(", ");
                        }
                        sb.append(parameter).append("=");
                        String[] a = req.getParameterValues(parameter);
                        for (int j = 0; j < a.length; j++) {
                            sb.append(a[j]).append(" ");
                        }
                        addDelimeter = true;
                    }
                    sb.append(")");
                    resultParams[i] = sb.toString();
                } else {
                    resultParams[i] = args[i];
                }
            }
            return resultParams;
        }
        return null;
    }
}
  • EchoController类，服务接口
package com.spring.cloud.provider1.demon.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class EchoController {

    @GetMapping(value = "/echo/{string}")
    public String echo(@PathVariable String string)  {
        return "Hello Nacos Discovery " + string;
    }
}
  • ApplicationProvider1Starter项目启动入口
package com.spring.cloud.provider1.demon;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

/**
 * @author len99
 * 入口类
 */
@SpringBootApplication
@EnableDiscoveryClient
public class ApplicationProvider1Starter {
    public static void main(String[] args) {
        SpringApplication.run(ApplicationProvider1Starter.class, args);
        System.out.println("Start Provider1 ------------------");
    }
}
  • log4j2-spring.xml日志配置文件采用log4j2 ，日志文件命名为默认格式，如果自定义方式命名需要在application.yml文件中配置日志路径
<?xml version="1.0" encoding="UTF-8"?>
<!--Configuration后面的status，这个用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，你会看到log4j2内部各种详细输出-->
<!--monitorInterval：Log4j能够自动检测修改配置 文件和重新配置本身，设置间隔秒数-->
<configuration monitorInterval="5">
    <!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->

    <!--变量配置-->
    <Properties>
        <!-- 格式化输出：%date表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度 %msg：日志消息，%n是换行符-->
        <!-- %logger{36} 表示 Logger 名字最长36个字符 -->
        <property name="LOG_PATTERN" value="%date{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n" />
        <!-- 定义日志存储的路径 -->
        <property name="FILE_PATH" value="../log/consumer1" />
        <property name="FILE_NAME" value="log4j2" />
    </Properties>

    <appenders>

        <console name="Console" target="SYSTEM_OUT">
            <!--输出日志的格式-->
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <!--控制台只输出level及其以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
        </console>

        <!-- 这个会打印出所有的info及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileInfo" fileName="${FILE_PATH}/info.log" filePattern="${FILE_PATH}/${FILE_NAME}-INFO-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，默认是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy max="15"/>
        </RollingFile>

        <!-- 这个会打印出所有的warn及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileWarn" fileName="${FILE_PATH}/warn.log" filePattern="${FILE_PATH}/${FILE_NAME}-WARN-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="warn" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，默认是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy max="15"/>
        </RollingFile>

        <!-- 这个会打印出所有的error及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileError" fileName="${FILE_PATH}/error.log" filePattern="${FILE_PATH}/${FILE_NAME}-ERROR-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，默认是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy max="15"/>
        </RollingFile>

    </appenders>

    <!--Logger节点用来单独指定日志的形式，比如要为指定包下的class指定不同的日志级别等。-->
    <!--然后定义loggers，只有定义了logger并引入的appender，appender才会生效-->
    <loggers>

        <!--过滤掉spring和mybatis的一些无用的DEBUG信息-->
        <logger name="org.mybatis" level="info" additivity="false">
            <AppenderRef ref="Console"/>
        </logger>
        <!--监控系统信息-->
        <!--若是additivity设为false，则 子Logger 只会在自己的appender里输出，而不会在 父Logger 的appender里输出。-->
        <Logger name="org.springframework" level="info" additivity="false">
            <AppenderRef ref="Console"/>
        </Logger>

        <root level="info">
            <appender-ref ref="Console"/>
            <appender-ref ref="RollingFileInfo"/>
            <appender-ref ref="RollingFileWarn"/>
            <appender-ref ref="RollingFileError"/>
        </root>
    </loggers>
</configuration>
  • bootstrap.properties 使用nacos统一管理配置文件，配置nacos信息以及所需配置文件信息，nacos通过DataId和group标识配置文件，DataId默认为应用名称，如果不一样，需要另外指明，这里ataId使用默认应用名称；nacos服务和配置文件信息后面再说~ ~
#命名空间ID
spring.cloud.nacos.config.namespace=8a86350a-75ea-4348-9da0-a43e75dd6ddb
#空间中的分组
spring.cloud.nacos.config.group=APP_GROUP
#应用名称，默认作为服务名称
spring.application.name=nacos-provider-1
#nacos服务地址
spring.cloud.nacos.config.server-addr=127.0.0.1:8848
#默认是properites格式，如需引用yaml/yml格式需要显示指明
spring.cloud.nacos.config.file-extension=yaml

五、consumer1服务消费者项目代码

  • ReqLogPrintConfig：用于请求响应日志打印管理
package com.spring.cloud.consumer1.demon.config;

import lombok.extern.slf4j.Slf4j;
import org.apache.catalina.connector.RequestFacade;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.Arrays;
import java.util.Enumeration;

@Aspect
@Component
@Slf4j
public class ReqLogPrintConfig {

    @Pointcut("execution(* com.spring.cloud.consumer1.demon.controller.*.*(..))")
    public void logPointCut() {
    }

    @Before("logPointCut()")
    public void beforeRequest(JoinPoint joinPoint) {
        ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = requestAttributes.getRequest();
        log.info("请求地址：{}", request.getRequestURL().toString());
        log.info("请求方式：{}", request.getMethod());
        log.info("请求主类：{}", joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
        log.info("请求参数：{}", Arrays.toString(getParameterString(joinPoint.getArgs(), request)));
    }

    @AfterReturning(pointcut = "logPointCut()", returning = "result")
    public void afterRequest(Object result) {
        log.info("result: {}", result);
    }

    @Around("logPointCut()")
    public Object aroundRequest(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        Object proceed = pjp.proceed();
        long end = System.currentTimeMillis();
        double div = 1000;
        log.info("请求耗时：{}", (end - start) / div + "s");
        return proceed;
    }

    private Object[] getParameterString(Object[] args, HttpServletRequest req) {
        if (args != null) {
            Object[] resultParams = new Object[args.length];
            for (int i = 0; i < args.length; i++) {
                if (args[i] instanceof RequestFacade) {
                    StringBuffer sb = new StringBuffer("HttpServletRequest(");
                    boolean addDelimeter = false;

                    Enumeration<String> parameters = req.getParameterNames();
                    while (parameters.hasMoreElements()) {
                        String parameter = (String) parameters.nextElement();
                        if (addDelimeter) {
                            sb.append(", ");
                        }
                        sb.append(parameter).append("=");
                        String[] a = req.getParameterValues(parameter);
                        for (int j = 0; j < a.length; j++) {
                            sb.append(a[j]).append(" ");
                        }
                        addDelimeter = true;
                    }
                    sb.append(")");
                    resultParams[i] = sb.toString();
                } else {
                    resultParams[i] = args[i];
                }
            }
            return resultParams;
        }
        return null;
    }
}
  •  EchoService：声明远端服务信息，使用OpenFeign组件远程调用服务，依赖spring-cloud-starter-alibaba-nacos-discovery已经集成ribbon组件
package com.spring.cloud.consumer1.demon.provider1;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.context.annotation.Bean;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@FeignClient(value = "nacos-provider-1", fallback = EchoServiceFallback.class, configuration = FeignConfiguration.class)
public interface EchoService {

    @RequestMapping(value = "/echo/{string}", method = RequestMethod.GET)
    public String echo(@PathVariable String string);
}

class FeignConfiguration {
    @Bean
    public EchoServiceFallback echoServiceFallback() {
        return new EchoServiceFallback();
    }
}

class EchoServiceFallback implements EchoService {

    @Override
    public String echo(@PathVariable("string") String string) {
        return "echo fallback";
    }
}
  • NacosController：调用provider1服务接口，和调用本地其它接口一样，交由Feign代理完成远程调用，本地已经声明远程接口信息（方法名、参数列表、请求方式、响应接受类型），配合从nacos拉取的缓存在本地内存的服务信息（IP、port）来完成调用逻辑
package com.spring.cloud.consumer1.demon.controller;

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.spring.cloud.consumer1.demon.provider1.EchoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class NacosController {
    @Autowired
    private EchoService echoService;
    @Value("${spring.application.name}")
    private String appName;

    @RequestMapping(value = "/echo/app-name", method = RequestMethod.GET)
    @SentinelResource("echoAppName")
    public String echoAppName(String name) {
        System.out.println(name);
        return echoService.echo(appName);
    }

    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    @SentinelResource("hello")
    public String hello() {
        return "hello";
    }
//
//    @GetMapping("/mono")
//    @SentinelResource("mono")
//    public Mono<String> mono() {
//        return Mono.just("simple string")
//                .transform(new SentinelReactorTransformer<>("otherResourceName"));
//    }
}
  • ApplicationConsumer1Starter：项目入口类

        这里配置了熔断监听，熔断状态变化可以启动监听，做一些其它配置

package com.spring.cloud.consumer1.demon;

import com.alibaba.csp.sentinel.slots.block.degrade.circuitbreaker.CircuitBreaker;
import com.alibaba.csp.sentinel.slots.block.degrade.circuitbreaker.EventObserverRegistry;
import com.alibaba.csp.sentinel.util.TimeUtil;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

/**
 * @author len99
 * 入口类
 */
@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
public class ApplicationConsumer1Starter {
    public static void main(String[] args) {
        SpringApplication.run(ApplicationConsumer1Starter.class, args);
        System.out.println("Start Consumer1 ------------------");
        EventObserverRegistry.getInstance().addStateChangeObserver("logging",(prevState, newState, rule, snapshotValue) -> {
            if (newState == CircuitBreaker.State.OPEN) {
                // 变换至 OPEN state 时会携带触发时的值
                System.err.println(String.format("%s -> OPEN at %d, snapshotValue=%.2f", prevState.name(),
                        TimeUtil.currentTimeMillis(), snapshotValue));
            } else {
                System.err.println(String.format("%s -> %s at %d", prevState.name(), newState.name(),
                        TimeUtil.currentTimeMillis()));
            }
        });
    }
}
  • log4j2-spring.xml：log4j2日志配置
<?xml version="1.0" encoding="UTF-8"?>
<!--Configuration后面的status，这个用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，你会看到log4j2内部各种详细输出-->
<!--monitorInterval：Log4j能够自动检测修改配置 文件和重新配置本身，设置间隔秒数-->
<configuration monitorInterval="5">
    <!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->

    <!--变量配置-->
    <Properties>
        <!-- 格式化输出：%date表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度 %msg：日志消息，%n是换行符-->
        <!-- %logger{36} 表示 Logger 名字最长36个字符 -->
        <property name="LOG_PATTERN" value="%date{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n" />
        <!-- 定义日志存储的路径 -->
        <property name="FILE_PATH" value="../log/consumer1" />
        <property name="FILE_NAME" value="log4j2" />
    </Properties>

    <appenders>

        <console name="Console" target="SYSTEM_OUT">
            <!--输出日志的格式-->
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <!--控制台只输出level及其以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
        </console>

        <!-- 这个会打印出所有的info及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileInfo" fileName="${FILE_PATH}/info.log" filePattern="${FILE_PATH}/${FILE_NAME}-INFO-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，默认是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy max="15"/>
        </RollingFile>

        <!-- 这个会打印出所有的warn及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileWarn" fileName="${FILE_PATH}/warn.log" filePattern="${FILE_PATH}/${FILE_NAME}-WARN-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="warn" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，默认是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy max="15"/>
        </RollingFile>

        <!-- 这个会打印出所有的error及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileError" fileName="${FILE_PATH}/error.log" filePattern="${FILE_PATH}/${FILE_NAME}-ERROR-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/>
            <PatternLayout pattern="${LOG_PATTERN}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，默认是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy max="15"/>
        </RollingFile>

    </appenders>

    <!--Logger节点用来单独指定日志的形式，比如要为指定包下的class指定不同的日志级别等。-->
    <!--然后定义loggers，只有定义了logger并引入的appender，appender才会生效-->
    <loggers>

        <!--过滤掉spring和mybatis的一些无用的DEBUG信息-->
        <logger name="org.mybatis" level="info" additivity="false">
            <AppenderRef ref="Console"/>
        </logger>
        <!--监控系统信息-->
        <!--若是additivity设为false，则 子Logger 只会在自己的appender里输出，而不会在 父Logger 的appender里输出。-->
        <Logger name="org.springframework" level="info" additivity="false">
            <AppenderRef ref="Console"/>
        </Logger>

        <root level="info">
            <appender-ref ref="Console"/>
            <appender-ref ref="RollingFileInfo"/>
            <appender-ref ref="RollingFileWarn"/>
            <appender-ref ref="RollingFileError"/>
        </root>
    </loggers>
</configuration>
  • bootstrap.properties：使用nacos统一管理配置文件，配置nacos信息以及所需配置文件信息，nacos通过DataId和group标识配置文件，DataId默认为应用名称，如果不一样，需要另外指明，这里ataId使用默认应用名称；nacos服务和配置文件信息后面再说~ ~
# 命名空间ID
spring.cloud.nacos.config.namespace=8a86350a-75ea-4348-9da0-a43e75dd6ddb
#空间中的分组
spring.cloud.nacos.config.group=APP_GROUP
#应用名称，默认作为服务名称
spring.application.name=nacos-consumer-1
#nacos服务地址
spring.cloud.nacos.config.server-addr=127.0.0.1:8848
#默认是properites格式，如需引用yaml/yml格式需要显示指明
spring.cloud.nacos.config.file-extension=yaml

六、Nacos服务端   

  • 介绍

        Nacos 是一个易于使用的动态服务发现、配置和服务管理平台，用于构建云原生应用程序。
借助Spring Cloud Alibaba Nacos Discovery，您可以基于Spring Cloud的编程模型快速访问Nacos服务注册功能。
        服务发现是微服务体系结构中的关键组件之一。在这样的体系结构中，手动为每个客户端配置服务列表可能是一项艰巨的任务，并且使动态扩展变得极其困难。Nacos Discovery 可帮助您自动将服务注册到 Nacos 服务器，Nacos 服务器会跟踪服务并动态刷新服务列表。此外，Nacos Discovery 还会将服务实例的一些元数据（如主机、端口、运行状况检查 URL、主页）注册到 Nacos。有关如何下载和启动 Nacos 的详细信息，请参阅 https://nacos.io/zh-cn/docs/quick-start.html 网站。
        Nacos Discovery与Netflix Ribbon，RestTemplate或OpenFeign集成，可用于服务到服务调用。

        这里nacos服务端的功能有用到config、服务注册注册和发现、sentinel的持久化数据源

        项目启动时会先向nacos请求配置信息，然后加载sentinel规则信息，最后向nacos注册服务信息并完成注册，nacos客服端和服务端建立监听联系之后，客服端会缓存服务端元数据列表，启动完成

        nacos服务端也配置了sentinel组件的流控规则，具体在下一小节讲到，先把配置配好。

  • nacos服务端使用版本nacos 2.0.2，在cmd选择单例模式启动，如下：

  •  访问nacos的web端，地址http://localhost:8848 查看控制台（默认帐户名/密码为 nacos/nacos）

  • 页面发现没有服务，现在需要启动provider1和consumer1，启动之前需要在nacos服务端配置好provider1、consumer1的配置文件(类似application.yml)，这里新建了命名空间dev

  •  建好dev命名空间后会发现配置列表多了dev空间

  •  在dev命名空间配置项目配置文件数据，配置好后如下

  • provider1的配置信息如下：

         其中配置内容为：

server:
    port: 8083
    
management: #actuator建立端点，暴露接口供组件采集
  endpoints:
    web:
      base-path: /actuator
      exposure:
        include: '*'  # 需要开启的端点
        exclude: env,caches # 不需要开启的端点
  endpoint:
    shutdown:
      enabled: true #开启shutdown
  • consumer1配置信息如下：

        这里配置了sentinel的流控规则，sentinel具体信息在下一小节会讲到

         其中配置内容如下：

server:
    port: 8086  # 项目端口
    
management: #actuator建立端点，暴露接口供其它组件合理采集
  endpoints:
    web:
      base-path: /actuator
      exposure:
        include: '*'  # 需要开启的端点
        exclude: env,caches # 不需要开启的端点
  endpoint:
    shutdown:
      enabled: true #开启shutdown

feign: # 开启sentinel对openfeign的监听和远程服务接口管理
  sentinel: 
    enabled: true

ribbon:  # 配置负载均衡ribbon,注意这里的超时时间会影响sentinel的延时熔断策略！
  ReadTimeout: 10000 # 秒
  ConnectTimeout: 10000 # 秒
  MaxAutoRetries: 1  # 同一台实例最大重试次数，不包括首次调用
  MaxAutoRetriesNextServer: 1 # 重试负载均衡其他的实例最大重试次数，不包括首次
  OkToRetryOnAllOperations: false  # 是否所有操作都重试 , 设置为false时，则是对get请求重试；如果设置为true时，便会对所有的请求

spring:
  cloud:
    sentinel:
      transport:  # 配置服务与sentinel-dashboard的交互端口和sentinel-dashboard的服务端口
        port: 8719 # 服务端默认端口，被占的话会在此基础上+1，直到可用为止
        dashboard: localhost:8082
      zuul: # 配置zuul参数，这里zuul交由sentinel来管理
        enabled: true #默认值
        order: # 配置zuul过滤器的有效执行时间
          pre: 2000
          post: 500
          error: -100
      filter:
        enabled: false  # 关闭自动配置过滤器
      datasource: # 配置动态数据源支持，数据源采用nacos,用于对sentinel的数据持久化
        ds1: # 自定义key值
          nacos: # 使用nacos数据源
            namespace: 8a86350a-75ea-4348-9da0-a43e75dd6ddb
            server-addr: localhost:8848
            data-id: nacos-consumer-1-flow-rules
            group-id: DEFAULT_GROUP
            data-type: json  # 数据保存格式
            rule-type: flow  # sentinel规则类型为flow(流控降级规则)
        ds2:
          nacos: 
            namespace: 8a86350a-75ea-4348-9da0-a43e75dd6ddb
            server-addr: localhost:8848
            data-id: nacos-consumer-1-degrade-rules
            group-id: DEFAULT_GROUP
            data-type: json
            rule-type: degrade # sentinel规则类型degrade(熔断)
        # gw-flow
        gw-flow:
          nacos:
            namespace: 8a86350a-75ea-4348-9da0-a43e75dd6ddb
            server-addr: localhost:8848
            dataId: nacos-consumer-1-gw-flow-rules
            groupId: DEFAULT_GROUP
            data-type: json
            rule-type: gw-flow # sentinel规则类型为网关流
        # w-api-group
        w-api-group:
          nacos:
            namespace: 8a86350a-75ea-4348-9da0-a43e75dd6ddb
            server-addr: localhost:8848
            dataId: nacos-consumer-1-gw-api-group-rules
            groupId: DEFAULT_GROUP
            data-type: json
            rule-type: gw-api-group # sentinel规则类型为网关api分组

七、sentinel组件/sentinel-dashboard仪表盘，流控熔断降级以及监控web端  

  •  sentinel

       Sentinel 是面向分布式服务架构的流量控制组件，主要以流量为切入点，从限流、流量整形、熔断降级、系统负载保护、热点防护等多个维度来帮助开发者保障微服务的稳定性。

        围绕资源的实时状态设定的规则，可以包括流量控制规则、熔断降级规则以及系统保护规则。所有规则可以动态实时调整。

        这里的规则设置有两种，1.通过 API 直接修改 (loadRules) 2.通过 DataSource 适配不同数据源修改，这里采用第二种方式，以配置文件的方式通过控制台设置规则后将规则推送到统一的规则中心nacos，客户端实现 ReadableDataSource 接口端监听规则中心实时获取变更。

  • sentinel-dashboard

        Sentinel 仪表板是一个轻量级控制台，提供计算机发现、单服务器资源监控、群集资源数据概述以及规则管理等功能。要使用这些功能，您只需完成几个步骤

  • sentinel、sentinel-dashboard搭配使用

        正常流程为sentinel-dashboard修改玩sentinel规则后，自动同步到nacos，服务ReadableDataSource监听到nacos规则信息变化后，拉取nacos相关规则配置，服务更新规则到内存，完成整个更新。

        sentinel-dashboard管理sentinel规则，实时监听sentinel规则变化，sentinel-dashboard修改规则后需要同步到nacos，可惜的是sentinel-dashboard目前不支持同步nacos，需要自己手动下载sentinel-dashboard源码，手动修改打包后才能做到同步更新到nacos，具体操作可以参考：https://blog.youkuaiyun.com/qq_23021275/article/details/122990857 

  • 在nacos服务端配置

        1. 流控规则：

         配置内容为：

[
    {
        "app": "nacos-consumer-1",
        "clusterConfig": {
            "acquireRefuseStrategy": 0,
            "clientOfflineTime": 2000,
            "fallbackToLocalWhenFail": true,
            "resourceTimeout": 2000,
            "resourceTimeoutStrategy": 0,
            "sampleCount": 10,
            "strategy": 0,
            "thresholdType": 0,
            "windowIntervalMs": 1000
        },
        "clusterMode": false,
        "controlBehavior": 0,
        "count": 1,
        "gmtCreate": 1652708664898,
        "gmtModified": 1652709600123,
        "grade": 1,
        "id": 1,
        "ip": "192.168.1.102",
        "limitApp": "nacos",
        "port": 8720,
        "resource": "hello",
        "strategy": 0
    }
]

               2. 流控熔断：

         配置内容为：

[
    {
        "app": "nacos-consumer-1",
        "count": 5000,
        "gmtCreate": 1652708953863,
        "gmtModified": 1652708953863,
        "grade": 0,
        "id": 1,
        "ip": "192.168.1.102",
        "limitApp": "default",
        "minRequestAmount": 3,
        "port": 8720,
        "resource": "GET:http://nacos-provider-1/echo/{string}",
        "slowRatioThreshold": 0.6,
        "statIntervalMs": 10000,
        "timeWindow": 10
    }
]

        3. 自定义网管流规则（gw-flow）：

        

         配置内容为：

[
    {
        "resource": "echoAppName",
        "count": 0,
        "paramItem": {
            "parseStrategy": 3,
            "fieldName": "name"
        }

    },
    {
        "resource": "hello",
        "count": 0
    }
]

        4. 自定义网管API分组规则（gw-api-group）： 一组api资源使用同一套规则

  •  在nacos服务端配置好后还需要服务的配置文件中配置相关的数据源（nacos）信息和监听ReadableDataSource（这里使用配置文件的方式自动装配，如上面配置中的ds1，ds2这种）

八、启动服务

        provider1、consumer1  服务启动成功之后，访问nacos服务端 ：http://localhost:8848/nacos/#/serviceManagement?serverId=center&group=&dataId=&namespace=&pageNo=&pageSize=&appName=&namespaceShowName=public

九、启动sentinel-dashboard

        下载源码https://github.com/alibaba/Sentinel修改后打包为sentinel-dashboard.jar。

        cmd命令窗口执行 java -Dserver.port=8082 -jar sentinel-dashboard.jar。

         访问sentinel-dashboard界面：http://localhost:8082/#/dashboard

         默认用户名密码为sentinel   

 十、zuul配置（建议采用gateway配置）

        zuul在springboot2.4之后就不支持了，最好改为gateway，

        配置信息可以参考：https://blog.youkuaiyun.com/m0_67393828/article/details/124039108

 十一、ribbon配置

        ribbon已集成到nacos中，负载均衡默认采用轮询，具体配置可参考上述配置

 十二、springCloud中注解的含义

  • @EnableDiscoveryClient：管理服务注册，开启服务发现并且和服务建立连接
  • @EnableFeignClients：启用Feign组件(实际就是个代理)，管理标识为@FeignClient的远程服务
  • @FeignClient：注册远端服务类到Feign组件
  • @SentinelResource：开启sentinel资源，从而对资源启动流控熔断等规则

 十三、测试

        各个组件是否有效果

        可以在sentinel-dashboard上修改规则查看nacos是否同步更新，规则是否有效

        。。。。。。

十四、添加配置类说明

1. 微服务启动拉取nacos配置文件
1.1 文件名默认就是服务名称，但配置了active（表示不同的环境），此时文件如下：

  [spring.application.name]-[spring.profiles.active].[file-extension]，例如：userservice-dev.yaml

1.2 nacos中配置文件修改后，服务实现热更新，有以下两种方式：

        这里推荐使用第二种方式，通过@ConfigurationProperties注入，直接自动刷新，第一种需要通过@Value注解注入，结合@RefreshScope来刷新。 

1.2.1 @Value注入的变量所在类上添加注解@RefreshScope
1.2.2 使用@ConfigurationProperties注解，利用prefix + 字段读取
1.2.3 spring.cloud.nacos.config.extension-configs是个list，可以配置多个，dataId时配置文件名称，refresh=true变更支持刷新。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值