SpringCloud详细教程(上)

作者专栏合集(限时特价) 同时被 2 个专栏收录
43 篇文章 137 订阅 ¥19.90 ¥99.00

【订阅专栏合集,作者所有付费文章都能看(持续更新)】

推荐【Kafka教程https://bigbird.blog.csdn.net/article/details/108770504
推荐【rabbitmq教程https://bigbird.blog.csdn.net/article/details/81436980
推荐【Flink教程https://blog.csdn.net/hellozpc/article/details/109413465
推荐【JVM面试与调优教程https://bigbird.blog.csdn.net/article/details/113888604
推荐【SpringBoot全套教程https://blog.csdn.net/hellozpc/article/details/107095951
推荐【SpringCloud教程https://blog.csdn.net/hellozpc/article/details/83692496
推荐【Mybatis教程https://blog.csdn.net/hellozpc/article/details/80878563
推荐【SnowFlake教程https://blog.csdn.net/hellozpc/article/details/108248227
推荐【并发限流教程https://blog.csdn.net/hellozpc/article/details/107582771
推荐【Redis教程https://bigbird.blog.csdn.net/article/details/81267030
推荐【Netty教程https://blog.csdn.net/hellozpc/category_10945233.html

SpringCloud详细教程代码下载地址:https://download.csdn.net/download/zpcandzhj/10762209

SpringCloud详细教程(上)

springcloud 官网 https://spring.io/projects/spring-cloud/

文章目录

1.SpringCloud详细教程目录

  • 开发环境说明
  • 细说微服务架构
  • SpringCloud 概论
  • SpringCloud 快速入门
  • Eureka 服务注册中心
  • 使用Spring Cloud Ribbon 实现负载均衡
  • 使用Spring Cloud Hystrix 实现容错

2. 开发环境说明

  • JDK:  1.8
  • IDE:    IntelliJ IDEA
  • Maven:3.3.9
  • OS:        Windows 10 10.0
  • Springboot版本:2.0+

3.细说微服务架构

目前微服务是非常火的架构或者说概念,也是在构建大型互联网项目时采用的架构方式。

3.1.单体架构

单体架构,是指将开发好的项目打成war包,然后发布到tomcat等容器中的应用。

假设你正准备开发一款与Uber和滴滴竞争的出租车调度软件,经过初步会议和需求分析,你可能会手动或者使用基于SpringBoot、Play或者Maven的生成器开始这个新项目,它的六边形架构是模块化的 ,架构图如下:
在这里插入图片描述

  • 应用核心是业务逻辑,由定义服务、领域对象和事件的模块完成。围绕着核心的是与外界打交道的适配器。适配器包括数据库访问组件、生产和处理消息的消息组件,以及提供API或者UI访问支持的web模块等。

  • 尽管也是模块化逻辑,但是最终它还是会打包并部署为单体式应用。具体的格式依赖于应用语言和框架。例如,许多Java应用会被打包为WAR格式,部署在Tomcat或者Jetty上,而另外一些Java应用会被打包成自包含的JAR格式,类似的,Rails和Node.js会被打包成层级目录。

  • 这种应用开发风格很常见,因为IDE和其它工具都擅长开发一个简单应用,这类应用也很易于调试,只需要简单运行此应用,用Selenium链接UI就可以完成端到端测试。单体式应用也易于部署,只需要把打包应用拷贝到服务器端,通过在负载均衡器后端运行多个拷贝就可以轻松实现应用扩展。在早期这类应用运行的很好。

3.2.单体架构存在的问题

在这里插入图片描述
在这里插入图片描述
如何解决以上问题呢? – 使用微服务架构。使得应用由重变轻。

3.3.什么是微服务?

在这里插入图片描述

作者:Martin Fowler
在这里插入图片描述
在这里插入图片描述

3.4.微服务架构的特征

在这里插入图片描述

3.5.微服务架构示例

在这里插入图片描述

每一个应用功能区都使用微服务完成。

4.SpringCloud概论

4.1.简介

SpringCloud项目的官方网址:
http://projects.spring.io/spring-cloud/
在这里插入图片描述
在这里插入图片描述

4.2.SpringCloud子项目

在这里插入图片描述

4.3.Springcloud版本说明

在这里插入图片描述

官方版本:
在这里插入图片描述

在这里插入图片描述

可见,目前Finchley.SR2版本是最新的稳定版,所以我们学习的过程中,就是使用的这个版本。
在这里插入图片描述

4.4.SpringCloud框架特点

在这里插入图片描述

5.使用 SpringBoot 实现微服务

在正式学习SpringCloud 之前我们先使用SpringBoot实现一个微服务。

业务非常简单:
1、商品微服务:通过商品id查询商品的服务;
2、订单微服务:创建订单时通时,通过调用商品的微服务进行查询商品数据;

图示:
在这里插入图片描述

说明:
1、对于商品微服务而言,商品微服务是服务的提供者,订单微服务是服务的消费者;
2、对于订单微服务而言,订单微服务是服务的提供者,人是服务的消费者。

5.1.实现商品微服务

5.1.1.创建maven工程

在这里插入图片描述
在这里插入图片描述

5.1.2.导入依赖

重点是导入SpringBoot的依赖:

<?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.zpc.microservice</groupId>
    <artifactId>microservice-item</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.6.RELEASE</version>
    </parent>

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

    <build>
        <finalName>${project.artifactId}</finalName>
        <plugins>
            <!-- 资源文件拷贝插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <configuration>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <!-- java编译插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
    </project>
5.1.3.创建实体Item
package com.zpc.item.entity;

public class Item {

    private Long id;

    private String title;

    private String pic;

    private String desc;

    private Long price;

    public Item(){}

    public Item(long id, String title, String pic, String desc, Long price) {
        this.id=id;
        this.title=title;
        this.pic=pic;
        this.desc=desc;
        this.price=price;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getPic() {
        return pic;
    }

    public void setPic(String pic) {
        this.pic = pic;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    public Long getPrice() {
        return price;
    }

    public void setPrice(Long price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Item [id=" + id + ", title=" + title + ", pic=" + pic + ", desc=" + desc + ", price=" + price + "]";
    }

}
5.1.4.编写ItemService

编写ItemService用于实现具体的商品查询逻辑,为了演示方便,我们并不真正的连接数据库,而是做模拟实现。

package com.zpc.item.service;
import com.zpc.item.entity.Item;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.Map;

@Service
public class ItemService {

    private static final Map<Long, Item> ITEM_MAP = new HashMap<Long, Item>();

    static {// 准备一些静态数据,模拟数据库
        ITEM_MAP.put(1L, new Item(1L, "商品1", "http://图片1", "商品描述1", 1000L));
        ITEM_MAP.put(2L, new Item(2L, "商品2", "http://图片2", "商品描述2", 2000L));
        ITEM_MAP.put(3L, new Item(3L, "商品3", "http://图片3", "商品描述3", 3000L));
        ITEM_MAP.put(4L, new Item(4L, "商品4", "http://图片4", "商品描述4", 4000L));
        ITEM_MAP.put(5L, new Item(5L, "商品5", "http://图片5", "商品描述5", 5000L));
        ITEM_MAP.put(6L, new Item(6L, "商品6", "http://图片6", "商品描述6", 6000L));
        ITEM_MAP.put(7L, new Item(7L, "商品7", "http://图片7", "商品描述7", 7000L));
        ITEM_MAP.put(8L, new Item(8L, "商品8", "http://图片8", "商品描述8", 8000L));
        ITEM_MAP.put(8L, new Item(9L, "商品9", "http://图片9", "商品描述9", 9000L));
        ITEM_MAP.put(8L, new Item(10L, "商品10", "http://图片10", "商品描述10", 10000L));
    }

    /**
     * 模拟实现商品查询
     *
     * @param id
     * @return
     */
    public Item queryItemById(Long id) {
        return ITEM_MAP.get(id);
    }

}
5.1.5.编写ItemController
package com.zpc.item.controller;

import com.zpc.item.entity.Item;
import com.zpc.item.service.ItemService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ItemController {

    @Autowired
    private ItemService itemService;

    /**
     * 对外提供接口服务,查询商品信息
     *
     * @param id
     * @return
     */
    @GetMapping(value = "item/{id}")
    public Item queryItemById(@PathVariable("id") Long id) {
        return this.itemService.queryItemById(id);
    }

}

@RestController注解的说明:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Controller
@ResponseBody
public @interface RestController {

   /**
    * The value may indicate a suggestion for a logical component name,
    * to be turned into a Spring bean in case of an autodetected component.
    * @return the suggested component name, if any (or empty String otherwise)
    * @since 4.0.1
    */
   @AliasFor(annotation = Controller.class)
   String value() default "";

}

从源码可以看出,这是一个组合注解,组合了@Controller@Response注解。相当于我们同时写了这2个注解。

@GetMapping注解的说明:

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@RequestMapping(method = RequestMethod.GET)
public @interface GetMapping {...}

@GetMapping注解是@RequestMapping(method = RequestMethod.GET)简写方式。其功能都是一样的。

同理还有其它注解:
在这里插入图片描述

5.1.6.编写程序入口
package com.zpc.item.runner;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;

/**
 * @author Evan
 */

@SpringBootApplication//申明这是一个Spring Boot项目
@ComponentScan(basePackages = {"com.zpc.item.controller","com.zpc.item.service"})//手动指定bean组件扫描范围
public class ItemApp {
    public static void main(String[] args) {
        SpringApplication.run(ItemApp.class, args);
    }
}
5.1.7.创建application.yml配置文件

SpringBoot以及SpringCloud项目支持yml和properties格式的配置文件。

yml格式是YAML(Yet Another Markup Language)编写的格式,YAML和properties格式的文件是可以相互转化的。如:

server:
  port: 8081 #服务端口

等价于properties文件的配置:
server.port=8081

配置文件的示例:

server:
  port: 8081 #服务端口
5.1.8.启动程序测试

在这里插入图片描述

可以看到已经通过微服务查询到数据。

5.2.实现订单微服务

5.2.1.创建工程

在这里插入图片描述
在这里插入图片描述

5.2.2.导入依赖
<?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.zpc.microservice</groupId>
    <artifactId>microservice-item</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.6.RELEASE</version>
    </parent>

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

    <build>
        <finalName>${project.artifactId}</finalName>
        <plugins>
            <!-- 资源文件拷贝插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <configuration>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <!-- java编译插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
    </project>
5.2.3.创建订单Order实体
package com.zpc.order.entity;

import java.util.Date;
import java.util.List;

public class Order {

    private String orderId;

    private Long userId;

    private Date createDate;

    private Date updateDate;

    private List<OrderDetail> orderDetails;

    public Order() {

    }

    public Order(String orderId, Long userId, Date createDate, Date updateDate) {
        this.orderId = orderId;
        this.userId = userId;
        this.createDate = createDate;
        this.updateDate = updateDate;
    }

    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public Long getUserId() {
        return userId;
    }

    public void setUserId(Long userId) {
        this.userId = userId;
    }

    public Date getCreateDate() {
        return createDate;
    }

    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }

    public Date getUpdateDate() {
        return updateDate;
    }

    public void setUpdateDate(Date updateDate) {
        this.updateDate = updateDate;
    }


    public List<OrderDetail> getOrderDetails() {
        return orderDetails;
    }

    public void setOrderDetails(List<OrderDetail> orderDetails) {
        this.orderDetails = orderDetails;
    }

    @Override
    public String toString() {
        return "Order [orderId=" + orderId + ", userId=" + userId
                + ", createDate=" + createDate + ", updateDate=" + updateDate
                + "]";
    }}
5.2.4.创建订单详情OrderDetail实体

订单与订单详情是一对多的关系。

package com.zpc.order.entity;

public class OrderDetail {

