Java学习笔记分享之Spring Cloud Netflix篇（上）

Myth丶恋晨 2022-12-24 08:55 167阅读 0赞

# Spring Cloud Netflix #

## Spring Cloud 是什么 ##

\[百度百科\]Spring Cloud是一系列框架的有序集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用 Spring Boot的开发风格做到一键启动和部署。Spring Cloud并没有重复制造轮子，它只是将目前各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，通过Spring Boot风格进行再封装屏蔽掉了复杂的配置和实现原理，最终给开发者提供一套简单易懂、易部署和易维护的分布式系统开发工具包。

Spring Cloud为开发人员提供了工具来快速构建分布式系统中的一些常见模式(例如配置管理、服务发现、断路器、智能路由、微代理、控制总线、一次性令牌、全局锁、领导选举、分布式会话、集群状态)。分布式系统的协调产生了模板模式，使用Spring Cloud开发人员可以快速建立实现这些模式的服务和应用程序。它们在任何分布式环境中都能很好地工作，包括开发者自己的笔记本电脑、裸机数据中心以及云计算等托管平台。

## Spring Cloud 解决什么问题 ##

Spring Cloud 规范及实现意图解决的问题是微服务架构实施过程中存在的一些问题，比如微服务架构中的服务注册发现问题、网络问题（比如熔断场景）、统一认证安全授权问题、负载均衡问题、链路追踪等问题。

## Spring Cloud 架构 ##

Spring Cloud是一个微服务相关规范，这个规范意图为搭建微服务架构提供一站式服务，采用组件（框架）化机制定义一系列组件，各类组件针对性的处理微服务中的特定问题，这些组件共同来构成Spring Cloud微服务技术栈。

### Spring Cloud 核心组件 ###

Spring Cloud 的生态技术圈中，按照发展可以分为第一代Spring Cloud组件和第二代Spring Cloud组件。具体的组件对比如下：

<table> 
 <thead> 
  <tr> 
   <th>组件</th> 
   <th>第一代Spring Cloud(Netflix)</th> 
   <th>第二代Spring Cloud(Alibaba)</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>注册中心</td> 
   <td>Netflix Eureka</td> 
   <td>Alibaba Nacos</td> 
  </tr> 
  <tr> 
   <td>客户端负载均衡</td> 
   <td>Netflix Ribbon</td> 
   <td>Alibaba Dubbo LB、Spring Cloud Loadbalaner</td> 
  </tr> 
  <tr> 
   <td>熔断器</td> 
   <td>Netflix Hystrix</td> 
   <td>Alibaba Sentinel</td> 
  </tr> 
  <tr> 
   <td>网关</td> 
   <td>Netflix Zuul</td> 
   <td>Spring Cloud Gateway</td> 
  </tr> 
  <tr> 
   <td>配置中心</td> 
   <td>Spring Cloud Config</td> 
   <td>Alibaba Nacos、携程 Apollo</td> 
  </tr> 
  <tr> 
   <td>服务调用</td> 
   <td>Netflix Feign</td> 
   <td>Alibaba Dubbo RPC</td> 
  </tr> 
  <tr> 
   <td>消息驱动</td> 
   <td>Spring Cloud Stream</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>链路追踪</td> 
   <td>Spring Cloud Sleuth/Zipkin</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>事务</td> 
   <td></td> 
   <td>Alibaba seata</td> 
  </tr> 
 </tbody> 
</table>

**组件协同工作流程**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzMyMzY2MzI5_size_16_color_FFFFFF_t_70_pic_center]

## Spring Cloud 和 Dubbo 对比 ##

Dubbo是阿里巴巴公司开源的一个高性能优秀的服务框架，基于RPC调用，对于目前使用率较高的Spring Cloud Netflix来说，它是基于HTTP的，所以效率上没有Dubbo高，但问题在于Dubbo体系的组件不全，不能够提供一站式解决⽅案，比如服务注册与发现需要借助于Zookeeper等实现，SpringCloud Netflix则是真正的提供了一站式服务化解决方案，且有Spring家族背景。

## Spring Cloud 和 Spring Boot 的关系 ##

Spring Cloud 只是利用了Spring Boot 的特点，让我们能够快速的实现微服务组件开发，否则不使用Spring Boot的话，我们在使用Spring Cloud时，每个组件的相关Jar包都需要我们导入配置以及需要考虑兼容性等各种情况。所以Spring Boot是我们快速把Spring Cloud微服务技术应用起来。

## 案例准备 ##

首先我们按照普通的方式模拟一个微服务之间的调用过程，后面会慢慢的加入Spring Cloud的组件改造该案例。通过这样的方式让大家了解微服务如何替代我们原始的开发，以及如何解决我们的痛点问题。

拉勾App有这样一个功能：“面试直通车”，当求职用户开启了面试直通车之后，会根据企业客户的招聘岗位需求进行双向匹配。其中有一个操作是：为企业用户开启一个定时任务，根据企业录用的用人条件，每日匹配一定数量的应聘者“投递”到企业的资源池中去，那么系统在将匹配到的应聘者投递到资源池的时候需要先检查：此时应聘者默认简历的状态(公开/隐藏)，如果此时默认简历的状态已经被应聘者设置为“隐藏”，那么不再执行“投递”操作。 “自动投递功能”在“自动投递微服务”中，“简历状态查询功能”在“简历微服务”中，那么就涉及到“自动投递微服务”调用“简历微服务”查询简历。在这种场景下，“自动投递微服务”就是一个服务消费者，“简历微服务”就是一个服务提供者。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzMyMzY2MzI5_size_16_color_FFFFFF_t_70_pic_center 1]

