手写dubbo案例: https://gitee.com/itmc/dubbo-m.git

注册中心原理

image.png

[

](https://gitee.com/itmc/dubbo-m.git)
说明:

服务提供者

启动服务读取接口信息存入本地缓存表—->解析client请求——>通过获取本地缓存列表—->获取对应的请求接口信息—->通过反射运行接口实现并响应

服务消费者

通过请求封装接口信息(代理)—>请求服务生产者

注册中心

注册中心简单实现可以用zk,redis,或者直接文件,之所以选择zk这种是因为它的watch监听机制,或者使用redis的发布/订阅机制

简单模拟实现

基础原理说明

在我们使用dubbo的时候,客户端如下:

  1. @Component
  2. public class BusinessService {
  3.     /**
  4.      * 引用服务
  5.      */
  6.     @Reference
  7.     private HelloService helloService;
  9.     public void testHello(String name) {
  10.         String str = helloService.sayHello(name);
  11.         System.out.println("调用结果：" + str);
  12.     }
  13. }

通过上面代码可以推测:

  1. 客户端获取到HelloService接口
  2. 验证是否被@Reference注解标注
  3. 如果存在@Reference注解,则说明是引入dubbo服务
  4. 获取通过反射获取接口信息,通过http或者dubbo协议调用服务端

客户端调用服务端需要哪些?

  • 服务端url
  • 接口信息

服务端需要哪些信息?

  • 接口信息

注册中心作用?
服务端向注册中心注册接口信息,客户端拉取地址列表

客户端怎样调用?
简单来说就是拿到接口信息通过http协议或者dubbo协议进行服务的调用

服务端怎样处理?
服务端收到client发来的接口信息,通过注册表查询接口信息.通过反射去创建调用对应的方法

服务端创建

创建HelloService

  1. package com.itmck.dubbom.provider.api;
  3. /**
  4.  * 太阳当空照,花儿对我笑
  5.  *
  6.  * Create by M ChangKe 2021/10/20 15:37
  7.  **/
  8. public interface HelloService {
  10.     String sayHello(String userName);
  11. }

创建HelloServiceImpl

  1. package com.itmck.dubbom.provider.impl;
  2. import com.itmck.dubbom.provider.api.HelloService;
  4. /**
  5.  * 太阳当空照,花儿对我笑
  6.  * <p>
  7.  * Create by M ChangKe 2021/10/20 15:37
  8.  **/
  9. public class HelloServiceImpl implements HelloService {
  11.     @Override
  12.     public String sayHello(String userName) {
  13.         return "Hello: " + userName;
  14.     }
  15. }

创建Invocation

Invocation用于存放接口类相关信息

  1. package com.itmck.dubbom.dubbom;
  3. import lombok.Getter;
  4. import lombok.Setter;
  6. import java.io.Serializable;
  8. /**
  9.  * 太阳当空照,花儿对我笑
  10.  * <p>
  11.  * Create by M ChangKe 2021/10/20 19:52
  12.  **/
  13. @Setter
  14. @Getter
  15. public class Invocation implements Serializable {
  17.     private static final long serialVersionUID = -2814851007135975046L;
  19.     /**
  20.      * 接口名
  21.      */
  22.     private String interfaceName;
  24.     /**
  25.      * 方法名
  26.      */
  27.     private String methodName;
  29.     /**
  30.      * 方法参数类型列表
  31.      */
  32.     private Class<?>[] paramTypes;
  34.     /**
  35.      * 参数列表
  36.      */
  37.     private Object[] params;
  39.     public Invocation(String interfaceName, String methodName, Class<?>[] paramTypes, Object[] params) {
  40.         this.interfaceName = interfaceName;
  41.         this.methodName = methodName;
  42.         this.paramTypes = paramTypes;
  43.         this.params = params;
  44.     }
  47. }

引入tomcat

  1. <dependency>
  2.   <groupId>org.apache.tomcat.embed</groupId>
  3.   <artifactId>tomcat-embed-core</artifactId>
  4.   <version>9.0.12</version>
  5. </dependency>

创建HttpServer

  1. package com.itmck.dubbom.dubbom.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. public class HttpServer {
  11.     // tomcat,jetty
  13.     public void start(String hostname, Integer port) {
  16.         Tomcat tomcat = new Tomcat();
  18.         Server server = tomcat.getServer();
  19.         Service service = server.findService("Tomcat");
  21.         Connector connector = new Connector();
  22.         connector.setPort(port);
  24.         Engine engine = new StandardEngine();
  25.         engine.setDefaultHost(hostname);
  27.         Host host = new StandardHost();
  28.         host.setName(hostname);
  30.         String contextPath = "";
  31.         Context context = new StandardContext();
  32.         context.setPath(contextPath);
  33.         context.addLifecycleListener(new Tomcat.FixContextListener());
  35.         host.addChild(context);
  36.         engine.addChild(host);
  38.         service.setContainer(engine);
  39.         service.addConnector(connector);
  41.         tomcat.addServlet(contextPath, "dispatcher", new DispatcherServlet());
  42.         context.addServletMappingDecoded("/*", "dispatcher");
  45.         try {
  46.             tomcat.start();
  47.             tomcat.getServer().await();
  48.         } catch (LifecycleException e) {
  49.             e.printStackTrace();
  50.         }
  53.     }
  54. }

创建DispatcherServlet

  1. package com.itmck.dubbom.dubbom.protocol.http;
  3. import javax.servlet.ServletException;
  4. import javax.servlet.http.HttpServlet;
  5. import javax.servlet.http.HttpServletRequest;
  6. import javax.servlet.http.HttpServletResponse;
  7. import java.io.IOException;
  9. /**
  10.  * 太阳当空照,花儿对我笑
  11.  * <p>
  12.  * Create by M ChangKe 2021/10/20 19:43
  13.  **/
  14. public class DispatcherServlet extends HttpServlet {
  17.     @Override
  18.     protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  20.         new HttpServerHandler().handler(req,resp);
  21.     }
  22. }

