本次主要用Java实现简单的游戏服务器事件通知，在游戏服中，事件通知是必不可少的一种游戏业务处理逻辑，可以基于观察者模式去编写，或则其他更好的方式。也可以用guava框架的事件通知框架，以下代码只是大概的实现思想，总体设计思路都大同小异；
1.Event注解
package ge;
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;
@Target({ ElementType.FIELD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Event {
public GameEventType value();
}
处理器接口
IGameEventHandler.Java
package ge;
public interface IGameEventHandler extends Runnable{
}
GameEventHadler.java(父类事件处理器实现类)
package ge;
public abstract class GameEventHadler implements IGameEventHandler {
/**
* 事件类型
*/
private GameEventType gameEventType;
/**
* 传递的参数
*/
private GameEventMsg gameEventMsg;
@Override
public void run() {
notice(gameEventType, gameEventMsg);
}
public abstract void notice(GameEventType gameEventType, GameEventMsg gameEventMsg);
/**
* 设置参数
*
* @param gameEventType
* @param gameEventMsg
* @return
*/
public GameEventHadler transmit(GameEventType gameEventType, GameEventMsg gameEventMsg) {
this.gameEventType = gameEventType;
this.gameEventMsg = gameEventMsg;
return this;
}
public GameEventType getGameEventType() {
return gameEventType;
}
public void setGameEventType(GameEventType gameEventType) {
this.gameEventType = gameEventType;
}
public GameEventMsg getGameEventMsg() {
return gameEventMsg;
}
public void setGameEventMsg(GameEventMsg gameEventMsg) {
this.gameEventMsg = gameEventMsg;
}
}
事件管理器
GameEventMgr。Java
package ge;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import ge.util.EventRegister;
public class GameEventMgr {
public static GameEventMgr observerMgr = new GameEventMgr();
public static final String EVENT_PACKGE = "ge.imp";
public static GameEventMgr getIns() {
return observerMgr;
}
private static final int MAX_THREAD_NUM = Runtime.getRuntime().availableProcessors() * 2;
/**
* 事件执行线程池
*/
private static ExecutorService executorService = Executors.newFixedThreadPool(MAX_THREAD_NUM);
/**
* 事件处理器容器
*/
public static Map<GameEventType, GameEventHadler> gameEventHadlerMaps = new HashMap<>();
static {
// 注解注册
EventRegister.registeredByAnnotation();
// 代码对象注册
EventRegister.registeredByClassCode();
}
/**
* 事件通知
* @param gameEventType
* @param gameEventMsg
*/
public static void poolEvent(GameEventType gameEventType, GameEventMsg gameEventMsg) {
if (gameEventHadlerMaps.containsKey(gameEventType)) {
GameEventHadler gameEventHadler = gameEventHadlerMaps.get(gameEventType);
executorService.execute(gameEventHadler.transmit(gameEventType, gameEventMsg));
}
}
/**
* 优雅的关闭线程池子
*/
public static void shutDownExecutorService() {
if (executorService != null) {
executorService.shutdown();
try {
if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {
executorService.shutdown();
}
if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {
}
} catch (Exception e) {
executorService.shutdown();
Thread.currentThread().interrupt();
}
}
System.err.println("Thread pool shutdown:OK");
}
}
事件消息基类
GameEventMsg。Java
package ge;
/**
* 事件消息基类
* @author admin
*
*/
public abstract class GameEventMsg {
}
事件类型枚举类
package ge;
public enum GameEventType {
UP_LEVEL(1, "升级事件"),
VIP_UP_LEVEL(2, "VIP升级事件"),
RECHARGE(3, "充值事件"),
MONSTER_DIE(4,"怪物死亡"),
;
private int value;
private String des;
GameEventType(int value, String des) {
this.value = value;
this.des = des;
}
public String getDes() {
return des;
}
public int getValue() {
return value;
}
}
消息实体
package ge.event;
import ge.GameEventMsg;
public class MonsterDeath_GE extends GameEventMsg {
// 击杀者
private long killPlayerId;
// 怪物id
private int monsterId;
public long getKillPlayerId() {
return killPlayerId;
}
public void setKillPlayerId(long killPlayerId) {
this.killPlayerId = killPlayerId;
}
public int getMonsterId() {
return monsterId;
}
public void setMonsterId(int monsterId) {
this.monsterId = monsterId;
}
}
package ge.event;
import ge.GameEventMsg;
public class RechargeEvent_GE extends GameEventMsg{
/**
* 充值数量
*/
private int rechargeNum;
public int getRechargeNum() {
return rechargeNum;
}
public void setRechargeNum(int rechargeNum) {
this.rechargeNum = rechargeNum;
}
}
package ge.event;
import ge.GameEventMsg;
public class UpLevelEvent_GE extends GameEventMsg{
/**
* 等级
*/
private int level;
public int getLevel() {
return level;
}
public void setLevel(int level) {
this.level = level;
}
}
package ge.event;
import ge.GameEventMsg;
public class VipLevelEvent_GE extends GameEventMsg{
/**
* VIP等级
*/
private int vipLevel;
public int getVipLevel() {
return vipLevel;
}
public void setVipLevel(int vipLevel) {
this.vipLevel = vipLevel;
}
}
通知处理器
package ge.imp;
import ge.GameEventHadler;
import ge.GameEventMsg;
import ge.GameEventType;
import ge.event.MonsterDeath_GE;
import ge.mgr.MonsterMgr;
public class MonsterDeathHandler extends GameEventHadler {
@Override
public void notice(GameEventType gameEventType, GameEventMsg gameEventMsg) {
MonsterDeath_GE MonsterDeath_GE = (MonsterDeath_GE) gameEventMsg;
MonsterMgr.getIns().monsterKillEvent(MonsterDeath_GE.getKillPlayerId(), MonsterDeath_GE.getMonsterId());
}
}
package ge.imp;
import ge.Event;
import ge.GameEventHadler;
import ge.GameEventMsg;
import ge.GameEventType;
import ge.mgr.RechargeMgr;
import observer.event.RechargeEvent_GE;
/**
* 接收事件触发后的业务处理
*
* @author admin
*
*/
@Event(GameEventType.RECHARGE)
public class RechargeEventHandler extends GameEventHadler {
@Override
public void notice(GameEventType gameEventType, GameEventMsg gameEventMsg) {
RechargeEvent_GE e = (RechargeEvent_GE) gameEventMsg;
RechargeMgr.getIns().rechargeEvent(e.getRechargeNum());
/**
* 通常相关业务处理：充值奖励，VIP充值经验增加等
*/
}
}
package ge.imp;
import ge.Event;
import ge.GameEventHadler;
import ge.GameEventMsg;
import ge.GameEventType;
import ge.mgr.LevelMgr;
import observer.event.UpLevelEvent_GE;
/**
* 接收事件触发后的业务处理
*
* @author admin
*
*/
@Event(GameEventType.UP_LEVEL)
public class UpLevelEventHandler extends GameEventHadler {
@Override
public void notice(GameEventType gameEventType, GameEventMsg gameEventMsg) {
UpLevelEvent_GE e = (UpLevelEvent_GE) gameEventMsg;
LevelMgr.getIns().uplevelEvent(e.getLevel());
/**
* 通常相关业务处理：玩家战力，系统开放，等级礼包，等级排行等相关
*/
}
}
package ge.imp;
import ge.Event;
import ge.GameEventHadler;
import ge.GameEventMsg;
import ge.GameEventType;
import ge.mgr.VipMgr;
import observer.event.VipLevelEvent_GE;
/**
* 接收事件触发后的业务处理
*
* @author admin
*
*/
@Event(GameEventType.VIP_UP_LEVEL)
public class VipUpLevelEventHandler extends GameEventHadler {
@Override
public void notice(GameEventType gameEventType, GameEventMsg gameEventMsg) {
VipLevelEvent_GE e = (VipLevelEvent_GE) gameEventMsg;
VipMgr.getIns().vipLevelEvent(e.getVipLevel());
/**
* 通常相关业务处理：VIP特权，奖励，系统开放相关等
*/
}
}
模拟业务管理器调用
package ge.mgr;
/**
* 业务类
* @author admin
*
*/
public class LevelMgr {
private static LevelMgr levelMgr=new LevelMgr();
public static LevelMgr getIns() {
return levelMgr;
}
public void uplevelEvent(int level) {
System.err.println("升级到：" + level);
}
}
package ge.mgr;
/**
* 业务类
*
* @author admin
*
*/
public class MonsterMgr {
private static MonsterMgr monsterMgr = new MonsterMgr();
public static MonsterMgr getIns() {
return monsterMgr;
}
public void monsterKillEvent(long killPlayer, int monsterId) {
System.err.println("击杀者ID：" + killPlayer + ":怪物id:" + monsterId);
}
}
package ge.mgr;
/**
* 业务类
*
* @author admin
*
*/
public class RechargeMgr {
private static RechargeMgr rechargeMgr = new RechargeMgr();
public static RechargeMgr getIns() {
return rechargeMgr;
}
public void rechargeEvent(int rechargeNum) {
System.err.println("充值了" + rechargeNum);
}
}
package ge.mgr;
public class VipMgr {
/**
* 业务类
*/
private static VipMgr vipMgr=new VipMgr();
public static VipMgr getIns() {
return vipMgr;
}
public void vipLevelEvent(int vipLevel) {
System.err.println("VIP升级到：" + vipLevel);
}
}
工具类
package ge.util;
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.net.URL;
import java.net.URLDecoder;
import java.util.Enumeration;
import java.util.LinkedHashSet;
import java.util.Set;
public class ClazzUtils {
/**
* 从包package中获取所有的Class
*
* @param pack
* @return
*/
public static Set<Class<?>> getClasses(String pack) {
Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
boolean recursive = true;
String packageName = pack;
String packageDirName = packageName.replace('.', '/');
Enumeration<URL> dirs;
try {
dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
while (dirs.hasMoreElements()) {
URL url = dirs.nextElement();
String protocol = url.getProtocol();
if ("file".equals(protocol)) {
System.err.println("file类型的扫描");
String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes);
}
}
} catch (IOException e) {
e.printStackTrace();
}
return classes;
}
/**
* 以文件的形式来获取包下的所有Class
*
* @param packageName
* @param packagePath
* @param recursive
* @param classes
*/
public static void findAndAddClassesInPackageByFile(String packageName, String packagePath, final boolean recursive,
Set<Class<?>> classes) {
File dir = new File(packagePath);
if (!dir.exists() || !dir.isDirectory()) {
return;
}
File[] dirfiles = dir.listFiles(new FileFilter() {
public boolean accept(File file) {
return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));
}
});
for (File file : dirfiles) {
if (file.isDirectory()) {
findAndAddClassesInPackageByFile(packageName + "." + file.getName(), file.getAbsolutePath(), recursive,
classes);
} else {
String className = file.getName().substring(0, file.getName().length() - 6);
try {
classes.add(
Thread.currentThread().getContextClassLoader().loadClass(packageName + '.' + className));
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
Set<Class<?>> clazz = getClasses("observer.imp");
clazz.forEach(s -> {
System.err.println(s);
});
}
}
事件处理器注册类
package ge.util;
import java.util.Set;
import ge.Event;
import ge.GameEventHadler;
import ge.GameEventMgr;
import ge.GameEventType;
import ge.imp.MonsterDeathHandler;
import observer.imp.RechargeEventHandler;
import observer.imp.UpLevelEventHandler;
import observer.imp.VipUpLevelEventHandler;
public class EventRegister {
/**
* 代码：注册事件处理器[注册方式1]
*/
public static void registeredByClassCode() {
registered(GameEventType.UP_LEVEL, new UpLevelEventHandler());
registered(GameEventType.RECHARGE, new RechargeEventHandler());
registered(GameEventType.VIP_UP_LEVEL, new VipUpLevelEventHandler());
registered(GameEventType.MONSTER_DIE, new MonsterDeathHandler());
}
/**
* 注册:如果存在就不再进行重复注册
*
* @param gameEventType
* @param gameEventHadler
*/
public static void registered(GameEventType gameEventType, GameEventHadler gameEventHadler) {
GameEventMgr.gameEventHadlerMaps.computeIfAbsent(gameEventType, s -> {
return gameEventHadler;
});
}
/**
* 通过扫描指定包名进行注册[注册方式2]
*/
public static void registeredByAnnotation() {
Set<Class<?>> clazzs = ClazzUtils.getClasses(GameEventMgr.EVENT_PACKGE);
if (clazzs == null||clazzs.isEmpty()) {
System.err.println("无可注册的事件处理器类");
return;
}
for (Class<?> clazz : clazzs) {
if (!clazz.isAnnotationPresent(Event.class)) {
continue;
}
Event event = clazz.getAnnotation(Event.class);
if (event == null) {
continue;
}
GameEventType gameEventType = event.value();
try {
GameEventMgr.gameEventHadlerMaps.put(gameEventType, (GameEventHadler) clazz.newInstance());
} catch (InstantiationException | IllegalAccessException e) {
e.printStackTrace();
}
}
}
}
测试类
package ge;
import java.util.Scanner;
import ge.event.MonsterDeath_GE;
import observer.event.RechargeEvent_GE;
import observer.event.UpLevelEvent_GE;
import observer.event.VipLevelEvent_GE;
public class GameEventTest {
@SuppressWarnings("static-access")
/**
* 测试
*
* @param args
*/
public static void main(String[] args) throws InterruptedException {
/**
* 添加守护线程：在jvm关闭前关闭线程池:一般用在服务器关闭前的操作{数据持久，线程池关闭等等...}
*/
Runtime.getRuntime().addShutdownHook(new Thread(() -> GameEventMgr.shutDownExecutorService()));
/**
* 模拟关闭程序命令操作
*/
new Thread(() -> closeSystemThread()).start();
/**
* 模拟玩家升级
*/
UpLevelEvent_GE upLevelEvent_GE = new UpLevelEvent_GE();
upLevelEvent_GE.setLevel(1000);
GameEventMgr.getIns().poolEvent(GameEventType.UP_LEVEL, upLevelEvent_GE);
/**
* 模拟vip升级
*/
VipLevelEvent_GE vipLevelEvent_GE = new VipLevelEvent_GE();
vipLevelEvent_GE.setVipLevel(12);
GameEventMgr.getIns().poolEvent(GameEventType.VIP_UP_LEVEL, vipLevelEvent_GE);
/**
* 模拟充值
*/
RechargeEvent_GE rechargeEvent_GE = new RechargeEvent_GE();
rechargeEvent_GE.setRechargeNum(500);
GameEventMgr.getIns().poolEvent(GameEventType.RECHARGE, rechargeEvent_GE);
/**
* 模拟怪物击杀
*/
MonsterDeath_GE monsterDeath_GE = new MonsterDeath_GE();
monsterDeath_GE.setKillPlayerId(1000200088);
monsterDeath_GE.setMonsterId(100008);
GameEventMgr.getIns().poolEvent(GameEventType.MONSTER_DIE, monsterDeath_GE);
}
/**
* 关闭程序
*/
@SuppressWarnings("resource")
public static void closeSystemThread() {
Scanner scanner = new Scanner(System.in);
if (scanner.next().equals("close"))
System.exit(0);
}
}