**数据库SQL**

/* Navicat Premium Data Transfer Source Server : localhost Source Server Type : MySQL Source Server Version : 50717 Source Host : 127.0.0.1:3306 Source Schema : lagou Target Server Type : MySQL Target Server Version : 50717 File Encoding : 65001 Date: 19/04/2020 17:49:15 */
    
    SET NAMES utf8mb4;
    SET FOREIGN_KEY_CHECKS = 0;
    
    -- ----------------------------
    -- Table structure for r_resume
    -- ----------------------------
    DROP TABLE IF EXISTS `r_resume`;
    CREATE TABLE `r_resume` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `sex` varchar(10) DEFAULT NULL COMMENT '性别',
      `birthday` varchar(30) DEFAULT NULL COMMENT '出生日期',
      `work_year` varchar(100) DEFAULT NULL COMMENT '工作年限',
      `phone` varchar(20) DEFAULT NULL COMMENT '手机号码',
      `email` varchar(100) DEFAULT NULL COMMENT '邮箱',
      `status` varchar(80) DEFAULT NULL COMMENT '目前状态',
      `resumeName` varchar(500) DEFAULT NULL COMMENT '简历名称',
      `name` varchar(40) DEFAULT NULL,
      `createTime` datetime DEFAULT NULL COMMENT '创建日期',
      `headPic` varchar(100) DEFAULT NULL COMMENT '头像',
      `isDel` int(2) DEFAULT NULL COMMENT '是否删除 默认值0-未删除 1-已删除',
      `updateTime` datetime DEFAULT NULL COMMENT '简历更新时间',
      `userId` int(11) DEFAULT NULL COMMENT '用户ID',
      `isDefault` int(2) DEFAULT NULL COMMENT '是否为默认简历 0-默认 1-非默认',
      `highestEducation` varchar(20) DEFAULT '' COMMENT '最高学历',
      `deliverNearByConfirm` int(2) DEFAULT '0' COMMENT '投递附件简历确认 0-需要确认 1-不需要确认',
      `refuseCount` int(11) NOT NULL DEFAULT '0' COMMENT '简历被拒绝次数',
      `markCanInterviewCount` int(11) NOT NULL DEFAULT '0' COMMENT '被标记为可面试次数',
      `haveNoticeInterCount` int(11) NOT NULL DEFAULT '0' COMMENT '已通知面试次数',
      `oneWord` varchar(100) DEFAULT '' COMMENT '一句话介绍自己',
      `liveCity` varchar(100) DEFAULT '' COMMENT '居住城市',
      `resumeScore` int(3) DEFAULT NULL COMMENT '简历得分',
      `userIdentity` int(1) DEFAULT '0' COMMENT '用户身份1-学生 2-工人',
      `isOpenResume` int(1) DEFAULT '3' COMMENT '人才搜索-开放简历 0-关闭，1-打开，2-简历未达到投放标准被动关闭 3-从未设置过开放简历',
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=2195388 DEFAULT CHARSET=utf8;
    
    -- ----------------------------
    -- Records of r_resume
    -- ----------------------------
    BEGIN;
    INSERT INTO `r_resume` VALUES (2195320, '女', '1990', '2年', '199999999', 'test@testtest01.com', '我目前已离职，可快速到岗', '稻壳儿的简历', 'wps', '2015-04-24 13:40:14', 'images/myresume/default_headpic.png', 0, '2015-04-24 13:40:14', 1545132, 1, '本科', 0, 0, 0, 0, '', '广州', 15, 0, 3);
    INSERT INTO `r_resume` VALUES (2195321, '女', '1990', '2年', '199999999', 'test@testtest01.com', '我目前已离职，可快速到岗', '稻壳儿的简历', 'wps', '2015-04-24 14:17:54', 'images/myresume/default_headpic.png', 0, '2015-04-24 14:20:35', 1545133, 1, '本科', 0, 0, 0, 0, '', '广州', 65, 0, 3);
    INSERT INTO `r_resume` VALUES (2195322, '女', '1990', '2年', '199999999', 'test@testtest01.com', '我目前已离职，可快速到岗', '稻壳儿的简历', 'wps', '2015-04-24 14:42:45', 'images/myresume/default_headpic.png', 0, '2015-04-24 14:43:34', 1545135, 1, '本科', 0, 0, 0, 0, '', '广州', 65, 0, 3);
    INSERT INTO `r_resume` VALUES (2195323, '女', '1990', '2年', '199999999', 'test@testtest01.com', '我目前已离职，可快速到岗', '稻壳儿的简历', 'wps', '2015-04-24 14:48:19', 'images/myresume/default_headpic.png', 0, '2015-04-24 14:50:34', 1545136, 1, '本科', 0, 0, 0, 0, '', '广州', 65, 0, 3);
    INSERT INTO `r_resume` VALUES (2195331, '女', '1990', '2年', '199999999', 'test@testtest01.com', '我目前已离职，可快速到岗', '稻壳儿的简历', 'wps', '2015-04-24 18:43:35', 'images/myresume/default_headpic.png', 0, '2015-04-24 18:44:08', 1545145, 1, '本科', 0, 0, 0, 0, '', '广州', 65, 0, 3);
    INSERT INTO `r_resume` VALUES (2195333, '女', '1990', '2年', '199999999', 'test@testtest01.com', '我目前已离职，可快速到岗', '稻壳儿的简历', 'wps', '2015-04-24 19:01:13', 'images/myresume/default_headpic.png', 0, '2015-04-24 19:01:14', 1545148, 1, '本科', 0, 0, 0, 0, '', '广州', 65, 0, 3);
    INSERT INTO `r_resume` VALUES (2195336, '女', '1990', '2年', '199999999', 'test@testtest01.com', '我目前已离职，可快速到岗', '稻壳儿的简历', 'wps', '2015-04-27 14:13:02', 'images/myresume/default_headpic.png', 0, '2015-04-27 14:13:02', 1545155, 1, '本科', 0, 0, 0, 0, '', '广州', 65, 0, 3);
    INSERT INTO `r_resume` VALUES (2195337, '女', '1990', '2年', '199999999', 'test@testtest01.com', '我目前已离职，可快速到岗', '稻壳儿的简历', 'wps', '2015-04-27 14:36:55', 'images/myresume/default_headpic.png', 0, '2015-04-27 14:36:55', 1545158, 1, '本科', 0, 0, 0, 0, '', '广州', 65, 0, 3);
    INSERT INTO `r_resume` VALUES (2195369, '女', '1990', '10年以上', '199999999', 'test@testtest01.com', '我目前已离职，可快速到岗', '稻壳儿', 'wps', '2015-05-15 18:08:19', 'images/myresume/default_headpic.png', 0, '2015-05-15 18:08:19', 1545346, 1, '本科', 0, 0, 0, 0, '', '广州', 65, 0, 3);
    INSERT INTO `r_resume` VALUES (2195374, '女', '1990', '1年', '199999999', 'test@testtest01.com', '我目前正在职，正考虑换个新环境', '稻壳儿', 'wps', '2015-06-04 17:53:37', 'images/myresume/default_headpic.png', 0, '2015-06-04 17:53:39', 1545523, 1, '本科', 0, 0, 0, 0, '', '广州', 65, 0, 3);
    INSERT INTO `r_resume` VALUES (2195375, '女', '1990', '1年', '199999999', 'test@testtest01.com', '我目前正在职，正考虑换个新环境', '稻壳儿', 'wps', '2015-06-04 18:11:06', 'images/myresume/default_headpic.png', 0, '2015-06-04 18:11:07', 1545524, 1, '本科', 0, 0, 0, 0, '', '广州', 65, 0, 3);
    INSERT INTO `r_resume` VALUES (2195376, '女', '1990', '1年', '199999999', 'test@testtest01.com', '我目前正在职，正考虑换个新环境', '稻壳儿', 'wps', '2015-06-04 18:12:19', 'images/myresume/default_headpic.png', 0, '2015-06-04 18:12:19', 1545525, 1, '本科', 0, 0, 0, 0, '', '广州', 65, 0, 3);
    INSERT INTO `r_resume` VALUES (2195377, '女', '1990', '1年', '199999999', 'test@testtest01.com', '我目前正在职，正考虑换个新环境', '稻壳儿', 'wps', '2015-06-04 18:13:28', 'images/myresume/default_headpic.png', 0, '2015-06-04 18:13:28', 1545526, 1, '本科', 0, 0, 0, 0, '', '广州', 65, 0, 3);
    INSERT INTO `r_resume` VALUES (2195378, '女', '1990', '1年', '199999999', 'test@testtest01.com', '我目前正在职，正考虑换个新环境', '稻壳儿', 'wps', '2015-06-04 18:15:16', 'images/myresume/default_headpic.png', 0, '2015-06-04 18:15:16', 1545527, 1, '本科', 0, 0, 0, 0, '', '广州', 65, 0, 3);
    INSERT INTO `r_resume` VALUES (2195379, '女', '1990', '1年', '199999999', 'test@testtest01.com', '我目前正在职，正考虑换个新环境', '稻壳儿', 'wps', '2015-06-04 18:23:06', 'images/myresume/default_headpic.png', 0, '2015-06-04 18:23:06', 1545528, 1, '本科', 0, 0, 0, 0, '', '广州', 65, 0, 3);
    INSERT INTO `r_resume` VALUES (2195380, '女', '1990', '1年', '199999999', 'test@testtest01.com', '我目前正在职，正考虑换个新环境', '稻壳儿', 'wps', '2015-06-04 18:23:38', 'images/myresume/default_headpic.png', 0, '2015-06-04 18:23:39', 1545529, 1, '本科', 0, 0, 0, 0, '', '广州', 65, 0, 3);
    INSERT INTO `r_resume` VALUES (2195381, '女', '1990', '1年', '199999999', 'test@testtest01.com', '我目前正在职，正考虑换个新环境', '稻壳儿', 'wps', '2015-06-04 18:27:33', 'images/myresume/default_headpic.png', 0, '2015-06-04 18:27:33', 1545530, 1, '本科', 0, 0, 0, 0, '', '广州', 65, 0, 3);
    INSERT INTO `r_resume` VALUES (2195382, '女', '1990', '1年', '199999999', 'test@testtest01.com', '我目前正在职，正考虑换个新环境', '稻壳儿', 'wps', '2015-06-04 18:31:36', 'images/myresume/default_headpic.png', 0, '2015-06-04 18:31:39', 1545531, 1, '本科', 0, 0, 0, 0, '', '广州', 65, 0, 3);
    INSERT INTO `r_resume` VALUES (2195383, '女', '1990', '1年', '199999999', 'test@testtest01.com', '我目前正在职，正考虑换个新环境', '稻壳儿', 'wps', '2015-06-04 18:36:48', 'images/myresume/default_headpic.png', 0, '2015-06-04 18:36:48', 1545532, 1, '本科', 0, 0, 0, 0, '', '广州', 65, 0, 3);
    INSERT INTO `r_resume` VALUES (2195384, '女', '1990', '1年', '199999999', 'test@testtest01.com', '我目前正在职，正考虑换个新环境', '稻壳儿', 'wps', '2015-06-04 19:15:15', 'images/myresume/default_headpic.png', 0, '2015-06-04 19:15:16', 1545533, 1, '本科', 0, 0, 0, 0, '', '广州', 65, 0, 3);
    INSERT INTO `r_resume` VALUES (2195385, '女', '1990', '1年', '199999999', 'test@testtest01.com', '我目前正在职，正考虑换个新环境', '稻壳儿', 'wps', '2015-06-04 19:28:53', 'images/myresume/default_headpic.png', 0, '2015-06-04 19:28:53', 1545534, 1, '本科', 0, 0, 0, 0, '', '广州', 65, 0, 3);
    INSERT INTO `r_resume` VALUES (2195386, '女', '1990', '1年', '199999999', 'test@testtest01.com', '我目前正在职，正考虑换个新环境', '稻壳儿', 'wps', '2015-06-04 19:46:42', 'images/myresume/default_headpic.png', 0, '2015-06-04 19:46:45', 1545535, 1, '本科', 0, 0, 0, 0, '', '广州', 65, 0, 3);
    INSERT INTO `r_resume` VALUES (2195387, '女', '1990', '1年', '199999999', 'test@testtest01.com', '我目前正在职，正考虑换个新环境', '稻壳儿', 'wps', '2015-06-04 19:48:16', 'images/myresume/default_headpic.png', 0, '2015-06-04 19:48:16', 1545536, 1, '本科', 0, 0, 0, 0, '', '广州', 65, 0, 3);
    COMMIT;
    
    SET FOREIGN_KEY_CHECKS = 1;

