JAVA RPC (六) 之手把手从零教你写一个生产级RPC之client的代理

首先对于RPC来讲，最主要的无非三点【SERVER IO模型】、【序列化协议】、【client连接池复用】,之前的博客大家应该对thrift有一个大致的了解了，那么我们现在来说一说如何将thrift的序列化和传输使用到生产中。先放一张作者自己写的一个rpc架构图。

分成几个主要部分：

1：server启动zk注册

2：client监听watch节点变动维护本地缓存，构建tcp连接池。

3：通过java aop代理获得接口代理实现，从而通过thrift序列化传输二进制自定义协议的字节流

4：server通过reactor主从模型来实现高性能服务端。

5：调用端数据上报，形成trace链路，数据大盘，TP99,可用率等。

先看一下使用方式

客户端有两种，第一种xml 使用

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:koalas="http://www.koalas.com/schema/ch"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
                           http://www.koalas.com/schema/ch
                           http://www.koalas.com/schema/ch.xsd">

    <koalas:client id="koalasService"
               serviceInterface="thrift.service.koalasService" 
               zkPath="127.0.0.1:2181"/> </beans>

package thrift.service;

import org.apache.thrift.TException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import thrift.domain.KoalasRequest;
import thrift.domain.koalasRespone;

@Service("testService")
public class TestService {

    @Autowired
    KoalasTestService.Iface koalastestService;

    public void getRemoteRpc() throws TException {

        KoalasRequest request= new KoalasRequest (  );
        request.setxxxx1 ( 1 );
        request.setxxxx2( 1 );
        request.setxxxxx3 ( 1 );
        request.setxxxx4 ( "你好" );
        request.setxxxx5 ( 1 );
        KoalastestRespone respone = koalastestService.getRPC (  request);
        System.out.println (respone);
     }
}

第二种使用方式 注解形式

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:koalas="http://www.koalas.com/schema/ch"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
                           http://www.koalas.com/schema/ch
                           http://www.koalas.com/schema/ch.xsd">

    <koalas:annotation package="thrift.annotation.client.impl"/>
</beans>

@Service("testServiceSync")
public class TestServiceSync {

    @KoalasClient(zkPath = "127.0.0.1:2181",readTimeout = 5000*1000)
    KoalasTestService.Iface koalastestService;

    public void getRemoteRpc() throws TException {
        KoalasRequest request= new KoalasRequest (  );
        //request.setSource ( 10 );
        request.setxxxxx1 ( 1 );
        request.setxxxxx2 ( 1 );
        request.setxxxxx3 ( 1 );
        request.setxxxxx4 ( "你好啊-我是注解实现的" );
        request.setxxxxx5 ( 1 );
        KoalasRespone respone = koalastestService.getRPC (  request);
        System.out.println (respone);
     }

}

简单吧，一行xml配合一个注解，client的实现这样就完成了。。。关于服务端的使用去看我git上面的wiki吧，博客中不做多说明了，这次主要讲源码。

首先看client的主要代理类入口client.proxyfactory.KoalasClientProxy，这个类的作用是所有的client服务端通过thrift的代理都通过他来完成，放出源码如下

package client.proxyfactory;

import client.cluster.ILoadBalancer;
import client.cluster.Icluster;
import client.cluster.impl.DirectClisterImpl;
import client.cluster.impl.RandomLoadBalancer;
import client.cluster.impl.ZookeeperClisterImpl;
import client.invoker.KoalsaMothodInterceptor;
import client.invoker.LocalMockInterceptor;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.pool2.impl.AbandonedConfig;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.apache.thrift.async.TAsyncClientManager;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.protocol.TProtocol;
import org.apache.thrift.protocol.TProtocolFactory;
import org.apache.thrift.transport.TNonblockingTransport;
import org.apache.thrift.transport.TTransport;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import protocol.KoalasBinaryProtocol;
import transport.TKoalasFramedTransport;

import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * Copyright (C) 2018
 * All rights reserved
 * User: yulong.zhang
 * Date:2018年09月18日17:44:58
 */
