简易RPC框架实现——8、引入SPI机制实现动态可拔插，引入一致性哈希进行负载均衡

最新推荐文章于 2023-09-01 09:49:33 发布
最新推荐文章于 2023-09-01 09:49:33 发布
阅读量724 收藏 2
点赞数
分类专栏： 手写RPC框架 文章标签： rpc 哈希算法 负载均衡
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fzzf__/article/details/125261891
版权

本章主要分为两个部分，第一部分是在负载均衡策略上引入了一致性哈希的算法，commit为798bcbb；第二个部分仿照Dubbo源码自己利用SPI机制实现了组件的可拔插，commit为9ac844a。

一致性哈希

在原本的负载均衡策略中，我们使用的是普通轮询负载均衡策略，在服务器的物理机硬件差距较大的情况下，会导致大量的请求堆积到硬件差的物理机上，严重的会造成宕机，因此，本章引入了一致性哈希负载均衡算法。

一致性哈希利用一个哈希环来防止某一个集群的服务宕机导致，所有散列表上的缓存失效的致命问题。如下图：
hash环
可以看到，每一个服务器在hash环上的定位需要经过两次hash计算，首先找到他位于哪个集群，之后找到它位于集群中环上的位置。当某一集群中某个节点消失后，会顺时针移动到下一集群，如下图：
删除节点
可以看到，使用这种hash环基本满足了要求，但是仍然存在些许问题。如果节点数量少，而hash环初始化空间很大，导致分布位置不均匀，集群的每个实例上缓存的数据量不一致，造成严重的数据倾斜。如果每一个集群只有一个节点，当这个集群消失时，他负责的所有缓存将交给下一个集群，下一个集群的压力会瞬间增大，有可能引发雪崩。

解决上述的两个问题我们可以引入虚拟节点，一个真实节点可以映射非常多的虚拟节点，这样的话可以使得各个节点在hash环上的分布非常均匀。

同时由于hash算法的随机性，当一个节点失效以后，他所持有的缓存也会均匀地分布给其他节点，如下图：
引入虚拟节点

代码示例

实现hash环，我们可以利用数组或者链表进行模拟，但这样的话查找hash值时可能需要排序，对于大量数据效率不高，因此我们采用TreeMap来模拟实现hash环。出于计算地考虑，本文采用hash算法为FNV1_32_HASH算法。新建一个ConsistentHash类，传入用户自定义地虚拟节点数（默认160个），之后映射到TreeMap中，获取实例，则根据客户端地址地hash值进行获取，如下：

public class ConsistentHash {
    private static TreeMap<Integer,String> Nodes = new TreeMap<>();
    private static int VIRTUAL_NODES = 160;
    private static List<Instance> instances = new ArrayList<>();
    public static final HashMap<String,Instance> map = new HashMap<>();
    public ConsistentHash(List<Instance> instances,int VIRTUAL_NODES){
        ConsistentHash.instances = instances;
        ConsistentHash.VIRTUAL_NODES = VIRTUAL_NODES;
        creatHashRound();
    }

    private void creatHashRound(){
        for(Instance instance : instances){
            String ip = instance.getIp();
            Nodes.put(getHash(ip),ip);
            map.put(ip,instance);
            for(int i = 0;i < VIRTUAL_NODES;i++){
                String virtualNodesName = getVirtualNodeName(ip, i);
                int hash = getHash(virtualNodesName);
                Nodes.put(hash,virtualNodesName);
            }
        }
    }
    private String getVirtualNodeName(String ip,Integer i){
        return ip + "&&VN" + i;
    }

    private String getRealNodeName(String virtualNodeName){
        return virtualNodeName.split("&&")[0];
    }


    public String getServer(String clientInfo){
        int hash = getHash(clientInfo);
        SortedMap<Integer,String> subMap = Nodes.tailMap(hash);
        String virtualNodeName;
        if(subMap == null || subMap.isEmpty()){
            virtualNodeName = Nodes.get(Nodes.firstKey());
        }else{
            virtualNodeName = subMap.get(subMap.firstKey());
        }
        return getRealNodeName(virtualNodeName);
    }



