AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

springCloud搭建、zuul、feign、hystrix、ribbon（内部培训）

2023-07-18 176
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： springCloud搭建、zuul、feign、hystrix、ribbon（内部培训）

一、搭建过程

1.1 创建方式

所有模块的创建均为空的maven项目，父项目中的src文件夹可直接删除

1.2 依赖管理

dependencies：当前项目与其子项目中都会添加改依赖（子项目会从父项目中继承）

dependencyManagement：只声明依赖，并不实先引入，然后子项目中添加该依赖不写版本号，则继承父项目中所声明的版本，若子项目有指定版本，则优先使用自己的；

ps: 我们可以再父项目中声明依赖，而不引入，做到版本集中统一管理；

1.3 按项目结构图创建出各个模块

对于其他模块的，可以选择直接复制一个模块文件夹，然后修改文件夹名称以及pom.xml中相关项目名，最后在父项目pom中添加一行module元素指向本模块即可；

1.4 将maven构建成springboot项目，父项目/pom.xml中

（可以构建一个springboot项目来参考一下）：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.15.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

<packaging>pom</packaging>

<properties>
    <java.version>1.8</java.version>
</properties>

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

1.5 父项目中声明SpringCloud相关依赖

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

1.6 Eureka

1.6.1 eureka-server中：

  • 依赖：
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>
  • 添加springBoot启动类，并增加注解
@EnableEurekaServer
  • yml配置：
