Netty(一) SpringBoot 整合長連線心跳機制

crossoverJie發表於2018-05-28

NettySpring Boot

前言

Netty 是一個高效能的 NIO 網路框架，本文基於 SpringBoot 以常見的心跳機制來認識 Netty。

最終能達到的效果：

客戶端每隔 N 秒檢測是否需要傳送心跳。
服務端也每隔 N 秒檢測是否需要傳送心跳。
服務端可以主動 push 訊息到客戶端。
基於 SpringBoot 監控，可以檢視實時連線以及各種應用資訊。

效果如下：

IdleStateHandler

Netty 可以使用 IdleStateHandler 來實現連線管理，當連線空閒時間太長（沒有傳送、接收訊息）時則會觸發一個事件，我們便可在該事件中實現心跳機制。

客戶端心跳

當客戶端空閒了 N 秒沒有給服務端傳送訊息時會自動傳送一個心跳來維持連線。

核心程式碼程式碼如下：

public class EchoClientHandle extends SimpleChannelInboundHandler<ByteBuf> {

    private final static Logger LOGGER = LoggerFactory.getLogger(EchoClientHandle.class);



    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {

        if (evt instanceof IdleStateEvent){
            IdleStateEvent idleStateEvent = (IdleStateEvent) evt ;

            if (idleStateEvent.state() == IdleState.WRITER_IDLE){
                LOGGER.info("已經 10 秒沒有傳送資訊！");
                //向服務端傳送訊息
                CustomProtocol heartBeat = SpringBeanFactory.getBean("heartBeat", CustomProtocol.class);
                ctx.writeAndFlush(heartBeat).addListener(ChannelFutureListener.CLOSE_ON_FAILURE) ;
            }


        }

        super.userEventTriggered(ctx, evt);
    }


    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, ByteBuf in) throws Exception {

        //從服務端收到訊息時被呼叫
        LOGGER.info("客戶端收到訊息={}",in.toString(CharsetUtil.UTF_8)) ;

    }
}    
複製程式碼

實現非常簡單，只需要在事件回撥中傳送一個訊息即可。

由於整合了 SpringBoot ，所以傳送的心跳資訊是一個單例的 Bean。

@Configuration
public class HeartBeatConfig {

    @Value("${channel.id}")
    private long id ;


    @Bean(value = "heartBeat")
    public CustomProtocol heartBeat(){
        return new CustomProtocol(id,"ping") ;
    }
}
複製程式碼

這裡涉及到了自定義協議的內容，請繼續檢視下文。

當然少不了啟動引導：

@Component
public class HeartbeatClient {

    private final static Logger LOGGER = LoggerFactory.getLogger(HeartbeatClient.class);

    private EventLoopGroup group = new NioEventLoopGroup();


    @Value("${netty.server.port}")
    private int nettyPort;

    @Value("${netty.server.host}")
    private String host;

    private SocketChannel channel;

    @PostConstruct
    public void start() throws InterruptedException {
        Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(group)
                .channel(NioSocketChannel.class)
                .handler(new CustomerHandleInitializer())
        ;

        ChannelFuture future = bootstrap.connect(host, nettyPort).sync();
        if (future.isSuccess()) {
            LOGGER.info("啟動 Netty 成功");
        }
        channel = (SocketChannel) future.channel();
    }
    
}

public class CustomerHandleInitializer extends ChannelInitializer<Channel> {
    @Override
    protected void initChannel(Channel ch) throws Exception {
        ch.pipeline()
                //10 秒沒傳送訊息 將IdleStateHandler 新增到 ChannelPipeline 中
                .addLast(new IdleStateHandler(0, 10, 0))
                .addLast(new HeartbeatEncode())
                .addLast(new EchoClientHandle())
        ;
    }
}    
複製程式碼

所以當應用啟動每隔 10 秒會檢測是否傳送過訊息，不然就會傳送心跳資訊。

服務端心跳

伺服器端的心跳其實也是類似，也需要在 ChannelPipeline 中新增一個 IdleStateHandler 。

public class HeartBeatSimpleHandle extends SimpleChannelInboundHandler<CustomProtocol> {

    private final static Logger LOGGER = LoggerFactory.getLogger(HeartBeatSimpleHandle.class);

    private static final ByteBuf HEART_BEAT =  Unpooled.unreleasableBuffer(Unpooled.copiedBuffer(new CustomProtocol(123456L,"pong").toString(),CharsetUtil.UTF_8));


