一、工具及说明

开发工具：IntelliJ IDEA 2018.2.2 (Ultimate Edition)
框架：spring boot 2.0.8、spring cloud Finchley.SR2

以通用户ID获取用户信息为例，搭建一套spring cloud微服务系统。
需要搭建一个父工程spring-cloud，一个服务注册中心eureka-server，两个微服务cloud-client,cloud-provider。
两个微服务均注册到服务注册中心。

二、微服务服务方的搭建

1.File—>New—>Module

2.选择Spring Initializr,选择对应的JDK，
Choose Initializr Server URL 选择 default。
Next。 

3.输入项目组Group:com.cloud。
组件名称Artifact:cloud-provider。
Type:选择Maven Project。
修改自动生成的Package。
Next。 

4.dependencies选择Cloud Discovery—>Eureka Discovery。
Spring Boot选择你需要的版本，我这选择2.0.8。
Next。 

5.Project Name一般不做修改，和组件名称Artifact一样。
Content root、Module file location 均按自动生成，不做修改。
Finish。

6.配置。
将自动生成的application.properties更改为application.yml文件，个人习惯使用yml文件。
rename的快捷键是Shift+F6。
在application.yml中加入以下配置：

server:
  port: 8081
spring:
  application:
    name: cloud-provider
eureka:
  client:
    serviceUrl:
      defaultZone: http://user:123456@localhost:8080/eureka/      #服务注册中信地址，含有BASIC认证的用户名和密码
  instance:
    prefer-ip-address: true         #将IP注册到服务注册中心

#放开所有节点
management:
  endpoints:
    web:
      exposure:
        include: '*'

7.修改pom文件。
可以发现，pom文件中已自动引入了Eureka客户端依赖。
将按以下修改，使用父工程spring-cloud的spring boot依赖。
如果需要使用/health进行健康检查，则加入健康检查模块。
如果需使用Tomcat运行，需要加入tomcat支持模块和web模块。

<?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>
    <!-- 引入父工程的spring boot依赖 -->
    <parent>
        <groupId>com.cloud</groupId>
        <artifactId>spring-cloud</artifactId>
        <version>1.0</version>
    </parent>
    <groupId>com.cloud</groupId>
    <artifactId>cloud-provider</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>cloud-provider</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Finchley.SR2</spring-cloud.version>
    </properties>

    <dependencies>
        <!--web模块-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- Eureka客户端模块 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!-- 健康检查模块 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!-- tomcat支持 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <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>

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

8.启动类CloudProviderApplication。
在启动类上加入@EnableDiscoveryClient注解，声明该微服务注册到服务注册中心。

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

@EnableDiscoveryClient
@SpringBootApplication
public class CloudProviderApplication {

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

9.使用Tomcat启动，需创建类ServletInitializer。

import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

public class ServletInitializer extends SpringBootServletInitializer {
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(CloudProviderApplication.class);
    }
}

10.创建获取用户信息的接口
10.1 项目结构

10.2 UserController

import com.cloud.provider.entity.User;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    @GetMapping("/{id}")
    public User findById(@PathVariable Long id) {

        User findOne = new User();
        if (id == 1) {
            findOne.setAge(20);
            findOne.setName("zhangsan");
            findOne.setUsername("zhangsan");
            findOne.setId(1L);
            findOne.setBalance(800D);
        } else {
            findOne.setAge(18);
            findOne.setName("lisi");
            findOne.setUsername("lisi");
            findOne.setId(2L);
            findOne.setBalance(2000D);
        }
        return findOne;
    }
}

10.3 User

