[Java知识库]SpringCloud精讲课件（内附源码）

SpirngCloud精讲课件

中文网：https://www.springcloud.cc/

1. Rest微服务构建案例工程模块

1.总体介绍

• 承接着我们的springmvc+ mybatis+ mysql初级高级课程，以Dept部门模块做一个微服务通用案例Consumer消费者(Client),通过REST调用Provider提供者(Server）提供的服务

• MicroServiceCloud父工程(Project)下初次带着3个子模块(Module)

  • microservicecloud-api：封装的整体entity/接口/公共配置等
    microservicecloud-provider-dept-8001：微服务落地的服务提供者
    microservicecloud-consumer-dept-80：微服务调用的客户端使用

2.本次SpringCloud的版本

3.构建步骤（SpringBoot项目未用到SpringCloud）

1. microservicecloud整体父工程Project

作用：主要是定义POM文件，将后续各个子模块公用的jar包等统一提出来，类似一个抽象父类

• 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>
    <groupId>org.example</groupId>
<artifactId>microservicecloud</artifactId>
<version>1.0</version>
<modules>
    <module>microservicecloud-api</module>
    <module>microservicecloud-provider-dept-8001</module>
    <module>microservicecloud-consumer-dept-80</module>
</modules>
<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>
</properties>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Dalston.SR1</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>1.5.9.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.0.4</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.31</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.0</version>
        </dependency>
        <!--日志-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>1.2.3</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
    </dependencies>
</dependencyManagement>
</project>

2. microservicecloud-api公共子模块Module（继承父模块：microservicecloud）

• 架构图
• 

• 步骤
  

• 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>microservicecloud</artifactId>
  <groupId>org.example</groupId>
  <version>1.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
    <artifactId>microservicecloud-api</artifactId>

<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
</dependencies>
</project>

• 实体类（Dept）

package com.mk.demo.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import java.io.Serializable;

@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)//开启链式访问
//实体类-序列化接口
public class Dept implements Serializable {// Dept(Entity) orm mysql->Dept(table) 类表关系映射
  private Long deptno;//主键
  private String dname;//部门名称
  private String db_source;//来自那个数据库，因为微服务架构可以一个服务对应一个数据库，同一个信息被存储到不懂数据库

  public static void main(String[] args) {
      Dept dept = new Dept();
      dept.setDeptno(11l).setDname("zhan").setDb_source("adkfl");//链式写法
  }
}

3. microservicecloud-provider-dept-8001部门微服务提供者Module

• 架构图
  

• 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>microservicecloud</artifactId>
  <groupId>org.example</groupId>
  <version>1.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
    <artifactId>microservicecloud-provider-dept-8001</artifactId>
<!-- 引入自己定义的api通用包，可以使用Dept部门Entity-->
<dependencies>
    <dependency>
        <artifactId>microservicecloud-api</artifactId>
        <groupId>org.example</groupId>
        <version>${project.version}</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
    </dependency>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jetty</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
    <!--日志-->
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-core</artifactId>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
    </dependency>
    <!--修改后立即生效，热部署-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>springloaded</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
    </dependency>
</dependencies>
</project>

• 配置文件（application.yml）

server:
port: 8001 # 端口号
mybatis:
config-location: classpath:mybatis/mybatis.cfg.xml # mybatis配置文件所在路径
type-aliases-package: com.mk.demo.entity           # 所有Entity别名类所在的包
mapper-locations:
    - classpath:mybatis/mapper/**/*.xml              # mapper映射文件
spring:
application:
name: microservicecloud-dept
datasource:
type: com.alibaba.druid.pool.DruidDataSource     # 当前数据源操作类型
driver-class-name: org.gjt.mm.mysql.Driver       # mysql驱动包
url: jdbc:mysql://localhost:3306/aa_mk_001       # 数据库名称
username: root
password: 123456
dbcp2:
min-idle: 5                                    # 数据库连接池的最小维持连接数
initial-size: 5                                # 初始化连接数
max-total: 5                                   # 最大连接数
max-wait-millis: 200                           # 等待连接获取的最大超时时间

• 编写接口（DeptDao）

package com.mk.demo.dao;
import com.mk.demo.entity.Dept;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;

@Mapper
public interface DeptDao {

  public boolean addDept(Dept dept);

  public Dept findById(Long id);

  public List<Dept> findAll();

}

• 编写映射文件（DeptMapper）

