使用Netty4实现基本的消息分发

示例工程代码

 

可从附件下载

 

具体的说明和用法在后面介绍

 

需求与目的

 

一个游戏服务端需要处理各种业务逻辑，每一种业务逻辑都对应着一个请求消息和一个响应消息。那么服务端需要把这些不同的消息自动分发到对应的业务逻辑中处理。

 

最简单的处理方式就是根据请求消息中的type字段，使用switch case来进行分别处理，但这种方式随着消息的增多，显现了一些坏味道：长长的一大坨不太好看；如果要添加新的消息、新的逻辑，或者去掉新的消息、新的逻辑，在代码上不但要修改这些消息和逻辑，还不得不修改这长长的一坨swtich case，这样的修改显得很多余。

 

所以我们的目的就是把消息分发这块的代码自动化，在增加、修改、删除消息和逻辑的时候不需要再对消息分发的代码再做修改，从而使得修改的代码最小化。

 

实现原理

 

在实现中，使用了注解（annotation）

Java代码  收藏代码
  1. package com.company.game.dispatcher.annotation;  
  2.   
  3. import java.lang.annotation.ElementType;  
  4. import java.lang.annotation.Retention;  
  5. import java.lang.annotation.RetentionPolicy;  
  6. import java.lang.annotation.Target;  
  7.   
  8. /** 
  9.  * 修饰消息类和业务逻辑执行类 
  10.  * msgType指定对应的类型，从1开始计数 
  11.  * @author xingchencheng 
  12.  * 
  13.  */  
  14.   
  15. @Target(ElementType.TYPE)  
  16. @Retention(RetentionPolicy.RUNTIME)  
  17. public @interface UserMsgAndExecAnnotation {  
  18.     short msgType();  
  19. }  

 

唯一的字段msgType代表了消息类型，这是客户端与服务端的约定，这里我们从1开始计数。

 

当我们要增加一个加法消息时，就使用这个注解来修饰我们的请求消息类：

Java代码  收藏代码
  1. package com.company.game.dispatcher.msg;  
  2.   
  3. import com.company.game.dispatcher.annotation.UserMsgAndExecAnnotation;  
  4.   
  5. /** 
  6.  * 加法请求消息类 
  7.  *  
  8.  * @author xingchencheng 
  9.  * 
  10.  */  
  11.   
  12. @UserMsgAndExecAnnotation(msgType = MsgType.ADD)  
  13. public class UserAddRequest extends RequestMsgBase {  
  14.   
  15.     private double leftNumber;  
  16.     private double RightNumber;  
  17.       
  18.     public UserAddRequest() {  
  19.         super(MsgType.ADD);  
  20.     }  
  21.   
  22.     public double getLeftNumber() {  
  23.         return leftNumber;  
  24.     }  
  25.   
  26.     public void setLeftNumber(double leftNumber) {  
  27.         this.leftNumber = leftNumber;  
  28.     }  
  29.   
  30.     public double getRightNumber() {  
  31.         return RightNumber;  
  32.     }  
  33.   
  34.     public void setRightNumber(double rightNumber) {  
  35.         RightNumber = rightNumber;  
  36.     }  
  37.   
  38. }  

 

为什么要这样修饰呢？先从服务端的解码（decode）说起，实例代码中，一个请求消息是这样规定的：

 

 0-1字节表示整个消息的长度（单位：字节）

 2-3字节代表消息类型，对应annotation的msgType

 余下的是消息的json字符串（UTF-8编码）

 

我们需要根据2-3字节表示的msgType得到对应请求消息类的class对象，用这个class对象来序列化json字符串，得到具体的请求对象。那么怎么根据msgType得到class对象呢？这就是为什么要使用annotation的原因。

 

在服务端程序启动前，会执行下面的处理：

 

