从0到1的Springcloud Alibaba项目，一篇入门！！！

1、新建项目

我们用maven管理项目

第一步：选择maven

第二步：项目命名，项目路径

第三步：进入项目，把src文件夹删掉（不删也没事，主要是用不到这个文件夹）

2、引入项目依赖

在父项目pom文件加入下面依赖。

注：springboot项目版本与cloud版本有一定的对应关系，在官网可以看到，下面是对应的版本关系，选择合适的即可。

本项目所用依赖版本：

<?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>project_springcloud</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <!--springboot版本-->
        <spring.boot.version>2.3.8.RELEASE</spring.boot.version>
        <!--springcloud版本-->
        <spring.cloud.version>Hoxton.SR10</spring.cloud.version>
        <!--springcloudalibaba版本-->
        <spring.cloud.alibaba.version>2.2.1.RELEASE</spring.cloud.alibaba.version>
    </properties>

    <!-- 管理依赖的版本 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring.boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <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>
</project>

注意：

父工程dependencyManagement中管理的依赖在你们仓库中可能没有，所以要注释dependencyManagement先下载对应版本的依赖
dependencyManagement只是声明依赖，并不实现引入，因此子项目需要显示声明需要用的依赖

3、Nacos服务注册和发现

3.1、Nacos下载与启动

模拟生产环境，采用Linux部署

第一步：官网下载nacos（Nacos | Nacos），下载不了的可以关注公众号【JavaCoding】回复nacos获取

第二步：进入bin文件，修改startup.sh配置文件，下载的默认启动配置需要的内存太大，改小一点

第三步：命令启动sh startup.sh -m standalone，注：这里standalone参数代表着单机模式运行，非集群模式

控制台输出这样的内容代表启动成功，我们打开start.out日志查看内容：

3.2、服务注册

第一步：新建一个服务service1

要在父级目录下创建service1项目，具体步骤与上述创建父项目类似，过程省略，创建后的项目结构如下：

pom依赖：