<?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.mk.demo.dao.DeptDao">
  <!--public Dept findById(Long id);-->
    <select id="findById" resultType="dept" parameterType="Long">
        select deptno , dname , db_source from dept where deptno = #{id};
    </select>
  <!--public List<Dept> findAll();-->
   <select id="findAll" resultType="dept">
       select deptno , dname , db_source from dept
   </select>
  <!--public boolean addDept(Dept dept);-->
  <insert id="addDept" parameterType="dept">
      insert into dept(dname,db_source) values (#{dname},DATABASE());
  </insert>
</mapper>

• 编写service接口（DeptService）

package com.mk.demo.service;
import com.mk.demo.entity.Dept;
import java.util.List;

public interface DeptService {

  public boolean add(Dept dept);

  public Dept get(Long id);

  public List<Dept> list();
}

• 编写serviceimpl实现类（DeptServiceImpl）

package com.mk.demo.service.impl;
import com.mk.demo.dao.DeptDao;
import com.mk.demo.entity.Dept;
import com.mk.demo.service.DeptService;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.List;
@Service
public class DeptServiceImpl implements DeptService {
@Resource
private DeptDao deptDao;
@Override
public boolean add(Dept dept) {
  return deptDao.addDept(dept);
}

@Override
public Dept get(Long id) {
  return deptDao.findById(id);
}

@Override
public List<Dept> list() {
  return deptDao.findAll();
}
}

• 编写控制层（DeptController）

package com.mk.demo.controller;
import com.mk.demo.entity.Dept;
import com.mk.demo.service.DeptService;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.List;

@RestController
public class DeptController {
  @Resource
  private DeptService deptService;

  @RequestMapping(value = "/dept/add" , method = RequestMethod.POST)
  public boolean add(@RequestBody Dept dept){
      return deptService.add(dept);
  }

  @RequestMapping(value = "/dept/get/{id}" , method = RequestMethod.GET)
  public Dept add(@PathVariable("id") Long id){
      return deptService.get(id);
  }

  @RequestMapping(value = "/dept/list")
  public List<Dept> list(){
      return deptService.list();
  }
}

• 启动类（DeptProvider8001_App）

package com.mk.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class DeptProvider8001_App {
  public static void main(String[] args) {
      SpringApplication.run(DeptProvider8001_App.class,args);
  }
}

• 启动项目
• 访问（ localhost:8001/dept/list ）
  

4. microservicecloud-consumer-dept-80部门微服务消费者Module

• 架构图
  

• 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>microservicecloud</artifactId>
 <groupId>org.example</groupId>
 <version>1.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
    <artifactId>microservicecloud-consumer-dept-80</artifactId>

<dependencies>
 <dependency>
     <artifactId>microservicecloud-api</artifactId>
     <groupId>org.example</groupId>
     <version>${project.version}</version>
 </dependency>
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
 <!--修改后立即生效，热部署-->
 <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>springloaded</artifactId>
 </dependency>
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-devtools</artifactId>
 </dependency>
</dependencies>
</project>

• 配置文件（application.yml）

server:
port: 80 # 端口号

• 编写配置类（ConfigBean配置RestTemplate）

package com.mk.demo.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
@Configuration
public class ConfigBean {
 @Bean
public RestTemplate restTemplate(){
     return new RestTemplate();
 }
}

RestTemplate提供了多种便捷访问远程Http服务的方法，是一种简单便捷的访问restful服务模板类，是Spring提供的用于访问Rest服务的客户端模板工具集

使用restTemplate访问restful接口非常的简单粗暴无脑。

(url, requestMap, ResponseBean.class)这三个参数分别代表

REST请求地址、请求参数、HTTP响应转换被转换成的对象类型。

• 编写控制器（DeptController_Consumer）

package com.mk.demo.controller;
import com.mk.demo.entity.Dept;
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;
import org.springframework.web.client.RestTemplate;
import java.util.List;

@RestController
public class DeptController_Consumer {

private static final String REST_URL_PREFIX="http://localhost:8001";

@Autowired
private RestTemplate restTemplate;

/*使用
使用restTemplate访问restful接口非常的简单粗暴无脑。
(url, requestMap, ResponseBean.class)这三个参数分别代表
REST请求地址、请求参数、HTTP响应转换被转换成的对象类型。
*/

@RequestMapping("/consumer/dept/add")
public boolean add(Dept dept){
   return restTemplate.postForObject(REST_URL_PREFIX+"/dept/add",dept,boolean.class);
}
@RequestMapping("/consumer/dept/get/{id}")
public Dept get(@PathVariable("id") Long id){
   return restTemplate.getForObject(REST_URL_PREFIX+"/dept/get/"+id,Dept.class);
}
@RequestMapping("/consumer/dept/list")
public List<Dept> list(){
   return restTemplate.getForObject(REST_URL_PREFIX+"/dept/list",List.class);
}

}

• 编写启动类（DeptConsumer80_App）

package com.mk.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

• 启动
• 访问（ localhost/consumer/dept/list ）
  

2. Eureka服务注册与发现

1. 介绍

• Eureka 是 Netflix 出品的用于实现服务注册和发现的工具。 Spring Cloud 集成了 Eureka，并提供了开 箱即用的支持。其中， Eureka 又可细分为 Eureka Server 和 Eureka Client。
• 1. Eureka Server提供服务注册服务各个节点启动后，会在EurekaServer中进行注册，这EurekaServer中的服务注册表中将会存储所有可用服务节点的信息，服务节点的信息可以在界面中直观的看到
  2. EurekaClient是一个Java客户端，用于简化Eureka Server的交互，客户端同时也具备一个内置的、使用轮询(round-robin)负载算法的负载均衡器。在应用启动后，将会向Eureka Server发送心跳(默认周期为30秒)。如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳，EurekaServer将会从服务注册表中把这个服务节点移除（默认90秒)

