springcloud的服务提供者的集群搭建和消费者使用Ribbon和Feign

前言

本章的标题可能有点长，总的来说在上章的知识中我们学了如何搭建一个注册中心集群，

本次内容：如何搭建服务提供者集群和通过调用ribbon来负载均衡的调用这个集群

---

1、搭建一个服务集群并起了个应用名字(三合一)

服务器名字为：microservice-student-provider

pom.xml配置
在原先的基础上并没有做出很大的改变

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!--保持使用版本的一致1.0-SNAPSHOT-->
    <parent>
        <groupId>com.liwangwang</groupId>
        <artifactId>springcloud</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <artifactId>microservice-student-provider</artifactId>

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

    <dependencies>
        <!--相当于全局的一个依赖关系，这个导入能确保整个项目使用的包版本一致
            比如全局中的： spring-cloud-dependencies
                           spring-boot-dependencies
                           druid-spring-boot-starter

        -->
        <dependency>
            <groupId>com.liwangwang</groupId>
            <artifactId>microservice-common</artifactId>
        </dependency>
        <!--处理web请求-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--test测试的包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--使用的数据库关系映射框架是jpa-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <!--使用的是mysql数据库-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--使用tomcat-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </dependency>
        <!--druid数据源-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
        </dependency>
        <!--  修改后立即生效，热部署  -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>springloaded</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <!--需要引入公共模块的实体类等（在导入的时候出现）-->
        <dependency>
            <groupId>com.liwangwang</groupId>
            <artifactId>microservice-common</artifactId>
            <version>1.0-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>
        <!--添加注册中心Eureka相关配置,就是说这个是消费者-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
        </dependency>
        <!-- actuator监控引入，点击后的追责 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>



    </dependencies>

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

</project>

application.yml文件

与原先的文件比多了

---
server:
  port: 1001
  context-path: /
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/context?useUnicode=true&characterEncoding=utf8
    username: root
    password: 123
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
  application: # 设置应用的基本信息(名称
    name: microservice-student
  profiles: provider-1001

eureka:
  instance:
    hostname: localhost  #eureka消费者主机实例名称
    appname: microservice-student  #消费者服务名
    instance-id: microservice-student:1001 #消费者实例名称
    prefer-ip-address: true #是否显示IP
  client:
    service-url:
      #设置与Eureka注册中心交互的地址，是所有注册中心
      defaultZone: http://eureka2001.javawwl.com:2001/eureka/,http://eureka2002.javawwl.com:2002/eureka/,http://eureka2003.javawwl.com:2003/eureka/   #把服务注册到eureka注册中心

info:
  groupId: com.liwangwang.springcloud
  artifactId: microservice-student-provider-1001
  version: 1.0-SNAPSHOT
  userName: http://www.javawwl.com
  phone: 123456

---
server:
  port: 1002
  context-path: /
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/context?useUnicode=true&characterEncoding=utf8
    username: root
    password: 123
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
  application: # 设置应用的基本信息(名称
    name: microservice-student
  profiles: provider-1002

eureka:
  instance:
    hostname: localhost  #eureka消费者主机实例名称
    appname: microservice-student  #消费者服务名
    instance-id: microservice-student:1002 #消费者实例名称
    prefer-ip-address: true #是否显示IP
  client:
    service-url:
      #设置与Eureka注册中心交互的地址，是所有注册中心
      defaultZone: http://eureka2001.javawwl.com:2001/eureka/,http://eureka2002.javawwl.com:2002/eureka/,http://eureka2003.javawwl.com:2003/eureka/   #把服务注册到eureka注册中心

info:
  groupId: com.liwangwang.springcloud
  artifactId: microservice-student-provider-1002
  version: 1.0-SNAPSHOT
  userName: http://www.javawwl.com
  phone: 123456

---
server:
  port: 1003
  context-path: /
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/context?useUnicode=true&characterEncoding=utf8
    username: root
    password: 123
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
  application: # 设置应用的基本信息(名称
    name: microservice-student
  profiles:

eureka:
  instance:
    hostname: localhost  #eureka消费者主机实例名称
    appname: microservice-student  #消费者服务名
    instance-id: microservice-student:1003 #消费者实例名称
    prefer-ip-address: true #是否显示IP
  client:
    service-url:
      #设置与Eureka注册中心交互的地址，是所有注册中心
      defaultZone: http://eureka2001.javawwl.com:2001/eureka/,http://eureka2002.javawwl.com:2002/eureka/,http://eureka2003.javawwl.com:2003/eureka/   #把服务注册到eureka注册中心

