买糖买板栗
买糖买板栗

Netty源码解读

目录

 

netty版本：4.1.30.Final

四个基本事件

Selector是什么？

SelectionKey是什么？

NioServerSocketChannel源码

NioSocketChannel源码

NioEventLoop是什么？

netty服务端启动

服务端整体逻辑架构

参考文档：

netty版本：4.1.30.Final

 

四个基本事件

OP_READ = 1        00000001 读
OP_WRITE = 4       00000100 写
OP_CONNECT = 8     00001000 连接
OP_ACCEPT = 16     00010000 接受连接

如果一个SelectionKey感兴趣读，     那么其interestOps=00000001
如果一个SelectionKey感兴趣写，     那么其interestOps=00000100
如果一个SelectionKey感兴趣连接，   那么其interestOps=00001000
如果一个SelectionKey感兴趣接受连接，那么其interestOps=00010000

如果感兴趣多个事件：java运算符 与（&）、非（~）、或（|）、异或（^）

读\写：00000001 | 00000100 = 00000101

读\写\连接\接受连接：00000001 | 00000100 | 00001000 | 00010000 = 00011101

判断自己是否有关注某个事件：

int interestSet = selectionKey.interestOps();
 
boolean isInterestedAccept    = (interestSet & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT；
boolean isInterestedConnect   = (interestSet & SelectionKey.OP_CONNECT) == SelectionKey.OP_CONNECT;
boolean isInterestedInRead    = (interestSet & SelectionKey.OP_READ) == SelectionKey.OP_READ;
boolean isInterestedInWrite   = (interestSet & SelectionKey.OP_WRITE) == SelectionKey.OP_WRITE;

 

Selector是什么？

它是一个抽象类，看它一个子类：SelectorImpl，它维护了一个Set（可以在selector上面注册多个socketchannel，selector会给每个channel返回一个selectionKey，该selectionKey就是标识该channel注册在某一个selector上）

Selector几个重载的select()方法： 

  • select():阻塞到至少有一个通道在你注册的事件上就绪了。 
  • select(long timeout)：和select()一样，但最长阻塞事件为timeout毫秒。 
  • selectNow():非阻塞，只要有通道就绪就立刻返回（如果没有也立马返回）。
     

Selector的wakeUp方法：

  • 当发现任务队列里面没有任务要处理就会执行selector的阻塞方法select（timeout），如果这时候突然有外部线程调用channel去发送一个消息，那么netty会把改消息包装成一个任务放入队列，放入队列的时候netty会检测当前selector是否处于阻塞，如果是则调用wakeup方法让selector从阻塞中恢复过来进行loop的run方法执行。
     

SelectionKey是什么？

它是一个抽象类，看它一个子类：SelectionKeyImpl，看它的定义：

public class SelectionKeyImpl extends AbstractSelectionKey {
    final SelChImpl channel;
    public final SelectorImpl selector;
    private int index;
    private volatile int interestOps;
    private int readyOps;
    ......
}

可以看到，一个SelectionKey中包含一个channel、一个Selector、该channel感兴趣的事件集合interestOps，SelectionKey就是标识该channel注册在某一个selector上

 

NioServerSocketChannel源码


public class NioServerSocketChannel extends AbstractNioMessageChannel
        implements io.netty.channel.socket.ServerSocketChannel {


    @Override
    protected int doReadMessages(List buf) throws Exception {
        SocketChannel ch = javaChannel().accept();

        try {
            if (ch != null) {
                buf.add(new NioSocketChannel(this, ch));
                return 1;
            }
        } catch (Throwable t) {
            logger.warn("Failed to create a new channel from an accepted socket.", t);

            try {
                ch.close();
            } catch (Throwable t2) {
                logger.warn("Failed to close a socket.", t2);
            }
        }

        return 0;
    }

}

首先通过ServerSocketChannel的accept()方法接受新的客户端请求，如果SocketChannel不为空，则利用当前的NioServerSocketChannel、EventLoop和SocketChannel创建新的NioSocketChannel，并加入到List buf中，最后返回1，标识服务端读取消息成功，对于NioServerSocketChannel，它的读取操作就是接受客户端连接请求，创建NioSocketChannel对象。


 


NioSocketChannel源码



public class NioSocketChannel extends AbstractNioByteChannel implements io.netty.channel.socket.SocketChannel {
    
    @Override
    protected SocketChannel javaChannel() {
        return (SocketChannel) super.javaChannel();
    }

    @Override
    protected boolean doConnect(SocketAddress remoteAddress, SocketAddress localAddress) throws Exception {
        if (localAddress != null) {
            javaChannel().socket().bind(localAddress);
        }

        boolean success = false;
        try {
            boolean connected = javaChannel().connect(remoteAddress);
            if (!connected) {
                selectionKey().interestOps(SelectionKey.OP_CONNECT);
            }
            success = true;
            return connected;
        } finally {
            if (!success) {
                doClose();
            }
        }
    }
}



先调用javaChannel().socket().bind(localAddress)绑定本地地址，若成功则：调用javaChannel().connect(remoteAddress)发起TCP连接

  


NioEventLoop是什么？


nioEventloop其内部（父类）持有一个thread对象，而该nioEventloop的run方法正是由该线程执行的


nioEventloop还持有两个最重要的对象--selector和queue，前者就是我们的多路复用器，后者则是存放我们的任务队列


分析nioEventloop的run方法：


@Override
protected void run() {
    for (;;) {
        try {
            switch (selectStrategy.calculateStrategy(selectNowSupplier, hasTasks())) {
                case SelectStrategy.CONTINUE:
                    continue;
                case SelectStrategy.SELECT:
                    select(wakenUp.getAndSet(false));
                    if (wakenUp.get()) {
                        selector.wakeup();
                    }
                default:
            }

            cancelledKeys = 0;
            needsToSelectAgain = false;
            final int ioRatio = this.ioRatio;
            if (ioRatio == 100) {
                try {
                    processSelectedKeys();
                } finally {
                    // Ensure we always run tasks.
                    runAllTasks();
                }
            } else {
                final long ioStartTime = System.nanoTime();
                try {
                    processSelectedKeys();
                } finally {
                    // Ensure we always run tasks.
                    final long ioTime = System.nanoTime() - ioStartTime;
                    runAllTasks(ioTime * (100 - ioRatio) / ioRatio);
                }
            }
        } catch (Throwable t) {
            handleLoopException(t);
        }
        // Always handle shutdown even if the loop processing threw an exception.
        try {
            if (isShuttingDown()) {
                closeAll();
                if (confirmShutdown()) {
                    return;
                }
            }
        } catch (Throwable t) {
            handleLoopException(t);
        }
    }
}


    

  • 第一步：先看switch里面的：selectStrategy.calculateStrategy(selectNowSupplier, hasTasks())：这是一个返回Int类型值的方法：calculateStrategy()方法里面的实现：return hasTasks ? selectSupplier.get() : SelectStrategy.SELECT;如果任务队列不为空，返回selectSupplier.get()，这个是get()是：return NioEventLoop.this.selectNow()  --> this.selector.selectNow(),NioEventLoop是什么已经介绍过selector.selectNow()
    • 

  • 若第一步返回的是SelectStrategy.SELECT，switch走到select(wakenUp.getAndSet(false));这代表当前没有可执行的任务，这个方法里面有一个非常著名的解决netty空轮询的判断：判断是否触发了jdk的selector的空轮旬bug，主要原理就是发现每次selector从阻塞方法中醒来既没有任务也没有io时间且阻塞的时间也没到我们设置的时间，如果一直重复这样到达一定的阈值，则我们就rebuildselector。详细分析见我的：Selector空轮询
    • 

  • 若第一步返回的是：selector.selectNow()>0，继续看下面的代码再看看下面的processSelectedKeys();这是真正处理每个channel的Io事件的方法；跟进去看： 
        private void processSelectedKeysOptimized() {
        for (int i = 0; i < selectedKeys.size; ++i) {
            final SelectionKey k = selectedKeys.keys[i];
            // null out entry in the array to allow to have it GC'ed once the Channel close
            // See https://github.com/netty/netty/issues/2363
            selectedKeys.keys[i] = null;

            final Object a = k.attachment();

            if (a instanceof AbstractNioChannel) {
                processSelectedKey(k, (AbstractNioChannel) a);
            } else {
                @SuppressWarnings("unchecked")
                NioTask task = (NioTask) a;
                processSelectedKey(k, task);
            }

            if (needsToSelectAgain) {
                // null out entries in the array to allow to have it GC'ed once the Channel close
                // See https://github.com/netty/netty/issues/2363
                selectedKeys.reset(i + 1);

                selectAgain();
                i = -1;
            }
        }
    }
     
    遍历该EventLoop持有的selector的selectedKeys：最终调用的是：
     
    private void processSelectedKey(SelectionKey k, AbstractNioChannel ch) {
        final AbstractNioChannel.NioUnsafe unsafe = ch.unsafe();
        if (!k.isValid()) {
            final EventLoop eventLoop;
            try {
                eventLoop = ch.eventLoop();
            } catch (Throwable ignored) {
                return;
            }
            if (eventLoop != this || eventLoop == null) {
                return;
            }
            unsafe.close(unsafe.voidPromise());
            return;
        }

        try {
            int readyOps = k.readyOps();
            if ((readyOps & SelectionKey.OP_CONNECT) != 0) {
                int ops = k.interestOps();
                ops &= ~SelectionKey.OP_CONNECT;
                k.interestOps(ops);
                unsafe.finishConnect();
            }
            if ((readyOps & SelectionKey.OP_WRITE) != 0) {
                ch.unsafe().forceFlush();
            }
            if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {
                unsafe.read();
            }
        } catch (CancelledKeyException ignored) {
            unsafe.close(unsafe.voidPromise());
        }
    }
     
    这个就已经是我们熟悉的NIO中的类似操作读写连接事件的io
     处理逻辑里面还有一个else：processSelectedKey(k, task);暂时不看了，详情见：task执行
     
    • 



 


netty服务端启动


EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
    // 创建并初始化 Netty 服务端 Bootstrap 对象
    ServerBootstrap bootstrap = new ServerBootstrap();
    bootstrap.group(bossGroup, workerGroup);
    bootstrap.channel(NioServerSocketChannel.class);
    bootstrap.childHandler(new ChannelInitializer() {
        @Override
        public void initChannel(SocketChannel channel) throws Exception {
            ChannelPipeline pipeline = channel.pipeline();

            /**
             * 收到客户端请求后，先执行解码RpcDecoder，在进入RpcServerHandler执行
             * 执行完成后，由RpcEncoder编码后，返回给客户端
             */
            //我是RpcDecoder，属于ChannelInboundHandlerAdapter，先add先执行
            pipeline.addLast(new RpcDecoder(RpcRequest.class)); // 解码 RPC 请求

            //我是RpcEncoder，属于ChannelOutboundHandlerAdapter，先add却要后执行
            pipeline.addLast(new RpcEncoder(RpcResponse.class)); // 编码 RPC 响应

            //我是RpcServerHandler，属于ChannelInboundHandlerAdapter，先add先执行，所以我在RpcDecoder之后执行
            pipeline.addLast(new RpcServerHandler(handlerMap)); // 处理 RPC 请求
        }
    });
    bootstrap.option(ChannelOption.SO_BACKLOG, 1024);
    bootstrap.childOption(ChannelOption.SO_KEEPALIVE, true);
    // 获取 RPC 服务器的 IP 地址与端口号
    String[] addressArray = StringUtil.split(serviceAddress, ":");
    String ip = addressArray[0];
    int port = Integer.parseInt(addressArray[1]);
    // 启动 RPC 服务器
    ChannelFuture future = bootstrap.bind(ip, port).sync();
    // 注册 RPC 服务地址
    if (serviceRegistry != null) {
        for (String interfaceName : handlerMap.keySet()) {
            serviceRegistry.register(interfaceName, serviceAddress);
            LOGGER.debug("register service: {} => {}", interfaceName, serviceAddress);
        }
    }
    LOGGER.debug("server started on port {}", port);
    // 关闭 RPC 服务器
    future.channel().closeFuture().sync();
} finally {
    workerGroup.shutdownGracefully();
    bossGroup.shutdownGracefully();
}


