8.RPC框架的简单实现（服务发布-Ldubbo协议）

最新推荐文章于 2024-03-20 12:00:18 发布

真相不难

最新推荐文章于 2024-03-20 12:00:18 发布

阅读量400

点赞数

分类专栏： RPC 文章标签： rpc dubbo

本文链接：https://blog.csdn.net/liwgdx80204/article/details/78923615

版权

RPC 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

RmiProtocol类的实现在第六篇和第七篇已经开发完了，借助了spring相关工具类。ldubbo自定义协议的实现类LdubboProtocol是接下来重点要实现的了。

在第一篇文章中，我们提到dubbo框架服务端和客户端的通信使用netty框架开发，这里也是基于netty去实现服务的发布。关于I/O这里不做详细的介绍，但是我们要实现这个简单的rpc框架，了解dubbo的源码，必须得有netty的基础知识。先了解Java的I/O类库，NIO实现，然后了解NIO框架netty，可以参考“Netty权威指南”这本书。

NIO指非阻塞I/O，netty是一个流行的NIO框架，server端和client通过socket进行通信。那怎么实现远程方法调用呢？server提供一个监听端口，接受client端发送的数据，回传数据给client。我们可以封装一个数据对象Invocation，包括服务接口名，方法名，参数等数据，client端发送一个Invocation数据，server端接收到之后找到接口对应的实现类对象，通过反射得到Method对象，然后调用method的invoke方法，再把返回值写回client端，这样我们就实现了一个简单的远程方法调用。

同RmiProtocol类一样，LdubboProtocol类也是继承AbstractProxyProtocol类，需要实现doExport和doRefer两个方法，我们先来实现doExport服务发布方法。

package com.lipenglong.ldubbo.rpc.protocol;

import com.lipenglong.ldubbo.config.RegistryConfig;
import com.lipenglong.ldubbo.remoting.ChannelHandler;
import com.lipenglong.ldubbo.remoting.transport.NettyClient;
import com.lipenglong.ldubbo.remoting.transport.NettyServer;
import com.lipenglong.ldubbo.rpc.AbstractProxyProtocol;
import com.lipenglong.ldubbo.rpc.Invocation;
import com.lipenglong.ldubbo.rpc.LdubboInvoker;
import com.lipenglong.ldubbo.rpc.Result;
import com.lipenglong.ldubbo.rpc.proxy.ProxyFactory;
import io.netty.channel.Channel;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;


/**
 * Ldubbo Protocol协议通信类，基于netty的发布服务和引用服务
 * <p/>
 * Created by lipenglong on 2017/8/29.
 */
public class LdubboProtocol extends AbstractProxyProtocol {
    //ldubbo协议提供服务的默认端口
    private static final Integer DEFAULT_PORT = 30880;
    //提供服务的service实例对象map，即spring配置文件中ref引用的服务实现类对象map，key为interface接口名
    private static final Map<String, Object> instanceMap = new ConcurrentHashMap<String, Object>();
    //netty server线程是否启动，当配置多个ldubbo service时，在默认端口只启动一个netty server线程
    private static transient Boolean isOpen = false;

    private ChannelHandler requestHandler = new ChannelHandler() {
        @Override
        public Object received(Object message) {
            Result result = null;
            Invocation inv = (Invocation) message;
            Object instance = instanceMap.get(inv.getServiceKey());
            try {
                Method method = instance.getClass().getMethod(inv.getMethodName(), inv.getParameterTypes());
                Object obj = method.invoke(instance, inv.getArguments());
                result = new Result(obj, inv.getSerialNo());
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            return result;
        }
    };

    @Override
    protected void doExport(Class interfaceClass, Object ref) {
        instanceMap.put(interfaceClass.getName(), ref);
        if (!isOpen) {
            new NettyServer(DEFAULT_PORT, requestHandler);
            isOpen = true;
        }
    }

    @Override
    protected <T> T doRefer(Class interfaceClass, RegistryConfig registryConfig) {
        return null;
    }
}

我们定义了一个instanceMap，doExport实现中，先把服务接口名称做key，服务实现的ref对象做value放到instanceMap中，然后判断NettyServer是否创建，如果没有的话，创建NettyServer对象，指定一个端口和一个ChannelHandler对象，ldubbo协议使用我们30880端口，ChannelHandler这里先不介绍。接下来看一下NettyServer的实现。

package com.lipenglong.ldubbo.remoting.transport;

import com.lipenglong.ldubbo.remoting.ChannelHandler;
import io.netty.bootstrap.Bootstrap;
import io.netty.bootstrap.ServerBootstrap;
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.NioServerSocketChannel;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;

/**
 * Netty服务端类实现，
 * </p>
 * Created by lipenglong on 2017/8/29.
 */
public class NettyServer {
    private int port;
    private ChannelHandler handler;

