vert.x实践六——让Eventbus像使用MVC一样

逃离我推掉我的手 2023-03-04 09:21 62阅读 0赞

> 这几天呕血封装，终于把Event Bus封装成人能用的样子了

## 如何使用 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70]  
我们看下vert.x-create项目如何使用之

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70 1]  
DemoController.java

package wanke.com.controller;
    
    import wanke.com.common.annotion.Controller;
    import wanke.com.common.annotion.RequestMapping;
    import wanke.com.common.msghandle.WrapMsg;
    
    import java.util.HashMap;
    import java.util.Map;
    
    @Controller
    @RequestMapping("device")
    public class DemoController { 
    
    
        @RequestMapping("getdevice")
        public Map get(WrapMsg msg){ 
            //获取传参
            Map body = msg.body();
    
            //返回结果
            HashMap data = new HashMap();
            data.put("a","1");
            return data;
        }
    }

application.properties

#proto,json,flat
    transfer.data.format=proto
    #本机局域网IP
    transfer.data.ip=192.168.2.112
    #Controller所在目录
    vert.x.controller=wanke.com.controller

VertXApplication.java

package wanke.com;
    
    import wanke.com.common.starter.AppCluster;
    
    public class VertXApplication { 
    
        public static void main(String[] args) { 
            new AppCluster().main(args);
        }
    }

而做到这些只需要在本maven模块化工程中新建一个模块

引入pom.xml

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>vertx-root</artifactId>
            <groupId>org.example</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>vert.x-create</artifactId>
        <packaging>jar</packaging>
        <version>1.0-SNAPSHOT</version>
        <name>vert.x-create</name>
        
        <url>http://www.example.com</url>
    
    
        <dependencies>
    
    
            <dependency>
                <groupId>org.example</groupId>
                <artifactId>vert.x-common</artifactId>
                <version>1.0-SNAPSHOT</version>
            </dependency>
    
        </dependencies>
        <build>
            <plugins>
    
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-shade-plugin</artifactId>
                    <version>2.4.2</version>
                    <executions>
                        <execution>
                            <phase>package</phase>
                            <goals>
                                <goal>shade</goal>
                            </goals>
                            <configuration>
                                <transformers>
                                    <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                        <manifestEntries>
                                            <Main-Class>${ main.class}</Main-Class>
                                        </manifestEntries>
                                    </transformer>
                                </transformers>
                                <artifactSet />
                                <outputFile>${ project.build.directory}/${ project.artifactId}-${ project.version}-prod.jar</outputFile>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    </project>

## vert.x-common在做什么 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70 2]  
VertxConfig.java

package wanke.com.common.config;
    
    import io.vertx.core.eventbus.DeliveryOptions;
    import wanke.com.common.log.LogUtil;
    import wanke.com.common.messagecodec.FlatBuffersMessageCodec;
    import wanke.com.common.messagecodec.ProtoMessageCodec;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.Properties;
    
    public class VertxConfig { 
    
        static { 
        //初始化数据监听ip、传输数据编码格式、需要扫包的路径(@Controlller的类所在路径)
            InputStream in = VertxConfig.class.getResourceAsStream("/application.properties");
            Properties properties = new Properties();
            try { 
                properties.load(in);
            } catch (IOException e) { 
                LogUtil.error("read properties error");
                System.exit(0);
            }
            String format = properties.getProperty("transfer.data.format");
            String dataIp = properties.getProperty("transfer.data.ip");
            String pkg = properties.getProperty("vert.x.controller");
            if (dataIp == null){ 
                LogUtil.errorDirect("transfer.data.ip is must");
                System.exit(-1);
            }
            setDataIp(dataIp);
            if (pkg == null){ 
                setPkg("wanke.com.controller");
            }else { 
                setPkg(pkg);
            }
    
           LogUtil.infoDirect("loading for " + format + " codec");
            DeliveryOptions options = new DeliveryOptions();
            setFormat("json");
            if (format != null){ 
                if (format.equals("proto")){ 
                    setFormat("proto");
                    options.setCodecName(new ProtoMessageCodec().name());
                }else if(format.equals("flat")){ 
                    setFormat("flat");
                    options.setCodecName(new FlatBuffersMessageCodec().name());
                }
            }
            setOptions(options);
        }
    
        private static VertxConfig instance = new VertxConfig();
    
        private VertxConfig(){ }
    
        public static VertxConfig  getInstance(){ 
    
            return instance;
    
        }
    
        private static DeliveryOptions options;
    
        private static String pkg;
    
        private static String dataIp;
    
        private static String format;
    
        public static DeliveryOptions getOptions() { 
            return options;
        }
    
        public static void setOptions(DeliveryOptions options) { 
            VertxConfig.options = options;
        }
    
        public static String getPkg() { 
            return pkg;
        }
    
        public static void setPkg(String pkg) { 
            VertxConfig.pkg = pkg;
        }
    
        public static String getDataIp() { 
            return dataIp;
        }
    
        public static void setDataIp(String dataIp) { 
            VertxConfig.dataIp = dataIp;
        }
    
        public static String getFormat() { 
            return format;
        }
    
        public static void setFormat(String format) { 
            VertxConfig.format = format;
        }
    }