2. 代码构建

1. microservicecloud-eureka-7001eureka服务注册中心Module（父模块：microservicecloud）

• 架构图
  

• pom文件（加入eureka-service服务端依赖）

<?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>microservicecloud</artifactId>
  <groupId>org.example</groupId>
  <version>1.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
    <artifactId>microservicecloud-eureka-7001</artifactId>
    <dependencies>
    <!--eureka-server服务端-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka-server</artifactId>
    </dependency>
    <!--修改后立即生效，热部署-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>springloaded</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
    </dependency>
</dependencies>
</project>

• 编写配置文件（application.yml）

server:
port: 7001 # 端口号
eureka:
instance:
hostname: localhost #eureka服务端的实例名称
client:
register-with-eureka: false #false表示不向注册中心注册自己
fetch-registry: false # false表示自己端就是注册中心，我的职责就是维护服务实例，并不需要检索服务
service-url:
defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/ # 设置与Eureka Server交互的地址查询服务和注册服务都依赖这个地址

• 编写启动类（EurekaServer7001_App）

package com.mk.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer//EurekaServer服务器端启动类,接受其它微服务注册进来
public class EurekaServer7001_App {
public static void main(String[] args) {
    SpringApplication.run(EurekaServer7001_App.class,args);
}
}

注意：@EnableEurekaServer注解（启动eureka服务端）

• 启动

• 访问（ Eureka ）

• 结果

  

2. 修改microservicecloud-provider-dept-8001将已有的部门微服务注册进eureka服务中心

• 架构图

• 在pom文件中添加依赖

<!--将微服务provider端注册进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>

• 修改yml文件

server:
  port: 8001 # 端口号
mybatis:
   config-location: classpath:mybatis/mybatis.cfg.xml # mybatis配置文件所在路径
   type-aliases-package: com.mk.demo.entity           # 所有Entity别名类所在的包
   mapper-locations:
       - classpath:mybatis/mapper/**/*.xml              # mapper映射文件
spring:
  application:
    name: microservicecloud-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource     # 当前数据源操作类型
    driver-class-name: org.gjt.mm.mysql.Driver       # mysql驱动包
    url: jdbc:mysql://localhost:3306/aa_mk_001       # 数据库名称
    username: root
    password: 123456
    dbcp2:
      min-idle: 5                                    # 数据库连接池的最小维持连接数
      initial-size: 5                                # 初始化连接数
      max-total: 5                                   # 最大连接数
      max-wait-millis: 200                           # 等待连接获取的最大超时时间
#-----------------------添加部分---------------------
eureka:
client: #客户端注册进eureka服务列表内
 service-url:
   defaultZone: http://localhost:7001/eureka

• 修改启动类（添加注解：@EnableEurekaClient）

package com.mk.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient//本服务启动后会自动注册进eureka服务中-----------添加部分------------
public class DeptProvider8001_App {
public static void main(String[] args) {
    SpringApplication.run(DeptProvider8001_App.class,args);
}
}

• 启动
• 访问（http://localhost:7001）
• 结果
  

3. 主机名称：服务名称修改

• 修改服务提供者的yml文件（完整如下）

server:
  port: 8001 # 端口号
mybatis:
  config-location: classpath:mybatis/mybatis.cfg.xml # mybatis配置文件所在路径
  type-aliases-package: com.mk.demo.entity           # 所有Entity别名类所在的包
  mapper-locations:
    - classpath:mybatis/mapper/**/*.xml              # mapper映射文件
spring:
  application:
    name: microservicecloud-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource     # 当前数据源操作类型
    driver-class-name: org.gjt.mm.mysql.Driver       # mysql驱动包
    url: jdbc:mysql://localhost:3306/aa_mk_001       # 数据库名称
    username: root
    password: 123456
    dbcp2:
      min-idle: 5                                    # 数据库连接池的最小维持连接数
      initial-size: 5                                # 初始化连接数
      max-total: 5                                   # 最大连接数
      max-wait-millis: 200                           # 等待连接获取的最大超时时间

eureka:
  client:  #客户端注册进eureka服务列表内
     service-url:
       defaultZone: http://localhost:7001/eureka
  instance:
    instance-id: microservicecloud-dept8001 # 自定义服务名称信息-----------添加部分---------
    prefer-ip-address: true # 访问路径可以显示IP地址

• 结果
  

4. 显示IP信息

• 修改服务提供者的yml文件（完整如下）