Java代码  收藏代码
  1. // msgType->请求、响应类的class对象  
  2. private static Map<Short, Class<?>> typeToMsgClassMap;  
  3.   
  4. // 根据类型得到对应的消息类的class对象  
  5. public static Class<?> getMsgClassByType(short type) {  
  6.     return typeToMsgClassMap.get(type);  
  7. }  
  8.   
  9. /** 
  10.  * 初始化typeToMsgClassMap 
  11.  * 遍历包com.company.game.dispatcher.msg 
  12.  * 取得消息类的class文件 
  13.  *  
  14.  * @throws ClassNotFoundException 
  15.  * @throws IOException 
  16.  */  
  17. public static void initTypeToMsgClassMap()   
  18.         throws ClassNotFoundException, IOException {  
  19.       
  20.     Map<Short, Class<?>> tmpMap = new HashMap<Short, Class<?>>();  
  21.       
  22.     Set<Class<?>> classSet = getClasses("com.company.game.dispatcher.msg");  
  23.     if (classSet != null) {  
  24.         for (Class<?> clazz : classSet) {  
  25.             if (clazz.isAnnotationPresent(UserMsgAndExecAnnotation.class)) {  
  26.                 UserMsgAndExecAnnotation annotation = clazz.getAnnotation(UserMsgAndExecAnnotation.class);  
  27.                 tmpMap.put(annotation.msgType(), clazz);  
  28.             }  
  29.         }  
  30.     }  
  31.       
  32.     typeToMsgClassMap = Collections.unmodifiableMap(tmpMap);  
  33. }  

 

程序初始化了一个映射，在指定的包找到请求的消息类的class，读取class上的annotation，保存到一个Map中，这样在后续就可以根据这个Map来根据msgType得到class对象了。

 

再给出解码器的实现：

 

Java代码  收藏代码
  1. package com.company.game.dispatcher.codec;  
  2.   
  3. import java.util.List;  
  4.   
  5. import com.company.game.dispatcher.util.ClassUtil;  
  6. import com.company.game.dispatcher.util.GsonUtil;  
  7. import com.google.gson.Gson;  
  8.   
  9. import io.netty.buffer.ByteBuf;  
  10. import io.netty.channel.ChannelHandlerContext;  
  11. import io.netty.handler.codec.ByteToMessageDecoder;  
  12.   
  13. /** 
  14.  * 解码器 
  15.  * 客户端和服务端均有使用 
  16.  * 0-1字节表示整个消息的长度（单位：字节） 
  17.  * 2-3字节代表消息类型，对应annotation 
  18.  * 余下的是消息的json字符串（UTF-8编码） 
  19.  *  
  20.  * @author xingchencheng 
  21.  * 
  22.  */  
  23.   
  24. public class MsgDecoder extends ByteToMessageDecoder {  
  25.   
  26.     @Override  
  27.     protected void decode(ChannelHandlerContext ctx, ByteBuf buf,  
  28.             List<Object> list) throws Exception {  
  29.           
  30.         if (buf.readableBytes() < 2) {  
  31.             return;  
  32.         }  
  33.           
  34.         Gson gson = GsonUtil.getGson();  
  35.         short jsonBytesLength = (short) (buf.readShort() - 2);  
  36.         short type = buf.readShort();  
  37.           
  38.         byte[] tmp = new byte[jsonBytesLength];  
  39.         buf.readBytes(tmp);  
  40.         String json = new String(tmp, "UTF-8");  
  41.           
  42.         Class<?> clazz = ClassUtil.getMsgClassByType(type);  
  43.         Object msgObj = gson.fromJson(json, clazz);  
  44.         list.add(msgObj);  
  45.     }  
  46. }  

 

解码完成后，程序进入到服务端的handler中：

Java代码  收藏代码
  1. @Override  
  2. protected void channelRead0(ChannelHandlerContext ctx, Object msgObject)  
  3.         throws Exception {  
  4.       
  5.     // 分发消息给对应的消息处理器  
  6.     Dispatcher.submit(ctx.channel(), msgObject);  
  7. }  

 

Dispatcher代码如下：

