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

jforgame

已于 2025-03-12 12:57:14 修改

阅读量2.4k

点赞数 5

分类专栏： java 从零开始搭建游戏服务器框架文章标签： java 手游事件驱动服务器

于 2017-08-14 22:11:10 首次发布

本文链接：https://blog.youkuaiyun.com/littleschemer/article/details/77169987

版权

从零开始搭建游戏服务器框架同时被 2 个专栏收录

48 篇文章 ¥59.90 ¥99.00

订阅专栏

java

22 篇文章

订阅专栏

本文探讨了游戏服务器中如何使用事件驱动来解决业务高度耦合的问题。通过事件驱动，当玩家升级时，相关业务逻辑不再集中处理，而是转化为事件分发给各个监听器执行，实现了低耦合、高复用的设计。文章详细介绍了事件驱动的实现步骤，包括事件、事件类型、监听器、事件分发器的定义以及测试案例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

事件驱动的作用与目标

假设这样的业务需求：游戏服务器希望在玩家升级时触发多种效果。例如玩家升级后，各种属性都会提高，开启新的系统玩法，学习新的技能……入门程序员写出来的代码可能是这样——

private void handleRoleUpgrade(Object role){  
        if(meetUpgradeCondition(role)){//满足升级条件  
            RoleManager.getInstance().upgradeAttribution(role);//属性提升  
            SkillManager.getInstance().learnNewSkill(role);//学会新技能  
            //其他一堆业务  
        }  
}

可以看出，玩家升级后，所有跟升级挂钩的业务都要集中在一起，依次被处理。这样写出来的代码耦合度非常高。一旦有新的业务加入，这里就要继续插代码。

为了达到解耦的效果，我们引入了事件驱动模型。

当玩家触发了升级这个动作，我们完全可以把“升级”这个动作包装成一个事件，任何对这个事件感兴趣的“观察者”就可以捕捉并执行相应的逻辑。

我们希望我们的事件驱动模型能够满足以下几个要求：

1. 当触发某个动作时，将动作包装成事件并进行分发，所有与之相关的监听器自动感应事件的发生；

2. 同一个事件可以被多个监听器响应；

3. 一个监听器可以同时监听多个事件;

4. 事件可以选择同步执行，也可以选择异步执行。

事件驱动的代码实现

下面开始我们的编码逻辑

1. 首先，我们定义”事件“这个抽象概念（GameEvent）。注意，事件有一个基类方法标识是否同步执行。

/**
 * 监听器监听的事件抽象类
 */
public abstract class GameEvent {
	
	/** 创建时间 */
	private long createTime;
	/** 事件类型 */
	private final EventType eventType;
	
	public GameEvent(EventType evtType) {
		this.createTime = System.currentTimeMillis();
		this.eventType  = evtType;
	}
	
	public long getCreateTime() {
		return this.createTime;
	}
	
	public EventType getEventType() {
		return this.eventType;
	}
	
	/**
	 * 是否在消息主线程同步执行
	 * @return
	 */
	public boolean isSynchronized() {
		return true;
	}

}

2. 为了区分各种事件，我们定义一个表示事件类型的枚举器（EventType.java）

public enum EventType {
	
	/** 升级事件 */
	LEVEL_UP;

}

3. 在游戏业务里，很多事件都是绑定角色的，所以定义一个跟玩家关系密切的玩家事件（PlayerEvent.java）

/**
 * 玩家事件抽象类
 */
public abstract class PlayerEvent extends GameEvent {

	/** 玩家id */
	private final long playerId;
	
	public PlayerEvent(EventType evtType, long playerId) {
		super(evtType);
		this.playerId = playerId;
	}
	
	public long getPlayerId() {
		return this.playerId;
	}
}

４.定义一个注解（Listener.java），标识”监听器“

@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Listener {

}

５. 定义事件分发器（EventDispatcher），该分发器拥有以下作用：

绑定事件与事件监听者；

分发事件，若为同步事件，则在当前的业务主线程执行，若为异步事件，则放到独立线池异步执行。

public class EventDispatcher {

	private static EventDispatcher instance = new EventDispatcher();

	private EventDispatcher() {
		new NameableThreadFactory("event-dispatch").newThread(new EventWorker()).start();
	};  

	public static EventDispatcher getInstance() {
		return instance;
	}

	/** 事件类型与事件监听器列表的映射关系 */
	private final Map<EventType, Set<Object>> observers = new HashMap<>(); 
	/** 异步执行的事件队列 */
	private LinkedBlockingQueue<GameEvent> eventQueue = new LinkedBlockingQueue<>();

	/**
	 * 注册事件监听器
	 * @param evtType
	 * @param listener
	 */
	public void registerEvent(EventType evtType, Object listener) {  
		Set<Object> listeners = observers.get(evtType);  
		if(listeners == null){  
			listeners = new CopyOnWriteArraySet<>();  
			observers.put(evtType, listeners);  
		}  
		listeners.add(listener);  
	}  