public class KoalasClientProxy implements FactoryBean<Object>, ApplicationContextAware, InitializingBean {
    private final static Logger logger = LoggerFactory.getLogger ( KoalasClientProxy.class );
    public static final String ASYNC_IFACE = "AsyncIface";
    public static final String IFACE = "Iface";
    public static final String CLIENT = "Client";
    public static final String ASYNC_CLIENT = "AsyncClient";
    //请求体最大长度
    public static final int DEFUAL_MAXLENGTH = 10 * 1024 * 1024;
    //连接超时
    public static final int DEFUAL_CONNTIMEOUT = 5*1000;
    //读取超时
    public static final int DEFUAL_READTIMEOUT = 30*1000;

    //client端service
    private Class<?> serviceInterface;
    // 方式1：zk管理的动态集群,格式192.168.3.253:6666
    private String zkPath;
    // 方式2：指定的server列表，逗号分隔，#分隔权重,格式192.168.3.253:6666#10,192.168.3.253:6667#10
    private String serverIpPorts;

    //代理对象,所有client-server类型统一代理
    private Object loalsServiceProxy;
    //spring上下文对象
    private ApplicationContext applicationContext;
    // 同步还是异步,默认同步。
    private boolean async = false;
    //连接超时时间
    private int connTimeout=DEFUAL_CONNTIMEOUT;
    //读取超时时间
    private int readTimeout=DEFUAL_READTIMEOUT;
    //本地client测试用实现
    private String localMockServiceImpl;
    //重试
    private boolean retryRequest = true;
    private int retryTimes = 3;
    private GenericObjectPoolConfig genericObjectPoolConfig;
    //最大连接数
    private int maxTotal=100;
    //最大闲置数
    private int maxIdle=50;
    //最小闲置数量
    private int minIdle=10;
    private boolean lifo = true;
    private boolean fairness = false;
    private long maxWaitMillis = 30 * 1000;
    //多长时间运行一次
    private long timeBetweenEvictionRunsMillis = 3 * 60 * 1000;
    private long minEvictableIdleTimeMillis = 5 * 60 * 1000;

    //对象空闲多久后逐出, 当空闲时间>该值 且 空闲连接>最大空闲数 时直接逐出,
    //不再根据MinEvictableIdleTimeMillis判断  (默认逐出策略)
    private long softMinEvictableIdleTimeMillis = 10 * 60 * 1000;
    private int numTestsPerEvictionRun = 20;
    private boolean testOnCreate = false;
    private boolean testOnBorrow = false;
    private boolean testOnReturn = false;
    private boolean testWhileIdle = true;
    private Icluster icluster;
    private ILoadBalancer iLoadBalancer;
    private String env="dev";
    AbandonedConfig abandonedConfig;
    private boolean removeAbandonedOnBorrow = true;
    private boolean removeAbandonedOnMaintenance = true;
    private int removeAbandonedTimeout = 30;
    private int maxLength_ = DEFUAL_MAXLENGTH;
    private static int cores = Runtime.getRuntime().availableProcessors();
    private int asyncSelectorThreadCount = cores * 2;
    private static List<TAsyncClientManager> asyncClientManagerList = null;

    private String privateKey;
    private String publicKey;

    public String getPrivateKey() {
        return privateKey;
    }

    public void setPrivateKey(String privateKey) {
        this.privateKey = privateKey;
    }

    public String getPublicKey() {
        return publicKey;
    }

    public void setPublicKey(String publicKey) {
        this.publicKey = publicKey;
    }

    public int getMaxLength_() {
        return maxLength_;
    }

    public void setMaxLength_(int maxLength_) {
        this.maxLength_ = maxLength_;
    }

    public int getMaxTotal() {
        return maxTotal;
    }

    public void setMaxTotal(int maxTotal) {
        this.maxTotal = maxTotal;
    }

    public int getMaxIdle() {
        return maxIdle;
    }

    public void setMaxIdle(int maxIdle) {
        this.maxIdle = maxIdle;
    }

    public int getMinIdle() {
        return minIdle;
    }

