SpringCloud整合Feign实现负载均衡

比眉伴天荒 2021-12-12 04:07 307阅读 0赞

> # **cloud负载均衡策略主要是rest+ribbon和Feign，但是Feign已经集成了ribbon，所以比较牛逼。就用这个好了** #

# **1、首先搭建那么几个项目，一个eureka服务端，用于注册服务，再来三个客户端用于注册服务(一个生产者，两个消费者)。** #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjQ4MDI5_size_16_color_FFFFFF_t_70][]

生产者的接口可以让消费者去消费。。。前提是必须注册到服务上

# 2、首先看eureka服务端配置 #

导入依赖（有的依赖可能不是必须的，我懒得检查，直接全部复制）：

<dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-configuration-processor</artifactId>
                    <version>2.0.0.RELEASE</version>
                </dependency>
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter</artifactId>
                </dependency>
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-test</artifactId>
                    <scope>test</scope>
                </dependency>
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-web</artifactId>
                </dependency>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-starter-eureka-server</artifactId>
                    <version>1.4.4.RELEASE</version>
                </dependency>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-starter-config</artifactId>
                </dependency>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-starter-eureka</artifactId>
                    <version>1.4.4.RELEASE</version>
                </dependency>
                <dependency>
    		        <groupId>org.springframework.boot</groupId>
    		        <artifactId>spring-boot-starter-security</artifactId>
    		    </dependency>
    
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>Finchley.BUILD-SNAPSHOT</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>

application.yml配置信息：

server:
      port: 8888
      
    spring:
      security: 
        basic: 
            enable: true
        user: 
            name: admin
            password: 1234  
    
    eureka:
      instance:
        hostname: localhost
      client:
        registerWithEureka: false
        fetchRegistry: false
        service-url: 
          defaultZone: http://${spring.security.user.name}:${spring.security.user.password}@${eureka.instance.hostname}:${server.port}/eureka/

启动类：

@SpringBootApplication //spring-boot 启动注解
    @EnableEurekaServer // spring-cloud 服务注解
    public class RegisterMain{
         public static void main(String [] args) {
        	 new SpringApplicationBuilder(RegisterMain.class).web(true).run(args);
         }
    }

写一个配置类

//Spring Cloud 2.0 以上的security默认启用了csrf检验，要在eurekaServer端配置security的csrf检验为false
    //覆盖父类的 configure(HttpSecurity http) 方法，关闭掉 csrf。
    @EnableWebSecurity
    public class WebSecurityConfig extends WebSecurityConfigurerAdapter{
    	 @Override
        protected void configure(HttpSecurity http) throws Exception {
            http.csrf().disable();
            super.configure(http);
        }
    }

\-----------------------------------------------这样就完成了服务端的配置--------------------------------------------------------

# 3、创建一个客户端。这里项目创建一个boot工程就行了，然后启动两次 #

首先是依赖，和上面一样，复制就行了，至于没用的依赖不管了。

启动类：

@SpringBootApplication
    @EnableEurekaClient //Eureka Client111
    public class AppMain {
        public static void main(String[] args) {
            new SpringApplicationBuilder(AppMain.class).web(true).run(args);
        }
    }

application.yml配置信息：

server:
      port: 8001
     
    spring:
      application:
        name: spring-cloud-common
     
    #注册中心指向start    
    eureka:
    #  instance:
    #    instance-id: spring-cloud-common
    #    appname: ${spring.application.name}
      client: 
        service-url: 
          defaultZone: http://admin:1234@127.0.0.1:8888/eureka/
    #注册中心指向end

在编写一个controller层

@RestController
    public class DemoController {
    
        @Value("${server.port}")
        String port;
    
        @GetMapping("/demo")
        public String demo(@RequestParam(value = "name", defaultValue = "小毅毅") String name) {
            return "name:" + name + " ,端口:" + port;
        }
    }

这里配置文件的端口为8001，我们启动一次后，端口修改成8002在启动一次，那么就会注册上2个服务了。

如何启动2次代码呢？

点击：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjQ4MDI5_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjQ4MDI5_size_16_color_FFFFFF_t_70 2][]

\---------------------------------------------------这样生产者就写好了------------------------------------------

# 四、现在是最关键的消费者，使用feign实现的负载均衡 #

关键的maven依赖注意，多添加一个这个

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

然后是启动类：

