前言

        在前面的课题把Netty网络编程的各种理论和主要组件、核心部件、重要机制都摊开说清楚后，今天给大家分享一下Netty在网络编程中的一些典型应用场景和一些重要问题的解决方案。比如由于TCP网络传输底层的原因，而产生不可预期的粘包和半包问题，致使收到对端的报文明显缺斤少两或前后报文之间相互粘连在一起；又如在生产环境中，网络通信的任意一端由于外界网络或自身bug的原因，导致网络长时间阻塞或直接断开等行为，对端无法明显感知真正原因；不能第一时间通知到对端或相关技术人员处理，最终导致更大的业务受损。


网络粘包半包

Netty网编程实战：四种解决粘包方式切换、两种生产级双向监听模式并行、高效编解码、多处理器协同作战_第1张图片

 假设客户端分别发送了两个数据包 D1 和 D2 给服务端，由于服务端一次读取到的字节 数是不确定的，故可能存在以下 4 种情况。 

（1）服务端分两次读取到了两个独立的数据包，分别是 D1 和 D2，没有粘包和拆包； 

（2）服务端一次接收到了两个数据包，D1 和 D2 粘合在一起，被称为 TCP 粘包； 

（3）服务端分两次读取到了两个数据包，第一次读取到了完整的 D1 包和 D2 包的部分 内容，第二次读取到了 D2 包的剩余内容，这被称为 TCP 拆包； 

（4）服务端分两次读取到了两个数据包，第一次读取到了 D1 包的部分内容 D1_1，第 二次读取到了 D1 包的剩余内容 D1_2 和 D2 包的整包。 

 如果此时服务端 TCP 接收滑窗非常小，而数据包 D1 和 D2 比较大，很有可能会发生第 五种可能，即服务端分多次才能将 D1 和 D2 包接收完全，期间发生多次拆包。

        由于 TCP 协议本身的机制（面向连接的可靠地协议-三次握手机制）客户端与服务器会 维持一个连接，数据在连接不断开的情况下，可以持续不断地将多个数据包发 往服务器，但是如果发送的网络数据包太小，那么他本身会启用 Nagle 算法（可配置是否启 用）对较小的数据包进行合并然后再发送。那么这样的话，服务器在接收到消息（数据流）的时候就无法区分哪 些数据包是客户端自己分开发送的，这样产生了粘包；服务器在接收到数据库后，放到缓冲 区中，如果消息没有被及时从缓存区取走，下次在取数据的时候可能就会出现一次取出多个 数据包的情况，造成粘包现象。

      解决办法已在前面的文章介绍得很清楚了，这里不在赘述。今天本文将综合采用回车字符分割、任意特殊字符分割、固定字符分割和数据本身带长度信息等四种方式，交替切换，在实战层面给大家展示这种四种方式是如何构建和工作的。


生产级双向心跳机制

Netty网编程实战：四种解决粘包方式切换、两种生产级双向监听模式并行、高效编解码、多处理器协同作战_第2张图片

        在凌晨等业务低谷时段，如果发生网络闪断、连接被 Hang 住等问题时，由于没有业务 消息，应用程序很难发现。到了白天业务高峰期时，会发生大量的网络通信失败，严重的会 导致一段时间进程内无法处理业务消息。为了解决这个问题，在网络空闲时采用心跳机制来检测链路的互通性，一旦发现网络故障，立即关闭链路，主动重连。

      本文将提供双向端对端心跳检测机制滑动检测，随时把双向服务的运行动向级存活情况，体现在前端控制台。


生产级存活检测和自动滑动重试与恢复机制

        自动监听对端通道是否断开或突变为未激活状态，致使网络传输中断或长时间阻塞等待。当这些问题发生时，对端会在第一时间感知到并启动自动滑动重试(重试频率在持续断开时，将逐渐降低)机制，当对端网络或服务恢复时，当前端也自动恢复正常的通讯，不需要外接的任何干预。


高效编解码器

Netty网编程实战：四种解决粘包方式切换、两种生产级双向监听模式并行、高效编解码、多处理器协同作战_第3张图片

        以上是Facebook在高连接数情况下，综合对以上20种三方开源序列和反序列化组件，进行对比测试。大家都知道JDK内置的基于流的序列化和反序列化效率都非常低下，数据报文和原文相比也膨胀得相当庞大。本文将以google的原生protostuff组件为例，展示Netty内嵌非内置组件的方式和高效轻快的序列化表现。


各种ChannelHandler协同

Netty网编程实战：四种解决粘包方式切换、两种生产级双向监听模式并行、高效编解码、多处理器协同作战_第4张图片

        在ChannelPipeline内部维护一个双向链表来存储进入管道的，各种ChannelHandler事件和处理器有序责任链式处理有业务执行先后顺序的处理及事件触发、传递等。倘若我们打乱Pipeline中处理器的顺序，那么执行最终会报错终止或数据报文传递和处理结果错乱。本文将容器化载入多种Handler实现多业务处理协同工作。


有了上面本文核心功能和业务集成介绍后，下面我们就运用Netty强大的特性，完成我们需集成的所有功能的代码设计。


各部分代码实战

一、客户端部分

/**
 * @author andychen https://blog.51cto.com/14815984
 * @description：Netty客户端业务通道处理器类
 * 负责处理和服务端的所有IO业务事件处理
 */
public class ClientChannelHandler extends SimpleChannelInboundHandler {
    /**
     * 统计当前通道第几次读取数据
     */
    private final AtomicInteger counter = new AtomicInteger(0);
    /**
     * 客户端读取网络通道数据后处理
     * @param channelHandlerContext 通道上下文(很重要,网络IO业务就靠它了)
     * @param byteBuf 网络传送过来的数据
     * @throws Exception
     */
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf) throws Exception {
        //打印接收到的服务端数据和当前统计计数
        System.out.println("Accept server data {"+byteBuf.toString(CharsetUtil.UTF_8)+"], the counter is:"+this.counter.incrementAndGet());
    }

    /**
     * 连接建立成功事件回调
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //连接建立后，循环10次向服务端发送连续报文
        ByteBuf buf = null;
        String msg = null;
        for (int i=0;i<10;i++){
            if(Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.SEND_LEN){
                UserAddress address = new UserAddress("[email protected]", "ChengDu.SiChuan");
                User user = new User(i,"AndyChen"+i,"WaveBeed"+i, address);
                ctx.write(user);
            }else{
                msg = "Client message"+i+" data ";
                if(Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.LINE_BASED){
                    msg += "(line_based)"+System.getProperty("line.separator");
                }
                else if(Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.DELIMITER_BASED){
                    msg += "(custom_based)"+Constant.CUSTOM_SPLIT_MARK;
                }else if(Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.FIXED_LEN){
                    msg = Constant.FIXED_LEN_CLIENT_TXT;
                }
                buf = Unpooled.buffer(msg.length());
                buf.writeBytes(msg.getBytes());
                ctx.writeAndFlush(buf);
            }
        }
        if(Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.SEND_LEN){
            ctx.flush();
        }
    }
    /**
     * 处理器异常集中处理
     * @param ctx 处理器上下文
     * @param cause 异常
     * @throws Exception
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
         cause.printStackTrace();
         ctx.close();
    }
}

/**
 * @author andychen https://blog.51cto.com/14815984
 * @description：Netty客户端启动器类
 */