	/**
	 * 分发事件
	 * @param event
	 */
	public void fireEvent(GameEvent event) {  
		if(event == null){  
			throw new NullPointerException("event cannot be null");  
		}  
		//如果事件是同步的，那么就在消息主线程执行逻辑
		if (event.isSynchronized()) {
			triggerEvent(event);
		} else {
		//否则，就丢到事件线程异步执行
			eventQueue.add(event);
		}
		
	}  
	
	private void triggerEvent(GameEvent event) {
		EventType evtType = event.getEventType();  
		Set<Object> listeners = observers.get(evtType);  
		if(listeners != null){  
			listeners.forEach(listener->{
				try{  
					ListenerManager.INSTANCE.fireEvent(listener, event);
				}catch(Exception e){  
					LoggerUtils.error("triggerEvent failed", e);;  //防止其中一个listener报异常而中断其他逻辑  
				}  
			});
		}  
	}
	
	private class EventWorker implements Runnable {
		@Override
		public void run() {
			while(true) {
				try {
					GameEvent event = eventQueue.take();
					triggerEvent(event);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}

}

６.分发器只是绑定了事件与其监听器，并没有说明，这个事件由其监听器的哪个方法监听。为了达到方法级别的绑定，我们引入另一个注解（EventHandler.java）。

/**
 * 事件处理者
 * @author kingston
 */
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface EventHandler {
	
	/** 绑定的事件类型列表 */
	public EventType[] value();
	
}

也就是说，监听器由Listener注解标识，该监听器要监听多个事件，那么就在每一个事件的执行者方法加一个EventHandler注解。如果看过之前的文章，那篇关于使用Controller, RequestMapper来自动映射玩家消息与业务执行者。就会发现，Listerner与ListenerHandler所发挥的作用，跟之前是完全一样的。

7. 由于一个监听器可以同时监听多个事件，为了精确找到具体的业务执行者，我们必须将监听器与事件类型作为联合主键，缓存这样一个映射关系。key=listener_eventType, value=listenerMethod。所以，我们又加入一个工具类(ListenerManager.java)

public enum ListenerManager {

	INSTANCE;

	private Map<String, Method> map = new HashMap<>();

	private final String SCAN_PATH = "com.kingston.game";

	public void initalize() {
        Set<Class<?>> listeners = ClassScanner.getClasses(SCAN_PATH, new ClassFilter() {
            @Override
            public boolean accept(Class<?> clazz) {
                return clazz.getAnnotation(Listener.class) != null;
            }
        });

        for (Class<?> listener: listeners) {
            try {
                Object handler = listener.newInstance();
                Method[] methods = listener.getDeclaredMethods();
                for (Method method:methods) {
                	EventHandler mapperAnnotation = method.getAnnotation(EventHandler.class);
                    if (mapperAnnotation != null) {
                    	EventType[] eventTypes = mapperAnnotation.value();
                    	 for(EventType eventType: eventTypes) {
                    		 EventDispatcher.getInstance().registerEvent(eventType, handler);
                    		 map.put(getKey(handler, eventType), method);
                         }
                    }
                }
            }catch(Exception e) {
                LoggerUtils.error("", e);
            }
        }
    }

	/**
	 * 分发给具体监听器执行
	 * @param handler
	 * @param event
	 */
	public void fireEvent(Object handler,GameEvent event) {
		try {
			Method method = map.get(getKey(handler, event.getEventType()));
			method.invoke(handler, event);
		} catch (Exception e) {
			LoggerUtils.error("", e);
		}

	}

	private String getKey(Object handler, EventType eventType) {
		return handler.getClass().getName() + "-" + eventType.toString();
	}
}

至此，事件驱动器的全部代码就完成了。

事件驱动模拟的测试案例

我们直接将引子的场景作为测试吧，当玩家升级时，就会触发学习一个新技能。

１.申明事件类型，EventType.LEVEL_UP

２.申明事件监听器(Listener)与执行事件的方法(ListenerHandler)

@Listener
public class SkillListener {
	
	@EventHandler(value=EventType.LEVEL_UP)
	public void onPlayerLevelup(EventPlayerLevelUp levelUpEvent) {
		System.err.println(getClass().getSimpleName()+"捕捉到事件"+levelUpEvent);
	}

}

3. 测试代码，服务启动时，直接抛出一个升级事件

		//启动socket服务
		try{
			new SocketServer().start();
		}catch(Exception e) {
			LoggerUtils.error("ServerStarter failed ", e);
		}

		Player player = PlayerManager.getInstance().get(10000L);
		EventDispatcher.getInstance().fireEvent(new EventPlayerLevelUp(EventType.LEVEL_UP,
				player.getId(), 2));

4. SkillListener直接捕捉到升级事件，输出如下

SkillListener捕捉到事件EventPlayerLevelUp [upLevel=2, playerId=2815129724291645440, EventType=LEVEL_UP]

到这里，关于事件驱动模型的实现就介绍完毕了。

文章预告：下一篇主要介绍如何使用http服务构建后台管理系统

手游服务端开源框架系列完整的代码请移步github ->> forgame