eureka:
  instance:
    hostname: ${EUREKA_HOSTNAME:${spring.cloud.client.ip-address}}
  #    ip-address: ${eureka.instance.hostname}
  server:
    enable-self-preservation: false    #关闭服务器自我保护（生产环境开启）
    eviction-interval-timer-in-ms: 30000 #清理间隔（单位毫秒，默认是60*1000）5秒将客户端剔除的服务在服务注册列表中剔除#
    response-cache-update-interval-ms: 30000  #eureka server刷新readCacheMap的时间，注意，client读取的是readCacheMap，这个时间决定了多久会把readWriteCacheMap的缓存更新到readCacheMap上 #eureka server刷新readCacheMap的时间，注意，client读取的是readCacheMap，这个时间决定了多久会把readWriteCacheMap的缓存更新到readCacheMap上默认30s
    response-cache-auto-expiration-in-seconds: 180   #eureka server缓存readWriteCacheMap失效时间，这个只有在这个时间过去后缓存才会失效，失效前不会更新，过期后从registry重新读取注册服务信息，registry是一个ConcurrentHashMap。
    renewal-percent-threshold: 0.85  #  指定每分钟需要收到的续约次数的阈值，默认值就是：0.85
  client:
    service-url:
      defaultZone: ${EUREKA_URL:http://${eureka.instance.hostname}:${server.port}/eureka}
    register-with-eureka: false  #是否将自己注册到Eureka服务中，默认为true
    fetch-registry: false       #是否从Eureka中获取注册信息，默认为true

1.6.2 eureka-client中：

  • 依赖：
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
  • 启动类添加注解：
@EnableDiscoveryClient
  • yml配置：
eureka:
  instance:
    hostname: ${HOSTNAME:${spring.cloud.client.ip-address}}
    #    hostname: ${HOSTNAME:127.0.0.1}
    ip-address: ${eureka.instance.hostname}
    prefer-ip-address: true
    instance-id: ${spring.application.name}:${eureka.instance.hostname}:${server.port}
    #    instance-id: ${spring.application.name}:${docker.ipAddress}:${spring.application.instance_id:${server.port}}
    lease-renewal-interval-in-seconds: 30    #续约间隔时间 s
    lease-expiration-duration-in-seconds: 90 #续约超时时间 s
  client:
    serviceUrl:
      defaultZone: ${DEFAULTZONE:http://admin:123456@${eureka.instance.hostname}:9001/eureka/}
    registry-fetch-interval-seconds: 30                  # 间隔多久去拉取服务注册信息，默认为30秒

二、zuul的配置与使用

2.1 配置

  • 依赖
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>
  • 启动类添加注解
@EnableZuulProxy
  • yml配置（包含重试）
######## zuul的配置  start ########
ribbon:
  eager-load:
    enabled: true
  ReadTimeout: ${READ_TIMEOUT:30000}            # 获取到响应内容的超时时间
  ConnectTimeout: ${CONNECTION_TIMEOUT:1000}          # 连接超时时间
  MaxAutoRetries: 0             # 在当前服务重试的次数
  MaxAutoRetriesNextServer: 1   # 默认轮询去重选列表中服务的次数
  OkToRetryOnAllOperations: ${ALLRETRY:false}  #是否所有操作都重试  (默认false)
# 使用okhttp： （还需要引入相关依赖，且okhttp默认开启重试）
#  http:
#    client:
#      enabled: false
#  okhttp:
#    enabled: true
hystrix:
  command:
    default:
      execution:
        timeout:
          enabled: true
        isolation:
          thread:
            timeoutInMilliseconds: ${THREAD_TIMEOUT:30000}

zuul:
  host: # routes使用url时走这个超时配置
    socket-timeout-millis: 30000
    connect-timeout-millis: 1000
    max-per-route-connections: 100      # 适用于ApacheHttpClient，如果是okhttp无效。每个服务的http客户端连接池最大连接，默认是200
    max-total-connections: 500          # 适用于ApacheHttpClient，如果是okhttp无效。每个route可用的最大连接数，默认值是20
  ribbon:
    eager-load:
      enabled: true
  # 开启自动重试
  retryable: true
  # 自定义路由转发规则
  routes:
    user:
      path: /uc/**
      #url: http://server-b-3:9006
      sensitiveHeaders:
      service-id: admin-user
    ebankpay:
      path: /pay/**
      #url: http://server-b-3:9008
      sensitiveHeaders:
      service-id: admin-ebankpay
    product:
      path: /product/**
      #url: http://server-b-3:9011
      sensitiveHeaders:
      service-id: admin-product
  add-proxy-headers: true
  #因为zuul有默认的隐射机制，如果没有以下的配置，那么访问http://ip:gatewayPort/c/也可以访问到你的c服务，如果你不想向外界暴露除你配置的隐射之外的服务，可以加上zuul.ignored-services:*
  ignoredServices: '*'
######## zuul的配置  end ########

2.2 Zuul重试配置需要添加依赖

依赖：

<dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
</dependency>

yml配置（重试次数配置见上方zuul的配置，这里不再全部重复写了）：

zuul:
  retryable: true     # 开启自动重试

2.3 动态路由

    @Bean
    public PatternServiceRouteMapper patternServiceRouteMapper() {
   
   
        // servicePattern 决定是哪个微服务eureka-client
         // routePattern 怎么样的访问形式  http://localhost/eureka-client/info
        return new PatternServiceRouteMapper("(?<name>.*)-service", "${name}");
    }

//main方法测试路由配置是否正确
    public static void main111(String[] args) {
   
   
        PatternServiceRouteMapper patternServiceRouteMapper = new PatternServiceRouteMapper("(?<name>.*)-service", "${name}");
        String apply = patternServiceRouteMapper.apply("user-service"); //user
        System.out.println(apply);
    }

2.4 ZuulFilter的使用

  • 自定义filter相关类，继承ZuulFilter，重写4个方法：
@Slf4j
@Component
public class TokenZuulFilter2 extends ZuulFilter {
   
   
    @Override
    public String filterType() {
   
   
        //指定过滤器类型
        // 4种过滤器类型，分别为pre（路由之前调用），route（路由时调用），error（发生异常时调用），post（routing和error之后调用）
        return FilterConstants.PRE_TYPE;
    }

    @Override
    public int filterOrder() {
   
   
        //过滤器优先级，数值越小优先级越高
        return FilterConstants.SEND_ERROR_FILTER_ORDER + 1;
    }

    @Override
    public boolean shouldFilter() {
   
   
        // 这里也可以做一些判断，决定是否开启这个filter
        RequestContext ctx = RequestContext.getCurrentContext();
        HttpServletRequest request = ctx.getRequest();
        //判断登录接口设置放行
        StringBuffer requestURL = request.getRequestURL();
        log.info("requestURL：{}", requestURL);
        if (requestURL.toString().endsWith("/uc/userLogin/login")){
   
   
            //请求登录的接口，放行
            return false;
        }
        return true;
    }

    @Override
    public Object run() throws ZuulException {
   
   
        // 具体的过滤逻辑，比如对token的判断等
        log.info("进入tokenZuulFilter2");

        /*
        // 放行方式，都可以:
        return null;
        return true;
        return false;
        ctx.setSendZuulResponse(true);

        // 不放行并设置响应内容
        ctx.setSendZuulResponse(false);
        ctx.setResponseBody("xxxx");
        */
        return null;
    }

}