info:
  groupId: com.liwangwang.springcloud
  artifactId: microservice-student-provider-1003
  version: 1.0-SNAPSHOT
  userName: http://www.javawwl.com
  phone: 123456

controller层
处理消费者发过来的请求

package com.liwangwang.microservicestudentprovider.controller;

import com.liwangwang.microservicecommon.entity.Student;
import com.liwangwang.microservicestudentprovider.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/student")
public class StudentProviderController {

    @Value("${server.port}")
    private String port;


    @Autowired
    private StudentService studentService;
     
    @PostMapping(value="/save")
    public boolean save(Student student){
        try{
            studentService.save(student);  
            return true;
        }catch(Exception e){
            return false;
        }
    }
     
    @GetMapping(value="/list")
    public List<Student> list(){
        return studentService.list();
    }
     
    @GetMapping(value="/get/{id}")
    public Student get(@PathVariable("id") Integer id){
        return studentService.findById(id);
    }
     
    @GetMapping(value="/delete/{id}")
    public boolean delete(@PathVariable("id") Integer id){
        try{
            studentService.delete(id);
            return true;
        }catch(Exception e){
            return false;
        }
    }

    @RequestMapping("/ribbon")
    public String ribbon(){
        return "工号【"+port+"】正在为您服务";
    }

}

main方法

package com.liwangwang.microservicestudentprovider;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@EntityScan("com.liwangwang.*.*")
@EnableEurekaClient
@SpringBootApplication
public class MicroserviceStudentProviderApplication {

    public static void main(String[] args) {
        SpringApplication.run(MicroserviceStudentProviderApplication.class, args);
    }

}

配置三个在上章已经教了如何使用

---

2、消费者调用使用Ribbon负载均衡器

消费端的名字：microservice-student-consumer-80

pom.xml的对比，消费端和服务提供者的区别

pom.xml
具体的细节在上面

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!--保持使用版本的一致1.0-SNAPSHOT-->
    <parent>
        <groupId>com.liwangwang</groupId>
        <artifactId>springcloud</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <artifactId>microservice-student-consumer-80</artifactId>

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

    <dependencies>
        <!--相当于全局的一个依赖关系，这个导入能确保整个项目使用的包版本一致
            比如全局中的： spring-cloud-dependencies
                           spring-boot-dependencies
                           druid-spring-boot-starter

        -->
        <dependency>
            <groupId>com.liwangwang</groupId>
            <artifactId>microservice-common</artifactId>
        </dependency>
        <!--处理web请求-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--test测试的包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--使用的数据库关系映射框架是jpa-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <!--使用的是mysql数据库-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--使用tomcat-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </dependency>
        <!--  修改后立即生效，热部署  -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>springloaded</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <!--需要引入公共模块的实体类等（在导入的时候出现）-->
        <dependency>
            <groupId>com.liwangwang</groupId>
            <artifactId>microservice-common</artifactId>
            <version>1.0-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>
        <!--添加注册中心Eureka相关配置,就是说这个是消费者-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
        </dependency>
        <!--使用了ribbon的包-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-ribbon</artifactId>
        </dependency>





    </dependencies>

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

</project>

yml文件

如上面所说加上了Eureka的一个消费者所该配置的

server:
  port: 80
  context-path: /
eureka:
  client:
    service-url:
      #设置与Eureka注册中心交互的地址，查询服务和注册服务用到
      defaultZone: http://eureka2001.javawwl.com:2001/eureka/,http://eureka2002.javawwl.com:2002/eureka/,http://eureka2003.javawwl.com:2003/eureka/
    register-with-eureka: false     #false 由于该应用为消费者，所以设置为false,代表不向注册中心注册自己。
    fetch-registry: true     #true 由于消费者(消费者)就是寻找服务实例，它需要去检索服务，所以设置为true

controller层：

改变不大，就改变了server_ip_port的字段，

记住一定要是上面的服务提供者搭建而成的一个名字，并且大写

config的改变：

结果测试

---

3、消费者的Feign优化，解决Ribbon轮询问题

重新创建一个消费者： microservice-student-consumer-feign-80
此pom.xml，和yml文件都不变。

一、解决Ribbon轮询问题