ClusterVerticle.java

package wanke.com.common.verticle;
    
    import io.vertx.core.AbstractVerticle;
    import io.vertx.core.eventbus.DeliveryOptions;
    import io.vertx.core.eventbus.EventBus;
    import io.vertx.core.http.HttpServer;
    import io.vertx.ext.web.Router;
    import wanke.com.common.annotion.Controller;
    import wanke.com.common.annotion.RequestMapping;
    import wanke.com.common.config.VertxConfig;
    import wanke.com.common.flat.FlatBuffersCommonMsg;
    import wanke.com.common.log.LogUtil;
    import wanke.com.common.messagecodec.FlatBuffersMessageCodec;
    import wanke.com.common.messagecodec.ProtoMessageCodec;
    import wanke.com.common.msghandle.WrapMsg;
    import wanke.com.common.util.ScanPackageClassUtil;
    
    import java.io.IOException;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.lang.reflect.Type;
    import java.util.List;
    import java.util.Map;
    
    public class ClusterVerticle  extends AbstractVerticle { 
    
        public void start() { 
            //注册编码解码器,当前支持proto、flat、json
            ProtoMessageCodec protoMessageCodec = new ProtoMessageCodec();
            FlatBuffersMessageCodec flatBuffersMessageCodec = new FlatBuffersMessageCodec();
            EventBus eventBus = vertx.eventBus();
            eventBus.registerCodec(protoMessageCodec);
            eventBus.registerCodec(flatBuffersMessageCodec);
    
    
            //扫描
            List<String> controllerList = null;
            Method[] methods = null;
            try { 
               controllerList = ScanPackageClassUtil.getClassNameFromPackage(VertxConfig.getPkg());
               LogUtil.info(controllerList.toString());
                for (String controllerClass : controllerList) { 
                    Class<?> controller = Class.forName(controllerClass);
                    if (!controller.isAnnotationPresent(Controller.class)) { 
                        continue;
                    }
                    methods = controller.getMethods();
                    String firstRMString = controller.getAnnotation(RequestMapping.class).value();
                    Object o = controller.newInstance();
                    for (Method method : methods) { 
                        RequestMapping curMethodRM = method.getAnnotation(RequestMapping.class);
                        if (curMethodRM == null){ 
                            continue;
                        }
                        Type t = method.getAnnotatedReturnType().getType();
                        if (!t.getTypeName().equals("java.util.Map") && !t.getTypeName().equals("java.util.HashMap")){ 
                            LogUtil.errorDirect("must method with Map or HashMap");
                            System.exit(-1);
                        }
                        String secondRMString = curMethodRM.value();
                        //注册Consumer
                        eventBus.consumer(firstRMString + "." + secondRMString, msg -> { 
                            WrapMsg wrapMsg = new WrapMsg();
                            wrapMsg.setInnerMsg(msg);
                            try { 
                                Object reply = method.invoke(o, wrapMsg);
                                wrapMsg.reply((Map) reply);
                            } catch (Exception e) { 
                                LogUtil.error(e.getMessage());
                            }
                        });
                    }
                }
            }catch (Exception e){ 
                LogUtil.errorDirect(e.getMessage());
                System.exit(-1);
            }
    
    
    
        }
    }

## 还在持续中。。。。。。 ##

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70]: /images/20230208/99c7414b6478420ca1e0a9e99af00032.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70 1]: /images/20230208/8bf5d0903b73435eb75018635455c656.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hrNDg0ODEyMw_size_16_color_FFFFFF_t_70 2]: /images/20230208/9110da3371c54d31bc7a8a7d2c8a17d7.png