手游服务端框架之模仿SpringMvc处理玩家请求

原创 2017年07月02日 14:53:56

经典web项目的三层架构

经典web开发项目通常采用三层架构来组织代码。典型的,第一层为表现层,通常使用MVC模式;第二层为业务逻辑层,该层主要是各种service业务操作类;第三层则为数据访问层,通过dao层对数据表进行增删查改操作。

游戏项目的三层架构

类似的,我们的游戏项目也可以采用上面的三层架构。在命名方面,我们部分借鉴了SpringMvc的命名,使用Controller注解对应MVC模式的控制器,使用RequestMapper注解对应的消息处理者(类似于web的http url地址)。网关层收到玩家请求后,将消息分发到对应控制器的指定方法处理者。控制器只用于控制业务流程,具体的业务逻辑将交由业务逻辑层service(游戏项目习惯用Manager来命名)。

使用控制器处理对应业务模块的请求消息

从前面的Message抽象消息的定义可以看出,每一个请求消息包含有一个模块id,一个模块(一个相对独立的游戏功能模块)映射到唯一的控制器;每一个消息包含一个cmd类型,一个cmd类型就代表该功能模块一个子操作。
模块控制器与cmd业务处理method的一对多关系模型如下:


从上面的模型图可以看出,对于给定的模块号结合给定的cmd类型,可以找到唯一的Method与之对应。

好了,开始我们的coding之路吧。

消息控制器与业务流程映射

1. 申明Controller注解,带有该注解的类被标记为消息控制器

package com.kingston.net.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 控制器Controller 
 * 负责处理由MessageDispatcher分发的请求
 */
@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Controller {

}
2.申明RequestMapping注解,带有该注解的方法被标记为处理消息的业务映射

package com.kingston.net.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 处理请求地址映射的注解
 * @author kingston
 */
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequestMapping {

}

3. 定义消息执行单元(CmdExecutor.java),该类负责封装消息的执行者所需要的全部信息

package com.kingston.net.dispatch;  
  
import java.lang.reflect.Method;  
  
/** 
 * 消息执行单元封装 
 * @author kingston 
 * 
 */  
public class CmdExecutor {  
  
    /** 业务处理的工作方法 */  
    private Method method;  
    /** 传递给工作方法的相关参数 */  
    private Class<?>[] params;  
    /** 控制器实例 */  
    private Object handler;  
  
    public static CmdExecutor valueOf(Method method, Class<?>[] params, Object handler) {  
        CmdExecutor executor = new CmdExecutor();  
        executor.method = method;  
        executor.params = params;  
        executor.handler = handler;  
  
        return executor;  
    }  
  
    public Method getMethod() {  
        return method;  
    }  
  
    public Class<?>[] getParams() {  
        return params;  
    }  
  
    public Object getHandler() {  
        return handler;  
    }  
  
}  

4. 定义消息分发器,该分发器负责Controller的初始化,RequestMapper的绑定,消息的接收处理。
package com.kingston.net.dispatch;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import org.apache.mina.core.session.IoSession;
import org.slf4j.Logger;

import com.kingston.logs.LoggerSystem;
import com.kingston.net.Message;
import com.kingston.net.SessionManager;
import com.kingston.net.annotation.Controller;
import com.kingston.net.annotation.Protocol;
import com.kingston.net.annotation.RequestMapping;
import com.kingston.utils.ClassFilter;
import com.kingston.utils.ClassScanner;

/**
 * 消息分发器
 */
public class MessageDispatcher {

	private final Logger logger = LoggerSystem.EXCEPTION.getLogger();

	private volatile static MessageDispatcher instance;

	/** [module_cmd, CmdExecutor] */
	private static final Map<String, CmdExecutor> MODULE_CMD_HANDLERS = new HashMap<>();

	public static MessageDispatcher getInstance() {
		//双重检查锁单例
		if (instance == null) {
			synchronized (MessageDispatcher.class) {
				if (instance == null) {
					instance = new MessageDispatcher();
				}
			}
		}
		return instance;
	}

	private MessageDispatcher() {
		initalize();
	}