    /**
     * 取消繫結
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {

        NettySocketHolder.remove((NioSocketChannel) ctx.channel());
    }

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {

        if (evt instanceof IdleStateEvent){
            IdleStateEvent idleStateEvent = (IdleStateEvent) evt ;

            if (idleStateEvent.state() == IdleState.READER_IDLE){
                LOGGER.info("已經5秒沒有收到資訊！");
                //向客戶端傳送訊息
                ctx.writeAndFlush(HEART_BEAT).addListener(ChannelFutureListener.CLOSE_ON_FAILURE) ;
            }


        }

        super.userEventTriggered(ctx, evt);
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, CustomProtocol customProtocol) throws Exception {
        LOGGER.info("收到customProtocol={}", customProtocol);

        //儲存客戶端與 Channel 之間的關係
        NettySocketHolder.put(customProtocol.getId(),(NioSocketChannel)ctx.channel()) ;
    }
}
複製程式碼

這裡有點需要注意：

當有多個客戶端連上來時，服務端需要區分開，不然響應訊息就會發生混亂。

所以每當有個連線上來的時候，我們都將當前的 Channel 與連上的客戶端 ID 進行關聯（因此每個連上的客戶端 ID 都必須唯一）。

這裡採用了一個 Map 來儲存這個關係，並且在斷開連線時自動取消這個關聯。

public class NettySocketHolder {
    private static final Map<Long, NioSocketChannel> MAP = new ConcurrentHashMap<>(16);

    public static void put(Long id, NioSocketChannel socketChannel) {
        MAP.put(id, socketChannel);
    }

    public static NioSocketChannel get(Long id) {
        return MAP.get(id);
    }

    public static Map<Long, NioSocketChannel> getMAP() {
        return MAP;
    }

    public static void remove(NioSocketChannel nioSocketChannel) {
        MAP.entrySet().stream().filter(entry -> entry.getValue() == nioSocketChannel).forEach(entry -> MAP.remove(entry.getKey()));
    }
}
複製程式碼

啟動載入程式：

Component
public class HeartBeatServer {

    private final static Logger LOGGER = LoggerFactory.getLogger(HeartBeatServer.class);

    private EventLoopGroup boss = new NioEventLoopGroup();
    private EventLoopGroup work = new NioEventLoopGroup();


    @Value("${netty.server.port}")
    private int nettyPort;


    /**
     * 啟動 Netty
     *
     * @return
     * @throws InterruptedException
     */
    @PostConstruct
    public void start() throws InterruptedException {

        ServerBootstrap bootstrap = new ServerBootstrap()
                .group(boss, work)
                .channel(NioServerSocketChannel.class)
                .localAddress(new InetSocketAddress(nettyPort))
                //保持長連線
                .childOption(ChannelOption.SO_KEEPALIVE, true)
                .childHandler(new HeartbeatInitializer());

        ChannelFuture future = bootstrap.bind().sync();
        if (future.isSuccess()) {
            LOGGER.info("啟動 Netty 成功");
        }
    }


    /**
     * 銷燬
     */
    @PreDestroy
    public void destroy() {
        boss.shutdownGracefully().syncUninterruptibly();
        work.shutdownGracefully().syncUninterruptibly();
        LOGGER.info("關閉 Netty 成功");
    }
}    


public class HeartbeatInitializer extends ChannelInitializer<Channel> {
    @Override
    protected void initChannel(Channel ch) throws Exception {
        ch.pipeline()
                //五秒沒有收到訊息 將IdleStateHandler 新增到 ChannelPipeline 中
                .addLast(new IdleStateHandler(5, 0, 0))
                .addLast(new HeartbeatDecoder())
                .addLast(new HeartBeatSimpleHandle());
    }
}
複製程式碼

也是同樣將IdleStateHandler 新增到 ChannelPipeline 中，也會有一個定時任務，每5秒校驗一次是否有收到訊息，否則就主動傳送一次請求。

因為測試是有兩個客戶端連上所以有兩個日誌。

自定義協議

上文其實都看到了：服務端與客戶端採用的是自定義的 POJO 進行通訊的。

所以需要在客戶端進行編碼，服務端進行解碼，也都只需要各自實現一個編解碼器即可。

CustomProtocol：

public class CustomProtocol implements Serializable{

    private static final long serialVersionUID = 4671171056588401542L;
    private long id ;
    private String content ;
    //省略 getter/setter
}
複製程式碼

客戶端的編碼器：

public class HeartbeatEncode extends MessageToByteEncoder<CustomProtocol> {
    @Override
    protected void encode(ChannelHandlerContext ctx, CustomProtocol msg, ByteBuf out) throws Exception {

        out.writeLong(msg.getId()) ;
        out.writeBytes(msg.getContent().getBytes()) ;

    }
}
複製程式碼