    public void setMinIdle(int minIdle) {
        this.minIdle = minIdle;
    }

    public boolean isLifo() {
        return lifo;
    }

    public void setLifo(boolean lifo) {
        this.lifo = lifo;
    }

    public boolean isFairness() {
        return fairness;
    }

    public void setFairness(boolean fairness) {
        this.fairness = fairness;
    }

    public long getMaxWaitMillis() {
        return maxWaitMillis;
    }

    public void setMaxWaitMillis(long maxWaitMillis) {
        this.maxWaitMillis = maxWaitMillis;
    }

    public long getTimeBetweenEvictionRunsMillis() {
        return timeBetweenEvictionRunsMillis;
    }

    public void setTimeBetweenEvictionRunsMillis(long timeBetweenEvictionRunsMillis) {
        this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
    }

    public long getMinEvictableIdleTimeMillis() {
        return minEvictableIdleTimeMillis;
    }

    public void setMinEvictableIdleTimeMillis(long minEvictableIdleTimeMillis) {
        this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
    }

    public long getSoftMinEvictableIdleTimeMillis() {
        return softMinEvictableIdleTimeMillis;
    }

    public void setSoftMinEvictableIdleTimeMillis(long softMinEvictableIdleTimeMillis) {
        this.softMinEvictableIdleTimeMillis = softMinEvictableIdleTimeMillis;
    }

    public int getNumTestsPerEvictionRun() {
        return numTestsPerEvictionRun;
    }

    public void setNumTestsPerEvictionRun(int numTestsPerEvictionRun) {
        this.numTestsPerEvictionRun = numTestsPerEvictionRun;
    }

    public boolean isTestOnCreate() {
        return testOnCreate;
    }

    public void setTestOnCreate(boolean testOnCreate) {
        this.testOnCreate = testOnCreate;
    }

    public boolean isTestOnBorrow() {
        return testOnBorrow;
    }

    public void setTestOnBorrow(boolean testOnBorrow) {
        this.testOnBorrow = testOnBorrow;
    }

    public boolean isTestOnReturn() {
        return testOnReturn;
    }

    public void setTestOnReturn(boolean testOnReturn) {
        this.testOnReturn = testOnReturn;
    }

    public boolean isTestWhileIdle() {
        return testWhileIdle;
    }

    public void setTestWhileIdle(boolean testWhileIdle) {
        this.testWhileIdle = testWhileIdle;
    }

    public String getLocalMockServiceImpl() {
        return localMockServiceImpl;
    }

    public void setLocalMockServiceImpl(String localMockServiceImpl) {
        this.localMockServiceImpl = localMockServiceImpl;
    }

    public int getReadTimeout() {
        return readTimeout;
    }

    public void setReadTimeout(int readTimeout) {
        this.readTimeout = readTimeout;
    }

    public int getConnTimeout() {
        return connTimeout;
    }

    public void setConnTimeout(int connTimeout) {
        this.connTimeout = connTimeout;
    }

    public String getZkPath() {
        return zkPath;
    }

    public void setZkPath(String zkPath) {
        this.zkPath = zkPath;
    }

    public String getServerIpPorts() {
        return serverIpPorts;
    }

    public void setServerIpPorts(String serverIpPorts) {
        this.serverIpPorts = serverIpPorts;
    }

    public boolean isAsync() {
        return async;
    }

    public void setAsync(boolean async) {
        this.async = async;
    }

    public Object getLoalsServiceProxy() {
        return loalsServiceProxy;
    }

    public void setLoalsServiceProxy(Object loalsServiceProxy) {
        this.loalsServiceProxy = loalsServiceProxy;
    }

    public ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    public Class<?> getServiceInterface() {
        return serviceInterface;
    }

    public void setServiceInterface(Class<?> serviceInterface) {
        this.serviceInterface = serviceInterface;
    }

    public ILoadBalancer getiLoadBalancer() {
        return iLoadBalancer;
    }

    public void setiLoadBalancer(ILoadBalancer iLoadBalancer) {
        this.iLoadBalancer = iLoadBalancer;
    }