    private String orderId;

    private Item item = new Item();

    public OrderDetail() {

    }

    public OrderDetail(String orderId, Item item) {
        this.orderId = orderId;
        this.item = item;
    }

    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public Item getItem() {
        return item;
    }

    public void setItem(Item item) {
        this.item = item;
    }

    @Override
    public String toString() {
        return "OrderDetail [orderId=" + orderId + ", item=" + item + "]";
    }

}
5.2.5.将商品微服务项目中的Item类拷贝到当前工程

在这里插入图片描述

5.2.6.编写OrderService

该Service实现的根据订单Id查询订单的服务,为了方便测试,我们将构造数据实现,不采用查询数据库的方式。

package com.zpc.order.service;

import com.zpc.order.entity.Item;
import com.zpc.order.entity.Order;
import com.zpc.order.entity.OrderDetail;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;

@Service
public class OrderService {

    private static final Map<String, Order> ORDER_DATA = new HashMap<String, Order>();

    static {
        // 模拟数据库,构造测试数据
        Order order = new Order();
        order.setOrderId("201810300001");
        order.setCreateDate(new Date());
        order.setUpdateDate(order.getCreateDate());
        order.setUserId(1L);
        List<OrderDetail> orderDetails = new ArrayList<OrderDetail>();

        Item item = new Item();// 此处并没有商品的数据,只是保存了商品ID,需要调用商品微服务获取
        item.setId(1L);
        orderDetails.add(new OrderDetail(order.getOrderId(), item));

        item = new Item(); // 构造第二个商品数据
        item.setId(2L);
        orderDetails.add(new OrderDetail(order.getOrderId(), item));

        order.setOrderDetails(orderDetails);

        ORDER_DATA.put(order.getOrderId(), order);
    }

    @Autowired
    private ItemService itemService;

    /**
     * 根据订单id查询订单数据
     *
     * @param orderId
     * @return
     */
    public Order queryOrderById(String orderId) {
        Order order = ORDER_DATA.get(orderId);
        if (null == order) {
            return null;
        }
        List<OrderDetail> orderDetails = order.getOrderDetails();
        for (OrderDetail orderDetail : orderDetails) {
            // 通过商品微服务查询商品详细数据
            Item item = this.itemService.queryItemById(orderDetail.getItem()
                    .getId());
            if (null == item) {
                continue;
            }
            orderDetail.setItem(item);
        }

        return order;
    }

}
5.2.7.实现ItemService
package com.zpc.order.service;


import com.zpc.order.entity.Item;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class ItemService {

    // Spring框架对RESTful方式的http请求做了封装,来简化操作
    @Autowired
    private RestTemplate restTemplate;

    public Item queryItemById(Long id) {
        return this.restTemplate.getForObject("http://127.0.0.1:8081/item/"
                + id, Item.class);
    }

}
5.2.8.编写OrderController
package com.zpc.order.controller;

import com.zpc.order.entity.Order;
import com.zpc.order.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class OrderController {
    @Autowired
    private OrderService orderService;

    @GetMapping(value = "order/{orderId}")
    public Order queryOrderById(@PathVariable("orderId") String orderId) {
        return this.orderService.queryOrderById(orderId);
    }
}
5.2.9.编写程序入口
package com.zpc.order.runner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.web.client.RestTemplate;

/**
 * @author Evan
 */
@SpringBootApplication//申明这是一个Spring Boot项目
@ComponentScan(basePackages = {"com.zpc.order.controller", "com.zpc.order.service"})//手动指定bean扫描范围
public class OrderApp {
    public static void main(String[] args) {
        SpringApplication.run(OrderApp.class, args);
    }

    /**
     * 向Spring容器中定义RestTemplate对象
     * @return
     */
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}
5.2.10.编写application.yml配置文件
server:
  port: 8082 #服务端口
5.2.11.启动测试

在这里插入图片描述

测试结果可见,查询订单时,同时也将商品数据查询到。

5.3.添加okHttp的支持

okhttp是一个封装URL,比HttpClient更友好易用的工具。目前似乎okhttp更流行一些。

官网:http://square.github.io/okhttp/

在这里插入图片描述

RestTemplate底层默认使用的jdk的标准实现,如果我们想让RestTemplate的底层使用okhttp,非常简单:
1、添加okhttp依赖

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>3.9.0</version>
</dependency>

2、设置requestFactory
return new RestTemplate(new OkHttp3ClientHttpRequestFactory());

@Bean
public RestTemplate restTemplate() {
    return new RestTemplate(new OkHttp3ClientHttpRequestFactory());
}

测试:
在这里插入图片描述

结果(没有变化):
在这里插入图片描述
测试结果是一样的。

5.4.解决订单系统中的url硬编码问题

  • 通过以上的测试我们发现,在订单系统中要调用商品微服务中的查询接口来获取数据,在订单微服务中将url硬编码到代码中,这样显然不好,因为,运行环境一旦发生变化这个url地址将不可用。

  • 如何解决呢?

解决方案:将url地址写入到application.yml配置文件中。

实现:
修改application.yml文件:

server:
  port: 8082 #服务端口
myspcloud:
  item:
    url: http://127.0.0.1:8081/item/

修改ItemService中的实现:

@Service
public class ItemService {

    // Spring框架对RESTful方式的http请求做了封装,来简化操作
    @Autowired
    private RestTemplate restTemplate;

    @Value("${myspcloud.item.url}")
    private String itemUrl;

    public Item queryItemById(Long id) {
        return this.restTemplate.getForObject(itemUrl
                + id, Item.class);
    }

}

测试(debug可以看到效果):
在这里插入图片描述

5.5.继续优化解决硬编码的问题

在SpringBoot中使用@ConfigurationProperties注解可以非常简单的将配置文件中的值映射成对象。
第一步,创建ItemProperties类:

package com.zpc.order.properties;

public class ItemProperties {
    private String url;

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

}

第二步,创建OrderProperties类:

package com.zpc.order.properties;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * 以myspcloud开头的配置被匹配到
 * @author Evan
 */
@Component
@ConfigurationProperties(prefix="myspcloud")
public class OrderProperties {

