目录
复习
上一节我们使用gradle构建了一个多模块系统。
并且在登录服启动了Netty服务，监听config文件中配置的端口。
在client模块中使用Netty创建一个客户端连接到登录服，并且发送并接收协议。
本节内容
本节我们学习一下Actor模型。并将其应用在我们的登录服中。
我们将会为每一个连接上来的客户端生成一个actor专门用于处理该连接发送上来的请求数据。
正文
什么是Actor模型
Actor模型是一种强大的并发计算模型。
在Actor模型中，一个Actor是一个最基本的计算单元，它可以看作是一个个独立的实体，它们之间毫无关联，但是可以通过消息来通信。
一个Actor收到其他Actor的信息后，可以根据需要作出各种响应。每个Actor的数据相互隔离，使用消息传递的方式来进行并发操作，避免了多线程编程中常见的同步和共享内存问题，从而提高了程序的可靠性和可伸缩性。
使用Actor模型最好的一点在于，为Actor逻辑进行编码时，无需过多考虑多线程并发问题，因为它是通过消息驱动的且其内部数据只能由其本身进行修改，而每个Actor的消息处理是串行的，所以每个Actor内部的数据不会被并发修改。
出bug的情况较少，对新人友好，意味着可以多招新人程序员来开发以节约项目成本。
如何应用
要在java中使用Actor模型，可以使用akka的actor库进行开发。
Kilim是一个比akka更轻量化的actor库，但是社区规模相对较小。
本项目选择使用akka的actor库。
implementation group: 'com.typesafe.akka', name: 'akka-actor-typed_3', version: '2.8.5'
创建Actor基类
因为我们项目中将会有多种不同功能的actor出现，我们先定一个actor基类用于规范所有actor。
创建BaseMsg和BaseActor两个类
/**
* 消息基类 所有Actor消息的基类
*/
public class BaseMsg implements Serializable {
}
/**
* Actor基类
*/
@Slf4j
public abstract class BaseActor extends AbstractBehavior<BaseMsg> {
public BaseActor(ActorContext<BaseMsg> context) {
super(context);
}
@Override
public Receive<BaseMsg> createReceive() {
ReceiveBuilder<BaseMsg> builder = newReceiveBuilder();
builder.onMessage(BaseMsg.class, this::onBaseMsg);
return builder.build();
}
private Behavior<BaseMsg> onBaseMsg(BaseMsg msg) {
log.info("receive base msg. {}", msg.toString());
return this;
}
}
BaseActor继承与AbstractBehavior，它接收所有BaseMsg类型的消息，当收到BaseMsg消息时打印receive base msg.
创建RootActor
RootActor是一个用于初始化ActorSystem和创建其他Actor的守护Actor
public class RootActor extends BaseActor{
public RootActor(ActorContext<BaseMsg> context) {
super(context);
}
public static Behavior<BaseMsg> create() {
return Behaviors.setup(RootActor::new);
}
}
创建AkkaContext
AkkaContext用于储存ActorSystem上下文，并提供创建Actor的方法。
final public class AkkaContext {
private static ActorSystem<BaseMsg> ACTOR_SYSTEM;
public static void initActorSystem() {
ACTOR_SYSTEM = ActorSystem.create(RootActor.create(), "ActorSystem");
}
public static ActorRef<BaseMsg> createActor(Behavior<BaseMsg> behavior, String name) {
return ACTOR_SYSTEM.systemActorOf(behavior, name, Props.empty());
}
}
服务器启动时调用initActorSystem初始化akka上下文。需要生成Actor则调用createActor。
创建ConnectActorManager和ConnectActor
在登录服中，我们会为每一个连接分配一个Actor，称之为ConnectActor，用于接收各个连接发送过来的消息，并串行地处理消息逻辑。
为了管理ConnectActor，我们需要一个ConnectActorManager用于存储每一个连接与connectActor的映射关系。
首先我们需要为每一个连接分配一个唯一id，称之为connectId。
修改LoginNettyHandler中负责处理建立连接逻辑的接口channelActive
// 登录服ctx自定义属性
private static final AttributeKey<HashMap<String, Object>> loginContextAttr = AttributeKey.valueOf("login");
/**
* 建立连接
*/
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
InetSocketAddress address = (InetSocketAddress) ctx.channel().remoteAddress();
String ip = address.getAddress().getHostAddress();
HashMap<String, Object> context = this.getContextAttrMap(ctx);
if (context == null) {
context = new HashMap<>();
ctx.channel().attr(loginContextAttr).set(context);
}
// 先只用uuid的64位来做connectId，只要不超过64位理论上不会重复
long connectId = UUID.randomUUID().getLeastSignificantBits();
context.put("connectId", connectId);
context.put("ip", ip);
if (ctx.channel().isActive()) {
log.info("创建连接—成功:ip = {}，connectId = {}", ip, connectId);
}
}
/**
* 从ctx中获取自定义属性参数
*/
private HashMap<String, Object> getContextAttrMap(ChannelHandlerContext ctx) {
return ctx.channel().attr(loginContextAttr).get();
}
我们为每一个连接设置了一个存放自定义属性的HashMap，然后使用UUID生成了一个connectId存入其中。
然后我们创建一个ConnectActor类，和RootActor类类似，继承BaseActor类，并实现create方法。
public class ConnectActor extends BaseActor {
private long connectId;
private ChannelHandlerContext ctx;
public ConnectActor(ActorContext<BaseMsg> context, long connectId, ChannelHandlerContext ctx) {
super(context);
this.connectId = connectId;
this.ctx = ctx;
}
/**
* 生成一个ConnectActor的行为
*/
public static Behavior<BaseMsg> create(long connectId, ChannelHandlerContext ctx) {
return Behaviors.setup(context -> new ConnectActor(context, connectId, ctx));
}
}
创建ConnectActorManager类，用于管理所有的ConnectActor。
@Component
public class ConnectActorManager {
private final Map<Long, ActorRef<BaseMsg>> connectActorMap = new ConcurrentHashMap<>();
public ActorRef<BaseMsg> getConnectActor(long connectId) {
return connectActorMap.get(connectId);
}
public static ConnectActorManager getInstance() {
return SpringUtils.getBean(ConnectActorManager.class);
}
/**
* 创建一个ConnectActor
*/
public ActorRef<BaseMsg> createConnectActor(long connectId, ChannelHandlerContext ctx) {
ActorRef<BaseMsg> actor = AkkaContext.createActor(ConnectActor.create(connectId, ctx), String.valueOf(connectId));
connectActorMap.put(connectId, actor);
return actor;
}
}
在ConnectActorManager类中，我们定义了一个ConcurrentHashMap，用于存放所有的ConnectActor，因为Netty接收数据是多线程的，所以可能有多个线程同时对其进行读写操作，所以使用ConcurrentHashMap保证线程安全。
生成actor并发送消息给它
我们修改LoginNettyHandler类，处理读取数据的接口channelRead0.
@Override
protected void channelRead0(ChannelHandlerContext ctx, byte[] msg) throws Exception {
HashMap<String, Object> context = this.getContextAttrMap(ctx);
long connectId = (long)context.get("connectId");
ConnectActorManager actorManager = SpringUtils.getBean(ConnectActorManager.class);
ActorRef<BaseMsg> connectActor = actorManager.getConnectActor(connectId);
if (connectActor == null) {
connectActor = actorManager.createConnectActor(connectId, ctx);
}
log.info(new String(msg));
BaseMsg baseMsg = new BaseMsg();
connectActor.tell(baseMsg);
ctx.channel().writeAndFlush(msg);
}
当接收到数据时，我们从ctx中获得建立连接时生成的connectId，再用其去ConnectActorManager中获取对应的connectActor，没有则创建一个新的。
然后我们创建一个消息BaseMsg，将其发送给connectActor进行处理。
最后我们将数据原封不动地返回回去。
运行一下试试。
可以看到我们的服务器收到了test消息，并且给ConnectActor发送了一个BaseMsg消息。
课后作业
现在我们可以给ConnectActor发送消息了，是不是可以将BaseMsg细分成更多不一样的消息，用于处理ctx的不同类型的数据。
我预计为BaseMsg创建不同的子类，用来通知ConnectActor来做出不同的行为。
ClientUpMsg：客户端上行数据消息；
ConnectClosedMsg：客户端断开消息；
但是我不会在这里将代码展示出来，我希望读者们可以自己去实现这两个消息，只需要打印出不同的日志就行。
结尾
本节我们讲了Actor模型并且在实战中使用了它。
Actor模型是一个非常好用的并发计算模型，有了它可以使开发者不用过多关心并发问题和数据共享问题，只需要专注于业务逻辑的开发即可。
希望本节的内容能对你有所帮助，有任何问题可以评论或私信。
感兴趣的同学可以关注该专栏，我会持续更新更多关于游戏服务器开发的内容。
1769
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