    public boolean isRemoveAbandonedOnBorrow() {
        return removeAbandonedOnBorrow;
    }

    public void setRemoveAbandonedOnBorrow(boolean removeAbandonedOnBorrow) {
        this.removeAbandonedOnBorrow = removeAbandonedOnBorrow;
    }

    public boolean isRemoveAbandonedOnMaintenance() {
        return removeAbandonedOnMaintenance;
    }

    public void setRemoveAbandonedOnMaintenance(boolean removeAbandonedOnMaintenance) {
        this.removeAbandonedOnMaintenance = removeAbandonedOnMaintenance;
    }

    public int getRemoveAbandonedTimeout() {
        return removeAbandonedTimeout;
    }

    public void setRemoveAbandonedTimeout(int removeAbandonedTimeout) {
        this.removeAbandonedTimeout = removeAbandonedTimeout;
    }

    public boolean isRetryRequest() {
        return retryRequest;
    }

    public void setRetryRequest(boolean retryRequest) {
        this.retryRequest = retryRequest;
    }

    public int getRetryTimes() {
        return retryTimes;
    }

    public void setRetryTimes(int retryTimes) {
        this.retryTimes = retryTimes;
    }

    public String getEnv() {
        return env;
    }
    public void setEnv(String env) {
        this.env = env;
    }
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    @Override
    public Object getObject(){
        if (getLoalsServiceProxy () == null) throw new RuntimeException ( "the Proxy can't be null" );
        return getLoalsServiceProxy ();
    }

    @Override
    public Class<?> getObjectType() {
        if (serviceInterface == null)
            return null;
        return getIfaceInterface ();
    }

    private Class<?> getIfaceInterface() {
        if (async)
            return getAsyncIfaceInterface ();
        else
            return getSynIfaceInterface ();
    }

    private Constructor<?> synConstructor;
    private Constructor<?> asyncConstructor;

    public Object getInterfaceClientInstance(TTransport socket,String server) {

        if (!async) {
            Class<?> clazz = getSynClientClass ();
            try {
                if (synConstructor == null) {
                    synConstructor = clazz.getDeclaredConstructor ( TProtocol.class );
                }
                TTransport transport  = new TKoalasFramedTransport ( socket, maxLength_ );
                if(this.getPrivateKey ()!=null && this.getPublicKey () != null){
                    ((TKoalasFramedTransport) transport).setRsa ( (byte) 1 );
                    ((TKoalasFramedTransport) transport).setPrivateKey ( this.privateKey );
                    ((TKoalasFramedTransport) transport).setPublicKey ( this.publicKey );
                }

                TProtocol protocol = new KoalasBinaryProtocol ( transport );

                return synConstructor.newInstance ( protocol );

            } catch (NoSuchMethodException e) {
                logger.error ( "the clazz can't find the Constructor with TProtocol.class" );
            } catch (InstantiationException e) {
                logger.error ( "get InstantiationException", e );
            } catch (IllegalAccessException e) {
                logger.error ( "get IllegalAccessException", e );
            } catch (InvocationTargetException e) {
                logger.error ( "get InvocationTargetException", e );
            }
        } else {
                if (null == asyncClientManagerList) {
                    synchronized (this) {
                        if (null == asyncClientManagerList) {
                            asyncClientManagerList = new ArrayList<> ();
                            for (int i = 0; i < asyncSelectorThreadCount; i++) {
                                try {
                                    asyncClientManagerList.add(new TAsyncClientManager());
                                } catch (IOException e) {
                                    e.printStackTrace ();
                                }
                            }
                        }
                    }
                }
            Class<?> clazz = getAsyncClientClass ();

            if (asyncConstructor == null) {
                try {
                    asyncConstructor = clazz.getDeclaredConstructor ( TProtocolFactory.class, TAsyncClientManager.class, TNonblockingTransport.class );
                } catch (NoSuchMethodException e) {
                    e.printStackTrace ();
                }
            }

            try {
                return asyncConstructor.newInstance ( new KoalasBinaryProtocol.Factory (), asyncClientManagerList.get (socket.hashCode () % asyncSelectorThreadCount), socket );
            } catch (InstantiationException e) {
                logger.error ( "get InstantiationException", e );
            } catch (IllegalAccessException e) {
                logger.error ( "get IllegalAccessException", e );
            } catch (InvocationTargetException e) {
                logger.error ( "get InvocationTargetException", e );
            }

        }
        return null;
    }

