DIY一个属于自己的微服务框架

谁践踏了优雅 2022-09-05 00:04 137阅读 0赞

### 从Vertx提供的通信方式开始 ###

#### 第一个集群节点启动 ####

package org.example;
    
    import com.hazelcast.config.Config;
    import com.hazelcast.config.FileSystemXmlConfig;
    import io.vertx.core.Vertx;
    import io.vertx.core.VertxOptions;
    import io.vertx.core.eventbus.EventBusOptions;
    import io.vertx.spi.cluster.hazelcast.HazelcastClusterManager;
    
    import java.net.InetAddress;
    import java.net.UnknownHostException;
    
    public class AppCluster { 
    
        public static void main(String[] args) throws  UnknownHostException { 
            final VertxOptions vertxOptions = new VertxOptions();
            EventBusOptions eventBusOptions = new EventBusOptions();
            // 本机局域网Ip
            String hostAddress = InetAddress.getLocalHost().getHostAddress();
            vertxOptions.setEventBusOptions(eventBusOptions).getEventBusOptions().setHost(hostAddress);
            //集群方式启动
            HazelcastClusterManager clusterManager = new HazelcastClusterManager();
    
            vertxOptions.setClusterManager(clusterManager);
    
            Vertx.clusteredVertx(vertxOptions, res -> { 
                Vertx result = res.result();
                result.deployVerticle(new MainClusterVerticle(), r -> { 
                    if (r.succeeded()) { 
                        System.out.println(MainClusterVerticle.class.getName() + " --> 部署成功");
                    } else { 
                        r.cause().printStackTrace();
                        System.err.println(MainClusterVerticle.class.getName() + " --> 部署失败, " + r.cause().getMessage());
                    }
                });
            });
        }
    }

#### 发布verticle服务 ####

package org.example;
    
    import io.vertx.core.AbstractVerticle;
    import io.vertx.core.json.JsonObject;
    
    public class MainClusterVerticle extends AbstractVerticle { 
    
      public void start() { 
        System.out.println("start thread" + Thread.currentThread().getName());
        //发布eventbus服务
        vertx.eventBus().consumer("com.xiaoniu.bus", msg -> { 
          System.out.println("read thread" + Thread.currentThread().getName());
          System.out.println("收到消息");
          System.out.println(msg != null ? ((JsonObject) msg.body()).encodePrettily() : "没有消息");
          JsonObject j = new JsonObject();
          j.put("info", "我是Main");
          msg.reply(j);
        });
      }
    }

#### 第二个集群节点启动 ####

package org.example;
    
    import com.hazelcast.config.Config;
    import com.hazelcast.config.FileSystemXmlConfig;
    import io.vertx.core.Vertx;
    import io.vertx.core.VertxOptions;
    import io.vertx.core.eventbus.EventBusOptions;
    import io.vertx.spi.cluster.hazelcast.HazelcastClusterManager;
    
    import java.io.FileNotFoundException;
    import java.net.InetAddress;
    import java.net.UnknownHostException;
    
    /** * @Author: Administrator * @Description: */
    public class AppCluster2 { 
    
        public static void main(String[] args) throws  UnknownHostException { 
            final VertxOptions vertxOptions = new VertxOptions();
            EventBusOptions eventBusOptions = new EventBusOptions();
            // 本机Ip
            String hostAddress = InetAddress.getLocalHost().getHostAddress();
            vertxOptions.setEventBusOptions(eventBusOptions).getEventBusOptions().setHost(hostAddress);
    
            HazelcastClusterManager clusterManager = new HazelcastClusterManager();
    
            vertxOptions.setClusterManager(clusterManager);
            Vertx.clusteredVertx(vertxOptions, res -> { 
                Vertx result = res.result();
                result.deployVerticle(new MainClusterVerticle2(), r -> { 
                    if (r.succeeded()) { 
                        System.out.println(MainClusterVerticle2.class.getName() + " --> 部署成功");
                    } else { 
                        r.cause().printStackTrace();
                        System.err.println(MainClusterVerticle2.class.getName() + " --> 部署失败, " + r.cause().getMessage());
                    }
                });
            });
        }
    }

#### 发布verticle服务 ####