public class User {
    private Long id;
    private String username;
    private String name;
    private Integer age;
    private Double balance;
    public Long getId() {
        return this.id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getUsername() {
        return this.username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getName() {
        return this.name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return this.age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public Double getBalance() {
        return this.balance;
    }
    public void setBalance(Double balance) {
        this.balance = balance;
    }
}

 

第一讲-引入springcloud

一、引入springcloud

1、什么是springcloud？

spring提供了一系列工具，帮助人员迅速搭建分布式系统中的公共组件，如：
【配置管理】、【服务发现】、【断路器】、【智能路由】、【微代理】、【控制总线】、【一次性令牌】、【全局锁】、【主节点选举】、【分布式session】、【集群状态】
协调分布式环境中各个系统，为各类服务提佛那个模板性配置。
使用Spring Cloud，开发人员可以搭建实现这些样板的应用，并且在任何分布式环境下都能工作得非常好。
Spring Cloud基于springboot，最适合用于管理springboot创建的各个微服务应用。
要管理，必然有个管理注册中心的服务器，eureka是一个高可用组件，它没有后端缓存，每一个实例注册之后就需要向注册中心发送心跳，在默认情况下erueka server也是一个erueka client，必须制定一个server

2、微服务是什么？它有哪些优缺点？

微服务就像一个公司，从最初的小公司到大公司拆分出多个子公司，每个公司都有自己独立的业务，员工，各自发展，互不影响。
单体项目中，臃肿的系统，重复的代码，超长的启动时间带给开发人员的只有无限的埋怨。
使用微服务的优势：
1）服务的独立部署
每个服务都是一个独立的项目，可以独立部署，不依赖于其他服务，耦合性第。
2）服务的快速启动
拆分之后服务启动的速度必然比拆分之前快很多，因为依赖的库少了，代码量也少了。
3）更适合敏捷开发
敏捷开发以用户的需求进化为核心，采用迭代、循序渐进的方法进行。服务拆分可以快速发布新版本，修改哪个服务只需要发布对应的服务即可，不用整体重新发布。
4）职责专一，由专门的团队负责专门的服务
业务发展迅速，每个团队可以负责对应的业务线，服务的拆分有利于团队之间的分工。
5）服务可以动态按需扩容
当某个服务的访问量较大时，我们只需要将这个服务扩容即可。
6）代码的复用
每个服务都提供REST API，所有的基础服务都必须抽出来，很多的底层实现都可以以接口方式提供。
使用微服务的劣势：
1）分布式部署，调用的复杂性高、
单体应用的时候，所有的模块之前的调用都是在本地进行的，在微服务中，每个模块都是独立部署的，通过http来进行通信，这当中会产生网络错误，容错问题，调用关系等。
2）独立的数据库，分布式事务的挑战
每个微服务都有自己的数据库，这就是所谓的去中心化的数据管理。这种模式的优点在于不同的服务，可以选择适合自身业务的数据，比如订单服务的可以用Mysql,评论服务的可以用Mongodb等
3）测试难度提升
服务质检通过接口来交互，当接口改变时，对所有的调用方都是有影响的，需要自动化测试。
4）运维难度的提升

第二章 springcloud简介

常用5大组件
服务发现——Netflix Eureka
客服端负载均衡——Netflix Ribbon
断路器——Netflix Hystrix
服务网关——Netflix Zuul
分布式配置——Spring Cloud Config

1、 微服务应该具备的功能

Spring Cloud Eureka是Spring Cloud Netflix项目下的服务治理模块。
而Spring Cloud Netflix项目是Spring Cloud的子项目之一，主要内容是对Netflix公司一系列开源产品的包装，它为Spring Boot应用提供了自配置的Netflix OSS整合。通过一些简单的注解，开发者就可以快速的在应用中配置一下常用模块并构建庞大的分布式系统。
它主要提供的模块包括：服务发现（Eureka），断路器（Hystrix），智能路由（Zuul），客户端负载均衡（Ribbon）等。

1.1 服务的注册于发现

使用Eureka实现服务治理
服务注册中心：eureka-server，提供服务注册功能
服务提供方：eureka-client，注册服务到服务注册中心
配置：
pom依赖以及配置
启动类注解：@EnableEurekaServer，@EnableEurekaClient
默认情况下改注册中心会将自己作为客户端来尝试注册自己，此处可以禁用
spring.application.name=eureka-server
server.port=1001
eureka.instance.hostname=localhost
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

服务提供方
pring.application.name=eureka-client
server.port=9002
eureka.client.serviceUrl.defaultZone=http://localhost:9001/eureka/

每一个实例注册后要向注册中心发送心跳，注册中心从每个服务提供方接收心跳消息，超市则从注册中心删除。

1.2 服务的负载均衡

Ribbon+RestTemplate实现调用服务

1)、Ribbon：基于Netflix Ribbon实现的一套客户端 负载均衡的工具，消费者可以自动看从Eureka中拿到对应的服务列表，默认进行轮询RoundRobinRule

在获取RestTemplate的方法上加@LoadBalanced实现默认轮询，要更改成其余均衡策略，则在配置类中声明想要的均衡策略
@Configuration
public class RestConfig {
@Bean //通过RestTemplate来实现调用接口
@LoadBalanced //表示RestTemplate开启了负载均衡
public RestTemplate getRestTemplate(){
return new RestTemplate();
}
//重新创建一个均衡策略，表示不使用默认
@Bean
public IRule getIReule(){ //通过获取一个IRule对象，
return new RandomRule(); //达到的目的，用我们重新选择的随机，替代默认的轮训方式
}
}

消费者Controller
//声明一个接口
// private static final String HTTP_NAME = “http://localhost:8001/product/”;
private static final String HTTP_NAME = “http://MICROSERVICE-PRODUCT”;
@Autowired
private RestTemplate restTemplate;
@Resource
private DiscoveryClient client; //我这个微服务想要被别人去发现
@GetMapping("/consum/find/{id}")
public User findone(@PathVariable(“id”)Integer id){
String url = HTTP_NAME+"/product/findone/"+id;
return (User) restTemplate.getForObject(url,User.class);
}
@GetMapping("/consum/findAll")
public List getAll(){
List users = restTemplate.getForObject(HTTP_NAME + “/product/list”, List.class);
return users;
}

2)、Fegin

Feign是一个声明式的Web服务客户端，使得编写Web服务客户端变得非常容易，在api层只需要创建一个接口，然后在上面添加注解即可

3)、两者的区别