    private ItemProperties item = new ItemProperties();

    public ItemProperties getItem() {
        return item;
    }

    public void setItem(ItemProperties item) {
        this.item = item;
    }
}

第三步,在Itemservice中注入该对象:

@Service
public class ItemService {

    // Spring框架对RESTful方式的http请求做了封装,来简化操作
    @Autowired
    private RestTemplate restTemplate;

    //@Value("${myspcloud.item.url}")
    //private String itemUrl;

    @Autowired
    OrderProperties orderProperties;

    public Item queryItemById(Long id) {
        return this.restTemplate.getForObject(orderProperties.getItem().getUrl()
                + id, Item.class);
    }

第四步,启动类中增加bean扫描路径

@ComponentScan(basePackages = {"com.zpc.order.controller","com.zpc.order.service","com.zpc.order.properties"})//
手动指定bean扫描范围

第五步,debug运行
在这里插入图片描述
可以看出,这种解决方案比第一种好很多,更加的方便的。

思考:

  • 这样是否还存在问题?如果商品的微服务有多个怎么办?
  • 我们在订单微服务中使用了Item实体,直接采取从商品微服务拷贝代码的方式是否太生硬?

6.SpringCloud快速入门

6.1.分析硬编码的问题

通过前面5.4、5.5的实现,我们视乎已经解决了url硬编码的问题,但是我们想想:
1、如果商品微服务的ip地址发生了变更,订单微服务中的配置文件也需要跟着修改
2、如果商品微服务有多个,那么在订单微服务中又该如何写地址?

那应该怎么解决呢? – 通过服务注册、发现的机制来完成。

6.2.微服务注册与发现

原理示意图:
在这里插入图片描述

由上图可以看出:
1、服务提供者将服务注册到注册中心
2、服务消费者通过注册中心查找服务
3、查找到服务后进行调用(这里就是无需硬编码url的解决方案)
4、服务的消费者与服务注册中心保持心跳连接,一旦服务提供者的地址发生变更时,注册中心会通知服务消费者

6.3.注册中心:Eureka

SpringCloud提供了多种注册中心的支持,如:Eureka、consul、ZooKeeper等。Eureka已经闭源了。本教程第二篇也会介绍使用其它两种方式作为注册中心。
在这里插入图片描述

6.3.1.原理

在这里插入图片描述

Eureka包含两个组件:Eureka ServerEureka Client

  • Eureka Server提供服务注册服务,各个节点启动后,会在Eureka Server中进行注册,这样EurekaServer中的服务注册表中将会存储所有可用服务节点的信息,服务节点的信息可以在界面中直观的看到。

  • Eureka Client是一个java客户端,用于简化与Eureka Server的交互,客户端同时也就别一个内置的、使用轮询(round-robin)负载算法的负载均衡器。

  • 在应用启动后,将会向Eureka Server发送心跳,默认周期为30秒,如果Eureka Server在多个心跳周期内没有接收到某个节点的心跳,Eureka Server将会从服务注册表中把这个服务节点移除(默认90秒)。

  • Eureka Server之间通过复制的方式完成数据的同步,Eureka还提供了客户端缓存机制,即使所有的Eureka Server都挂掉,客户端依然可以利用缓存中的信息消费其他服务的API。综上,Eureka通过心跳检查、客户端缓存等机制,确保了系统的高可用性、灵活性和可伸缩性。

6.3.2.编写Eureka Server

第一步:创建Maven工程:

在这里插入图片描述
在这里插入图片描述
第二步,导入依赖:
这里需要导入SpringCloud的管理依赖。

<?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.zpc.springcloud.eureka</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.6.RELEASE</version>
    </parent>
    <dependencyManagement>
        <dependencies>
            <!-- 导入SpringCloud的依赖管理 -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Finchley.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
    	<!--springboot 整合eureka服务端-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>

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

第三步,编写程序启动类:

package com.zpc.springcloud.eureka;

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

/**
 * Eureka注册中心
 */
@SpringBootApplication
@EnableEurekaServer //申明这是一个Eureka服务
public class AppEureka {

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

第四步,编写application.yml配置文件:

###服务端口号
server:
  port: 8100

###服务名称
spring:
  application:
    name: app-eureka-center

eureka:
  instance:
    #注册中心地址
    hostname: 127.0.0.1
###客户端调用地址
  client:
    serviceUrl:
      defaultZone: http://${eureka.instance.hostname}:8100/eureka/
###是否将自己注册到Eureka服务中,因为该应用本身就是注册中心,不需要再注册自己(集群的时候为true)
    register-with-eureka: false
###是否从Eureka中获取注册信息,因为自己为注册中心,不会在该应用中的检索服务信息
    fetch-registry: false

第五步,启动程序做测试:
在这里插入图片描述

6.4.将商品微服务注册到Eureka

接下来,我们需要将商品的微服务注册到Eureka服务中。

第一步:修改pom文件,引入SpringCloud的管理依赖以及eureka服务依赖。

<?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.zpc.microservice</groupId>
    <artifactId>microservice-item</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.6.RELEASE</version>
    </parent>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Finchley.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--springboot 整合eureka客户端-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
    </dependencies>

    <build>
        <finalName>${project.artifactId}</finalName>
        <plugins>
            <!-- 资源文件拷贝插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <configuration>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <!-- java编译插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

第二步,修改application.yml配置文件:

###服务端口号(本身是一个web项目)
server:
  port: 8081
###起个名字作为服务名称(该服务注册到eureka注册中心的名称,比如商品服务)
spring:
    application:
        name: app-item
###服务注册到eureka注册中心的地址
eureka:
  client:
    service-url:
           defaultZone: http://127.0.0.1:8100/eureka
###因为该应用为服务提供者,是eureka的一个客户端,需要注册到注册中心
    register-with-eureka: true
###是否需要从eureka上检索服务
    fetch-registry: true

第三步,修改启动类,增加@EnableEurekaClient 注解:

package com.zpc.item.runner;

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

/**
 * @author Evan
 */
//申明这是一个Spring Boot项目
@SpringBootApplication
@EnableEurekaClient
@ComponentScan(basePackages = {"com.zpc.item.controller","com.zpc.item.service"})
public class ItemApp {
    public static void main(String[] args) {
        SpringApplication.run(ItemApp.class, args);
    }

}

第四步,启动测试:

在这里插入图片描述

至此,我们已经将自己的微服务注册到Eureka server中了。

6.5.订单系统从Eureka中发现商品服务

之前我们在订单系统中是将商品微服务的地址进行了硬编码,现在,由于已经将商品服务注册到Eureka中,所以,只需要从Eureka中发现服务即可。

第一步,在订单系统中添加依赖:

<?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.zpc.microservice</groupId>
    <artifactId>microservice-order</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.6.RELEASE</version>
    </parent>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Finchley.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--springboot 整合eureka客户端-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
            <version>3.9.0</version>
        </dependency>

    </dependencies>

    <build>
        <finalName>${project.artifactId}</finalName>
        <plugins>
            <!-- 资源文件拷贝插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <configuration>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <!-- java编译插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

第二步,修改application.yml配置文件:

server:
  port: 8082 #服务端口
myspcloud:
  item:
    url: http://127.0.0.1:8081/item/
###起个名字作为服务名称(该服务注册到eureka注册中心的名称,比如订单服务)
spring:
    application:
        name: app-order
###服务注册到eureka注册中心的地址
eureka:
  client:
    service-url:
           defaultZone: http://127.0.0.1:8100/eureka
###因为该应用为服务提供者,是eureka的一个客户端,需要注册到注册中心
    register-with-eureka: true
###是否需要从eureka上检索服务
    fetch-registry: true

第三步,修改ItemService的实现逻辑:

package com.zpc.order.service;
import com.zpc.order.entity.Item;
import com.zpc.order.properties.OrderProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class ItemService {

    // Spring框架对RESTful方式的http请求做了封装,来简化操作
    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    OrderProperties orderProperties;

    public Item queryItemById(Long id) {

        // 该方法走eureka注册中心调用(去注册中心根据app-item查找服务,这种方式必须先开启负载均衡@LoadBalanced)
        String itemUrl = "http://app-item/item/{id}";
        Item result = restTemplate.getForObject(itemUrl, Item.class, id);
        System.out.println("订单系统调用商品服务,result:" + result);
        return result;
    }
}

第四步,在启动类中添加@EnableEurekaClient注解 ,获取RestTemplate的方法上加 @LoadBalanced注解

package com.zpc.order.runner;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.http.client.OkHttp3ClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

/**
 * @author Evan
 */

@SpringBootApplication//申明这是一个Spring Boot项目
@EnableEurekaClient
@ComponentScan(basePackages = {"com.zpc.order.controller", "com.zpc.order.service","com.zpc.order.properties"})//手动指定bean扫描范围
public class OrderApp {
    public static void main(String[] args) {
        SpringApplication.run(OrderApp.class, args);
    }

