Spring Boot笔记-Spring Boot与分布式（十四）

1.分布式应用

随着项目的不断完善，用户量上升，请求变多，在一台机器扛不住这么多的请求，此时，就需要用到分布式，将系统中的模块划分到多台机器上，每个模块做集群部署。此时就能扛得住更高的请求。假设有用户模块和订单模块，它们都做了分布式和集群部署，假设用户模块有5台机器，订单模块有5台机器，那么，用户模块调用订单模块，找哪台订单模块的机器呢？按照什么规则分发请求呢？这就是一个问题。此时，就需要用到Zookeeper和Dubbo。

在分布式系统中，国内常用的是Zookeeper+Dubbo的组合，如果使用了Spring Boot，推荐使用全栈的Spring，也就是Spring Boot+Spring Cloud。

• 单一应用架构

当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。此时，用于简化增删改查工作量的数据访问框架(ORM)是关键。

• 垂直应用架构

当访问量逐渐增大，单一应用增加机器带来的加速度越来越小，将应用拆成互不相干的几个应用，以提升效率。此时，用于加速前端页面开发的Web框架(MVC)是关键。

• 分布式服务架构

当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。此时，用于提高业务复用及整合的分布式服务框架(RPC)是关键。

• 流动计算架构

当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。此时，用于提高机器利用率的资源调度和治理中心(SOA)是关键。

2.Zookeeper和Dubbo

1.Zookeeper和Dubbo介绍

• Zookeeper是服务注册中心

ZooKeeper 是一个分布式的，开放源码的分布式应用程序协调服务。它是一个为分布式应用提供一致性服务的软件，提供的功能包括：配置维护、域名服务、分布式同步、组服务等。

• Dubbo是分布式服务框架

Dubbo是Alibaba开源的分布式服务框架，它最大的特点是按照分层的方式来架构，使用这种方式可以使各个层之间解耦合（或者最大限度地松耦合）。从服务模型的角度来看，Dubbo采用的是一种非常简单的模型，要么是提供方提供服务，要么是消费方消费服务，所以基于这一点可以抽象出服务提供方（Provider）和服务消费方（Consumer）两个角色。

2.搭建项目测试

使用命令：docker pull zookeeper下载Zookeeper镜像。

使用命令：docker run -d -p 2181:2181 -p 2888:2888 -p 3888:3888 --restart always zookeeper运行Zookeeper。

在idea中创建空的工程，添加Spring Boot的Module，Artifact为ticket-provider，加入Spring Web依赖。添加Provider.java文件，作为Ticket的生产者，用于提供Ticket。

package com.atguigu.provider.service;

public interface Provider {
    String getTicket();
}

添加Spring Boot的Module，Artifact为ticket-consumer，加入Spring Web依赖，添加Spring Web依赖。

要想发布服务，需要有Dubbo和Zookeeper，在provider的pom文件中加入相应依赖。

<dependency>
	<groupId>com.alibaba.boot</groupId>
	<artifactId>dubbo-spring-boot-starter</artifactId>
	<version>0.2.0</version>
</dependency>
<dependency>
	<groupId>com.github.sgroschupf</groupId>
	<artifactId>zkclient</artifactId>
	<version>0.1</version>
</dependency>

在yml中添加dubbo的配置。

dubbo:
  application:
    # 当前应用的名称
    name: ticket-provider
  # 注册中心的地址，就是Zookeeper的地址
  registry:
    address: zookeeper://192.168.0.123:2181
  # 服务扫描包
  scan:
    base-packages: com.atguigu.provider.service

添加ProviderImpl.java，将服务暴露出去，注意这里加入的两个@Service注解，分别来自不同的包，所以要把包名带上。

package com.atguigu.provider.service;

// 加入Spring的Service，将service加入Spring容器
@org.springframework.stereotype.Service
// 需要将服务发布出去，这里的@Service是com.alibaba.dubbo包下的
@com.alibaba.dubbo.config.annotation.Service
public class ProviderImpl implements Provider {
    @Override
    public String getTicket() {
        return "《肖申克的救赎》";
    }
}