从ChannelFuture future = bootstrap.bind(ip, port).sync()开始分析：调用的是：AbstractBootstrap.bind，最后调用AbstractBootstrap的这个方法：


private ChannelFuture doBind(final SocketAddress localAddress) {
        final ChannelFuture regFuture = initAndRegister();
        final Channel channel = regFuture.channel();
        if (regFuture.cause() != null) {
            return regFuture;
        }

        if (regFuture.isDone()) {
            // At this point we know that the registration was complete and successful.
            ChannelPromise promise = channel.newPromise();
            doBind0(regFuture, channel, localAddress, promise);
            return promise;
        } else {
            // Registration future is almost always fulfilled already, but just in case it's not.
            final PendingRegistrationPromise promise = new PendingRegistrationPromise(channel);
            regFuture.addListener(new ChannelFutureListener() {
                @Override
                public void operationComplete(ChannelFuture future) throws Exception {
                    Throwable cause = future.cause();
                    if (cause != null) {
                        // Registration on the EventLoop failed so fail the ChannelPromise directly to not cause an
                        // IllegalStateException once we try to access the EventLoop of the Channel.
                        promise.setFailure(cause);
                    } else {
                        // Registration was successful, so set the correct executor to use.
                        // See https://github.com/netty/netty/issues/2586
                        promise.registered();

                        doBind0(regFuture, channel, localAddress, promise);
                    }
                }
            });
            return promise;
        }
    }