package org.example;
    
    import io.vertx.core.AbstractVerticle;
    import io.vertx.core.http.HttpServer;
    import io.vertx.core.json.JsonObject;
    import io.vertx.ext.web.Router;
    
    public class MainClusterVerticle2 extends AbstractVerticle { 
      public void start() { 
        System.out.println("start thread" + Thread.currentThread().getName());
        //发布web服务
    
        // 创建HttpServer
        HttpServer server = vertx.createHttpServer();
        // 创建路由对象
        Router router = Router.router(vertx);
        // 监听/index地址
        router.route("/index").handler(request -> { 
          System.out.println("haha" + Thread.currentThread().getName());
          System.out.println("时间到了，发送消息");
          JsonObject json = new JsonObject().put("info", "我是另主");
          //通过eventbus发送请求
          vertx.eventBus().request("com.xiaoniu.bus", json, msg -> { 
            System.out.println("read thread" + Thread.currentThread().getName());
            if (msg.succeeded()) { 
              System.out.println(msg.result() != null
                      ? ((JsonObject)msg.result().body()).encodePrettily()
                      : "没有信息");
            } else { 
              System.err.println(msg.cause().getMessage());
              msg.cause().printStackTrace();
            }
          });
          request.response().end("INDEX SUCCESS");
        });
    
        // 把请求交给路由处理--------------------(1)
        server.requestHandler(router);
        server.listen(7777);
    
    
      }
    }

上面提供了两种通信方式，一种是通过HttpServer对外提供http服务，一种式集群间的基于EventBus的通信，后面我将基于这两种通信方式来构造一个小型的微服务框架。

### 集群启动及原理分析 ###

![在这里插入图片描述][20200720141020635.png]

*  该进程三个重要的TCP端口。

1.  58331端口用于集群中别的vertx服务通过eventbus向它发数据。
2.  5700端口，实验中观察发现集群中启动n个服务，每个服务都会与其他n-1个服务建立连接，并且通过心跳保持连接，这样就可以在一个服务挂掉以后，别的服务会有断开连接提示进而知道集群中某节点挂掉。

*  该进程一个重要UDP端口，组播端口，用于互相告知连接端口，如果上面的5700，进而建立连接形成集群。

第一个vertx服务启动界面  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70]

第二个vertx服务启动界面  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70 1]

第三个vertx服务启动界面  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70 2]  
可以看出每个服务都保存一份集群节点

从第一个进程（4980）的套接字看  
![在这里插入图片描述][20200720150718355.png]  
可以看出第一个进程通过它的集群端口（5700端口）和其他两个集群中的服务保持了TCP连接从而建立集群

从第二个进程的套接字看（3376）  
![在这里插入图片描述][20200720150900263.png]  
可以看出第二个进程通过50674端口和第一个进程集群端口（5700端口）保持TCP连接建立集群，通过50787端口连接第三个进程的集群端口（5702端口）保持TCP连接建立集群

看图可能会直观一点

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70 3]

### 效果展示 ###

定义controller对外提供服务

package com.koala.controller;
    
    import java.util.Date;
    
    import com.koala.common.dto.User;
    import com.koala.common.exception.DemoException;
    import com.koala.core.annotion.*;
    import com.koala.service.DemoService;
    
    @BusController
    @BusMapping("demo")
    public class DemoController { 
    
        @Autowired
        private DemoService demoService;
    
        @BusMapping(value = "resource",method = RequestMethod.GET)
        public User test1(@RequestParam("user") User msg,@RequestParam("num") long num){ 
            demoService.serviceMethod();
            //获取传参
            System.out.println(msg.getA());
            //返回结果
            User user = new User();
            user.setA("adf32");
            user.setB(2);
            user.setDate(new Date());
            return user;
        }
    
        @BusMapping(value = "resource1",method = RequestMethod.GET)
        public User test2(@RequestParam("user") User msg,@RequestParam("num") long num) throws DemoException { 
            throw new DemoException("您报错了");
        }
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70 4]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70 5]  
支持Bean配置类：

package com.koala.config;
    
    import com.koala.core.annotion.Value;
    import com.koala.core.annotion.VertxBean;
    import com.koala.core.annotion.VertxConfiguration;
    import com.koala.pojo.A;
    import com.koala.pojo.B;
    
    /** * @Author: chendi * @Description: @VertxConfiguration下的@VertxBean可以创建一些基础公共组件，在@VertxComponent下可以使用@Autowired注入 */
    @VertxConfiguration
    public class TestConfiguration { 
    
        //配置公共组件需要一些配置参数时，目前先在这儿写死，后续会支持@VertxValue("${my.value}")从application.properties读取
        @Value("${my.value}")
        private String value;
    
        @VertxBean
        public B getB() { 
            B b = new B();
            b.setA(getA());
            return b;
        }
    
        @VertxBean
        public A getA() { 
            A a = new A();
            a.setValue(value);
            return a;
        }
    }

支持IOC及服务启动时执行组件自定义初始化方法