public class NettyClientStarter {
    //采用netty内置定时器
    private static final HashedWheelTimer timer = new HashedWheelTimer();
    /**
     * 启动客户端
     * @param args
     */
    public static void main(String[] args){
        try {
            start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 启动客户端
     */
    private static void start() throws InterruptedException {
        //线程组
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            //Netty客户端启动类
            final Bootstrap boot = new Bootstrap();
            boot.group(group)//将线程组绑定到启动器
                    .channel(NioSocketChannel.class)//使用NIO进行网络传输
                    //绑定服务端连接地址
                    .remoteAddress(new InetSocketAddress(Constant.SERV_HOST, Constant.SERV_PORT));
            /**
             * 定义监听器
             */
            final ChannelMonitor monitor = new ClientMonitorHandler(Constant.SERV_HOST, Constant.SERV_PORT, timer, boot);
            boot.handler(new ChannelInitializer(){
                protected void initChannel(Channel channel) throws Exception {
                    channel.pipeline().addLast(monitor.setMonitorHandlers());
                }
            });
            //这里会阻塞，直到连接完成
            ChannelFuture future = boot.connect().sync();
            System.out.println("Has connected to server："+Constant.SERV_PORT+" ...");
            //这里也会阻塞，直到连接通道关闭
            future.channel().closeFuture().sync();
        }finally {
            //线程池组关闭
            //group.shutdownGracefully().sync();
        }
    }
}


二、服务端部分

/**
 * @author andychen https://blog.51cto.com/14815984
 * @description：Netty服务端业务通道处理器类
 * 负责向对端响应业务应答和服务端相关IO业务处理
 */
public class ServerChannelHandler extends ChannelInboundHandlerAdapter {
    /**
     * 消息接收计数器
     */
    private final AtomicInteger counter = new AtomicInteger(0);
    /**
     * 接收客户端发送的数据
     * @param ctx 处理器上下文
     * @param msg 消息
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        String clientData = null;
        User user = null;
        if(msg instanceof User){
            user = (User)msg;
            clientData = user.toString();
        }else{
            clientData = ((ByteBuf)msg).toString(CharsetUtil.UTF_8);
        }
        System.out.println("Accept client data ["+clientData+"], the counter is:"+this.counter.incrementAndGet());
        //回馈消息给客户端
        String toClientData = "Data has been accepted by server";
        if(Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.LINE_BASED ||
           Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.SEND_LEN){
            toClientData += "(line_based)"+System.getProperty("line.separator");
        }
        else if(Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.DELIMITER_BASED){
            toClientData += "(custom_based)"+Constant.CUSTOM_SPLIT_MARK;
        }else if(Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.FIXED_LEN){
            toClientData = Constant.FIXED_LEN_SERVER_TXT;
        }
        ctx.writeAndFlush(Unpooled.copiedBuffer(toClientData.getBytes()));
        if(Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.SEND_LEN && null != user){
            ctx.fireChannelRead(user);
        }
    }
    /**
     *
     * @param ctx 处理器上下文
     * @throws Exception
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.fireChannelReadComplete();
        System.out.println("Client data recevied completed!");
    }

    /**
     * 管道关闭时触发
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("Client: "+ctx.channel().remoteAddress()+" channel will close...");
    }
    /**
     * 异常处理器
     * @param ctx 处理器上下文
     * @param cause 异常
     * @throws Exception
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

/**
 * @author andychen https://blog.51cto.com/14815984
 * @description：Netty服务端启动器类
 */
public class NettyServerStarter {
    /**
     * 启动服务器
     * @param args
     */
    public static void main(String[] args) {
        try {
            start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 启动服务器端
     */
    private static void start() throws InterruptedException {
        //线程组
        EventLoopGroup mainGroup = new NioEventLoopGroup();
        EventLoopGroup workGroup = new NioEventLoopGroup();
        try {
            //服务端启动器
            ServerBootstrap boot = new ServerBootstrap();
            boot.group(mainGroup, workGroup)//将线程组绑定到启动器
                    .channel(NioServerSocketChannel.class)//使用NIO进行网络通讯
                    .localAddress(new InetSocketAddress(Constant.SERV_PORT))//绑定本地端口监听
                    .childHandler(new ChannelInitializerExt());//为Channel添加业务处理器
            //异步绑定服务器端口，sync()方法阻塞，直到绑定完成
            ChannelFuture future = boot.bind().sync();
            System.out.println("Server address:"+Constant.SERV_PORT+" has bind complete，waiting for data...");
            //这里通道会阻塞，直到通道关闭
            future.channel().closeFuture().sync();
        }finally {
            //优雅地关闭线程池组
            mainGroup.shutdownGracefully().sync();
            workGroup.shutdownGracefully().sync();
        }
    }
    /**
     * 通道初始化器扩展
     * 负责定义初始化各种业务ChannelHandler
     */
    private static class ChannelInitializerExt extends ChannelInitializer{
        /**
         * 初始化Channel
         * @param channel 当前通道
         * @throws Exception
         */
        protected void initChannel(Channel channel) throws Exception {
            ChannelPipeline p = channel.pipeline();
            //添加对客户端心跳检测
            p.addLast("heartbeat-state",new IdleStateHandler(Constant.HEART_BEAT_TIMEOUT,0,0, TimeUnit.SECONDS));
            p.addLast("heartbeat-check", new ServerHeartbeatHandler());
            /**
             * 解决粘包半包问题办法一：字符分隔
             */
            //支持一：回车分隔
            if(Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.LINE_BASED){
                p.addLast("linebase", new LineBasedFrameDecoder(Constant.DECODER_BYTE_MAX_LEN));
            }
            //支持二：自定义分隔符分隔
            if(Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.DELIMITER_BASED) {
                ByteBuf byteMark = Unpooled.copiedBuffer(Constant.CUSTOM_SPLIT_MARK.getBytes());
                p.addLast("custom", new DelimiterBasedFrameDecoder(Constant.DECODER_BYTE_MAX_LEN, byteMark));
            }
            /**
             * 解决粘包半包问题办法二：固定长度
             */
            if(Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.FIXED_LEN) {
                p.addLast("fixlength", new FixedLengthFrameDecoder(Constant.FIXED_LEN_CLIENT_TXT.length()));
            }
            /**
             * 解决粘包半包问题办法三：带长度
             */
            if(Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.SEND_LEN) {
                p.addLast("sendlen", new LengthFieldBasedFrameDecoder(65535,0,2,0,2));
                p.addLast(new ProtoStuffDecoder(User.class));
                p.addLast("linebase", new LineBasedFrameDecoder(Constant.DECODER_BYTE_MAX_LEN));
            }
            //业务处理Handler--往往此Handler是注册在管道的最后节点
            p.addLast(new ServerChannelHandler());
        }
    }
}


三、心跳机制部分

/**
 * @author andychen https://blog.51cto.com/14815984
 * @description：客户端心跳检测处理器
 */
public class ClientHeartbeatHandler extends ChannelInboundHandlerAdapter {
    /**
     * 事件触发器
     * @param ctx 处理器上下文
     * @param evt 触发对象
     * @throws Exception
     */
    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        /**
         * 构建心跳字节序列
         */
        String seq = Constant.HEART_BEAT_CLIN_MSG;
        if(Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.LINE_BASED ||
           Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.SEND_LEN){
            seq += System.getProperty("line.separator");
        }
        else if(Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.DELIMITER_BASED){
            seq += Constant.CUSTOM_SPLIT_MARK;
        }else if(Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.FIXED_LEN){
            seq = Constant.FIXED_LEN_SERVER_TXT;
        }
        final ByteBuf HEARBEAT_SEQ = Unpooled.unreleasableBuffer(Unpooled.copiedBuffer(seq, CharsetUtil.UTF_8));//ISO_8859_1
        /**
         * 发送心跳消息，并在发送失败时关闭连接
         */
        if(evt instanceof IdleStateEvent){
            IdleState state = ((IdleStateEvent)evt).state();
            /**
             * 服务端是数据接收端，那么客户端就是Write
             * 客户端5秒钟未收到应答，则认为发送心跳包检测
             */
            if(state == IdleState.WRITER_IDLE){
                ctx.writeAndFlush(HEARBEAT_SEQ).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
            }
        }else{
            //非心跳事件，将它传递给下个处理器处理
            super.userEventTriggered(ctx, evt);
        }
    }
}

/**
 * @author andychen https://blog.51cto.com/14815984
 * @description：服务端心跳检测处理器
 */
public class ServerHeartbeatHandler extends ChannelInboundHandlerAdapter {
    /**
     * 事件触发器
     * @param ctx 处理器上下文
     * @param evt 触发对象
     * @throws Exception
     */
    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        /**
         * 构建心跳字节序列
         */
        String seq = Constant.HEART_BEAT_SERV_MSG;
        if(Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.LINE_BASED ||
           Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.SEND_LEN){
            seq += System.getProperty("line.separator");
        }
        else if(Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.DELIMITER_BASED){
            seq += Constant.CUSTOM_SPLIT_MARK;
        }else if(Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.FIXED_LEN){
            seq = Constant.FIXED_LEN_SERVER_TXT;
        }
        final ByteBuf HEARBEAT_SEQ = Unpooled.unreleasableBuffer(Unpooled.copiedBuffer(seq, CharsetUtil.UTF_8));//ISO_8859_1
        /**
         * 发送心跳消息，并在发送失败时关闭连接
         */
        if(evt instanceof IdleStateEvent){
            IdleState state = ((IdleStateEvent)evt).state();
            /**
             * 客户端是数据发送端，那么服务器端就是Read
             * 服务器端5秒钟未收到应答，则认为发送心跳包检测
             */
            if(state == IdleState.READER_IDLE){
                ctx.writeAndFlush(HEARBEAT_SEQ).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
            }
        }else{
            //非心跳事件，将它传递给下个处理器处理
            super.userEventTriggered(ctx, evt);
        }
    }
}


四、生产级检活和重试机制部分

/**
 * @author andychen https://blog.51cto.com/14815984
 * @description：通道监视器设计类
 * 负责定时监听与对端的连接，当连接断开时，自动重试连接
 */
@ChannelHandler.Sharable
public abstract class ChannelMonitor extends ChannelInboundHandlerAdapter
                                     implements MonitoredChannelHandler, TimerTask {
    private final String host;//监视的主机
    private final int port;//监视的端口
    private final Timer timer;//定时器
    private final AbstractBootstrap boot;//启动对象
    private final AtomicInteger counter = new AtomicInteger(0);//重试次数统计
    public ChannelMonitor(String host, int port, Timer timer, AbstractBootstrap boot) {
        this.host = host;
        this.port = port;
        this.timer = timer;
        this.boot = boot;
    }

    /**
     * 运行定时任务检测通道是否断开
     * @param timeout 定时时间
     * @throws Exception
     */
    public void run(Timeout timeout) throws Exception {
        ChannelFuture future = null;

        /**
         * 设置绑定
         */
        //synchronized (this.boot) {
            if (this.boot instanceof ServerBootstrap) {
                ((ServerBootstrap) this.boot).childHandler(new ChannelInitializerExt());
                future = this.boot.bind(new InetSocketAddress(this.host, this.port));
            } else {
                this.boot.handler(new ChannelInitializerExt());
                future = ((Bootstrap) this.boot).connect(this.host, this.port);
            }
        //}
        /**
         * 监听通道连接
         */
        future.addListener(new ChannelFutureListener() {
            public void operationComplete(ChannelFuture channelFuture) throws Exception {
                boolean success = channelFuture.isSuccess();
                System.out.println("Retry channel connection "+(success ? "success" : "fail")+"("+counter.get()+"times).");
                if(!success){
                    channelFuture.channel().pipeline().fireChannelInactive();
                }
            }
        });
    }

    /**
     * 连接断开事件处理
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("Monitored channel will disconnection...");
        System.out.println("Monitored channel disconnected and will auto reconnect...");
        int times = this.counter.incrementAndGet();
        if(Constant.CH_RETRY_TIMES >= times){
            //逐步延长重试时间
            int timeout = 4 << times;
            this.timer.newTimeout(this, timeout, TimeUnit.MILLISECONDS);
        }
        //触发对下个断开事件的调用
        ctx.fireChannelInactive();
    }
    /**
     * 初始化器扩展
     */
    private class ChannelInitializerExt extends ChannelInitializer {
        //加入handler
        protected void initChannel(T t) throws Exception {
            ChannelHandler[] handlers = setMonitorHandlers();
            t.pipeline().addLast(handlers);
        }
    }
}

/**
 * @author andychen https://blog.51cto.com/14815984
 * @description：客户端监视器实现类
 */
@ChannelHandler.Sharable
public class ClientMonitorHandler extends ChannelMonitor {
    public ClientMonitorHandler(String host, int port, Timer timer, AbstractBootstrap boot) {
        super(host, port, timer, boot);
    }