也就是說訊息的前八個位元組為 header，剩餘的全是 content。

服務端的解碼器：

public class HeartbeatDecoder extends ByteToMessageDecoder {
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {

        long id = in.readLong() ;
        byte[] bytes = new byte[in.readableBytes()] ;
        in.readBytes(bytes) ;
        String content = new String(bytes) ;

        CustomProtocol customProtocol = new CustomProtocol() ;
        customProtocol.setId(id);
        customProtocol.setContent(content) ;
        out.add(customProtocol) ;

    }
}
複製程式碼

只需要按照剛才的規則進行解碼即可。

實現原理

其實聯想到 IdleStateHandler 的功能，自然也能想到它實現的原理：

應該會存在一個定時任務的執行緒去處理這些訊息。

來看看它的原始碼：

首先是建構函式:

    public IdleStateHandler(
            int readerIdleTimeSeconds,
            int writerIdleTimeSeconds,
            int allIdleTimeSeconds) {

        this(readerIdleTimeSeconds, writerIdleTimeSeconds, allIdleTimeSeconds,
             TimeUnit.SECONDS);
    }
複製程式碼

其實就是初始化了幾個資料：

readerIdleTimeSeconds：一段時間內沒有資料讀取
writerIdleTimeSeconds：一段時間內沒有資料傳送
allIdleTimeSeconds：以上兩種滿足其中一個即可

因為 IdleStateHandler 也是一種 ChannelHandler，所以會在 channelActive 中初始化任務：

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        // This method will be invoked only if this handler was added
        // before channelActive() event is fired.  If a user adds this handler
        // after the channelActive() event, initialize() will be called by beforeAdd().
        initialize(ctx);
        super.channelActive(ctx);
    }
    
    private void initialize(ChannelHandlerContext ctx) {
        // Avoid the case where destroy() is called before scheduling timeouts.
        // See: https://github.com/netty/netty/issues/143
        switch (state) {
        case 1:
        case 2:
            return;
        }

        state = 1;
        initOutputChanged(ctx);

        lastReadTime = lastWriteTime = ticksInNanos();
        if (readerIdleTimeNanos > 0) {
            readerIdleTimeout = schedule(ctx, new ReaderIdleTimeoutTask(ctx),
                    readerIdleTimeNanos, TimeUnit.NANOSECONDS);
        }
        if (writerIdleTimeNanos > 0) {
            writerIdleTimeout = schedule(ctx, new WriterIdleTimeoutTask(ctx),
                    writerIdleTimeNanos, TimeUnit.NANOSECONDS);
        }
        if (allIdleTimeNanos > 0) {
            allIdleTimeout = schedule(ctx, new AllIdleTimeoutTask(ctx),
                    allIdleTimeNanos, TimeUnit.NANOSECONDS);
        }
    }    
複製程式碼

也就是會按照我們給定的時間初始化出定時任務。

接著在任務真正執行時進行判斷：

    private final class ReaderIdleTimeoutTask extends AbstractIdleTask {

        ReaderIdleTimeoutTask(ChannelHandlerContext ctx) {
            super(ctx);
        }

        @Override
        protected void run(ChannelHandlerContext ctx) {
            long nextDelay = readerIdleTimeNanos;
            if (!reading) {
                nextDelay -= ticksInNanos() - lastReadTime;
            }

            if (nextDelay <= 0) {
                // Reader is idle - set a new timeout and notify the callback.
                readerIdleTimeout = schedule(ctx, this, readerIdleTimeNanos, TimeUnit.NANOSECONDS);

                boolean first = firstReaderIdleEvent;
                firstReaderIdleEvent = false;

                try {
                    IdleStateEvent event = newIdleStateEvent(IdleState.READER_IDLE, first);
                    channelIdle(ctx, event);
                } catch (Throwable t) {
                    ctx.fireExceptionCaught(t);
                }
            } else {
                // Read occurred before the timeout - set a new timeout with shorter delay.
                readerIdleTimeout = schedule(ctx, this, nextDelay, TimeUnit.NANOSECONDS);
            }
        }
    }
複製程式碼

如果滿足條件則會生成一個 IdleStateEvent 事件。

SpringBoot 監控

由於整合了 SpringBoot 之後不但可以利用 Spring 幫我們管理物件，也可以利用它來做應用監控。

actuator 監控

當我們為引入了:

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
複製程式碼

就開啟了 SpringBoot 的 actuator 監控功能，他可以暴露出很多監控端點供我們使用。

如一些應用中的一些統計資料：

存在的 Beans：

更多資訊請檢視：docs.spring.io/spring-boot…