	public void initalize() {
		Set<Class<?>> controllers = ClassScanner.getClasses("com.kingston.game", new ClassFilter() {
			@Override
			public boolean accept(Class<?> clazz) {
				return clazz.getAnnotation(Controller.class) != null;
			}
		});

		for (Class<?> controller: controllers) {
			try {
				Object handler = controller.newInstance();
				Method[] methods = controller.getDeclaredMethods();
				for (Method method:methods) {
					RequestMapping mapperAnnotation = method.getAnnotation(RequestMapping.class);
					if (mapperAnnotation != null) {
						MessageMeta meta = getMessageMeta(method);
						if (meta == null) {
							throw new RuntimeException(String.format("controller[%s]方法[%s]缺少RequestMapping注解", 
									controller.getName(), method.getName()));
						}
						short module = meta.module;
						short cmd    = meta.cmd;
						String key = buildKey(meta.module, meta.cmd);
						CmdExecutor cmdExecutor = MODULE_CMD_HANDLERS.get(key);
						if (cmdExecutor != null) {
							throw new RuntimeException(String.format("module[%d] cmd[%d]重复", module, cmd));
						}

						cmdExecutor = CmdExecutor.valueOf(method, method.getParameterTypes(), handler);
						MODULE_CMD_HANDLERS.put(key, cmdExecutor);
					}
				}
			}catch(Exception e) {
				logger.error("", e);
			}
		}
	}

	private MessageMeta getMessageMeta(Method method) {
		for (Class<?> paramClazz: method.getParameterTypes()) {
			if (Message.class.isAssignableFrom(paramClazz)) {
				Protocol protocol = paramClazz.getAnnotation(Protocol.class);
				if (protocol != null) {
					return MessageMeta.valueOf(protocol.module(), protocol.cmd());
				}
			}
		}
		return null;
	}

	/**
	 * 向线程池分发消息
	 * @param session
	 * @param message
	 */
	public void dispatch(IoSession session, Message message) {
		short module = message.getModule();
		short cmd    = message.getCmd();

		CmdExecutor cmdExecutor = MODULE_CMD_HANDLERS.get(buildKey(module, cmd));
		if (cmdExecutor == null) {
			logger.error("请求协议不存在,module=[%d],cmd=[%d]", module, cmd);
			return;
		}

		Object[] params = convertToMethodParams(session, cmdExecutor.getParams(), message);
		Object controller = cmdExecutor.getHandler();
		try {
			//通过反射,
			cmdExecutor.getMethod().invoke(controller, params);
		}catch(Exception e) {
			logger.error("dispatch message failed", e);
		}

	}


	/**
	 * 将各种参数转为被RequestMapper注解的方法的实参
	 * @param session
	 * @param methodParams
	 * @param message
	 * @return
	 */
	private Object[] convertToMethodParams(IoSession session, Class<?>[] methodParams, Message message) {
		Object[] result = new Object[methodParams==null?0:methodParams.length];

		for (int i=0;i<result.length;i++) {
			Class<?> param = methodParams[i];
			if (IoSession.class.isAssignableFrom(param)) {
				result[i] = session;
			}else if (Long.class.isAssignableFrom(param)) {
				result[i] = SessionManager.INSTANCE.getPlayerId(session);
			}else if (long.class.isAssignableFrom(param)) {
				result[i] = SessionManager.INSTANCE.getPlayerId(session);
			}else if (Message.class.isAssignableFrom(param)) {
				result[i] = message;
			}
		}

		return result;
	}

	private String buildKey(short module, short cmd) {
		return module + "_" + cmd;
	}

}

对上文的IoHandler的messageReceived()进行修改,让消息分发器处理消息

@Override 
	public void messageReceived(IoSession session, Object data ) throws Exception 
	{ 
		Message message = (Message)data;
		System.err.println("收到消息-->" + message); 
		//交由消息分发器处理
		MessageDispatcher.getInstance().dispatch(session, message);
		
	} 

至此,整个消息控制器的接收与逻辑映射就完成了。

服务端与客户端程序入口

1.服务端入口,服务端仅需要完成各自模块的初始化,启动mina nioSocket进行监听
package com.kingston;

import com.kingston.logs.LoggerSystem;
import com.kingston.net.MessageFactory;
import com.kingston.net.SocketServer;

public class ServerStarter {

	public static void main(String args[]) {
		//初始化协议池
		MessageFactory.INSTANCE.initMeesagePool();
		//启动socket服务
		try{
			new SocketServer().start();
		}catch(Exception e) {
			LoggerSystem.EXCEPTION.getLogger().error("ServerStarter failed ", e);
		}
	} 

}
2.客户端程序入口,由于编写客户端界面比较麻烦,这里就用一些机器人模拟登录就好了
package com.kingston;

import com.kingston.net.MessageFactory;
import com.kingston.robot.SocketRobot;

public class ClientStarter {

