1 分布式系统理论
1 什么是分布式
分布式系统是由一组通过网络进行通信、为了完成共同的任务而协调工作的计算机节点组成的系统
分布式系统的出现是为了用廉价的、普通的机器完成单个计算机无法完成的计算、存储任务。其目的是利用更多的机器,处理更多的数据。
分布式系统是若干独立计算机的集合,这些计算机对于用户来说就像单个相关系统”;
分布式常见的网络通信协议有RPC,和HTTP
2 互联网应用架构的发展
- 单体应用架构
当网站流量很小时,只需一个应用,将所有功能都部署在一起,以减少部署节点和成本。此时,用于简化增删改查工作量的数据访问框架(ORM)是关键。
适用于小型网站,小型管理系统,将所有功能都部署到一个功能里,简单易用。
缺点:
1、性能扩展比较难
2、协同开发问题
3、不利于升级维护
2 垂直应用架构
当访问量逐渐增大,单一应用增加机器带来的加速度越来越小,将应用拆成互不相干的几个应用,以提升效率。此时,用于加速前端页面开发的Web框架(MVC)是关键。
通过切分业务来实现各个模块独立部署,降低了维护和部署的难度,团队各司其职更易管理,性能扩展也更方便,更有针对性
缺点:公用模块无法重复利用,开发性的浪费
3 分布式应用架构
当垂直应用越来越多,应用之间交互不可避免,将核心业务抽取出来,作为独立的服务,逐渐形成稳定的服务中心,使前端应用能更快速的响应多变的市场需求。此时,用于提高业务复用及整合的**分布式服务框架(RPC)**是关键。
4 流动式计算架构
当服务越来越多,容量的评估,小服务资源的浪费等问题逐渐显现,此时需增加一个调度中心基于访问压力实时管理集群容量,提高集群利用率。此时,用于提高机器利用率的资源调度和治理中心(SOA)[ Service Oriented Architecture]是关键。
2 什么是RPC
RPC【Remote Procedure Call】是指远程过程调用,是一种进程间通信方式,他是一种技术的思想,而不是规范。它允许程序调用另一个地址空间(通常是共享网络的另一台机器上)的过程或函数,而不用程序员显式编码这个远程调用的细节。
1 什么是本地调用
假设你有一个计算器接口,Calculator,以及它的实现类CalculatorImpl,那么在系统还是单体应用时,你要调用Calculator的add方法来执行一个加运算,直接new一个CalculatorImpl,然后调用add方法就行了
2 什么远程调用
现在将系统变为分布式系统,将实现类CalculatorImpl放在另外一台服务器,形成一个服务,那么Calculator如何调用另一台服务器中的代码
解决方案
-
模仿B/S架构的调用方式呀,在B服务暴露一个Restful接口,然后A服务通过调用这个Restful接口来间接调用B的方法
- 缺点 每次调用时,都需要写一串发起http请求的代码 ,如何让使用者感知不到远程调用的过程
-
用代理模式呀!而且最好是结合Spring IoC一起使用,通过Spring注入calculator对象,注入时,如果扫描到对象加了@Reference注解,那么就给它生成一个代理对象,将这个代理对象放进容器中。而这个代理对象的内部,就是通过httpClient来实现RPC远程过程调用的。
许多RPC框架就是利用上面原理实现的
RPC要解决的两个问题:
- 解决分布式系统中,服务之间的调用问题。
- 远程调用时,要能够像本地调用一样方便,让调用者感知不到远程调用的逻辑。
RPC的本质是通过网络编程的Socket等相关技术,来实现调用远程的服务
RPC的基本原理
Client 的Application 要调用远程的Server 服务,Client Stub 表示要调用服务接口的代理类,这个代理类通过 Client Run-time Library,(实现远程调用的工具包) 通过序列化,将需要调用的请求 序列化传输给Server
Server 通过反序列化,以及Client Run-time Library接收 Client的请求信息
通过Server Stub ,所负责的,只是去解析请求对象,知道调用方要调的是哪个RPC接口,传进来的参数又是什么,然后再把这些参数传给对应的RPC接口,即相关服务的实现类去调用,然后通过远程调用,将结果序列化传递给Client
这个过程CLient 就好像调用本地服务一样,实际上是通过远程调用调用远程的服务进行处理
RPC两个核心模块:通讯,序列化。
如何实现一个RPC
这里以ServiceA ,要调用ServiceB 为例子
根据完整的RPC流程
1 Service A的应用层代码中,调用了Calculator的一个实现类的add方法,希望执行一个加法运算;
2 这个Calculator实现类,内部并不是直接实现计算器的加减乘除逻辑,而是通过远程调用Service B的RPC接口,来获取运算结果,因此称之为Stub;
3 Stub怎么和Service B建立远程通讯呢?这时候就要用到远程通讯工具了,也就是图中的Run-time Library,这个工具将帮你实现远程通讯的功能,比如Java的Socket,就是这样一个库,当然,你也可以用基于Http协议的HttpClient,或者其他通讯工具类,都可以,RPC并没有规定说你要用何种协议进行通讯;
4 Stub通过调用通讯工具提供的方法,和Service B建立起了通讯,然后将请求数据发给Service B。需要注意的是,由于底层的网络通讯是基于二进制格式的,因此这里Stub传给通讯工具类的数据也必须是二进制,比如calculator.add(1,2),你必须把参数值1和2放到一个Request对象里头(这个Request对象当然不只这些信息,还包括要调用哪个服务的哪个RPC接口等其他信息),然后序列化为二进制,再传给通讯工具类,这一点也将在下面的代码实现中体现;
5 二进制的数据传到Service B这一边了,Service B当然也有自己的通讯工具,通过这个通讯工具接收二进制的请求;
既然数据是二进制的,那么自然要进行反序列化了,将二进制的数据反序列化为请求对象,然后将这个请求对象交给Service B的Stub处理;
和之前的Service A的Stub一样,这里的Stub也同样是个“假玩意”,它所负责的,只是去解析请求对象,知道调用方要调的是哪个RPC接口,传进来的参数又是什么,然后再把这些参数传给对应的RPC接口,也就是Calculator的实际实现类去执行。很明显,如果是Java,那这里肯定用到了反射。
6 RPC接口执行完毕,返回执行结果,现在轮到Service B要把数据发给Service A了,怎么发?一样的道理,一样的流程,只是现在Service B变成了Client,Service A变成了Server而已:Service B反序列化执行结果->传输给Service A->Service A反序列化执行结果 -> 将结果返回给Application,完毕。
实际代码
1 服务消费者
1 编程ComsumerApp 调用 Provider 提供的服务
public class ComsumerApp {
public static void main(String[] args) {
Calculator calculator = new CalculatorRemoteImpl();
int result = calculator.add(1, 2);
}
}
2 CalculatorRemoteImpl 是实现RPC逻辑的类 这样客户端调用时感知不到远程调用的麻烦
public class CalculatorRemoteImpl implements Calculator {
public int add(int a, int b) {
// 寻找所有提供 "Calculator.add"的提供者
List<String> addressList = lookupProviders("Calculator.add");
// 选择一个提供者
String address = chooseTarget(addressList);
try {
Socket socket = new Socket(address, PORT);
// 将请求序列化
CalculateRpcRequest calculateRpcRequest = generateRequest(a, b);
ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
// 将请求发给服务提供方
objectOutputStream.writeObject(calculateRpcRequest);
// 将响应体反序列化
ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
Object response = objectInputStream.readObject();
if (response instanceof Integer) {
return (Integer) response;
} else {
throw new InternalError();
}
} catch (Exception e) {
log.error("fail", e);
throw new InternalError();
}
}
}
//寻找服务提供者,因为可能有多个服务提供者
public static List<String> lookupProviders(String name) {
List<String> strings = new ArrayList();
strings.add("127.0.0.1");
return strings;
}
private String chooseTarget(List<String> providers) {
if (null == providers || providers.size() == 0) {
throw new IllegalArgumentException();
}
// 默认选择第一个
return providers.get(0);
}
3 calculateRpcRequest 将请求封装成一个对象
package com.sexycode.simplerpc.request;
import java.io.Serializable;
public class CalculateRpcRequest implements Serializable {
private static final long serialVersionUID = 7503710091945320739L;
private String method;
private int a;
private int b;
public String getMethod() {
return method;
}
public void setMethod(String method) {
this.method = method;
}
public int getA() {
return a;
}
public void setA(int a) {
this.a = a;
}
public int getB() {
return b;
}
public void setB(int b) {
this.b = b;
}
@Override
public String toString() {
return "CalculateRpcRequest{" +
"method='" + method + '\'' +
", a=" + a +
", b=" + b +
'}';
}
}
到此消费者实现完毕
4 服务提供者
1 创建要提供的服务
public interface Calculator {
int add(int a, int b);
}
public class CalculatorImpl implements Calculator {
public int add(int a, int b) {
return a + b;
}
}
2 创建进行服务提供的类
public class ProviderApp {
private Calculator calculator = new CalculatorImpl();
private static Logger log = LoggerFactory.getLogger(ProviderApp.class);
public static void main(String[] args) {
new ProviderApp().run();
}
private void run(){
ServerSocket serverSocket = null;
ObjectInputStream objectInputStream = null;
ObjectOutputStream objectOutputStream =null;
Socket accept = null;
//1 创建 ServerSocket
try {
serverSocket = new ServerSocket(9898);
while (true){
//2 监听Socket
accept = serverSocket.accept();
//3 获取消费者的请求
objectInputStream = new ObjectInputStream(accept.getInputStream());
Object object = objectInputStream.readObject();
log.info("request is {}", object);
int result=0;
//4 对消费者的请求进行处理,
if (object instanceof CalculateRpcRequest){
CalculateRpcRequest calculateRpcRequest = (CalculateRpcRequest) object;
if ("add".equals(calculateRpcRequest.getMethod())) {
result = calculator.add(calculateRpcRequest.getA(), calculateRpcRequest.getB());
} else {
throw new UnsupportedOperationException();
}
}
//5 将计算的结果序列化后,发送给消费者
objectOutputStream = new ObjectOutputStream(accept.getOutputStream());
objectOutputStream.writeObject(result);
}
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
if (serverSocket != null){
try {
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (accept != null){
try {
accept.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (objectInputStream != null){
try {
objectInputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (objectOutputStream != null){
try {
objectOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
5 项目中需要的依赖,以及相关的配置文件
# Set root logger level to DEBUG and its only appender to A1.
log4j.rootLogger=DEBUG, A1
# A1 is set to be a ConsoleAppender.
log4j.appender.A1=org.apache.log4j.ConsoleAppender
# A1 uses PatternLayout.
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n
6 依赖
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${slf4jVersion}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${slf4jVersion}</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.16</version>
<scope>runtime</scope>
</dependency>
</dependencies>
小结
RPC的本次还是利用了远程调用的相关库,比如Socket,将请求序列化
然后远程调用别的服务,然后把结果序列化,传递给Client端
就这样我们实现了一个简陋而又详细的RPC。
缺点
1、缺乏通用性
我通过给Calculator接口写了一个CalculatorRemoteImpl,来实现计算器的远程调用,下一次要是有别的接口需要远程调用,是不是又得再写对应的远程调用实现类?这肯定是很不方便的
那该如何解决呢?先来看看使用Dubbo时是如何实现RPC调用的:
@Reference
private Calculator calculator;
...
calculator.add(1,2);
Dubbo通过和Spring的集成,在Spring容器初始化的时候,如果扫描到对象加了@Reference注解,那么就给这个对象生成一个代理对象,这个代理对象会负责远程通讯,然后将代理对象放进容器中。所以代码运行期用到的calculator就是那个代理对象了。
我们可以先不和Spring集成,也就是先不采用依赖注入,但是我们要做到像Dubbo一样,无需自己手动写代理对象,怎么做呢?那自然是要求所有的远程调用都遵循一套模板,把远程调用的信息放到一个RpcRequest对象里面,发给Server端,Server端解析之后就知道你要调用的是哪个RPC接口、以及入参是什么类型、入参的值又是什么,就像Dubbo的RpcInvocation:
public class RpcInvocation implements Invocation, Serializable {
private static final long serialVersionUID = -4355285085441097045L;
private String methodName;
private Class<?>[] parameterTypes;
private Object[] arguments;
private Map<String, String> attachments;
private transient Invoker<?> invoker;
2、集成Spring
在实现了代理对象通用化之后,下一步就可以考虑集成Spring的IOC功能了,通过Spring来创建代理对象,这一点就需要对Spring的bean初始化有一定掌握了。
3、长连接or短连接
总不能每次要调用RPC接口时都去开启一个Socket建立连接吧?是不是可以保持若干个长连接,然后每次有rpc请求时,把请求放到任务队列中,然后由线程池去消费执行?只是一个思路,后续可以参考一下Dubbo是如何实现的。
4 我们现在的Server端,是单线程的,每次都要等一个请求处理完,才能去accept另一个socket的连接,这样性能肯定很差,是不是可以通过一个线程池,来实现同时处理多个RPC请求?同样只是一个思路。
5 正如之前提到的,要调用服务,首先你需要一个服务注册中心,告诉你对方服务都有哪些实例。Dubbo的服务注册中心是可以配置的,官方推荐使用Zookeeper。如果使用Zookeeper的话,要怎样往上面注册实例,又要怎样获取实例,这些都是要实现的
6 如何从多个实例里挑选一个出来,进行调用,这就要用到负载均衡了。负载均衡的策略肯定不只一种,要怎样把策略做成可配置的?又要如何实现这些策略?同样可以参考Dubbo
7、结果缓存
每次调用查询接口时都要真的去Server端查询吗?是不是要考虑一下支持缓存?
8、异步调用
客户端调用完接口之后,不想等待服务端返回,想去干点别的事,可以支持不?
Dubbo的原理 重要
服务提供者(Provider):暴露服务的服务提供方,服务提供者在启动时,向注册中心注册自己提供的服务。
服务消费者(Consumer):调用远程服务的服务消费方,服务消费者在启动时,向注册中心订阅自己所需的服务,服务消费者,从提供者地址列表中,基于软负载均衡算法,选一台提供者进行调用,如果调用失败,再选另一台调用
注册中心(Registry):注册中心返回服务提供者地址列表给消费者,如果有变更,注册中心将基于长连接推送变更数据给消费者
监控中心(Monitor):服务消费者和提供者,在内存中累计调用次数和调用时间,定时每分钟发送一次统计数据到监控中心
调用关系说明
l 服务容器负责启动,加载,运行服务提供者。
l 服务提供者在启动时,向注册中心注册自己提供的服务。
l 服务消费者在启动时,向注册中心订阅自己所需的服务。
l 注册中心返回服务提供者地址列表给消费者,如果有变更,注册中心将基于长连接推送变更数据给消费者。
l 服务消费者,从提供者地址列表中,基于软负载均衡算法,选一台提供者进行调用,如果调用失败,再选另一台调用。
l 服务消费者和提供者,在内存中累计调用次数和调用时间,定时每分钟发送一次统计数据到监控中心。
3 Dubbo环境搭建
1 下载安装zookeeper
ZooKeeper 是一个用于维护配置信息、命名、提供分布式同步和提供组服务的集中服务。
所有这些类型的服务都以某种形式被分布式应用程序所使用。
Zookeeper是一个注册中心,常见的注册中心有
-
Nacos 注册中心 阿里巴巴开发的一个注册中心
-
Zookeeper 注册中心
-
Redis 注册中心
-
Multicast 注册中心
1 zookeeper的安装
1 下载地址
https://www.apache.org/dyn/closer.lua/zookeeper/zookeeper-3.7.0/apache-zookeeper-3.7.0-bin.tar.gz
2 下载后解压文件夹
3 进入bin文件中,zkServer.cmd ,如果出现闪退
编辑zkServer.cmd
taskkill /pid %%%%p /t /f" -cp "%CLASSPATH%" %ZOOMAIN% "%ZOOCFG%" %*
//加上
pause
endlocal
这样我们能够查看具体出现的问题 显示zoo.config 未找到
4 进入config文件夹,复制zoo_sample.cfg,重命名为zoo.cfg
5 双击 zkServer.cmd zkCli.cmd 查看是否启动成功
zookeeper的默认端口号2181
6 zookeeper的常见命令
- ls /:列出zookeeper根下保存的所有节点
- create –e /kuangshen 123:创建一个kuangshen节点,值为123
- get /kuangshen:获取/kuangshen节点的值
2 window下安装dubbo-admin
dubbo-admin : 是一个监控管理后台,查看我们注册了哪些服务,哪些服务被消费了
1 下载dubbo-admin
1 https://github.com/apache/dubbo-admin/tree/master
2 解压
修改 dubbo-admin\src\main\resources \application.properties 指定zookeeper地址
server.port=7001
spring.velocity.cache=false
spring.velocity.charset=UTF-8
spring.velocity.layout-url=/templates/default.vm
spring.messages.fallback-to-system-locale=false
spring.messages.basename=i18n/message
spring.root.password=root
spring.guest.password=guest
dubbo.registry.address=zookeeper://127.0.0.1:2181
3 在项目目录下打包,dubbo-admin
mvn clean package -Dmaven.test.skip=true
打包时间有点久
出现上面结果则成功
如果失败,请修改dubbo-admin-master 下的prom.xml 的jdk版本
重新打包
4 打开zookeeper的服务 Server.cmd Cli.cmd
5 执行 dubbo-admin\target 下的dubbo-admin-0.0.1-SNAPSHOT.jar
java -jar dubbo-admin-0.0.1-SNAPSHOT.jar
6 访问一下 http://localhost:7001/ 需要输入登录账户和密码,都是默认的root-root;
4 服务注册 发现实战
创建多个SpringBoot 模块,实现注册Provider模块中的服务到注册中兴,Consumer模块 从注册中心调用Provider注册的服务
1 创建一个空项目
NEW->PROJECT ->EMPTY PROJECT
2 创建两个SpringBoot 模块
添加SpringBoot -web依赖即可
3 进入provider-server
- 导入依赖
<!--dubbo-->
<!-- Dubbo Spring Boot Starter -->
<!-- https://mvnrepository.com/artifact/org.apache.dubbo/dubbo-spring-boot-starter -->
<!-- Dubbo 依赖-->
<dependency>
<groupId>org.apache.dubbo</groupId>
<artifactId>dubbo-spring-boot-starter</artifactId>
<version>2.7.8</version>
</dependency>
<!-- zookeeper依赖-->
<!-- https://mvnrepository.com/artifact/com.github.sgroschupf/zkclient -->
<dependency>
<groupId>com.github.sgroschupf</groupId>
<artifactId>zkclient</artifactId>
<version>0.1</version>
</dependency>
<!-- 引入zookeeper,依赖包,以及新版解决和SpringBoot 的日志冲突 -->
<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>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
- 创建要提供的服务
public interface TicketService {
String getTicket();
}
//将服务自动注册到服务中心
@DubboService
//注册bean
@Service
public class TicketServiceImpl implements TicketService{
@Override
public String getTicket() {
return "<<狂神说Java>>";
}
}
老版本Dubbo ,有和Spring Framarker 一样的@Service 注解,作用和DubboService一样
- 在配置文件中配置Dubbo信息
- Dubbo应用名
- 注册中心地址
- 要扫描的服务
# 配置Dubbo的相关属性
dubbo.application.name=provider-server
#配置要扫描的服务
dubbo.scan.base-packages=com.kuang.service
#配置注册中心的地址
dubbo.registry.address=zookeeper://127.0.0.1:2181
4 进入consumer-server
1 导入依赖,和上面一样
<!-- 引入zookeeper,依赖包,以及新版解决和SpringBoot 的日志冲突 -->
<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>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
2 配置Dubbo信息
#配置Dubbo
dubbo.application.name=consumer-server
dubbo.registry.address=zookeeper://127.0.0.1:2181
3 使用服务
@Service
public class UserService {
//远程引用指定的服务,他会按照全类名进行匹配,看谁给注册中心注册了这个全类名
@DubboReference
private TicketService ticketService;
public void buyTicket(){
System.out.println("在注册中心买了一张"+ticketService.getTicket());
}
}
- 注意应该建立和提供服务相同包结构的TicketService服务接口
4 测试
启动两个模块再进行测试
@SpringBootTest
class ConsumerServerApplicationTests {
@Autowired
private UserService userService;
@Test
void contextLoads() {
userService.buyTicket();
}
}
- 注意这里后台服务都应该开启如 Dubbo 的服务
- Zookeeper的服务
访问http://localhost:7001/ 查看提供者和消费者,两者都存在
成功
参考文档
- 作者:柳树之
链接:https://www.jianshu.com/p/5b90a4e70783 - 作者:狂神说
原文链接:https://blog.csdn.net/qq_33369905/article/details/106647287