创建HttpServerHandler

当前是服务端实现的重点:

  • 根据HttpServletRequest拿到请求信息Invocation
  • 通过接口名向注册列表中获取class
  • 反射执行方法
  • 将结果写入HttpServletResponse ```java package com.itmck.dubbom.dubbom.protocol.http;

import com.itmck.dubbom.dubbom.Invocation; import com.itmck.dubbom.dubbom.register.LocalRegister; import org.apache.commons.io.IOUtils;

import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.ObjectInputStream; import java.lang.reflect.Method;

/**

  • 太阳当空照,花儿对我笑

  • Create by M ChangKe 2021/10/20 19:44 **/ public class HttpServerHandler {
  1. public void handler(HttpServletRequest req, HttpServletResponse resp) {
  2.     try {
  3.         ObjectInputStream ois = new ObjectInputStream(req.getInputStream());
  5.         //获取传进来的接口信息
  6.         Invocation invocation = (Invocation)ois.readObject();
  8.         //获取接口名
  9.         String interfaceName = invocation.getInterfaceName();
  11.         //通过本地注册表获取接口类
  12.         Class<?> interfaceClass = LocalRegister.get(interfaceName);
  14.         //获取方法
  15.         Method method = interfaceClass.getMethod(invocation.getMethodName(), invocation.getParamTypes());
  17.         //通过反射调用
  18.         String result = (String) method.invoke(interfaceClass.newInstance(), invocation.getParams());
  20.         System.out.println("tomcat:" + result);
  21.         IOUtils.write(result, resp.getOutputStream());
  22.     } catch (Exception e) {
  23.         e.printStackTrace();
  24.     }
  27. }

}

  1. <a name="NeUsN"></a>
  2. ### 创建LocalRegister
  3. ```java
  4. package com.itmck.dubbom.dubbom.register;
  6. import java.util.HashMap;
  7. import java.util.Map;
  9. /**
  10.  * 太阳当空照,花儿对我笑
  11.  * <p>
  12.  * Create by M ChangKe 2021/10/20 19:17
  13.  **/
  14. public class LocalRegister {
  16.     private static Map<String, Class<?>> map = new HashMap<>();
  18.     public static void register(String interfaceName, Class<?> implClass) {
  20.         map.put(interfaceName, implClass);
  21.     }
  23.     public static Class<?> get(String interfaceName) {
  24.         return map.get(interfaceName);
  25.     }
  26. }

客户端创建

