# noob-rpc-core
loadbalancer：
	- LoadBalancer
	- RoundRobinLoadBalancer
	- RandomLoadBalancer
	- ConsistentHashLoadBalancer
	- LoadBalancerKeys
	- LoadBalancerFactory

config:
	- RpcConfig

proxy：
	- ServiceProxy

test：
	- VertxTcpServerTest
	
# sample-consumer
application.properties

1.多种负载均衡器的实现

在学习负载均衡的时候，可以参考Nginx 的负载均衡算法实现，此处依次实现轮询、随机、一致性 Hash三种负载均衡算法。

在RPC项目中新建loadbalancer包,将所有负载均衡器相关的代码放到该包下。

负载均衡器通用接口

编写负载均衡器通用接口：提供一个选择服务方法，接受请求参数和可用服务列表，可以根据这些信息进行选择

/**
 * 负载均衡器（消费端使用）
 */
public interface LoadBalancer {

    /**
     * 选择服务调用
     *
     * @param requestParams       请求参数
     * @param serviceMetaInfoList 可用服务列表
     * @return
     */
    ServiceMetaInfo select(Map<String, Object> requestParams, List<ServiceMetaInfo> serviceMetaInfoList);
}

轮询负载均衡器

使用JUC包下的AtomicInteger实现院子计数器，防止并发冲突问题

/**
 * 轮询负载均衡器
 */
public class RoundRobinLoadBalancer implements LoadBalancer {

    /**
     * 当前轮询的下标
     */
    private final AtomicInteger currentIndex = new AtomicInteger(0);

    @Override
    public ServiceMetaInfo select(Map<String, Object> requestParams, List<ServiceMetaInfo> serviceMetaInfoList) {
        if (serviceMetaInfoList.isEmpty()) {
            return null;
        }
        // 只有一个服务，无需轮询
        int size = serviceMetaInfoList.size();
        if (size == 1) {
            return serviceMetaInfoList.get(0);
        }
        // 取模算法轮询
        int index = currentIndex.getAndIncrement() % size;
        return serviceMetaInfoList.get(index);
    }
}

随机负载均衡器

使用Java自带的Random类实现随机选择

/**
 * 随机负载均衡器
 */
public class RandomLoadBalancer implements LoadBalancer {

    private final Random random = new Random();

    @Override
    public ServiceMetaInfo select(Map<String, Object> requestParams, List<ServiceMetaInfo> serviceMetaInfoList) {
        int size = serviceMetaInfoList.size();
        if (size == 0) {
            return null;
        }
        // 只有 1 个服务，不用随机
        if (size == 1) {
            return serviceMetaInfoList.get(0);
        }
        return serviceMetaInfoList.get(random.nextInt(size));
    }
}

一致性 Hash负载均衡器

使用TreeMap实现一致性Hash环，该数据结构提供了ceilingEntry 和firstEntry两个方法，便于获取符合算法要求的节点。

此处实现注意两个点：

（1）根据requestParams对象计算Hash值，此处只是简单地调用了对象的hashCode方法,可以根据需求实现自己的Hash算法

（2）每次调用负载均衡器时，都会重新构造Hash环,这是为了能够即时处理节点的变化

/**
 * 一致性哈希负载均衡器
 */
public class ConsistentHashLoadBalancer implements LoadBalancer {

    /**
     * 一致性 Hash 环，存放虚拟节点
     */
    private final TreeMap<Integer, ServiceMetaInfo> virtualNodes = new TreeMap<>();

    /**
     * 虚拟节点数
     */
    private static final int VIRTUAL_NODE_NUM = 100;

    @Override
    public ServiceMetaInfo select(Map<String, Object> requestParams, List<ServiceMetaInfo> serviceMetaInfoList) {
        if (serviceMetaInfoList.isEmpty()) {
            return null;
        }

        // 构建虚拟节点环
        for (ServiceMetaInfo serviceMetaInfo : serviceMetaInfoList) {
            for (int i = 0; i < VIRTUAL_NODE_NUM; i++) {
                int hash = getHash(serviceMetaInfo.getServiceAddress() + "#" + i);
                virtualNodes.put(hash, serviceMetaInfo);
            }
        }

        // 获取调用请求的 hash 值
        int hash = getHash(requestParams);

        // 选择最接近且大于等于调用请求 hash 值的虚拟节点
        Map.Entry<Integer, ServiceMetaInfo> entry = virtualNodes.ceilingEntry(hash);
        if (entry == null) {
            // 如果没有大于等于调用请求 hash 值的虚拟节点，则返回环首部的节点
            entry = virtualNodes.firstEntry();
        }
        return entry.getValue();
    }


    /**
     * Hash 算法，可自行实现
     *
     * @param key
     * @return
     */
    private int getHash(Object key) {
        return key.hashCode();
    }
}

2.支持配置和扩展负载均衡器

一个成熟的RPC框架可能会支持多个负载均衡器，像序列化器和注册中心-样，目前设定需求是让开发者能够填写配置来指定使用的负载均衡器，并且支持自定义负载均衡器，让框架更易用、更利于扩展。要实现这点，开发方式和序列化器、注册中心都是一样的，都可以使用工厂创建对象、使用SPI动态加载自定义的注册中心。

（1）定义LoadBalancerKeys负载均衡器常量：定义所有支持的负载均衡器键名

/**
 * 负载均衡器键名常量
 */