**工程环境**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzMyMzY2MzI5_size_16_color_FFFFFF_t_70_pic_center 2]

**父工程lagou-parent**

*  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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
            <modelVersion>4.0.0</modelVersion>
        
            <groupId>org.example</groupId>
            <artifactId>spring-cloud-netflix</artifactId>
            <version>1.0-SNAPSHOT</version>
            
            <packaging>pom</packaging>
            <parent>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-parent</artifactId>
                <version>2.1.6.RELEASE</version>
            </parent>
        
            <dependencyManagement>
                <dependencies>
                    <dependency>
                        <groupId>org.springframework.cloud</groupId>
                        <artifactId>spring-cloud-dependencies</artifactId>
                        <version>Greenwich.RELEASE</version>
                        <type>pom</type>
                        <scope>import</scope>
                    </dependency>
                </dependencies>
            </dependencyManagement>
        
            <dependencies>
                
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-web</artifactId>
                </dependency>
                
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </dependency>
                
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-test</artifactId>
                    <scope>test</scope>
                </dependency>
                
                <dependency>
                    <groupId>org.projectlombok</groupId>
                    <artifactId>lombok</artifactId>
                    <version>1.18.4</version>
                    <scope>provided</scope>
                </dependency>
                
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-actuator</artifactId>
                </dependency>
                
                <dependency>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-devtools</artifactId>
                    <optional>true</optional>
                </dependency>
        
        
                
                <dependency>
                    <groupId>com.sun.xml.bind</groupId>
                    <artifactId>jaxb-core</artifactId>
                    <version>2.2.11</version>
                </dependency>
                <dependency>
                    <groupId>javax.xml.bind</groupId>
                    <artifactId>jaxb-api</artifactId>
                </dependency>
                <dependency>
                    <groupId>com.sun.xml.bind</groupId>
                    <artifactId>jaxb-impl</artifactId>
                    <version>2.2.11</version>
                </dependency>
                <dependency>
                    <groupId>org.glassfish.jaxb</groupId>
                    <artifactId>jaxb-runtime</artifactId>
                    <version>2.2.10-b140310.1920</version>
                </dependency>
                <dependency>
                    <groupId>javax.activation</groupId>
                    <artifactId>activation</artifactId>
                    <version>1.1.1</version>
                </dependency>
                
            </dependencies>
            <build>
                <plugins>
                    
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-compiler-plugin</artifactId>
                        <configuration>
                            <source>11</source>
                            <target>11</target>
                            <encoding>utf-8</encoding>
                        </configuration>
                    </plugin>
                    
                    <plugin>
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-maven-plugin</artifactId>
                    </plugin>
                </plugins>
            </build>
        </project>