    /**
     * 向Spring容器中定义RestTemplate对象
     * @return
     */
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate(new OkHttp3ClientHttpRequestFactory());
    }

}

第五步,启动测试(此时有3个应用:Eureka注册中心、Item服务、order服务)
在这里插入图片描述

在注册中心http://localhost:8100看到有2个客户端:
在这里插入图片描述

7.深入理解Eureka

7.1.为Eureka添加用户认证

在前面的示例中,我们可以看到我们需要登录即可访问到Eureka服务,这样其实是不安全的。

接下来,我们为Eureka添加用户认证。

第一步,为Eureka服务端(eureka-server)添加安全认证依赖:

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

第二步,增加application.yml配置文件:

###服务端口号
server:
  port: 8100

###服务名称
spring:
  application:
    name: app-eureka-center
  security:
    basic:
      enable: true #开启基于HTTP basic的认证
    user: #配置用户的账号信息
      name: zpc
      password: 123456

eureka:
  instance:
    #注册中心地址
    hostname: 127.0.0.1

###客户端调用地址
  client:
    serviceUrl:
      defaultZone: http://${spring.security.user.name}:${spring.security.user.password}@${eureka.instance.hostname}:8100/eureka/
###是否将自己注册到Eureka服务中,因为该应用本身就是注册中心,不需要再注册自己(集群的时候为true)
    register-with-eureka: false
###是否从Eureka中获取注册信息,因为自己为注册中心,不会在该应用中的检索服务信息
    fetch-registry: true

第三步,在eurka服务端添加一个安全认证类:

package com.zpc.springcloud.eureka;

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    /**
     * 高版本springcloud的丢弃了配置:
     *
     * security:
     *   basic:
     *    enabled: true
     *
     * 所以应该使用以下方式开启
     *
     * @param http
     * @throws Exception
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // Configure HttpSecurity as needed (e.g. enable http basic).
        http.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.NEVER);
        http.csrf().disable();
        //注意:为了可以使用 http://${user}:${password}@${host}:${port}/eureka/ 这种方式登录,所以必须是httpBasic,
        // 如果是form方式,不能使用url格式登录
        http.authorizeRequests().anyRequest().authenticated().and().httpBasic();
    }
}

第四步,重新启动Eureka服务进行测试:
在这里插入图片描述

输入正确的用户名密码即可登录。

这时,服务提供者注册到Eureka时会报错:

2018-10-31 23:01:13.419  WARN 143840 --- [nfoReplicator-0] c.n.d.s.t.d.RetryableEurekaHttpClient    : Request execution failure with status code 401; retrying on another server if available
2018-10-31 23:01:13.420  WARN 143840 --- [nfoReplicator-0] com.netflix.discovery.DiscoveryClient    : DiscoveryClient_APP-ORDER/Evan-Zhou:app-order:8082 - registration failed Cannot execute request on any known server

com.netflix.discovery.shared.transport.TransportException: Cannot execute request on any known server

所以,需要在服务注册时也需要设置用户名和密码。

7.1.1.服务注册时(client端)设置账户信息

服务注册到有认证需求的注册中心时,需要设置如下地址:

http://USER:PASSWORD@127.0.0.1:端口号/eureka/

配置如下(至此,Eureka注册中心、Item服务、order服务3个配置文件全部改成了带账号密码的请求地址):

###服务注册到eureka注册中心的地址
eureka:
  client:
    service-url:
           defaultZone: http://zpc:123456@127.0.0.1:8100/eureka

7.2.Eureka的自我保护模式

在这里插入图片描述

如图,当前Eureka进入了自我保护模式。(先开启Eureka server端和client端,然后再断开client端,此时刷新Eureka界面,就会看到红色字样)
在这里插入图片描述

在短时间内丢失了服务实例的心跳,不会剔除该服务,这是eurekaserver的自我保护机制的宗旨。主要是为了防止由于短暂的网络故障误删除可用的服务。

所以,一般进入自我保护模式,无需处理。如果,需要禁用自我保护模式,只需要在配置文件中添加配置即可:
(测试环境、开发环境可以关闭自我保护机制,保证服务不可用时及时剔除)
配置方式:在server端 配置文件中添加server: 配置

eureka:
  instance:
    #注册中心地址
    hostname: 127.0.0.1

###客户端调用地址
  client:
    serviceUrl:
      defaultZone: http://${spring.security.user.name}:${spring.security.user.password}@${eureka.instance.hostname}:8100/eureka/
    register-with-eureka: false
    fetch-registry: true

  server:
      enable-self-preservation: false #禁用自我保护模式

重新启动服务查看效果:
在这里插入图片描述
提示,如果禁用自我保护模式,在网络通信故障下可能会出现问题,因为服务可能只是短暂的不可用。
上述界面出现后,断开client端,此时刷新Eureka界面,就会看到红色字样,同时会把服务实例从注册中心剔除:No instances available
在这里插入图片描述

7.3.Eureka的高可用(Eureka集群)

前面的测试,我们会发现,Eureka服务是一个单点服务,在生产环境就会出现单点故障,为了确保Eureka服务的高可用,我需要搭建Eureka服务的集群。

搭建Eureka集群非常简单,只要启动多个Eureka Server服务并且让这些Server端之间彼此进行注册即可实现。

第一步,修改eureka server端的application.yml文件:

  • 端口为8100的机器注册到端口为9100的注册中心
###服务端口号
server:
  port: 8100

###服务名称
spring:
  application:
    name: app-eureka-center
  security:
    basic:
      enable: true #开启基于HTTP basic的认证
    user: #配置用户的账号信息
      name: zpc
      password: 123456

eureka:
  instance:
    #注册中心地址
    hostname: 127.0.0.1

###客户端调用地址
  client:
    serviceUrl:
      defaultZone: http://${spring.security.user.name}:${spring.security.user.password}@${eureka.instance.hostname}:9100/eureka/
###是否将自己注册到Eureka服务中,集群的时候为true
    register-with-eureka: true
    fetch-registry: true

  server:
      enable-self-preservation: false

第二步,修改配置文件,再建一个Eureka server工程,启动两个工程(两个工程的name属性一样)测试:

  • 端口为9100的机器注册到端口为8100的注册中心
###服务端口号
server:
 port: 9100

###服务名称
spring:
 application:
   name: app-eureka-center
 security:
   basic:
     enable: true #开启基于HTTP basic的认证
   user: #配置用户的账号信息
     name: zpc
     password: 123456

eureka:
 instance:
   #注册中心地址
   hostname: 127.0.0.1
###客户端调用地址
 client:
   serviceUrl:
     defaultZone: http://${spring.security.user.name}:${spring.security.user.password}@${eureka.instance.hostname}:8100/eureka/
###是否将自己注册到Eureka服务中,集群的时候为true
   register-with-eureka: true
   fetch-registry: true
###测试环境、开发环境可以关闭自我保护机制,保证服务不可用时及时剔除
 server:
   enable-self-preservation: false
   eviction-interval-timer-in-ms: 2000

测试结果:
在这里插入图片描述
在这里插入图片描述

可以看到,2个Eureka服务进行了彼此注册。

7.4.将client端服务注册到Eureka高可用集群

服务注册到Eureka集群时,可以指定多个,也可以指定一个Eureka服务(因为Eureka服务集群间彼此互联)。

修改商品微服务项目microservice-item的application.yml配置文件,defaultZone 写上所有注册中心的地址:

###服务端口号(本身是一个web项目)
server:
  port: 8081
###起个名字作为服务名称(该服务注册到eureka注册中心的名称,比如商品服务)
spring:
    application:
        name: app-item
###服务注册到eureka注册中心的地址
eureka:
  client:
    service-url:
           defaultZone: http://zpc:123456@127.0.0.1:8100/eureka/,http://zpc:123456@127.0.0.1:9100/eureka/
###因为该应用为服务提供者,是eureka的一个客户端,需要注册到注册中心
    register-with-eureka: true
###是否需要从eureka上检索服务
    fetch-registry: true

重启启动,测试:可以通过停止其中一个Eureka server服务进行测试,结果会发现集群是高可用。
即:启动2个Eureka服务端(注册中心),1个商品服务(item),1个订单服务(order)。停掉其中一个Eureka服务端后,访问另外一个Eureka服务端页面可以看到item服务立马切换到此注册中心,订单服务照样可以访问商品服务,浏览器输入http://localhost:8082/order/201810300001还能获取到商品数据(因为商品服务同时注册到了2个注册中心)。

为了防止是缓存的效果,OrderService 再加一条数据201810300002 ,用http://localhost:8082/order/201810300002测试高可用。

package com.zpc.order.service;

import com.zpc.order.entity.Item;
import com.zpc.order.entity.Order;
import com.zpc.order.entity.OrderDetail;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;

@Service
public class OrderService {

    private static final Map<String, Order> ORDER_DATA = new HashMap<String, Order>();

    static {
        // 模拟数据库,构造测试数据
        Order order1 = new Order();
        order1.setOrderId("201810300001");
        order1.setCreateDate(new Date());
        order1.setUpdateDate(order1.getCreateDate());
        order1.setUserId(1L);
        List<OrderDetail> orderDetails1 = new ArrayList<OrderDetail>();

        Item item = new Item();// 此处并没有商品的数据,只是保存了商品ID,需要调用商品微服务获取
        item.setId(1L);
        orderDetails1.add(new OrderDetail(order1.getOrderId(), item));

        item = new Item(); // 构造第二个商品数据
        item.setId(6L);
        orderDetails1.add(new OrderDetail(order1.getOrderId(), item));
        order1.setOrderDetails(orderDetails1);
        ORDER_DATA.put(order1.getOrderId(), order1);

        Order order2 = new Order();
        order2.setOrderId("201810300002");
        order2.setCreateDate(new Date());
        order2.setUpdateDate(order2.getCreateDate());
        order2.setUserId(3L);
        List<OrderDetail> orderDetails2 = new ArrayList<OrderDetail>();

        Item item2 = new Item();// 此处并没有商品的数据,只是保存了商品ID,需要调用商品微服务获取
        item2.setId(3L);
        orderDetails2.add(new OrderDetail(order2.getOrderId(), item2));

        item2 = new Item(); // 构造第二个商品数据
        item2.setId(5L);
        orderDetails2.add(new OrderDetail(order2.getOrderId(), item2));
        order2.setOrderDetails(orderDetails2);
        ORDER_DATA.put(order2.getOrderId(), order2);
    }

    @Autowired
    private ItemService itemService;

    /**
     * 根据订单id查询订单数据
     *
     * @param orderId
     * @return
     */
    public Order queryOrderById(String orderId) {
        Order order = ORDER_DATA.get(orderId);
        if (null == order) {
            return null;
        }
        List<OrderDetail> orderDetails = order.getOrderDetails();
        for (OrderDetail orderDetail : orderDetails) {
            // 通过商品微服务查询商品详细数据
            Item item = this.itemService.queryItemById(orderDetail.getItem()
                    .getId());
            if (null == item) {
                continue;
            }
            orderDetail.setItem(item);
        }

        return order;
    }

}

7.5.指定服务的IP地址

在服务的提供者配置文件中可以指定ip地址,如下:

###服务注册到eureka注册中心的地址
eureka:
  client:
    service-url:
           defaultZone: http://zpc:123456@127.0.0.1:8100/eureka/,http://zpc:123456@127.0.0.1:9100/eureka/
###因为该应用为服务提供者,是eureka的一个客户端,需要注册到注册中心
    register-with-eureka: true
###是否需要从eureka上检索服务
    fetch-registry: true
  instance:
      prefer-ip-address: true #将自己的ip地址注册到Eureka服务中
      ip-address: 127.0.0.1

在这里插入图片描述

7.6.指定实例id

通过instance-id 参数指定服务注册到Eureka中的服务实例id:

eureka:
  client:
    service-url:
           defaultZone: http://zpc:123456@127.0.0.1:8100/eureka/,http://zpc:123456@127.0.0.1:9100/eureka/
###因为该应用为服务提供者,是eureka的一个客户端,需要注册到注册中心
    register-with-eureka: true
###是否需要从eureka上检索服务
    fetch-registry: true
  instance:
      prefer-ip-address: true #将自己的ip地址注册到Eureka服务中
      ip-address: 127.0.0.1
      instance-id: ${spring.application.name}###${server.port} #指定实例id

在这里插入图片描述

8.负载均衡:Ribbon

首先,我们思考一个问题,如果为同一个的提供者在Eureka中注册了多个服务,那么客户端该如何选择服务呢?

这时,就需要在客户端实现服务的负载均衡。

在SpringCloud中推荐使用Ribbon来实现负载均衡。

8.1.Ribbon简介

在这里插入图片描述

8.2.架构

在这里插入图片描述

8.3.开始使用SpringCloud Ribbon

8.3.1.为microservice order增加ribbon依赖
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>

其实,该依赖是可以省略的,因为spring-cloud-starter-netflix-eureka-client中已经包含了spring-cloud-starter-netflix-ribbon:
在这里插入图片描述

8.3.2.为RestTemplate设置@LoadBalanced注解
package com.zpc.order.runner;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.http.client.OkHttp3ClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

/**
 * @author Evan
 */
@SpringBootApplication//申明这是一个Spring Boot项目
@EnableEurekaClient
@ComponentScan(basePackages = {"com.zpc.order.controller", "com.zpc.order.service","com.zpc.order.properties"})//手动指定bean扫描范围
public class OrderApp {
    public static void main(String[] args) {
        SpringApplication.run(OrderApp.class, args);
    }