server:
  port: 8001 # 端口号
mybatis:
  config-location: classpath:mybatis/mybatis.cfg.xml # mybatis配置文件所在路径
  type-aliases-package: com.mk.demo.entity           # 所有Entity别名类所在的包
  mapper-locations:
    - classpath:mybatis/mapper/**/*.xml              # mapper映射文件
spring:
  application:
    name: microservicecloud-dept
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource     # 当前数据源操作类型
    driver-class-name: org.gjt.mm.mysql.Driver       # mysql驱动包
    url: jdbc:mysql://localhost:3306/aa_mk_001       # 数据库名称
    username: root
    password: 123456
    dbcp2:
      min-idle: 5                                    # 数据库连接池的最小维持连接数
      initial-size: 5                                # 初始化连接数
      max-total: 5                                   # 最大连接数
      max-wait-millis: 200                           # 等待连接获取的最大超时时间

eureka:
  client:  #客户端注册进eureka服务列表内
     service-url:
       defaultZone: http://localhost:7001/eureka
  instance:
    instance-id: microservicecloud-dept8001 # 自定义服务名称信息
    prefer-ip-address: true # 访问路径可以显示IP地址-----------添加部分---------

• 结果
  

5. actuator与注册微服务信息完善

• 在microservicecloud-provider-dept-8001中加入依赖

<!--actuator监控信息完善-->
  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-actuator</artifactId>
  </dependency>

• 在父工程microservicecloud中加入

<build>
  <finalName>microservicecloud</finalName>
  <resources>
      <resource>
          <directory>src/main/resources</directory>
          <filtering>true</filtering>
      </resource>
  </resources>
  <plugins>
      <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-resources-plugin</artifactId>
          <configuration>
              <delimiters>
                  <delimit>$</delimit>
              </delimiters>
          </configuration>
      </plugin>
  </plugins>
</build>

• 在microservicecloud-provider-dept-8001工程配置文件中加入

info:
app.name: atguigu-microservicecloud
company.name: www.atguigu.com
build.artifactId: $project.artifactId$
build.version: $project.version$

3. 集群配置

• 步骤
  

• 修改microservicecloud-provider-dept-8001配置文件为
  

• 访问（ http://eureka7001.com:7001/ ，http://eureka7002.com:7002/，http://eureka7002.com:7002/）
  

4. 作为服务注册中心，Eureka比zookeeper好在哪里

• 作为服务注册中心，Eureka比Zookeeper好在哪里,著名的CAP理论指出，一个分布式系统不可能同时满足C(一致性)、A(可用性)和P(分区容错性)。由于分区容错性P在是分布式系统中必须要保证的，因此我们只能在A和C之间进行权衡。
• Zookeeper保证的是CP。
• Eureka则是AP。

3. Ribbon负载均衡

1. 概述

• Spring Cloud Ribbon是基于Netflix Ribbon实现的—套客户端负载均衡的工具。
• 简单的说，Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法，将Netflix的中间层服务连接在一起。Ribbon客户端组件提供一系列完善的配置项如连接超时，重试等。简单的说，就是在配置文件中列出Load Balancer(简称LB)后面所有的机器，Ribbon会自动的帮助你基于某种规则(如简单轮询，随机连接等）去连接这些机器。我们也很容易使用Ribbon实现自定义的负载均衡算法。
• LB，即负载均衡(Load Balance)，在微服务或分布式集群中经常用的一种应用负载均衡简单的说就是将用户的请求平摊的分配到多个服务上，从而达到系统的HAT常见的负载均衡有软件Nginx，LVS，硬件F等。
  相应的在中间件，例如: dubbo和SpringCloud中均给我们提供了负载均衡，SpringCloud的负载均衡算法可以自定义。

2. Ribbon配置初步

1. 步骤图

2. 修改pom.xml文件（添加ribbon依赖）

 <!--Ribbon相关-->
        <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>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-ribbon</artifactId>
        </dependency>

3. 修改application.yml追加eureka的服务注册地址

# 追加部分--------------------------------------------------------------------------
eureka:
  client:  #客户端注册进eureka服务列表内
    register-with-eureka: false #false表示不向注册中心注册自己
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

# 完整版----------------------------------------------------------------------------
server:
  port: 80 # 端口号

eureka:
  client:  #客户端注册进eureka服务列表内
    register-with-eureka: false #false表示不向注册中心注册自己
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

4. 对ConfigBean进行新注解@LoadBalanced获得Rest时加入Ribbon的配置

package com.mk.demo.config;

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 ConfigBean {
      @Bean
      @LoadBalanced //添加部分----------------------------------------------------------
    public RestTemplate restTemplate(){
          return new RestTemplate();
      }
}

5. 主启动类DeptConsumer80_App添加@EnableEurekaClient

package com.mk.demo;

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

@SpringBootApplication
@EnableEurekaClient//添加部分----------------------------------------------------------
public class DeptConsumer80_App {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer80_App.class,args);
    }
}

