2023-12-03  阅读(625)
版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。 本文链接:https://www.skjava.com/series/article/1323683324

上篇文章(Netty 入门 — 第一个完整的 demo 之智能客服)大明哥演示了强大的智能客服,它能够很好的解决用户的一些常见的问题,但是有些问题依然还需要人工客服来完成,所以这篇文章我们来实现人工坐席。

功能实现

当用户输入 0 的时候,智能客户需要将这个用户转发给某一个人工客服,如果没有人工客户在线需要提示用户是否继续等待。在等待期间若有人工客服上线则将其转接到该用户。

那么服务端需要做如下几件事情:

  1. 维护用户与人工坐席之间的关系,发的消息不能串。
  2. 将人工坐席分配给用户。若没有人工坐席,则在用户等待期间,人工坐席上线则将其转接给该用户。
  3. 消息的转发。

至于用户和人工坐席,则相对来说就比较简单了,接收服务端的消息,并发送消息。

代码实现

代码逻辑相比上篇文章智能 AI 来说有点儿复杂代码,所以大明哥将其分为两部分实现:

  1. 无人工坐席
  2. 有人工坐席

无人工坐席

无人工坐席的时候,用户就是与智能客服交互,在用户输入 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);
        }
    }
}

对于人工坐席注册,它除了注册之外还需要做两件事:

  1. 判断这个时候是否有用户在等待,如果有客户在等待的,则服务端需要通知人工坐席与该用户打招呼。
  2. 如果没有用户,则他就加入到等待池中,等下一个用户来咨询的时候可以直接联系。大明哥在智能客服回答 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 核心组件的基本概念,以及使用方法。

文章代码只是部分,完整的代码见源码部分。

源码:http://suo.nz/1ZjowB

阅读全文
  • 点赞