文章目录

Pigeon是一个分布式服务通信框架（RPC），是美团点评最基础的底层框架之一。

一、rpc的基础框架

rpc的基础流程：

客户端在调用某一个服务时，这个服务实际上是通过动态代理生成的一个代理类的对象。因此在执行方法的时候，实际上执行的是InvocationHandler的invoke方法（pigeon的InvocationHandler是ServiceInvocationProxy）。然后调用的信息去zk注册中心去拿服务提供方的集群信息，通过负载均衡发现一台实际的服务提供方的服务器地址。将请求信息序列化为二进制数据，然后通过netty的client将请求发送给服务提供方，同时wait服务的响应。

在服务方，启动应用后，rpc将需要发布的服务注册到zk上，开启netty server监听器。服务方收到客户端的数据后，将数据反序列化为请求对象，然后解析请求，进行一系列的过滤操作。最后根据请求的信息定位到服务方唯一的一个服务，执行服务的方法。将执行的结果反序列化为二进制数据，回写到调用服务的客户端。

客户端接收到服务方的响应后，将响应结果反序列化为响应对象，最后返回给用户线程，完成了rpc的调用过程。

pigeon的主要组件：

客户端的组件：

ReferenceBean/ProxyBeanFactory：获取服务代理对象的类，实现了FactoryBean，在init方法中初始化了代理对象的创建， 一系列初始化的操作。

InvokerBootStrap：客户端一系列的初始化操作，如初始化ServiceInvocationRepository（令牌桶算法，慢慢放入流量），初始化客户端服务调度器工厂，初始化序列化工厂，初始化负载均衡管理器，初始化路由策略管理器，初始化监控器monitor，初始化response处理器工厂等。

ServiceInvocationProxy：pigeon的动态代理handler，实现了jdk的InvocationHandler接口，每一个客户端动态生成service都会执行ServiceInvocationProxy的invoke方法，在这个方法中service去请求真正的远程服务，这是rpc实现的基础。

ServiceInvocationHandler：服务真正调度的handler，由InvokerProcessHandlerFactory生成，与下面的ServiceInvocationFilter共同组成责任链模式，在handle方法中实际上执行是ServiceInvocationFilter的invoke方法，同时又将下一个handler和上下文InvocationContext传入filter中，这样实现一层一层的调用。

ServiceInvocationFilter：pigeon的rpc调用的过滤器，客户端有RemoteCallMonitorInvokeFilter，TraceFilter，DegradationFilter，FaultInjectionFilter，ClusterInvokeFilter，GatewayInvokeFilter，ContextPrepareInvokeFilter，SecurityFilter，RemoteCallInvokeFilter这些Filter，实现了monitor监控、调用跟踪、服务降级、集群重试、网关、上下文初始化/解析、安全控制、网络调用等过程，实际上rpc的主要功能都是通过这些ServiceInvocationFilter实现的。

NettyClient：pigeon用netty实现的网络客户端，实现了Client接口（还有HttpInvokerClient实现了Client接口，负责http通信），负责初始化netty的ClientBootstrap，维护ChannelPool，以及最重要的给服务提供方write请求数据。

NettyClientHandler：pigeon绑定了ClientBootstrap的客户端ChannelHandler，客户端的众多ChannelHandler之一，绑定在ClientBootstrap的ChannelPipeline上，当服务提供方回复请求结果给客户端时，NettyClientHandler会接收到数据，通过ResponseProcessor将响应数据放到CallbackFuture（盛放结果的类）中，当客户端去取response时，如果已经收到服务提供方响应的数据，则直接获取；如果没有，则await，期间如果收到响应数据，则notify获取响应数据的线程去取，如果超时则报TimeoutException。

服务端的组件：

ServiceBean/ServiceRegistry：跟客户端的ReferenceBean类似，ServiceBean是服务方的入口，实现了ApplicationListener了（为了检测服务方的服务是否发布完成），在init方法中完成了provider的初始化和服务注册操作。

