');}

自己实现一个Dubbo

Author Avatar
Rico 12月 20, 2018

Dubbo

Dubbo是一款高性能轻量级的开源Java RPC框架

什么是RPC？

远程过程调用。

HTTP也是一种RPC协议 TCP也是

传统的HTTP调用

需要关心地址，地址变了消费端也要跟着变 ，需要字符串转换等缺点

RPC式的调用

consumer配置

provider配置

特别简单，作为消费者不需要关心地址

dubbo可扩展，它支持多种协议

自己实现

本项目就不采用模块的形式了（可以采用模块的形式） ，采用包代替模块的方式

我们注册中心一般用zookeeper或者eureka 或者redis ,注册中心也是可以扩展的

我们自己实现一个注册中心

注册中心要实现的是保存服务配置，需要保存: 服务名, url, 服务的实现类

形如

  1. {
  2.  服务名://因为可能有多个提供者
  3.    {URL:服务实现类},
  4.    {URL:服务实现类}
  5. }

我们用hashmap来存

一个Java对象要在网络中进行传输，需要序列化

部分源码

注册中心

采用一个hashmap来充当注册中心. 注册中心是独立于服务提供方和服务消费方的，但是这里为了省事，放在同一个工程中了 

  1. package org.rico.learnDubbo.register;
  2. import org.rico.learnDubbo.framework.URL;
  3. import java.util.HashMap;
  4. import java.util.Map;
  5. /**
  6.  * 自己实现的一个注册中心,采用map
  7.  * Created by Rico on 2018/12/20.
  8.  */
  9. public class RegisterServer {
  10.     private static Map<String,Map<URL,Class>>   REGISTER =new HashMap<String,Map<URL,Class>>();
  12.     //注册服务
  13.     public static  void register(URL url,String interfaceName,Class implClass){//需要传入URL，服务名，接口名(interface),实现类
  14.         Map<URL,Class> map=new HashMap<URL,Class>();
  15.         map.put(url,implClass);
  16.         System.out.println("服务注册成功!注册的服务接口名为:"+interfaceName+",所在接口类为:"+implClass.getName());
  17.         REGISTER.put(interfaceName,map);
  18.     }
  20.     public static Class get(URL url,String interfaceName){
  21.         return REGISTER.get(interfaceName).get(url);
  22.     }
  23.     //获取可用服务
  24.     public static  URL get(String interfaceName){
  25.       return null;
  26.     }
  27. }

传输协议