    /**
     * 向Spring容器中定义RestTemplate对象
     * @return
     */
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate(new OkHttp3ClientHttpRequestFactory());
    }

}

这样,RestTemplate就具备了负载均衡的功能。

8.3.3.改造ItemService的实现

之前的实现(其实本教程前面没有用这种方式):

public Item queryItemById(Long id) {
    String serviceId = "app-item";
    List<ServiceInstance> instances = this.discoveryClient.getInstances(serviceId);
    if(instances.isEmpty()){
        return null;
    }
    // 为了演示,在这里只获取第一个实例
    ServiceInstance serviceInstance = instances.get(0);
    String url = serviceInstance.getHost() + ":" + serviceInstance.getPort();
    return this.restTemplate.getForObject("http://" + url + "/item/" + id, Item.class);
}

改造后的实现(其实本教程一直采用的是这种方式):

public Item queryItemById(Long id) {
    // 该方法走eureka注册中心调用(这种方式必须先开启负载均衡@LoadBalanced)
    String itemUrl = "http://app-item/item/{id}";
    Item result = restTemplate.getForObject(itemUrl, Item.class, id);
    System.out.println("订单系统调用商品服务,result:" + result);
    return result;
}

可以发现,实现更加简化了。
这种方式关键在于获取RestTemplat对象时要加上@LoadBalanced注解 ,否则restTemplate.getForObject方法会报java.net.UnknownHostException: app-item,而前面一种方式是手动指定了获取的服务实例,不需要加此注解。

8.3.4.重启订单服务进行测试

测试结果:
在这里插入图片描述

结果显示,可以正常获取到商品数据。

内部原理(可以启动多个item实例看效果,比如端口分别设为8081,8091,在下面2个类里打断点):
org.springframework.cloud.client.loadbalancer.LoadBalancerInterceptor
在这里插入图片描述
org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient
在这里插入图片描述

在执行请求前会经过org.springframework.cloud.client.loadbalancer.LoadBalancerInterceptor这个拦截器,并且在org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient中,通过serverId查找服务地址,通过一定的负载均衡策略去做真正的请求。

8.3.5.测试负载均衡

测试方法:
第一步,启动2个microservice-item服务(多个也可以)
在这里插入图片描述
第二步,导入测试依赖,编写单元测试用例:

<!-- 引入SpringBoot的单元测试 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
</dependency>

第三步,编写测试用例:

package com.zpc.test;

import com.zpc.order.runner.OrderApp;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.context.annotation.Import;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = ItemServiceTest.class)
@Import(OrderApp.class)
public class ItemServiceTest {

    @Autowired
    private LoadBalancerClient loadBalancerClient;//自动注入

    @Test
    public void test() {
        String serviceId = "app-item";
        for (int i = 0; i < 100; i++) {
            ServiceInstance serviceInstance = this.loadBalancerClient.choose(serviceId);
            System.out.println("第" + (i + 1) + "次:" + serviceInstance.getHost() + ": " + serviceInstance.getPort());
        }
    }

}

测试结果:
第1次:127.0.0.1: 8091
第2次:127.0.0.1: 8081
第3次:127.0.0.1: 8091
第4次:127.0.0.1: 8081
第5次:127.0.0.1: 8091
第6次:127.0.0.1: 8081
第7次:127.0.0.1: 8091
第8次:127.0.0.1: 8081
第9次:127.0.0.1: 8091
第10次:127.0.0.1: 8081
第11次:127.0.0.1: 8091
第12次:127.0.0.1: 8081
第13次:127.0.0.1: 8091
第14次:127.0.0.1: 8081
第15次:127.0.0.1: 8091
第16次:127.0.0.1: 8081
第17次:127.0.0.1: 8091
第18次:127.0.0.1: 8081
第19次:127.0.0.1: 8091
第20次:127.0.0.1: 8081
第21次:127.0.0.1: 8091
第22次:127.0.0.1: 8081
第23次:127.0.0.1: 8091
第24次:127.0.0.1: 8081
第25次:127.0.0.1: 8091
第26次:127.0.0.1: 8081
第27次:127.0.0.1: 8091
第28次:127.0.0.1: 8081
第29次:127.0.0.1: 8091
第30次:127.0.0.1: 8081
第31次:127.0.0.1: 8091
第32次:127.0.0.1: 8081
第33次:127.0.0.1: 8091
第34次:127.0.0.1: 8081
第35次:127.0.0.1: 8091
第36次:127.0.0.1: 8081
第37次:127.0.0.1: 8091
第38次:127.0.0.1: 8081
第39次:127.0.0.1: 8091
第40次:127.0.0.1: 8081