6. 修改DeptController_Consumer客户端访问类

package com.mk.demo.controller;

import com.mk.demo.entity.Dept;
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;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
public class DeptController_Consumer {

    //private static final String REST_URL_PREFIX="http://localhost:8001";
    private static final String REST_URL_PREFIX="http://MICROSERVICECLOUD-DEPT";
    //更改部分-------------------------------------------------------------------------
    @Autowired
    private RestTemplate restTemplate;

   /*使用
    使用restTemplate访问restful接口非常的简单粗暴无脑。
    (url, requestMap, ResponseBean.class)这三个参数分别代表
    REST请求地址、请求参数、HTTP响应转换被转换成的对象类型。
    */

    @RequestMapping("/consumer/dept/add")
    public boolean add(Dept dept){
        return restTemplate.postForObject(REST_URL_PREFIX+"/dept/add",dept,boolean.class);
    }
    @RequestMapping("/consumer/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id){
        return restTemplate.getForObject(REST_URL_PREFIX+"/dept/get/"+id,Dept.class);
    }
    @RequestMapping("/consumer/dept/list")
    public List<Dept> list(){
        return restTemplate.getForObject(REST_URL_PREFIX+"/dept/list",List.class);
    }

}

• 先启动3个eureka集群后，再启动microservicecloud-provider-dept-8001并注册进eureka
• 启动microservicecloud-consumer-dept-80
• 测试
• 访问（http://localhost:80/consumer/dept/list）
• 结果
  

• 小结：Ribbon和Eureka整合后Consumer可以直接调用服务而不用再关心地址和端口号
  个

3. Ribbon负载均衡

• 步骤
  

• 参考microservicecloud-provider-dept-8001，新建两份，分别命名为8002，8003（更改端口号，pom文件，启动类名称等等）

• 新建8002/8003数据库，各自微服务分别连各自的数据库

/*
Navicat MySQL Data Transfer

Source Server         : mysql
Source Server Version : 50709
Source Host           : localhost:3306
Source Database       : aa_mk_001 -----------aa_mk_002----------------aa_mk_003-------------------------

Target Server Type    : MYSQL
Target Server Version : 50709
File Encoding         : 65001

Date: 2022-10-09 11:02:08
*/

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for dept
-- ----------------------------
DROP TABLE IF EXISTS `dept`;
CREATE TABLE `dept` (
  `deptno` bigint(20) NOT NULL AUTO_INCREMENT,
  `dname` varchar(60) DEFAULT NULL,
  `db_source` varchar(60) DEFAULT NULL,
  PRIMARY KEY (`deptno`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of dept
-- ----------------------------
INSERT INTO `dept` VALUES ('1', '开发部', 'aa_mk_001');
INSERT INTO `dept` VALUES ('2', '人事部', 'aa_mk_001');
INSERT INTO `dept` VALUES ('3', '财务部', 'aa_mk_001');
INSERT INTO `dept` VALUES ('4', '市场部', 'aa_mk_001');
INSERT INTO `dept` VALUES ('5', '运维部', 'aa_mk_001');
INSERT INTO `dept` VALUES ('6', '狗', 'aa_mk_001');
INSERT INTO `dept` VALUES ('7', 'dkfjaifa', 'aa_mk_001');

• 修改8002/8003各自YML
• 启动3个eureka集群配置区

• 启动3个Dept微服务并各自测试通过
• http://localhost:8001/dept/list
• http://localhost:8002/dept/list
• http://localhost:8003/dept/list

• 启动microservicecloud-consumer-dept-80
• localhost/consumer/dept/list

• 客户端通过Ribbo完成负载均衡并访问上一步的Dept微服务

• 总结:Ribbon其实就是一个软负载均衡的客户端组件

• Ribbon是结合REST一块使用的

4. Ribbon核心组件IRule

• lRule:根据特定算法中从服务列表中选取一个要访问的服务
  

5. Ribbon自定义

• 官方文档明确给出了警告:
  这个自定义配置类不能放在@ComponentScan所扫描的当前包下以及子包下,否则我们自定义的这个配置类就会被所有的Ribbon客户端所共享，也就是说我们达不到特殊化定制的目的了。

• 在客户端的启动类上加注解（@RibbonClient(name = “MICROSERVICECLOUD-DEPT”,configuration = MySelfRule.class)）

package com.mk.demo;

import com.mk.my.MySelfRule;
import com.mk.my.MySelfRule;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.ribbon.RibbonClient;

@SpringBootApplication
@EnableEurekaClient
//在启动该微服务的时候就能去加载我们的自定义Ribbon配置类，从而使配置生效，形如:
@RibbonClient(name = "MICROSERVICECLOUD-DEPT",configuration = MySelfRule.class)
//----------------------------------自定义类MySelfRule---------------------------------------------
public class DeptConsumer80_App {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer80_App.class,args);
    }
}

