在游戏服务器的框架设计中,最重要的就是管理业务逻辑处理。当收到客户端的请求消息时,服务器如何辨认这个消息是什么请求,怎么样保证同一个用户请求处理的顺序性?怎么样提高并发性?这些都是在底层框架中要解决的问题。这里分享一种做法,有用者取之。
1,定义消息Id
给客户端与服务器交互的消息定义一个唯一的消息id,通过消息的id,处理对应的业务请求,比如1001 代表登陆,1002 代表签到,1003代表抽卡,等。
2,管理消息Id与处理方法的映射
当服务器解析出客户端的请求拿到消息号之后,怎么做相应处理呢?有的是这样做的:
public void dispatch(int id, JSONObject param, long userId) { if (id == 1001) { // 调用相关的处理方法 } else if (id == 1002) { // 调用相关的处理方法 } else if (id == 1003) { // 调用相关的处理方法 } // 或者 switch (id) { case 1001: // 调用相关的处理方法 break; case 1002: // 调用相关的处理方法 break; case 1003: // //调用相关的处理方法 break; default: break; } }
这两种方法不是不可以,如果是请求不多还行,如果大一点的游戏,几十上百个请求,一个类中几百行if或switch,看起来就心烦,再加上团队间协作开发,多人修改导致提交git冲突等问题。
一种解决方法是,设计一个统一的接口,每个请求对应一个接口,把id和接口映射起来,放到一个map中。例如:
public class LogicManager { Map<Integer, IMessageProcess> messageMap = new HashMap<>(); public void init() { messageMap.put(1001, new LoginProcess()); //以下省略很多 } public void dispatch(int id, JSONObject param, long userId) { IMessageProcess process = messageMap.get(id); if(process != null) { process.action(userId, param); } } }
这种方式只需要每增加一个消息,增加一个接口实现即可,但是有个问题是每次都需要手动添加消息号和接口的映射,很不爽,我们可以使用注解的反射解决这个问题。
我的项目是使用spring boot管理的,所以使用了spring的特性,从容器中获取实例,因为spring已经在启动的时候扫描了所有注解。
先看定义的注解:
import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; import org.springframework.stereotype.Service; import com.xinyue.interview.logiccontroller.RequestCode; @Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Service public @interface LogicRequestMapping { public RequestCode value() default RequestCode.DEFAULT; }
这个注解具体有spring @Service的特性。RequestCode是定义的消息号枚举,把它添加到接口的实现类上面。
@LogicRequestMapping public class LoginProcess implements IMessageProcess{ @Override public void action(long userId, JSONObject param) { } }
然后在服务器启动的时候,使用程序自动映射消息号和接口
package com.netty; import java.util.HashMap; import java.util.Map; import javax.annotation.PostConstruct; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.ApplicationContext; import org.springframework.stereotype.Service; import com.alibaba.fastjson.JSONObject; @Service public class LogicManager { Map<Integer, IMessageProcess> messageMap = new HashMap<>(); @Autowired private ApplicationContext context; @PostConstruct public void init() { Map<String, Object> beanMap = context.getBeansWithAnnotation(LogicRequestMapping.class); beanMap.forEach((k,v)->{ LogicRequestMapping logicRequestMapping = v.getClass().getAnnotation(LogicRequestMapping.class); if(logicRequestMapping != null && v instanceof IMessageProcess) { int id = logicRequestMapping.value().getCode(); messageMap.put(id, (IMessageProcess) v); } }); } public void dispatch(int id, JSONObject param, long userId) { IMessageProcess process = messageMap.get(id); if (process != null) { process.action(userId, param); } } }
这样增加新请求的时候,只需要增加新接口实现即可,而旧的代码不需要修改,也没有长长的if和switch判断。如果觉得RequestCode也需要修改,可以去掉,换成接口,每个人可以定义自己的消息枚举。
如果觉得一个接口处理一个消息有点浪费的话,也可以像web的controller那样,把处理定位到方法上面。即一个方法对应一个处理的消息id.服务器启动的时候缓存方法:
3,管理业务线程
要保证同一个用户的消息处理都是顺序性的,一般有几种方式,1,加锁,2,使用队列,生产者消费者模式,3,在同一个线程中处理。使用锁,在高并发的时候导致cpu上下文切换频繁,性能下降,我们可以采用netty的方式,同一个连接的所有消息都在同一个线程中处理。一服务器处理的线程并不是越多越好,见:https://www.cnblogs.com/wgslucky/p/9749990.html 所以在处理业务的时候最好不要有io操作。那不可避免的io操作,比如查数据库,更新数据,我们放在别的单独线程处理。这里先说业务处理,它操作的都是内存中的数据,所以速度很快,不会卡玩家。
首先创建一个线程处理器的类,用于管业务线程数:
package com.xinyue.interview.utils.concurrent; import io.netty.util.concurrent.DefaultEventExecutor; import io.netty.util.concurrent.EventExecutor; public class LogicEventExecutorGroup { private EventExecutor[] executors; public LogicEventExecutorGroup(int nthreads) { executors = new EventExecutor[nthreads]; for (int i = 0; i < nthreads; i++) { executors[i] = new DefaultEventExecutor(); } } public EventExecutor select(long userId) { int index = (int) (userId % executors.length); return executors[index]; } }
这里根据用户的userId,取余固定一个线程处理器,所以同一个用户的请求都放到这个线程处理器中。
在收到消息后:
package com.xinyue.interview.dispatch;
import java.util.List;
import java.util.concurrent.TimeUnit;
import javax.annotation.PostConstruct;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.alibaba.fastjson.JSONObject;
import com.xinyue.interview.controller.protocol.HeadInfo;
import com.xinyue.interview.controller.protocol.LogicMessage;
import com.xinyue.interview.exception.ServerError;
import com.xinyue.interview.exception.ServerErrorException;
import com.xinyue.interview.logic.manager.AccountManager;
import com.xinyue.interview.logic.manager.EntityManagerFactory;
import com.xinyue.interview.logic.manager.IEntityManager;
import com.xinyue.interview.utils.concurrent.LogicEventExecutorGroup;
import io.netty.util.concurrent.EventExecutor;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.Promise;
@Service
public class LogicRequestDispatch {
private Logger logger = LoggerFactory.getLogger(LogicRequestDispatch.class);
@Autowired
private LogicRequestMappingManager logicRequestMappingManager;
private LogicEventExecutorGroup executorGroup;
@PostConstruct
public void init() {
//初始化4个线程处理器处理业务逻辑
int nthreads = 4;
this.executorGroup = new LogicEventExecutorGroup(nthreads);
}
public void fireRead(LogicRequestContext ctx, JSONObject param) {
long userId = ctx.getUserId();
EventExecutor executor = executorGroup.select(userId);
executor.execute(() -> {
try {
// 检测是否登陆成功
this.checkLogin(ctx.getHeadInfo());
// 调用业务方法
Integer commandId = ctx.getCommandId();
logicRequestMappingManager.callMethod(commandId, ctx, param);
} catch (Throwable e) {
LogicMessage response = null;
if (e instanceof ServerErrorException) {
ServerErrorException errorException = (ServerErrorException) e;
response = new LogicMessage(errorException);
} else {
response = new LogicMessage(ServerError.SYSTEM_ERROR);
}
ctx.writeAndflush(response);
}
});
}
private void checkLogin(HeadInfo headInfo) {
long userId = headInfo.getUserId();
AccountManager accountManager = EntityManagerFactory.getManager(userId, AccountManager.class);
if (accountManager == null) {
ServerError.throwError(ServerError.USER_NOT_LOGIN, "userId:{}", userId);
return;
}
String token = headInfo.getToken();
if (!accountManager.checkToken(token)) {
ServerError.throwError(ServerError.USER_NOT_LOGIN, "userId:{},token错误", userId);
return;
}
}
/**
*
* <p>
* Description:初始化相应的数据管理类到对应的逻辑线程中
* </p>
*
* @param userId
* @param managers
* @author wgs
* @date 2018年10月19日 下午4:39:31
*
*/
public void initEntityManager(long userId, List<? extends IEntityManager> managers) {
EventExecutor executor = executorGroup.select(userId);
executor.execute(() -> {
try {
EntityManagerFactory.init(userId, managers);
} catch (Exception e) {
logger.error("初始化EntityManager出错", e);
}
});
executor.scheduleAtFixedRate(() -> {
EntityManagerFactory.flushDB();
}, 5, 5, TimeUnit.MINUTES);
}
public Future<Object> fireEvent(long selectKey, Object param, Promise<Object> promise) {
return promise;
}
}
这样就实现了业务处理保证在同一个线程中。