**简历微服务**

*  pom.xml
    
        <dependencies>
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-jpa</artifactId>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <scope>runtime</scope>
            </dependency>
            <dependency>
                common模块坐标
            </dependency>
        </dependencies>
 *  实体类，放到common模块
    
        package org.example.pojo;
        
        import lombok.Data;
        
        import javax.persistence.Column;
        import javax.persistence.Entity;
        import javax.persistence.Id;
        import javax.persistence.Table;
        
        @Data
        @Entity
        @Table(name="r_resume")
        public class Resume { 
            @Id
            private Long id; 
            private String sex; 
            private String birthday;
            @Column(name = "work_year")
            private String workYear; 
            private String phone; 
            private String email; 
            private String status; 
            private String resumeName; 
            private String name; 
            private String createTime; 
            private String headPic;
            private Integer isDel; 
            private String updateTime;
            private Long userId; 
            private Integer isDefault;
            private String highestEducation;
            private Integer deliverNearByConfirm;
            private Integer refuseCount;
            private Integer markCanInterviewCount; 
            private Integer haveNoticeInterCount; 
            private String oneWord; 
            private String liveCity; 
            private Integer resumeScore;
            private Integer userIdentity; 
            private Integer isOpenResume; 
        }
 *  Dao层接口
    
        package org.example.dao;
        
        import org.example.pojo.Resume;
        import org.springframework.data.jpa.repository.JpaRepository;
        
        public interface ResumeDao extends JpaRepository<Resume, Long> { 
        }
 *  Service层接口和实现类
    
        package org.example.service;
        
        import org.example.pojo.Resume;
        
        public interface ResumeService { 
        
            Resume findDefaultResumeByUserId(Long userId);
        
        }
    
        package org.example.service.impl;
        
        import org.example.pojo.Resume;
        import org.example.dao.ResumeDao;
        import org.example.service.ResumeService;
        import org.springframework.beans.factory.annotation.Autowired;
        import org.springframework.data.domain.Example;
        import org.springframework.stereotype.Service;
        
        @Service
        public class ResumeServiceImpl implements ResumeService { 
        
            @Autowired
            private ResumeDao resumeDao;
        
            @Override
            public Resume findDefaultResumeByUserId(Long userId) { 
                Resume resume = new Resume();
                resume.setId(userId);
                Example<Resume> resumeExample = Example.of(resume);
                return resumeDao.findOne(resumeExample).get();
            }
        }
 *  Controller控制层
    
        package org.example.controller;
        
        import org.example.service.ResumeService;
        import org.springframework.beans.factory.annotation.Autowired;
        import org.springframework.beans.factory.annotation.Value;
        import org.springframework.cloud.context.config.annotation.RefreshScope;
        import org.springframework.web.bind.annotation.PathVariable;
        import org.springframework.web.bind.annotation.RequestMapping;
        import org.springframework.web.bind.annotation.RestController;
        
        @RestController
        @RequestMapping("/resume")
        public class ResumeController { 
        
            @Autowired
            private ResumeService resumeService;
        
            @RequestMapping("/openstate/{userId}")
            public Integer findDefaultResumeState(@PathVariable Long userId) { 
                return resumeService.findDefaultResumeByUserId(userId).getIsOpenResume();
            }
        }
 *  Spring Boot 启动类
    
        package org.example;
        
        import org.springframework.boot.SpringApplication;
        import org.springframework.boot.autoconfigure.SpringBootApplication;
        import org.springframework.boot.autoconfigure.domain.EntityScan;
        import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
        
        @SpringBootApplication
        @EntityScan("org.example.pojo")
        public class ResumeApplication8080 { 
        
            public static void main(String[] args) { 
                SpringApplication.run(ResumeApplication8080.class, args);
            }
        
        }
 *  yml配置文件
    
        server:
          port: 8080 
        spring:
          application:
            name: service-resume # 配置应用的名称
          datasource: # 配置数据库信息 serverTimezone=UTC避免时区错误
            url: jdbc:mysql://localhost:3306/lagou_spring_cloud?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC
            driver-class-name: com.mysql.jdbc.Driver
            username: root
            password: root
          jpa: # 配置jpa信息
            database: mysql # 数据库类型
            show-sql: true # 是否显示执行的sql
            hibernate: # jpa底层是使用hibernate作为实现
              naming:
                physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl # 避免将驼峰命名转换为下划线命名