package com.koala.service;
    
    import com.koala.core.annotion.Autowired;
    import com.koala.core.annotion.Value;
    import com.koala.core.annotion.VertxComponent;
    import com.koala.core.ioc.VertxInitializer;
    import com.koala.core.ioc.aware.VertxAware;
    import com.koala.core.log.LogUtil;
    import com.koala.pojo.A;
    import com.koala.pojo.B;
    
    import io.vertx.core.Vertx;
    
    /** * @Author: chen_di * @Description: @VertxComponent一般用于业务层组件或者数据层组件，可以使用@Autowired注入公共组件或者别的组件或者远程调用组件 */
    @VertxComponent
    //实现VertxInitializer接口，init方法中的业务代码会在服务启动时执行
    package com.koala.service;
    
    import com.koala.core.annotion.Autowired;
    import com.koala.core.annotion.Value;
    import com.koala.core.annotion.VertxComponent;
    import com.koala.core.ioc.VertxInitializer;
    import com.koala.core.ioc.aware.VertxAware;
    import com.koala.core.log.LogUtil;
    import com.koala.pojo.A;
    import com.koala.pojo.B;
    
    import io.vertx.core.Vertx;
    
    /** * @Author: chen_di * @Description: @VertxComponent一般用于业务层组件或者数据层组件，可以使用@Autowired注入公共组件或者别的组件或者远程调用组件 */
    @VertxComponent
    //实现VertxInitializer接口，init方法中的业务代码会在服务启动时执行
    public class DemoService implements VertxInitializer, VertxAware { 
    
        @Value("${my.url}")
        private String url;
    
        @Autowired
        private A a;
    
        @Autowired
        private B b;
    
        private Vertx vertx;
    
        public void serviceMethod(){ 
            System.out.println(a);
            System.out.println(b);
        }
    
    
        @Override
        public void init() { 
    
            System.out.println(a);
            System.out.println(b.getA());
    
            System.out.println(a.getValue());
            System.out.println(url);
        }
    
        @Override
        public void setVertx(Vertx vertx) { 
            this.vertx = vertx;
        }
    
    
    }

支持接口配置式的远程调用并可注入

package com.koala.client;
    
    import com.koala.common.dto.User;
    import com.koala.common.exception.DemoException;
    import com.koala.core.annotion.BusMapping;
    import com.koala.core.annotion.RequestMethod;
    import com.koala.core.annotion.RequestParam;
    import com.koala.core.annotion.VertxClient;
    
    /** * @Author: chen_di * @Description: @VertxClient标识远程调用组件 */
    @VertxClient
    @BusMapping("koala.demo")//koala为第一个应用的名字
    public interface MyClient { 
    
        @BusMapping(value = "resource", method = RequestMethod.GET)
        public User test1(@RequestParam("user") User msg, @RequestParam("num") long num);
    
        @BusMapping(value = "resource1", method = RequestMethod.GET)
        public User test2(@RequestParam("user") User msg, @RequestParam("num") long num) throws DemoException;
    
    }

package com.koala.controller;
    
    
    import com.koala.client.MyClient;
    import com.koala.common.dto.User;
    import com.koala.common.exception.DemoException;
    import com.koala.core.annotion.*;
    
    @BusController
    @BusMapping("demo")
    public class DemoController { 
    
        @Autowired
        private MyClient myClient;
    
        @BusMapping(value = "resource",method = RequestMethod.GET)
        public User test1(@RequestParam("user") User msg,@RequestParam("num") long num) { 
            try { 
                //远程调用得到结果
                System.out.println(myClient.test2(msg,num));
            }catch (DemoException e){ 
                e.printStackTrace();
            }
            return new User();
    
        }
    
        @BusMapping(value = "resource1",method = RequestMethod.GET)
        public User test2(@RequestParam("user") User msg,@RequestParam("num") long num) { 
            try { 
            //远程调用捕获异常
                myClient.test2(msg,num);
            }catch (DemoException e){ 
                e.printStackTrace();
            }
            return new User();
    
        }
    
    }

### 实现概览 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70_pic_center]

### 源码解析 ###

。。。

### 适用场景 ###

服务之间传输轻量，单Reactor多线程模型，使用于IO密集型应用。

[20200720141020635.png]: /images/20220829/6b40191eda76483ca09d89218c2f068b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70]: /images/20220829/d92f02efe38d45529ec0a22d469b827d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70 1]: /images/20220829/4eac42280b9b4247bc54369aebad0d2c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70 2]: /images/20220829/dee22f3c08b84a0080e6b62c970e4d8c.png
[20200720150718355.png]: /images/20220829/5583577bd9454ff1bef7f095b139f578.png
[20200720150900263.png]: /images/20220829/e8cf1db5cf69492793de1d53622786fe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70 3]: /images/20220829/26092cf4e5d44a57bada781451c3c5ec.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70 4]: /images/20220829/090978177c334b9a83f0599010e8a2be.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70 5]: /images/20220829/054e9d9900694d77862176f64299d339.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70_pic_center]: /images/20220829/de24c041cc154a52aa1fbcfa06c1d639.png