    /**
     * 定义客户端处理器
     * @return
     */
    public ChannelHandler[] setMonitorHandlers() {
        int aLen = (Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.SEND_LEN ? 7 : 5);
        ChannelHandler[] handlers = new ChannelHandler[aLen];
        handlers[0] = this;//监听器本身也是Handler，这里也加入
        handlers[1] = new IdleStateHandler(0, Constant.HEART_BEAT_TIMEOUT+1,0, TimeUnit.SECONDS);
        handlers[2] = new ClientHeartbeatHandler();
        /**
         * 解决粘包半包问题办法一：字符分隔
         */
        //支持一：回车分隔
        if(Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.LINE_BASED){
            handlers[3] = new LineBasedFrameDecoder(Constant.DECODER_BYTE_MAX_LEN);
        }
        //支持二：自定义分隔符分隔
        if(Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.DELIMITER_BASED) {
            ByteBuf byteMark = Unpooled.copiedBuffer(Constant.CUSTOM_SPLIT_MARK.getBytes());
            handlers[3] = new DelimiterBasedFrameDecoder(Constant.DECODER_BYTE_MAX_LEN, byteMark);
        }
        /**
         * 解决粘包半包问题办法二：固定长度
         */
        if(Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.FIXED_LEN) {
            handlers[3] = new FixedLengthFrameDecoder(Constant.FIXED_LEN_SERVER_TXT.length());
        }
        /**
         * 解决粘包半包问题办法三：带长度
         */
        if(Constant.STICKUP_SOLUTION_TYPE == StickupSolutionType.SEND_LEN){
            handlers[3] = new LengthFieldPrepender(2);
            handlers[4] = new ProtoStuffEncoder(User.class);
            handlers[5] = new LineBasedFrameDecoder(Constant.DECODER_BYTE_MAX_LEN);
        }
        handlers[aLen-1] = new ClientChannelHandler();

        return handlers;
    }
}

/**
 * @author andychen https://blog.51cto.com/14815984
 * @description：定义被监视的ChannelHandler
 */
public interface MonitoredChannelHandler {
    /**
     * 设置被监视的ChannelHandler
     * @return
     */
    ChannelHandler[] setMonitorHandlers();
}


五、Protostuff编解码器部分

/**
 * @author andychen https://blog.51cto.com/14815984
 * @description：ProtoStuff解码器类
 */
public class ProtoStuffDecoder extends MessageToMessageDecoder {
    private final RuntimeSchema schema;
    public ProtoStuffDecoder(Class clazz) {
        this.schema = (RuntimeSchema) RuntimeSchema.createFrom(clazz);
    }