**自动投递微服务**

*  yml配置文件
    
        server:
        	port: 8090
 *  Controller控制层
    
        package org.example.controller;
        
        import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
        import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
        import org.springframework.beans.factory.annotation.Autowired;
        import org.springframework.cloud.client.ServiceInstance;
        import org.springframework.cloud.client.discovery.DiscoveryClient;
        import org.springframework.web.bind.annotation.PathVariable;
        import org.springframework.web.bind.annotation.RequestMapping;
        import org.springframework.web.bind.annotation.RestController;
        import org.springframework.web.client.RestTemplate;
        
        import java.util.List;
        
        /** * @Author zhang yong jun * @time 2020/8/25 15:51 */
        @RestController
        @RequestMapping("/autodeliver")
        public class AutodeliverController { 
        
            @Autowired
            private RestTemplate restTemplate; // spring 对restful编程风格的支持
        
            // URL常见的参数模式：http://localhost:8090/autodeliver/checkState?userId=12356
            // 将参数做为请求路径的写法：http://localhost:8090/autodeliver/checkState/12356
            @RequestMapping("/checkState/{userId}")
            public Integer findResumeOpenState(@PathVariable(value = "userId") Long userId) { 
                // http方式调用
                Integer forObject = restTemplate.getForObject("http://localhost:8080/resume/openstate/" + userId, Integer.class);
                System.out.println("[autodeliver]微服务调用[resume]微服务的[openstate]方法返回结果：" + forObject);
                return forObject;
            }
        
        }
 *  Spring Boot 启动类
    
        @SpringBootApplication
        public class AutodeliverApplication8090 { 
        
            public static void main(String[] args) { 
                SpringApplication.run(AutodeliverApplication8090.class, args);
            }
        
        }