http

  1. package org.rico.learnDubbo.protocol.http;
  2. import javax.servlet.ServletException;
  3. import javax.servlet.http.HttpServlet;
  4. import javax.servlet.http.HttpServletRequest;
  5. import javax.servlet.http.HttpServletResponse;
  6. import java.io.IOException;
  7. /**
  8.  * Created by Rico on 2018/12/20.
  9.  */
  10. public class DispatcherServlet extends HttpServlet {
  11.     @Override
  12.     protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  13.         //super.service(req, resp);
  14.         new HttpServerHandler().handler(req,resp);
  15.     }
  16. }
  1. package org.rico.learnDubbo.protocol.http;
  3. import org.apache.commons.io.IOUtils;
  4. import org.rico.learnDubbo.framework.TransferModel;
  5. import org.rico.learnDubbo.framework.URL;
  6. import org.rico.learnDubbo.register.RegisterServer;
  8. import javax.servlet.http.HttpServletRequest;
  9. import javax.servlet.http.HttpServletResponse;
  10. import java.io.IOException;
  11. import java.io.InputStream;
  12. import java.io.ObjectInputStream;
  13. import java.io.OutputStream;
  14. import java.lang.reflect.InvocationTargetException;
  15. import java.lang.reflect.Method;
  17. /**
  18.  * Created by Rico on 2018/12/20.
  19.  */
  20. public class HttpServerHandler{
  21.     //处理请求和响应
  22.     public void handler(HttpServletRequest req, HttpServletResponse resp){
  23.         //对象通过网络传输
  24.         InputStream inputStream= null;
  25.         try {
  26.             inputStream = req.getInputStream();
  27.             ObjectInputStream objectInputStream=new ObjectInputStream(inputStream);
  28.             TransferModel  transferModel =(TransferModel)objectInputStream.readObject();//二进制数据反序列化成一个对象
  29.             //根据transferModel中的信息去注册中心找接口的实现类
  30.             String interfaceName=transferModel.getInterfaceName();
  31.             URL url=new URL("localhost",8080);
  32.             Class implementClass=RegisterServer.get(url,interfaceName);//根据url和接口名找一个实现类
  33.             //然后new出这个实现类,然后执行一下需要调用的这个方法
  34.             Method method=implementClass.getMethod(transferModel.getMethodName(),transferModel.getParamTypes());//这里Class的getMethod方法的第一个参数:方法的名字,第二个参数,方法的参数类型
  35.             //执行,并保存返回值
  36.             String result=(String)method.invoke(implementClass.newInstance(),transferModel.getParams());//第一个参数:new出来的这个实现类,第二个参数:参数 我们这里因为知道sayHello方法返回的是String，所以强转成String了,实际dubbo框架肯定是Object
  37.             //然后把结果返回,通过outputstream返回给resp
  38.             OutputStream outputStream=resp.getOutputStream();
  39.             IOUtils.write(result,outputStream);//把字符串给output了 这样就完成了一个结果的返回
  40.             //server端就写完了
  41.         } catch (IOException e) {
  42.             e.printStackTrace();
  43.         } catch (ClassNotFoundException e) {
  44.             System.out.println("找不到这个类");
  45.             e.printStackTrace();
  46.         } catch (NoSuchMethodException e) {
  47.             System.out.println("没有这个方法");
  48.             e.printStackTrace();
  49.         } catch (IllegalAccessException e) {
  50.             e.printStackTrace();
  51.         } catch (InstantiationException e) {
  52.             e.printStackTrace();
  53.         } catch (InvocationTargetException e) {
  54.             e.printStackTrace();
  55.         }
  56.     }
  57. }
  1. package org.rico.learnDubbo.protocol.http;
  3. import org.apache.catalina.*;
  4. import org.apache.catalina.connector.Connector;
  5. import org.apache.catalina.core.StandardContext;
  6. import org.apache.catalina.core.StandardEngine;
  7. import org.apache.catalina.core.StandardHost;
  8. import org.apache.catalina.startup.Tomcat;
  10. /**
  11.  * Created by Rico on 2018/12/20.
  12.  */
  13. public class HttpServer {
  14.     public void start(String hostname,Integer port){
  15.         Tomcat tomcat=new Tomcat();
  17.         Server server=tomcat.getServer();
  18.         Service service=server.findService("Tomcat");//默认 叫tomcat
  20.         Connector connector=new Connector();
  21.         connector.setPort(port);
  23.         Engine engine=new StandardEngine();
  24.         engine.setDefaultHost(hostname);
  26.         Host host=new StandardHost();
  27.         host.setName(hostname);
  29.         String contextPath="";
  30.         Context context=new StandardContext();
  31.         context.setPath(contextPath);
  32.         context.addLifecycleListener(new Tomcat.FixContextListener());//加一个tomcat生命周期的监听器
  34.         host.addChild(context);
  35.         engine.addChild(host);
  37.         service.setContainer(engine);
  38.         service.addConnector(connector);
  39.         //tomcat是servlet的容器 所以要加入servlet,servlet用来处理请求的
  40.         tomcat.addServlet(contextPath,"dispatcher",new DispatcherServlet());//指定servlet,第二个参数是servlet的名字，第三个参数是指定其实现类
  41.         context.addServletMappingDecoded("/*","dispatcher");//mapping
  42.         try {
  43.             tomcat.start();//只是初始化
  44.             tomcat.getServer().await();//接收请求
  45.         } catch (LifecycleException e) {
  46.             e.printStackTrace();
  47.         }
  48.     }
  49. }
  1. package org.rico.learnDubbo.protocol.http;
  2. import org.apache.commons.io.IOUtils;
  3. import org.rico.learnDubbo.framework.TransferModel;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.io.ObjectOutputStream;
  7. import java.io.OutputStream;
  8. import java.net.HttpURLConnection;
  9. import java.net.MalformedURLException;
  10. import java.net.ProtocolException;
  11. import java.net.URL;
  12. /**
  13.  * Created by Rico on 2018/12/21.
  14.  */
  15. public class HttpClient {
  16.     public String post(String hostname, Integer port, TransferModel transferModel) {
  17.         try {
  18.             //发送请求
  19.             URL url = new URL("http", hostname, port, "/");
  20.             HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
  21.             httpURLConnection.setRequestMethod("POST");
  22.             httpURLConnection.setDoOutput(true);
  23.             OutputStream outputStream = httpURLConnection.getOutputStream();
  24.             ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
  25.             objectOutputStream.writeObject(transferModel);
  26.             objectOutputStream.flush();
  27.             objectOutputStream.close();
  28.             //发送完请求,然后拿到结果
  29.             InputStream inputStream=httpURLConnection.getInputStream();
  30.             return IOUtils.toString(inputStream);
  31.         } catch (MalformedURLException e) {
  32.             e.printStackTrace();
  33.             return "";
  34.         } catch (ProtocolException e) {
  35.             e.printStackTrace();
  36.             return "";
  37.         } catch (IOException e) {
  38.             e.printStackTrace();
  39.             return "";
  40.         }
  41.     }
  42. }

未完，待续….

目录结构

下面2张图帮助理解源码

源码下载

This blog is under a CC BY-NC-SA 3.0 Unported License
本文链接：http://hogwartsrico.github.io/2018/12/20/write-a-dubbo/