制作一款游戏协议联调工具
2019-08-03 本文已影响0人
小圣996
时光不在于你拥有多少，而在于你怎样使用 --艾克
通过前面一篇博文 使用Netty+Protobuf实现游戏TCP通信 已为大家实现了客户端和服务端如何使用Netty和Protobuf进行TCP通信，这其实已经是一个缩略版的游戏服务器内部跨服通信框架了，即游戏跨服玩法就可以使用这个通信实例去完善实现。当知道如何实现C/S通信后，我们便可以利用这个实例去制作一款游戏协议的联调工具，这也是这个实例的另一个作用（后续还有一个作用，可以用它做服务器压测机器人）。
这款游戏协议的测试工具有什么用呢？通常来说，在开发游戏功能玩法时，服务端和客户端的进度是不一样的，而且服务端基本都先于客户端完成，因为客户端还没完成，服务端无法联调测试自己所写功能的正确性（在服务端想办法调用自己的协议接口也行，但协议一多，所写的调用方法和代码量也跟着增多了），所以，有了这款协议联调工具，就不用坐等客户端完成后再进行功能联调了。在一定程度上增加开发效率，避免联调出错率。
这其实也可看成游戏的一个小外挂，因为它没通过客户端也能正确和服务端通信，甚至发送大量协议到服务端攻击服务器，因此服务端也需考虑这种情况做好安全检测。
这款工具的最终效果如下，它其实是在上一篇博文《使用Netty+Protobuf实现游戏TCP通信》中的客户端工程中加了一个界面而已，它的登录按钮即处理Netty客户端连接Netty服务端，此后，在下拉列表框中选择要联调的协议，它会自动把参数类型和需求参数打印出来，填入正确参数后，点“发出请求”，即可发到服务端，服务端相应业务逻辑处理后，即可返回协议，显示在控制台中。
游戏协议联调工具.png
现摘录核心代码如下，首先是工具界面代码：
ProtoTestTool.java
/**
* 协议联调工具
* @author 小圣996
* Java游戏服务器编程 https://www.jianshu.com/u/711bb4362a2a
*/
public class ProtoTestTool extends JFrame {
private static final long serialVersionUID = 7163462189849326849L;
private static ProtoTestTool ins = null;
private static String server = "127.0.0.1";//默认链接的服务器ip
private static String port = "38996";//默认链接的服务器端口
private static String account = "18888888888";//账号
private static String selectedStr = "----------请选择需要联调的协议----------";//协议列表默认提示
private JPanel contentPane;//主面板
private JTextField hostInput;//服务器ip输入框
private JTextField portInput;//服务器端口输入框
private JTextField accountInput;//游戏账号输入框
private JButton loginBtn; //登录按钮
private JButton logoutBtn; //下线按钮
private JButton sendBtn; //发送按钮
private JComboBox<String> protocolCombo; //协议列表
private JTextArea reqText;//请求协议输入框
private static JTextArea console;//返回协议控制台
private static JScrollPane scroll;//滚动面板
/**
* Launch the application.
*/
public void start() {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
ProtoTestTool frame = new ProtoTestTool();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
/**
* Create the frame.
* @throws UnknownHostException
*/
public ProtoTestTool() throws UnknownHostException {
setResizable(false);
setTitle("游戏协议联调工具 - 简书 小圣996");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(50, 100, 450, 810);
contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
setContentPane(contentPane);
contentPane.setLayout(null);
//服务器ip输入框
JLabel hostLabel = new JLabel("server:", SwingConstants.LEFT);
hostLabel.setBounds(10, 5, 90, 40);
contentPane.add(hostLabel);
server = InetAddress.getLocalHost().getHostAddress();
hostInput = new JTextField(server, 14);
hostInput.setBounds(55, 10, 150, 30);
contentPane.add(hostInput);
//服务器端口输入框
JLabel portLabel = new JLabel("port:", SwingConstants.LEFT);
portLabel.setBounds(21, 45, 90, 40);
contentPane.add(portLabel);
portInput = new JTextField(port, 14);
portInput.setBounds(55, 50, 150, 30);
contentPane.add(portInput);
//......其余省略，具体见github源码...
}
}
点了登陆后，即相当于开启了客户端去连接服务端，核心代码如下
NettyTcpClient.java
public void conect(String host, int port){
EventLoopGroup group = new NioEventLoopGroup();
Bootstrap bootstrap = new Bootstrap();
bootstrap.group(group);
bootstrap.channel(NioSocketChannel.class);
bootstrap.handler(new ChannelInitializer<Channel>() {
@Override
protected void initChannel(Channel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
pipeline.addLast("decoder", new ProtoDecoder(5120));
pipeline.addLast("encoder", new ProtoEncoder(2048));
pipeline.addLast("serverHandler", new ClientHandler());
}
});
ChannelFuture future;
try {
future = bootstrap.connect(new InetSocketAddress(host, port)).sync();
System.out.println("----channel:"+future.channel());
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
//future.channel().closeFuture().awaitUninterruptibly();
}
接下来可以选择要联调的协议了，这里有一点游戏协议设计上的技巧，即请求协议最好与返回协议能区分出来，比如这里的RoleProto.proto文件，请求协议就用了xxxReq_xxxxxx，返回协议就用了xxxResp_xxxxxx来区分，这样不仅容易区分协议类型，而且做协议联调工具时，很容易做好客户端服务端协议分离；而且在后续做机器人压测工具时，因为有些机器人是功能性机器人，比如专门测世界boss的机器人，如果我们定义好游戏各功能模块的id，假设世界boss这个功能模块的id为5，那么它的协议范围区间可以定义为WorldBossReq_005001至WorldBossReq_005999，这样在做世界boss的机器人时，我们只要匹配出"Req_005"的所有协议，那么它们就是世界Boss的所有请求协议，这样我们只要在这些协议中随机协议出来，就可以做机器人随机测世界boss的功能了。
当选好协议后，它需要的参数就会在请求协议下面的文本框中显示出来，填入正确参数后，然后点发出请求按钮，即可模仿客户端发送请求协议了，这样就可以联调服务端的业务逻辑了。
选择协议，显示协议中字段类型和字段名称的核心代码如下：
public void fillUpInput() {
String[] strs = selectedStr.split("-");
if(strs.length != 2){//可能是那句提示语
reqText.setText("需填入协议各字段");
return;
}
int protocol = Integer.parseInt(strs[0]);
TreeMap<Integer, Class<?>> reqMap = ProtoManager.getInstance().getReqMap();
Class<?> selectClz = reqMap.get(protocol);
Class<?> buildClass = null;
for (Class<?> cls : selectClz.getDeclaredClasses()) {
if ("Builder".equals(cls.getSimpleName())) {
buildClass = cls;
break;
}
}
StringBuilder sb = new StringBuilder();
if (buildClass != null) {
for (Field field : buildClass.getDeclaredFields()) {
if ("bitField0_".equals(field.getName())) {
continue;
}
String fieldType;
if(field.getType().isAssignableFrom(String.class)){
fieldType = "String";
}else if(field.getType().isAssignableFrom(List.class)){
Class<?> parameterClass = (Class<?>) ((ParameterizedType) field.getGenericType())
.getActualTypeArguments()[0];
String subFieldType = parameterClass == Integer.class ? "int" :
(parameterClass == Long.class ? "long" : "string");
fieldType = "List<"+subFieldType+">";
}else if(field.getType().isAssignableFrom(LazyStringList.class)){
fieldType = "List<string>";
}else{
fieldType = field.getType().toString();
}
if(sb.length() > 0)
sb.append("\n");
//int a =
sb.append(fieldType)
.append(" ")
.append(field.getName()
.replaceAll("_", ""))
.append(" = ");
}
}
reqText.setText(sb.toString());
}
正确填入协议各参数后，点“发出请求”按钮解析并打包协议各字段的核心代码为：
private void sendReq(){
String[] strs = selectedStr.split("-");
if(strs.length != 2){//可能是那句提示语
JOptionPane.showMessageDialog(ProtoTestTool.this, "请选择正确协议！");
return;
}
//console.setText("等待响应中...");
int protocol = Integer.parseInt(strs[0]);
Class<?> selectClz = ProtoManager.getInstance().getReqMap().get(protocol);
try {
Method newMethod = selectClz.getDeclaredMethod("newBuilder", new Class[0]);
Object builder = newMethod.invoke(selectClz, new Object[0]);
Method buildMethod = builder.getClass().getDeclaredMethod("build", new Class[0]);
String[] keyValues = reqText.getText().split("\n");
boolean isNullParam = true;
for (String str : keyValues) {
if ("".equals(str.trim())) {
continue;
}
String[] nameValue = str.split("=");
if (nameValue.length < 2 || nameValue[1].trim().equals("")) {
continue;
}
isNullParam = false;
String[] typeValue = nameValue[0].split(" ");
Field field = builder.getClass().getDeclaredField(typeValue[1] + "_");
Method setter = null;
Class<?> parameterClass = null;
if (field.getType().isAssignableFrom(String.class)) {
parameterClass = String.class;
setter = builder.getClass().getDeclaredMethod(
"set" + typeValue[1].substring(0, 1).toUpperCase()
+ typeValue[1].substring(1),
parameterClass);
} else if (field.getType().isAssignableFrom(List.class)) {
parameterClass = (Class<?>) ((ParameterizedType) field.getGenericType())
.getActualTypeArguments()[0];
setter = builder.getClass().getDeclaredMethod(
"add" + typeValue[1].substring(0, 1).toUpperCase()
+ typeValue[1].substring(1),
getMethodClass(parameterClass));
} else {
parameterClass = field.getType();
setter = builder.getClass().getDeclaredMethod(
"set" + typeValue[1].substring(0, 1).toUpperCase()
+ typeValue[1].substring(1),
parameterClass);
}
if (field.getType().isAssignableFrom(String.class)) {
setter.invoke(builder, nameValue[1].trim());
} else if ("int".equals(field.getType().getSimpleName())) {
setter.invoke(builder, Integer.parseInt(nameValue[1].trim()));
} else if ("long".equals(field.getType().getSimpleName())) {
setter.invoke(builder, Long.parseLong(nameValue[1].trim()));
} else if (field.getType().isAssignableFrom(List.class)) {
String[] values = nameValue[1].trim().split(",");
for (String value : values) {
if (parameterClass == Long.class) {
setter.invoke(builder, Long.parseLong(value));
} else if (parameterClass == Integer.class) {
setter.invoke(builder, Integer.parseInt(value));
} else {
setter.invoke(builder, value);
}
}
}
}
if(keyValues.length > 1 && isNullParam){
JOptionPane.showMessageDialog(ProtoTestTool.this, "不能发送,参数为空!! cmd:"+protocol);
return;
}
//print("\n 协议:"+protocol+"参数如下:");
Object builded = buildMethod.invoke(builder, new Object[0]);
System.out.println(ProtoPrinter.parseResps(builded));
ProtoManager.getInstance().send((Message) builded);
}catch(Exception e){
e.printStackTrace();
}
}
接下来就是上篇博文《使用Netty+Protobuf实现游戏TCP通信》中先将Protobuf协议打包成Packet数据包，然后编码成二进制字节流发给服务端，服务端返回协议给客户端后，客户端最终收到Packet数据包并解析和显示Protobuf返回协议的各字段的核心代码如下：
//返回协议处理
public void handleProto(Packet packet){
//打印协议
Class<?> clz = getRespMap().get(packet.getCmd());
try {
Method method = clz.getMethod("parseFrom", byte[].class);
Object object = method.invoke(clz, packet.getBytes());
String resp = ProtoPrinter.parseResps(object);
ProtoTestTool.print(packet.getCmd(), resp);
} catch (Exception e1) {
e1.printStackTrace();
}
}
ProtoPrinter.java
public class ProtoPrinter {
public static String parseResps(Object object) throws Exception {
try {
StringBuilder builder = new StringBuilder();
Class<?> objClass = object.getClass();
Class<?> builderClass = null;
for(Class<?> cls : objClass.getDeclaredClasses()) {
if("Builder".equals(cls.getSimpleName())) {
builderClass = cls;
break;
}
}
if (builderClass != null) {
for(Field field : builderClass.getDeclaredFields()) {
if(field.getName().startsWith("bitField")) {
continue;
}
if (field.getName().indexOf("Builder") >= 0) {
continue;
}
Method getter = null;
Object value = null;
if(field.getType().isAssignableFrom(String.class)) {
getter = objClass.getDeclaredMethod("get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1).replaceAll("_", ""), new Class[0]);
} else if(field.getType().isAssignableFrom(List.class)) {
getter = objClass.getDeclaredMethod("get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1).replaceAll("_", "List"), new Class[0]);
} else if(field.getType().isAssignableFrom(LazyStringList.class)) {
getter = objClass.getDeclaredMethod("get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1).replaceAll("_", "List"), new Class[0]);
} else {
//System.out.println("get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1).replaceAll("_", ""));
getter = objClass.getDeclaredMethod("get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1).replaceAll("_", ""), new Class[0]);
}
if(builder.length() > 0)
builder.append("\n");
builder.append(field.getName().replaceAll("_", "") + ": ");
value = getter.invoke(object, new Object[0]);
//System.out.println(value);
doPrint(value, "", builder);
}
}
return builder.toString();
} catch (Exception e) {
e.printStackTrace();
}
return String.format("解析返回协议出错，cmd:%s", object.toString());
}
@SuppressWarnings("rawtypes")
private static void doPrint(Object object, String offset, StringBuilder result) {
try {
if(object instanceof String) {
result.append(object.toString());
} else if(object instanceof List) {
result.append("[");
List list = (List) object;
for(Object obj : list) {
doPrint(obj, offset, result);
result.append(",");
}
result.append("]");
} else if (object instanceof GeneratedMessageV3) {
Class<?> objClass = object.getClass();
result.append("{");
Class<?> builderClass = null;
for(Class<?> cls : objClass.getDeclaredClasses()) {
if("Builder".equals(cls.getSimpleName())) {
builderClass = cls;
break;
}
}
if (builderClass != null) {
for(Field field : builderClass.getDeclaredFields()) {
if("bitField0_".equals(field.getName())) {
continue;
}
Object value = null;
Method getter = null;
if(field.getType().isAssignableFrom(String.class)) {
getter = objClass.getDeclaredMethod("get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1).replaceAll("_", ""), new Class[0]);
} else if(field.getType().isAssignableFrom(List.class)) {
getter = objClass.getDeclaredMethod("get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1).replaceAll("_", "List"), new Class[0]);
} else if(field.getType().isAssignableFrom(LazyStringList.class)) {
getter = objClass.getDeclaredMethod("get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1).replaceAll("_", "List"), new Class[0]);
} else {
getter = objClass.getDeclaredMethod("get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1).replaceAll("_", ""), new Class[0]);
}
value = getter.invoke(object, new Object[0]);
result.append("\n" + offset + "\t" + field.getName().replaceAll("_", "") + ":");
doPrint(value, offset + "\t", result);
}
}
result.append("}");
} else {
result.append(object.toString());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
这样，完整的协议联调工具就大功告成了。
工具源码地址为：
https://github.com/zhou-hj/ProtoTestTool.git
服务端源码地址为：
https://github.com/zhou-hj/NettyProtobufTcpServer.git