    private Class<?> getAsyncIfaceInterface() {
        Class<?>[] classes = serviceInterface.getClasses ();
        for (Class c : classes)
            if (c.isMemberClass () && c.isInterface () && c.getSimpleName ().equals ( ASYNC_IFACE )) {
                return c;
            }
        throw new IllegalArgumentException ( "can't find the interface AsyncIface,please make the service with thrift tools!" );
    }

    private Class<?> getSynIfaceInterface() {
        Class<?>[] classes = serviceInterface.getClasses ();
        for (Class c : classes)
            if (c.isMemberClass () && c.isInterface () && c.getSimpleName ().equals ( IFACE )) {
                return c;
            }
        throw new IllegalArgumentException ( "can't find the interface Iface,please make the service with thrift tools" );
    }

    private Class<?> getSynClientClass() {
        Class<?>[] classes = serviceInterface.getClasses ();
        for (Class c : classes)
            if (c.isMemberClass () && !c.isInterface () && c.getSimpleName ().equals ( CLIENT )) {
                return c;
            }
        throw new IllegalArgumentException ( "serviceInterface must contain Sub Class of Client" );
    }

    private Class<?> getAsyncClientClass() {
        Class<?>[] classes = serviceInterface.getClasses ();
        for (Class c : classes)
            if (c.isMemberClass () && !c.isInterface () && c.getSimpleName ().equals ( ASYNC_CLIENT )) {
                return c;
            }
        throw new IllegalArgumentException ( "serviceInterface must contain Sub Class of AsyncClient" );
    }

    @Override
    public boolean isSingleton() {
        return true;
    }

    @Override
    public void afterPropertiesSet(){

        if(serviceInterface==null){
            throw  new IllegalArgumentException ( "serviceInterface can't be null" );
        }

        if(zkPath==null && serverIpPorts==null){
            throw  new IllegalArgumentException ( "zkPath or serverIpPorts at least ones can't be null" );
        }

        Class<?> _interface = null;
        if (localMockServiceImpl != null && !StringUtils.isEmpty ( localMockServiceImpl.trim () )) {
            LocalMockInterceptor localMockInterceptor = new LocalMockInterceptor ( localMockServiceImpl );
            _interface = getIfaceInterface ();
            ProxyFactory pf = new ProxyFactory ( _interface, localMockInterceptor );
            setLoalsServiceProxy ( pf.getProxy () );
            return;
        }

        genericObjectPoolConfig = getGenericObjectPoolConfig ();
        abandonedConfig = getAbandonedConfig ();

        if (!StringUtils.isEmpty ( serverIpPorts )) {
            icluster = new DirectClisterImpl ( serverIpPorts, iLoadBalancer == null ? new RandomLoadBalancer () : iLoadBalancer, serviceInterface.getName (), async, connTimeout, readTimeout, genericObjectPoolConfig, abandonedConfig );
        } else{
            icluster = new ZookeeperClisterImpl ( zkPath ,iLoadBalancer == null ? new RandomLoadBalancer () : iLoadBalancer, serviceInterface.getName (),env,async,connTimeout,readTimeout,genericObjectPoolConfig,abandonedConfig);
        }

        KoalsaMothodInterceptor koalsaMothodInterceptor = new KoalsaMothodInterceptor ( icluster, retryTimes, retryRequest, this,readTimeout );
        _interface = getIfaceInterface ();

        loalsServiceProxy = new ProxyFactory ( _interface, koalsaMothodInterceptor ).getProxy ();

        logger.info ( "the service【{}】is start !", serviceInterface.getName () );
    }