    /**
     * 自定义实现高效解码方法
     * @param channelHandlerContext 处理器上下文
     * @param byteBuf 缓冲对象
     * @param list 对象集合
     * @throws Exception
     */
    protected void decode(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf, List list) throws Exception {
        int length = byteBuf.readableBytes();
        if(0 < length){
            byte[] bytes = new byte[length];
            byteBuf.getBytes(byteBuf.readerIndex(), bytes, 0, length);
            T t = this.schema.newMessage();
            ProtostuffIOUtil.mergeFrom(bytes, t, this.schema);
            list.add(t);
        }
    }
}
 
  
 
  
/**
 * @author andychen https://blog.51cto.com/14815984
 * @description：序列化编码器
 */
public class ProtoStuffEncoder extends MessageToByteEncoder {
    private final RuntimeSchema schema;
    public ProtoStuffEncoder(Class clazz) {
        this.schema = (RuntimeSchema) RuntimeSchema.createFrom(clazz);
    }

    /**
     * 实现高效序列化方法
     * @param channelHandlerContext 处理器上下文
     * @param o 传输对象
     * @param byteBuf buffer缓冲
     * @throws Exception
     */
    protected void encode(ChannelHandlerContext channelHandlerContext, Object o, ByteBuf byteBuf) throws Exception {
       byte[] bytes = ProtostuffIOUtil.toByteArray((T)o, this.schema,
               LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE));
       byteBuf.writeBytes(bytes);
    }
}
 
  

 
  
六、其它协同工具
 
  
 
  
/**
 * @author andychen https://blog.51cto.com/14815984
 * @description：系统相关常量配置
 * 建议直接从全局应用配置文件中
 */
public class Constant {
    /**
     * 服务器端ip
     */
    public static final String SERV_HOST = "127.0.0.1";
    /**
     * 服务端监听端口
     */
    public static final int SERV_PORT = 6888;
    /**
     * 解码器处理字节最大长度
     */
    public static final int DECODER_BYTE_MAX_LEN = 1024;
    /**
     * 固定长度文本
     */
    public static final String FIXED_LEN_CLIENT_TXT = "Netty Client Fixed Len Text";
    /**
     * 固定长度文本
     */
    public static final String FIXED_LEN_SERVER_TXT = "Netty Server Fixed Len Text";
    /**
     * 自定义分隔标记
     */
    public static final String CUSTOM_SPLIT_MARK = "@#";
    /**
     * 粘包解决方法
     */
    public static final StickupSolutionType STICKUP_SOLUTION_TYPE = StickupSolutionType.LINE_BASED;
    /**
     * 心跳超时时间
     */
    public static final int HEART_BEAT_TIMEOUT = 4;
    /**
     * 服务端心跳
     */
    public static final String HEART_BEAT_SERV_MSG = "SERV_HEARTBEAT";
    /**
     * 客户端心跳
     */
    public static final String HEART_BEAT_CLIN_MSG = "CLIN_HEARTBEAT";
    /**
     * 通道重试次数
     */
    public static final int CH_RETRY_TIMES = 30;
}
 
  
 
  
/**
 * @author andychen https://blog.51cto.com/14815984
 * @description：粘包解决类型定义
 */
public enum StickupSolutionType{
    LINE_BASED(1, "回车分隔"),
    DELIMITER_BASED(2,"自定义分隔"),
    FIXED_LEN(4, "固定长度"),
    SEND_LEN(8, "带长度");


    public int getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }

    private final int code;
    private final String msg;
    StickupSolutionType(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }
}
 
  
运行结果
 
  
image.png
 
  
Netty网编程实战：四种解决粘包方式切换、两种生产级双向监听模式并行、高效编解码、多处理器协同作战_第5张图片
 
  
Netty网编程实战：四种解决粘包方式切换、两种生产级双向监听模式并行、高效编解码、多处理器协同作战_第6张图片
 
  
Netty网编程实战：四种解决粘包方式切换、两种生产级双向监听模式并行、高效编解码、多处理器协同作战_第7张图片
 
  
Netty网编程实战：四种解决粘包方式切换、两种生产级双向监听模式并行、高效编解码、多处理器协同作战_第8张图片
 
  

Netty网编程实战：四种解决粘包方式切换、两种生产级双向监听模式并行、高效编解码、多处理器协同作战_第9张图片
 
  
总结
 
  
基于Netty的网络编程高效性、稳定性、扩展性和易用性远不止于此，后面我们将陆续展示Netty在其它领域的应用和相关实战，给大家分享不同的网络编程场景体验与借鉴。
 
  

 
  

 
  

 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Netty,粘包拆包,心跳)

        

            

                
    
                    
  • Radius协议详解
                        靖节先生
基础框架网络协议java
                        
    Radius协议详解radius协议ruoyi-radiusRadius协议开源框架1.FreeRADIUS2.TinyRadius3.JRadius4.Radius4J5.Netty-Radius总结切换git指定tagradius协议802.1X认证原理描述https://support.huawei.com/enterprise/zh/doc/EDOC1100301697?section=j
    
                    
    • 
                    
  • 【Redis系列】Redis安装与使用
                        m0_74825409
面试学习路线阿里巴巴redis数据库缓存
                        
    ???欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。推荐:kwan的首页,持续学习,不断总结,共同进步,活到老学到老导航檀越剑指大厂系列:全面总结java核心技术点,如集合,jvm,并发编程redis,kafka,Spring,微服务,Netty等常用开发工具系列:罗列常用的开发工具,如IDE
    
                    
    • 
                    
  • RPC框架Dubbo深入分析
                        radcb55226
程序员rpcdubbo网络协议
                        
    《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！依赖于Zookeeper的稳定性Redis支持基于客户端双写的集群方式，性能高要求服务器时间同步，用于检查心跳过期脏数据Multicast去中心化，不需要安装注册中心依赖于网络拓普和路由，跨机房有风险SimpleDogfooding，注册中心本身也是一个标准的RPC服务没有集群支持，可能单点故障cl
    
                    
    • 
                    
  • Netty的ByteBuf为何如此高效？深入解析其设计与优势
                        星辰@Sea