@SpringBootApplication
    //@EnableEurekaClient //Eureka 客户端
    @EnableDiscoveryClient
    @EnableFeignClients //开启Feign的功能
    public class CrudMain {
        public static void main(String[] args) {
            new SpringApplicationBuilder(CrudMain.class).web(true).run(args);
        }
    }

application.yml配置文件：

server:
      port: 8010
    spring:
      application:
        name: spring-cloud-crud
     
    #注册中心指向start    
    eureka:
      instance:
        instance-id: spring-cloud-crud
        appname: ${spring.application.name}
      client: 
        service-url: 
          defaultZone: http://admin:1234@127.0.0.1:8888/eureka/
    #注册中心指向end

关键地方，接口的编写，我这里为了省事，就一个类里面把所有代码都写上

@RestController
    public class TestController {
    //    @Autowired
    //    private RestTemplate restTemplate;
        @Autowired
        Feign feign;  //依赖注入的接口
    //    private static final String MALL_CRUD_USERS_URL = "http://spring-cloud-common/";
    
        @GetMapping("/getCommon")
        public String getCommon(@RequestParam String name) {
            System.out.println("调用服务开始---------");
    //        String s = restTemplate.getForObject(MALL_CRUD_USERS_URL+"demo?name="+name, String.class);
            String s=feign.feignDemo(name);
            System.out.println("调用服务结束---------调用取得的值为："+s);
            return s;
        }
    }
    
    /*
    * 这个接口就是为了调用别的服务
    * */
    @Service
    @FeignClient(value = "spring-cloud-common")  //Feign会根据注解上的value值找到具体的服务名，然后再根据接口上的Mapping找到当前服务对应的接口
    interface Feign{
        @GetMapping("/demo")    //这里的路径和生产者的路径一致，所以才能对应上
        String feignDemo(@RequestParam(value = "name") String name);
    }

\------------------------------------------消费者完成--------------------------------------------------------

# 接下来系统测试： #

按照顺序启动，首先是eureka服务端，由于开启了安全认证，所以登录后就能访问了，账号amdin，密码1234。配置文件都写了的。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjQ4MDI5_size_16_color_FFFFFF_t_70 3][]

登录成功后，还没有服务注册：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjQ4MDI5_size_16_color_FFFFFF_t_70 4][]

然后服务端的启动顺序就不规定了，我这里先启动common这个包的，这个生产者得启动两次，启动第一次后修改端口启动第二次。两次都启动成功后如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjQ4MDI5_size_16_color_FFFFFF_t_70 5][]

注册成功，这时候启动消费者crud包

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjQ4MDI5_size_16_color_FFFFFF_t_70 6][]

成功启动成所有项目。。这个时候进行测试：

浏览器输入：[http://localhost:8010/getCommon?name=][http_localhost_8010_getCommon_name]小毅毅

![20190710110312159.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjQ4MDI5_size_16_color_FFFFFF_t_70 7][]

![2019071011032331.png][]

成功实现负载均衡--------------

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjQ4MDI5_size_16_color_FFFFFF_t_70]: /images/20211211/9a8ccc5419e44923bc6d734f94fbf0b1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjQ4MDI5_size_16_color_FFFFFF_t_70 1]: /images/20211211/e1631cb3705049128a7e9c0897699790.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjQ4MDI5_size_16_color_FFFFFF_t_70 2]: /images/20211211/8019163498db44be9f6568d44cad42e6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjQ4MDI5_size_16_color_FFFFFF_t_70 3]: /images/20211211/07871de0019d4af781e0fa3474caf33e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjQ4MDI5_size_16_color_FFFFFF_t_70 4]: /images/20211211/d0f4f293f3134231b5ae71392d718dd3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjQ4MDI5_size_16_color_FFFFFF_t_70 5]: /images/20211211/7a576258fc764f60b20bee18190d5b56.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjQ4MDI5_size_16_color_FFFFFF_t_70 6]: /images/20211211/ef00609eec384c90b7c546deb9714ede.png
[http_localhost_8010_getCommon_name]: http://localhost:8010/getCommon?name=%E5%B0%8F%E6%AF%85%E6%AF%85
[20190710110312159.png]: /images/20211211/32e0476f62e44f30b538d982e8b18ac3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5NjQ4MDI5_size_16_color_FFFFFF_t_70 7]: /images/20211211/6e6ff15621af4eaaafe4807e512899ec.png
[2019071011032331.png]: /images/20211211/5992c575141b4f588edd194674f66ac7.png