ProviderBootStrap：服务端的一系列初始化的操作，如初始化服务方处理器工厂（初始化服务方的handler），初始化序列化工厂，初始化注册管理器，初始化JettyHttpServer（就是我们经常用的那个4080端口的server）等。然后，在ProviderBootStrap的startup方法中初始化NettyServer，执行NettyServer的doStart方法，绑定ServerBootstrap。并初始化RequestThreadPoolProcessor的所有线程。

ServicePublisher：服务方注册服务节点信息到zk注册中心的组件，通过RegistryManager管理器注册，最后实际上是使用CuratorRegistry注册器（用CuratorFramework实现的）实现的。

NettyServer：pigeon用netty实现的网络服务端，实现了Server接口（Server还有JettyHttpServer子类，负责http通信，监听了4080端口）。负责初始化服务端的ServerBootstrap，监听tcp端口，绑定ChannelHandler，维护tcp的通信。

NettyServerHandler：pigeon绑定了ServerBootstrap的服务端ChannelHandler，服务端的众多ChannelHandler之一，当客户端发起数据请求时，NettyServerHandler会接收到数据，如果是心跳检查，直接处理回写数据，如果是真实的请求，则通过RequestThreadPoolProcessor去处理，找到服务调用然后回写数据。

RequestThreadPoolProcessor：根据不同的messageType选择不同的ServiceInvocationHandler，提供了四种类型的handler，分别是业务处理handler、心跳处理handler、健康检查handler、scanner心跳handler。内部维护了一组线程池，提供了服务隔离功能。通过ServiceInvocationHandler和ServiceInvocationFilter去处理请求信息，在BusinessProcessFilter通过反射执行真正的服务方法，在WriteResponseProcessFilter回写处理完成的response数据给客户端，完成整个服务端处理请求的链路。

二、客户端如何调用pigeon的服务
客户端调用pigeon服务主要分为两步：

第一步：初始化及启动invoker，获取动态代理类对象；

第二步：通过代理类对象动态的调用远程服务，并将响应结果返回给客户端。

invoker初始化的处理链路：

客户端创建代理服务对象有两种方式：spring注入和api编码的方式。如果是spring依赖注入的方式，是通过ProxyBeanFactory或ProxyBeanFactory获取动态代理的bean，实际上是通过ServiceFactory的getService()方法调用的；如果是api编程的方式，则是直接通过ServiceFactory的getService()获取的。

在ServiceFactory中，调用了AbstractServiceProxy的getProxy方法，invoker初始化大部分工作都是在这个类中完成的。首先调用invoker初始化器InvokerBootStrap初始化一系列的管理器与工厂（调度仓库、调度器、序列化工厂、负载均衡管理器、路由策略管理器、监控器、response处理器等等），这是客户端调用rpc服务必须的组件。

然后会调用AbstractSerializer的proxyRequest方法通过Proxy.newProxyInstance创建一个代理类对象，设置InvocationHandler为ServiceInvocationProxy，返回创建好的proxy。

接下来进行一系列的注册，先后注册路由策略和服务配置，在ClientManager中根据invokerConfig去zk注册中心上拉取远程服务器的ip和端口号。在CuratorRegistry中通过CuratorClient（就是CuratorFramework实现的）从zk上拉取address，同时构建NettyClient也是在这里实现的。

最后将proxy服务 put到AbstractServiceProxy的services（ConcurrentHashMap类型）中，然后返回代理对象，完成整个过程。

调用远程服务的处理链路

当客户端通过proxyService调用远程服务时，由于proxyService是代理类，因此实际上会去调用ServiceInvocationProxy的invoke方法，在invoke方法中，会执行ServiceInvocationHandler的handle方法。

ServiceInvocationHandler与ServiceInvocationFilter共同组成责任链模式，ServiceInvocationHandler的handle方法实际上执行的是ServiceInvocationFilter的invoke方法。InvokerProcessHandlerFactory构建了一个filterList，遍历filterList，对每一个filter都创建了一个ServiceInvocationHandler，同时将上一个创建的ServiceInvocationHandler传入filter的invoke方法中。返回最后创建的handler。这样如果在filter中需要调用下一个filter，执行传入的handler.handle()即可。

filterList的代码如下：