系统架构JavaNettyJava
                        
    前言在高性能网络编程中，Netty因其卓越的性能和灵活性而被广泛应用。本文将深入探讨Netty的核心组件之一——ByteBuf的设计理念及其优势。部署准备一、JavaNIOBuffer的痛点在传统JavaNIO编程中，ByteBuffer存在以下缺陷：容量固定：初始化后无法自动扩容读写模式切换：需要调用flip()方法切换API复杂：position/limit等指针管理繁琐内存管理：直接内存需要
    
                    
    • 
                    
  • Netty如何优雅地解决TCP粘包、拆包问题
                        星辰@Sea
系统架构Javatcp/ip网络网络协议Netty
                        
    引言在TCP/IP协议族中，TCP（传输控制协议）是一个面向连接的、可靠的、基于字节流的传输层协议。TCP协议确保了数据能够可靠地从一个端点传输到另一个端点，但它并没有提供消息边界的概念。这意味着，当数据被发送时，可能会出现“粘包”（数据包被合并）或“拆包”（数据包被分割）的问题。这对开发人员来说是一个挑战，因为如果不正确处理这些问题，可能导致应用程序的逻辑错误或性能问题。在本文中，我们将深入探讨
    
                    
    • 
                    
  • vertx
                        三笠爷
vert.x
                        
    vert.x是reactive(响应式编程),是一种思想,特点:事件驱动(发挥单台机器的性能):单台机器上,用少量线程处理大量并发异步处理请求(多个服务间通信阻塞较少,响应时间降低):https://vertx.io/官网基于netty的、运行在jvm之上的、支持多种编程语言的高性能异步、非阻塞、响应式全栈javaweb框架eclipse软件基金会顶级java开源项目之一在techempower.
    
                    
    • 
                    
  • Netty UDP 客户端发消息后接收服务器信息
                        一顿敲代码的小朋
nettyjava
                        
    在本站大神的文章的基础上，加入了我的项目需求,当客户端用UDP给服务端发送消息后，接收到服务端返回的消息再关闭客户端。UdpServer.javaimportio.netty.bootstrap.Bootstrap;importio.netty.channel.ChannelOption;importio.netty.channel.EventLoopGroup;importio.netty.ch
    
                    
    • 
                    
  • ELK - Hearthbeat实现服务监控
                        如锋
ArchitectELKDevOpsELKHearthbeat服务监控KibanaUptime
                        
    Hearthbeat，心跳，顾名思义，Hearthbeat可以用来定时探测服务是否正常运行。Hearthbeat支持ICMP、TCP和HTTP，也支持TLS、身份验证和代理。Hearthbeat能够与Logstash、Elasticsearch和Kibana无缝协作。安装Hearthbeat，添加需要监控的服务，配置好Elasticsearch和Kibana，即可将结果输出到Elasticsear
    
                    
    • 
                    
  • fastadmin后台使用websocket
                        玉阳软件yuyangdev_cn