实际开发中，对服务依赖的调用可能不止一处，往往一个接口会被多处调用，如果使用Ribbon+RestTemplate，就需要在每一个模块都要创建一个配置类，而且，各社区中javaweb也倾向于面向接口编程
通常针对每个微服务自行封装一些客户端类来包装这些依赖服务的调用，所以，Feign在此基础上做了进一步封装，在Feign的实现下，我们只需要创建一个接口并使用注解的方式来配置它(以前是Dao接口上面标注Mapper注解，现在是一个微服务接口上面标注一个Feign注解即可)，完成对服务提供方的接口绑定
使用Feign是通过接口的方法调用Rest服务，该请求发送给Eureka服务器，通过Feign直接找到服务接口。Feign融合了Ribbon技术，所以也支持负载均衡。
　在使用Feign的时候其实就是远程通过调用标注微服务的对应接口(每一个方法上的路径)，来获取返回值

1.3 服务的容错

Hystrix
在分布式架构中，存在许多的服务单元，一个单元出现故障，容易因依赖关系引发故障的蔓延，所以产生了断路器等服务保护机制；
流程：单元故障——》向调用方返回一个错误响应，释放线程
Spring Cloud Hystrix实现了断路器、线程隔离等一系列服务保护功能；
具备服务降级、服务熔断、线程、信号隔离、请求缓存、请求合并、服务监控等强大功能；
使用：
　在消费者启动类上使用@EnableCircuitBreaker注解开启断路器功能；
　在service或其他的方法上增加@HystrixCommand(fallbackMethod="")注解指定回调方法；

1.4 服务的网关

网关的作用：
为了简化前端的调用逻辑，同时简化内部服务之间调用的复杂度，具体作用就是转发服务，接收并转发所有内部的客户端调用，还拥有权限认证，限流控制等。
api网关，路由，负载均衡等多种作用