public static void init() {

if  (!isInitialized) {


   if  (Constants.MONITOR_ENABLE) {


      registerBizProcessFilter( new  RemoteCallMonitorInvokeFilter());


   }


   registerBizProcessFilter( new  TraceFilter());


   registerBizProcessFilter( new  DegradationFilter());


   registerBizProcessFilter( new  FaultInjectionFilter());


   registerBizProcessFilter( new  ClusterInvokeFilter());


   registerBizProcessFilter( new  GatewayInvokeFilter());


   registerBizProcessFilter( new  ContextPrepareInvokeFilter());


   registerBizProcessFilter( new  SecurityFilter());


   registerBizProcessFilter( new  RemoteCallInvokeFilter());


   bizInvocationHandler = createInvocationHandler(bizProcessFilters);


   isInitialized =  true ;

}

}

最后执行的ServiceInvocationFilter是RemoteCallInvokeFilter，实现发送请求的地方，通过NettyClient将请求发送到远程服务的机器上去。RemoteCallInvokeFilter提供了四种调用方式：SYNC，CALLBACK，FUTURE，ONEWAY。这就是我们在spring配置中经常需要设置的参数

四种调用方式都是通过InvokerUtils的sendRequest方法中调用NettyClient的write方法，将请求数据发送到目的服务器去。

SYNC：同步的调用方式，发送完数据后，通过getResponse去取结果，如果远程服务已经返回结果了就直接取，还没有返回结果就等待，等待超时了就报TimeoutException异常。
CALLBACK：回调的调用方式，把回调函数传入到方法中，当远程服务返回了结果会调用回调函数，异步的调用。
FUTURE：future的调用方式，发送完请求后，创建一个future对象放入当前线程的threadLocal中，客户端需要的话可以通过threadLocal去取结果。对pigeon来说是异步的调用，如果客户端需要取结果则是非阻塞同步的方式。
ONEWAY：单向调用的方式，发送完请求直接返回，不关心处理结果，异步的调用。

调用方法如下：

switch (callMethod) {

 case  SYNC:


     CallbackFuture future =  new  CallbackFuture();


     //在InvokerUtils的sendRequest方法中调用NettyClient的write方法，将请求数据发送到目的服务器去


     response = InvokerUtils.sendRequest(client, invocationContext.getRequest(), future);


     invocationContext.getTimeline().add( new  TimePoint(TimePhase.Q));


     if  (response ==  null ) {


         //如果是同步的，就通过getResponse去取结果，远程服务还没有返回结果就等待，有就直接取


         response = future.getResponse(request.getTimeout());


     }


     break ;


 case  CALLBACK:


     InvocationCallback callback = invokerConfig.getCallback();


     InvocationCallback tlCallback = InvokerHelper.getCallback();


     if  (tlCallback !=  null ) {


         callback = tlCallback;


         InvokerHelper.clearCallback();


     }


     //回调的方式则将你的回调函数传入，远程服务返回结果后会调用回调函数


     InvokerUtils.sendRequest(client, invocationContext.getRequest(),  new  ServiceCallbackWrapper(


             invocationContext, callback));


     response = NO_RETURN_RESPONSE;


     invocationContext.getTimeline().add( new  TimePoint(TimePhase.Q));


     break ;


 case  FUTURE:


     ServiceFutureImpl futureImpl =  new  ServiceFutureImpl(invocationContext, request.getTimeout());


     InvokerUtils.sendRequest(client, invocationContext.getRequest(), futureImpl);


     //future方式，将future对象放入当前线程的threadLocal中


     FutureFactory.setFuture(futureImpl);


     //返回的是一个future的response，并没有真是的结果


     response = InvokerUtils.createFutureResponse(futureImpl);


     invocationContext.getTimeline().add( new  TimePoint(TimePhase.Q));


     break ;


 case  ONEWAY:


     //oneway不处理返回结果


     InvokerUtils.sendRequest(client, invocationContext.getRequest(),  null );


     response = NO_RETURN_RESPONSE;


     invocationContext.getTimeline().add( new  TimePoint(TimePhase.Q));


     break ;


 default :


     throw  new  BadRequestException( "Call type["  + callMethod.getName() +  "] is not supported!" );

}