    public static int getHash(String str){
        final int p = 16777619;
        int hash = (int) 2166136261L;
        for(int i = 0; i < str.length();i++){
            hash = (hash^str.charAt(i)) * p;
            hash += hash << 13;
            hash ^= hash >> 7;
            hash += hash << 3;
            hash ^= hash >> 17;
            hash += hash << 5;
            if(hash < 0){
                hash = Math.abs(hash);
            }
        }
        return hash;
    }
}

实现LoadBalance接口，由于在一致性hash算法中，每个客户端每次获得的服务器实例应该相同，因此我们根据客户端地址进行获取实例，如下：

public class IpHashLoadBalance implements LoadBalance {

    private String address;


    @Override
    public Instance getInstance(List<Instance> list) {
        ConsistentHash ch = new ConsistentHash(list,100);
        HashMap<String, Instance> map = ch.map;
        return map.get(ch.getServer(address));
    }

    public void setAddress(String address){
        this.address = address;
    }
    
}

完成了一致性哈希负载均衡算法的引入。

实现SPI机制

SPI 全称为 Service Provider Interface，是一种服务发现机制。SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口替换实现类。正因此特性，我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。机制如下：

SPI机制
SPI实际上是“接口+策略模式+配置文件”实现的动态加载机制。在系统设计中，模块之间通常基于接口编程，不直接显示指定实现类。一旦代码里指定了实现类，就无法在不修改代码的情况下替换为另一种实现。为了达到动态可插拔的效果，java提供了SPI以实现服务发现，但是java原生的SPI模式在加载外部配置时，会将所有的类进行加载，大量增加了服务器负载。因此我们这里实现SPI机制仿照的dubbo源码中采用键值对配置的方式。为了能够加载指定接口，我们需要自定义注解，以此来标注：

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface SPI {
}

之后需要自定义加载器，其中创建加载方法，具体代码如下，详细内容见代码注释：

public final class ExtensionLoader<T> {

    private static final Logger logger = LoggerFactory.getLogger(ExtensionLoader.class);

    /**
     *扩展类存放的地址
     */
    private static final String SERVICE_DIRECTORY = "META-INF/extensions/";
    /**
     *扩展加载器的缓存
     */
    private static final Map<Class<?>,ExtensionLoader<?>> EXTENSION_LOADER = new ConcurrentHashMap<>();
    /**
     *扩展类实例的缓存
     */
    private static final Map<Class<?>,Object> EXTENSION_INSTANCE = new ConcurrentHashMap<>();


    /**
     *扩展类Class文件
     */
    private final Class<?> type;
    /**
     *扩展类实例持有者Holder的缓存
     */
    private final Map<String,Holder<Object>> cachedInstances = new ConcurrentHashMap<>();
    /**
     *扩展类配置列表缓存
     */
    private final Holder<Map<String,Class<?>>> cachedClass = new Holder<>();

    /**
     *构造器指定Class类型
     */
    public ExtensionLoader(Class<?> type){this.type = type;}

    /**
    * @Description: 根据类型得到扩展加载器
    * @Param: Class文件
    * @return: 扩展类型加载器
    * @Author: fzzfrjf
    * @Date: 2022/6/13
    */
    public static <S> ExtensionLoader<S> getExtensionLoader(Class<S> type){
        if(type == null){
            throw new IllegalArgumentException("Extension type should not be null");
        }
        if(!type.isInterface()){
            throw new IllegalArgumentException("Extension type must be an interface");
        }
        if(type.getAnnotation(SPI.class) == null){
            throw new IllegalArgumentException("Extension type must be annotated by @SPI");
        }
        ExtensionLoader<S> extensionLoader = (ExtensionLoader<S>) EXTENSION_LOADER.get(type);
        if(extensionLoader == null){
            EXTENSION_LOADER.putIfAbsent(type,new ExtensionLoader<S>(type));
            extensionLoader = (ExtensionLoader<S>) EXTENSION_LOADER.get(type);
        }
        return extensionLoader;
    }