**测试**

*  启动自动投递微服务和简历微服务
 *  通过浏览器访问自动投递微服务的findResumeOpenState方法，可以发现通过http调用了简历微服务

**问题分析**

*  接口调用问题，自动投递微服务通过http方式硬编码了请求简历微服务的地址，不方便维护
 *  简历微服务目前只有一个服务，但是如果是集群，那么如何分配请求成为难题，负载均衡难以处理
 *  自动投递微服务不清楚简历微服务的状态，服务是否可用
 *  如果调用简历微服务出现异常，如何处理
 *  RestTemplate请求方式如何优化
 *  各个微服务之间如何统一认证
 *  多个服务之间的功能配置如何管理，如何动态修改立即生效

**问题解决**

*  服务管理：自动注册、发现与监控服务状态
 *  服务负载均衡
 *  熔断
 *  远程过程调用
 *  网关统一拦截、路由、认证
 *  配置中心

对于以上问题，Spring Cloud都提供了对应的解决方案，下面我们慢慢改造这个案例，逐步引入Spring Cloud组件。

## 第一代Spring Cloud核心组件 ##

**说明：由于篇幅有限，这里的案例改造我们只演示Eureka服务注册中心和Feign远程调用组件。更多的技术知识学习可以加入拉勾Java高薪训练营**

*  改造目标

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzMyMzY2MzI5_size_16_color_FFFFFF_t_70_pic_center 3]

### Eureka服务注册中心 ###

服务注册中心存在的意义和本质：解耦以及管理服务提供者和服务消费者。在分布式架构中，必定存在多个服务提供者，为了进一步的管理和扩容这些微服务。就需要可以实时的管理服务（新增或者剔除）。实现这个功能的就是服务注册中心。

目前市场主流的服务提供者有Zookeeper、Nacos、Eureka等。今天我们引入的是第一代Spring Cloud组件的Eureka。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzMyMzY2MzI5_size_16_color_FFFFFF_t_70_pic_center 4]

在分布式微服务架构中，服务注册中心用于存储服务提供者的地址信息、服务的相关属性，消费者通过主动查询和被动通知的方式获取服务提供者的地址信息，而不用通过硬编码的方式写死服务提供者地址。

服务消费者只需要知道目前服务注册中心有哪些服务，不需要知道这些服务具体的地址信息，这就是路由透明化。

*  服务注册中心对比
    
     *  Zookeeper
        
        Zookeeper它是一个分布式服务框架，是Apache Hadoop 的一个子项目，它主要是解决分布式应 用中经常遇到的数据管理问题，如：统一命名服务、状态同步服务、集群管理、分布式应用配置项的管理等。
        
        Zookeeper 做服务注册中心，主要是因为它具有节点变更通知功能，只要客户端监听相关服务节点，服务节点的所有变更，都能及时的通知到监听客户端，这样调用方只要使用Zookeeper 的客户端就能实现服务节点的订阅和变更通知功能。另外，Zookeeper可用性也可以，因为只要半数以上的选举节点存活，整个集群就可用。
     *  Eureka
        
        由Netflix开源，并被Pivatal集成到SpringCloud体系中，它是基于 RestfulAPI 风格开发的服务注册  
        与发现组件。
     *  Consul
        
        Consul是由HashiCorp基于Go语言开发的支持多数据中心分布式高可用的服务发布和注册服务软  
        件， 采用Raft算法保证服务的一致性，并且支持健康检查。
     *  Nacos
        
        Nacos是一个易于构建云原生应用的动态服务发现、配置管理和服务管理平台。简单来说 Nacos就是 注册中心 + 配置中心的组合，帮助我们解决微服务开发必会涉及到的服务注册 与发现，服务  
        配置，服务管理等问题。Nacos 是 Spring Cloud Alibaba 核心组件之一，负责服务注册与发现以及配置中心的功能。
    
    <table> 
     <thead> 
      <tr> 
       <th>组件</th> 
       <th>语言</th> 
       <th>CAP</th> 
       <th>接口调用方式</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>Eureka</td> 
       <td>Java</td> 
       <td>AP（高可用、分区容错性）</td> 
       <td>HTTP</td> 
      </tr> 
      <tr> 
       <td>Consul</td> 
       <td>Go</td> 
       <td>CP（数据一致性、分区容错性）</td> 
       <td>HTTP/DNS</td> 
      </tr> 
      <tr> 
       <td>Zookeeper</td> 
       <td>Java</td> 
       <td>CP（数据一致性、分区容错性）</td> 
       <td>客户端</td> 
      </tr> 
      <tr> 
       <td>Nacos</td> 
       <td>Java</td> 
       <td>支持AP/CP切换</td> 
       <td>HTTP</td> 
      </tr> 
     </tbody> 
    </table>
 *  parent的pom.xml
    
        
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>Greenwich.RELEASE</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
 *  eureka模块pom.xml
    
        <dependencies>
            
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
            </dependency>
        </dependencies>
 *  application.yml
    
        server:
          port: 8761 # 项目端口
        spring:
          application:
            name: cloud-eureka-server
        # eureka配置
        eureka:
          instance:
            hostname: localhost
            prefer-ip-address: true # 使用ip注册，如果不填写就会使用主机名称注册
          client:
            service-url: # 客户端与eureka server交互的地址，如果是集群使用逗号隔开
              defaultZone: http://LagouCloudEurekaServerB:8762/eureka/ # 在集群中，作为镜像节点进行数据的复制
            register-with-eureka: false # 是否将自己注册到eureka server 单应用模式，不用注册，如果是集群就需要注册，给其他eureka server发现
            fetch-registry: false # 是否需要从eureka server中获取服务信息，单应用模式，不需要，如果是集群就需要获取其他eureka server
 *  Spring Boot启动类
    
        package org.example;
        
        import org.springframework.boot.SpringApplication;
        import org.springframework.boot.autoconfigure.SpringBootApplication;
        import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
        
        @EnableEurekaServer // 声明项目是一个Eureka Server
        @SpringBootApplication
        public class EurekaServerApplication8761 { 
        
            public static void main(String[] args) { 
                SpringApplication.run(EurekaServerApplication8761.class, args);
            }
        
        }
    
    **说明**
    
     *  启动Eureka注册中心
     *  访问http://127.0.0.1:8761 就可以看到Eureka注册中心后台，则表明EurekaServer发布成功