Zuul：
使用的是阻塞式的 API，不支持长连接，比如 websockets。
底层是servlet，Zuul处理的是http请求
没有提供异步支持，流控等均由hystrix支持。
依赖包spring-cloud-starter-netflix-zuul。
Gateway：
底层依然是servlet，但使用了webflux，多嵌套了一层框架
依赖spring-boot-starter-webflux和/ spring-cloud-starter-gateway
提供了异步支持，提供了抽象负载均衡，提供了抽象流控，并默认实现了RedisRateLimiter。
相同点：
1、底层都是servlet
2、两者均是web网关，处理的是http请求
不同点：

1、内部实现：

gateway对比zuul多依赖了spring-webflux，在spring的支持下，功能更强大，内部实现了限流、负载均衡等，扩展性也更强，但同时也限制了仅适合于Spring Cloud套件
　　zuul则可以扩展至其他微服务框架中，其内部没有实现限流、负载均衡等。

2、是否支持异步

zuul仅支持同步
　　gateway支持异步。理论上gateway则更适合于提高系统吞吐量（但不一定能有更好的性能），最终性能还需要通过严密的压测来决定

3、框架设计的角度

gateway具有更好的扩展性，并且其已经发布了2.0.0的RELESE版本，稳定性也是非常好的

4、性能

WebFlux 模块的名称是 spring-webflux，名称中的 Flux 来源于 Reactor 中的类 Flux。Spring webflux 有一个全新的非堵塞的函数式 Reactive Web 框架，可以用来构建异步的、非堵塞的、事件驱动的服务，在伸缩性方面表现非常好。使用非阻塞API。 Websockets得到支持，并且由于它与Spring紧密集成，所以将会是一个更好的 开发 体验。
　　Zuul 1.x，是一个基于阻塞io的API Gateway。Zuul已经发布了Zuul 2.x，基于Netty，也是非阻塞的，支持长连接，但Spring Cloud暂时还没有整合计划。
总结
　　总的来说，在微服务架构，如果使用了Spring Cloud生态的基础组件，则Spring Cloud Gateway相比而言更加具备优势，单从流式编程+支持异步上就足以让开发者选择它了。
　　对于小型微服务架构或是复杂架构（不仅包括微服务应用还有其他非Spring Cloud服务节点），zuul也是一个不错的选择。

Zuul是spring cloud中的微服务网关。网关： 是一个网络整体系统中的前置门户入口。请求首先通过网关，进行路径的路由，定位到具体的服务节点上。
　　Zuul是一个微服务网关，首先是一个微服务。也是会在Eureka注册中心中进行服务的注册和发现。也是一个网关，请求应该通过Zuul来进行路由。
　　Zuul网关不是必要的。是推荐使用的。
　　使用Zuul，一般在微服务数量较多（多于10个）的时候推荐使用，对服务的管理有严格要求的时候推荐使用，当微服务权限要求严格的时候推荐使用。

网关有以下几个作用：
统一入口：未全部为服务提供一个唯一的入口，网关起到外部和内部隔离的作用，保障了后台服务的安全性。
鉴权校验：识别每个请求的权限，拒绝不符合要求的请求。
动态路由：动态的将请求路由到不同的后端集群中。
减少客户端与服务端的耦合：服务可以独立发展，通过网关层来做映射。

网关访问方式
　　通过zuul访问服务的，URL地址默认格式为：http://zuulHostIp:port/要访问的服务名称/服务中的URL
　　服务名称：properties配置文件中的spring.application.name。
　　服务的URL：就是对应的服务对外提供的URL路径监听。
网关限流
Zuul网关组件也提供了限流保护。当请求并发达到阀值，自动触发限流保护，返回错误结果。只要提供error错误处理机制即可。
gateWay使用：
入口添加注解@EnableZuulProxy
配置文件指定注册中心地址，服务本身名称，自定义路由映射，统一入口，处理http请求，权限校验(权限校验需要通过实现ZuulFilter进行拦截)

1.5 Config服务配置的统一管理

作用：配置管理
简介：SpringCloud Config提供服务器端和客户端。服务器存储后端的默认实现使用git，因此它轻松支持标签版本的配置环境，以及可以访问用于管理内容的各种工具。
这个还是静态的，得配合Spring Cloud Bus实现动态的配置更新，可以轻松的实现分布式项目配置文件统一管理。