package com.liwangwang.microservicestudentconsumerfeign80.config;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RetryRule;
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 SpringCloudConfig {

    @LoadBalanced  // 引入ribbon负载均衡
    @Bean
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }

    /**
     * 自定义调用规则（服务提供者掉线后不再调用，解决轮询问题）
     * @return
     */
    @Bean
    public IRule myRule(){
        return new RetryRule();
//        return new RandomRule();
    }
}

二、Feign的优化

controller改变成了这个，变成了从common项目里获取一个service,并注入里面

StudentConsumerController

package com.liwangwang.microservicestudentconsumerfeign80.controller;

import com.liwangwang.microservicecommon.entity.Student;
import com.liwangwang.microservicecommon.service.StudentClientService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
@RequestMapping("/student")
public class StudentConsumerController {

    @Autowired
    private StudentClientService studentClientService;

    @Autowired
    private RestTemplate restTemplate;

    @PostMapping(value = "/save")
    private boolean save(Student student) {
        return studentClientService.save(student);
    }

    @GetMapping(value = "/list")
    public List<Student> list() {
        return studentClientService.list();
    }

    @GetMapping(value = "/get/{id}")
    public Student get(@PathVariable("id") Integer id) {
        return studentClientService.get(id);
    }

    @GetMapping(value = "/delete/{id}")
    public boolean delete(@PathVariable("id") Integer id) {
        try {
            studentClientService.delete(id);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    @RequestMapping("/ribbon")
    public String ribbon(){
        return studentClientService.ribbon();
    }
}

main文件

common层的改变

StudentClientService ：这个就是要使用到注入的service 层

package com.liwangwang.microservicecommon.service;

import com.liwangwang.microservicecommon.entity.Student;
import org.springframework.cloud.netflix.feign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

/**
 * Student Feign接口消费者
 * @author Administrator
 *
 */
@FeignClient(value="MICROSERVICE-STUDENT")
public interface StudentClientService {
 
    /**
     * 根据id查询学生信息
     * @param id
     * @return
     */
    @GetMapping(value="/student/get/{id}")
    public Student get(@PathVariable("id") Integer id);
     
    /**
     * 查询学生信息
     * @return
     */
    @GetMapping(value="/student/list")
    public List<Student> list();
     
    /**
     * 添加或者修改学生信息
     * @param student
     * @return
     */
    @PostMapping(value="/student/save")
    public boolean save(Student student);
     
    /**
     * 根据id删除学生信息
     * @return
     */
    @GetMapping(value="/student/delete/{id}")
    public boolean delete(@PathVariable("id") Integer id);

    @RequestMapping("/student/ribbon")
    public String ribbon();
}

测试

---

后记

好吧，其实大部分的讲解我都已图解的方式写了上去，额，导致不能copy了，哎~

本章学习内容：
1、创建了一个服务集群
在上章中我们搭建好了一个服务注册中心的三合一集群，那么此次我们第一步要做的就是搭建一个服务集群，注意大致的配置文件不变：
增加一个
application.name: microservice-student # 设置集群名称
profiles: provider-1001 # 设置此服务的唯一标识

2、使用到了Ribbon的负载均衡
这里简单聊一下负载均衡干嘛的？
在我们以前是直接知道那个服务提供者的一个地址(ip+端口)的话就直接去访问就是了，可现如今我们的一个服务提供者变成了一个服务提供者集群并且注册到了Eureka的注册中心上，那么等我们的消费端使用注册中心获取服务地址(ip+端口)后发现有了三个服务提供者，其实这并不影响操作，你大可继续像之前一样知道之前的服务地址就可以访问了，可这就没什么变化了，所以为了提高性能我们使用了Ribbon的负载均衡，这样是把原先固定的地址(ip+端口)变成了由Ribbon掌控的分配，比如说：轮询，随机，这样每一个服务提供者都会被访问到，并且就算宕机宕的只有一个服务提供者了，那一个服务提供者也能提供所有的服务。

额，实现负载均衡的重点：
消费者中导好：Ribbon依赖
消费者中 加上注解：@LoadBalanced

3、使用了Feign来优化代码
为什么要优化？
我们是不是到时候会在每一个controller层里都会写一个类似(http://MICROSERVICE-STUDENT)
那么如果我们有一天更改了名字，那么是不是意味这所有的controller层都需要更改这个字符串。
还有写成了service层的话，有些要调用的话也可以少写一些代码。

实现Feign的重点
消费者中导好：Feign依赖
消费者中在main类上加上注解：@EnableFeignClients(value = “com.liwangwang..”)

在common项目上的注解：@FeignClient(value=“MICROSERVICE-STUDENT”)