    private AbandonedConfig getAbandonedConfig() {
        AbandonedConfig abandonedConfig = new AbandonedConfig ();
        abandonedConfig.setRemoveAbandonedOnBorrow ( isRemoveAbandonedOnBorrow () );
        abandonedConfig.setRemoveAbandonedOnMaintenance ( isRemoveAbandonedOnMaintenance () );
        abandonedConfig.setRemoveAbandonedTimeout ( getRemoveAbandonedTimeout () );
        return abandonedConfig;
    }

    private GenericObjectPoolConfig getGenericObjectPoolConfig() {
        GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig ();
        genericObjectPoolConfig.setMaxTotal ( getMaxTotal () );
        genericObjectPoolConfig.setMinIdle ( getMinIdle () );
        genericObjectPoolConfig.setMaxIdle ( maxIdle );
        genericObjectPoolConfig.setMaxWaitMillis ( getMaxWaitMillis () );
        genericObjectPoolConfig.setLifo ( isLifo () );
        genericObjectPoolConfig.setFairness ( isFairness () );
        genericObjectPoolConfig.setMinEvictableIdleTimeMillis ( getMinEvictableIdleTimeMillis () );
        genericObjectPoolConfig.setSoftMinEvictableIdleTimeMillis ( getSoftMinEvictableIdleTimeMillis () );
        genericObjectPoolConfig.setNumTestsPerEvictionRun ( getNumTestsPerEvictionRun () );
        genericObjectPoolConfig.setTimeBetweenEvictionRunsMillis ( getTimeBetweenEvictionRunsMillis () );
        genericObjectPoolConfig.setTestOnCreate ( isTestOnCreate () );
        genericObjectPoolConfig.setTestOnBorrow ( isTestOnBorrow () );
        genericObjectPoolConfig.setTestOnReturn ( isTestOnReturn () );
        genericObjectPoolConfig.setTestWhileIdle ( isTestWhileIdle () );
        return genericObjectPoolConfig;
    }

    public void destroy(){
        if(icluster!= null) icluster.destroy ();
    }

    public static void main(String[] args) {
        String a = "192.168.3.253:6666#10#thrift,192.168.3.253:6667#10#netty";
        System.out.println ( Arrays.toString ( a.split ( "[^0-9a-zA-Z_\\-\\.:#]+" ) ) );
    }
}

首先这个类实现了FactoryBean和InitializingBean，FactoryBean的实现方法getObject就是这个代理类本身的实现了，返回的对象为全局的setKoalasServiceProxy，注意一下这块的代码

        koalasServiceProxy = new ProxyFactory ( _interface, koalsaMothodInterceptor ).getProxy ();

可以看出koalasServiceProxy为spring代理出来的对象，代理的接口是interface，也就是我们thrift自动生成class的 xxxxxx.iface

private Class<?> getSynIfaceInterface() {
        Class<?>[] classes = serviceInterface.getClasses ();
        for (Class c : classes)
            if (c.isMemberClass () && c.isInterface () && c.getSimpleName ().equals ( IFACE )) {
                return c;
            }
        throw new IllegalArgumentException ( "can't find the interface Iface,please make the service with thrift tools" );
    }

这也就说为什么在我们的spring bean注入的类为 xxxxx.iface,对spring有一些知识的朋友一定会了解。（不懂的去学呗）

至于反射的实现肯定是在

        KoalsaMothodInterceptor koalsaMothodInterceptor = new KoalsaMothodInterceptor ( icluster, retryTimes, retryRequest, this,readTimeout );

里面了，里面的东西是什么，敬请期待下回分解！

https://gitee.com/a1234567891/koalas-rpc

koalas-RPC 个人作品，提供大家交流学习，有意见请私信，欢迎拍砖。客户端采用thrift协议，服务端支持netty和thrift的TThreadedSelectorServer半同步半异步线程模型，支持动态扩容，服务上下线，权重动态，可用性配置，页面流量统计等，持续为个人以及中小型公司提供可靠的RPC框架技术方案

更多学习内容请加高级java QQ群:825199617