• 新建自定义配置类（MySelfRule）（自定义配置类不能放在@ComponentScan所扫描的当前包下以及子包下）

package com.mk.my;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MySelfRule {
    @Bean
    public IRule myRule(){
        return new RandomRule();//Ribbon默认是轮询，我自定义为随机

    }
}

• 结构图
  

4. Feign负载均衡

1. 介绍

Feign是一个声明式WebService客户端。使用Feign能让编写Web Service客户端更加简单,它的使用方法是定义一个接口，然后在上面添加注解，同时也支持JAX-RS标准的注解。Feign也支持可拔插式的编码器和解码器。Spring Cloud刘Feign进行了封装,使其支持了Spring MVC标准注解和HttpMessageConverters。Feign可以与Eureka和Ribbon组合使用以支持负载均衡。

2. 步骤

3. 构建

1. 新建microservicecloud-consumer-dept-feign工程（修改主启动类名字）

2. pom文件（加入feign依赖）

<?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>microservicecloud</artifactId>
        <groupId>org.example</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microservicecloud-consumer-dept-feign</artifactId>

    <dependencies>
        <dependency>
            <artifactId>microservicecloud-api</artifactId>
            <groupId>org.example</groupId>
            <version>${project.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--修改后立即生效，热部署-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>springloaded</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <!--Ribbon相关-->
        <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>
        <!-----------------------------------新增---------------------------------------->
        <!--Feign依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-feign</artifactId>
        </dependency>
    </dependencies>
</project>

3. 在microservicecloud-api工程pom文件中加入feign依赖

<?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>microservicecloud</artifactId>
        <groupId>org.example</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microservicecloud-api</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!------------------------------新增-------------------------------->
        <!--Feign依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-feign</artifactId>
        </dependency>
    </dependencies>


</project>

4. 在microservicecloud-api工程中新建DeptClientService接口

package com.mk.demo.service;

import com.mk.demo.entity.Dept;
import org.springframework.cloud.netflix.feign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import java.util.List;

@FeignClient(value = "MICROSERVICECLOUD-DEPT")
public interface DeptClientService {
    @RequestMapping(value = "/dept/get/{id}", method = RequestMethod.GET)
    public Dept get(@PathVariable("id") long id);

    @RequestMapping(value = "/dept/list", method = RequestMethod.GET)
    public List<Dept> list();

    @RequestMapping(value = "/dept/add", method = RequestMethod.POST)
    public boolean add(Dept dept);
}

5. microservicecloud-consumer-dept-feign工程修改Controller，添加上一步新建的DeptClientService接口

package com.mk.demo.controller;

import com.mk.demo.entity.Dept;
import com.mk.demo.service.DeptClientService;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.List;

@RestController
public class DeptController_Consumer {

    @Resource
    private DeptClientService deptClientService;

    @RequestMapping("/consumer/dept/add")
    public boolean add(Dept dept){
        return deptClientService.add(dept);
    }
    @RequestMapping("/consumer/dept/get/{id}")
    public Dept get(@PathVariable("id") Long id){
        return deptClientService.get(id);
    }
    @RequestMapping("/consumer/dept/list")
    public List<Dept> list(){
        return deptClientService.list();
    }

}

6. 编写启动类

package com.mk.demo;

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

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients//扫描Feign
public class DeptConsumer80_Feign_App {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer80_Feign_App.class,args);
    }
}

• 启动（注册中心，服务提供者，消费者）
• 访问（ localhost/consumer/dept/list ）
• 结果
  

5. Hystrix断路器

1. 概述

1. Hystrix是一个用于处理分布式系统的延迟和容错的开源库，在分布式系统里，许多依赖不可避免的会调用失败，比如超时、异常等，Hystrix能够保证在一个依赖出问题的情况下，不会导致整体服务失败，避免级联故障，以提高分布式系统的弹性。
2. "断路器”本身是一种开关装置，当某个服务单元发生故障之后，通过断路器的故障监控（类似熔断保险丝)，向调用方返回一个符合预期的、可处理的备选响应(FallBack)，而不是长时间的等待或者抛出调用方无法处理的异常，这样就保证了服务调用方的线程不会被长时间、不必要地占用，从而避免了故障在分布式系统中的蔓延，乃至雪崩。

• 作用：

1. 服务降级
2. 服务熔断
3. 服务限流

2. 服务熔断

• 熔断机制是应对雪崩效应的一种微服务链路保护机制。
• 当扇出链路的某个微服务不可用或者响应时间太长时，会进行服务的降级，进而熔断该节点微服务的调用，快速返回"错误"的响应信息。当检测到该节点微服务调用响应正常后恢复调用链路。在SpringCloud框架里熔断机制通过Hystrix实现。Hystrix会监控微服务间调用的状况，当失败的调用到一定阈值，缺省是5秒内20次调用失败就会启动熔断机制。熔断机制的注解是
  @HystrixCommand。