看这里方法面的两个核心方法：initAndRegister()，以及doBind0()，先看initAndRegister():


    final ChannelFuture initAndRegister() {
        Channel channel = null;
        try {
            channel = channelFactory.newChannel();
            init(channel);
        } catch (Throwable t) {}

        ChannelFuture regFuture = config().group().register(channel);
    
        return regFuture;
    }


initAndRegister主要做三个事情：new channel、init channel、register channel


    

  • newChannel()：
     channelFactory是     
        public B channel(Class channelClass) {
        if (channelClass == null) {
            throw new NullPointerException("channelClass");
        }
        return channelFactory(new ReflectiveChannelFactory(channelClass));
    }
     这个方法是：bootstrap.channel(NioServerSocketChannel.class)，即channelFactory.newChannel()最终创建channel相当于调用默认构造函数new出一个 NioServerSocketChannel对象。NioServerSocketChannel的初始化还会涉及到newChannelPipeline等各种参数的初始化，后面再单独分析。
    • 

  • init(channel)：由于是服务端的channel的init，具体方法实现我们找到ServerBootstrap.init
       
    public class ServerBootstrap extends AbstractBootstrap {
    
    @Override
    void init(Channel channel) throws Exception {
        final Map, Object> options = options0();
        synchronized (options) {
            setChannelOptions(channel, options, logger);
        }

        final Map, Object> attrs = attrs0();
        synchronized (attrs) {
            for (Entry, Object> e: attrs.entrySet()) {
                @SuppressWarnings("unchecked")
                AttributeKey key = (AttributeKey) e.getKey();
                channel.attr(key).set(e.getValue());
            }
        }

        ChannelPipeline p = channel.pipeline();

        final EventLoopGroup currentChildGroup = childGroup;
        final ChannelHandler currentChildHandler = childHandler;
        final Entry, Object>[] currentChildOptions;
        final Entry, Object>[] currentChildAttrs;
        synchronized (childOptions) {
            currentChildOptions = childOptions.entrySet().toArray(newOptionArray(0));
        }
        synchronized (childAttrs) {
            currentChildAttrs = childAttrs.entrySet().toArray(newAttrArray(0));
        }

        p.addLast(new ChannelInitializer() {
            @Override
            public void initChannel(final Channel ch) throws Exception {
                final ChannelPipeline pipeline = ch.pipeline();
                ChannelHandler handler = config.handler();
                if (handler != null) {
                    pipeline.addLast(handler);
                }

                ch.eventLoop().execute(new Runnable() {
                    @Override
                    public void run() {
                        pipeline.addLast(new ServerBootstrapAcceptor(
                                ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
                    }
                });
            }
        });
    }
    
}
 
    重点看最后的p.addLast()向serverChannel的流水线处理器中加入了一个 ServerBootstrapAcceptor，从名字上就可以看出来，这是一个接入器，专门接受新请求，把新的请求扔给某个事件循环器。
     

  • register channel：
     这个ChannelFuture regFuture = config().group().register(channel)实际调用的是    NioEventLoop 中的register（实际是其父类SingleThreadEventLoop的对应方法）： 
    public abstract class SingleThreadEventLoop extends SingleThreadEventExecutor implements EventLoop {
    
    @Override
    public ChannelFuture register(Channel channel) {
        return register(new DefaultChannelPromise(channel, this));
    }

    @Override
    public ChannelFuture register(final ChannelPromise promise) {
        ObjectUtil.checkNotNull(promise, "promise");
        promise.channel().unsafe().register(this, promise);
        return promise;
    }
    
}
     
    这个promise.channel().unsafe().register(this, promise)实际是：AbstractUnsafe.register，后面代码没法理解了，后面再学吧
     
    • 


     
    

    服务端整体逻辑架构
    

    

                                                                      服务端 Netty Reactor 工作架构图
    

    Server 端包含 1 个 Boss NioEventLoopGroup 和 1 个 Worker NioEventLoopGroup。
    

    NioEventLoopGroup 相当于 1 个事件循环组，这个组里包含多个事件循环 NioEventLoop，每个 NioEventLoop 包含 1 个 Selector 和 1 个事件循环线程。
    

    每个 Boss NioEventLoop 循环执行的任务包含 3 步：
    

      

    • 轮询 Accept 事件。
      • 

    • 处理 Accept I/O 事件，与 Client 建立连接，生成 NioSocketChannel，并将 NioSocketChannel 注册到某个 Worker NioEventLoop 的 Selector 上。
      • 

    • 处理任务队列中的任务，runAllTasks。任务队列中的任务包括用户调用 eventloop.execute 或 schedule 执行的任务，或者其他线程提交到该 eventloop 的任务。
      • 

    

    每个 Worker NioEventLoop 循环执行的任务包含 3 步：
    

      

    • 轮询 Read、Write 事件。
      • 

    • 处理 I/O 事件，即 Read、Write 事件，在 NioSocketChannel 可读、可写事件发生时进行处理。
      • 

    • 处理任务队列中的任务，runAllTasks。
      • 

    

     
    

     
    

     
    

     
    

     
    

     
    

     
    

     
    

     
    

     
    

    参考文档：
    

      

    • Nioeventloop原理
      • 

    • netty源码分析之服务端启动全解析
      • 

    

     
    

     
    

     
    

     
    

     
    

     
    

     
    

     
    

     
    

     
    

     
    

     
    

     
    

     
    







    



    


    


    




    

    你可能感兴趣的:(netty,netty)
    

    

    

      

    • netty-简易聊天
2401_84046645
程序员java开发语言

      publicvoidsend(Stringtext){channel.writeAndFlush(Unpooled.copiedBuffer(text.getBytes()));}publicvoidcloseConnect(){send(“bye”);channel.close();}}classMyHandlerextendsChannelInboundHandlerAdapter{@Over
      

      • 

    • Netty权威指南：Netty总结-高性能与可靠性
Ty_1106
Nettyjava网络rpc

      第二十二章高性能之道22.1RPC调用性能模型分析22.1.1传统RPC调用性能差三宗罪：网络传输采用同步阻塞I/O导致经常性阻塞序列化性能差线程模型问题22.1.2I/O通信性能三要素传输：BIO、NIO或者AIO协议：HTTP公有协议，内部私有协议线程：数据报如何读取，Reactor线程模型22.2Netty高性能之道22.2.1异步非阻塞通信I/O多路复用技术22.2.2高效的Reactor
      

      • 

    • netty4源码阅读与分析---netty线程模型
红尘之一骑
javaNIOnetty源码阅读与分析

      本文主要说下我自己对netty线程模型的理解，以及这样的线程模型的好处。通俗的来讲，netty的线程模型描述的就是老板和员工的故事。老板(通常情况下是一个老板)负责接活，与客户沟通，协调(netty的accept),谈成后(通道建立)，他需要从员工中选出一位员工来负责处理后续具体的事宜(worker线程，这里我们有16位员工，编号1-16)，员工做事时按照任务的先后顺序进行处理，这样可以避免错乱，
      

      • 

    • 深度长文解析SpringWebFlux响应式框架15个核心组件源码
快乐非自愿
javaspring

      SpringWebFlux介绍SpringWebFlux是SpringFramework5.0版本引入的一个响应式Web框架，它与SpringMVC并存，提供了一种全新的编程范式，支持异步非阻塞的Web应用开发。WebFlux完全基于响应式编程模型，支持ReactiveStreams规范，可以在诸如Netty、Undertow以及Servlet3.1+容器上运行。WebFlux的核心控制器是Dis
      

      • 

    • Java网络编程：IO，NIO与Netty
坚持是一种态度
javajava网络编程NettyJavaIONIONIO与Netty

      Java网络编程：IO，NIO与NettyJava网络编程：IO，NIO与NettyJavaI/O相关概念同步与异步阻塞与非阻塞OIONIOAIOreactor模型proactor模型JavaIO应用场景Netty简介NIO与Netty生产使用Java网络编程：IO，NIO与Netty新公司新项目，项目需要在硬件和软件平台进行信息传递，具体来说使用Netty。硬件和软件使用socket连接，硬件作
      

      • 

    • java reactor模式例子_Netty Reactor模式实现原理详解
weixin_39923623
javareactor模式例子

      在前面的文章中(Reactor模型详解)，我们讲解了Reactor模式的各种演变形式，本文主要讲解的则是Netty是如何实现Reactor模式的。这里关于Netty实现的Reactor模式，需要说明的是，其实现的模式如下图所示：对于Netty使用的Reactor模式，其主要特点如下：使用一个线程作为mainReactor，专门用于监听客户端的连接事件，当获取到事件之后就将该事件交由Acceptor
      

      • 

    • Netty实战二-实现UDP的单播和广播(1)
2401_84048671
程序员udp网络协议网络

      publicclassAnswerHandlerextendsSimpleChannelInboundHandler{/应答的具体内容从常量字符串数组中取得，由nextQuote方法随机获取/privatestaticfinalString[]DICTIONARY={“一个男生暗恋一个女生很久了。一天自习课上，男生偷偷的传了小纸条给女生，上面写着“其实我注意你很久了”。不一会儿，女生传了另一张纸条
      

      • 

    • netty源码解读三（NioEventLoop）
orcharddd_real
nettyjavanetty

      NioEventLoop初始化EventExecutor类型的数组数组大小默认为cpu数量的两倍，遍历数组，通过newNioEventLoop(xxx)往数组中添加元素，NioEventLoop继承了EventExecutor；每次需要线程时，执行chooser的next方法从数组中取出一个线程；关键代码打开netty源码，找到example包下的EchoService类，追溯创建boss线程组和
      

      • 

    • Netty源码分析:NioEventLoopGroup
HelloWorld_EE
netty源码分析源代码nettyEventLoop

      Netty源码分析:NioEventLoopGroup在工作之余，看到自己公司的超哥（俞超）关于Netty的系列博文，讲解的很好，因此，自己在学习之余也跟了下源代码，来了解Netty，也做了相关的笔记，将形成系列博文，这是第一篇。超哥的博文地址在这里：http://www.jianshu.com/p/c5068caab217Netty版本：4.0.23.Final借用超哥的例子，一般服务端的代码如
      

      • 

    • netty-NioServerSocketChannel和boss NioEventLoopGroup 如何建立关系的
一个人的想法
javanetty

      一、EventLoopGroupbossGroup=newNioEventLoopGroup();EventLoopGroupworkerGroup=newNioEventLoopGroup();1、boss或者workerNioEventLoopGroup初始化完成了一个NioEventLoop数组（默认机器核数的2倍）所有NioEventLoop持有了同一个Executor调用execute时
      

      • 

    • 经验笔记：RPC与高性能NIO框架
漆黑的莫莫
计算机网络笔记rpcnio

      RPC与高性能NIO框架的经验笔记引言随着互联网技术的发展，分布式系统逐渐成为了现代软件架构的标准之一。在这种架构中，服务之间的通信变得尤为关键，而RPC（远程过程调用）作为一种服务间通信的方式，因其简便的使用方式和高效的性能表现而受到了广泛的关注。在实现RPC的过程中，选择合适的网络通信框架至关重要，尤其是那些基于NIO（非阻塞I/O）的高性能框架，如Netty。本文将首先介绍RPC的概念及其在
      

      • 

    • 基础学习之——Netty
北欧人写代码
学习网络服务器

      Netty是一个基于Java的网络通信框架，提供了一种简单、高效、可扩展的方式来开发网络服务器和客户端应用程序。Netty的设计目标是提供一种统一的异步编程模型，使得开发者能够轻松地编写可维护和可重用的代码。Netty的核心组件包括：Channel：网络通信的通道，可以用于读取、写入和关闭操作。EventLoop：负责处理I/O事件，包括接收、发送和处理数据。ChannelHandler：用于处理
      

      • 

    • Springboot-websocket实现及底层原理
No.Ada
深入项目底层原理springbootwebsocket后端

      引入依赖SpringBoot中的WebSocket依赖于SpringWebFlux模块，使用了ReactorNetty库来实现底层的WebSocket通信。org.springframework.bootspring-boot-starter-websocket服务端配置/***WebSocket配置类*/@ConfigurationpublicclassWebSocketConfig{/***注
      

      • 

    • 【Netty】实战：基于WebSocket的聊天室
马丁的代码日记
netty聊天室网络websockethttp

      本文将使用Netty快速实现一个聊天室应用，该应用基于WebSocket协议，用户可以在浏览器内聊天。实现过程很简单，就几步。一、处理Http请求packagecn.md.netty.websocket.groupchat;importio.netty.channel.*;importio.netty.handler.codec.http.*;importio.netty.handler.ssl.
      

      • 

    • 精通 Spring Cloud Feign：从理论到实战的通信优化之路
TopicOnline
springcloud

      一、服务间调用的几种方式使用SpringCloud开发微服务时，在服务消费者调用服务提供者时，底层通过HTTPClient的方式访问。但实际上在服务调用时，有主要以下来实现：使用JDK原生的URLConnection；Apache提供的HTTPClient；Netty提供的异步HTTPClient；Spring提供的RestTemplate。SpringCloud的SpringCloudOpenF
      

      • 

    • Dubbo与Netty
蹩脚的小三

      CodecCodecSupportAbstractCodecTransportCodecCodecAdapterDispacherChannelHandlersDispatcherAllDispatcherAllChannelHandlerChannelEventRunnableWrappedChannelHandlerChannelHandlerChannelHandlerAdapterChan
      

      • 

    • netty开发模拟qq斗地主
平平无奇的Coding Peasant
nettyqq斗地主

      为什么要搞这样一个项目满足自己的java网络多线程编程的欲望！因为之前一直都是搞web开发，服务器和客户端数据交流人家web服务器早就给你搞好了，比如tomcat,jetty...等等，其实之前脑子里就有想过--是否可以自己开发一个简单的类似tomcat的web服务器，这样做了的话，至少知道其实web开发是建立在网络多线程web服务器之上否则web开发无从谈起！市面上的书籍和互联网上的电子教材以及
      

      • 

    • Netty 知识目录
王小工
javajava

      Netty知识结构NettyBootstrap/ServerBootstrapNettyEventLoopGroup/EventLoopNettyChannelNettyChannelPipeline/ChannelHandlerNettyByteBufNettyTCPNettyUDPNettyHTTPNettyWebsocketNettySSL/TLS
      

      • 

    • elasticsearch简单介绍
甜美河边的钓鱼人
elasticsearch

      1、elasticsearch简单介绍elasticsearch是基于操作文档的搜索引擎，里面使用了netty，luncen相关技术。它可以用作站内搜索，也可以结合Logstash，kibana等技术进行日志收集分析，使用聚合技术可以进行各种数据的聚合，并且和kibana一起展示条形图，饼图，map地理分布等功能。1.1、elasticsearch的安装因为是练习用的，所以我直接使用windows
      

      • 

    • Netty UDP
王小工
javaudp网络协议网络javanio

      Netty在UDP（用户数据报协议，UserDatagramProtocol）通信中的应用非常广泛，特别是在对实时性要求较高、对数据准确性要求相对较低的场景中，如视频传输、语音通信等。以下是对Netty在UDP通信中的详细解析：一、UDP协议简介UDP是一种无连接的协议，它并不在通信双方之间建立连接，而是直接将数据包从发送端发送到接收端。UDP不保证数据包的可靠传输，也不保证数据包的顺序，因此其传
      

      • 

    • 【四、使用Netty编写UDP应用】
ThinkLess404
Netty网络编程udp网络协议网络

      编写UDP应用目标创建UDPServer创建ServerHandler创建UDP客户端创建客户端的Handler目标之前的章节我们学习了编码服务端，使用TCP通信，本章我们学习如何使用Netty构建一个UDP应用。创建UDPServerpackagecom.coman404.base;importcom.coman404.base.handler.UDPServerHandler;importio
      

      • 

    • linux部署jar项目报错_linux jar 服务
国家级做梦冠军
linux部署jar项目报错

      关于linuxjar服务的搜索结果问题linux重启netty服务一些问题，请大神进linux上部署netty架构的服务时我一般启动的时候用下面脚本nohupjava-jarxxx-xxx.jarstart80808888&关闭的时候杀进程就可以了。今天部署的时候启动服务就报userBind，于是我查...杨冬芳2019-12-0120:26:501161浏览量回答数0问题Linux下Tomcat
      

      • 

    • Spring Cloud全解析：网关之GateWay简介
拾光师
springcloudjava

      GateWay简介由于zuul升级为zuul2时，netflix公司内部出现了分歧，所以springcloud自己研发了一套网关gateway，提供一种简单有效的方式来对API进行路由，以及提供一些强大的过滤器功能，如：熔断、限流、重试等，基于WebFlux框架实现的，底层使用了高性能的Reactor模式通信框架Netty特性基于spring5和springboot2构建动态路由：能够匹配任何请求
      

      • 

    • Netty+WebSocket实现高并发网络编程
Sunny_yiyi
Java精英阶级JavaWebSocket网络websocket网络协议

      我们来实现一个Netty+WebSocket集成案例，由于Netty+WebSocket集成代码比较麻烦，我们可以利用目前开源的项目netty-websocket-spring-boot-starter轻松实现Netty和WebSocket的集成。我们搭建一个项目，项目叫seckill-message，用于处理通知用户抢单状态。1)pom.xmlorg.yeauty</groupId
      

      • 

    • Spring Boot 一个极简且完整的后台框架
搬砖养女人
数据库架构javaspringsqltomcat

      一个完整的极简后台框架，方便做小项目的时候可以快速开发。这里面多贴图片和代码，做个参考吧，代码可以下载下来自己看看，里面这套后台模板不错，喜欢的拿去。先放几张图imageimageimage项目介绍SpringBoot，实现了一个极简单的后台框架image小编提供免费的Java架构学习资料（里面有高可用、高并发、高性能及分布式、Jvm性能调优、Spring源码，MyBatis，Netty,Redi
      

      • 

    • netty编程
chenjunxu

      需要导包：netty-all-4.1.25.Final或者导入依赖：io.nettynetty-all4.1.25.Final定义一个server类：publicclassHelloServer{publicstaticvoidmain(String[]args){//定义一对线程组//主线程组,用于接受客户端的连接，但是不做任何处理，跟老板一样，不做事EventLoopGroupbossGrou
      

      • 

    • Simple RPC - 05 从零开始设计一个客户端（下）_ 依赖倒置和SPI
小小工匠
【SimpleRPC】rpc网络协议网络

      文章目录Pre概述依赖倒置原则与解耦设计与实现1.定义接口来隔离调用方与实现类2.实现类`DynamicStubFactory`3.调用方与实现类的解耦依赖注入与SPI的解耦依赖注入SPI（ServiceProviderInterface）总结PreSimpleRPC-01框架原理及总体架构初探SimpleRPC-02通用高性能序列化和反序列化设计与实现SimpleRPC-03借助Netty实现异
      

      • 

    • 使用Netty实现 WebSocket至Socket的消息转发服务
Leon-aHandler
websocket服务器网络协议nettyspringboot

      业务需求场景：通过网页发送指令至硬件设备，并在连接过程中能够接收来自硬件设备的实时参数信息中转服务器逻辑：服务器内实现了一个websocket服务端和一个socket客户端，设置全局保存的ChannelGroup进行消息的转发。项目框架使用的是Springboot代码地址：https://github.com/Leon-aHandler/Netty-relayDemo
      

      • 

    • Netty Websocket
王小工
javawebsocketjavanio

      一、WebSocket协议概述WebSocket是一种在单个TCP连接上进行全双工通信的协议。它允许服务端主动向客户端推送数据，从而实现了实时通信。WebSocket建立在HTTP之上，但与HTTP的轮询（Polling）和长轮询（LongPolling）相比，WebSocket只需一次握手，即可在客户端和服务器之间建立持久的连接，并通过这个连接进行双向数据传输。二、Netty框架简介Netty是
      

      • 

    • Netty 实现 WebSocket 协议
最业余的程序猿
nettywebsocket网络协议网络

      要使用Netty框架实现WebSocket服务端与客户端通信，你需要按照以下步骤进行：1、添加依赖首先，在你的项目中引入Netty和其WebSocket支持库的依赖。如果你使用Maven构建项目，可以在pom.xml文件中添加相应的依赖项。Maven:io.nettynetty-all4.1.77.Finalorg.springframework.bootspring-boot-starter-w
      

      • 

    • ios内付费
374016526
ios内付费

      近年来写了很多IOS的程序，内付费也用到不少，使用IOS的内付费实现起来比较麻烦，这里我写了一个简单的内付费包，希望对大家有帮助。
 
具体使用如下:
这里的sender其实就是调用者，这里主要是为了回调使用。
[KuroStoreApi kuroStoreProductId:@"产品ID" storeSender:self storeFinishCallBa
      

      • 

    • 20 款优秀的 Linux 终端仿真器
brotherlamp
linuxlinux视频linux资料linux自学linux教程

       
终端仿真器是一款用其它显示架构重现可视终端的计算机程序。换句话说就是终端仿真器能使哑终端看似像一台连接上了服务器的客户机。终端仿真器允许最终用户用文本用户界面和命令行来访问控制台和应用程序。（LCTT 译注：终端仿真器原意指对大型机-哑终端方式的模拟，不过在当今的 Linux 环境中，常指通过远程或本地方式连接的伪终端，俗称“终端”。）
你能从开源世界中找到大量的终端仿真器，它们
      

      • 

    • Solr Deep Paging(solr 深分页)
eksliang
solr深分页solr分页性能问题

      转载请出自出处：http://eksliang.iteye.com/blog/2148370
作者：eksliang(ickes) blg:http://eksliang.iteye.com/ 概述
长期以来，我们一直有一个深分页问题。如果直接跳到很靠后的页数，查询速度会比较慢。这是因为Solr的需要为查询从开始遍历所有数据。直到Solr的4.7这个问题一直没有一个很好的解决方案。直到solr
      

      • 

    • 数据库面试题
18289753290
面试题 数据库

      1.union ,union all
网络搜索出的最佳答案：
union和union all的区别是,union会自动压缩多个结果集合中的重复结果，而union all则将所有的结果全部显示出来，不管是不是重复。
Union：对两个结果集进行并集操作，不包括重复行，同时进行默认规则的排序；
Union All：对两个结果集进行并集操作，包括重复行，不进行排序；
2.索引有哪些分类？作用是
      

      • 

    • Android TV屏幕适配
酷的飞上天空
android

      先说下现在市面上TV分辨率的大概情况
两种分辨率为主
1.720标清，分辨率为1280x720.
屏幕尺寸以32寸为主，部分电视为42寸
2.1080p全高清，分辨率为1920x1080
屏幕尺寸以42寸为主，此分辨率电视屏幕从32寸到50寸都有
 
适配遇到问题，已1080p尺寸为例：
分辨率固定不变，屏幕尺寸变化较大。
如：效果图尺寸为1920x1080，如果使用d
      

      • 

    • Timer定时器与ActionListener联合应用
永夜-极光
java

      功能:在控制台每秒输出一次
 
代码:
package Main;
import javax.swing.Timer;
import java.awt.event.*;
public class T {
private static int count = 0;
public static void main(String[] args){ 
      

      • 

    • Ubuntu14.04系统Tab键不能自动补全问题解决
随便小屋
Ubuntu 14.04

      Unbuntu 14.4安装之后就在终端中使用Tab键不能自动补全，解决办法如下：
 
1、利用vi编辑器打开/etc/bash.bashrc文件（需要root权限）
sudo vi /etc/bash.bashrc
 接下来会提示输入密码
2、找到文件中的下列代码
#enable bash completion in interactive shells
#if
      

      • 

    • 学会人际关系三招 轻松走职场
aijuans
职场

      要想成功，仅有专业能力是不够的，处理好与老板、同事及下属的人际关系也是门大学问。如何才能在职场如鱼得水、游刃有余呢？在此，教您简单实用的三个窍门。
　　第一，多汇报
最近，管理学又提出了一个新名词“追随力”。它告诉我们，做下属最关键的就是要多请示汇报，让上司随时了解你的工作进度，有了新想法也要及时建议。不知不觉，你就有了“追随力”，上司会越来越了解和信任你。
　　第二，勤沟通
团队的力
      

      • 

    • 《O2O：移动互联网时代的商业革命》读书笔记
aoyouzi
读书笔记

      移动互联网的未来：碎片化内容+碎片化渠道=各式精准、互动的新型社会化营销。
 
O2O：Online to OffLine 线上线下活动
O2O就是在移动互联网时代，生活消费领域通过线上和线下互动的一种新型商业模式。
 
手机二维码本质：O2O商务行为从线下现实世界到线上虚拟世界的入口。
 
线上虚拟世界创造的本意是打破信息鸿沟，让不同地域、不同需求的人
      

      • 

    • js实现图片随鼠标滚动的效果
百合不是茶
JavaScript滚动属性的获取图片滚动属性获取页面加载

      1,获取样式属性值
top 与顶部的距离
left 与左边的距离
right 与右边的距离
bottom 与下边的距离
zIndex 层叠层次
 
  例子:获取左边的宽度,当css写在body标签中时
<div id="adver" style="position:absolute;top:50px;left:1000p
      

      • 

    • ajax同步异步参数async
bijian1013
jqueryAjaxasync

              开发项目开发过程中，需要将ajax的返回值赋到全局变量中，然后在该页面其他地方引用，因为ajax异步的原因一直无法成功，需将async:false，使其变成同步的。
        格式：
$.ajax({ type: 'POST', ur
      

      • 

    • Webx3框架（1）
Bill_chen
eclipsespringmaven框架ibatis

      Webx是淘宝开发的一套Web开发框架，Webx3是其第三个升级版本；采用Eclipse的开发环境，现在支持java开发；
采用turbine原型的MVC框架，扩展了Spring容器，利用Maven进行项目的构建管理，灵活的ibatis持久层支持，总的来说，还是一套很不错的Web框架。
Webx3遵循turbine风格，velocity的模板被分为layout/screen/control三部
      

      • 

    • 【MongoDB学习笔记五】MongoDB概述
bit1129
mongodb

      MongoDB是面向文档的NoSQL数据库，尽量业界还对MongoDB存在一些质疑的声音，比如性能尤其是查询性能、数据一致性的支持没有想象的那么好，但是MongoDB用户群确实已经够多。MongoDB的亮点不在于它的性能，而是它处理非结构化数据的能力以及内置对分布式的支持(复制、分片达到的高可用、高可伸缩)，同时它提供的近似于SQL的查询能力，也是在做NoSQL技术选型时，考虑的一个重要因素。Mo
      

      • 

    • spring/hibernate/struts2常见异常总结
白糖_
Hibernate

      
Spring
①ClassNotFoundException: org.aspectj.weaver.reflect.ReflectionWorld$ReflectionWorldException
缺少aspectjweaver.jar，该jar包常用于spring aop中
 
②java.lang.ClassNotFoundException: org.sprin
      

      • 

    • jquery easyui表单重置(reset)扩展思路
bozch
formjquery easyuireset

      在jquery easyui表单中 尚未提供表单重置的功能，这就需要自己对其进行扩展。
扩展的时候要考虑的控件有：
combo,combobox,combogrid,combotree,datebox,datetimebox
需要对其添加reset方法，reset方法就是把初始化的值赋值给当前的组件，这就需要在组件的初始化时将值保存下来。
在所有的reset方法添加完毕之后，就需要对fo
      

      • 

    • 编程之美-烙饼排序
bylijinnan
编程之美

      
package beautyOfCoding;
import java.util.Arrays;
/*
*《编程之美》的思路是：搜索+剪枝。有点像是写下棋程序：当前情况下，把所有可能的下一步都做一遍；在这每一遍操作里面，计算出如果按这一步走的话，能不能赢（得出最优结果）。
*《编程之美》上代码有很多错误，且每个变量的含义令人费解。因此我按我的理解写了以下代码：
*/

      

      • 

    • Struts1.X 源码分析之ActionForm赋值原理
chenbowen00
struts

      struts1在处理请求参数之前，首先会根据配置文件action节点的name属性创建对应的ActionForm。如果配置了name属性，却找不到对应的ActionForm类也不会报错，只是不会处理本次请求的请求参数。
如果找到了对应的ActionForm类，则先判断是否已经存在ActionForm的实例，如果不存在则创建实例，并将其存放在对应的作用域中。作用域由配置文件action节点的s
      

      • 

    • [空天防御与经济]在获得充足的外部资源之前,太空投资需有限度
comsci
资源

      
      这里有一个常识性的问题:
      地球的资源,人类的资金是有限的,而太空是无限的.....
      就算全人类联合起来,要在太空中修建大型空间站,也不一定能够成功,因为资源和资金,技术有客观的限制....
&
      

      • 

    • ORACLE临时表—ON COMMIT PRESERVE ROWS
daizj
oracle临时表

      ORACLE临时表 转
临时表：像普通表一样，有结构，但是对数据的管理上不一样，临时表存储事务或会话的中间结果集，临时表中保存的数据只对当前
会话可见，所有会话都看不到其他会话的数据，即使其他会话提交了，也看不到。临时表不存在并发行为，因为他们对于当前会话都是独立的。
创建临时表时，ORACLE只创建了表的结构（在数据字典中定义），并没有初始化内存空间，当某一会话使用临时表时，ORALCE会
      

      • 

    • 基于Nginx XSendfile+SpringMVC进行文件下载
denger
应用服务器Webnginx网络应用lighttpd

          在平常我们实现文件下载通常是通过普通 read-write方式，如下代码所示。
@RequestMapping("/courseware/{id}")
public void download(@PathVariable("id") String courseID, HttpServletResp
      

      • 

    • scanf接受char类型的字符
dcj3sjt126com
c

      /*
2013年3月11日22:35:54
目的：学习char只接受一个字符
*/
# include <stdio.h>
int main(void)
{
int i;
char ch;
scanf("%d", &i);
printf("i = %d\n", i);
scanf("%
      

      • 

    • 学编程的价值
dcj3sjt126com
编程

      发一个人会编程, 想想以后可以教儿女, 是多么美好的事啊, 不管儿女将来从事什么样的职业, 教一教, 对他思维的开拓大有帮助
 
像这位朋友学习:  
http://blog.sina.com.cn/s/articlelist_2584320772_0_1.html
 
VirtualGS教程 (By @林泰前): 几十年的老程序员，资深的
      

      • 

    • 二维数组（矩阵）对角线输出
飞天奔月
二维数组

      今天在BBS里面看到这样的面试题目,
 
1，二维数组（N*N），沿对角线方向，从右上角打印到左下角如N=4： 4*4二维数组 
{ 1 2 3 4 }
{ 5 6 7 8 }
{ 9 10 11 12 }
{13 14 15 16 }
打印顺序 
4
3 8
2 7 12
1 6 11 16
5 10 15
9 14
13
要
      

      • 

    • Ehcache（08）——可阻塞的Cache——BlockingCache
234390216
并发ehcacheBlockingCache阻塞

      可阻塞的Cache—BlockingCache
 
       在上一节我们提到了显示使用Ehcache锁的问题，其实我们还可以隐式的来使用Ehcache的锁，那就是通过BlockingCache。BlockingCache是Ehcache的一个封装类，可以让我们对Ehcache进行并发操作。其内部的锁机制是使用的net.
      

      • 

    • mysqldiff对数据库间进行差异比较
jackyrong
mysqld

        mysqldiff该工具是官方mysql-utilities工具集的一个脚本，可以用来对比不同数据库之间的表结构，或者同个数据库间的表结构
   如果在windows下，直接下载mysql-utilities安装就可以了，然后运行后，会跑到命令行下：
1） 基本用法
   mysqldiff --server1=admin:12345
      

      • 

    • spring data jpa 方法中可用的关键字
lawrence.li
javaspring

      spring data jpa 支持以方法名进行查询/删除/统计。
查询的关键字为find
删除的关键字为delete/remove (>=1.7.x)
统计的关键字为count (>=1.7.x)
 
修改需要使用@Modifying注解
@Modifying
@Query("update User u set u.firstna
      

      • 

    • Spring的ModelAndView类
nicegege
spring

      项目中controller的方法跳转的到ModelAndView类，一直很好奇spring怎么实现的？
/*
* Copyright 2002-2010 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* yo
      

      • 

    • 搭建 CentOS 6 服务器(13) - rsync、Amanda
rensanning
centos

      （一）rsync
Server端
# yum install rsync
# vi /etc/xinetd.d/rsync
service rsync
{
disable = no
flags = IPv6
socket_type = stream
wait 
      

      • 

    • Learn Nodejs 02
toknowme
nodejs

      （1）npm是什么
npm is the package manager for node
官方网站：https://www.npmjs.com/
npm上有很多优秀的nodejs包，来解决常见的一些问题，比如用node-mysql，就可以方便通过nodejs链接到mysql，进行数据库的操作
在开发过程往往会需要用到其他的包，使用npm就可以下载这些包来供程序调用
&nb
      

      • 

    • Spring MVC 拦截器
xp9802
spring mvc

      Controller层的拦截器继承于HandlerInterceptorAdapter
HandlerInterceptorAdapter.java  1  public   abstract   class  HandlerInterceptorAdapter  implements  HandlerIntercep
      

      •