创建HttpClient

  1. package com.itmck.dubbom.dubbom.protocol.http;
  3. import com.itmck.dubbom.dubbom.Invocation;
  4. import org.apache.commons.io.IOUtils;
  6. import java.io.InputStream;
  7. import java.io.ObjectOutputStream;
  8. import java.io.OutputStream;
  9. import java.net.HttpURLConnection;
  10. import java.net.URL;
  12. /**
  13.  * 太阳当空照,花儿对我笑
  14.  * <p>
  15.  * Create by M ChangKe 2021/10/21 10:06
  16.  **/
  17. public class HttpClient {
  20.     /**
  21.      * 
  22.      * @param hostname 主机ip
  23.      * @param port 端口
  24.      * @param invocation 参数
  25.      * @return 响应数据
  26.      */
  27.     public String send(String hostname, Integer port, Invocation invocation) {
  29.         try {
  30.             URL url = new URL("http", hostname, port, "/");
  31.             HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
  33.             httpURLConnection.setRequestMethod("POST");
  34.             httpURLConnection.setDoOutput(true);
  36.             OutputStream outputStream = httpURLConnection.getOutputStream();
  37.             ObjectOutputStream oos = new ObjectOutputStream(outputStream);
  39.             oos.writeObject(invocation);
  40.             oos.flush();
  41.             oos.close();
  43.             InputStream inputStream = httpURLConnection.getInputStream();
  44.             String result = IOUtils.toString(inputStream);
  45.             return result;
  46.         } catch (Exception e) {
  47.             e.printStackTrace();
  48.         }
  49.         return null;
  50.     }
  51. }

创建代理类

  1. package com.itmck.dubbom.dubbom;
  3. import com.itmck.dubbom.dubbom.register.RemoteMapRegister;
  5. import java.lang.reflect.InvocationHandler;
  6. import java.lang.reflect.Method;
  7. import java.lang.reflect.Proxy;
  8. import java.util.List;
  10. /**
  11.  * 太阳当空照,花儿对我笑
  12.  * <p>
  13.  * Create by M ChangKe 2021/10/21 10:14
  14.  **/
  15. public class ProxyFactory {
  17.     /**
  18.      * @param interfaceClass 被代理接口
  19.      * @param <T>
  20.      * @return 返回代理对象
  21.      */
  22.     public static <T> T getProxy(final Class<?> interfaceClass) {
  23.         return (T) Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class[]{interfaceClass}, new InvocationHandler() {
  25.             @Override
  26.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  27.                 Invocation invocation = new Invocation(interfaceClass.getName(), method.getName(), method.getParameterTypes(), args);
  28.                 HttpClient httpClient = new HttpClient();
  29.                 String result =httpClient.send("localhost","8080",invocation);
  30.                 return result;
  31.             }
  32.         });
  33.     }
  34. }


测试

  • 启动 Provider ```java package com.itmck.dubbom;

import com.itmck.dubbom.dubbom.Protocol; import com.itmck.dubbom.dubbom.ProtocolFactory; import com.itmck.dubbom.dubbom.URL; import com.itmck.dubbom.dubbom.register.LocalRegister; import com.itmck.dubbom.dubbom.register.RemoteMapRegister; import com.itmck.dubbom.provider.api.HelloService; import com.itmck.dubbom.provider.impl.HelloServiceImpl;

public class Provider {

  1. public static void main(String[] args) {
  4.     //注册服务信息到本地注册表
  5.     URL url = new URL("localhost", 8080);
  6.     LocalRegister.register(HelloService.class.getName(), HelloServiceImpl.class);
  7.     RemoteMapRegister.regist(HelloService.class.getName(), url);
  8.     Protocol protocol = ProtocolFactory.getProtocol();
  9.     protocol.start(url);
  11. }

}

  2. - 启动 Consumer
  3. ```java
  4. package com.itmck.dubbom.consumer;
  6. import com.itmck.dubbom.dubbom.ProxyFactory;
  7. import com.itmck.dubbom.provider.api.HelloService;
  9. /**
  10.  * 太阳当空照,花儿对我笑
  11.  * <p>
  12.  * Create by M ChangKe 2021/10/21 9:57
  13.  **/
  14. public class Consumer {
  16.     public static void main(String[] args) {
  18.         HelloService helloService = ProxyFactory.getProxy(HelloService.class);
  19.         String result = helloService.sayHello("mck");
  20.         System.out.println(result);
  21.     }
  22. }

优化代码

  • 上面的注册列表待完善.参考RemoteMapRegister
  • 客户端的url获取.随机负载均衡参考LoadBalance
  • 使用http还是dubbo协议. 参考ProtocolFactory