1. 步骤

2. 新建microservicecloud-provider-dept-hystrix-8001（拷贝microservicecloud-provider-dept-8001所有内容）

3. 添加新依赖（hystrix依赖）

        <!--hystrix依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-hystrix</artifactId>
        </dependency>

4. 完整版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>microservicecloud</artifactId>
        <groupId>org.example</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microservicecloud-provider-dept-hystrix-8001</artifactId>
    <!-- 引入自己定义的api通用包，可以使用Dept部门Entity-->
    <dependencies>
        <dependency>
            <artifactId>microservicecloud-api</artifactId>
            <groupId>org.example</groupId>
            <version>${project.version}</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jetty</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <!--日志-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
        </dependency>
        <!--修改后立即生效，热部署-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>springloaded</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
        <!--将微服务provider端注册进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>
        <!--hystrix依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-hystrix</artifactId>
        </dependency>
    </dependencies>
</project>

5. 去配置文件更改微服务名称

6. 修改控制器（DeptController）

package com.mk.demo.controller;

import com.mk.demo.entity.Dept;
import com.mk.demo.service.DeptService;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.List;

@RestController
public class DeptController {
    @Resource
    private DeptService deptService;

    @RequestMapping(value = "/dept/get/{id}" , method = RequestMethod.GET)
    //-------------------------------------------------------------------------
    //一旦调用服务方法失败并抛出了错误信息后，会自动调用@HystrixCommand标注好的fallbackMethod调用类中的方法
    @HystrixCommand(fallbackMethod = "processHystrix_Get")
    public Dept get(@PathVariable("id") Long id){
        Dept dept = deptService.get(id);
        if (dept == null){
            throw new RuntimeException("该ID:"+id+"没有对应的信息");
        }
        return dept;
    }
    public Dept processHystrix_Get(@PathVariable("id") Long id){
        return new Dept().setDeptno(id).setDname("该ID:"+id+"没有对应的信息,null--@HystrixCommand")
                .setDb_source("no this database in Mysql");
    }


}

7. 修改主启动类DeptProvider8001_Hystrix_App并添加新注解@EnableCircuitBreaker

package com.mk.demo;

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


@SpringBootApplication
@EnableEurekaClient//本服务启动后会自动注册进eureka服务中
@EnableCircuitBreaker//对hystrix熔断的支持
public class DeptProvider8001_Hystrix_App {
    public static void main(String[] args) {
        SpringApplication.run(DeptProvider8001_Hystrix_App.class,args);
    }
}

• 启动
• 访问（ localhost/consumer/dept/get/311 ）
• 效果

3. 服务降级

1. 步骤

2. 在microservicecloud-api工程新建DeptClientServiceFallbackFactory类实现FallbackFactory

package com.mk.demo.service;

import com.mk.demo.entity.Dept;
import feign.hystrix.FallbackFactory;
import org.springframework.stereotype.Component;

import java.util.List;
@Component
public class DeptClientServiceFallbackFactory implements FallbackFactory<DeptClientService> {
    @Override
    public DeptClientService create(Throwable throwable) {
        return new DeptClientService() {
            @Override
            public Dept get(long id) {
                return new Dept().setDeptno(id).setDname("该ID:"+id+"没有对应的信息,Consumer客户端提供的降级信息,此刻服务ovider已经关闭")
                        .setDb_source("no this database in Mysql");
            }

            @Override
            public List<Dept> list() {
                return null;
            }

            @Override
            public boolean add(Dept dept) {
                return false;
            }
        };
    }
}

3. 在接口DeptClientService上加注解（@FeignClient(value = “MICROSERVICECLOUD-DEPT”,fallbackFactory = DeptClientServiceFallbackFactory.class)）

package com.mk.demo.service;

import com.mk.demo.entity.Dept;
import org.springframework.cloud.netflix.feign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import java.util.List;

@FeignClient(value = "MICROSERVICECLOUD-DEPT",fallbackFactory = DeptClientServiceFallbackFactory.class)
public interface DeptClientService {
    @RequestMapping(value = "/dept/get/{id}", method = RequestMethod.GET)
    public Dept get(@PathVariable("id") long id);

    @RequestMapping(value = "/dept/list", method = RequestMethod.GET)
    public List<Dept> list();

    @RequestMapping(value = "/dept/add", method = RequestMethod.POST)
    public boolean add(Dept dept);
}

4. 向工程microservicecloud-consumer-dept-feign中的yml文件加入配置(前提服务端需要抛出异常)

server:
  port: 80 # 端口号

feign: #---------------------------新增-----------------------------------
   hystrix:
     enabled: true


eureka:
  client:  #客户端注册进eureka服务列表内
    register-with-eureka: false #false表示不向注册中心注册自己
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