1.6 服务链路追踪

服务追踪组件zipkin，Spring Cloud Sleuth集成了zipkin组件。
简介：
Spring Cloud Sleuth 主要功能就是在分布式系统中提供追踪解决方案，并且兼容支持了 zipkin，你只需要在pom文件中引入相应的依赖即可。
分析：
微服务架构上通过业务来划分服务的，通过REST调用，对外暴露一个接口，可能需要很多个服务协同完成这个接口功能。任何一环失败则接口失败。
术语：
Span：基本工作单玉环

2 springcloud与Dubbo比较

2.1、springcloud

Service Provider： 暴露服务的提供方。
Service Consumer：调用远程服务的服务消费方。
EureKa Server： 服务注册中心和服务发现中心。
从核心要素来看：
Spring Cloud 更胜一筹，在开发过程中只要整合Spring Cloud的子项目就可以顺利的完成各种组件的融合，而Dubbo缺需要通过实现各种Filter来做定制，开发成本以及技术难度略高。
Dubbo只是实现了服务治理，而Spring Cloud子项目分别覆盖了微服务架构下的众多部件，而服务治理只是其中的一个方面。Dubbo提供了各种Filter，对于上述中“无”的要素，可以通过扩展Filter来完善。
例如

1. 分布式配置：可以使用淘宝的diamond、百度的disconf来实现分布式配置管理
2. 服务跟踪：可以使用京东开源的Hydra，或者扩展Filter用Zippin来做服务跟踪
3. 批量任务：可以使用当当开源的Elastic-Job、tbschedule

从协议上看：
Dubbo缺省协议采用单一长连接和NIO异步通讯，适合于小数据量大并发的服务调用，以及服务消费者机器数远大于服务提供者机器数的情况
Spring Cloud 使用HTTP协议的REST API
dubbo支持各种通信协议，而且消费方和服务方使用长链接方式交互，通信速度上略胜Spring Cloud，如果对于系统的响应时间有严格要求，长链接更合适。

从服务依赖方式看：
Dubbo服务依赖略重，需要有完善的版本管理机制，但是程序入侵少。
而Spring Cloud通过Json交互，省略了版本管理的问题，但是具体字段含义需要统一管理，自身Rest API方式交互，为跨平台调用奠定了基础。

从组件运行流程看：

• dubbo：

每个组件都是需要部署在单独的服务器上，gateway用来接受前端请求、聚合服务，并批量调用后台原子服务。每个service层和单独的DB交互。

• springcloud：

所有请求都统一通过 API 网关（Zuul）来访问内部服务。网关接收到请求后，从注册中心（Eureka）获取可用服务。由 Ribbon 进行均衡负载后，分发到后端的具体实例。微服务之间通过 Feign 进行通信处理业务。

业务部署方式相同，都需要前置一个网关来隔绝外部直接调用原子服务的风险。
Dubbo需要自己开发一套API 网关，
而Spring Cloud则可以通过Zuul配置即可完成网关定制。使用方式上Spring Cloud略胜一筹。

springcloud架构说明：

