java实现简易版简易版dubbo

一、dubbo简介

实现一个简易版的dubbo，首先看下dubbo是什么

dubbo是阿里开源的rpc框架，目前是apache顶级开源项目，可以用来构建微服务。社区已经到了3.0版本，生态活跃，原来是java写的，现在有go版本，支持云原生。

研究dubbo的目的

dubbo浑身是宝，用到了zk/javassit/netty/spring/spi等技术，可以说看懂了dubbo源码，对自己是十分有帮助的。不仅能学习优秀的代码设计，理解solid原则，更能深刻理解rpc的实现原理，了解各种技术的运用。
当前目前有不少大公司在使用，dubbo也是经常被问的面试题，包括dubbo spi/dubbo通信流程，对于简历也是十分加分的。
手写dubbo，比看懂dubbo要难得多，让自己透彻理解dubbo的设计细节，内功修炼更上一层楼，以后再去看其他源码会非常快。

二、架构设计

博主在看懂dubbo源码的基础上，自己动手实现dubbo最基础的功能，包括服务注册、服务发现、服务负载均衡、网络通信、与spring boot集成等，以便更好掌握dubbo的实现原理。实现架构如下：

Api层主要是面向框架使用者，通过注解就能使用简易版dubbo。并实现了在spring boot中进行自动配置。

目前微服务都是基于spring boot搭建的，大部分公司都从spring迁移到spring boot。整个实例都是基于spring boot来构建的，基于自动化配置搞个starter，配置下yaml就能使用miniDubbo，无需配置xml。

服务发现基于zookeeper实现，所有发现的实例，暂存在注册目录中。

Zookeeper是一个树状的结构，有三种节点类型，永久节点（需要自己删除）、临时节点（有会话的概念，当zookeeper监听到会话断开时，会删除临时节点）、有序节点。在dubbo中主要用的是临时节点，用于实时感知服务实例上下线。

路径格式：

/miniDubbo/${group}/${className}/providers/${ip:port}

集群失败策略：主要有failover/failsafe/failback。

也就是当consumer调用某个provider失败时，采取的策略，failover表示失败转移，重试下一台实例；failsafe表示不重试，不抛出异常，返回null。

模拟dubbo协议，这里通过netty实现网络通信，底层使用JSON序列化，通过长度 + body的协议防止粘包。

Netty是java领域的一套高性能的nio异步网络编程框架，底层也是基于java nio，已经封装好了网络编程，实现网络通信非常方便。在dubbo中用于provider-consumer建立长连接，避免重复建立连接。

整体思路是：consumer调用接口方法时，对接口进行JDK代理，代理逻辑是通过服务发现找到一台可用实例，将请求的类名、方法名、入参进行打包、编码，通过网络请求发送给provider。在服务端拿到请求的类名、方法名、入参后，通过反射调用服务实例，并将结果的返回给consumer。

三、开发工具

需要安装如下工具。

IDEA+JDK8+MAVEN
zookeeper

四、一步步实现

这里给出部分代码，具体参考github：miniDubbo

4.1 客户端消费实现

4.1.1 扫描Reference注解，注入dubbo依赖

定义一个Reference注解，这个注解必须是运行时注解，且至少可用在属性上。

package com.jessin.practice.dubbo.processor;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 消费端注解
 * @Author: jessin
 * @Date: 19-11-25 下午9:48
 */