2.5 Zuul的降级处理

实现此接口（FallbackProvider）中的方法，详细见项目中 【GatewayFallbackProvider】 类

三、feign的配置与使用

3.1 服务的消费者（示例：order-server 调用 user-server）

  • 依赖
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
  • 启动类注解
@EnableFeignClients
  • @FeignClient 的使用
@FeignClient(name = "user-server", fallback = UserTestFeignClientFallback.class) 
public interface UserTestFeignClient {
   
   
    @GetMapping("/adminUser/findByUsername/{username}")
    ResultVo<Object> findByUsernameGet(@PathVariable("username") String username) ;

    @PostMapping("/adminUser/findByUsername/{username}")
    ResultVo<Object> findByUsernamePost(@PathVariable("username") String username);
}
  • yml配置
######## feign的配置  start ########
feign:
  hystrix:
    enabled: true          # 开启hystrix，使@FeignClient注解中fallback的指定降级处理生效
  httpclient:              #默认就使用httpclient，在pom里面添加就是httpclient，不添加就实现HttpUrlConnection
    enabled: true
    max-connections: 200
    max-connections-per-route: 50
  okhttp:
    enabled: false
#  client:
#    config:
#      default:
#        readTimeout: 5000
#        connectTimeout: 200

ribbon:
  eager-load:
    enabled: true
  ReadTimeout: ${READ_TIMEOUT:30000}            # 获取到响应内容的超时时间
  ConnectTimeout: ${CONNECTION_TIMEOUT:1000}          # 连接超时时间
  MaxAutoRetries: 0             # 在当前服务重试的次数
  MaxAutoRetriesNextServer: 1   # 默认轮询去重选列表中服务的次数
  OkToRetryOnAllOperations: ${ALLRETRY:false}  #是否所有操作都重试  (默认false)

hystrix:
  command:
    default:
      execution:
        timeout:
          enabled: true
        isolation:
          thread:
            timeoutInMilliseconds: ${THREAD_TIMEOUT:30000}
######## feign的配置  end ########
  • 优化

Feign 的底层 构建了一个RestTemplate 对象，而RestTemplate对象并没有直接发起请求的能力，其内部使用HttpURLConnection 来实际发请求的 。Feign 里面RestTemplate 利用的使用JDK的HttpUrlConenction 发请求。 HttpUrlConnection 它的性能比较好，但是它不支持连接池特性，在并发量特别大时，需要频繁的创建连接。若没有池对象，则会创建大量的对象，导致性能下降，所以我们选有池的好一点

使用httpclient连接池，在pom里面添加依赖

<!--feign调用的httpclient连接池支持-->
<dependency>
    <groupId>io.github.openfeign</groupId>
    <artifactId>feign-httpclient</artifactId>
</dependency>

3.2 服务的提供者

提供对应访问路径的Controller即可

3.3 feign-API 的抽取

image

  • 给每个服务提供者创建对应的 feign api 模块，抽取其FeignController
  • 注意：服务提供者中对api的实现，方法注解可以继承下来，但是参数注解需要加上去（不能漏）

四、重试机制、负载均衡

feign中默认使用的是RestTemplate，底层还是HttpURLConnection；
Zuul默认使用的是HttpClient，但是zuul没有开启重试，要引入其他依赖并添加配置开启重试机制；

4.1 HttpClient VS OKHttp

  • 1、都可以使用连接池，达到优化的目的；2、ribbon都支持；

  • OkHttp是一个Http-client，它的主要优势：

·HTTP/2 支持允许所有访问同一主机的请求共享一个socket
·支持GZIP压缩
·响应缓存减少重复请求
OkHttp多例模式下性能更好
  • HttpClient：
如果是在单例模式下，推荐使用HttpClient效率更高；原因是httpClient的创建相对来说慢一些，在单例情况下，httpClient的速度更有优势