<?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>project_springcloud</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>service1</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>${spring.boot.version}</version>
        </dependency>
        <!--nacos服务注册-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            <version>${spring.cloud.alibaba.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>nacos-client</artifactId>
                    <groupId>com.alibaba.nacos</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--nacos配置中心-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
            <version>${spring.cloud.alibaba.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>nacos-client</artifactId>
                    <groupId>com.alibaba.nacos</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--单独指定nacos client版本（自带的版本会在控制台一直输出日志）-->
        <dependency>
            <groupId>com.alibaba.nacos</groupId>
            <artifactId>nacos-client</artifactId>
            <version>1.4.2</version>
        </dependency>

    </dependencies>

</project>

第二步：登录我们启动的nacos地址，新建一个命名空间

第三步：点击配置列表右侧加号，新建一个配置

第四步：yml中配置（注意这里项目中配置文件名一定要是bootstrap）

spring:
  application:
    name: service1
  cloud:
    nacos:
      discovery:
        # 你的服务器ip
        server-addr: 114.115.xxx.xx:8848
        namespace: 900c8c5e-b442-4b61-abf4-90b640e643ea
      config:
        server-addr: 114.115.xxx.xx:8848
        namespace: 900c8c5e-b442-4b61-abf4-90b640e643ea
        prefix: service1
        group: DEFAULT_GROUP
        file-extension: yaml

最后启动项目：

我们可以看到，项目端口是用的我们nacos里配置里写好的端口

点开nacos服务列表：

我们可以看到我们启动的服务已经注册进来了，这里的服务名就是我们项目里spring.application.name配置的名

最后接口测试：

注意：

我们这里的启动类并没有加@EnableDiscoveryClient注解，是因为从Spring Cloud Edgware开始，这个注解可以省略。但是maven依赖中必须要有spring-cloud-starter-alibaba-nacos-discovery服务注册的依赖。

但是值得注意的是，如果使用了Eureka作为注册中心，那么需要使用@EnableEurekaClient注解来启动Eureka客户端。因此，是否需要省略@EnableDiscoveryClient注解取决于你的具体需求和使用的服务注册中心类型。

4、Gateway网关服务

4.1、项目引入

第一步：新建Gateway项目，过程省略，项目结构如下

第二步：引入pom依赖

<?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>project_springcloud</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>gateway</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!--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>
            <version>${spring.cloud.alibaba.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>nacos-client</artifactId>
                    <groupId>com.alibaba.nacos</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--nacos配置中心-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
            <version>${spring.cloud.alibaba.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>nacos-client</artifactId>
                    <groupId>com.alibaba.nacos</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--单独指定nacos client版本（自带的版本会在控制台一直输出日志）-->
        <dependency>
            <groupId>com.alibaba.nacos</groupId>
            <artifactId>nacos-client</artifactId>
            <version>1.4.2</version>
        </dependency>

    </dependencies>

</project>

第三步：nacos新增配置文件，与service1一样，端口我们设置为8002

第四步：配置文件

spring:
  application:
    name: gateway
  cloud:
    nacos:
      discovery:
        server-addr: 114.115.xxx.xx:8848
        namespace: 900c8c5e-b442-4b61-abf4-90b640e643ea
      config:
        server-addr: 114.115.xxx.xx:8848
        namespace: 900c8c5e-b442-4b61-abf4-90b640e643ea
        prefix: gateway
        group: DEFAULT_GROUP
        file-extension: yaml

第五步：启动项目

在nacos里可以看到我们的Gateway服务已经注册进来了

4.2、路由配置

上面步骤我们只是把Gateway服务启动，并没有体现出Gateway的作用，我们想要看到的是通过访问不通的接口，Gateway可以帮我自动找到到相应的服务。

简单介绍Gateway配置项：

路由（Route）：由ID、目标URI、断言集合和过滤器集合组成。如果聚合断言结果为真，则转发到该路由。

（1）id：路由标识，要求唯一，名称任意（默认值 uuid，一般不用，需要自定义）

（2）uri：请求最终被转发到的目标地址

（3）order：路由优先级，数字越小，优先级越高

（4）predicates：断言数组，即判断条件，如果返回值是boolean，则转发请求到 uri 属性指定的服务中

（5）filters：过滤器数组，在请求传递过程中，对请求做一些修改

断言（Predicate）：参照 Java8 的新特性Predicate，允许开发人员匹配 HTTP 请求中的任何内容，比如请求头或请求参数，最后根据匹配结果返回一个布尔值。

Predicate 来自于 Java8 的接口。Predicate 接受一个输入参数，返回一个布尔值结果。该接口包含多种默认方法来将 Predicate 组合成其他复杂的逻辑（比如：与，或，非）。

Predicate 可以用于接口请求参数校验、判断新老数据是否有变化需要进行更新操作。Spring Cloud Gateway 内置了许多 Predict，这些 Predict 的源码在 org.springframework.cloud.gateway.handler.predicate 包中，有兴趣可以阅读一下。

过滤器（Filter）：可以在返回请求之前或之后修改请求和响应的内容。

Gateway 过滤器的生命周期：

PRE：这种过滤器在请求被路由之前调用。我们可利用这种过滤器实现身份验证、在集群中选择请求的微服务、记录调试信息等。

POST：这种过滤器在路由到微服务以后执行。这种过滤器可用来为响应添加标准的 HTTP Header、收集统计信息和指标、将响应从微服务发送给客户端等。

Gateway 过滤器从作用范围可分为两种:

GatewayFilter：应用到单个路由或者一个分组的路由上（需要在配置文件中配置）

GlobalFilter：应用到所有的路由上（无需配置，全局生效）

有两种方式可以实现Gateway路由配置：

准备工作：我们先按照service1服务创建一个service2服务，端口用8003，创建后的项目架构：

service1和service2接口方法如下：

第一种：yml配置

在Gateway项目的yml中加入以下配置：

spring:
  application:
    name: gateway
  cloud:
    nacos:
      discovery:
        server-addr: 114.115.xxx.xx:8848
        namespace: 900c8c5e-b442-4b61-abf4-90b640e643ea
      config:
        server-addr: 114.115.xxx.xx:8848
        namespace: 900c8c5e-b442-4b61-abf4-90b640e643ea
        prefix: gateway
        group: DEFAULT_GROUP
        file-extension: yaml
    # gateway 配置
    gateway:
      # 路由数组：指当请求满足什么样的断言时，转发到哪个服务上
      routes:
          # 路由唯一标识
        - id: gateway-service1
          # 要转发到哪个服务,我们这里不直接写ip：端口的形式，因为一旦服务的域名或IP地址发生修改，路由配置中的 uri 就必须修改
          # 使用了lb形式，从注册中心负载均衡的获取uri
          uri: lb://service1
          # 设置断言
          predicates:
              # 满足/service1的请求路径会路由到localhost:8001服务
            - Path=/service1/**
          # 过滤器
          filters:
            # 去除原始请求路径中的前1级路径，也就是/service1
            - StripPrefix=1

          # 路由唯一标识
        - id: gateway-service2
          # 要转发到哪个服务
          uri: lb://service2
          # 设置断言
          predicates:
            # 满足/service1的请求路径会路由到localhost:8001服务
            - Path=/service2/**
          # 过滤器
          filters:
            # 去除原始请求路径中的前1级路径，也就是/service1
            - StripPrefix=1

启动项目：

通过网关访问service1服务的接口：

通过网关访问service2服务的接口：

结论：虽然两个服务接口地址一样，但通过网关配置，我们可以根据不同的请求路径前缀来访问不通的服务

第二种：代码配置

通过代码我们可以更加灵活的对Gateway进行配置，面对的场景也更加复杂。

第一步：先把yml中Gateway配置注释

第二步：添加自定义配置类

package com.javacoding.config;

import org.springframework.cloud.gateway.filter.FilterDefinition;
import org.springframework.cloud.gateway.handler.predicate.PredicateDefinition;
import org.springframework.cloud.gateway.route.RouteDefinition;
import org.springframework.cloud.gateway.route.RouteDefinitionRepository;
import org.springframework.stereotype.Component;
import org.springframework.web.util.UriComponentsBuilder;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.net.URI;
import java.util.*;

@Component
public class MyRouteDefinitionRepository implements RouteDefinitionRepository {
    @Override
    public Flux<RouteDefinition> getRouteDefinitions() {
        List<RouteDefinition> routeDefinitions = new ArrayList<>();
        // service1的route配置
        RouteDefinition service1 = setService1();
        // service2的route配置
        RouteDefinition service2 = setService2();
        routeDefinitions.add(service1);
        routeDefinitions.add(service2);
        return Flux.fromIterable(routeDefinitions);
    }

    private RouteDefinition setService2() {
        RouteDefinition definition = new RouteDefinition();
        // id
        definition.setId("service2");
        URI uri = UriComponentsBuilder.fromUriString("lb://service2").build().toUri();
        // uri
        definition.setUri(uri);

        PredicateDefinition predicate = new PredicateDefinition();
        predicate.setName("Path");

        Map<String, String> predicateParams = new HashMap<>(8);
        predicateParams.put("pattern", "/service2/**");
        predicate.setArgs(predicateParams);

        //定义Filter
        FilterDefinition filter = new FilterDefinition();
        filter.setName("StripPrefix");
        Map<String, String> filterParams = new HashMap<>(8);
        //该_genkey_前缀是固定的，见org.springframework.cloud.gateway.support.NameUtils类
        filterParams.put("_genkey_0", "1");
        filter.setArgs(filterParams);

        definition.setFilters(Collections.singletonList(filter));
        definition.setPredicates(Collections.singletonList(predicate));
        return definition;
    }

    private RouteDefinition setService1() {
        RouteDefinition definition = new RouteDefinition();
        // id
        definition.setId("service1");
        URI uri = UriComponentsBuilder.fromUriString("lb://service1").build().toUri();
        // uri
        definition.setUri(uri);

        PredicateDefinition predicate = new PredicateDefinition();
        predicate.setName("Path");

        Map<String, String> predicateParams = new HashMap<>(8);
        predicateParams.put("pattern", "/service1/**");
        predicate.setArgs(predicateParams);

        //定义Filter
        FilterDefinition filter = new FilterDefinition();
        filter.setName("StripPrefix");
        Map<String, String> filterParams = new HashMap<>(8);
        //该_genkey_前缀是固定的，见org.springframework.cloud.gateway.support.NameUtils类
        filterParams.put("_genkey_0", "1");
        filter.setArgs(filterParams);

        definition.setFilters(Collections.singletonList(filter));
        definition.setPredicates(Collections.singletonList(predicate));
        return definition;
    }

    @Override
    public Mono<Void> save(Mono<RouteDefinition> route) {
        return null;
    }

    @Override
    public Mono<Void> delete(Mono<String> routeId) {
        return null;
    }
}

第三步：启动项目测试

总结：这些只是基础的配置，实际生产中还会有自定义全局过滤器等。

5、Feign服务调用

5.1、服务调用

当我们在service1调用service2中的接口时，传统的项目我们直接用maven引入service2项目就可以直接调用。但在微服务中，各个项目都是独立存在的，我们如果用http去调用每次都非常繁琐，而且不方便拓展。因此Feign就是解决这个问题。

第一步：创建Feign项目，过程省略，项目结构如下

第二步：pom依赖

<?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>project_springcloud</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>feign</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

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

第三步：yml配置

spring:
  application:
    name: feign
  cloud:
    nacos:
      discovery:
        server-addr: 114.115.xxx.xx:8848
        namespace: 900c8c5e-b442-4b61-abf4-90b640e643ea
      config:
        server-addr: 114.115.xxx.xx:8848
        namespace: 900c8c5e-b442-4b61-abf4-90b640e643ea
        prefix: feign
        group: DEFAULT_GROUP
        file-extension: yaml

第四步：写feign客户端接口

package com.javacoding.service;

import com.javacoding.service.impl.Service2ClientBack;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

@FeignClient(value = "service2", fallback = Service2ClientBack.class)
public interface Service2Client {

    @RequestMapping("/test/msg")
    public String test(@RequestParam("msg") String msg);

}

说明：

1. @FeignClient注解标识当前接口是feign调用接口，value代表哪个服务调用接口，这里我们想调用service2服务，所以写service2（为什么写service2，因为service2服务里的配置文件spring.application.name，与他保持一致）；fallback是如果服务调用失败，我该怎么处理，这个类就是处理这个问题的。

2. 接口请求路径，请求名和方法与service2要调用的接口保持一致。

package com.javacoding.service.impl;

import com.javacoding.service.Service2Client;
import org.springframework.stereotype.Component;

/**
 * 调用失败返回
 */
@Component
public class Service2ClientBack implements Service2Client {
    @Override
    public String test(String msg) {
        return "service2服务调用失败！！！";
    }
}

第五步：在service1通过feign实现service2接口请求响应

1、在pom中加入feign依赖

<!--feign类引用-->
<dependency>
    <groupId>org.example</groupId>
    <artifactId>feign</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>
<!--feign服务依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

2、启动类添加@EnableFeignClients注解

package com.javacoding;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableFeignClients
public class Service1Application {
    public static void main(String[] args) {
        SpringApplication.run(Service1Application.class, args);
    }
}

3、controller添加调用的方法

package com.javacoding.controller;

import com.javacoding.service.Service2Client;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
@RequestMapping("/test")
public class TestController {
    
    @Resource
    private Service2Client service2Client;

    @GetMapping("/msg")
    public String test(@RequestParam("msg") String msg) {
        return "service1:" + msg;
    }

    /**
     * 通过feign调用service2的接口
     * 
     * @param msg
     * @return
     */
    @GetMapping("/feign/msg")
    public String test2(@RequestParam("msg") String msg) {
        String result = service2Client.test(msg);
        return "通过feign调用请求返回：" + result;
    }

}

4、测试

总结：我们并没有在service1中引入service2的服务，也实现了调用service2服务中的接口。之后我们想要在微服务中引入其他服务只需写一个某某服务的接口（xxxClient）利用@FeignClient注解指明哪个服务，通过这个接口就可以去调用我们的目标服务的接口。

5.2、服务降级

前面我在@FeignClient注解里加了fallback参数。Fallback是通过Hystrix实现的，所以需要开启Hystrix，spring boot application.properties文件配置feign.hystrix.enabled=true，这样就开启了Fallback。

service1的nacos中的yml配置：

server:
    port: 8001

feign:
  hystrix:
      enabled: true

service2中服务抛出个异常，模拟服务不可用：

package com.javacoding.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/test")
public class TestController {

    @GetMapping("/msg")
    public String test(@RequestParam("msg") String msg) {
        throw new RuntimeException();
//        return "service2:" + msg;
    }

}

测试：

5.3、负载均衡

如果我们service2服务是非常重要的，我们通过会部署好几个防止其中一个崩溃导致服务不可用，那么service1在通过feign调用的时候到底调用了哪一个service2呢？如何把请求进行分配呢?

第一步：先把service2的nacos配置的端口注释掉，改为写在项目bootstrap.yml里面。经过测试发现，如果不写在项目bootstrap.yml里面，后续我们启动两个service2服务的时候会一直用nacos配置里的端口。

spring:
  application:
    name: service2
  cloud:
    nacos:
      discovery:
        server-addr: 114.115.xxx.xx:8848
        namespace: 900c8c5e-b442-4b61-abf4-90b640e643ea
      config:
        server-addr: 114.115.xxx.xx:8848
        namespace: 900c8c5e-b442-4b61-abf4-90b640e643ea
        prefix: service2
        group: DEFAULT_GROUP
        file-extension: yaml
server:
  port: 8003

第二步：改造一下service2中的方法，返回信息中加入端口信息，方便区分请求的是哪个服务

package com.javacoding.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;

@RestController
@RequestMapping("/test")
public class TestController {

    @GetMapping("/msg")
    public String test(@RequestParam("msg") String msg, HttpServletRequest request) {
//        throw new RuntimeException();
        int serverPort = request.getServerPort();
        return "service2:" + msg + ",端口：" + serverPort;
    }

}

第三步：启动网关、service1、service2服务，然后复制service2更改端口启动，这样service2服务就启动了两个实例。

所有服务启动后nacos里的实例信息如下：

第四步：测试接口

总结：可以看到我们的请求在8003和8004端口来回切换，这就是默认的轮训策略。

拓展：除了默认的轮训还有哪些策略？

通常我们都是自定义的方式来配置我们的负载均衡策略，这样我们会有更多的操作空间。

在service1中我们自定义配置：

package com.javacoding.config;

import com.netflix.loadbalancer.RandomRule;
import com.netflix.loadbalancer.RoundRobinRule;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class FeignBalanceConfig {
    @Bean
    @LoadBalanced
    public RestTemplate getResTemplate() {
        return new RestTemplate();
    }

//    @Bean
//    public RoundRobinRule getRule() {
//        // 轮训
//        return new RoundRobinRule();
//    }

    @Bean
    public RandomRule getRule() {
        //随机策略
        return new RandomRule();
    }
}

测试随机策略：

还有其他一些策略，不在一一演示了，配置如下：

@Bean
public AvailabilityFilteringRule getRule() {
    //首先会过滤掉故障机或者并发链接数超过阈值的服务器.剩余的机器轮询配置
     return new AvailabilityFilteringRule();
}


@Bean
public WeightedResponseTimeRule getRule() {
    //服务器影响时间越快,则权重越高
     return new WeightedResponseTimeRule();
}


@Bean
public BestAvailableRule getRule() {
    //最大可用策略，即先过滤出故障服务器后，选择一个当前并发请求数最小的
    return new BestAvailableRule();
}

ok，以上内容如果都学会并了解那代表你已经可以用springcloud微服务应对90%开发需求了。当然还有Hystrix、Ribbon组件，虽然没讲如何用，但这两个组件Feign都已经很好了集成了，如果你面对的是非常复杂的开发场景，那也可以单独去配置这两个组件（原理都是一样的）。

希望这篇微服务项目可以带你很好的入门~~~