或者在应用程序里测试,比如在item微服务里打印端口信息,这样多启动几个item服务,多次请求可以看到效果:

package com.zpc.item.controller;

import com.zpc.item.entity.Item;
import com.zpc.item.service.ItemService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author Evan
 */
@RestController
public class ItemController {

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

    @Autowired
    private ItemService itemService;

    /**
     * 对外提供接口服务,查询商品信息
     *
     * @param id
     * @return
     */
    @GetMapping(value = "item/{id}")
    public Item queryItemById(@PathVariable("id") Long id) {
        System.out.println("service port:"+port);
        return this.itemService.queryItemById(id);
    }

}

8.4.设置负载均衡策略

只需要在配置文件中添加配置
serviceId.ribbon.NFLoadBalancerRuleClassName=自定义的负载均衡策略类

例如在order微服务的yml配置文件中添加:

app-item:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

其中app-item是要访问的服务id

测试:
第1次:127.0.0.1: 8081
第2次:127.0.0.1: 9081
第3次:127.0.0.1: 9081
第4次:127.0.0.1: 8081
第5次:127.0.0.1: 9081
第6次:127.0.0.1: 8081
第7次:127.0.0.1: 9081
第8次:127.0.0.1: 9081
第9次:127.0.0.1: 8081
第10次:127.0.0.1: 8081
第11次:127.0.0.1: 8081
第12次:127.0.0.1: 8081
第13次:127.0.0.1: 8081
第14次:127.0.0.1: 9081
第15次:127.0.0.1: 9081
第16次:127.0.0.1: 9081
第17次:127.0.0.1: 8081
第18次:127.0.0.1: 9081
第19次:127.0.0.1: 8081
第20次:127.0.0.1: 8081

8.5.其它策略

接口:com.netflix.loadbalancer.IRule,其实现类:
在这里插入图片描述
策略描述:
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

9.容错保护:Hystrix

9.1.分析

在这里插入图片描述
在这里插入图片描述

9.2.雪崩效应

  • 在微服务架构中通常会有多个服务层调用,基础服务的故障可能会导致级联故障,进而造成整个系统不可用的情况,这种现象被称为服务雪崩效应。服务雪崩效应是一种因“服务提供者”的不可用导致“服务消费者”的不可用,并将不可用逐渐放大的过程。

  • 如果下图所示:A作为服务提供者,B为A的服务消费者,C和D是B的服务消费者。A不可用引起了B的不可用,并将不可用像滚雪球一样放大到C和D时,雪崩效应就形成了。

在这里插入图片描述

9.3.SpringCloud Hystrix简介

主页:https://github.com/Netflix/Hystrix/

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

9.4.原理说明

正常情况:
在这里插入图片描述
在这里插入图片描述
当对特定服务的呼叫达到一定阈值时(Hystrix中的默认值为5秒内的20次故障),电路打开,不进行通讯。并且是一个隔离的线程中进行的。

9.5.快速入门

在 microservice-order系统中增加Hystrix容错(本教程中order微服务工程主要扮演消费者的角色)。

9.5.1.导入依赖
<!--整合hystrix-->
<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>
9.5.2.修改ItemService的queryItemById方法

在要做容错处理的方法上加@HystrixCommand注解,并指定一个容错方法,即fallbackMethod 。

/**
 * 进行容错处理
 * fallbackMethod的方法参数个数类型要和原方法一致
 *
 * @param id
 * @return
 */
@HystrixCommand(fallbackMethod = "queryItemByIdFallbackMethod")
public Item queryItemById3(Long id) {
    String itemUrl = "http://app-item/item/{id}";
    Item result = restTemplate.getForObject(itemUrl, Item.class, id);
    System.out.println("===========HystrixCommand queryItemById-线程池名称:" + Thread.currentThread().getName() + "订单系统调用商品服务,result:" + result);
    return result;
}

/**
 * 请求失败执行的方法
 * fallbackMethod的方法参数个数类型要和原方法一致
 *
 * @param id
 * @return
 */
public Item queryItemByIdFallbackMethod(Long id) {
    return new Item(id, "查询商品信息出错!", null, null, null);
}
9.5.3.在启动类OrderApplication添加@EnableHystrix注解
/**
 * @author Evan
 */
@SpringBootApplication
@EnableEurekaClient
@EnableHystrix
@ComponentScan(basePackages = {"com.zpc.order.controller", "com.zpc.order.service","com.zpc.order.properties"})//手动指定bean扫描范围
public class OrderApp {
    public static void main(String[] args) {
        SpringApplication.run(OrderApp.class, args);
    }

    /**
     * 向Spring容器中定义RestTemplate对象
     * @return
     */
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate(new OkHttp3ClientHttpRequestFactory());
    }

}
9.5.4.在Controller增加一个入口
package com.zpc.order.controller;

import com.zpc.order.entity.Order;
import com.zpc.order.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class OrderController {
    @Autowired
    private OrderService orderService;

    @GetMapping(value = "order/{orderId}")
    public Order queryOrderById(@PathVariable("orderId") String orderId) {
        return this.orderService.queryOrderById(orderId);
    }

    @GetMapping(value = "order2/{orderId}")
    public Order queryOrderById2(@PathVariable("orderId") String orderId) {
        return this.orderService.queryOrderByIdx(orderId);
    }
}

OrderService中增加:

public Order queryOrderByIdx(String orderId) {
    Order order = ORDER_DATA.get(orderId);
    if (null == order) {
        return null;
    }
    List<OrderDetail> orderDetails = order.getOrderDetails();
    for (OrderDetail orderDetail : orderDetails) {
        // 通过商品微服务查询商品详细数据
        Item item = this.itemService.queryItemById3(orderDetail.getItem()
                .getId());
        if (null == item) {
            continue;
        }
        orderDetail.setItem(item);
    }

    return order;
}
9.5.5.重新启动进行测试

http://localhost:8082/order/201810300001
http://localhost:8082/order2/201810300001
在这里插入图片描述

测试一切正常。可以发现加了@HystrixCommand注解的方法和普通方法不是共用的线程池,是隔离的:
在这里插入图片描述

接下来,我们把商品服务停止进行测试:

在这里插入图片描述

  • 可以看到,使用了hystrix容错机制时订单服务(app-order)正常,尽管查询商品服务(app-item)已停止服务,查询到的是错误信息。

  • 由此可见,商品服务的宕机并没有影响订单服务的正常工作,起到的容错效果。

如果调用没有做Hytrix容错的方法,则直接返回异常信息:
在这里插入图片描述

9.6.定义统一的fallback接口

        如果在每个方法里都定义对应的fallback方法,显得太臃肿,实际项目中可以单独使用一个类定义各种fallback,在使用feign客户端时使用统一fallback接口。
详情请见本教程的姊妹篇 Spring cloud详细教程2 :介绍了其它SpringCloud组件。