4.2 feign使用HttpClient

  • 添加依赖：
<!--feign调用的httpclient连接池支持-->
<dependency>
    <groupId>io.github.openfeign</groupId>
    <artifactId>feign-httpclient</artifactId>
</dependency>
  • 在添加依赖的服务中添加配置
feign:
  httpclient:
    enabled: true          #默认就是开启的，只要引入了HttpClient的依赖，就会加载并使用httpClient
    max-connections: 200   # 默认连接池最大200个
    max-connections-per-route: 50    #默认单个路由请求上最大连接数50个

4.3 feign使用OKHttp

  • 依赖
<dependency>
    <groupId>io.github.openfeign</groupId>
    <artifactId>feign-okhttp</artifactId>
</dependency>
  • yml配置
feign:
  httpclient:
    enabled: false              #关闭httpClient
    max-connections: 200        #okhttp也是从这里取值 和httpclient一样
    max-connections-per-route: 50  #okhttp也是从这里取值 和httpclient一样
  okhttp:
    enabled: true              #开启okhttp

ps：部分源码信息可以查看此类 OkHttpFeignConfiguration

4.4 zuul 使用默认httpClient时，需要手动开启重试机制

  • 依赖
<dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
</dependency>
  • yml配置
zuul:
  retryable: true       # 添加retry依赖后，开启重试
ribbon:
  ReadTimeout: 30000
  connectTimeout: 2000
  MaxAutoRetries: 0             # 在当前服务重试的次数
  MaxAutoRetriesNextServer: 1   # 默认轮询去重选列表中服务的次数
  OkToRetryOnAllOperations: false # 是否所有类型请求都重试 默认false（只有GET请求重试）

4.5 zuul 使用OKHttp

  • 依赖
<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
</dependency>
  • yml配置
ribbon:
  http:
    client:
      enabled: false          # 关闭httpclient
  okhttp:
    enabled: true             # 开启okhttp

4.6 ribbon.OkToRetryOnAllOperations

  • 源码查看：FeignLoadBalancer
public RequestSpecificRetryHandler getRequestSpecificRetryHandler(FeignLoadBalancer.RibbonRequest request, IClientConfig requestConfig) {
   
   
        if (this.ribbon.isOkToRetryOnAllOperations()) {
   
   
            return new RequestSpecificRetryHandler(true, true, this.getRetryHandler(), requestConfig);
        } else {
   
   
            return !request.toRequest().httpMethod().name().equals("GET") ? new RequestSpecificRetryHandler(true, false, this.getRetryHandler(), requestConfig) : new RequestSpecificRetryHandler(true, true, this.getRetryHandler(), requestConfig);
        }
    }

    public RequestSpecificRetryHandler(boolean okToRetryOnConnectErrors, boolean okToRetryOnAllErrors, RetryHandler baseRetryHandler, @Nullable IClientConfig requestConfig) {
   
   
        this.retrySameServer = -1;
        this.retryNextServer = -1;
        this.connectionRelated = Lists.newArrayList(new Class[]{
   
   SocketException.class});
        Preconditions.checkNotNull(baseRetryHandler);
        this.okToRetryOnConnectErrors = okToRetryOnConnectErrors;
        this.okToRetryOnAllErrors = okToRetryOnAllErrors;
        this.fallback = baseRetryHandler;
        if (requestConfig != null) {
   
   
            if (requestConfig.containsProperty(CommonClientConfigKey.MaxAutoRetries)) {
   
   
                this.retrySameServer = (Integer)requestConfig.get(CommonClientConfigKey.MaxAutoRetries);
            }

            if (requestConfig.containsProperty(CommonClientConfigKey.MaxAutoRetriesNextServer)) {
   
   
                this.retryNextServer = (Integer)requestConfig.get(CommonClientConfigKey.MaxAutoRetriesNextServer);
            }
        }

    }

4.7 ribbon重试存在的问题：

issues: SocketTimeoutException(connect time out) is not judged as a ConnectionException： https://github.com/Netflix/ribbon/issues/359

csdn博客：https://blog.csdn.net/weixin_44032384/article/details/104414846

五、swagger的使用

5.1 分别在网关服务与其他服务中配置