将请求数据发送给远程服务的机器后，客户端需要接受服务器响应的结果。这个是通过NettyClientHandler等ChannelHandler实现。在创建NettyClient的时候，ClientBootstrap会setPipelineFactory将一组ChannelHandler关联到Client上去。当服务端给客户端发送数据时，会通过这一组handler来响应处理。handlers解决了tcp粘包、序列化、反序列化等问题。

当收到远程服务的响应数据时，NettyClientHandler会调用ResponseThreadPoolProcessor使用多线程去处理response，在线程中，使用ServiceInvocationRepository的单例对象处理response，把response放到RemoteCallInvokeFilter创建的CallbackFuture中，用condition.signal()唤醒RemoteCallInvokeFilter等待的线程（如果是同步的调用），完成整个调用工作。

pigeon的调用结构图

三、服务端如何处理rpc的请求
服务提供方提供和处理pigeon服务主要分为两步：

第一步：初始化及启动provider，监听tcp端口，注册服务；

第二步：监听客户端发送的请求消息，处理结果并返回给客户端。

provider初始化的处理链路

服务端初始化provider和注册服务也有两种方式：spring注入和api编码的方式。如果是spring注入的方式，通过ServiceBean的init方法，将coder设置在services中的服务通过ServiceFactory.addServices()方法初始化和注册；如果是api编码的方式，则是直接调用ServiceFactory.addService()的方法进行初始化和注入，过程都是相同的。

在ServiceFactory中，ServiceFactory的静态代码块会执行ProviderBootStrap.init()方法，ProviderBootStrap是服务方的启动器，完成服务方各种初始化工厂和管理器（服务方处理器工厂、序列化工厂、注册管理器），还会启动JettyHttpServer监听4080端口。跟客户端的InvokerBootStrap类似，是服务方提供rpc服务必须的组件。

接下来调用PublishPolicy的doAddService()方法，PublishPolicy首先去startup ProviderBootStrap，在这里才初始化了NettyServer，执行NettyServer的doStart方法，绑定ServerBootstrap，监听tcp端口（并不是固定端口号）。并初始化RequestThreadPoolProcessor的所有线程。然后通过ServicePublisher发布注册服务。

ServicePublisher通过publishService发布服务，实际上是调用preparePublishTask()方法，通过自身的静态内部类PublishTask在线程中异步发布注册服务，在PublishTask通过RegistryManager的registerService()方法在CuratorRegistry注册了服务，而在CuratorRegistry中通过CuratorClient（CuratorFramework实现的）实现了zk注册服务，基本逻辑是：如果当前serviceName在zk注册中心的节点上存在，则在这个节点添加一个address，如果不存在，则创建一个节点存放address。

响应请求消息的处理链路

上面的启动provider的过程中，NettyServer将一组ChannelHandler通过setPipelineFactory关联到ServerBootstrap上去。客户端发起远程服务请求后，会通过这一组handler来响应处理。与客户端的handlers类似，服务端的handlers同样解决了tcp粘包、序列化、反序列化等问题。

NettyServerHandler收到客户端的请求数据后，首先判断是不是scanner心跳的请求， 如果是，则直接回写数据回去即可；如果是客户端的正常请求，则通过AbstractServer的processRequest()方法去处理。

AbstractServer直接通过RequestThreadPoolProcessor的doProcessRequest来处理请求数据。RequestThreadPoolProcessor内部维护了一组线程池，提供了服务隔离功能。RequestThreadPoolProcessor首先根据请求去获取对应的线程池（默认提供slowRequestProcessThreadPool、sharedRequestProcessThreadPool，另外还提供了可定制针对单个服务和方法的methodThreadPools和serviceThreadPools），然后检测请求是否可行。如果一切ok，则创建一个Callable对象，用线程池去处理这个请求。

在Callable中，首先通过ProviderProcessHandlerFactory的selectInvocationHandler()方法创建一个handler，与客户端相同的是，ServiceInvocationHandler与ServiceInvocationFilter同样构成责任链模式，provider提供四种handler链，分别是业务处理handler、心跳处理handler、健康检查handler、scanner心跳handler，根据不同的请求处理不同的handler链。

责任链模式使得ServiceInvocationFilter一层一层的调用，直到BusinessProcessFilter为止开始一层一层的返回。BusinessProcessFilter是FilterList最核心的ServiceInvocationFilter，在这个Filter中，provider通过请求的数据获取到真正对应的bizService和method，然后通过反射的方式调用这个方法，返回调用结果，把结果封装到response中。

四、pigeon中的设计模式
pigeon是一个设计很优雅的rpc框架，里面用到很多很好的设计模式

代理模式

客户端创建代理服务对象的时候就用到了代理模式，创建的对象并不是通过new的方式来创建，而是Proxy.newProxyInstance()方法。在调用代理类的方法时，会去调用传入newProxyInstance的参数ServiceInvocationProxy对象的invoke方法，这样就实现了通过网络通信去调用远程服务的功能了。

pigeon在AbstractSerializer类中通过代理模式创建了代理服务对象。

工厂模式

工厂模式是将创建对象的操作放在工程类中，需要使用的时候去工厂类中取。pigeon使用的工厂模式很多，如ProviderProcessHandlerFactory，在这个工厂类中创建了四种ServiceInvocationHandler，需要用的时候根据不同的type去取。代码如下：

public static ServiceInvocationHandler selectInvocationHandler( int messageType) {

if  (Constants.MESSAGE_TYPE_HEART == messageType) {


   return  heartBeatInvocationHandler;


}  else  if  (Constants.MESSAGE_TYPE_HEALTHCHECK == messageType) {


   return  healthCheckInvocationHandler;


}  else  if  (Constants.MESSAGE_TYPE_SCANNER_HEART == messageType) {


   return  scannerHeartBeatInvocationHandler;


}  else  {


   return  bizInvocationHandler;


}

}

根据messageType这个参数，来获取heartBeatInvocationHandler，healthCheckInvocationHandler，scannerHeartBeatInvocationHandler或者bizInvocationHandler。

策略模式

策略模式是定义了一系列的策略，并将每一个策略封装起来，而且使他们可以相互替换，在运行时动态选择具体要执行的行为。pigeon也使用了很多策略模式。如在ClusterInvokeFilter中，定义了一组集群重试策略，在运行时可以动态的选择具体需要执行的集群重试行为。

public InvocationResponse invoke(ServiceInvocationHandler handler, InvokerContext invocationContext)

   throws  Throwable {


InvokerConfig<?> invokerConfig = invocationContext.getInvokerConfig();


Cluster cluster = ClusterFactory.selectCluster(invokerConfig.getCluster());


if  (cluster ==  null ) {


   throw  new  IllegalArgumentException( "Unsupported cluster type:"  + cluster);


}


return  cluster.invoke(handler, invocationContext);

}

责任链模式

责任链模式是使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系， 将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理他为止。在pigeon中，ServiceInvocationHandler与ServiceInvocationFilter组成责任链模式，InvokerProcessHandlerFactory构建了一个filterList，ServiceInvocationHandler的handle方法实际上执行的是ServiceInvocationFilter的invoke方法。ServiceInvocationFilter一层一层的调用，直到最后一个filter然后开始一层一层的返回。

for ( int i = filterList.size() - 1 ; i >= 0 ; i–) {

final  V filter = filterList.get(i);


final  ServiceInvocationHandler next = last;


last =  new  ServiceInvocationHandler() {


   @SuppressWarnings ( "unchecked" )


   @Override


   public  InvocationResponse handle(InvocationContext invocationContext)  throws  Throwable {


      InvocationResponse resp = filter.invoke(next, invocationContext);


      return  resp;


   }


};

}

遍历filterList，获取所有的filter。每一个filter都会对发送的请求进行过滤，直到有一个filter拦截请求（不符合过滤条件），然后抛出异常或作出其他处理。这就是责任链模式。（我认为）

单例模式

单例模式是最简单的设计模式，也是pigeon中用得最多的设计模式。单例模式可以保证系统中，应用该模式的类一个类只有一个实例。pigeon的资源管理器大部分都设计为单例模式，如ServiceInvocationRepository、RoutePolicyManager、ServiceConfigManager、ClientManager等等。主要是为了管理公共资源，保持唯一访问路径。