    /**
    * @Description: 获取扩展实例对象
    * @Param: name 扩展类在配置文件中的名字
    * @return: 扩展类实例对象
    * @Author: fzzfrjf
    * @Date: 2022/6/13
    */
    public T getExtension(String name){
        if(StringUtil.isBlank(name)){
            throw new IllegalArgumentException("Extension name should not be null or empty");
        }
        Holder<Object> holder = cachedInstances.get(name);
        if(holder == null){
            cachedInstances.putIfAbsent(name,new Holder<>());
            holder = cachedInstances.get(name);
        }
        Object instance = holder.getValue();
        if(instance == null){
            synchronized (holder){
                if(instance == null){
                    instance = createExtension(name);
                    holder.setValue(instance);
                }
            }
        }
        return (T) instance;
    }

    /**
    * @Description: 创建对应名字的扩展类对象
    * @Param: name 扩展类在配置文件中的名字
    * @return: 扩展类对象
    * @Author: fzzfrjf
    * @Date: 2022/6/13
    */
    private T createExtension(String name){
        Map<String, Class<?>> extensionClasses = getExtensionClasses();
        Class<?> clazz = extensionClasses.get(name);
        if(clazz == null){
            throw new RuntimeException("No such extension of name:" + name);
        }
        T instance = (T) EXTENSION_INSTANCE.get(clazz);
        if(instance == null){
            try{
                EXTENSION_INSTANCE.putIfAbsent(clazz,clazz.newInstance());
                instance = (T) EXTENSION_INSTANCE.get(clazz);
            }catch (Exception e){
                logger.error(e.getMessage());
                throw new RuntimeException("Fail to create instance of the extension class:" + clazz);
            }
        }
        return instance;
    }

    /**
    * @Description: 获取当前类型的所有扩展类
    * @Param: 
    * @return: 扩展类名字与对应的全类名的Map
    * @Author: fzzfrjf
    * @Date: 2022/6/13
    */
    private Map<String,Class<?>> getExtensionClasses(){
        Map<String, Class<?>> classes = cachedClass.getValue();
        if(classes == null){
            synchronized (cachedClass){
                classes = cachedClass.getValue();
                if(classes == null){
                    classes = new HashMap<>();
                    loadDirectory(classes);
                    cachedClass.setValue(classes);
                }
            }
        }
        return classes;
    }


    /**
    * @Description: 获取指定配置文件中所有的配置
    * @Param: Map<String,Class<?>>
    * @return: void
    * @Author: fzzfrjf
    * @Date: 2022/6/13
    */
    private void loadDirectory(Map<String,Class<?>> extensionClasses){
        String fileName = ExtensionLoader.SERVICE_DIRECTORY +type.getName();
        try{
            Enumeration<URL> urls;
            ClassLoader classLoader = ExtensionLoader.class.getClassLoader();
            urls = classLoader.getResources(fileName);
            if(urls != null){
                while(urls.hasMoreElements()){
                    URL url = urls.nextElement();
                    loadResource(extensionClasses,classLoader,url);
                }
            }
        }catch (IOException e){
            logger.error(e.getMessage());
        }
    }

    /**
    * @Description: 读取指定配置文件中不同的实例化对象配置并放入缓存
    * @Param:
    * @return: void
    * @Author: fzzfrjf
    * @Date: 2022/6/13
    */
    private void loadResource(Map<String,Class<?>> extensionClasses,ClassLoader classLoader,URL url){
        try(BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream(), StandardCharsets.UTF_8))){
            String line;
            while((line = reader.readLine()) != null){
                final int ci = line.indexOf("#");
                if(ci >= 0){
                    line = line.substring(0,ci);
                }
                line = line.trim();
                if(line.length() > 0){
                    try{
                        final int ei = line.indexOf("=");
                        String name = line.substring(0,ei).trim();
                        String clazzName = line.substring(ei + 1).trim();
                        if(name.length() > 0 && clazzName.length() > 0){
                            Class<?> clazz = classLoader.loadClass(clazzName);
                            extensionClasses.put(name,clazz);
                        }
                    }catch (ClassNotFoundException e){
                        logger.error(e.getMessage());
                    }
                }
            }
        }catch (IOException e){
            logger.error(e.getMessage());
        }
    }
}

Holder为仿照dubbo中持有对象实例的Holder构造。

之后我们只需在resources文件中创建对应的键值对：

文件结构
最终可以在需要的位置加载我们需要的接口实现组件，例如NettyServer构造方法中选择序列化方法：