（可以抽取swagger公共模块）

添加依赖

<!--swagger （已父项目中声明依赖与版本号：2.9.2） -->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
</dependency>
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
</dependency>

网关服务中需要的配置：

@Configuration
@EnableSwagger2
public class SwaggerConfig {
   
   

    @Autowired
    private DiscoveryClientRouteLocator discoveryClientRouteLocator;

    @Primary
    @Bean
    public SwaggerResourcesProvider swaggerResourcesProvider() {
   
   
        return new SwaggerResourcesProvider() {
   
   
            @Override
            public List<SwaggerResource> get() {
   
   
                List<SwaggerResource> resources = new ArrayList<>();
                List<Route> routes = discoveryClientRouteLocator.getRoutes();
                for (Route route : routes) {
   
   
                    // 从网关中取获取各个服务的 api-docs
                    resources.add(swaggerResource(route.getId(), route.getFullPath().replace("**", "v2/api-docs")));
                }
                return resources;
            }
        };
    }

    private SwaggerResource swaggerResource(String name, String location) {
   
   
        SwaggerResource swaggerResource = new SwaggerResource();
        swaggerResource.setName(name);
        swaggerResource.setLocation(location);
        swaggerResource.setSwaggerVersion("2.0");
        return swaggerResource;
    }

}

其他微服务中需要的配置：

@Configuration
@EnableSwagger2
@ConfigurationProperties(prefix = "com.swagger")   // 自定义前缀
@Data
public class Swagger2Config {
   
   
    //在各个项目配置文件中添加相应的属性：
    private String basePackage = "com.basePackage";    
    private String title = "swagger-title";
    private String description;

    @Bean
    public Docket createRestApi() {
   
   
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select().apis(RequestHandlerSelectors.basePackage(basePackage))
                .paths(PathSelectors.any()).build().securitySchemes(securitySchemes())
                .securityContexts(securityContexts());
    }

    private ApiInfo apiInfo() {
   
   
        return new ApiInfoBuilder()
                // 文档标题
                .title(title)
                // 文档描述
                .description(StringUtils.hasText(description) ? description : title)
               // .termsOfServiceUrl("https://www.***.com")
                // 设置文档版本号
                .version("v2.3")
                .build();
    }

    private List<ApiKey> securitySchemes() {
   
   
        List<ApiKey> apiKeyList = new ArrayList();
        apiKeyList.add(new ApiKey("Authorization", "Authorization", "header"));
        return apiKeyList;
    }

    private List<SecurityContext> securityContexts() {
   
   
        List<SecurityContext> securityContexts = new ArrayList<>();
        securityContexts.add(
                SecurityContext.builder()
                        .securityReferences(defaultAuth())
                        .forPaths(PathSelectors.regex("^(?!auth).*$"))
                        .build());
        return securityContexts;
    }

    List<SecurityReference> defaultAuth() {
   
   
        AuthorizationScope authorizationScope = new AuthorizationScope("global", "accessEverything");
        AuthorizationScope[] authorizationScopes = new AuthorizationScope[1];
        authorizationScopes[0] = authorizationScope;
        List<SecurityReference> securityReferences = new ArrayList<>();
        securityReferences.add(new SecurityReference("Authorization", authorizationScopes));
        return securityReferences;
    }

}

访问地址

ip:port/swagger-ui.html

可以通过网关服务的swagger页面去调用其他服务（会先经过网关）

如果是直接访问某个服务的swagger页面，则直接调用该服务，不经过网关

5.2 注解的使用

略

六、Maven在 Linux中使用

6.1 maven3.6.1下载地址

wget https://archive.apache.org/dist/maven/maven-3/3.6.1/binaries/

6.2 修改settings.xml配置

#自定义仓库地址
<localRepository>/usr/local/server/maven/repository3.6.1</localRepository>
#阿里云maven仓库
  <mirrors>
    <mirror>  
        <id>nexus-aliyun</id>  
        <mirrorOf>central</mirrorOf>    
        <name>Nexus aliyun</name>  
        <url>http://maven.aliyun.com/nexus/content/groups/public</url>  
    </mirror> 
  </mirrors> 
#修改maven的默认jdk版本为1.8
<profiles>
    <profile>
        <id>jdk-1.8</id>
        <activation>
            <activeByDefault>true</activeByDefault>
            <jdk>1.8</jdk>
        </activation>
        <properties>
            <maven.compiler.source>1.8</maven.compiler.source>
            <maven.compiler.target>1.8</maven.compiler.target>
            <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
        </properties>
    </profile>
</profiles>

6.3 配置mvn环境变量

echo "export MAVEN_HOME=/usr/local/maven3.6.1/apache-maven-3.6.1"  >>  /etc/profile
echo "export PATH=$MAVEN_HOME/bin:$PATH"  >>  /etc/profile
source /etc/profile
测试：
mvn -v

6.4 mvn常用命令

mvn  clean   
mvn  compile    # 编译
mvn  package    # 打包
mvn  install    # 打包并构建到本地仓库
mvn install -Dmaven.test.skip=true   # 打包并跳过测试
#单独构建模块 commonweb   同时会构建commonweb模块依赖的其他模块（上游模块）
mvn install -pl commonweb -am  
#单独构建模块commonweb ，同时构建依赖模块commonweb 的其他模块（下游模块）
mvn install -pl commonweb  -amd

#单独构建模块nnhx-eureka 并跳过测试
mvn install -pl  nnhx-eureka -am  -Dmaven.test.skip=true

#单独构建模块register-center 下面的 nnhx-eureka 并跳过测试
mvn install -pl  register-center/nnhx-eureka -am -Dmaven.test.skip=true

ps：构建指定模块时，建议先构建其上游模块（如果少量模块构建推荐使用命令操作，带上此参数【 -am】 ） ，且尽量避免同时构建同一个模块

文章标签：
Java
C++
微服务
Linux
负载均衡
网络架构
Maven
API
关键词：
Ribbon springcloud
springcloud Ribbon
springcloud feign
Hystrix springcloud
feign Ribbon
一壶明月
目录
相关文章
李杰-@yd
|
2月前
|
JSON Java 数据格式
【微服务】SpringCloud之Feign远程调用
本文介绍了使用Feign作为HTTP客户端替代RestTemplate进行远程调用的优势及具体使用方法。Feign通过声明式接口简化了HTTP请求的发送，提高了代码的可读性和维护性。文章详细描述了Feign的搭建步骤，包括引入依赖、添加注解、编写FeignClient接口和调用代码，并提供了自定义配置的示例，如修改日志级别等。
李杰-@yd
141 1
程序员小海绵
|
3月前
|
负载均衡 Java Nacos
SpringCloud基础2——Nacos配置、Feign、Gateway
nacos配置管理、Feign远程调用、Gateway服务网关
程序员小海绵
587 2
SpringCloud基础2——Nacos配置、Feign、Gateway
大数据文摘
|
3月前
|
XML 监控 Java
Spring Cloud全解析：熔断之Hystrix简介
Hystrix 是由 Netflix 开源的延迟和容错库，用于提高分布式系统的弹性。它通过断路器模式、资源隔离、服务降级及限流等机制防止服务雪崩。Hystrix 基于命令模式，通过 `HystrixCommand` 封装对外部依赖的调用逻辑。断路器能在依赖服务故障时快速返回备选响应，避免长时间等待。此外，Hystrix 还提供了监控功能，能够实时监控运行指标和配置变化。依赖管理方面，可通过 `@EnableHystrix` 启用 Hystrix 支持，并配置全局或局部的降级策略。结合 Feign 可实现客户端的服务降级。
大数据文摘
203 23
刘大猫.
|
3月前
|
前端开发 API 微服务
SpringCloud微服务之间使用Feign调用不通情况举例
SpringCloud微服务之间使用Feign调用不通情况举例
刘大猫.
672 2
土木林森
|
3月前
|
Java 对象存储 开发者
故障隔离与容错处理：Hystrix在Spring Cloud和Netflix OSS中的应用
故障隔离与容错处理：Hystrix在Spring Cloud和Netflix OSS中的应用
土木林森
65 3
艾利克斯冰
|
3月前
|
Java API 开发者
【已解决】Spring Cloud Feign 上传文件，提示：the request was rejected because no multipart boundary was found的问题
【已解决】Spring Cloud Feign 上传文件，提示：the request was rejected because no multipart boundary was found的问题
艾利克斯冰
735 0
mao29955
|
1月前
|
负载均衡 监控 网络协议
SpringCloud之Ribbon使用
通过以上步骤，就可以在Spring Cloud项目中有效地使用Ribbon来实现服务调用的负载均衡，提高系统的可靠性和性能。在实际应用中，根据具体的业务场景和需求选择合适的负载均衡策略，并进行相应的配置和优化，以确保系统的稳定运行。
mao29955
76 15
mao29955
|
1月前
|
负载均衡 算法 Java
除了 Ribbon，Spring Cloud 中还有哪些负载均衡组件？
这些负载均衡组件各有特点，在不同的场景和需求下，可以根据项目的具体情况选择合适的负载均衡组件来实现高效、稳定的服务调用。
mao29955
92 5
程序员小海绵
|
3月前
|
负载均衡 Java Nacos
SpringCloud基础1——远程调用、Eureka,Nacos注册中心、Ribbon负载均衡
微服务介绍、SpringCloud、服务拆分和远程调用、Eureka注册中心、Ribbon负载均衡、Nacos注册中心
程序员小海绵
102 0
SpringCloud基础1——远程调用、Eureka,Nacos注册中心、Ribbon负载均衡
蓝易云
|
4月前
|
负载均衡 算法 Java
SpringCloud之Ribbon使用
通过 Ribbon，可以非常便捷的在微服务架构中实现请求负载均衡，提升系统的高可用性和伸缩性。在实际使用中，需要根据实际场景选择合适的负载均衡策略，并对其进行适当配置，以达到更佳的负载均衡效果。
蓝易云
125 13

