一个简单的微服务框架(RPC)

一个简单的微服务框架(RPC)

参考书籍:微服务分布式构架开发实战 龚鹏

RPC:Remote Procedure Call —远程过程调用。简单说就是通过http协议,连接两个应用程序,应用程序之间通过接口实现数据共享。

项目Github地址

基本工作流程:

  • 客户端发起调用请求(调用服务端的某一个方法)
  • 将调用的内容序列化后通过网络发给服务端(序列化数据,方便在流中传输对象)(是通过socket发送数据的)
  • 服务端接收到调用请求,执行具体服务并获得结果
  • 将结果序列化后通过网络返回给客户端

1,公共接口的定义

在发起远程调用时,需要基于接口(interface)来约定,客户端与服务端所调用服务的具体内容。

  • 新建maven工程,maven参数如下

  • 定义接口 HelloService

package org.zyf.rpc;

/**
 * Created by zyf on 2018/3/30.
 */
public interface HelloService {

    String hello(String name);

}
  • 生成jar包,方便其他应用导入依赖

2,服务端

  • 新建用于提供服务端Maven应用,并在 pom.xml 中引入刚编写好的接口应用的依赖

  • 创建 HelloService 接口的实现类 HelloServiceImpl ,该类用来处理业务请求
package org.zyf.service.impl;

import org.zyf.rpc.HelloService;

/**
 * Created by zyf on 2018/3/30.
 */
public class HelloServiceImpl implements HelloService {
    public String hello(String s) {
        System.out.println("接收到消息:"+s);
        return "你好:"+s;
    }
}
  • 编写监听服务类 Server ,该类用来操作服务端,开启服务,注册业务等操作
package org.zyf.server;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Method;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created by zyf on 2018/3/30.
 */
public class Server {
    private static ExecutorService executor = Executors.newFixedThreadPool(10);

    //此hashMap用来保管定义的服务接口与用到的对应的实现类
    private static final HashMap<String,Class> serviceRegistry = new HashMap<String, Class>();

    /**
     * 对外暴露的,用于注册服务接口与对应实现类的方法
     * @param serviceInterface
     * @param impl
     */
    public void register(Class serviceInterface,Class impl){
        //注册服务
        //将接口名与实现类名存入hashMap中
        serviceRegistry.put(serviceInterface.getName(),impl);
    }

    /**
     * 启动一个阻塞式的Socket服务,用于等待客户端发起的调用请求
     * 当收到请求后,将码流反序列化成对象
     * 并根据接口,从注册列表(serviceRegistry)中寻找具体实现类
     * 最终通过反射的方式调用该实现类的方法,得到方法结果
     * @param port
     * @throws IOException
     */
    public void start(int port) throws IOException {
        final ServerSocket server = new ServerSocket();

        //绑定监听端口
        server.bind(new InetSocketAddress(port));

        System.out.println("======服务已启动======");

        while (true){
            executor.execute(new Runnable() {
                public void run() {
                    Socket socket = null;
                    ObjectInputStream input = null;
                    ObjectOutputStream output = null;
                    try {

                        //获取到server连接的客户端
                        socket = server.accept();

                        //获得socket的输入流,并作为构造方法参数,得到对象输入流
                        input = new ObjectInputStream(socket.getInputStream());

                        //反序列化定位到具体的服务
                        String serviceName = input.readUTF();

                        //简单的看了下readUTF的源码,大致是一次性能读出一段数据
                        //而serviceName和methodName就相当于两段数据
                        String methodName = input.readUTF();

                        Class<?>[] parameterTypes= (Class<?>[]) input.readObject();

                        Object[] arguments = (Object[]) input.readObject();

                        //在服务注册表中,根据调用的服务获取到具体的实现类
                        Class serviceClass = serviceRegistry.get(serviceName);
                        if(serviceClass == null){
                            throw new ClassNotFoundException(serviceName+" 未找到");
                        }

                        //反射获得该类中的方法
                        Method method = serviceClass.getMethod(methodName,parameterTypes);

                        //调用方法,获得方法返回值
                        Object result = method.invoke(serviceClass.newInstance(), arguments);

                        //得到对象输出流
                        output = new ObjectOutputStream(socket.getOutputStream());

                        //将结果序列化发送给客户端
                        output.writeObject(result);

                    }catch (Exception e){
                        e.printStackTrace();
                    }finally {
                        //关闭资源
                        try {
                            if(socket != null) socket.close();
                            if (input != null) input.close();
                            if (output != null) output.close();
                        }catch (IOException e){
                            e.printStackTrace();
                        }
                    }
                }
            });
        }
    }
}
  • 创建服务端程序入口类 App ,提供main方法,创建并使用Server对象
package org.zyf;

import org.zyf.rpc.HelloService;
import org.zyf.server.Server;
import org.zyf.service.impl.HelloServiceImpl;

import java.io.IOException;

/**
 * Created by zyf on 2018/3/30.
 */
public class App {

    public static void main(String[] args) throws IOException {
        Server server = new Server();
        //注册服务
        server.register(HelloService.class, HelloServiceImpl.class);
        //启动并绑定端口
        server.start(9999);
    }
}

3,客户端

  • 新建用于提供客户端Maven应用,并在 pom.xml 中引入刚编写好的接口应用的依赖

  • 编写远程调用类,想服务端发起Socket远程调用请求,并获得服务端的反馈信息

package org.zyf.client;

import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.InetSocketAddress;
import java.net.Socket;

/**
 * Created by zyf on 2018/3/30.
 */
public class Client<T> {

    /** 这里使用的是javajdk的动态代理
     * 根据提供的服务接口类,将接口序列化成码流
     * 向目标服务端发起Socket远程请求
     * 获得服务器反馈的结果,并反序列化对象后返回
     * @param serviceInterface
     * @param addr
     * @param <T>
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> T get(final Class<?> serviceInterface, final InetSocketAddress addr){


        //提供接口的类加载器
        //提供接口的类对象
        //得到一个实现该接口的代理类
        final T instance = (T) Proxy.newProxyInstance(serviceInterface.getClassLoader(), new Class<?>[]{serviceInterface}, new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                Socket socket = null;
                ObjectOutputStream output = null;
                ObjectInputStream input = null;

                try{
                    //连接服务端
                    socket = new Socket();
                    //连接端口地址
                    socket.connect(addr);

                    //将调用的接口类,方法名,参数列表等序列化后方给服务提供者
                    output = new ObjectOutputStream(socket.getOutputStream());

                    //直接根据UTF-8编码输出接口名
                    output.writeUTF(serviceInterface.getName());

                    //直接根据UTF-8编码输出方法名
                    output.writeUTF(method.getName());

                    output.writeObject(method.getParameterTypes());

                    output.writeObject(args);

                    input = new ObjectInputStream(socket.getInputStream());

                    return input.readObject();
                }finally {
                    if(socket != null) socket.close();
                    if(output != null) output.close();
                    if(input != null) input.close();
                }
            }
        });
        return instance;
    }
}
  • 创建客户端程序入口类 App ,提供main方法,创建并使用Server对象
package org.zyf;

import org.zyf.client.Client;
import org.zyf.rpc.HelloService;

import java.net.InetSocketAddress;

/**
 * Created by zyf on 2018/3/30.
 */
public class App {
    public static void main(String[] args) {
        HelloService service = Client.get(HelloService.class,new InetSocketAddress("localhost",9999));

        System.out.println(service.hello("RPC"));
    }
}

4,运行演示:先启动服务端,再启动客户端

  • 启动服务端

  • 启动客户端后

5,程序流程总结

展开阅读全文
©️2020 CSDN 皮肤主题: 编程工作室 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值