workerman
                        
    直接使用gatewayworker。在backend-init.js中：断线重连、心跳检测define(['backend'],function(Backend){varsocket;//websocket的实例varlockReconnect=false;//避免重复连接reconnect();functiongetwebsocket(){//新建websocket的函数页面初始化断开连接时重新
    
                    
    • 
                    
  • JAVA面试宝典：2020年程序员面试必备
                        Neo-ke

                        
    本文还有配套的精品资源，点击获取简介：Java面试宝典是求职或晋升的必备参考资料，涵盖了Java、Redis、SpringBoot、Netty、虚拟机、前端、SpringCloud、MySQL和RocketMQ等热门技术领域的最新知识。掌握这些知识点不仅有助于面试成功，还能提升专业技能，在IT行业保持竞争力。1.Java基础与核心技术Java作为一门面向对象的编程语言，在IT行业中广泛应用。本章将
    
                    
    • 
                    
  • JDK 官方迁移指南中文版（基于 JDK 8 → JDK 11 → JDK 17）
                        金州小铁匠
java开发语言
                        
    JDK官方迁移指南中文版（基于JDK8→JDK11→JDK17）一、迁移前的准备工作环境评估与兼容性检查操作系统支持：确保当前系统支持目标JDK版本。例如，JDK17要求Windows10/11、macOSBigSur或更高版本，以及主流Linux发行版。第三方依赖审查：检查项目中使用的框架（如SpringBoot）、工具（如Maven/Gradle）和库（如Netty、Lombok）是否兼容目标
    
                    
    • 
                    
  • 国标GB28181公网直播平台EasyGBS国标GB28181-2016标准中的应答命令消息体
                        EasyGBS
EasyGBS音视频GB28181视频监控安全
                        
    随着技术的不断进步，GB28181-2016标准中的应答命令消息体也在不断地拓展其功能。从最初的设备注册、心跳保活等基本功能，到如今的信息查询、报警事件通知、媒体流传输控制等多样化功能，应答命令消息体已经能够满足视频监控系统的各种需求。特别是在报警事件通知和分发流程中，应答命令消息体更是发挥了至关重要的作用。源设备可以通过应答命令消息体向SIP服务器通知报警信息，而SIP服务器则可以通过应答命令消
    
                    
    • 
                    
  • Netty解决TCP粘包拆包问题
                        is_Peng
Java基础javanettysocket网络通信网络
                        
    什么是TCP粘包/拆包TCP是一种面向连接的、可靠的、基于字节流的传输层通信协议。TCP是基于字节流传输的，就像河流一样，数据“流”式传输，数据中间没有分界。TCP底层并不了解上层业务数据的具体含义，它会根据TCP缓冲区的实际情况进行包的划分，所以一个完整的数据包可能会拆分成多个包传输，或者多个数据包可能会合并成一个包传输，这就是所谓的TCP的粘包/拆包问题。如下图所示：正常业务逻辑上，Clien
    
                    
    • 
                    
  • Spark源码分析
                        数据年轮
Sparkspark源码spark大数据源码分析
                        
    过程描述:1.通过Shell脚本启动Master，Master类继承Actor类，通过ActorySystem创建并启动。2.通过Shell脚本启动Worker，Worker类继承Actor类，通过ActorySystem创建并启动。3.Worker通过Akka或者Netty发送消息向Master注册并汇报自己的资源信息(内存以及CPU核数等)，以后就是定时汇报，保持心跳。4.Master接受消息
    
                    
    • 
                    
  • 分库分表后，有哪些查询问题？该如何解决？
                        码炫课堂-码哥
java面试题面试分库分表
                        
    作者简介：大家好，我是码炫码哥，前中兴通讯、美团架构师，现任某互联网公司CTO，兼职码炫课堂主讲源码系列专题代表作：《jdk源码&多线程&高并发》，《深入tomcat源码解析》，《深入netty源码解析》，《深入dubbo源码解析》，《深入springboot源码解析》，《深入spring源码解析》，《深入redis源码解析》等联系qq：184480602，加我进群，大家一起学习，一起进步，一起对
    
                    
    • 
                    
  • 2024Java零基础自学路线（Java基础、Java高并发、MySQL、Spring、Redis、设计模式、Spring Cloud）
                        ekskef_sef
面试学习路线阿里巴巴javaspringmysql
                        
    目录一、Java基础1、Java基础3、Java8新特性4、Java集合5、Java高并发6、Java代码实例二、MySQL数据库三、SpringBoot框架（35天）四、微服务SpringCloud四、Redis中间件五、MongoDB数据库六、Netty网络编程七、23种设计模式八、Dubbo九、JavaScript零基础入门十、Vue基础知识十一、数据结构与算法大家好，我是哪吒。现在网上的学
    
                    
    • 
                    
  • UDP协议转换TCP协议
                        在下陈平安
网络通信
                        
    UDP协议转换TCP协议项目背景：项目类似中间件作用是数据搬运，可以搬运文件，视频，音频。从互联网把数据搬运到内网中。有的时候拉取视频流数据的时候使用UDP拉取会存在丢包的情况通过TCP拉拉取视频流数据再通过UDP发送这样可以保证质量也能提高效率。着重说明协议转换使用的技术1.netty2.scoket过程描述测试利用两个视频开源平台LiveGBS一个放在内网中充当视频播放设备此处命名为SPA2一
    
                    
    • 
                    
  • 2024最强Java面试八股文（精简、纯手打）
                        m0_74823021
面试学习路线阿里巴巴java面试开发语言
                        
    2024最新最全国内大厂Java面试高频题库本小册内容涵盖：Java基础，JVM，多线程，数据库（MySQL/Redis）SSM，Dubbo，网络，MQ，Zookeeper，Netty，微服务，大数据，算法，项目，设计模式等，篇幅足足近2千页，大家面试前拿去提前刷刷，一、基础篇1.接口和抽象类的区别相似点：（1）接口和抽象类都不能被实例化（2）实现接口或继承抽象类的普通子类都必须实现这些抽象方法不
    
                    
    • 
                    
  • async-http-client使用示例
                        光芒再现0394
http网络协议网络
                        
    文章目录概要整体架构流程技术名词解释技术细节小结概要async-http-client是一个用于Java平台的高性能、非阻塞HTTP客户端库，它允许开发者以异步的方式发送HTTP请求并处理响应，从而提高应用程序的性能和响应性。主要特点异步处理：基于Netty框架实现，支持异步发送HTTP请求和处理响应，避免了传统同步请求中的阻塞。支持多种请求方法：支持GET、POST、PUT、DELETE等常见的
    
                    
    • 
                    
  • WebSocket通信中心跳机制的作用
                        ♚呜啦啦啦啦啦啦啦
websocket网络协议网络
                        
    心跳机制是WebSocket连接管理中的一个重要部分，用于确保连接的稳定性和可靠性。通过定期发送心跳消息并接收服务器的响应，可以有效地避免因网络问题导致的连接中断，并及时发现和处理连接异常情况。为什么有重连机制仍然需要心跳机制？虽然在连接中断后进行重连是一个重要的机制，但心跳（Heartbeat）机制依然有其不可替代的作用：1.及时发现连接问题心跳机制：通过定期发送心跳消息并接收确认响应，可以快速
    
                    
    • 
                    
  • Netty HTTP2 示例-响应式编程-013
                        ApiHug
ApiHugintellij-ideajavaspringspringboot
                        
    ApiHug×{Postman|Swagger|Api...}=快↑准√省↓GitHub-apihug/apihug.com:AllaboutheApihugapihug.com:有爱，有温度，有质量，有信任ApiHug-APIdesignCopilot-IntelliJIDEsPlugin|MarketplaceTheNextGenerationAPIDevelopmentPlatform-Ap
    
                    
    • 
                    
  • Reactor Netty TCP 服务器端-响应式编程-011
                        ApiHug
intellij-ideaspringspringbootApiHug
                        
    ApiHug×{Postman|Swagger|Api...}=快↑准√省↓GitHub-apihug/apihug.com:AllaboutheApihugapihug.com:有爱，有温度，有质量，有信任ApiHug-APIdesignCopilot-IntelliJIDEsPlugin|MarketplaceTheNextGenerationAPIDevelopmentPlatform-Ap
    
                    
    • 
                    
  • 面试官：谈谈你对IO多路复用的理解？
                        
java后端
                        
    “IO多路复用”是编程中常见的技术词汇，使用这种技术的框架有很多，如，Redis、Kafka、Netty、Nginx中都用到了此技术。那问题来了，什么是IO多路复用？它的具体实现技术有哪些？这些技术之间有什么区别？今天我们就来简单的探讨一下。1.什么是IO多路复用？IO多路复用技术是一种允许单个线程管理多个网络连接的技术，它使得服务器能够高效地处理大量的并发连接而不需要为每个连接创建一个独立的线程
    
                    
    • 
                    
  • 【分布式理论五】分布式调用（3）：服务注册与发现
                        roman_日积跬步-终至千里
分布式架构分布式
                        
    文章目录一.传统服务调用方式的局限性二.服务注册与发现1.服务注册中心的作用2.服务注册中心的可用性三、服务的健康检查与失效处理1.心跳检测机制2.失效服务的处理本文关键字：传统服务调用的局限性、服务中心的桥梁作用、服务的可用性服务注册与发现是微服务架构中的关键组件，它能够有效解决服务调用时的地址管理问题，提高系统的灵活性和可扩展性。通过合理的服务注册机制、负载均衡策略以及健康检测，分布式系统可以
    
                    
    • 
                    
  • 高级java每日一道面试题-2024年8月11日-网络篇-说一下TCP粘包是怎么产生的?
                        java我跟你拼了
java每日一道面试题网络javatcp/ip网络篇TCP粘包
                        
    如果有遗漏,评论区告诉我进行补充面试官:说一下TCP粘包是怎么产生的?我回答:在Java高级面试中，TCP粘包是一个常见的网络编程问题，它主要涉及到TCP协议的特性以及数据在网络中的传输方式。以下是对TCP粘包产生原因的详细解析：一、TCP粘包现象概述TCP粘包是指在网络传输中，由于TCP协议本身的特性，发送方发送的多个数据包在接收方可能会被合并成一个大的数据包接收，导致接收方无法准确区分每个数据
    
                    
    • 
                    
  • tcp粘包是怎么产生的？
                        m0_74009543
tcp/ip网络网络协议
                        
    什么是tcp粘包？发送方发送的多个数据包，到接收方缓冲区首尾相连，粘成一包，被接收。2、原因：发送端需要等缓冲区满才发送。如TCP协议默认使用Nagle算法可能会把多个数据包一次发送到接收方。接收方不及时接收缓冲区的包，造成多个包接收。如应用程读取缓存中的数据包的速度小于接收数据包的速度，缓存中的多个数据包会被应用程序当成一个包一次读取3、处理方法：发送方使用TCP_NODELAY选项来关闭Nag
    
                    
    • 
                    
  • tcp 粘包是怎么产生的？
                        复活的夜神月
tcp/ip网络网络协议
                        
    TCP粘包是指在传输过程中多个小数据包粘在一起，形成一个大数据包传输的现象。产生TCP粘包问题主要有以下几个方面：1.应用程序写入数据的速度快于发送数据的速度，这种情况下多次写入的小数据包可能会打包在一起发送（但并不一定）2.接收方缓冲区大小设置不合理，导致多个小数据包粘在一起传输，形成一个大数据包发送。3.通过虚拟通道传输数据，但通道并没有提供消息边界保护的机制，导致多个数据包合并成一个数据包发
    
                    
    • 
                    
  • 说一下 Tcp 粘包是怎么产生的？
                        众乐乐_2008
杂说tcp/ip网络网络协议
                        
    TCP粘包是什么？TCP粘包（TCPPacketMerging）是指多个小的数据包在TCP传输过程中被合并在一起，接收方读取时无法正确分辨数据边界，导致数据解析错误。TCP是流式协议，没有数据包的概念，它只是保证数据按照字节流的顺序传输，不保证接收方能按照原始发送时的数据边界来接收数据。因此，TCP可能会把多个数据包合并（粘包）或者拆分（拆包）。1.TCP粘包的两种情况（1）发送端导致的粘包当发送
    
                    
    • 
                    
  • 封装websocket支持断网重连和自动心跳
                        new code Boy
websocket网络协议网络
                        
    TS版本import{EventDispatcher}from'./dispatcher';exportclassWebSocketClientextendsEventDispatcher{//#socket链接privateurl='';//#socket实例privatesocket:WebSocket|null=null;//#重连次数privatereconnectAttempts=0;/
    
                    
    • 
                    
  • dubbo实战之一：准备和初体验，Java进阶
                        阿伦Java
javazookeeperrpc
                        
    org.apache.dubbodubbo-dependencies-bom${dubbo.version}pomimportio.nettynetty-all4.1.25.Finalorg.apache.dubbodubbo${dubbo.version}org.apache.dubbodubbo-dependencies-zookeeper${dubbo.version}pomorg.apac
    
                    
    • 
                                
  • 基本数据类型和引用类型的初始值
                                    3213213333332132
java基础
                                    
    package com.array;

/**
 * @Description 测试初始值
 * @author FuJianyong
 * 2015-1-22上午10:31:53
 */
public class ArrayTest {
    
	ArrayTest at;
	String str;
	byte bt;
	short s;
	int i;
	long
    
                                
    • 
                                
  • 摘抄笔记--《编写高质量代码：改善Java程序的151个建议》
                                    白糖_
高质量代码
                                    
            记得3年前刚到公司，同桌同事见我无事可做就借我看《编写高质量代码：改善Java程序的151个建议》这本书，当时看了几页没上心就没研究了。到上个月在公司偶然看到，于是乎又找来看看，我的天，真是非常多的干货，对于我这种静不下心的人真是帮助莫大呀。 
  
        看完整本书，也记了不少笔记
    
                                
    • 
                                
  • 【备忘】Django 常用命令及最佳实践
                                    dongwei_6688
django
                                    
    注意：本文基于 Django 1.8.2 版本 
  
生成数据库迁移脚本（python 脚本） 
python manage.py makemigrations polls 
 说明：polls 是你的应用名字，运行该命令时需要根据你的应用名字进行调整 
  
查看该次迁移需要执行的 SQL 语句（只查看语句，并不应用到数据库上）： 
python manage.p
    
                                
    • 
                                
  • 阶乘算法之一N! 末尾有多少个零
                                    周凡杨
java算法阶乘面试效率
                                    
                                     &n
    
                                
    • 
                                
  • spring注入servlet
                                    g21121
Spring注入
                                    
    传统的配置方法是无法将bean或属性直接注入到servlet中的，配置代理servlet亦比较麻烦，这里其实有比较简单的方法，其实就是在servlet的init()方法中加入要注入的内容： 
ServletContext application = getServletContext();
WebApplicationContext wac = WebApplicationContextUtil
    
                                
    • 
                                
  • Jenkins 命令行操作说明文档
                                    510888780
centos
                                    
     
假设Jenkins的URL为http://22.11.140.38:9080/jenkins/ 
 
 
 
基本的格式为 
 
java 
 
基本的格式为 
 
java -jar jenkins-cli.jar [-s JENKINS_URL] command [options][args] 
 
 
 
 
下面具体介绍各个命令的作用及基本使用方法 
 
 
 
1. &nb
    
                                
    • 
                                
  • UnicodeBlock检测中文用法
                                    布衣凌宇
UnicodeBlock
                                    
    /**  * 判断输入的是汉字  */ public static boolean isChinese(char c) {        Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);    
    
                                
    • 
                                
  • java下实现调用oracle的存储过程和函数
                                    aijuans
javaorale
                                    
      1.创建表：STOCK_PRICES 
   
  2.插入测试数据： 
   
  3.建立一个返回游标：  
PKG_PUB_UTILS 
   4.创建和存储过程：P_GET_PRICE 
  
   5.创建函数： 
   6.JAVA调用存储过程返回结果集 
JDBCoracle10G_INVO
    
                                
    • 
                                
  • Velocity Toolbox
                                    antlove
模板toolboxvelocity
                                    
    velocity.VelocityUtil 
package velocity;

import org.apache.velocity.Template;
import org.apache.velocity.app.Velocity;
import org.apache.velocity.app.VelocityEngine;
import org.apache.velocity.c
    
                                
    • 
                                
  • JAVA正则表达式匹配基础
                                    百合不是茶
java正则表达式的匹配
                                    
      
正则表达式;提高程序的性能,简化代码,提高代码的可读性,简化对字符串的操作 
  
正则表达式的用途; 
字符串的匹配

字符串的分割

字符串的查找

字符串的替换
 
  
  
  
正则表达式的验证语法 
    
  [a]    //[]表示这个字符只出现一次  ,[a] 表示a只出现一
    
                                
    • 
                                
  • 是否使用EL表达式的配置
                                    bijian1013
jspweb.xmlELEasyTemplate
                                    
            今天在开发过程中发现一个细节问题，由于前端采用EasyTemplate模板方法实现数据展示，但老是不能正常显示出来。后来发现竟是EL将我的EasyTemplate的${...}解释执行了，导致我的模板不能正常展示后台数据。 
        网
    
                                
    • 
                                
  • 精通Oracle10编程SQL(1-3)PLSQL基础
                                    bijian1013
oracle数据库plsql
                                    
    --只包含执行部分的PL/SQL块
--set serveroutput off
begin
  dbms_output.put_line('Hello,everyone!');
end;


select * from emp;

--包含定义部分和执行部分的PL/SQL块
declare
   v_ename varchar2(5);
begin
   select 
    
                                
    • 
                                
  • 【Nginx三】Nginx作为反向代理服务器
                                    bit1129
nginx
                                    
    Nginx一个常用的功能是作为代理服务器。代理服务器通常完成如下的功能： 
  
 
 接受客户端请求 
 将请求转发给被代理的服务器 
 从被代理的服务器获得响应结果 
 把响应结果返回给客户端 
 实例 
本文把Nginx配置成一个简单的代理服务器 
 
 对于静态的html和图片，直接从Nginx获取 
 对于动态的页面，例如JSP或者Servlet，Nginx则将请求转发给Res
    
                                
    • 
                                
  • Plugin execution not covered by lifecycle configuration: org.apache.maven.plugin
                                    blackproof
maven报错
                                    
    转：http://stackoverflow.com/questions/6352208/how-to-solve-plugin-execution-not-covered-by-lifecycle-configuration-for-sprin 
  
maven报错： 
Plugin execution not covered by lifecycle configuration: 
    
                                
    • 
                                
  • 发布docker程序到marathon
                                    ronin47
docker 发布应用
                                    
    1 发布docker程序到marathon 1.1 搭建私有docker registry 1.1.1 安装docker regisry 
docker pull docker-registry
docker run -t -p 5000:5000 docker-registry
 下载docker镜像并发布到私有registry 
docker pull consol/tomcat-8.0

    
                                
    • 
                                
  • java-57-用两个栈实现队列&&用两个队列实现一个栈
                                    bylijinnan
java
                                    
    
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

	/*
	 * Q 57 用两个栈实现队列
	 */

public class QueueImplementByTwoStacks {

	private Stack<Integer> stack1;
	pr
    
                                
    • 
                                
  • Nginx配置性能优化
                                    cfyme
nginx
                                    
    转载地址：http://blog.csdn.net/xifeijian/article/details/20956605 
  
大多数的Nginx安装指南告诉你如下基础知识——通过apt-get安装，修改这里或那里的几行配置，好了，你已经有了一个Web服务器了。而且，在大多数情况下，一个常规安装的nginx对你的网站来说已经能很好地工作了。然而，如果你真的想挤压出Nginx的性能，你必
    
                                
    • 
                                
  • [JAVA图形图像]JAVA体系需要稳扎稳打,逐步推进图像图形处理技术
                                    comsci
java
                                    
     
 
     对图形图像进行精确处理，需要大量的数学工具，即使是从底层硬件模拟层开始设计，也离不开大量的数学工具包，因为我认为，JAVA语言体系在图形图像处理模块上面的研发工作，需要从开发一些基础的，类似实时数学函数构造器和解析器的软件包入手，而不是急于利用第三方代码工具来实现一个不严格的图形图像处理软件...... 
 
  &nb
    
                                
    • 
                                
  • MonkeyRunner的使用
                                    dai_lm
androidMonkeyRunner
                                    
    要使用MonkeyRunner，就要学习使用Python，哎 
 
先抄一段官方doc里的代码 
作用是启动一个程序（应该是启动程序默认的Activity），然后按MENU键，并截屏 
 

# Imports the monkeyrunner modules used by this program
from com.android.monkeyrunner import MonkeyRun
    
                                
    • 
                                
  • Hadoop-- 海量文件的分布式计算处理方案
                                    datamachine
mapreducehadoop分布式计算
                                    
    csdn的一个关于hadoop的分布式处理方案，存档。 
原帖：http://blog.csdn.net/calvinxiu/article/details/1506112。 
 
    Hadoop 是Google MapReduce的一个Java实现。MapReduce是一种简化的分布式编程模式，让程序自动分布到一个由普通机器组成的超大集群上并发执行。就如同ja
    
                                
    • 
                                
  • 以資料庫驗證登入
                                    dcj3sjt126com
yii
                                    
    以資料庫驗證登入 
由於 Yii 內定的原始框架程式, 採用綁定在UserIdentity.php 的 demo 與 admin 帳號密碼:    public function authenticate()    {        $users=array( &nbs
    
                                
    • 
                                
  • github做webhooks：[2]php版本自动触发更新
                                    dcj3sjt126com
githubgitwebhooks
                                    
    上次已经说过了如何在github控制面板做查看url的返回信息了。这次就到了直接贴钩子代码的时候了。       
工具/原料  
 
   git   
   github   
     
方法/步骤  
 
       在github的setting里面的webhooks里把我们的url地址填进去。   
       钩子更新的代码如下： error_reportin
    
                                
    • 
                                
  • Eos开发常用表达式
                                    蕃薯耀
Eos开发Eos入门Eos开发常用表达式
                                    
    Eos开发常用表达式 
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
蕃薯耀 2014年8月18日 15:03:35 星期一 
  
  
&
    
                                
    • 
                                
  • SpringSecurity3.X--SpEL 表达式
                                    hanqunfeng
SpringSecurity
                                    
    使用 Spring 表达式语言配置访问控制，要实现这一功能的直接方式是在<http>配置元素上添加 use-expressions 属性： 
  
<http auto-config="true"  use-expressions="true"> 
这样就会在投票器中自动增加一个投票器：org.springframework
    
                                
    • 
                                
  • Redis vs Memcache
                                    IXHONG
redis
                                    
    1. Redis中，并不是所有的数据都一直存储在内存中的，这是和Memcached相比一个最大的区别。 
2. Redis不仅仅支持简单的k/v类型的数据，同时还提供list，set，hash等数据结构的存储。 
3. Redis支持数据的备份，即master-slave模式的数据备份。 
4. Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。 
Red
    
                                
    • 
                                
  • Python - 装饰器使用过程中的误区解读
                                    kvhur
JavaScriptjqueryhtml5css
                                    
    大家都知道装饰器是一个很著名的设计模式，经常被用于AOP(面向切面编程)的场景，较为经典的有插入日志，性能测试，事务处理，Web权限校验， Cache等。 
原文链接：http://www.gbtags.com/gb/share/5563.htm 
Python语言本身提供了装饰器语法（@），典型的装饰器实现如下：     
 
 @function_wrapper 
  de
    
                                
    • 
                                
  • 架构师之mybatis-----update 带case when 针对多种情况更新
                                    nannan408
case when
                                    
    1.前言. 
   如题. 
2. 代码. 
  

	<update id="batchUpdate" parameterType="java.util.List">
			<foreach collection="list" item="list" index=&
    
                                
    • 
                                
  • Algorithm算法视频教程
                                    栏目记者
Algorithm算法
                                    
    课程：Algorithm算法视频教程 
 
百度网盘下载地址： http://pan.baidu.com/s/1qWFjjQW 密码: 2mji 
 
 
程序写的好不好,还得看算法屌不屌！Algorithm算法博大精深。 
 一、课程内容： 
课时1、算法的基本概念 + Sequential search 
课时2、Binary search 
课时3、Hash table 
课时4、Algor
    
                                
    • 
                                
  • C语言算法之冒泡排序
                                    qiufeihu
c算法
                                    
    任意输入10个数字由小到大进行排序。 
代码： 
#include <stdio.h>
int main()
{
	int i,j,t,a[11];        /*定义变量及数组为基本类型*/
	for(i = 1;i < 11;i++){
		scanf("%d",&a[i]);     /*从键盘中输入10个数*/
	}
	for
    
                                
    • 
                                
  • JSP异常处理
                                    wyzuomumu
Webjsp
                                    
    1.在可能发生异常的网页中通过指令将HTTP请求转发给另一个专门处理异常的网页中: 
<%@ page errorPage="errors.jsp"%> 
  
2.在处理异常的网页中做如下声明： 
errors.jsp: 
<%@ page isErrorPage="true"%>，这样设置完后就可以在网页中直接访问exc
    
                                
    •