public interface LoadBalancerKeys {

    /**
     * 轮询
     */
    String ROUND_ROBIN = "roundRobin";

    /**
     * 随机
     */
    String RANDOM = "random";

    /**
     * 一致性Hash
     */
    String CONSISTENT_HASH = "consistentHash";

}

（2）工厂模式构建：LoadBalancerFactory（SpiLoader装配）

LoadBalancerFactory可参考此前的序列化器、注册中心相关进行修改即可

/**
 * 负载均衡器工厂（工厂模式，用于获取负载均衡器对象）
 */
public class LoadBalancerFactory {

    static {
        SpiLoader.load(LoadBalancer.class);
    }

    /**
     * 默认负载均衡器
     */
    private static final LoadBalancer DEFAULT_LOAD_BALANCER = new RoundRobinLoadBalancer();

    /**
     * 获取实例
     *
     * @param key
     * @return
     */
    public static LoadBalancer getInstance(String key) {
        return SpiLoader.getInstance(LoadBalancer.class, key);
    }

}

（3）SPI机制装配：在META-INF的rpc/system目录下引入负载均衡接口的SPI配置文件

# SPI配置文件名称
com.noob.rpc.loadbalancer.LoadBalancer

# SPI配置文件内容
roundRobin=com.noob.rpc.loadbalancer.RoundRobinLoadBalancer
random=com.noob.rpc.loadbalancer.RandomLoadBalancer
consistentHash=com.noob.rpc.loadbalancer.ConsistentHashLoadBalancer

（4）为RpcConfig全局配置新增负载默认负载均衡器配置

@Data
public class RpcConfig {
	 /**
     * 负载均衡配置
     */
    private String loadBalancer = LoadBalancerKeys.ROUND_ROBIN;
}

3.应用负载均衡器（服务消费方）

修改ServiceProxy代码，将原有“固定调用第一个服务节点”调整为“调用负载均衡器获取一个服务节点”

					 // 方式2：调用负载均衡算法选择一个服务节点
            LoadBalancer loadBalancer = LoadBalancerFactory.getInstance(rpcConfig.getLoadBalancer());
            // 将调用方法名（请求路径）作为负载均衡参数
            Map<String,Object> requestParams = new HashMap<>();
            requestParams.put("methodName",rpcRequest.getMethodName());
            ServiceMetaInfo selectedServiceMetaInfo = loadBalancer.select(requestParams,serviceMetaInfoList);

上述代码中，给负载均衡器传入了一个requestParams HashMap，并且将请求方法名作为参数放到了Map中。如果使用的是一致性 Hash算法，那么会根据requestParams计算Hash值，调用相同方法的请求Hash值肯定相同，所以总会请求到同一个服务器节点上。

4.测试

测试负载均衡算法

可替换不同的LoadBalancer测试负载均衡效果

/**
 * 负载均衡器测试
 */
public class LoadBalancerTest {

    final LoadBalancer loadBalancer = new ConsistentHashLoadBalancer();

    @Test
    public void select() {
        // 请求参数
        Map<String, Object> requestParams = new HashMap<>();
        requestParams.put("methodName", "apple");
        // 服务列表
        ServiceMetaInfo serviceMetaInfo1 = new ServiceMetaInfo();
        serviceMetaInfo1.setServiceName("myService");
        serviceMetaInfo1.setServiceVersion("1.0");
        serviceMetaInfo1.setServiceHost("localhost");
        serviceMetaInfo1.setServicePort(1234);
        ServiceMetaInfo serviceMetaInfo2 = new ServiceMetaInfo();
        serviceMetaInfo2.setServiceName("myService");
        serviceMetaInfo2.setServiceVersion("1.0");
        serviceMetaInfo2.setServiceHost("blog.holic-x.com");
        serviceMetaInfo2.setServicePort(80);
        List<ServiceMetaInfo> serviceMetaInfoList = Arrays.asList(serviceMetaInfo1, serviceMetaInfo2);
        // 连续调用 3 次
        ServiceMetaInfo serviceMetaInfo = loadBalancer.select(requestParams, serviceMetaInfoList);
        System.out.println(serviceMetaInfo);
        Assert.assertNotNull(serviceMetaInfo);
        serviceMetaInfo = loadBalancer.select(requestParams, serviceMetaInfoList);
        System.out.println(serviceMetaInfo);
        Assert.assertNotNull(serviceMetaInfo);
        serviceMetaInfo = loadBalancer.select(requestParams, serviceMetaInfoList);
        System.out.println(serviceMetaInfo);
        Assert.assertNotNull(serviceMetaInfo);
    }
}

测试负载均衡调用

sample-consumer中配置application.properties：配置指定的负载均衡算法：rpc.loadBalancer=random

首先在不同的端口启动2个服务提供者，然后启动服务消费者项目，通过Debug或者控制台输出来观察每次请求的节点地址。

扩展说明

扩展说明

（1）实现更多不同算法的负载均衡器

参考思路:比如最少活跃数负载均衡器，选择当前正在处理请求的数量最少的服务提供者

（2）自定义一致性Hash算法中的Hash算法

参考思路:比如根据请求客户端的IP地址来计算Hash值，保证同IP的请求发送给相同的服务提供者

昵称

邮箱

网址

按正序
按倒序
按热度

【noob-rpc】⑨扩展版RPC-负载均衡（服务消费端）

预览: