Spring Boot——分布式

一、分布式

1、分布式的基本概念

分布式系统是由一组通过网络进行通信、为了完成共同的任务而协调工作的计算机节点组成的系统。其目的是利用更多的机器，处理更多的数据。

在分布式系统中，国内常用zookeeper+dubbo组合，而Spring Boot推荐使用全栈的Spring，Spring Boot+Spring Cloud。

2、应用架构的发展

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

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

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

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

二、Dubbo——Zookeeper

1、ZooKeeper（注册中心）

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

2、Dubbo

（1）Dubbo概念
Apache Dubbo 是一款高性能、轻量级的开源Java RPC框架，它提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。从服务模型的角度来看，Dubbo采用的是一种非常简单的模型，要么是提供方提供服务，要么是消费方消费服务，所以基于这一点可以抽象出服务提供方（Provider）和服务消费方（Consumer）两个角色。

（2）RPC：远程过程调用
RPC（Remote Procedure Call）是指远程过程调用，是一种进程间通信方式，它是一种技术的思想，而不是规范。它允许程序调用另一个地址空间（通常是共享网络的另一台机器上）的函数，由于不在一个内存空间，不能直接调用，需要通过网络来表达调用的语义和传达调用的数据，和调用本地方法的语法一样，只不过需要网络传输。

注：
RPC两个核心模块：通讯，序列化。

（3）Dubbo的核心组件

• 服务提供者（Provider）：暴露服务的服务提供方，服务提供者在启动时，向注册中心注册自己提供的服务。
• 服务消费者（Consumer）：调用远程服务的服务消费方，服务消费者在启动时，向注册中心订阅自己所需的服务，服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
• 注册中心（Registry）：注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
• 监控中心（Monitor）：服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

3、测试

（1）安装zookeeper作为注册中心

Dobbo中的zookeeper安装帮助文档：https://registry.hub.docker.com/_/zookeeper

1）拉取zookeeper

docker pull ezsfsfyys.mirror.aliyuncs.com/library/zookeeper

2）运行zookeeper

docker run --name ZK01 -p 2181:2181 --restart always -d e1763fd3a0e3

This image includes EXPOSE 2181 2888 3888 8080 (the zookeeper client port, follower port, election port, AdminServer port respectively). 在这里我们不做集群、选举，只需暴露2181端口即可。

（2）编写服务提供者

dubbo-SpringBoot官方：https://github.com/apache/dubbo-spring-boot-project

1）引入依赖：

 <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.7.3</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.github.sgroschupf/zkclient -->
        <dependency>
            <groupId>com.github.sgroschupf</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.1</version>
        </dependency>

        <!-- 引入zookeeper -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>2.12.0</version>
        </dependency>

        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>2.12.0</version>
        </dependency>

        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.14</version>
            <!--排除这个slf4j-log4j12-->
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

注意:
这里有日志冲突，需要排除slf4j-log4j12。

2）配置application.properties

dubbo.application.name=provider-ticket
dubbo.registry.address=zookeeper://44.92.240.49:2181
dubbo.scan.base-packages=com.glp.service

dubbo.config-center.timeout=10000

dubbo.registry.address：配置注册中心的地址
dubbo.scan.base-packages=com.glp.service：配置扫描包
dubbo.config-center.timeout：配置连接的超时时间

3）发布服务：

import org.apache.dubbo.config.annotation.Service;
import org.springframework.stereotype.Component;

@Component
@Service //将服务发布出去
public class TicketServiceImpl implements TicketService {
    
    
    @Override
    public String getTicket() {
    
    
        return "《我爱我的祖国》";
    }
}

@Service：将服务发布出去

（3）编写服务消费者

1）引入依赖：和提供者相同

2）配置注册中心的地址

dubbo.application.name=consumer-user
dubbo.registry.address=zookeeper://46.78.236.59 

3）引用服务

本来正常步骤是需要将服务提供者的接口打包，然后用pom文件导入，我们这里使用简单的方式，直接将服务的接口拿过来，路径必须保证正确，即和服务提供者相同；

import com.glp.service.TicketService;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    
    

    @Reference
    TicketService ticketService;
    public void getTicket(){
    
    
        System.out.println("买到票："+ticketService.getTicket());
    }
}

（4）测试

 @Autowired
    UserService userService;
    @Test
    void contextLoads() {
    
    
        userService.getTicket();
    }

终于买到票了，前期不断报错，主要原因在于pom中依赖的版本问题。

本测试完整代码：dubbo——zookeeper

三、Spring Cloud

本实例源码：SpringCloud练习

1、Spring Cloud基本概念

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

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

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

2、注册中心

（1）配置eureka

server:
  port: 8761
eureka:
  instance:
    hostname: eureka-server
  client:
    register-with-eureka: false  #不将自己注册到eureka上
    fetch-registry: false  #不从eureka上获取服务的注册信息
    service-url:
      defaultZone: http://localhost:8761/eureka/

（2）@EnableEurekaServer

（3）访问http://localhost:8761/

3、服务提供者

（1）配置eureka

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

（2）编写服务

（3）打jar包运行服务
可以将此服务以不同的端口号打包多个jar包，同时运行。

4、服务消费者

（1）配置eureka

spring:
  application:
    name: consumer-user
server:
  port: 8200

eureka:
  instance:
    prefer-ip-address: true  #注册服务的时候使用服务的ip地址进行注册
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/

（2）@EnableDiscoveryClient开启服务发现功能

（3）配置RestTemplate

（4）获取服务

（5）访问测试