热门文章

最新文章

  • 1
    Hystrix和Sentinel有什么异同
  • 2
    常见的Ribbon/Spring LoadBalancer的负载均衡策略
  • 3
    微服务架构系统稳定性的神器-Hystrix
  • 4
    Hystrix 与 Sentinel 大比拼：微服务稳定性工具谁更优？
  • 5
    Spring Cloud Alibaba：一站式微服务解决方案
  • 6
    从单体到微服务：如何借助 Spring Cloud 实现架构转型
  • 7
    深入 Spring Cloud Gateway 过滤器
  • 8
    利用Spring Cloud Gateway Predicate优化微服务路由策略
  • 9
    深入探索Spring Cloud与Spring Boot：构建微服务架构的实践经验
  • 10
    微服务SpringCloud链路追踪之Micrometer+Zipkin
  • 1
    Spring cloud原理详解
    79
  • 2
    在SpringCloud2023中快速集成SpringCloudGateway网关
    168
  • 3
    SpringCloud基础 Consul的引入
    60
  • 4
    SpringCloud 基础配置
    53
  • 5
    springboot和springcloud有哪些区别？
    109
  • 6
    spring cloud使用jar包部署和docker部署的区别
    740
  • 7
    Spring Cloud原理详解
    121
  • 8
    IDEA 创建 SpringCloud项目-多项目方式
    184
  • 9
    Spring Cloud Feign 使用Apache的HTTP Client替换Feign原生httpclient
    433
  • 10
    Spring Cloud：一文读懂其原理与架构
    4947

    • 相关课程

    更多
  • 微服务+全栈在线教育实战项目演练（SpringCloud Alibaba+SpringBoot）
  • 微服务实战-服务注册与发现 - Nacos Discovery
  • 微服务实战-服务熔断 - Sentinel
  • 微服务实战-分布式配置中心 - Config
  • Dubbo 3.0 服务治理最佳实践
  • 微服务框架 Spring Cloud 快速入门

    • 相关电子书

    更多
  • 搭建基于SpringCloud的微服务应用
  • 搭建基于Spring Cloud 的微服务应用
  • Spring Cloud 微服务核心组件集 mica 的设计思路

    • 相关实验场景

    更多
  • 快速玩转Dubbo生态之限流降级篇（Sentinel）
  • 快速上手使用Dubbo进行远程调用
  • Spring-cloud-bus-rocketmq入门与实践
  • Spring-cloud-stream-binder-rocketmq入门与实践
    • 下一篇
    手把手教你白嫖阿里云服务器(免费领服务器)