在Provider项目的主启动类上加上@EnableDubbo注解，否则，后面会报错。启动Provider项目发布服务，在控制台可以看到如下内容，表示发布成功了。

2020-05-10 09:46:01.874  INFO 5756 --- [168.0.123:2181)] org.apache.zookeeper.ClientCnxn          : Opening socket connection to server 192.168.0.123/192.168.0.123:2181. Will not attempt to authenticate using SASL (unknown error)
2020-05-10 09:46:01.876  INFO 5756 --- [168.0.123:2181)] org.apache.zookeeper.ClientCnxn          : Socket connection established to 192.168.0.123/192.168.0.123:2181, initiating session
2020-05-10 09:46:01.883  INFO 5756 --- [168.0.123:2181)] org.apache.zookeeper.ClientCnxn          : Session establishment complete on server 192.168.0.123/192.168.0.123:2181, sessionid = 0x100000048130004, negotiated timeout = 40000
2020-05-10 09:46:01.964  INFO 5756 --- [ain-EventThread] o.a.c.f.state.ConnectionStateManager     : State change: CONNECTED

再修改Consumer项目的pom.xml文件，同样是引入依赖。

<dependency>
	<groupId>com.alibaba.boot</groupId>
	<artifactId>dubbo-spring-boot-starter</artifactId>
	<version>0.2.0</version>
</dependency>
<dependency>
	<groupId>com.github.sgroschupf</groupId>
	<artifactId>zkclient</artifactId>
	<version>0.1</version>
</dependency>

配置Consumer项目的yml文件。

dubbo:
  # 当前应用的名称
  application:
    name: ticket-consumer
  # 注册中心地址，就是Zookeeper的地址
  registry:
    address: zookeeper://192.168.0.123:2181

在Consumer下创建一个Provider.java的接口，用于调用。

package com.atguigu.provider.service;

public interface Provider {
    String getTicket();
}

添加消费者类，调用生产者的服务。

package com.atguigu.consumer.service;

import com.alibaba.dubbo.config.annotation.Reference;
import com.atguigu.provider.service.Provider;
import org.springframework.stereotype.Service;

@Service
public class Consumer {
    // @Reference是dubbo包下的，根据全类名来查找
    @Reference
    Provider provider;
    
    public void rpc() {
        System.out.println(provider.getTicket());
    }
}

在消费者的主启动类上加上@EnableDubbo注解，编写测试类测试。

package com.atguigu.consumer;

import com.atguigu.consumer.service.Consumer;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class TicketConsumerApplicationTests {
    @Autowired
    Consumer consumer;

    @Test
    void contextLoads() {
        consumer.rpc();
    }
}

先启动Producer的主启动类，向Zookeeper发布服务，再启动测试类进行测试，发现可以调用成功。

3.Dubbo-Admin的使用

这块是我自己添加上的，如果前面的测试出问题，可以用Dubbo-Admin查看一下，是不是服务没有组成成功。

首先，在https://github.com/apache/dubbo-admin/tree/master地址下载项目，解压后，用idea打开其中的dubbo-admin项目。打开配置文件，稍作修改。将dubbo.registry.address的值改为虚拟机的Zookeeper的地址，这里我改成zookeeper://192.168.0.123:2181。留意一下server.port的值，我这里是7001，也就是Tomcat的启动端口，别和其他地方冲突了。启动Dubbo-Admin的主启动类，访问http://localhost:7001/，会提示输入密码，通过配置文件可知，输入root-root就可以进入到Dubbo-Admin了。

找到“服务治理”-“服务”，此时里面是没有服务的，我们将Provider的主启动类启动起来，再次查看“服务治理”-“服务”，可以发现已经有服务了，（如果没有，说明注册失败了），点击机器IP下面的链接，跳转到提供者的详细信息，此时还没有消费者。

为了方便看到消费者，我们在测试类后面加一个Thread.sleep()，执行测试方法，点击“消费者”标签，可以看到提供者的信息。

3.Spring Boot和Spring Cloud