Java代码  收藏代码
  1. package com.company.game.dispatcher;  
  2.   
  3. import io.netty.channel.Channel;  
  4.   
  5. import java.util.concurrent.ExecutorService;  
  6. import java.util.concurrent.Executors;  
  7.   
  8. import com.company.game.dispatcher.exec.BusinessLogicExecutorBase;  
  9. import com.company.game.dispatcher.msg.RequestMsgBase;  
  10. import com.company.game.dispatcher.util.ClassUtil;  
  11.   
  12. /** 
  13.  * 抽象了分发器 
  14.  * 多线程执行 
  15.  * 某个消息对象msgObject指定某个业务逻辑对象executor 
  16.  * submit到线程池中 
  17.  * @author xingchencheng 
  18.  * 
  19.  */  
  20.   
  21. public class Dispatcher {  
  22.       
  23.     private static final int MAX_THREAD_NUM = 50;  
  24.       
  25.     private static ExecutorService executorService =  
  26.             Executors.newFixedThreadPool(MAX_THREAD_NUM);  
  27.       
  28.     public static void submit(Channel channel, Object msgObject)   
  29.             throws InstantiationException, IllegalAccessException {  
  30.           
  31.         RequestMsgBase msg = (RequestMsgBase) msgObject;  
  32.         Class<?> executorClass = ClassUtil.getExecutorClassByType(msg.getType());  
  33.         BusinessLogicExecutorBase executor =   
  34.                 (BusinessLogicExecutorBase) executorClass.newInstance();  
  35.         executor.setChannel(channel);  
  36.         executor.setMsgObject(msgObject);  
  37.           
  38.         executorService.submit(executor);  
  39.     }  
  40. }  

 

我们看到，在代码中也是根据msgType取得了对应的一个class对象，并new了一个对象出来，交给了线程池进行并发执行，这个对象就是业务逻辑处理器对象，它实现了Runnable接口，进行一些业务逻辑上的处理。根据msgType取得class对象的映射过程跟前面提到的映射原理是相同的，可以参见代码。贴出业务逻辑处理器对象的代码：

Java代码  收藏代码
  1. package com.company.game.dispatcher.exec;  
  2.   
  3. import com.company.game.dispatcher.annotation.UserMsgAndExecAnnotation;  
  4. import com.company.game.dispatcher.msg.MsgType;  
  5. import com.company.game.dispatcher.msg.UserAddRequest;  
  6. import com.company.game.dispatcher.msg.UserAddResponse;  
  7.   
  8. /** 
  9.  * 具体的业务逻辑 
  10.  * 实现加法 
  11.  *  
  12.  * @author xingchencheng 
  13.  * 
  14.  */  
  15.   
  16. @UserMsgAndExecAnnotation(msgType = MsgType.ADD)  
  17. public class UserAddExecutor extends BusinessLogicExecutorBase {  
  18.   
  19.     public void run() {  
  20.         UserAddResponse response = new UserAddResponse();  
  21.           
  22.         if (this.msgObject instanceof UserAddRequest) {  
  23.             UserAddRequest request = (UserAddRequest) this.msgObject;  
  24.             double result = request.getLeftNumber() + request.getRightNumber();  
  25.             response.setResult(result);  
  26.             response.setSuccess(true);  
  27.         } else {  
  28.             response.setSuccess(false);  
  29.         }  
  30.           
  31.         System.out.println("服务端处理结果：" + response.getResult());  
  32.         channel.writeAndFlush(response);  
  33.     }  
  34.   
  35. }  

注意，它也得用annotation来修饰。

 

思路大致就是如此，如果要增加一个请求，在示例代码中，需要做3件事情：

  • 在MsgType添加一个类型
  • 添加请求相应消息类
  • 添加业务逻辑处理器类

而不需要修改消息分发的代码。

 

示例项目的说明和使用

 

  • 工程可在文章开头的github中或附件得到
  • 项目使用Maven3构建，构建的结果是一个jar，可通过命令行分别运行服务端和客户端
  • 仅仅是个示例，并没有过多的考虑异常处理，性能等方面
  • 没有单元测试和其他测试

提供了命令行工具，帮助信息如下：


 

服务端启动命令：


 

客户端启动命令：


 

结语

 

本文的描述未必清晰，更好的方法是直接看代码。

关于消息分发想必还有更好的方法，这里只是抛砖引玉，希望路过的各位能提供更好的方法一起参考。

posted @ 2017-11-13 16:54  上台阶  阅读(2299)  评论(0)  编辑  收藏  举报