SpringCloud分布式应用微服务系统组件列表：
微服务框架组件：Spring Boot2 + SpringCloud Hoxton.SR8 + SpringCloud Alibaba
Spring Boot Admin: 管理和监控SpringBoot应用程序的微服务健康状态
数据持久化组件：MySql + Druid + MyBatis + MyBatis-Plus
Mycat: 中间件实现数据库读写分离
Seata: 分布式事务管理，跨服务的业务操作保持数据一致性
高性能的key-value缓存数据库：Redis + RedissonClient + RedisTemplate
API接口文档: Swagger2 + knife4j
接口参数校验：spring-boot-starter-validation
Nacos：一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台
Sentinel：把流量作为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性
OpenFeign: 微服务架构下服务之间的调用的解决方案 + Ribbon实现负载均衡/高可用重试机制
Gateway: 微服务路由转发 + 聚合knife4j微服务文档 + 【Gateway+OAuth2+JWT微服务统一认证授权】
Oauth2：SpringSecurity单点登录功能支持多终端认证授权 + RBAC权限框架
验证码：集成滑动验证码【AJ-Captcha】 + 图片验证码【EasyCaptcha】
多租户: 基于Mybatis-Plus【TenantLineInnerInterceptor】插件实现多租户功能
数据权限: 基于Mybatis-Plus【PaginationInnerInterceptor】分页插件实现可配置的数据权限功能
对象存储服务( OSS)：MinIO + 阿里云 + 七牛云 + 腾讯云 + 百度云 + 华为云
工作流：Flowable轻量级业务流程引擎
XXL-JOB：分布式任务调度平台，作业调度系统
Ant-design-vue + ElementUI （基础）优秀流行的前端开源框架整合
uni-app: 可发布到iOS、Android、Web（响应式）、以及各种小程序（微信/支付宝/百度/头条/QQ/钉钉/淘宝）、快应用等多个平台 (本框架中主要用于H5、小程序)
Flutter: 给开发者提供简单、高效的方式来构建和部署跨平台、高性能移动应用 (本框架中主要用于移动应用)
EKL: Elasticsearch + Logstash + Kibana分布式日志监控平台
代码生成器： 基于Mybatis-Plus代码生成插件开发的，便捷可配置的代码生成器
Keepalived + Nginx: 高可用 + 高性能的HTTP和反向代理web服务器
DevOps : kubernetes + docker + jenkins 实现持续集成（CI）和持续交付（CD）
数据报表：基于Ant-design-vue + Echarts实现的自定义数据可视化报表

第三章 搭建一个springcloud项目工程

以下是具备eureka注册中心,client服务提供方,gateway网关统一管理接口，feign调用服务的多模块父子工程的springcloud工程详细搭建过程
结构图：

1、新建springboot父子工程

1）新建父项目cloudparent

建一个springboot父项目

2）建立子module

new Module,
此子项目就是各个服务（eureka,client,gateway…）

2、建立eureka注册中心

1）、新建module模块，取名eureka，添加依赖

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

因为是父子工程，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>
   <groupId>com.myself</groupId>
   <artifactId>eureka</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>eureka</name>
   <description>Demo project for Spring Boot</description>
    <packaging>jar</packaging>
    <parent>
        <groupId>com.myself</groupId>
        <artifactId>cloudparent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <relativePath>../pom.xml</relativePath>
    </parent>
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.3.5.RELEASE</spring-boot.version>
        <spring-cloud.version>Hoxton.SR9</spring-cloud.version>
    </properties>
   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>
   <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>
   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   <repositories>
      <repository>
         <id>spring-milestones</id>
         <name>Spring Milestones</name>
         <url>https://repo.spring.io/milestone</url>
      </repository>
   </repositories>
</project>

${spring-cloud.version}，继承父工程的依赖设置

2）配置application.yml配置文件

server:
  port: 8761
spring:
  application:
    name: eureka
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/,http://localhost:8762/eureka/

注册中心配置，下面两句是设置是否向注册中心注册自己本身。
如果是单个注册中心，就加上此两句配置

register-with-eureka: false #标明是否向注册中心注册自己
fetch-registry: false #不获取服务的注册信息

3）、启动类上添加注解

@EnableEurekaServer

此时注册中心配置完毕
浏览器输入：localhost:8761即可查看注册中心情况

3、服务提供方client

pom.xml，pom其余配置和注册中心相同，这里服务提供方添加client依赖

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

yml配置文件

application.yml
server:
  port: 8081
spring:
  application:
    name: client #\u670D\u52A1\u5668\u540D\u79F0
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/,http://localhost:8762/eureka/

启动类添加注解

@EnableEurekaClient //开启注册中心客户端的注解

此时一个服务提供方就完成了

4、网关gateway

pom.xml，pom其余配置和注册中心相同，这里服务提供方添加client依赖

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

application.yml

spring:
  application:
    name: gateway #\u670D\u52A1\u5668\u540D\u79F0
