消息推送

1 什么是消息推送

很多手机APP会不定时的给用户推送消息，例如一些新闻APP会给用户推送用户可能感兴趣的新闻，或者APP有更新了，会给用户推送是否选择更新的消息等等，这就是所谓的“消息推送”。

对于APP或者桌面客户端这种C/S架构的软件，实现消息推送其实比较简单，只需要维护TCP连接就行了，因为TCP本身是全双工的，客户端和服务端都能发送消息。但Web环境就不太一样了，目前的Web软件大多数都是B/S架构（即浏览器/服务端），使用的消息传输协议也大多数是HTTP，HTTP1.0和HTTP1.1都无法实现服务端向客户端（浏览器）主动发送消息，所以实现的手段主要就是客户端定时或者不定时轮询（例如间隔时间动态变化），这种方式实现并不算复杂，最大的问题就是性能，轮询是需要消耗CPU资源的，如果很长一段时间内，服务端都没有消息要给客户端，那么这个CPU空轮询的占比就比较大了，而且轮询也会对服务端造成压力，因为如果服务端没有消息要给客户端，那么其实这样的“请求-响应”是没有意义的，算是服务端的额外压力。

可能有朋友难以理解上面所描述的情况，下面我画个图来描述这个问题：

FudDcn.png

可以从图中看到，客户端老是不断的孜孜不倦的跑去问服务端“有没有新的推送消息”，而且还不长记性，每次都问同样的问题（HTTP是无状态的协议），这事给谁谁都得烦，是吧，服务端老被客户端“骚扰”，所以有时候就会“罢工”不干了！（服务端压力过大，短暂不可用）那怎么解决这个问题呢？也就是说让服务端过得舒服一些？

2 解决方案

目前主要有两种主流的解决方案：

• 利用新版的HTTP2.0，重构原有的代码，因为HTTP2.0支持服务端主动发送数据给客户端，但这种方案实现其实是比较困难的，一是服务端实现起来并不简单，而是一般也不用来推送大量的数据，常见的使用场景是请求.html，然后服务端把HTML作为响应给前端，并且同时把CSS，JS文件都“推”给前端（在传统的HTTP中，要拿到这三个东西，至少需要三次HTTP请求）。本文不讨论该方案。
• 利用WebSocket协议，WebSocket是一种在浏览器环境下可以全双工通信的应用层协议（等会儿会给出简单介绍）。这种方案就是利用WebSocket的全双工通信的特性，使得B/S架构的软件也能像C/S架构的软件那样简单的实现消息推送。本文主要介绍的就是这种解决方案。

3 WebSocket协议

WebSocket和HTTP,FTP等一样，都属于应用层协议，诞生于2008年，与2011年称为国际标准（说实话，这段时间真的很短，说明WebSocket确实解决了一些问题）。下面是维基百科上的定义：

WebSocket是一种在单个TCP连接上进行全双工通信的协议。WebSocket通信协议于2011年被IETF定为标准RFC 6455，并由RFC7936补充规范。WebSocket API也被W3C定为标准。

WebSocket使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在WebSocket API中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。

其优点也不少（这里所提到的优点是相对于HTTP来说的）：

• 支持全双工通信，这对于某些场景尤其重要，例如消息推送。
• 更好的二进制支持，HTTP本身是文本传输协议，对于二进制的数据需要特殊处理（不过2.0版本也对二进制做了补充），而WebSocket定义了二进制帧，所以传输二进制数据的时候不需要像HTTP那样特殊处理。
• 较少的控制开销。连接创建后，ws客户端、服务端进行数据交换时，协议控制的数据包头部较小。在不包含头部的情况下，服务端到客户端的包头只有2~10字节（取决于数据包长度），客户端到服务端的的话，需要加上额外的4字节的掩码。而HTTP协议每次通信都需要携带完整的头部。
• ...............

那WebSocket连接是如何建立的呢？答案是：握手协议。

在真正建立WebSocket之前，会先建立一个HTTP连接，然后服务端响应状态码101，表示切换协议，之后通信协议会升级成WebSocket，这样WebSocket连接才算是建立起来。下面是一个WebSocket握手的示例：

客户端请求：

GET / HTTP/1.1
#Upgrade就表示要把协议升级成WebSocket
Upgrade: websocket
Connection: Upgrade
Host: example.com
Origin: http://example.com
Sec-WebSocket-Key: sN9cRrP/n9NdMgdcy2VJFQ==
Sec-WebSocket-Version: 13

服务端响应：

#客户端收到该HTTP报文之后，会将通信协议升级成WebSocket，之后的数据传输就都使用WebSocket了
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: fFBooB7FAkLlXgRSz0BT3v4hq5s=
Sec-WebSocket-Location: ws://example.com/

这就是所谓的握手了（双方建立友好关系）。