    public NettyServer(Integer port, ChannelHandler requestHandler) {
        this.port = port;
        this.handler = requestHandler;
        doOpen();
    }

    private void doOpen() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                EventLoopGroup bossGroup = new NioEventLoopGroup();
                EventLoopGroup workerGroup = new NioEventLoopGroup();
                ServerBootstrap b = new ServerBootstrap();
                b.group(bossGroup, workerGroup)
                        .channel(NioServerSocketChannel.class)
                        .option(ChannelOption.SO_BACKLOG, 100)
                        .handler(new LoggingHandler(LogLevel.INFO))
                        .childHandler(new ChannelInitializer<SocketChannel>() {
                            @Override
                            protected void initChannel(SocketChannel ch) throws Exception {
                                ch.pipeline().addLast("decoder", MarshallingCodecFactory.buildMarshallingDecoder());
                                ch.pipeline().addLast("encoder", MarshallingCodecFactory.buildMarshallingEncoder());
                                ch.pipeline().addLast(new NettyHandler(handler));
                            }
                        });
                try {
                    ChannelFuture f = b.bind(port).sync();
                    synchronized (handler) {
                        handler.notify();
                    }
                    f.channel().closeFuture().sync();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    bossGroup.shutdownGracefully();
                    workerGroup.shutdownGracefully();
                }
            }
        }).start();
        try {
            synchronized (handler) {
                handler.wait();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

NettyServer构造方法中，执行了doOpen方法，开启了一个新的线程，启动server端的监听线程，doOpen里面就是netty server的基本实现，请参考netty相关资料。

第45，46行代码是消息数据的编解码处理，在第一篇文章中就提到了对象在网络上传输要用到序列化工具，我们使用的是jboss的marshalling框架。关于编解码这里也不用详细的介绍了，参考netty相关的书籍和jboss相关的资料，看一下MarshallingCodecFactory编码器、解码器的创建实现。

package com.lipenglong.ldubbo.remoting.transport;

import io.netty.channel.ChannelHandler;
import io.netty.handler.codec.marshalling.*;
import org.jboss.marshalling.MarshallerFactory;
import org.jboss.marshalling.Marshalling;
import org.jboss.marshalling.MarshallingConfiguration;

/**
 * Marshalling编解码工具类
 * <p/>
 * Created by lipenglong on 2017/8/24.
 */
public class MarshallingCodecFactory {
    /**
     * 创建编码器对象
     *
     * @return 编码器
     */
    public static ChannelHandler buildMarshallingDecoder() {
        MarshallerFactory marshallerFactory = Marshalling.getProvidedMarshallerFactory("serial");
        MarshallingConfiguration configuration = new MarshallingConfiguration();
        configuration.setVersion(5);
        UnmarshallerProvider provider = new DefaultUnmarshallerProvider(marshallerFactory, configuration);
        return new MarshallingDecoder(provider, 1024);
    }

    /**
     * 创建解码器对象
     *
     * @return 解码器
     */
    public static ChannelHandler buildMarshallingEncoder() {
        MarshallerFactory marshallerFactory = Marshalling.getProvidedMarshallerFactory("serial");
        MarshallingConfiguration configuration = new MarshallingConfiguration();
        configuration.setVersion(5);
        MarshallerProvider provider = new DefaultMarshallerProvider(marshallerFactory, configuration);
        return new MarshallingEncoder(provider);
    }
}

第47行是创建了netty的handler消息处理类，server端和client端的通信的具体实现都使用该类，它实现了当接受到消息后的处理过程。下面是NettyHandler类的具体实现。

package com.lipenglong.ldubbo.remoting.transport;

import com.lipenglong.ldubbo.remoting.ChannelHandler;
import com.lipenglong.ldubbo.rpc.Invocation;
import com.lipenglong.ldubbo.rpc.LdubboInvoker;
import com.lipenglong.ldubbo.rpc.Result;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

/**
 * netty handler消息处理类
 * </p>
 * Created by lipenglong on 2017/8/29.
 */
public class NettyHandler extends ChannelInboundHandlerAdapter {
    private ChannelHandler handler;
    private LdubboInvoker invoker;

    public NettyHandler(ChannelHandler handler) {
        this.handler = handler;
    }

    public NettyHandler(ChannelHandler handler, LdubboInvoker invoker) {
        this.handler = handler;
        this.invoker = invoker;
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        if (invoker != null) {
            invoker.setChannel(ctx.channel());
        }
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        if (msg.getClass().equals(Invocation.class)) {
            Object result = handler.received(msg);
            if (result != null) {
                ctx.writeAndFlush(result);
            }
        } else if (msg.getClass().equals(Result.class)) {
            invoker.addResult((Result) msg);
        }
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }
}

NettyHandler持有ChannelHandler对象，在LdubboProtocol类的doExport方法创建NettyServer时，就指定了一个ChannelHandler对象，这个对象交给NettyServer，然后又交给了NettyHandler。消息的处理在channelRead方法中，Invocation对象是client端发送的数据对象，封装client端具体请求信息，Result对象是server端返给client的结果数据对象，封装server端方法执行后的返回值。NettyHandler这里对接收到的对象做类型判断，如果是Invocation类，调用ChannelHandler的received方法，并把结果Result写回client端。

在ChannelHandler的实现前，看一下Invocation对象的实现。

package com.lipenglong.ldubbo.rpc;

import java.io.Serializable;
import java.util.Arrays;

/**
 * client端发送的请求对象
 * </p>
 * Created by lipenglong on 2017/9/1.
 */
public class Invocation implements Serializable {
    //请求的方法名
    private String methodName;
    //方法所有参数类型
    private Class<?>[] parameterTypes;
    //方法所有参数值
    private Object[] arguments;
    //请求的服务key
    private String serviceKey;
    //请求的序号
    private String serialNo;

    public Invocation(String methodName, Class<?>[] parameterTypes, Object[] arguments) {
        this.methodName = methodName;
        this.parameterTypes = parameterTypes;
        this.arguments = arguments;
    }

    public String getMethodName() {
        return methodName;
    }

    public Class<?>[] getParameterTypes() {
        return parameterTypes;
    }

    public Object[] getArguments() {
        return arguments;
    }

    public String getServiceKey() {
        return serviceKey;
    }

    public void setServiceKey(String serviceKey) {
        this.serviceKey = serviceKey;
    }

    public String getSerialNo() {
        return serialNo;
    }

    public void setSerialNo(String serialNo) {
        this.serialNo = serialNo;
    }

    @Override
    public String toString() {
        return "RpcInvocation{" +
                "methodName='" + methodName + '\'' +
                ", parameterTypes=" + Arrays.toString(parameterTypes) +
                ", arguments=" + Arrays.toString(arguments) +
                ", serviceKey='" + serviceKey + '\'' +
                ", serialNo='" + serialNo + '\'' +
                '}';
    }
}

方法名，参数类型，参数容易理解，服务key是client端请求的具体服务路径，这里使用的是提供服务的接口类name，序号这里先不介绍。

先看一下ChannelHandler的接口定义。

package com.lipenglong.ldubbo.remoting;


import com.lipenglong.ldubbo.rpc.Result;

/**
 * server端的netty channel处理信息类
 * </p>
 * Created by lipenglong on 2017/8/29.
 */
public interface ChannelHandler {
    /**
     * 接收消息处理方法
     *
     * @param message 消息对象
     * @return 处理结果
     */
    Result received(Object message);
}

只有一个received方法，在LdubboProtocol类里面有它的匿名实现。回看一下最上面的LdubboProtocol类代码，received实现部分，把message转为Invocation对象，从instanceMap中取出serviceKey对应的服务实现类实例对象，通过Java的反射去执行服务实现类的具体方法，然后把方法的返回值和序号写入Result对象返回。

下面是Result类代码：

package com.lipenglong.ldubbo.rpc;

import java.io.Serializable;

/**
 * server端返回的结果对象
 * </p>
 * Created by lipenglong on 2017/8/29.
 */
public class Result implements Serializable {
    //返回值
    private Object result;
    //序号
    private String serialNo;

    public Result(Object result, String serialNo) {
        this.result = result;
        this.serialNo = serialNo;
    }

    public Object getValue() {
        return result;
    }

    public String serialNo() {
        return serialNo;
    }

    @Override
    public String toString() {
        return "RpcResult{" +
                "result=" + result +
                ", serialNo='" + serialNo + '\'' +
                '}';
    }
}

LDubbo协议的服务发布实现完了，先来测试一下server能否正常运行
在第六章里面，测试rmi协议时，已经写好了测试ldubbo-api项目和provider项目，把provider项目的applicationContext-ldubbo.xml文件的协议修改为ldubbo，如下：

<?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:ldubbo="http://www.lipenglong.com/schema/ldubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.lipenglong.com/schema/ldubbo
       http://www.lipenglong.com/schema/ldubbo/ldubbo.xsd" default-lazy-init="true">

    <ldubbo:protocol name="ldubbo"/>
    <ldubbo:service interface="com.lipenglong.ldubbo.api.service.UserService" ref="userService"/>
</beans>