但是如果我想監控現在我的服務端有多少客戶端連上來了，分別的 ID 是多少？

其實就是實時檢視我內部定義的那個關聯關係的 Map。

這就需要暴露自定義端點了。

自定義端點

暴露的方式也很簡單：

繼承 AbstractEndpoint 並複寫其中的 invoke 函式：

public class CustomEndpoint extends AbstractEndpoint<Map<Long,NioSocketChannel>> {


    /**
     * 監控端點的 訪問地址
     * @param id
     */
    public CustomEndpoint(String id) {
        //false 表示不是敏感端點
        super(id, false);
    }

    @Override
    public Map<Long, NioSocketChannel> invoke() {
        return NettySocketHolder.getMAP();
    }
}
複製程式碼

其實就是返回了 Map 中的資料。

再配置一個該型別的 Bean 即可：

@Configuration
public class EndPointConfig {


    @Value("${monitor.channel.map.key}")
    private String channelMap;

    @Bean
    public CustomEndpoint buildEndPoint(){
        CustomEndpoint customEndpoint = new CustomEndpoint(channelMap) ;
        return customEndpoint ;
    }
}
複製程式碼

這樣我們就可以通過配置檔案中的 monitor.channel.map.key 來訪問了：

一個客戶端連線時：

兩個客戶端連線時：

整合 SBA

這樣其實監控功能已經可以滿足了，但能不能展示的更美觀、並且多個應用也可以方便檢視呢？

有這樣的開源工具幫我們做到了：

github.com/codecentric…

簡單來說我們可以利用該工具將 actuator 暴露出來的介面視覺化並聚合的展示在頁面中：

接入也很簡單，首先需要引入依賴：

        <dependency>
            <groupId>de.codecentric</groupId>
            <artifactId>spring-boot-admin-starter-client</artifactId>
        </dependency>        

複製程式碼

並在配置檔案中加入：

# 關閉健康檢查許可權
management.security.enabled=false
# SpringAdmin 地址
spring.boot.admin.url=http://127.0.0.1:8888
複製程式碼

在啟動應用之前先講 SpringBootAdmin 部署好：

這個應用就是一個純粹的 SpringBoot ，只需要在主函式上加入 @EnableAdminServer 註解。

@SpringBootApplication
@Configuration
@EnableAutoConfiguration
@EnableAdminServer
public class AdminApplication {

	public static void main(String[] args) {
		SpringApplication.run(AdminApplication.class, args);
	}
}
複製程式碼

引入：

		<dependency>
			<groupId>de.codecentric</groupId>
			<artifactId>spring-boot-admin-starter-server</artifactId>
			<version>1.5.7</version>
		</dependency>
		<dependency>
			<groupId>de.codecentric</groupId>
			<artifactId>spring-boot-admin-server-ui</artifactId>
			<version>1.5.6</version>
		</dependency>
複製程式碼

之後直接啟動就行了。

這樣我們在 SpringBootAdmin 的頁面中就可以檢視很多應用資訊了。

更多內容請參考官方指南：

codecentric.github.io/spring-boot…

自定義監控資料

其實我們完全可以藉助 actuator 以及這個視覺化頁面幫我們監控一些簡單的度量資訊。

比如我在客戶端和服務端中寫了兩個 Rest 介面用於向對方傳送訊息。

只是想要記錄分別傳送了多少次：

客戶端：

@Controller
@RequestMapping("/")
public class IndexController {

    /**
     * 統計 service
     */
    @Autowired
    private CounterService counterService;

    @Autowired
    private HeartbeatClient heartbeatClient ;

    /**
     * 向服務端發訊息
     * @param sendMsgReqVO
     * @return
     */
    @ApiOperation("客戶端傳送訊息")
    @RequestMapping("sendMsg")
    @ResponseBody
    public BaseResponse<SendMsgResVO> sendMsg(@RequestBody SendMsgReqVO sendMsgReqVO){
        BaseResponse<SendMsgResVO> res = new BaseResponse();
        heartbeatClient.sendMsg(new CustomProtocol(sendMsgReqVO.getId(),sendMsgReqVO.getMsg())) ;

        // 利用 actuator 來自增
        counterService.increment(Constants.COUNTER_CLIENT_PUSH_COUNT);

        SendMsgResVO sendMsgResVO = new SendMsgResVO() ;
        sendMsgResVO.setMsg("OK") ;
        res.setCode(StatusEnum.SUCCESS.getCode()) ;
        res.setMessage(StatusEnum.SUCCESS.getMessage()) ;
        res.setDataBody(sendMsgResVO) ;
        return res ;
    }
}
複製程式碼