你要的SpringCloud简略指南来了！（Netflix版本）

一、概述

官网简介地址https://spring.io/cloud

1、基于分布式的微服务架构

2、SpringCloud简介

1.What is SpringCloud

SpringCloud=分布式微服务架构的一站式解决方案，是多种微服务架构落地技术的集合体，俗称微服务全家桶

2.集成的相关项目

SpringCloud已经成为国际微服务开发的主流技术栈，国内开发者社区十分火爆，同时Alibaba已经加入SpringCloud Alibaba

3.京东架构

4.学习的技术栈

5.版本选择

SpringCloud D版本对应SpringBoot1版本，（过时）

SpringCloud H版本对应SpringBoot2版本

Spring Cloud Alibaba

SpringBoot 1.x版本在2020早已过时

6.SpringCloud 版本关系

采用英国伦敦地铁站来命名，并由地铁站名称字母A-Z依次类推的形式来迭代版本

截止目前2020年5月10日为H版本🏍

二、创建一个简单的微服务项目（纯http连接）

1、创建一个父maven项目（可选）

父项目是用来统一管理依赖版本，在父项目中定义各个依赖的版本，子maven项目只需要声明GroupId+artifactId即可，版本会自动的依赖父maven项目

如果子maven项目拥有自己的版本，就以子项目为主

即默认为父maven项目的版本号

1.idea新建maven项目：

删去src，因为我们只需要一个父maven工程，src没有用

这里也可以选择使用SpringInitializer生成，只要，删去src，修改pom结构为父maven结构即可。

1.设置编码（很重要）

在idea的setting中，找到FileEncodings

有四处需要你修改，尽量都改utf8

2.设置文件过滤显示（个性化）

解决idea显示了一堆没用的文件，如*.iml文件等等等等

在FileTypes下修改设置

这里修改了两个，如图，注意一定要书写规范，用分号间隔！

3.编写pom文件，修改父maven项目设置

pom.xml如下

pom的坑：因为使用了阿里云的镜像，似乎存在一些版本缺失的问题，调整一下maven依赖的版本，就能解决，

下面是2020年5月11日能使用的版本