欢迎关注公众号「程猿薇茑」
微信扫一扫
<p style="color:#333333;"> <strong> </strong> </p> <p style="font-family:"color:#222226;font-size:14px;background-color:#FFFFFF;"> <strong><span style="color:#337FE5;">[为什么要学习Spring Cloud微服务]</span> </strong> </p> <p style="font-family:"color:#222226;font-size:14px;background-color:#FFFFFF;"> <strong><span style="color:#4D555D;"></span> </strong> </p> <p class="ql-long-24357476" style="font-family:"color:#222226;font-size:14px;background-color:#FFFFFF;"> <strong><span style="font-family:"background-color:#FFFFFF;">SpringCloud作为主流微服务框架,<span style="color:#4D555D;">已成为各互联网公司的首选框架,国内外企业占有率持续攀升,</span>是Java工程师的必备技能。</span><span style="font-family:"background-color:#FFFFFF;">就连大名鼎鼎的阿里巴巴</span><span style="font-family:"background-color:#FFFFFF;">dubbo</span><span style="font-family:"background-color:#FFFFFF;">也正式更名为</span><span style="font-family:"background-color:#FFFFFF;">Spring Cloud Alibaba</span><span style="font-family:"background-color:#FFFFFF;">,成为了</span><span style="font-family:"background-color:#FFFFFF;">Spring Cloud </span><span style="font-family:"background-color:#FFFFFF;">微服务中的一个子模块。</span><span style="font-family:"background-color:#FFFFFF;"></span><span style="font-family:"background-color:#FFFFFF;">Spring Cloud是企业架构转型、个人能力提升、架构师进阶的不二选择。</span> </strong> </p> <p style="color:#333333;"> <strong><strong><br /> </strong> </strong> </p> <strong><span style="font-family:"color:#337FE5;font-size:14px;background-color:#FFFFFF;">【推荐你学习这门课的理由】</span><br /> </strong> <p> <br /> </p> <p> <span>1、</span><span style="color:#222226;font-family:"font-size:14px;background-color:#FFFFFF;">本课程总计</span><span style="background-color:#FFFFFF;">29</span><span style="color:#222226;font-family:"font-size:14px;background-color:#FFFFFF;">课时,<span style="color:#333333;">从微服务是什么、能够做什么开始讲起,绝对的零基础入门</span></span><span></span> </p> <p> <span style="background-color:#FFFFFF;">2、<span style="color:#333333;">课程附带全部26个项目源码,230页高清PDF正版课件</span><span style="color:#333333;"></span></span> </p> <p> <span style="background-color:#FFFFFF;"><b><br /> </b></span> </p> <p> <span style="background-color:#FFFFFF;"><b><span style="color:#337FE5;">【课程知识梳理】</span></b></span> </p> <p> <span style="background-color:#FFFFFF;"><b>1、</b></span><span style="color:#333333;">先讲解了什么是单体架构、什么是微服务架构、他们之间有什么区别和联系,各自有什么优缺点。</span> </p> <p> <span style="color:#333333;">2、</span><span style="color:#333333;">从本质入手,使用最简单的Spring Boot搭建微服务,让你认清微服务是一种思想和解决问题的手段,而不是新兴技术。</span> </p> <p style="color:#333333;"> 3、讲解Spring Boot 与Spring Cloud 微服务架构之间的联系,原生的RestTemplate工具,以及Actuator监控端点的使用。 </p> <p style="color:#333333;"> 4、带着微服务所带来的各种优缺点,为大家引入服务发现与注册的概念和原理,从而引入我们的第一个注册中心服务Eureka。 </p> <p style="color:#333333;"> 5、引入负载均衡的理念,区分什么是服务端负载均衡,什么是客户端负载均衡,进而引入Ribbon负载均衡组件的详细使用。 </p> <p style="color:#333333;"> 6、为了解决微服务之间复杂的调用,降低代码的复杂度,我们引入了Feign声明式客户端,让你几行代码搞定服务的远程调用。 </p> <p style="color:#333333;"> 7、最后为大家介绍了整个微服务体系应该包含什么,学习路线是什么,应该学习什么。 </p> <p style="color:#333333;"> <strong><br /> </strong> </p> <p style="color:#333333;"> <strong><span style="color:#337FE5;">【</span><strong><span style="color:#337FE5;">学习方法</span></strong><span style="color:#337FE5;"></span><span style="color:#337FE5;">】</span></strong> </p> <p style="color:#333333;"> 每一节课程均有代码,最好的方式是静下心来,用一天的时间,或者两个半天时间来学习。 </p> <p style="color:#333333;"> 一边听我的讲解,一边使用我提供的项目代码进行观察和运行。 </p> <p style="color:#333333;"> 只要你能跟住我的节奏,你就可以搞定微服务。 </p> <br />
相关推荐
<p> <span style="color:#337fe5;"><strong> </strong></span> </p> <p class="MsoNormal"> <span style="color:#000000;font-size:16px;">本课程总计13大章节,115课时,是一门全面的SpringCloud微服务体系化课程。课程共包括</span><span style="color:#000000;font-size:16px;">十三个大章节,涵盖注册中心、网关、熔断、降级、监控、安全、限流等全部体系。</span><span style="color:#000000;font-size:16px;">包含阿里巴巴Nacos,Consul,Spring Cloud Gateway,OAuth2.0 JWT 等主流技术。</span> </p> <p class="MsoNormal"> <span style="color:#000000;font-size:16px;"> </span> </p> <p>   </p> <p> <span style="color:#337fe5;"><strong>[为什么要学习Spring Cloud微服务]</strong></span> </p> <p> <span style="color:#4d555d;"> </span> </p> <p class="ql-long-24357476" style="font-family:"color:#222226;font-size:14px;background-color:#ffffff;"> <span style="font-family:"background-color:#FFFFFF;"><span style="font-size:12px;">SpringCloud作为主流微服务框架,</span><span style="color:#4d555d;font-family:"background-color:#FFFFFF;font-size:12px;">已成为各互联网公司的首选框架,国内外企业占有率持续攀升,</span><span style="font-size:12px;">是Java工程师的必备技能。</span></span><span style="font-family:"background-color:#FFFFFF;font-size:12px;">就连大名鼎鼎的阿里巴巴</span><span style="font-family:"background-color:#FFFFFF;font-size:12px;">dubbo</span><span style="font-family:"background-color:#FFFFFF;font-size:12px;">也正式更名为</span><span style="font-family:"background-color:#FFFFFF;font-size:12px;">Spring Cloud Alibaba</span><span style="font-family:"background-color:#FFFFFF;font-size:12px;">,成为了</span><span style="font-family:"background-color:#FFFFFF;font-size:12px;">Spring Cloud </span><span style="font-family:"background-color:#FFFFFF;font-size:12px;">微服务中的一个子模块。</span><span style="font-family:"background-color:#FFFFFF;font-size:12px;">Spring Cloud是企业架构转型、个人能力提升、架构师进阶的不二选择。</span><span style="font-family:"background-color:#FFFFFF;"> </span> </p> <p class="ql-long-8780922" style="font-size:11pt;color:#494949;">   </p> <p class="ql-long-8780922" style="font-size:11pt;color:#494949;">   </p> <p class="ql-long-24357476" style="font-family:"color:#222226;font-size:14px;background-color:#ffffff;"> <span style="color:#337fe5;"><strong>【推荐你学习这门课的理由:<span style="color:#e53333;">知识体系完整+丰富学习资料】</span></strong></span> </p> <p class="ql-long-24357476" style="font-family:"color:#222226;font-size:14px;background-color:#ffffff;">   </p> <p class="MsoNormal"> 1、本课程总计13大章节,115课时,是一门全面的SpringCloud微服务体系化课程。 </p> <p class="MsoNormal"> 2、课程0基础入门,逐层递进深入,理论和代码相结合。 </p> <p class="MsoNormal"> 3、十三个大章节,涵盖注册中心、网关、熔断、降级、监控、安全、限流等全部体系。 </p> <p class="MsoNormal"> 4、包含阿里巴巴Nacos,Consul,Spring Cloud Gateway,OAuth2.0 JWT 主流技术。 </p> <p style="background:white;"> 5、课程附带230页高清PDF正版课件、Hoxton版本配套项目源码37个、Edgware版本配套项目26个,所有代码均有详细注释。 </p> <p>   </p> <p class="MsoNormal">   </p> <p> <span style="color:#337fe5;">【主讲讲师】</span> </p> <p> <span style="color:#337fe5;"><span style="color:#000000;">尹洪亮Kevin:</span><br /> <span style="color:#000000;">现任职某互联网公司首席架构师,负责系统架构、项目群管理、产品研发工作。</span><br /> <span style="color:#000000;">10余年软件行业经验,具有数百个线项目实战经验。</span><br /> <span style="color:#000000;">擅长JAVA技术栈、高并发高可用伸缩式微服务架构、DevOps。</span><br /> <span style="color:#000000;">主导研发的蜂巢微服务架构已经成功支撑数百个微服务稳定运行</span></span> </p> <p> <span style="color:#337fe5;"><span style="color:#000000;"> </span></span> </p> <p>   </p> <p class="ql-long-24357476" style="font-family:"color:#222226;font-size:14px;background-color:#ffffff;"> <span style="color:#337fe5;"><strong>【学完后我将达到什么水平?】</strong></span> </p> <p class="MsoNoSpacing" style="margin-left:18.0pt;text-indent:-18.0pt;"> 1、 对Spring Cloud的各个组件能够熟练配置、开发、部署。 </p> <p class="MsoNoSpacing" style="margin-left:18.0pt;text-indent:-18.0pt;"> 2、 吊打一切关于Spring Cloud微服务的笔试面试题 </p> <p class="MsoNoSpacing" style="margin-left:18.0pt;text-indent:-18.0pt;"> 3、 能够手搭建十分完整的微服务分布式系统,涵盖服务注册与发现、负载、网关、配置中心、监控、安全、熔断等。 </p> <p class="MsoNoSpacing" style="margin-left:18.0pt;text-indent:-18.0pt;"> 4、 对整个微服务体系架构有十分清晰准确的掌握。 </p> <p>   </p> <p class="ql-long-24357476"> <span style="font-family:""> </span> </p> <p class="MsoListParagraph" style="margin-left:36pt;text-indent:-36pt;" align="left"> <strong><span style="color:#337fe5;">【</span><span style="color:#337fe5;">面向人群</span><span style="color:#337fe5;">】</span></strong> </p> <p class="MsoListParagraph" style="margin-left:18.0pt;text-indent:-18.0pt;"> 1、 <span style="color:#4d555d;">不了解微服务是什么,</span>感觉微服务很难、不敢学,<span style="color:#4d555d;">网资料松散,</span>没有好的学习资料 </p> <p class="MsoListParagraph" style="margin-left:18.0pt;text-indent:-18.0pt;"> 2、 这么多年还一直在写SSH、SSM项目,没有更新过自己的知识体系。 </p> <p class="MsoListParagraph" style="margin-left:18.0pt;text-indent:-18.0pt;"> 3、 Spring Cloud组件太多,不知道应该重点关注和学习哪些。 </p> <p class="MsoListParagraph" style="margin-left:18.0pt;text-indent:-18.0pt;"> 4、 不会搭建微服务项目、依赖项目太多、完全搞不清楚。 </p> <p class="MsoListParagraph" style="margin-left:18.0pt;text-indent:-18.0pt;">   </p> <p class="MsoListParagraph" style="margin-left:18.0pt;text-indent:-18.0pt;"> <span style="color:#337fe5;"><strong>【课程知识体系图】</strong></span> </p> <p class="MsoListParagraph" style="margin-left:18.0pt;text-indent:-18.0pt;"> <span style="color:#337fe5;"><strong><img src="https://img-bss.csdnimg.cn/202007100719132383.png" alt="" /><br /> </strong></span> </p>
<p style="color:rgb(66,66,66);font-size:14px;"><strong><span style="color:rgb(112,48,160);">SpringCloud是目前流行的微服务框架,在各大互联网公司都有广泛的应用,同时在企业招聘面试时也会要求对微服务技术栈有所了解和掌握。SpringCloud是一套完整的微服务解决方案,基于SpringBoot框架。</span></strong> </p> <p style="color:rgb(66,66,66);font-size:14px;"><br /></p> <p style="color:rgb(66,66,66);font-size:14px;"><span style="color:rgb(255,0,0);"><strong><span>本课程以通俗易懂的方式讲解SpringCloud技术栈,由浅入深,帮您快速入</span></strong><span><strong><span>门!<span><strong><span>详细讲解了SpringCloud的五大核心组件,同时准备了SpringCloud的案例项目,全面提升微服务的编程功底!</span></strong></span></span></strong></span></span> </p> <p style="color:rgb(66,66,66);font-size:14px;"><span style="color:rgb(255,0,0);"><span><strong><span><span><strong><span><img src="https://img-bss.csdn.net/202003281323408232.png" alt="" /><br /></span></strong></span></span></strong></span></span> </p> <p style="color:rgb(66,66,66);font-size:14px;"><span style="color:rgb(255,0,0);"><span><strong><span><span><strong><span><br /></span></strong></span></span></strong></span></span> </p> <p style="color:rgb(66,66,66);font-size:14px;"><span style="color:rgb(255,0,0);"><span><strong><span><span><strong><span><br /></span></strong></span></span></strong></span></span> </p> <p style="color:rgb(66,66,66);font-size:14px;"><span style="color:rgb(255,0,0);"><span><strong><span><span><strong><span><span style="color:#FF0000;font-size:14px;">教学全程采用</span><span style="color:rgb(0,176,80);font-size:14px;">笔记+代码案例</span><span style="color:#FF0000;font-size:14px;">的形式讲解,每个知识点都有详细的讲解,通俗易懂!!!</span></span></strong></span></span></strong></span></span> </p> <p style="color:rgb(66,66,66);font-size:14px;"><span style="color:rgb(255,0,0);"><span><strong><span><span><strong><span><br /></span></strong></span></span></strong></span></span> </p> <p style="color:rgb(66,66,66);font-size:14px;"><span style="color:rgb(255,0,0);"><span><strong><span><span><strong><span><img src="https://img-bss.csdn.net/202003281329173164.png" alt="" /><br /></span></strong></span></span></strong></span></span> </p> <p style="color:rgb(66,66,66);font-size:14px;"><span style="color:rgb(255,0,0);"><span><strong><span><span><strong><span><br /></span></strong></span></span></strong></span></span> </p> <p style="color:rgb(66,66,66);font-size:14px;"><span style="color:rgb(255,0,0);"><span><strong><span><span><strong><span><span style="color:#FF0000;">部分讲义截图:</span></span></strong></span></span></strong></span></span> </p> <p style="color:rgb(66,66,66);font-size:14px;"><span style="color:rgb(255,0,0);"><span><strong><span><span><strong><span><br /></span></strong></span></span></strong></span></span> </p> <p style="color:rgb(66,66,66);font-size:14px;"><span style="color:rgb(255,0,0);"><span><strong><span><span><strong><span><img src="https://img-bss.csdn.net/202003281329395213.png" alt="" /></span></strong></span></span></strong></span></span> </p> <p style="color:rgb(66,66,66);font-size:14px;"><span style="color:rgb(255,0,0);"><span><strong><span><span><strong><span><br /></span></strong></span></span></strong></span></span> </p> <p style="color:rgb(66,66,66);font-size:14px;"><span style="color:rgb(255,0,0);"><span><strong><span><span><strong><span><img src="https://img-bss.csdn.net/202003281329504761.png" alt="" /></span></strong></span></span></strong></span></span> </p> <p style="color:rgb(66,66,66);font-size:14px;"><span style="color:rgb(255,0,0);"><span><strong><span><span><strong><span><br /></span></strong></span></span></strong></span></span> </p> <p style="color:rgb(66,66,66);font-size:14px;"><span style="color:rgb(255,0,0);"><span><strong><span><span><strong><span><img src="https://img-bss.csdn.net/202003281330015286.png" alt="" /><br /></span></strong></span></span></strong></span></span> </p>
<p> <strong><span style="color:#7030A0;font-size:16px;">SpringCloud是目前流行的微服务框架,在各大互联网公司都有广泛的应用,同时在企业招聘面试时也会要求对微服务技术栈有所了解和掌握。SpringCloud是一套完整的微服务解决方案,基于SpringBoot框架。</span></strong> </p> <p> <br /> </p> <p> <span style="font-size:16px;color:#FF0000;"><strong><span style="font-size:18px;">本课程以通俗易懂的方式讲解SpringCloud技术栈,由浅入深,帮您快速入</span></strong><span style="font-size:18px;"><strong><span style="font-size:18px;">门!</span></strong></span></span> </p> <p> <span style="font-size:16px;color:#FF0000;"><br /> </span> </p> <p> <strong><span style="font-size:16px;">课程内容包括:</span></strong> </p> <p> <span style="font-size:16px;">1<span style="font-size:16px;">. 微服务简介</span></span> </p> <p> <span style="font-size:16px;">2. SpringCloud技术栈</span> </p> <p> <span style="font-size:16px;">3. Restful API简介和设计原则</span> </p> <p> <span style="font-size:16px;">4. Restful API用法</span> </p> <p> <span style="font-size:16px;">5. 使用Postman测试接口</span> </p> <p> <span style="font-size:16px;">6. 使用Swagger2生成API文档</span> </p> <p> <span style="font-size:16px;">7. Eureka注册中心</span> </p> <p> <span style="font-size:16px;"><span style="font-size:16px;">8. </span><span style="font-size:16px;">Feign客户端</span></span> </p> <p> <span style="font-size:16px;">9. Hystrix断路器</span> </p> <p> <span style="font-size:16px;">10. Zuul网关</span> </p> <p> <span style="font-size:16px;">11. Ribbon负载均衡</span> </p> <p> <span style="font-size:16px;">12. 微服务的面试题</span> </p> <p> <br /> </p> <p> <br /> </p> <p> <span style="font-size:18px;"><strong><span style="color:#FF0000;">教学全程采用<span style="font-size:20px;color:#00B050;">笔记+代码案例</span>的形式讲解,每个知识点都有详细的讲解,通俗易懂!!!</span></strong></span> </p> <p> <br /> </p> <p> <img src="https://img-bss.csdn.net/201912191421361425.png" alt="" /> </p> <p> <br /> </p> <p> <img src="https://img-bss.csdn.net/201912191421501561.png" alt="" /> </p> <p> <br /> </p> <p> <img src="https://img-bss.csdn.net/201912191422071317.png" alt="" /> </p> <p> <br /> </p> <p> <img src="https://img-bss.csdn.net/201912191422176568.png" alt="" /> </p> <p> <br /> </p> <p> <img src="https://img-bss.csdn.net/201912191422296123.png" alt="" /> </p> <p> <br /> </p> <p> <img src="https://img-bss.csdn.net/201912191422419349.png" alt="" /> </p> <p> <br /> </p> <p> <br /> </p> <p> <span style="font-size:16px;"><strong><strong><strong>讲师介绍</strong></strong></strong><strong><strong><strong></strong></strong></strong><strong><strong></strong></strong></span> </p> <p> <img src="https://img-bss.csdn.net/201912191423463144.jpg" alt="" /> </p>
©️2020 CSDN 皮肤主题: 博客之星2020 设计师:CY__ 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值