server:
  port: 9000
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/,http://localhost:8762/eureka/
zuul:
  prefix: /api
  routes:
    userserver: /user/**
    orderserver: /order/**
    goodsserver: /goods/**

启动类添加注解

@EnableEurekaClient // 注册中心客户端
@EnableZuulProxy // 启用网关

5、建立userserver服务提供方和orderserver服务提供方

1）新建两个module,配置依赖和上面client服务提供方相同

pom.xml依赖

<!--客户端-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<!--SQL依赖-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

<!--使用open feign依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

application.yml配置

server:
  port: 9600
spring:
  application:
    name: userserver
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/cms?characterEncoding=utf-8&useSSL=false
    username: root
    password: root
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/,http://localhost:8762/eureka/

启动类上注解：

@EnableEurekaClient
@SpringBootApplication
@EnableFeignClients

6、使用组件Feign实现服务间相互调用

1）、结构：

2）、调用方userserver服务中新建feign服务

OrderServiceFeign用来调用orderserver服务里的方法，注意注解上需要指定被调用服务方的服务名

@FeignClient(value = "orderserver")
public interface OrdersServiceFeign {
    /**
     * @Author chenpengyu
     * @Description 调用订单中的查询订单方法
     * @Date 2021/2/4
     * @Param
     **/
    @GetMapping(value = "/orders/selectList",produces = MediaType.APPLICATION_JSON_VALUE)
    ReturnMsg findList(@RequestParam("userId")Integer userId);
}

3）、被调用方orderserver服务中准备方法

@RestController
@RequestMapping("/orders")
public class OrderController {
    @Resource
    private OrderService orderService;

    @GetMapping(value = "selectList", produces = MediaType.APPLICATION_JSON_VALUE)
    public string findList(Integer userId) {
        ReturnMsg<Object> returnMsg = ReturnMsg.builder().build();
        List<Order> orderList = null;
        orderList = orderService.findAllOrderByUserId(userId);
        returnMsg.setData(orderList);
        return returnMsg;
    }
}

4）userserver中添加controller方法调用feign

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    OrdersServiceFeign ordersServiceFeign;
    @GetMapping("findOrder")
    public Integer findOrderByUserId(){
        ordersServiceFeign.findList(1);
        return 1;
    }
}

7、postman测试，分别测试启动网关和不启动网关测试

测试时：
1、端口号因为添加了网关，所以此处需要添加前缀/api/user，同时端口号统一使用网关的端口号调用服务。
2、通过userserver中controller的方法直接测试

一、需要的环境（硬件、软件）

1.1 硬件版本：IDEA

硬件介绍：在这个教程里面IDEA使用的是IntelliJ IDEA 2019.3 (Ultimate Edition)这个版本，IDEA版本尽量用最新的毕竟越新越好用嘛。IDEA这个工具的功能是很强大的，各种各样的插件应有尽有可以让我们快速搭建我们的程序，并且简单易学的特性可以让新手们快速上手。

看起来界面很简洁挺好看的

1.2 软件版本：SpringCloud 全家桶

软件介绍：开发一个程序出了硬件之外还需要软件，本文中使用的各种软件版本如下：

1. maven版本（也可以使用Gradle）：3.6.3
2. mybatis版本：3.4.6
3. mysql连接jar包版本：5.1.47
4. springboot版本：2.3.1
5. springcloud版本：Hoxton SR6

上面需要注意的是springboot的版本需要可springcloud版本对应上，不然会有不兼容的情况出现，如果需要用Hoxton SR5这个版本的springcloud和springboot进行整合时，可以看springcloud官网的介绍，可以看到Hoxton SR5 对应的版本是2.2.4.RELEASE,而我们的2.3.1就应该用Hoxton SR6这个版本了。

二、搭建微服务程序

什么是微服务程序呢？微服务的微的理解简单的理解就是把传统的单一运行程序拆分成若干个小程序，每个小程序都能自己启动运行并负责自己的特有的功能，甚至有的还有自己的数据库。服务呢就是这些小程序将自己的功能服务提供给外面的调用者调用的意思。
从上面的微服务解释就可以得知，我们需要建造多个工程，下面我们就来看怎么建立这个工程。

