上篇文章(Netty 入门 — 第一个完整的 demo 之智能客服)大明哥演示了强大的智能客服,它能够很好的解决用户的一些常见的问题,但是有些问题依然还需要人工客服来完成,所以这篇文章我们来实现人工坐席。
功能实现
当用户输入 0 的时候,智能客户需要将这个用户转发给某一个人工客服,如果没有人工客户在线需要提示用户是否继续等待。在等待期间若有人工客服上线则将其转接到该用户。
那么服务端需要做如下几件事情:
- 维护用户与人工坐席之间的关系,发的消息不能串。
- 将人工坐席分配给用户。若没有人工坐席,则在用户等待期间,人工坐席上线则将其转接给该用户。
- 消息的转发。
至于用户和人工坐席,则相对来说就比较简单了,接收服务端的消息,并发送消息。
代码实现
代码逻辑相比上篇文章智能 AI 来说有点儿复杂代码,所以大明哥将其分为两部分实现:
- 无人工坐席
- 有人工坐席
无人工坐席
无人工坐席的时候,用户就是与智能客服交互,在用户输入 0 的时候,智能客服需要去获取已经注册在线的人工坐席,如果没有需要提示用户是否继续等待。
服务端
- 服务端基础代码
public class ZzkfServer {
public static void main(String[] args) {
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(new NioEventLoopGroup(),new NioEventLoopGroup());
bootstrap.channel(NioServerSocketChannel.class);
bootstrap.childHandler(new ChannelInitializer<NioSocketChannel>() {
@Override
protected void initChannel(NioSocketChannel ch) throws Exception {
ch.pipeline().addLast(new StringDecoder()); // 解码
ch.pipeline().addLast(new StringEncoder()); // 编码
}
});
// 绑定 8081 端口
bootstrap.bind(8081);
}
}
- 用户注册 handler
因为这个时候已经有用户注册、人工坐席注册了,所以为了遵循单一职责原则,我们需要将用户注册拆分出来。
public class UserRegisterHandler extends SimpleChannelInboundHandler {
@Override
protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
String[] messages = ((String) msg).split("&");
// 消息体有两部分构成 key&value
// key 用来区分身份,value 是真正的消息
String key = messages[0];
Channel channel = ctx.channel();
if (MessageTypeEnum.USER_REGISTER.getType().equals(key)) {
// 注册用户
ChannelSessionMemory.putClientChannel(channel.id().toString(),channel);
// 用户注册成功后,立刻向用户发送问题列表
sendInitMessage(channel);
} else {
ctx.fireChannelRead(msg);
}
}
/**
* 发送消息
* @param channel
*/
private void sendInitMessage(Channel channel) {
StringBuilder message = new StringBuilder(channel.id().toString() + ",您好,我是智能客服小磕。请告诉你想咨询的服务").append("\r\n")
.append("1. 死磕 Java 目前哪些系列").append("\r\n")
.append("2. 死磕 Java 的网址哪个").append("\r\n")
.append("3. 投诉与建议").append("\r\n")
.append("0. 人工").append("\r\n")
.append("==================请输入咨询问题的编号==================");
channel.writeAndFlush(message);
}
}
用户注册 handler 比较简单,它只做用户注册工作,注册成功后,给用户发送初始化消息,告诉用户它能做哪些事。
- 智能客服回答 handler
public class AiAnswerHandler extends SimpleChannelInboundHandler {
@Override
protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
String[] messages = ((String) msg).split("&");
String key = messages[0];
Channel channel = ctx.channel();
String userChannelId = channel.id().toString();
if (MessageTypeEnum.USER_QUESTION.getType().equals(key)) {
String value = messages[1];
if ("0".equals(value)) {
// 转交给人工 handler 处理
String rgChannelId = ChannelSessionMemory.getRgChannelId();
if (rgChannelId == null) {
// 如果没有,先将用户添加到等待队列,然后返回给用户目前暂无人工坐席
ChannelSessionMemory.putWaitingUser(userChannelId);
channel.writeAndFlush("当前暂无人工坐席,继续等待请输入 0 ,退出请输入 9");
} else {
Channel rgChannel = ChannelSessionMemory.getClientChannel(rgChannelId);
rgChannel.writeAndFlush(MessageTypeEnum.USER_HELLO.getType() + "&" + userChannelId + "|有用户咨询");
}
} else if ("9".equals(value)) {
// 用户退出
ChannelSessionMemory.deleteWaitingUser(userChannelId);
channel.writeAndFlush("对不起,无法解决您的问题,深感抱歉");
} else {
String answer = ServiceAnswerSet.getAnswer(value);
channel.writeAndFlush(answer);
}
}
}
}
回答问题 handler 就需要区分用户输入的指令了。
-
0:判断当前是否有在线的人工坐席,如果没有,将用户加入等待队列,并通知用户暂无人工坐席
-
9:将用户从等待队列中删除
-
其他:从答案库里面找到问题集,返回给用户
-
添加到 ChannelPipeline 中
ch.pipeline().addLast(new UserRegisterHandler());
ch.pipeline().addLast(new AiAnswerHandler());
用户端
- 用户基础代码
public class UserClient {
public static void main(String[] args) throws Exception {
Bootstrap bootstrap = new Bootstrap();
bootstrap.group(new NioEventLoopGroup());
bootstrap.channel(NioSocketChannel.class);
bootstrap.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ch.pipeline().addLast(new StringDecoder());
ch.pipeline().addLast(new StringEncoder());
ch.pipeline().addLast(new UserHandler());
}
});
bootstrap.connect("127.0.0.1",8081).sync().channel();
}
}
- 用户处理 handler
public class UserHandler extends ChannelInboundHandlerAdapter {
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
ctx.channel().writeAndFlush(MessageTypeEnum.USER_REGISTER.getType() + "&我是用户:" + ctx.channel().id().toString());
}
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
String message = (String) msg;
System.out.println(message);
Scanner scanner = new Scanner(System.in);
String key = scanner.nextLine();
ctx.channel().writeAndFlush(MessageTypeEnum.USER_QUESTION.getType() + "&" + key);
}
}
用户部分逻辑还是非常简单的,这里就阐述了。
运行结果
输入 0 的时候,需要等待 30 秒。
我相信这个截图完美呈现了无人工坐席的场景。
有人工坐席
这里我们就需要再增加一个人工坐席客户端了。
服务端
服务端逻辑比较复杂了,因为它不仅仅只是智能客服了,他需要维护人工坐席,用户与人工坐席的对话。部分已经将没有人工坐席的部分写好,现在我们来梳理人工坐席的逻辑。
- 人工坐席注册
当人工坐席上线后,他需要注册到服务端,告诉服务端它上线了。
public class RgRegisterHandler extends SimpleChannelInboundHandler {
@Override
protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
String[] messages = ((String) msg).split("&");
String key = messages[0];
if (MessageTypeEnum.RG_REGISTER.getType().equals(key)) {
Channel channel = ctx.channel();
String channelId = channel.id().toString();
// 注册
ChannelSessionMemory.putClientChannel(channelId,channel);
String waitingUser = ChannelSessionMemory.getWaitingUser();
if (waitingUser == null || "".equals(waitingUser)) {
// 无用户等待,则直接加入
ChannelSessionMemory.putRg(channelId);
} else {
// 这里的消息体 messageType&channelId|message
// -1 消息体表示用户刚刚进来,需要人工去打招呼
channel.writeAndFlush(MessageTypeEnum.USER_HELLO.getType() + "&" + waitingUser + "|-1");
}
} else {
ctx.fireChannelRead(msg);
}
}
}
对于人工坐席注册,它除了注册之外还需要做两件事:
- 判断这个时候是否有用户在等待,如果有客户在等待的,则服务端需要通知人工坐席与该用户打招呼。
- 如果没有用户,则他就加入到等待池中,等下一个用户来咨询的时候可以直接联系。大明哥在智能客服回答 handler:AiAnswerHandler中已经有这部分逻辑了,当用户输入 0 的时候就判断当前是否有人工坐席在线。
- 用户-人工坐席对话
当用户与人工坐席建立联系后,他们就可以对话了。
public class UserRgChatHandler extends SimpleChannelInboundHandler {
@Override
protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
String[] messages = ((String)msg).split("&");
String messageType = messages[0];
if (MessageTypeEnum.RG_USER_MESSAGE.getType().equals(messageType)) {
String[] values = messages[1].split("\\|");
// 转发的内容
String content = values[1];
// 发给谁
String toChannelId = values[0];
Channel toChannel = ChannelSessionMemory.getClientChannel(toChannelId);
// 从哪里来
String fromChannelId = ctx.channel().id().toString();
// message
content = MessageTypeEnum.RG_USER_MESSAGE.getType() + "&" + fromChannelId + "|" + content;
// 发送内容
toChannel.writeAndFlush(content);
} else {
ctx.fireChannelRead(msg);
}
}
}
这个 handler 一定要注意发送的消息体,大明哥采用的消息体为 messageType&toChannelId|content
。为什么要这么设计呢?因为用户与人工坐席是绑定的关系,他们不能串,他需要告诉服务端他是与谁进行交互。
-
对于用户来的消息:fromChannelId 则为用户 channelId,toChannelId 则为绑定的人工做些 channelId,同时服务端要使用 toChannel 来发送,因为要发给人工坐席。
-
对于人工坐席的消息:与上面一致。
-
添加到 ChannelPipeline 中
ch.pipeline().addLast(new UserRegisterHandler());
ch.pipeline().addLast(new RgRegisterHandler());
ch.pipeline().addLast(new AiAnswerHandler());
ch.pipeline().addLast(new UserRgChatHandler());
还是那句话,注意顺序。
人工坐席
对于人工坐席就稍微简单了,他和用户端一样,做两件事,1 是连接成功后,注册到服务端,2 是与用户端交互。
public class RgHandler extends ChannelInboundHandlerAdapter {
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
ctx.channel().writeAndFlush(MessageTypeEnum.RG_REGISTER.getType() + "&我是人工坐席:" + ctx.channel().id().toString());
}
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
String[] message = ((String) msg).split("&");
String messageType = message[0];
String[] values = message[1].split("\\|");
String userChannelId = values[0];
String rgChannelId = ctx.channel().id().toString();
if (MessageTypeEnum.USER_HELLO.getType().equals(messageType)) {
System.out.println("有用户[" + userChannelId + "]在等待人工坐席,请尽快接入");
ctx.channel().writeAndFlush(MessageTypeEnum.RG_USER_MESSAGE.getType() + "&" + userChannelId + "|您好,我是工号[" + rgChannelId + "],请问您有什么问题需要咨询吗?");
} else if (MessageTypeEnum.RG_USER_MESSAGE.getType().equals(messageType)) {
String content = values[1];
System.out.println("用户说:" + content);
System.out.println();
Scanner scanner = new Scanner(System.in);
String rgContent = scanner.nextLine();
// 人工坐席 Channel
String toChannelId = values[0];
rgContent = MessageTypeEnum.RG_USER_MESSAGE.getType() + "&" + toChannelId + "|" + rgContent;
ctx.channel().writeAndFlush(rgContent);
}
}
}
- 添加到 ChannelPipeline 中
ch.pipeline().addLast(new StringDecoder());
ch.pipeline().addLast(new StringEncoder());
ch.pipeline().addLast(new RgHandler());
用户端
用户端的 handler 就需要改造下了,他需要区分是智能客服来的还是人工坐席的。两者的消息提不一样。当然这里也是可以拆分为两个 handler,这是没有必要了。
public class UserHandler extends ChannelInboundHandlerAdapter {
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
ctx.channel().writeAndFlush(MessageTypeEnum.USER_REGISTER.getType() + "&我是用户:" + ctx.channel().id().toString());
}
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
String[] messages = ((String) msg).split("&");
String messageType = messages[0];
if (MessageTypeEnum.USER_QUESTION.getType().equals(messageType)) {
// 如果是智能客服
System.out.println(messages[1]);
System.out.println();
Scanner scanner = new Scanner(System.in);
String key = scanner.nextLine();
ctx.channel().writeAndFlush(MessageTypeEnum.USER_QUESTION.getType() + "&" + key);
} else if (MessageTypeEnum.RG_USER_MESSAGE.getType().equals(messageType)) {
// 人工坐席
String[] values = messages[1].split("\\|");
String content = values[1];
System.out.println("人工坐席说:" + content);
System.out.println();
Scanner scanner = new Scanner(System.in);
String userContent = scanner.nextLine();
// 人工坐席 Channel
String toChannelId = values[0];
userContent = MessageTypeEnum.RG_USER_MESSAGE.getType() + "&" + toChannelId + "|" + userContent;
ctx.channel().writeAndFlush(userContent);
}
}
}
运行结果
运行结果有两种结果,1 是用户先输入 0 ,然后等待人工坐席,2 是用户登录的时候有人工坐席。
- 用户输入 0 ,等待人工坐席
用户端日志
输入 0 后,其实用户一直在这里等待,小伙伴去看下 ChannelSessionMemory.getRgChannelId()
这个获取人工做些的代码,其实大明哥这里使用的是阻塞队列 ArrayBlockingQueue,在获取的时候会等待 30 秒。
当人工坐席注册后,日志如下:
人工坐席一注册,智能客服就告诉他有用户在等待,需要他尽快接入,这个时候,他会给用户发送一条消息:您好,我是工号[xxx],请问您有什么问题需要咨询吗?
,用户收到这个消息后就知道有人工坐席了,这个时候他们就可以对话了。
- 用户输入 0 时,有人工坐席在线
如果用户输入 0 的时候,有人工坐席在线的话,会立刻收到 您好,我是工号[xxx],请问您有什么问题需要咨询吗?
。
对于人工坐席而言,他不会收到有 xxx 用户在等待,而是直接收到用户发过来的消息。
到这里整个人工坐席就已经完成了,是不是超级牛逼(LJ),超级智能(ZZ)。当然里面还有很多问题没有解决,比如用户突然下线怎么处理?还有并发情况等等一系列的情况,但是这个毕竟是一个入门级别的 demo,我们的目的是掌握 Netty 核心组件的基本概念,以及使用方法。
文章代码只是部分,完整的代码见源码部分。