this.serializer = ExtensionLoader.getExtensionLoader(CommonSerializer.class).getExtension("kryo");

最终完成了类似dubbo的SPI机制的实现。

fzzfrjf
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Go-GoConfig一个可插拔的动态配置库
08-14
Go Config 一个可插拔的动态配置库
从零实现RPC框架2: 插件化设计 SPI机制
xsjzn的博客
04-12 1444
1.什么是SPI？ SPI的全称是Service Provider Interface, 直译过来就是"服务提供接口"，为了降低耦合，实现在模块装配的时候动态指定具体实现类的一种服务发现机制。动态地为接口寻找服务实现。它的核心来自于ServiceLoader这个类。 java SPI应用场景很广泛，在Java底层和一些框架中都很常用，比如java数据驱动加载。Java底层定义加载接口后，由不同的厂商提供驱动加载的实现方式，当我们需要加载不同的数据库的时候，只需要替换数据库对应的驱动加载jar包，就可以进行使
【自己动手实现一个简单的RPC框架】8、[v4.3]增加SPI机制
qq_38939822的博客
05-30 422
本文代码地址：https://github.com/MSC419/msc-rpc-framework 文章目录0.实现的改进1.SPI机制1.1 Java SPI1.1.1 示例1.1.2 SPI作用1.1.3 源码分析1.2 Dubbo SPI1.2.1 示例1.2.2 源码分析1.3 RPC SPI总结学到的知识 0.实现的改进 1.增加SPI机制，方便我们为程序提供扩展功能 1.SPI机制 参考: 搞懂dubbo的SPI扩展机制 - 知乎 (zhihu.com) 从零开始实现简单 RPC 框架 .
手撸RPC----SPI机制
m0_52376306的博客
09-01 142
一、spi机制 SPI（Service Provider Interface），是JDK内置的一种服务提供发现机制，可以用来启用框架扩展和替换组件，主要是被框架的开发人员使用，比如java.sql.Driver接口，其他不同厂商可以针对同一接口做出不同的实现，MySQL和PostgreSQL都有不同的实现提供给用户，而Java的SPI机制可以为某个接口寻找服务实现。Java中SPI机制主要思想是将装配的控制权移到程序之外，在模块化设计中这个机制尤其重要，其核心思想就是解耦。 SPI整体机制图如下：
可插拔组件设计机制—SPI
京东科技开发者
03-14 542
SPI 的全称是Service Provider Interface,即提供服务接口；是一种服务发现机制，SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。本篇文章聚焦SPI的使用场景及使用介绍。
基于贪心算法的一致性哈希负载均衡优化-论文
05-22
基于贪心算法的一致性哈希负载均衡优化
一致性哈希算法以及其PHP实现详细解析
12-19
一致性哈希算法是一种在分布式系统中实现负载均衡的策略，特别是在缓存服务、数据库分片等领域广泛应用。它的核心思想是解决传统哈希算法在节点增减时导致大规模数据迁移的问题。传统的哈希算法，如简单地对哈希值...
基于C# 实现的一致性哈希算法
最新发布
04-30
一致性哈希算法是一种分布式哈希（Distributed Hash Table, DHT）技术，它解决了在分布式环境中数据分片和负载均衡的问题。在传统的哈希算法中，如果增加或减少服务器节点，会导致大量数据重新分配，而一致性哈希...
PHP实现的一致性哈希算法完整实例
12-19
通过这样的实现，开发者可以方便地在PHP项目中使用一致性哈希算法，以实现负载均衡、分布式缓存等目的。在实际应用中，可以根据需求调整虚拟节点的数量，选择合适的哈希算法，并结合其他策略（如加权分布）来优化...
24一致性哈希：如何高效地均衡负载？1
08-03
总结起来，一致性哈希算法解决了传统哈希算法在分布式环境中的不足，通过巧妙的设计实现了在节点增减时数据迁移量的最小化，同时保证了数据分布的均衡性和系统的可扩展性。它在现代分布式数据库、缓存服务（如...
Dubbo中的SPI机制实现，自定义对接SPI
LeoHan
11-20 1611
SPI在java中称为Service Provider Interface，Dubbo中对java的spi机制自己实现相对应的逻辑。 我们以Dubbo中的Protociol为例，一般我们去获取对应的Protocol的时候都是通过如下方式： ExtensionLoader.getExtensionLoader(Protocol.class).getAdaptiveExtension(); // 或者 ExtensionLoader.getExtensionLoader(Protocol.class).getE
仿照java的spi，dubbo实现自己的spi
chouyandeng3609的博客
05-06 231
1、平时遇到过的使用java的spi的例子 1）mysql的驱动 2）spring-web 2、spi的设计目标 面向对象的设计里，模块之间是接口编程，模块之间不对实现类进行硬编码，如果实现类写死在代码里，想要换一种实现，就需要修改代码，为了不在代码里写...
【无标题】如何实现可插拔配置？
YYniannian的博客
07-25 375
我的项目逐渐成型了之后，有挺多小伙伴吐槽过我的项目太重了，依赖的中间件有点多。
手把手教你手写一个RPC（实现SPI、注册中心等）
qq_250161537
01-05 2094
手写一个简易的Rpc，实现SPI、zookeeper注册中心、负载均衡等
从零开始实现简单 RPC 框架 2：扩展利器 SPI
小新是也的博客
08-15 337
RPC 框架有很多可扩展的地方，最好的做法就是留下扩展点，让使用者可以不需要修改框架，就能自己去实现扩展。 JDK 原生已经为我们提供了 SPI 机制，ccx-rpc 在此基础上，进行了性能优化和功能增强。
让我带你弄明白什么是RPC ,帮你整理一下你的小脑瓜！
m0_58559010的博客
06-22 1414
一、系统架构的演变 1、单一应用架构 将所有的功能模块都放在1个工程中编码、编译、打包并且部署在1个tomcat容器中的架构。这样维护成本比较低。 优点： 项目前期开发周期快，团队成员少的时候能够快速迭代； 架构简单：MVC架构，只需借助IDE开发，调试即可。 易于测试：只通过单元测试或者浏览器完成 易于部署 缺点： 随着时间推移业务增加，功能不断迭代，项目会变得臃肿，业务耦合严重 新增业务困难 核心业务与边缘业务混在一块儿，出现问题相互影响。 2、垂直架..
带你手写基于 Spring 的可插拔式 RPC 框架（五）注册中心
07-04 210
注册中心代码使用 zookeeper 实现，通过图片来看看我们注册中心的架构。 首先说明， zookeeper 的实现思路和代码是参考架构探险这本书上的，另外在 github 和我前面配置文件中的 zookeeper 服务器是用的1个月免费适用的阿里云，大家也可以用它当测试用。 不多说，一次性给出注册中心全部代码。 客户端对应的注册中心接口 public interface RegisterCe...
插拔式代码
weixin_43623808的博客
05-16 207
常用 const apiList = ['api/text ', '.api/test', ' ']; const newList = []; apiList.map(item => { let apiName = item.trim(); //去除空格 if (apiName) { newList.push(`http://www.test.com/${apiName}`); } }) 这种代码属于解决当前需求的代码，也是我一直用的 不易扩展
OSGi动态拔插，动态部署，动态权限菜单
paladin1988的专栏
12-01 3575
今天和思雨同学把动态菜单，权限以及Bundle的动态拔插基本给解决了。 大致的场景是这样的： 1、进行权限控制，RBAC0，权限-角色-菜单，菜单只是对应到页面，不涉及页面的具体操作组件，实现起来不是太麻烦。（之前本来打算把权限控制到按钮的，但是项目只要求到页面就方便了很多）。     2、权限控制这块，之前打算控制到组件，用的自定义标签，TagSup...
负载均衡的一致性哈希算法是如何实现的？
04-21
一致性哈希算法是通过在节点和哈希环之间建立映射来实现的，它能够让节点的添加和删除对负载均衡的影响降到最低。当一个请求过来时，它会被哈希函数映射到一个特定的节点上，这个节点就会处理请求。而在节点增减时，它们在哈希环上的位置和映射关系也会变化，但这个变化会尽可能的小，已经映射到某个节点上的键，通常不会因为节点的增减而重新映射到别的节点上。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值