@Target({ ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
// 必须写为runtime，否则获取不到
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Reference {

    String group() default "";

    String version() default "1.0.0";

    String timeout() default "3000";

    String failStrategy() default "failover";

    String retryCount() default "3";
}

在spring bean实例化后初始化前，对应的是InstantiationAwareBeanPostProcessor#postProcessProperties，这个是bean实例化后第一个扩展点，且在aware方法之前，进行依赖反射注入，并设置动态代理，代理实现该属性对应的接口。

package com.jessin.practice.dubbo.processor;

import com.jessin.practice.dubbo.config.InterfaceConfig;
import com.jessin.practice.dubbo.config.MiniDubboProperties;
import java.lang.reflect.Field;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;

/**
 * @Author: jessin
 * @Date: 19-11-25 下午9:49
 */
@Slf4j
public class ReferenceBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter {
    private MiniDubboProperties miniDubboProperties;
    public ReferenceBeanPostProcessor(MiniDubboProperties miniDubboProperties) {
        this.miniDubboProperties = miniDubboProperties;
    }

    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
            throws BeansException {
        Field[] fields = bean.getClass().getDeclaredFields();
        for (Field field : fields) {
            boolean isExist = field.isAnnotationPresent(Reference.class);
            if (isExist) {
                try {
                    if (!field.getType().isInterface()) {
                        throw new RuntimeException("dubbo依赖不是接口：" + field.getType().getName());
                    }
                    Reference  ref = field.getAnnotation(Reference.class);
                    log.info("尝试注入接口代理，bean的{}属性为：{}", beanName, ref);
                    // 私有属性，必须设置为可访问
                    field.setAccessible(true);
                    field.set(bean, JdkDynamicProxy.createProxy(field.getType(), transform(ref), miniDubboProperties));
                } catch (IllegalAccessException e) {
                    log.error("设置jdk实例出错啦：{}", field);
                }
            }
        }
        return pvs;
    }

    private InterfaceConfig transform(Reference ref) {
        InterfaceConfig interfaceConfig = new InterfaceConfig();
        interfaceConfig.setGroup(ref.group());
        interfaceConfig.setVersion(ref.version());
        interfaceConfig.setTimeout(ref.timeout());
        interfaceConfig.setFailStrategy(ref.failStrategy());
        interfaceConfig.setRetryCount(ref.retryCount());
        return interfaceConfig;
    }
}

动态代理的逻辑非常简单，基于注册目录找到可用的DubboInvoker，并发起网络请求，传输请求id、类名、入参、超时时间、版本等信息。

package com.jessin.practice.dubbo.processor;

import com.alibaba.fastjson.JSONObject;
import com.jessin.practice.dubbo.config.InterfaceConfig;
import com.jessin.practice.dubbo.config.MiniDubboProperties;
import com.jessin.practice.dubbo.invoker.FailfastClusterInvoker;
import com.jessin.practice.dubbo.invoker.RpcInvocation;
import com.jessin.practice.dubbo.registry.RegistryDirectory;
import com.jessin.practice.dubbo.transport.Response;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import lombok.extern.slf4j.Slf4j;
/**
 * @Author: jessin
 * @Date: 19-11-25 下午9:54
 */
@Slf4j
public class JdkDynamicProxy implements InvocationHandler {

    private String clazzName;

    private Object proxy;

    private RegistryDirectory registryDirectory;

    private FailfastClusterInvoker failfastClusterInvoker;

    private InterfaceConfig interfaceConfig;

    private MiniDubboProperties miniDubboProperties;

    public JdkDynamicProxy(Class clazz, InterfaceConfig interfaceConfig, MiniDubboProperties miniDubboProperties) {
        proxy = Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class[]{clazz}, this);
        this.clazzName = clazz.getName();
        registryDirectory = new RegistryDirectory(clazzName, miniDubboProperties.getRegistry(), interfaceConfig);
        failfastClusterInvoker = new FailfastClusterInvoker(registryDirectory);
        this.interfaceConfig = interfaceConfig;
    }


    public static   Object createProxy(Class clazz, InterfaceConfig interfaceConfig, MiniDubboProperties miniDubboProperties) {
        return new JdkDynamicProxy(clazz, interfaceConfig, miniDubboProperties).proxy;
    }

    /**
     * TODO 特殊方法不拦截。。
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if ("toString".equals(method.getName())) {
            return this.toString();
        }
        // todo group，attachment
        RpcInvocation rpcInvocation = new RpcInvocation();
        rpcInvocation.setInterfaceName(clazzName);
        rpcInvocation.setParameterType(method.getParameterTypes());
        rpcInvocation.setArgs(args);
        rpcInvocation.setMethodName(method.getName());
        rpcInvocation.setVersion(interfaceConfig.getVersion());
        Class returnType = method.getReturnType();

        log.info("jdk调用：{}，代理类为：{}，返回类型：{}", rpcInvocation, proxy, returnType);
        // todo 通过接口配置决定用哪种策略
        Response response = (Response)failfastClusterInvoker.invoke(rpcInvocation);
        if (returnType == Void.class) {
            return null;
        }
        JSONObject jsonObject = (JSONObject)response.getResult();
        return jsonObject.toJavaObject(returnType);
    }
}

4.1.2 使用注册目录刷新服务实例

主要是创建zk连接，订阅该类的zk路径，处理zk子节点事件，维护子节点上线和下线，并构造DubboInvoker，建立网络连接。该service接口的所有可用实例，都会存在一个注册目录中，并动态刷新。

package com.jessin.practice.dubbo.registry;

import com.google.common.collect.Lists;
import com.jessin.practice.dubbo.config.InterfaceConfig;
import com.jessin.practice.dubbo.invoker.DubboInvoker;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;

/**
 *  * 注册项目录，所有的dubboInvoker都保存到这里，实现zk listener，监听zk路径变化，当zk变化时，构造DubboInvoker。
 *  * 每个service应该有一个，同一个zk集群同一台机器应该只建立一个共享连接
 * @Author: jessin
 * @Date: 19-11-25 下午10:34
 */
@Slf4j
public class RegistryDirectory {

    private Map ipAndPort2InvokerMap = new ConcurrentHashMap<>();

    private CuratorZookeeperClient curatorZookeeperClient;

    private InterfaceConfig interfaceConfig;

    private String providerPath;

    /**
     * TODO 创建zk连接，监听zk路径创建DubboInvoker
     * @param path
     */
    public RegistryDirectory(String path, String registry, InterfaceConfig interfaceConfig) {
        this.interfaceConfig = interfaceConfig;
        // 监听group/接口名/providers，有变化时通知RegistryDirectory，也就是调用notify(url, listener, urls);
        this.providerPath = "/miniDubbo/" + interfaceConfig.getGroup() + "/" + path + "/providers";

        // TODO 创建zk连接，并创建RegistryDirectory，第一次时创建DubboInvoker
        // 判断zk/redis。
        curatorZookeeperClient = RegistryManager.getCuratorZookeeperClient(registry);
        // todo 抽取subscribe方法
        List children = curatorZookeeperClient.addTargetChildListener(providerPath, new ChildListener() {
                    @Override
                    public void childChanged(String path, List children) {
                        log.info("监听到zk路径变化:{}，children:{}", path, children);
                        processChildren(children);
                    }
                });

        processChildren(children);
    }


    public void processChildren(List children) {
        try {
            if (children == null || children.size() == 0) {
                // 可能是远程抖动，或者zookeeper出问题了，造成所有服务实例下线，这里还需要通过心跳检测。
                log.info("监听到zk路径无子节点:{}", providerPath);
                children = Lists.newArrayList();
            }
            List added = children.stream()
                    .filter(one -> !ipAndPort2InvokerMap.containsKey(one))
                    .collect(Collectors.toList());
            List finalChildren = children;
            List deleted = ipAndPort2InvokerMap.keySet().stream()
                    .filter(one -> !finalChildren.contains(one))
                    .collect(Collectors.toList());
            log.info("监听到zk路径：{}，子节点变化，新增zk节点：{}，删除zk节点：{}", providerPath, added, deleted);

            added.forEach(ipAndPort -> {
                if (!ipAndPort2InvokerMap.containsKey(ipAndPort)) {
                    ipAndPort2InvokerMap.put(ipAndPort, new DubboInvoker(ipAndPort, interfaceConfig));
                }
            });
            deleted.forEach(ipAndPort -> {
                ipAndPort2InvokerMap.get(ipAndPort).destroy();
                ipAndPort2InvokerMap.remove(ipAndPort);
            });
        } catch (Exception e) {
            log.error("处理zk事件出错", e);
        }

    }

    public List getInvokerList() {
        return new ArrayList<>(ipAndPort2InvokerMap.values());
    }
}

4.1.3 Netty client网络通信传输，编解码器的实现

这里基于netty client 4.x api，也就是NioEventLoopGroup/NioSocketChannel等，快速开发网络连接功能，异步发送网络请求，处理各种网络请求：

package com.jessin.practice.dubbo.netty;

import com.alibaba.fastjson.JSON;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import lombok.extern.slf4j.Slf4j;


/**
 * @Author: jessin
 * @Date: 19-11-25 下午10:17
 */
@Slf4j
public class NettyClient {


    private String ipAndPort;
    /**
     * worker可以共用
     */
    private EventLoopGroup worker = new NioEventLoopGroup();

    private Channel socketChannel;

    private NettyClientHandler clientHandler = new NettyClientHandler();

    public NettyClient(String ipAndPort) {
        this.ipAndPort = ipAndPort;
        connect();
    }

    public void connect() {
        log.info("建立netty连接：{}", ipAndPort);
        Bootstrap bootstrap = new Bootstrap();
        try {
            bootstrap.group(worker).channel(NioSocketChannel.class)
                    .option(ChannelOption.SO_KEEPALIVE, true)
                    .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 3000)
                    .handler(new ChannelInitializer() {
                        // TODO 注意pipeline的顺序
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline()
                                    // clientHandler可以提为全局变量
                                    .addLast(new BaseEncoder())
                                    .addLast(new BaseDecoder())
                                    .addLast(clientHandler);
                        }
                    });
            // 客户端是connect
            String[] values = ipAndPort.split(":");
            // TODO 考虑超时重连，心跳断开重连，底层转换为pipeline.connect()
            ChannelFuture channelFuture = bootstrap.connect(values[0], Integer.parseInt(values[1])).sync();
            if (channelFuture.isSuccess()) {
                log.info("与服务端建立连接成功：{}", ipAndPort);
            } else {
                log.error("与服务端建立连接失败:{}", ipAndPort);
            }
            // 建立连接时保存下来，可能有需要连接多个客户端
            this.socketChannel = channelFuture.channel();
        } catch (Exception e) {
            log.error("与服务端建立连接失败:{}", ipAndPort, e);
            throw new RuntimeException("与服务端建立连接失败: " + ipAndPort, e);
        }
    }

    /**
     * 对外发送数据接口
     * @param msg
     */
    public void send(Object msg) {
        // TODO 必须用writeAndFlush才会真正发出去，同时必须序列化为字符串，才能被编码继续往下走
        String jsonStr = JSON.toJSONString(msg);
        socketChannel.writeAndFlush(jsonStr);
    }

    public void close() {
        log.info("关闭访问服务的连接：{}", ipAndPort);
        socketChannel.close();
        if (socketChannel != null && socketChannel.isActive()) {
            try {
                socketChannel.closeFuture().sync();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        worker.shutdownGracefully();
    }
}

编码器通过长度字段 + body实现，具体如下：

package com.jessin.practice.dubbo.netty;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * todo protocol buf
 * @Author: jessin
 * @Date: 19-11-25 下午10:20
 */
public class BaseEncoder extends MessageToByteEncoder {
    private Logger logger = LoggerFactory.getLogger(getClass());

    /**
     * Encode a message into a {@link ByteBuf}. This method will be called for each written message that can be handled
     * by this encoder.
     *
     * @param ctx the {@link ChannelHandlerContext} which this {@link MessageToByteEncoder} belongs to
     * @param msg the message to encode
     * @param out the {@link ByteBuf} into which the encoded message will be written
     * @throws Exception is thrown if an error occurs
     */
    @Override
    protected void encode(ChannelHandlerContext ctx, String msg, ByteBuf out) throws Exception {
        logger.info("对消息：{}进行编码", msg);
        byte[] wordBytes = msg.getBytes("utf-8");
        out.writeInt(wordBytes.length);
        out.writeBytes(wordBytes);
    }
}

对应解码器：

package com.jessin.practice.dubbo.netty;


/**
 * 发送的字节数 + 字节信息
 * 按照这个格式进行装包和拆包，主要是会产生粘包的现象
 * 也就是发送方按照abc, def, 发送
 * 接收方收到的可能是a,bc,de,f，面向的是字节流，需要拆包解出命令
 *
 * @author jessin
 * @create 19-11-25 下午10:20
 **/
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;

public class BaseDecoder extends ByteToMessageDecoder {
    private Logger logger = LoggerFactory.getLogger(getClass());
    private int totalBytes = -1;

    /**
     * Decode the from one {@link ByteBuf} to an other. This method will be called till either the input
     * {@link ByteBuf} has nothing to read when return from this method or till nothing was read from the input
     * {@link ByteBuf}.
     *
     * @param ctx the {@link ChannelHandlerContext} which this {@link ByteToMessageDecoder} belongs to
     * @param in  the {@link ByteBuf} from which to read data
     * @param out the {@link List} to which decoded messages should be added
     * @throws Exception is thrown if an error occurs
     */
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List