Spring Cloud是一个分布式的整体解决方案。Spring Cloud 为开发者提供了在分布式系统（配置管理，服务发现，熔断，路由，微代理，控制总线，一次性token，全局琐，leader选举，分布式session，集群状态）中快速构建的工具，使用Spring Cloud的开发者可以快速的启动服务或构建应用、同时能够快速和云平台资源进行对接。

SpringCloud分布式开发五大常用组件：

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

新建一个空的工程。添加Spring Boot的Modules，Artifact为eureka-server，添加Eureka Server依赖。添加Spring Boot的Modules，Artifact为provider，添加Spring Web、Eureka Discovery Client依赖。添加Spring Boot的Modules，Artifact为consumer，添加Spring Web、Eureka Discovery Client依赖。

修改eureka-server的yml配置文件，添加基本配置，在它的主启动类上添加@EnableEurekaServer注解。

server:
  port: 8761
eureka:
  instance:
    # eureka实例的主机名
    hostname: eureka-server
  client:
    # 不把自己注册到Eureka上
    register-with-eureka: false
    # 不从Eureka上获取服务注册信息
    fetch-registry: false
    # 注册中心的地址
    service-url: {defaultZone: 'http://localhost:8761/eureka/'}

启动项目eureka-server项目后，访问http://localhost:8761/可以看到Eureka的管理页面，类似于Dubbo-Admin。

切换到provider项目，在service包下，添加ProviderService.java，在controller包下，添加ProviderController.java。

package com.atguigu.provider.service;

import org.springframework.stereotype.Service;

@Service
public class ProviderService {
    public String getTicket() {
        System.out.println("8001");
        return "《肖申克的救赎》";
    }
}

package com.atguigu.provider.controller;

import com.atguigu.provider.service.ProviderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProviderController {
    @Autowired
    ProviderService providerService;

    @GetMapping("/getTicket")
    public String getTicket() {
        return providerService.getTicket();
    }
}

修改Provider的yml配置文件，将Provider添加到注册中心中。在主启动类上加上@EnableEurekaClient注解。

server:
  port: 8001
eureka:
  instance:
    # 注册服务时候使用服务ip地址
    ip-address: true
  client:
    service-url: {defaultZone: 'http://localhost:8761/eureka/'}
spring:
  application:
    name: provider

启动Provider项目，访问http://localhost:8001/getTicket，可以获取到正常的返回结果。刷新Eureka的管理后台，可以看到有一个Application，也就是我们的Provider。

将Provider先停掉，使用maven的package将Provider打成jar包的形式。将jar包复制出来，改名，修改配置文件中的8001以及service中的8001，将其改成8002，再次打包，将jar包复制出来，改名。

在cmd里，使用java -jar命令启动8001和8002项目后，再次刷新Eureka的管理后台，可以看到两个同名的应用都注册进来了。

切换到consumer项目，在controller包下添加ConsumerController.java。

package com.atguigu.consumer.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
public class ConsumerController {
    @Autowired
    RestTemplate restTemplate;

    @GetMapping("/buyTicket")
    public String buyTicket() {
        // url由3部分组成
        // 第一部分是http://
        // 第二部分是Eureka注册中心Application的name
        // 第三部分是要访问的接口
        String url = "http://" + "PROVIDER" + "/getTicket";
        String s = restTemplate.getForObject(url, String.class);
        return "购买了" + s;
    }
}

修改consumer项目的yml配置文件。

spring:
  application:
    name: consumer
server:
  port: 9001
eureka:
  instance:
    # 注册服务时候使用服务ip地址
    ip-address: true
  client:
    service-url: {defaultZone: 'http://localhost:8761/eureka/'}

在consumer的主启动类上添加@EnableDiscoveryClient注解。

package com.atguigu.consumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
// 开启发现服务功能
@EnableDiscoveryClient
public class ConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class, args);
    }

    // 启用负载均衡机制
    @LoadBalanced
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

启动consumer项目，在Eureka的注册中心可以看到consumer也注册进来了。此时访问consumer的buyTicket()方法，通过浏览器访问http://localhost:9001/buyTicket，可以发现浏览器正常返回了provider中的内容，说明RPC调用成功。

多次刷新页面，通过刚才cmd控制台，可以看到负载均衡生效了。