#### 改造微服务注册到Eureka ####

*  parent引入spring-cloud-commons依赖
    
        <dependency>
        	<groupId>org.springframework.cloud</groupId>
        	<artifactId>spring-cloud-commons</artifactId>
        </dependency>
 *  简历微服务改造
    
     *  pom.xml引入Eureka client坐标
        
            <dependency>
            	<groupId>org.springframework.cloud</groupId>
            	<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            </dependency>
     *  yml配置文件
        
            # 添加eureka client配置
            eureka:
              client:
                service-url:
                  defaultZone: http://localhost:8761/eureka/ # 将服务信息注册到eureka server集群,集群有多少个server就写多少个
              instance:
                prefer-ip-address: true # 使用ip注册，如果不填写就会使用主机名称注册
                # 自定义实例id的显示格式，添加版本号方便排查问题
                instance-id: ${ spring.cloud.client.ip-address}:${ spring.application.name}:${ server.port}:@project.version@
     *  启动类改造
        
            // 添加注解
            @EnableDiscoveryClient
            // 启动简历微服务，就可以在Eureka注册中心界面看到服务
     *  注意
        
         *  Spring Cloud Edgware版本开始，@EnableDiscoveryClient或者@EnableEurekaClient注解可以省略。只需要添加依赖并且进行相关配置，就可以将服务发布到Eureka上
         *  @EnableDiscoveryClient和@EnableEurekaClient注解功能一样的。但是区别在于@EnableEurekaClient只适合注册中心是Eureka，而@EnableDiscoveryClient适合所有的注册中心例如Eureka、Nacos、Zookeeper等。所以推荐使用@EnableDiscoveryClient注解，这样可以在以后切换注册中心的时候不用更代码
 *  自动投递微服务改造
    
     *  pom.xml引入Eureka client坐标
        
            <dependency>
            	<groupId>org.springframework.cloud</groupId>
            	<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            </dependency>
     *  yml配置文件
        
            # 添加eureka client配置
            eureka:
              client:
                service-url:
                  defaultZone: http://localhost:8761/eureka/ # 将服务信息注册到eureka server集群,集群有多少个server就写多少个
              instance:
                prefer-ip-address: true # 使用ip注册，如果不填写就会使用主机名称注册
                # 自定义实例id的显示格式，添加版本号方便排查问题
                instance-id: ${ spring.cloud.client.ip-address}:${ spring.application.name}:${ server.port}:@project.version@
     *  启动类改造
        
            // 添加注解
            @EnableDiscoveryClient
            // 启动简历微服务，就可以在Eureka注册中心界面看到服务
     *  通过Eureka注册中心调用服务
        
            package org.example.controller;
            
            import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
            import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
            import org.springframework.beans.factory.annotation.Autowired;
            import org.springframework.cloud.client.ServiceInstance;
            import org.springframework.cloud.client.discovery.DiscoveryClient;
            import org.springframework.web.bind.annotation.PathVariable;
            import org.springframework.web.bind.annotation.RequestMapping;
            import org.springframework.web.bind.annotation.RestController;
            import org.springframework.web.client.RestTemplate;
            
            import java.util.List;
            
            /** * @Author zhang yong jun * @time 2020/8/25 15:51 */
            @RestController
            @RequestMapping("/autodeliver")
            public class AutodeliverController { 
            
                // 使用服务注册中心，调用微服务实现
                @Autowired
                private DiscoveryClient discoveryClient; // 注入微服务发现客户端
            
                @RequestMapping("/checkStateDis/{userId}")
                public Integer findResumeOpenStateDis(@PathVariable(value = "userId") Long userId) { 
                    // 从服务注册中心获取指定的实例
                    List<ServiceInstance> serviceInstances = discoveryClient.getInstances("service-resume");
                    // 从多个实例中获取一个
                    ServiceInstance serviceInstance = serviceInstances.get(0);
                    // 获取实例的信息
                    String host = serviceInstance.getHost();
                    int port = serviceInstance.getPort();
                    System.out.println("host:" + host + " port:" + port);
                    // http
                    Integer forObject = restTemplate.getForObject("http://" + host + ":" + port + "/resume/openstate/" + userId, Integer.class);
                    System.out.println("[autodeliver]微服务调用[resume]微服务的[openstate]方法返回结果：" + forObject);
                    return forObject;
                }
            }