<?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>com.jirath.cloud</groupId>
  <artifactId>springcloud1</artifactId>
  <packaging>pom</packaging>
  <version>1.0-SNAPSHOT</version>

  <modules>
    <module>eureka</module>
    <module>comsumer1</module>
    <module>producer1</module>
    <module>api</module>
  </modules>

  <name>Maven</name>
  <!-- FIXME change it to the project's website -->
  <url>http://maven.apache.org/</url>
  <inceptionYear>2001</inceptionYear>

  <!-- 统一管理jar包版本 -->
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <junit.version>4.12</junit.version>
    <log4j.version>1.2.17</log4j.version>
    <lombok.version>1.16.18</lombok.version>
    <mysql.version>8.0.18</mysql.version>
    <druid.version>1.1.16</druid.version>
    <druid.spring.boot.starter.version>1.1.10</druid.spring.boot.starter.version>
    <spring.boot.version>2.3.0.RELEASE</spring.boot.version>
    <spring.cloud.version>Hoxton.SR4</spring.cloud.version>
    <spring.cloud.alibaba.version>2.1.0.RELEASE</spring.cloud.alibaba.version>
    <mybatis.spring.boot.version>1.3.0</mybatis.spring.boot.version>
    <mybatis-spring-boot-starter.version>2.1.1</mybatis-spring-boot-starter.version>
    <hutool-all.version>5.1.0</hutool-all.version>
  </properties>

  <distributionManagement>
    <site>
      <id>website</id>
      <url>scp://webhost.company.com/www/website</url>
    </site>
  </distributionManagement>

  <!-- 子模块继承之后，提供作用：锁定版本 + 子module不用谢groupId和version -->
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>com.jirath.cloud</groupId>
        <artifactId>api</artifactId>
        <version>1.0-SNAPSHOT</version>
      </dependency>
      <!--spring boot 2.2.2-->
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>${spring.boot.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
      <!--spring cloud Hoxton.SR1-->
      <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-dependencies</artifactId>
        <version>Hoxton.SR4</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
      <!--Spring cloud alibaba 2.1.0.RELEASE-->
      <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-alibaba-dependencies</artifactId>
        <version>2.1.0.RELEASE</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
      <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>${mysql.version}</version>
      </dependency>
      <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>${druid.version}</version>
      </dependency>
      <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>${druid.spring.boot.starter.version}</version>
      </dependency>
      <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>${mybatis-spring-boot-starter.version}</version>
      </dependency>
      <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>${lombok.version}</version>
      </dependency>
    </dependencies>
  </dependencyManagement>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <configuration>
          <fork>true</fork>
          <addResources>true</addResources>
        </configuration>
      </plugin>
    </plugins>
  </build>

  <!--第三方maven私服-->
  <repositories>
    <repository>
      <id>nexus-aliyun</id>
      <name>Nexus aliyun</name>
      <url>http://maven.aliyun.com/nexus/content/groups/public</url>
      <releases>
        <enabled>true</enabled>
      </releases>
      <snapshots>
        <enabled>false</enabled>
      </snapshots>
    </repository>
  </repositories>

​
​

​

2、搭建子maven项目

1、创建数据库

a.SpringInitializer搭建SpringBoot项目

在父maven项目下新建model，选择SpringInitializer，然后修改pom配置，

使用SpringInitializer生成的项目，默认的父项目都是SpringBoot

为了让该模块与父模块关联，需要指定parent，这里与父maven项目的设定相同

<parent>
        <artifactId>springcloud1</artifactId>
        <groupId>com.jirath.cloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>

去除SpringInitializer自动引入依赖的版本

自动生成的pom文件，可能带有依赖版本，建议修改为父pom相同，去掉版本就行。

b.maven项目搭建SpringBoot子项目

1.父maven项目下新建model，选择maven项目，然后修改pom配置

本示例中，parent要保持与父项目相同其余设定是子项目的信息，无要求，配置后不影响项目整体。

示例：

<?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>
        <artifactId>springcloud1</artifactId>
        <groupId>com.jirath.cloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <groupId>com.jirath.cloud</groupId>
    <artifactId>producer1</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>producer1</name>
    <description>Demo project for Spring Boot</description>

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

    <dependencies>
       
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <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>

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

</project>

2、resource目录下新建 application.yml

2、resource目录下新建 application.yml

注意： mysql8的数据库驱动包是 com.mysql.cj.jdbc.Driver

mysql5是 com.mysql.jdbc.Driver

这里一昧的复制是必然报错的，比如mybatis的配置需要根据你项目实际包名确定，数据库等等等等都需要根据实际配置

server:
  port: 8001 #服务端口
  servlet:
    context-path: /

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource  #当前数据源操作类型
    driver-class-name: com.mysql.cj.jdbc.Driver #数据库驱动包
    url: jdbc:mysql://localhost:3306/test?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true
    username: root
    password: root
  application:
    name: producer1
mybatis:
  mapper-locations: classpath:mapper/*Mapper.xml
  type-aliases-package: com.jirath.cloud.entity  #所有entity别名所在包

4、新建启动类Producer1Application

package com.jirath.cloud.producer1;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Producer1Application {

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

}

至此子项目以及配置完成，为了方便学习与演示，将简单构建一下接口

5、dao层开发

新建PaymentDao接口，这里本人没有注解@Component注解，也能运行

相关文章：https://juejin.im/post/5d9c60d46fb9a04ddd42ea37

@Mapper
public interface TestDao {
    @Select("SELECT * FROM test")
    List<Test> getAll();

    void add(Test test);
}

mapper.xml

resource下创建mapper文件夹，新建PaymentMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.jirath.cloud.producer1.dao.TestDao">
    <insert id="add" parameterType="Test">
        INSERT INTO test (id,`name`) VALUES (#{id},#{name})
    </insert>
</mapper>

6、service层

service接口

public interface TestService {
    List<Test> getAll();

    void add(Test test);
}

service实现类

这里因为我没有在mapper接口上注解@Component注解，会爆红，但是能正常运行，强迫症可以自己加一个@Repository注解

@Service
public class TestServiceImpl implements TestService {

    @Autowired
    TestDao testDao;
    @Override
    public List<Test> getAll() {
        return testDao.getAll();
    }

    @Override
    public void add(Test test) {
        testDao.add(test);
    }
}

7、controller层

@RestController
public class MsgController {
    @Autowired
    TestService testService;
    @RequestMapping(value = "/prod",method = RequestMethod.GET)
    public ResultVo<List<Test>> getAll(){
        return new ResultVo<List<Test>>(200, "所有内容", testService.getAll());
    }
    @RequestMapping(value = "/prod",method = RequestMethod.POST)
    public ResultVo<String> add(Test test){
        testService.add(test);
        return new ResultVo(200, "增加内容","success");
    }
}

8、测试

1、get测试：浏览器输入：http://localhost:8001/prod/

2、post测试：

c.模仿前一步炮制一个调用接口的项目

该项目为了区分，项目端口放在了80

使用RestTemplate进行服务调用

1、RestTemplate

RestTemplate提供了多种便捷访问远程Http服务的方法，

是一种简单便捷的访问restful服务的模板类，是spring提供的用于访问Rest服务的客户端模板工具集。

配置类

@Configuration
public class ApplicationContextConfig {

    @Bean
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }
}

6、controller层用RestTemplate调用就行。

这里需要用到Test与ResultVo两个类，我们选择直接复制过来这个项目即可

@RestController
public class MsgController {
    private final static String BASIC_URL="http://localhost:8001";
    @Autowired
    private RestTemplate restTemplate;
    @RequestMapping(value = "/prod",method = RequestMethod.GET)
    public ResultVo getAll(){
        return new ResultVo(200, "所有内容", restTemplate.getForEntity(BASIC_URL+"prod",ResultVo.class));
    }
    @RequestMapping(value = "/prod",method = RequestMethod.POST)
    public ResultVo<String> add(Test test){
        restTemplate.postForEntity(BASIC_URL+"prod",test,ResultVo.class);
        return new ResultVo(200, "增加内容","success");
    }
}

7、rundashbroad

运用spring cloud框架基于spring boot构建微服务，一般需要启动多个应用程序，在idea开发工具中，多个同时启动的应用

需要在RunDashboard运行仪表盘中可以更好的管理，但有时候idea中的RunDashboard窗口没有显示出来，也找不到直接的开启按钮

idea中打开Run Dashboard的方法如下

view > Tool Windows > Run Dashboard

如果上述列表找不到Run Dashboard,则可以在工程目录下找到.idea文件夹下的workspace.xml，在其中相应位置加入以下代码（替换）即可：

<component name="RunDashboard">
<option name="configurationTypes">
  <set>
    <option value="SpringBootApplicationConfigurationType"/>
  </set>
</option>
<option name="ruleStates">
  <list>
    <RuleState>
      <option name="name" value="ConfigurationTypeDashboardGroupingRule"/>
    </RuleState>
    <RuleState>
      <option name="name" value="StatusDashboardGroupingRule"/>
    </RuleState>
  </list>
</option>
</component>

关闭重启后出现。

现在我们已经做到了一个基础的互相依赖的两个项目，我们现在对这个项目进行第一次升级

3、工程重构

我们需要遵循设计模式，将共用的部分提取出来，使系统更灵活

在本项目中，entity包明显是共用的，我们着手提取出这个包为独立的项目依赖

1、新建模块 api

依赖：

这里我没有写依赖，因为lombok的一些特性，并不是很提倡使用，使用idea的一键get\set也很轻松，模块的依赖自然是需要用到一些工具，按需添加即可

注：请确认与父pom的依赖设置正确

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud1</artifactId>
        <groupId>com.jirath.cloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>api</artifactId>


</project>

2、将消费者和服者种的entities拷贝至新模块中，

删除原来的entities包

选择api模块，clean、install cloud-api-commons 模块，

使用install命令可以将模块安装在依赖中，其他模块就能使用本模块了

在消费则服务者pom.xml中分别引入依赖，测试运行。

这里的artificialid就是api模块中配置的名称

<dependency>
            <groupId>com.jirath.cloud</groupId>
            <artifactId>api</artifactId>
            <version>1.0-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>

如果不能流畅成功，细心找找错误，clean所有的模块，然后从api模块开始安装，因为api被所有模块依赖

测试运行，成功

三、Eureka服务注册中心

文档wikihttps://github.com/Netflix/eureka/wiki

1、简介

简要介绍

分布式的服务注册中心，各个服务在这里注册，Eureka会检测服务的心跳

Eureka是基于REST的服务，主要在AWS云中用于定位服务，以实现负载均衡和中间层服务器的故障转移。 我们称此服务为Eureka服务器。 Eureka还带有一个基于Java的客户端组件Eureka Client，它使与服务的交互变得更加容易。 客户端还具有一个内置的负载平衡器，可以执行基本的循环负载平衡。 在Netflix，更复杂的负载均衡器将Eureka包装起来，以基于流量，资源使用，错误条件等多种因素提供加权负载均衡，以提供出色的弹性。

Eureka的架构位置，

注意这里有多台Eureka服务器，这样做的原因是防止因为Eureka故障导致整体结构崩溃

2、Eureka服务端安装

a.创建Eureka服务端服务注册中心

Eureka的服务注册中心是一个依托SpringBoot的web服务，搭建起来很轻松。

个人比较懒，使用了Initializer来快速搭建

SpringBoot的web模块

另外加上一个Spring Boot Actuator

只有Eureka服务端模块就能满足我们的使用了，这两个是可不选的

最后选择服务发现里面的Eureka服务端（必选）

Actuator是什么

Spring Boot Actuator提供了生产上经常用到的功能（如健康检查，审计，指标收集，HTTP跟踪等），帮助我们监控和管理Spring Boot应用程序。这些功能都可以通过JMX或HTTP端点访问。

通过引入相关的依赖，即可监控我们的应用程序，收集指标、了解流量或数据库的状态变得很简单。该库的主要好处是我们可以获得生产级工具，而无需自己实际实现这些功能。与大多数Spring模块一样，我们可以通过多种方式轻松配置或扩展它。

Actuator还可以与外部应用监控系统集成，如Prometheus，Graphite，DataDog，Influx，Wavefront，New Relic等等。 这些系统为您提供出色的仪表板，图形，分析和警报，以帮助我们在一个统一界面监控和管理应用服务。

b.服务注册和发现中心的配置

pom.xml文件需要修改父项目（切记，使用initializer生成的子项目都需要修改！）

yml配置文件如下，

注意这里只需要简单的Eureka服务配置即可

排错：

若url字段无数值，需要配置数据源：删去数据源的依赖，这里一开始我父项目填为了依赖数据源的项目，导致Eureka也得配置数据源，把这个改回来就不用了。

设置了中心不注册自己

设置了服务的位置

server:
  port: 7000

eureka:
  instance:
    hostname: localhost #Eruka服务端的实例名称
  client:
    #不注册自己
    register-with-eureka: false
    #false表示自己就是注册中心，职责是维护服务，不需要检索服务
    fetch-registry: false
    service-url:
      defaultZone: Http://${
   eureka.instance.hostname}:${
   server.port}/eruka/

附：使用maven引入依赖：

注意是SpringCloud的新版本依赖，相对旧版本的不太一样，不要用错了，结尾要是Server

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

d.使用注解开启Eureka服务端服务

@EnableEurekaServer
@SpringBootApplication
public class EurekaApplication {
   

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

}

e.运行项目，测试成功

为了区分，建议划一块端口给服务中心集群专用，避免混淆

3、将其他模块配置为Client模块

在之前的项目中，添加Eureka-Client的依赖

注意这里使用的是新版本的Eureka依赖！！，版本不同会导致无法成功注册

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

添加配置：(在原有基础上添加Eureka的配置)

这里需要设置为client模式，即注册本服务，扫描其他服务

配置本服务的名称，为spring.application.name:

另外需要配置service-url：Server的服务地址

这里要注意url，很容易写错

spring:
  application:
    name: producer1
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/
    #服务。需要开启入驻与搜索
    register-with-eureka: true
    fetch-registry: true

使用注解开启服务

@SpringBootApplication
@EnableEurekaClient
public class Producer1Application {
   

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

}

测试，打开Eureka服务的地址，检查有没有加入新服务

暂时忽略红色警告

4、Eureka集群

a.Eureka集群原理

Eureka 集群的工作原理。我们假设有三台 Eureka Server 组成的集群，第一台 Eureka Server 在北京机房，另外两台 Eureka Server 在深圳和西安机房。这样三台 Eureka Server 就组建成了一个跨区域的高可用集群，只要三个地方的任意一个机房不出现问题，都不会影响整个架构的稳定性。

Eureka Server注册中心集群中每个节点都是平等的，集群中的所有节点同时对外提供服务的发现和注册等功能。同时集群中每个Eureka Server节点又是一个微服务，也就是说，每个节点都可以在集群中的其他节点上注册当前服务。又因为每个节点都是注册中心，所以节点之间又可以相互注册当前节点中已注册的服务，并发现其他节点中已注册的服务。

集群中的每个节点互相注册，互相守望，对外暴露为一个整体

b.集群配置

关键：互相守望

我们将多台服务互相守望，配置在defaultZone中，多个地址用逗号隔开就行

注意：本地运行需要配置一下host，否则Eureka无法识别是集群配置

server:
  port: 7002

eureka:
  instance:
    hostname: eureka.server2.com
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
      defaultZone: http://eureka.server1.com:7001/eureka/

server:
  port: 7001

eureka:
  instance:
    hostname: eureka.server1.com
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
      defaultZone: http://eureka.server2.com:7002/eureka/

要点：hostname表示本机位置，defaultZone表示关注的服务地址

eureka.server2.com，eureka.server1.com 都是指向本机127.0.0.1（localhost）的host映射，可以自己选名的

请注意两个文件中的细微差别