• 重新编译microservicecloud-api工程
• 启动（注册中心，服务提供者，消费者）
• 访问（ localhost/consumer/dept/get/323 ）
• 结果

5. 服务降级熔断小总结

• 【服务熔断】
  1. 一般是某个服务故障或者异常引起,类似现实世界中的“保险丝“，当某个异常条件被触发，直接熔断整个服务，而不是一直等到此服务超时。
• 【服务降级】
  1. 所谓降级，一般是从整体负荷考虑。就是当某个服务熔断之后，服务器将不再被调用，此时客户端可以自己准备一个本地的fallback回调，返回一个缺省值。这样做，虽然服务水平下降，但好歹可用，比直接挂掉要强。

4. 服务监控hystrixDashboard

• 除了隔离依赖服务的调用以外，Hystrix还提供了准实时的调用监控(Hystrix Dashboard)，Hystrix会持续地记录所有通过Hystrix发起的请求的执行信息，并以统计报表和图形的形式展示给用户，包括每秒执行多少请求多少成功，多少失败等。
  Netflix通过hystrix-metrics-event-stream项目实现了对以上指标的监控。Spring Cloud也提供了Hystrix Dashboard的整合，对监控内容转化成可视化界面。

1. 步骤

2. 新建microservicecloud-consumer-hystrix-dashboard工程

3. 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>microservicecloud</artifactId>
        <groupId>org.example</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microservicecloud-consumer-hystrix-dashboard</artifactId>

    <dependencies>
        <!-- hystrix和 hystrix-dashboard相关-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-hystrix</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-hystrix-dashboard</artifactId>
        </dependency>
    </dependencies>

</project>

4. 配置文件（application.yml）

server:
  port: 9001 # 端口号

5. 启动类（DeptConsumer_DashBoard_App）

package com.mk.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;

@SpringBootApplication
@EnableHystrixDashboard
public class DeptConsumer_DashBoard_App {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer_DashBoard_App.class,args);
    }
}

6. 访问（ http://localhost:9001/hystrix ）

7. 效果（图标：豪猪）

8. 启动三个eureka集群

9. 启动（microservicecloud-provider-dept-hystrix-8001）

10. 启动（microservicecloud-consumer-hystrix-dashboard工程）

6. zuul路由网关

1. 概述

• Zuul包含了对请求的路由和过滤两个最主要的功能:
• 其中路由功能负责将外部请求转发到具体的微服务实例上，是实现外部访问统一入口的基础而过滤器功能则负责对请求的处理过程进行干预，是实现请求校验、服务聚合等功能的基础.Zuul和Eureka进行整合，将Zuul自身注册为Eureka吸务治理下的应用，同时从Eureka中获得其他微服务的消息，也即以后的访问微服务都是通过Zuul跳转后获得。

• 注意:Zuul服务最终还是会注册进Eureka

2. 路由基本配置

1. 步骤

2. 新建Module模块microservicecloud-zuul-gateway-9527

3. pom文件

• 添加部分

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

• 完整部分

<?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>microservicecloud</artifactId>
        <groupId>org.example</groupId>
        <version>1.0</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>microservicecloud-zuul-gateway-9527</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>
        <!--zuul路由网关-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zuul</artifactId>
        </dependency>
    </dependencies>


</project>

4. hosts修改

• 127.0.0.1 myzuul.com

5. 配置文件（application.yml）

server:
  port: 9527 # 端口号

spring:
  application:
    name: microservicecloud-zuul-gateway

eureka:
  client:  #客户端注册进eureka服务列表内
     service-url:
       defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
  instance:
    instance-id: gateway-9527.com    # 自定义服务名称信息
    prefer-ip-address: true # 访问路径可以显示IP地址

6. 启动类（zuul_9527_StartSpringCloudApp ）

package com.mk.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

@SpringBootApplication
@EnableZuulProxy
public class zuul_9527_StartSpringCloudApp {
    public static void main(String[] args) {
        SpringApplication.run(zuul_9527_StartSpringCloudApp.class,args);
    }
}

7. 启动

8. 测试

3. 路由访问映射规则

1. 步骤

2. 代理名字（修改前工程的yml文件）

zuul:
  routes:
    mydept.serviceId: microservicecloud-dept
    mydept.path: /mydept/**

3. 原真实服务名忽略

4. 完整yml文件

server:
  port: 9527 # 端口号

spring:
  application:
    name: microservicecloud-zuul-gateway

eureka:
  client:  #客户端注册进eureka服务列表内
     service-url:
       defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
  instance:
    instance-id: gateway-9527.com    # 自定义服务名称信息
    prefer-ip-address: true # 访问路径可以显示IP地址

zuul:
  routes:
    mydept.serviceId: microservicecloud-dept # 更改原路径中服务的名称
    mydept.path: /mydept/**
  ignored-services: microservicecloud-dept # 该路径禁止访问
  prefix: /zwh # 设置统一前缀

持续更新中（有什么不足还望留言）