### Feign 远程组件调用 ###

Feign是Netflix开发的一款轻量级RESTful的HTTP服务客户端利用它来发起远程调用的请求，是以Java接口注解的方式发起HTTP调用，而不是Java中封装请求报文的方式发起HTTP调用，这样服务消费者就可以向调用本地接口方法一样去调用，Feign被广泛的应用在Spring Cloud的解决方案中。

*  Feign可以帮助我们更加便捷的调用HTTP API。不需要像前面的案例一样拼接URL，再通过restTemplate调用。Spring Cloud中使用Feign非常简单，创建一个接口并添加注解即可。
 *  Spring Cloud对Feign进行了增强，使得Feign支持Spring MVC的注解OpenFeign

#### 整合Feign ####

*  自动投递微服务引入依赖
    
        <dependency>
        	<groupId>org.springframework.cloud</groupId>
        	<artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
 *  自动投递微服务启动类添加注解@EnableFeignClients开启对Feign的支持
    
        @EnableFeignClients // 开启Feign
 *  自动投递微服务创建Feign接口
    
        package org.example.service;
        
        import org.example.service.impl.ResumeFallback;
        import org.springframework.cloud.openfeign.FeignClient;
        import org.springframework.web.bind.annotation.PathVariable;
        import org.springframework.web.bind.annotation.RequestMapping;
        
        @FeignClient(name = "service-resume"/*服务注册在Eureka的名称，大小写均可*/)
        public interface ResumeInterface { 
        
            @RequestMapping("/openstate/{userId}", method=RequestMethod.GET)
            public Integer findDefaultResumeState(@PathVariable Long userId);
        
        }
 *  修改调用服务过程
    
        package org.example.controller;
        
        import org.example.service.ResumeInterface;
        import org.springframework.beans.factory.annotation.Autowired;
        import org.springframework.web.bind.annotation.PathVariable;
        import org.springframework.web.bind.annotation.RequestMapping;
        import org.springframework.web.bind.annotation.RestController;
        
        @RestController
        @RequestMapping("/autodeliver")
        public class AutodeliverController { 
        
            @Autowired
            private ResumeInterface resumeInterface;
        
            @RequestMapping("/checkState/{userId}")
            public Integer findResumeOpenStateFeign(@PathVariable(value = "userId") Long userId) { 
                // feign调用
                Integer forObject = resumeInterface.findDefaultResumeState(userId);
                System.out.println("[autodeliver]微服务调用[resume]微服务的[openstate]方法返回结果：" + forObject);
                return forObject;
            }
        
        }

**注意**

*  @FeignClient注解的name属性用于指定调用的服务提供者名称，和服务提供者yml配置文件中spring.application.name保持一致
 *  接口中的方法，和服务提供者的Controller保持一致
 *  OpenFeign是Spring对Feign的增强，支持Spring MVC注解。例如@PathVariable、@RequstParam、@RequestHandler等
 *  Feign = restTemplate（远程调用） + ribbon（负载均衡） + hystrix（熔断）三个加在一起的功效
 *  这里只使用了Feign的远程调用功能，负载均衡和熔断暂时没有介绍

@RestController  
@RequestMapping("/autodeliver")  
public class AutodeliverController \{

@Autowired
      private ResumeInterface resumeInterface;
    
      @RequestMapping("/checkState/{userId}")
      public Integer findResumeOpenStateFeign(@PathVariable(value = "userId") Long userId) {
          // feign调用
          Integer forObject = resumeInterface.findDefaultResumeState(userId);
          System.out.println("[autodeliver]微服务调用[resume]微服务的[openstate]方法返回结果：" + forObject);
          return forObject;
      }

**注意**
    
    * @FeignClient注解的name属性用于指定调用的服务提供者名称，和服务提供者yml配置文件中spring.application.name保持一致
    * 接口中的方法，和服务提供者的Controller保持一致
    * OpenFeign是Spring对Feign的增强，支持Spring MVC注解。例如@PathVariable、@RequstParam、@RequestHandler等
    * Feign = restTemplate（远程调用） + ribbon（负载均衡） + hystrix（熔断）三个加在一起的功效
    * 这里只使用了Feign的远程调用功能，负载均衡和熔断暂时没有介绍

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzMyMzY2MzI5_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/bc60742d765e417b98a0ac37b6094be9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzMyMzY2MzI5_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20201127150729939.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzMyMzY2MzI5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzMyMzY2MzI5_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/2020112715074780.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzMyMzY2MzI5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzMyMzY2MzI5_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20201127150816559.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzMyMzY2MzI5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzMyMzY2MzI5_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20201127150827570.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzMyMzY2MzI5,size_16,color_FFFFFF,t_70#pic_center