	public static void main(String[] args) {
		//初始化协议池
		MessageFactory.INSTANCE.initMeesagePool();
		
		SocketRobot robot = new SocketRobot("hello");
		robot.buildConnection();
		robot.sendMessage();
	}
	
}
SocketRobot类完成客户端链路的建立及收发消息
package com.kingston.robot;

import java.net.InetSocketAddress;

import org.apache.mina.core.future.ConnectFuture;
import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.transport.socket.nio.NioSocketConnector;

import com.kingston.game.login.message.ReqLoginMessage;
import com.kingston.net.codec.MessageCodecFactory;

public class SocketRobot {

	private String name;

	private IoSession session;

	public SocketRobot(String name) {
		this.name = name;
	}

	public void buildConnection() {
		NioSocketConnector connector = new NioSocketConnector();
		connector.getFilterChain().addLast("codec", new ProtocolCodecFilter(MessageCodecFactory.getInstance()));
		connector.setHandler(new ClientHandler());

		System.out.println("开始连接socket服务端"); 
		ConnectFuture future = connector.connect(new InetSocketAddress(9527));
		
		future.awaitUninterruptibly();

		IoSession session = future.getSession();
		this.session = session;

	}

	public void sendMessage() {
		ReqLoginMessage message = new ReqLoginMessage();
		message.setPassword("kingston");
		message.setAccountId(123L);
		this.session.write(message);
	}

	private class ClientHandler extends IoHandlerAdapter {
		public void messageReceived(IoSession session, Object message) {
			System.out.println("收到响应-->" + message); 
		}
	}

}
3.程序运行结果(先启动服务端,再启动客户端)

a.服务端运行截图

b.客户端运行截图


本文主要讲述Mina socket服务端消息在业务上的流向,从中我们也可以看到,消息是在mina的io线程上进行处理的(服务io线程接收消息后直接处理)。如果业务执行非常耗时,就会影响消息的吞吐量。
文章预告:下一篇主要介绍利用独立线程池来异步处理玩家请求。
手游服务端开源框架系列完整的代码请移步github ->>game_server


版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

手游服务端框架之消息线程模型

玩家的消息请求如果放在mina的io线程池进行处理,当业务处理非常耗时,会严重影响io的吞吐量。所以,我们应该另起用于处理业务逻辑的线程池,采用生产者消费者模型,异步处理玩家请求。

手游服务端框架之GM金手指的设计

游戏开发需要一些命令,能够像金山游侠这种软件一样,修改游戏里的玩家或公共服务的数据。在游戏项目里,这些命令统称为GM命令。本文将介绍实现gm系统的一种方式。

手游服务端框架之使用事件驱动模型解决业务高耦合

游戏里经常有这样的业务,当玩家触发某个动作时,有若干与之关联的业务也要一起执行。诸如这样场景,我们选择引入事件驱动模型来帮助我们解决业务代码耦合的问题。本文实现一个工具库,来解决监听器与事件多对多的关...

游戏开发的艰辛历程与升级展望

从第一款游戏《贪吃蛇》开始,到《水果忍者》、《时空猎人》,再到如今风靡全国的《王者荣耀》,手机游戏迎来了百花齐放的繁华时代。怀着对游戏行业的热爱,一批一批游戏开发大军加入了队伍。即使从业道路很艰辛,我...

再见百田,你好三七

在百田愉快工作了五个月,项目却遭遇了解散。虽然留下遗憾,但未来还有路要走。国庆后,我就要在三七继续奋斗我的青春与汗水。

自定义orm框架解决玩家数据持久化问题

使用持久化框架诸如Hibernate过于重量级,使用原生jdbc又显得非常啰嗦。本文通过几百行代码,演示一个轻量级的持久化框架。可以用于游戏服务端的数据持久化方案。

手游服务端框架之使用Guava构建缓存系统

缓存,在项目中的应用非常之广泛。诸如这样的场景,某些对象计算或者获取的代码比较昂贵,并且在程序里你不止一次要用到这些对象,那么,你就应该使用缓存。缓存,在项目中的应用非常之广泛。诸如这样的场景,某些对...

Netty网络聊天室之会话管理

浏览器第一次与服务器建立连接的时候,服务器就会自动为之分配一个Session。在我们的聊天室,也可以使用Session来判断用户是否经过登录验证,保存用户的各种信息,向客户端发送消息。这极大方便了程序...

游戏服务端防御式开发

游戏服务端承担着游戏复杂业务逻辑实现,玩家数据持久化等重要作用。作为一个合格的服务端开发人员,我们有必要遵守一些好的防御手段,让自己的代码少踩些坑,或者当出现了bug,能够在第一时间进行抢救。本文是我...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)