2.1 创建父工程

父工程的作用就是统一管理软件版本和插件的工程，没有其他特殊的功能，父工程可以方便做版本控制。下面演示一下怎么创建。

打开IDEA点击新建工程，选择maven,直接Next

根据自己的情况填写信息，点击finish

Maven工程已经建立好了，现在我们要在父工程里面的pom文件定义子工程的标准(软件版本)

打开父工程的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">
    <modelVersion>4.0.0</modelVersion>

    <!-- 定义springboot的版本为2.3.1.RELEASE-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>


    <groupId>org.hjy</groupId>
    <artifactId>springcloudMulti</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--父工程要设置成pom-->
    <packaging>pom</packaging>
    <name>springcloudMulti</name>

    <!--编码设置-->
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    </properties>


    <dependencies>
        <!--lombok插件，用来自动生成getter和setter方法-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
            <scope>provided</scope>
        </dependency>

        <!--引入mybatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>

        <!--mysql 数据库连接jar包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

        <!--test 模块-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

    </dependencies>

    <!--springcloud的版本为 Hoxton.SR6-->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Hoxton.SR6</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!--maven插件，用来打包和运行的插件-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

至此父工程就创建好了。

2.2 子工程创建

Eureka 需要创建服务注册中心和若干服务提供者（调用者）。
什么是服务注册中心和服务提供者（调用者）呢？其实三者的关系可以类比为商场、商家和消费者三者的关系，商场（服务注册中心）提供场地给商家（服务提供商），商家把自己的商品（服务）摆在那里给消费者（服务调用者）购买；商场提供的就是场地和商场地图，让消费者能够更快地找到要买的商品。服务提供者也可以是服务调用者，服务调用者也可以是服务提供者。

2.2.1 服务注册中心（Eureka-Server）创建

右键new ->moudule

选择spring initializr

填写信息

勾选依赖，这里勾选了springcloud discovery里面的eurekaServer依赖

确认信息直接finish

建好eureka-server子工程后的项目目录为

修改eureka-server的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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!--指向父工程-->
    <parent>
        <groupId>org.hjy</groupId>
        <artifactId>springcloudMulti</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <groupId>com.hjy</groupId>
    <artifactId>eureka-server</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <!-- 指定为war包部署-->
    <packaging>war</packaging>
    <name>eureka-server</name>
    <description>Demo project for Spring Boot</description>

    <dependencies>

        <!--spring web依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--springcloud eureka依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>

        <!--外置tomcat运行要这样配置-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>

    </dependencies>


</project>

修改好pom文件后，需要开启服务注册中心开关和配置服务信息，步骤为

1. yml配置文件内容修改
   由于springcloud官网用的是yml(yaml)文件来配置应用信息，所以我我就把application.properties文件改成application.yml，其实作用是相同，自己可以选择。以下是内容

#设置服务端口
server:
  port: 8083

# 应用名称
spring:
  application:
    name: eureka-server


#eureka 信息配置
eureka:
  instance:
    hostname: localhost #eureka服务的地址
  client:
    fetch-registry: false # 是否需要检索服务
    register-with-eureka: false #是否需要向注册中心注册自己
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/ #服务注册中心地址 ，后面的服务提供者和服务调用者填写这个就可以将服务注册进来或者调用

2. 开启eureka-server开关

在springboot启动类上增加@EnableEurekaServer注解标记这个一个服务注册中心

至此服务注册中心子工程就建好了，启动eureka-server服务，在浏览器输入localhost:8083,如下图就证明服务注册中心就建好了。

2.2.1 服务提供者（eureka- enterprise）和服务调用者（eureka-consumer）的创建

经过上面的步骤，商场已经建立好了，现在就等商家和消费者的到来，下面我们来创建服务提供者（eureka- enterprise） 和服务调用者（eureka-consumer）两个子工程。

TODO :暂时不写，先按照该文章熟练的搭建eureka吧。