4 利用Netty + WebSocket实现消息推送

在动手之前，先声明一点：本文不会介绍WebSocket的简单使用，因为本文的标题是“消息推送”，而不是“WebSocket入门”，Netty也是同理。

首先，我们先确定一些设计方案：

1. 客户端和服务端使用WebSocket作为通信协议，当服务端有新的推送消息的时候，主动把消息“推”给客户端。
2. Netty作为网络通信的基础框架。
3. 服务端监听消息队列，当消息队列中有新的消息时，把消息发送给客户端。
4. 可以还有另外一个专门往消息队列里放入消息的服务，至此整个系统就形成一个完整的消息推送系统了。

大致了解了方案之后，可以着手实现了，先来看看服务端的实现：

服务启动类：

public class WebSocketServer {

    //RabbitMQ客户端连接工厂
    private static ConnectionFactory connectionFactory = new ConnectionFactory();

    //客户端连接
    private static Connection connection;

    //客户端Channel
    private static com.rabbitmq.client.Channel channel;

    //Jackson，序列化用的
    private static ObjectMapper objectMapper = new ObjectMapper();


    public static void main(String[] args) {
        //初始化ServerBootstrap
        ServerBootstrap server = new ServerBootstrap();
        EventLoopGroup boss = new NioEventLoopGroup();
        EventLoopGroup worker = new NioEventLoopGroup();

        server.group(boss, worker)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer() {
                    @Override
                    protected void initChannel(Channel ch) throws Exception {
                        ch.pipeline().addLast(new HttpServerCodec());
                        ch.pipeline().addLast(new HttpObjectAggregator(16 * 16 * 1024));
                        ch.pipeline().addLast(new ChunkedWriteHandler());
                        ch.pipeline().addLast(new WebSocketServerHandler());
                    }
                });

        //初始化RabbitMQ的配置
        connectionFactory.setHost("xxx.xxx.xxx.xxx");
        connectionFactory.setUsername("xxx");
        connectionFactory.setPassword("xxx");

        try {
            connection = connectionFactory.newConnection();
            channel = connection.createChannel();
            channel.queueDeclare(RabbitMQConfig.PUSH_MSG_QUEUE, false, false, true, null);
        } catch (IOException | TimeoutException e) {
            e.printStackTrace();
        }

        //服务端绑定8081端口
        server.bind(8081).syncUninterruptibly().addListener(future -> {
            if (future.isSuccess()) {
                System.out.println("绑定成功");
                startPushMessage();
                startMQListener();
            } else {
                System.out.println("绑定失败");
            }
        });


    }

    //开启消息队列的监听，当有消息的时候，就把消息推送给客户端
    private static void startMQListener() {
        new Thread(() -> {
            Consumer consumer = new DefaultConsumer(channel) {
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    String message = new String(body, "UTF-8");
                    //这里就比较粗暴的获取ChannleGroup了，建议读者尝试的时候用更好的方法
                    ChannelGroup group = WebSocketServerHandler.group;
                    if (group != null) {
                    
                        group.writeAndFlush(new TextWebSocketFrame(message));
                    }
                }


            };
            System.out.println("开始监听");
            try {
                channel.basicConsume(RabbitMQConfig.PUSH_MSG_QUEUE, true, consumer);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();
    }

    private static final AtomicLong id = new AtomicLong(0);

    //随机生成一个消息
    private static Notify generateNotify() {
        Notify notify = new Notify();
        notify.setId(id.getAndIncrement());
        notify.setTitle(UUID.randomUUID().toString());
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < 500; i++) {
            builder.append(getRandomChar());
        }
        notify.setContent(builder.toString());
        notify.setPushTime(new Date());
        return notify;
    }

    private static char getRandomChar() {
        String str = "";
        int hightPos; //
        int lowPos;

        Random random = new Random();

        hightPos = (176 + Math.abs(random.nextInt(39)));
        lowPos = (161 + Math.abs(random.nextInt(93)));

        byte[] b = new byte[2];
        b[0] = (Integer.valueOf(hightPos)).byteValue();
        b[1] = (Integer.valueOf(lowPos)).byteValue();

        try {
            str = new String(b, "GBK");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            System.out.println("错误");
        }

        return str.charAt(0);
    }


    //这里我不另外写专门的生产消息的服务了，直接定时的往消息队列里放入消息
    private static void startPushMessage() {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(4);
        service.scheduleAtFixedRate(() -> {
            try {
                Notify notify = generateNotify();
                String message = objectMapper.writeValueAsString(notify);
                channel.basicPublish("", RabbitMQConfig.PUSH_MSG_QUEUE, null, message.getBytes());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }, 5, 5, TimeUnit.SECONDS);
    }
}

WebSocketHandler类：

public class WebSocketServerHandler extends SimpleChannelInboundHandler