MccreeFei
MccreeFei

Netty学习笔记

NIO

public class NIOServer {

    /*标识数字*/
    private  int flag = 0;
    /*缓冲区大小*/
    private  int BLOCK = 4096;
    /*接受数据缓冲区*/
    private  ByteBuffer sendbuffer = ByteBuffer.allocate(BLOCK);
    /*发送数据缓冲区*/
    private  ByteBuffer receivebuffer = ByteBuffer.allocate(BLOCK);
    private  Selector selector;

    public NIOServer(int port) throws IOException {
        // 打开服务器套接字通道
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        // 服务器配置为非阻塞
        serverSocketChannel.configureBlocking(false);
        // 检索与此通道关联的服务器套接字
        ServerSocket serverSocket = serverSocketChannel.socket();
        // 进行服务的绑定
        serverSocket.bind(new InetSocketAddress(port));
        // 通过open()方法找到Selector
        selector = Selector.open();
        // 注册到selector，等待连接
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("Server Start----8888:");
    }


    // 监听
    private void listen() throws IOException {
        while (true) {
            // 阻塞 直到有事件到达
            selector.select();
            // 返回此选择器的已选择键集。
            Set selectionKeys = selector.selectedKeys();
            Iterator iterator = selectionKeys.iterator();
            while (iterator.hasNext()) {
                SelectionKey selectionKey = iterator.next();
                iterator.remove();
                handleKey(selectionKey);
            }
        }
    }

    // 处理请求
    private void handleKey(SelectionKey selectionKey) throws IOException {
        // 接受请求
        ServerSocketChannel server = null;
        SocketChannel client = null;
        String receiveText;
        String sendText;
        int count=0;
        // 测试此键的通道是否已准备好接受新的套接字连接。
        if (selectionKey.isAcceptable()) {
            // 返回为之创建此键的通道。
            server = (ServerSocketChannel) selectionKey.channel();
            // 接受到此通道套接字的连接。
            // 此方法返回的套接字通道（如果有）将处于阻塞模式。
            client = server.accept();
            // 配置为非阻塞
            client.configureBlocking(false);
            // 注册到selector，等待连接
            client.register(selector, SelectionKey.OP_READ);
        } else if (selectionKey.isReadable()) {
            // 返回为之创建此键的通道。
            client = (SocketChannel) selectionKey.channel();
            //将缓冲区清空以备下次读取
            receivebuffer.clear();
            //读取服务器发送来的数据到缓冲区中
            count = client.read(receivebuffer);
            if (count > 0) {
                receiveText = new String( receivebuffer.array(),0,count);
                System.out.println("服务器端接受客户端数据--:"+receiveText);
                client.register(selector, SelectionKey.OP_WRITE);
            }
        } else if (selectionKey.isWritable()) {
            //将缓冲区清空以备下次写入
            sendbuffer.clear();
            // 返回为之创建此键的通道。
            client = (SocketChannel) selectionKey.channel();
            sendText="message from server--" + flag++;
            //向缓冲区中输入数据
            sendbuffer.put(sendText.getBytes());
            //将缓冲区各标志复位,因为向里面put了数据标志被改变要想从中读取数据发向服务器,就要复位
            sendbuffer.flip();
            //输出到通道
            client.write(sendbuffer);
            System.out.println("服务器端向客户端发送数据--："+sendText);
            client.register(selector, SelectionKey.OP_READ);
        }
    }

    /**
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        int port = 8888;
        NIOServer server = new NIOServer(port);
        server.listen();
    }
}

public class NIOClient {

    /*标识数字*/
    private static int flag = 0;
    /*缓冲区大小*/
    private static int BLOCK = 4096;
    /*接受数据缓冲区*/
    private static ByteBuffer sendbuffer = ByteBuffer.allocate(BLOCK);
    /*发送数据缓冲区*/
    private static ByteBuffer receivebuffer = ByteBuffer.allocate(BLOCK);
    /*服务器端地址*/
    private final static InetSocketAddress SERVER_ADDRESS = new InetSocketAddress(
            "localhost", 8888);

    public static void main(String[] args) throws IOException {
        // 打开socket通道
        SocketChannel socketChannel = SocketChannel.open();
        // 设置为非阻塞方式
        socketChannel.configureBlocking(false);
        // 打开选择器
        Selector selector = Selector.open();
        // 注册连接服务端socket动作
        socketChannel.register(selector, SelectionKey.OP_CONNECT);
        // 连接
        socketChannel.connect(SERVER_ADDRESS);
        // 分配缓冲区大小内存

        Set selectionKeys;
        Iterator iterator;
        SelectionKey selectionKey;
        SocketChannel client;
        String receiveText;
        String sendText;
        int count=0;

        while (true) {
            //选择一组键，其相应的通道已为 I/O 操作准备就绪。
            //此方法执行处于阻塞模式的选择操作。
            selector.select();
            //返回此选择器的已选择键集。
            selectionKeys = selector.selectedKeys();
            //System.out.println(selectionKeys.size());
            iterator = selectionKeys.iterator();
            while (iterator.hasNext()) {
                selectionKey = iterator.next();
                if (selectionKey.isConnectable()) {
                    System.out.println("client connect");
                    client = (SocketChannel) selectionKey.channel();
                    // 判断此通道上是否正在进行连接操作。
                    // 完成套接字通道的连接过程。
                    if (client.isConnectionPending()) {
                        client.finishConnect();
                        System.out.println("完成连接!");
                        sendbuffer.clear();
                        sendbuffer.put("Hello,Server".getBytes());
                        sendbuffer.flip();
                        client.write(sendbuffer);
                    }
                    client.register(selector, SelectionKey.OP_READ);
                } else if (selectionKey.isReadable()) {
                    client = (SocketChannel) selectionKey.channel();
                    //将缓冲区清空以备下次读取
                    receivebuffer.clear();
                    //读取服务器发送来的数据到缓冲区中
                    count=client.read(receivebuffer);
                    if(count>0){
                        receiveText = new String( receivebuffer.array(),0,count);
                        System.out.println("客户端接受服务器端数据--:"+receiveText);
                        client.register(selector, SelectionKey.OP_WRITE);
                    }

                } else if (selectionKey.isWritable()) {
                    sendbuffer.clear();
                    client = (SocketChannel) selectionKey.channel();
                    sendText = "message from client--" + (flag++);
                    sendbuffer.put(sendText.getBytes());
                    //将缓冲区各标志复位,因为向里面put了数据标志被改变要想从中读取数据发向服务器,就要复位
                    sendbuffer.flip();
                    client.write(sendbuffer);
                    System.out.println("客户端向服务器端发送数据--："+sendText);
                    client.register(selector, SelectionKey.OP_READ);
                }
            }
            selectionKeys.clear();
        }
    }
}

Buffer

NIO ByteBuffer

//重要属性
private int position;
private int limit;
private int capacity;

写模式时 position指向当前待写的索引处，limit和capacity都指向数组索引最大值+1处

Netty学习笔记_第1张图片
写模式

读模式 需要调用flip（）方法 

  public final Buffer flip() {
        limit = position;
        position = 0;
        mark = -1;
        return this;
    }

即position置为0,limit置为写模式下postion，标记最大可读位置。capacity不变表示此buffer内存数组最大容量。

Netty学习笔记_第2张图片
读模式

Netty ByteBuf

Neety ByteBuf不同于NIO ByteBuffer，ByteBuffer读写模式使用同一套索引，转换需要调用flip。而ByteBuf同时维护了两个索引：读索引和写索引，readIndex与writeIndex。有三种种类的buffer，堆缓冲/直接缓冲/混合缓冲

heap buffers

即在JVM堆中分配的字节数组，最普遍的缓冲形式，分配释放也较为廉价，一般使用方式：


Netty学习笔记_第3张图片
head buffers

direct buffers

直接缓存由JVM通过本地调用在对外进行分配，分配释放比heap buffers更为昂贵，但是效率高省去了一次拷贝，因为堆内存在socket中进行传输之前，都需要进行一次heap buffer 到 direct buffer的拷贝，使用方式：


Netty学习笔记_第4张图片
direct buffers

composite buffers

对各种ByteBuf的组合使用，相当于ByteBuf的容器，使用方式：


Netty学习笔记_第5张图片
composite buffers

引用计数 refCount

ByteBuf采用引用计数，ByteBuf被分配后reCount=1,调用retain()方法refCount+1,调用release()方法refCount-1.当refCount==0时代表ByeBuf生命周期已过，会被释放或者归池。调用refCount==0的ByteBuf将会抛出IllegalReferenceCountException。需要注意的是有些过程是netty内部帮助release的，比如SimpleChannelInboundHandler

 @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        boolean release = true;
        try {
            if (acceptInboundMessage(msg)) {
                @SuppressWarnings("unchecked")
                I imsg = (I) msg;
                channelRead0(ctx, imsg);
            } else {
                release = false;
                ctx.fireChannelRead(msg);
            }
        } finally {
            if (autoRelease && release) {
                ReferenceCountUtil.release(msg);
            }
        }
    }

默认构造器实现类autoRelease为true，channelRead0模板方法由用户进行实现，处理信息，处理完成后可以看到netty帮助释放了。
ByteBuf拷贝，copy()进行深拷贝即内部字节数组也会即你想嗯拷贝，duplicate()进行浅拷贝，只对readIndex和writeIndex进行拷贝，但共用同一个字节数组。同样readSlice()浅拷贝，readBytes()深拷贝。

Netty

Netty服务端典型代码：

final EchoServerHandler serverHandler = new EchoServerHandler();
        EventLoopGroup boosGroup = new NioEventLoopGroup(1);
        EventLoopGroup workGroup = new NioEventLoopGroup(3);
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(boosGroup, workGroup)
                    .channel(NioServerSocketChannel.class)
                    .localAddress(new InetSocketAddress(port))
                    .childHandler(new ChannelInitializer() {
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(serverHandler);
                        }
                    })
                    .childOption(ChannelOption.SO_KEEPALIVE, true);

            ChannelFuture f = b.bind().sync();
            System.out.println(EchoServer.class.getName() +
                    " started and listening for connections on " + f.channel().localAddress());
            f.channel().closeFuture().sync();
        } finally {
            boosGroup.shutdownGracefully().sync();
            workGroup.shutdownGracefully().sync();
        }

ServerSocketChannel初始化

ServerBootstrap中进行Channel等初始化工作实在bind()方法中进行的，一系列调用链后在initAndRegister()方法中进行ServerSocketChannel的初始化工作。

 final ChannelFuture initAndRegister() {
        Channel channel = null;
        try {
            channel = channelFactory.newChannel();
            init(channel);
        } catch (Throwable t) {
            if (channel != null) {
                // channel can be null if newChannel crashed (eg SocketException("too many open files"))
                channel.unsafe().closeForcibly();
                // as the Channel is not registered yet we need to force the usage of the GlobalEventExecutor
                return new DefaultChannelPromise(channel, GlobalEventExecutor.INSTANCE).setFailure(t);
            }
            // as the Channel is not registered yet we need to force the usage of the GlobalEventExecutor
            return new DefaultChannelPromise(new FailedChannel(), GlobalEventExecutor.INSTANCE).setFailure(t);
        }

        ChannelFuture regFuture = config().group().register(channel);
        if (regFuture.cause() != null) {
            if (channel.isRegistered()) {
                channel.close();
            } else {
                channel.unsafe().closeForcibly();
            }
        }

这里重要的是channel实例化和channel初始化两部操作，channelFactory.newChannel()使用Channel的反射工厂生成一个Channel实例。

private static ServerSocketChannel newSocket(SelectorProvider provider) {
        try {
            return provider.openServerSocketChannel();
        } catch (IOException e) {
            throw new ChannelException(
                    "Failed to open a server socket.", e);
        }
    }
    /**
     * Create a new instance
     */
    public NioServerSocketChannel() {
        this(newSocket(DEFAULT_SELECTOR_PROVIDER));
    }
    /**
     * Create a new instance using the given {@link SelectorProvider}.
     */
    public NioServerSocketChannel(SelectorProvider provider) {
        this(newSocket(provider));
    }
    /**
     * Create a new instance using the given {@link ServerSocketChannel}.
     */
    public NioServerSocketChannel(ServerSocketChannel channel) {
        super(null, channel, SelectionKey.OP_ACCEPT);
        config = new NioServerSocketChannelConfig(this, javaChannel().socket());
    }

使用默认provider构建了一个java nio的ServerSocketChannel实例，后再调用重载构造方法，设置感兴趣事件OP_ACCEPT用于监听客户端连接事件，构造器一直调用上层构造器，其中在父类AbstractCHannel中实例化Unsafe和Pipeline，Unsafe封装了Java底层的Socket操作，实际上是沟通 Netty 上层和 Java 底层的重要的桥梁。
实例化过程：

  • 调用 NioServerSocketChannel.newSocket(DEFAULT_SELECTOR_PROVIDER) 打开一个新的 Java NIO ServerSocketChannel

  • AbstractChannel(Channel parent) 中初始化 AbstractChannel 的属性:

    • parent 属性置为 null

    • unsafe 通过newUnsafe() 实例化一个 unsafe 对象, 它的类型是 AbstractNioMessageChannel#AbstractNioUnsafe 内部类

    • pipeline 是 new DefaultChannelPipeline(this) 新创建的实例.

  • AbstractNioChannel 中的属性:

    • SelectableChannel ch 被设置为 Java ServerSocketChannel, 即 NioServerSocketChannel#newSocket 返回的 Java NIO ServerSocketChannel.

    • readInterestOp 被设置为 SelectionKey.OP_ACCEPT

    • SelectableChannel ch 被配置为非阻塞的 ch.configureBlocking(false)

  • NioServerSocketChannel 中的属性:

    • ServerSocketChannelConfig config = new NioServerSocketChannelConfig(this, javaChannel().socket())

接下来是Channel的初始化工作：

@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));
                    }
                });
            }
        });
    }
 
 
init()方法中首先设置配置Options和Attributes，重点在于最后向Pipeline中添加一个ServerBootstrapAcceptor，ServerBootStrapAcceptor继承自ChannelInboundHandlerAdapter，核心是其中的channelRead()方法
 
 
@Override
        @SuppressWarnings("unchecked")
        public void channelRead(ChannelHandlerContext ctx, Object msg) {
            final Channel child = (Channel) msg;

            child.pipeline().addLast(childHandler);

            setChannelOptions(child, childOptions, logger);

            for (Entry, Object> e: childAttrs) {
                child.attr((AttributeKey) e.getKey()).set(e.getValue());
            }

            try {
                childGroup.register(child).addListener(new ChannelFutureListener() {
                    @Override
                    public void operationComplete(ChannelFuture future) throws Exception {
                        if (!future.isSuccess()) {
                            forceClose(child, future.cause());
                        }
                    }
                });
            } catch (Throwable t) {
                forceClose(child, t);
            }
        }
 
 
当有客户端连接时，连接后的SocketChannel会有Pipeline进行链式调用，于是就会调用该channelRead方法，首先将ServerBootStrap中配置的childHanlder添加到SocketChannel的Pipeline中，然后设置SocketChannel的Options和Attributes，最后将SocketChannel注册到workGroup，绑定到一个EventLoop上，完成整个ServerChannel初始化工作。
 
 
EventLoopGroup
 
 
 
  
 
   
 
    Netty学习笔记_第6张图片 
   
 
  
 
  

    image 
  
 
 
 
 
 
 
EventLoopGroup相当于线程池，EventLoop相当于线程池中的线程用于处理相关的IO事件。Server拥有两个线程池，bossGroup用于接受客户端连接事件，workGroup用于处理连接后SocketChannel产生的IO事件。一旦SocketChannel就绪就会在workGroup中进行注册，平均注册到一个EventLoop，此后该Channel就会与该EventLoop绑定，一个Channel对应一个EventLoop，但一个EventLoop可以对应多个Channel。
 
 
ChannelHandler
 
 
ChannelHandler为Netty消息的处理器，分为InboundChannelHandler和OutbountChannelHandler，对于Channel的read消息由InbountChannelHandler处理，write消息由OutbountChannelHandler处理。常见的几种处理器有ChannelInitializer是InbountChannelHandler，一般用于向Pipline中添加其他Handler，只会调用一次，完成后就会从Pipline中移除该Handler。Decoder和Encoder解码和编码器，Decoder为InbountHandler，Encoder为OutbountHandler。
 
 
ChannelPipline
 
 
一个Channel对应了一个CahnnelPipeline，维护保存了ChannelHandler的链式结构，具体如图：
 
 
 
 
 
  
 
   
 
    Netty学习笔记_第7张图片 
   
 
  
 
  

    ChannelPipeline 
  
 
 
 
 
ChannelContext
 
 
ChannelContext是对ChannelHandler的封装，在ChannelHandler添加进Pipeline时生成，其实Pipeline中的链式结构保存的是ChannelContext的双向链表，ChannelHandler是不知道所在Pipeline中前后ChannelHandler的，但ChannelContext保存有前后ChannelContext的索引。ChannelContext调用下一个处理器相关方法是以fire为开头的，比如context.fireChannelRead()即调用下一个处理器的channelRead操作。
 还有需要注意的是pipeline和channel调用write()都是从第一个outbount开始链式处理，但context调用write()是从当前context的下一个outbount开始链式处理。
 
 
//channel
   @Override
    public ChannelFuture write(Object msg) {
        return pipeline.write(msg);
    }
//pipeline
    @Override
    public final ChannelFuture write(Object msg) {
        return tail.write(msg);
    }
//context
        private void write(Object msg, boolean flush, ChannelPromise promise) {
            AbstractChannelHandlerContext next = findContextOutbound();
            final Object m = pipeline.touch(msg, next);
        ........
    }
     private AbstractChannelHandlerContext findContextOutbound() {
        AbstractChannelHandlerContext ctx = this;
        do {
            ctx = ctx.prev;
        } while (!ctx.outbound);
        return ctx;
    }

 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Netty学习笔记)

        

            

                
    
                    
  • Netty学习笔记(3) Netty进阶3 -聊天室
                        JWASX
Nettyjava开发语言后端
                        
    文章目录前言聊天室群聊1.思路2.代码1.handler，用于处理消息1.好友聊天消息处理器2.群聊消息处理器3.创建群消息处理器4.加入群聊消息处理器5.查看群成员消息处理器6.退出群消息处理器7.登陆消息处理器8.退出程序处理器2.消息类，用于发送返回1.AbstractResponseMessage2.ChatRequestMessage3.ChatResponseMessage4.Grou
    
                    
    • 
                    
  • Netty学习笔记
                        等待花开I
Netty学习网络服务器
                        
    Netty应用开发语雀链接1.引言1.1什么是Nettyhttps://netty.io/Nettyisanasynchronousevent-drivennetworkapplicationframeworkforrapiddevelopmentofmaintainablehighperformanceprotocolservers&clients.Netty是一个异步事件驱动的网络应用框架。用
    
                    
    • 
                    
  • Netty | 第1章 Java NIO 网络编程《Netty In Action》
                        多氯环己烷

                        
    前言参考资料：《NettyInAction》；B站《尚硅谷Netty视频教程》；本系列为Netty学习笔记，本篇介绍总结JavaNIO网络编程。Netty作为一个异步的、事件驱动的网络应用程序框架，也是基于NIO的客户、服务器端的编程框架。其对JavaNIO底层API进行了封装，因此有必要对Java网络编程做个大概了解。本篇将重点放在NIO网络编程模型上，对BIO及AIO仅做简要说明；1.Java
    
                    
    • 
                    
  • 04、Netty学习笔记—(黏包半包及协议设计解析)
                        长路 ㅤ   
#Nettyjavanetty黏包半包协议设计
                        
    文章目录一、粘包与半包1.1、现象分析1.1.1、粘包、半包情况分析1.1.2、滑动窗口、MSS限制、Nagle算法介绍1.2、粘包、半包现象复现1.2.1、粘包复现1.2.2、半包复现1.3、解决方案①短链接（连接、停止作为边界）②定长解码器（指定字节长度解码）③行解码器（分割符解决）④LTC解码器（基于长度字段的帧解码器，长度+内容组成）四个基础字段分析实际案例二、协议设计与解析2.1、red
    
                    
    • 
                    
  • Netty学习笔记：三、NIO零拷贝
                        象话
NettyNIO零拷贝mmap和sendfile零拷贝sendFile
                        
    1、传统IO4次上下文切换、4次内存拷贝上图中，上半部分表示用户态和内核态的上下文切换。下半部分表示数据复制操作。下面说说他们的步骤：read调用导致用户态到内核态的一次变化，同时，第一次复制开始：DMA（DirectMemoryAccess，直接内存存取，即不使用CPU拷贝数据到内存，而是DMA引擎传输数据到内存，用于解放CPU）引擎从磁盘读取index.html文件，并将数据放入到内核缓冲区。
    
                    
    • 
                    
  • Netty学习笔记
                        只因我实在是太美
学习笔记java
                        
    1.NIO基础non-blockingio，jdk1.4后新增1.1三大组件1.1.1Channel读写数据的双向通道，可以用channel将数据从buffer中读出，也可以将buffer的数据写入channel，而java的Stream流要么输入要么输出，常用的Channel有SocketChannel、ServerSocketChannel、FileChannel1.1.2BufferBuff
    
                    
    • 
                    
  • Netty学习笔记（四）Netty概述及传统阻塞 IO 、Reactor 模式线程模型
                        yangwen-bo
后端开发nettyjava多线程
                        
    原生NIO存在的问题1.NIO的类库和API繁杂，使用麻烦：需要熟练掌握Selector、ServerSocketChannel、SocketChannel、ByteBuffer等。2.需要具备其他的额外技能：要熟悉Java多线程编程，因为NIO编程涉及到Reactor模式，你必须对多线程和网络编程非常熟悉，才能编写出高质量的NIO程序。3.开发工作量和难度都非常大：例如客户端面临断连重连、网络闪
    
                    
    • 
                    
  • Netty学习笔记三-TCP粘包拆包
                        无聪帅

                        
    案例重现首先我们通过具体的case重现一下TCP粘包的过程我们模拟下故障场景，客户端循环一百次调用服务端传输报文，服务端接收报文并打印接收报文和计数，同时根据报文回应客户端服务端代码publicclassTimeServerHandlerextendsChannelHandlerAdapter{privateintcount;@OverridepublicvoidchannelRead(Chann
    
                    
    • 
                    
  • 【netty学习笔记八】IdleStateHandler心跳检测机制
                        月落亦莫离

                        
    在节点通信时，经常需要心跳机制来探测对方是否是存活的。在netty中，IdleStateHandler就能提供这种心跳检测功能。让我们先看看例子：服务端添加的handler.childHandler(newChannelInitializer(){@OverridepublicvoidinitChannel(SocketChannelch)throwsException{ChannelPipeli
    
                    
    • 
                    
  • Netty学习笔记
                        倩mys
Java学习笔记
                        
    文章目录1Netty2BIO1、介绍2、工作机制3、应用实例4、问题分析3NIO1、介绍2、BIOvs.VIO3、NIO三大核心原理4、Buffer缓冲区5、Channel通道6、Selector选择器7、NIO网络编程应用实例-群聊系统8、NIO与零拷贝9、AIO4Netty1、概述2、高性能架构设计3、Netty模型4、异步模型5、核心模块6、实例：群聊系统7、实例：心跳检测机制8、实例：We
    
                    
    • 
                    
  • Netty学习笔记(二)——netty组件及其用法
                        给我来一杯可乐
学习javajvm服务器网络
                        
    1、Netty是一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。原生NIO存在的问题1)NIO的类库和API繁杂，使用麻烦:需要熟练掌握Selector、ServerSocketChannel、SocketChannel、ByteBuffer等。2)需要具备其他的额外技能:要熟悉Java多线程编程，因为NIO编程涉及到Reactor模式，你必须对多线程和网络编程非
    
                    
    • 
                    
  • 用Java的BIO和NIO、Netty实现HTTP服务器(一) BIO与绪论
                        
javahttp
                        
    前言关于网络相关的文章已经写过很多了:[1]《计算机网络引论》[2]《计算机网络安全引论》[3]《NIO学习笔记(一)初遇》[4]《Socket简介和I/O多路复用》[5]《NIO学习笔记(二)相识篇》[6]《NIO学习笔记(三)甚欢篇》[7]《Netty学习笔记(一)初遇篇》[8]《HTTP/2.0的二进制是什么?》[9]《我们来聊聊HTTPS吧》[10]TCP学习笔记(三)可靠传输[11]HT
    
                    
    • 
                    
  • Netty学习笔记四-序列化
                        无聪帅

                        
    上一节学习了Netty的TCP拆包粘包问题的解决之道，今天学习Netty的序列化。什么是序列化引入百科：序列化(Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象Java的序列化Java原生API提供了对象的输入输出流ObjectIntputStre
    
                    
    • 
                    
  • Netty学习笔记五-LengthFieldBasedFrameDecoder源码分析
                        无聪帅

                        
    上一节中提到了对象反序列化解析器ObjectDecoder,ObjectDecoder是继承自LengthFieldBasedFrameDecoder，LengthFieldBasedFrameDecoder是Netty通用的拆包器LengthFieldBasedFrameDecoder用法LengthFieldBasedFrameDecoder源码解释中是这么说的：通过长度域lengthFiel
    
                    
    • 
                    
  • Netty学习笔记(三)Reactor线程模型
                        云师兄

                        
    单线程模型所有操作都在同一个NIO线程处理，在这个单线程中要负责接收请求，处理IO，编解码所有操作，相当于一个饭馆只有一个人，同时负责前台和后台服务，效率低。单线程模型多线程模型多线程的优点在于有单独的一个线程去处理请求，另外有一个线程池创建多个NIO线程去处理IO。相当于一个饭馆有一个前台负责接待，有很多服务员去做后面的工作，这样效率就比单线程模型提高很多。多线程模型主从线程模型多线程模型的缺点
    
                    
    • 
                    
  • Netty学习笔记六-ByteBuf学习
                        无聪帅

                        
    背景Java自带的NioByteBuffer具有局限性和操作的复杂性，主要缺点如下：1、ByteBuffer长度固定，一旦分配成功长度不能动态扩展和缩容，很容易发生越界异常。2、ByteBuffer只有一个标识位置的指针，读写切换时需要手工调用flip方法为了弥补这些不足，Netty作者重新造轮子，提供了自己实现的ByteBuf。ByteBuf原理ByteBuf也是通过字节数组byte[]作为缓冲
    
                    
    • 
                    
  • Netty学习笔记
                        渣渣苏
学习笔记NettyNIO
                        
    文章目录二、Netty入门2.1、概述2.1.1、Netty是什么？2.1.2、Netty的作者2.1.3、Netty的地位2.1.4、Netty的优势2.2、HelloWorld2.2.1、目标2.2.2、服务器端2.2.3、客户端2.2.4、流程梳理提示2.3、组件2.3.1、EventLoop优雅关闭演示NioEventLoop处理io事件handler执行中如何换人？演示NioEventL
    
                    
    • 
                    
  • netty学习笔记
                        silverbo1
nettynettyjava
                        
    io.nettyPART1Netty——异步和事件驱动1.netty概述Netty是一款异步的事件驱动的网络应用程序框架，支持快速地开发可维护的高性能的面向协议的服务器和客户端。在网络编程领域，Netty是Java的卓越框架。它驾驭了Java高级API的能力，并将其隐藏在一个易于使用的API之后。Netty使你可以专注于自己真正感兴趣的——你的应用程序的独一无二的价值。2.netty特性非阻塞网
    
                    
    • 
                    
  • Netty学习笔记（一）
                        Xiaoweidumpb
#Netty网络编程学习javajvm
                        
    NIO介绍字节流入门案例importlombok.extern.slf4j.Slf4j;importjava.io.FileInputStream;importjava.io.IOException;importjava.nio.ByteBuffer;importjava.nio.channels.FileChannel;@Slf4jpublicclassTestByteBuffer{public
    
                    
    • 
                    
  • Netty学习笔记之线程模型【上】
                        爪哇小白2021
Nettyrpcjava分布式
                        
    大家好，我是爪哇小白2021。半路出家的程序员，在从事开发之前在某省测绘院玩了一年的飞机，机缘巧合之下发现了更有趣的事情，从此步入了编程的世界…ps：同时也是一个热爱旅行的航拍小能手！目的：记录自己的学习历程，希望你看完之后，能对你有所帮助，不足请指正！共同学习交流NettyNetty对JDK自带的NIO的API进行了良好的封装，解决了上述问题。且Netty拥有高性能、吞吐量更高，延迟更低，减少资
    
                    
    • 
                    
  • 张龙netty学习笔记 P52 executor
                        不存在的里皮

                        
    线程工厂常规的线程逻辑是用Runnable或者Thread创建线程，然后调用start()。这个做法的缺点是，线程的行为和线程的创建绑定到了一起。所以最好是将线程的创建与它的任务解耦。ThreadPerTaskExecutor命令模式ThreadFactoryDefaultThreadFactoryExcutorSerialExecutorNioEventLoopGroup首先给出其类层次图跟踪N
    
                    
    • 
                    
  • Netty编解码开发+多协议开发和应用+源码+高级特性笔记免费送
                        java码农之路1
netty大数据java人工智能编程语言
                        
    目前Netty已经在互联网领域、电信领域、大数据领域、银行证券等金融领域、游戏行业、电力等企业市场已经大力应用了。网络通信框架Netty已经逐渐成为了构建高可用分布式系统核心组件通信的基础，它的线程模型、零拷贝和多协议支持也让从业者们爱不释手。今天分享的这份Netty学习笔记从JavaNIO讲起，再到Netty编解码开发，再到Netty多协议开发和应用，然后到Netty功能介绍和源码分析，最后讲述
    
                    
    • 
                    
  • Netty学习笔记
                        MccreeFei

                        
    NIOpublicclassNIOServer{/*标识数字*/privateintflag=0;/*缓冲区大小*/privateintBLOCK=4096;/*接受数据缓冲区*/privateByteBuffersendbuffer=ByteBuffer.allocate(BLOCK);/*发送数据缓冲区*/privateByteBufferreceivebuffer=ByteBuffer.al
    
                    
    • 
                    
  • Netty学习笔记：PoolChunk的内存分配策略
                        王白告龙

                        
    关键数据结构image.png对照上图，我们看一下相关数据结构PooledArena代表内存中一块连续区域，其内部有2个重要的数据结构tinySubpagePools/smallSubpagePools小于8KB的内存申请，优先从tinySubpagePools/smallSubpagePools数组中申请内存。如果subPages数组为空，则从PoolChunk申请内存。PoolChunkLis
    
                    
    • 
                    
  • Netty学习笔记(二)Channel的分类
                        云师兄

                        
    Channel分类在Netty中存在众多Channel类和接口，大致关系如下：Netty中Channel类图Channel：和JavaNio中的Channel同名，是Netty对网络底层读写和连接的抽象。AbstractChannel：是Channel的抽象实现类，抽象出了parent，id，unsafe，pipeline等概念。AbstractNioChannel：封装JavaNIO，通过Sel
    
                    
    • 
                    
  • Netty学习笔记(四)NioEventLoopGroup分析
                        云师兄

                        
    引子在上一篇文章中我们已经分析了Netty注册相关的逻辑，接下来再开看下NioEventLoopGroup这个类内部的相关构造。NioEventLoopGroup在之前的demo中第一行就是：EventLoopGroupbossGroup=newNioEventLoopGroup(1);这个NioEventLoopGroup类的构造函数最终实现如下：protectedMultithreadEven
    
                    
    • 
                    
  • Netty入门教程2——动手搭建HttpServer
                        追那个小女孩

                        
    上一篇：Netty学习笔记1——认识Netty在上一章中我们认识了netty，他有三大优点：并发高，传输快，封装好。在这一章我们来用Netty搭建一个HttpServer，从实际开发中了解netty框架的一些特性和概念。netty.png认识Http请求在动手写Netty框架之前，我们先要了解http请求的组成，如下图：HTTPrequestcomponentpartsHTTPRequest第一部
    
                    
    • 
                    
  • Netty学习笔记（1）
                        斯文遮阳

                        
    一、Netty介绍Netty是一款异步的事件驱动的网络应用程序框架，支持快速地开发可维护的高性能的面向协议的服务器和客户端，例如zookeeper、阿里的dubbo等。Netty的主要特性如下所示（吐槽下MD的表格。。）：分类Netty的特性设计统一的API，支持多种传输类型；阻塞的和非阻塞的简单而强大的线程模型；真正的无连接数据报套接字支持；链接逻辑组件以支持复用易于使用详实的Javadoc和大
    
                    
    • 
                    
  • Netty学习笔记（二）
                        dev_winner

                        
    原生NIO存在的问题：NIO的类库和API繁杂，使用麻烦：需要熟练掌握Selector、ServerSocketChannel、SocketChannel、ByteBuffer等。需要具备其他的额外技能：要熟悉Java多线程编程，因为NIO编程涉及到Reactor模式，你必须对多线程和网络编程非常熟悉，才能编写出高质量的NIO程序。开发工作量和难度都非常大：例如客户端面临断连重连、网络闪断、半包读
    
                    
    • 
                    
  • Netty学习笔记(一)初遇篇
                        

                        
    本篇的学习需要懂NIO的知识，不懂的可以参看下面的文章:NIO学习笔记(一)初遇NIO学习笔记(二)相识篇Socket简介和I/O多路复用NIO学习笔记(三)甚欢篇除此之外，还需要大概懂一点网络协议，比如HTTP。开始之前这里我们在复习一下简单的复习NIO的三个重要的核心知识点，Selector(选择器)、Channel(通道)、Buffer(缓冲区)。这三个概念是从I/O多路复用抽象而来,网络通
    
                    
    • 
                                
  • web前段跨域nginx代理配置
                                    刘正强
nginxcmsWeb
                                    
    nginx代理配置可参考server部分 
 
server { 
        listen       80; 
        server_name  localhost; 
 

    
                                
    • 
                                
  • spring学习笔记
                                    caoyong
spring
                                    
    一、概述 
    a>、核心技术 : IOC与AOP 
 b>、开发为什么需要面向接口而不是实现 
     接口降低一个组件与整个系统的藕合程度，当该组件不满足系统需求时，可以很容易的将该组件从系统中替换掉，而不会对整个系统产生大的影响 
 c>、面向接口编口编程的难点在于如何对接口进行初始化,(使用工厂设计模式) 
    
                                
    • 
                                
  • Eclipse打开workspace提示工作空间不可用
                                    0624chenhong
eclipse
                                    
    做项目的时候，难免会用到整个团队的代码，或者上一任同事创建的workspace， 
1.电脑切换账号后，Eclipse打开时，会提示Eclipse对应的目录锁定，无法访问，根据提示，找到对应目录，G:\eclipse\configuration\org.eclipse.osgi\.manager，其中文件.fileTableLock提示被锁定。 
解决办法，删掉.fileTableLock文件，重
    
                                
    • 
                                
  • Javascript 面向对面写法的必要性？
                                    一炮送你回车库
JavaScript
                                    
    现在Javascript面向对象的方式来写页面很流行，什么纯javascript的mvc框架都出来了：ember 
这是javascript层的mvc框架哦,不是j2ee的mvc框架 
  
我想说的是，javascript本来就不是一门面向对象的语言，用它写出来的面向对象的程序，本身就有些别扭，很多人提到js的面向对象首先提的是：复用性。那么我请问你写的js里有多少是可以复用的，用fu
    
                                
    • 
                                
  • js array对象的迭代方法
                                    换个号韩国红果果
array
                                    
    1.forEach 该方法接受一个函数作为参数， 对数组中的每个元素 
使用该函数  return 语句失效 
 

function square(num) {
print(num, num * num);
}
var nums = [1,2,3,4,5,6,7,8,9,10];
nums.forEach(square);
 
2.every 该方法接受一个返回值为布尔类型
    
                                
    • 
                                
  • 对Hibernate缓存机制的理解
                                    归来朝歌
session一级缓存对象持久化
                                    
    在hibernate中session一级缓存机制中，有这么一种情况： 
问题描述：我需要new一个对象，对它的几个字段赋值，但是有一些属性并没有进行赋值，然后调用 
session.save()方法，在提交事务后，会出现这样的情况： 
1：在数据库中有默认属性的字段的值为空 
2：既然是持久化对象，为什么在最后对象拿不到默认属性的值？ 
通过调试后解决方案如下： 
对于问题一，如你在数据库里设置了
    
                                
    • 
                                
  • WebService调用错误合集
                                    darkranger
webservice
                                    
     Java.Lang.NoClassDefFoundError: Org/Apache/Commons/Discovery/Tools/DiscoverSingleton   
调用接口出错， 
一个简单的WebService 
import org.apache.axis.client.Call;import org.apache.axis.client.Service; 
首先必不可
    
                                
    • 
                                
  • JSP和Servlet的中文乱码处理
                                    aijuans
Java Web
                                    
    JSP和Servlet的中文乱码处理 
前几天学习了JSP和Servlet中有关中文乱码的一些问题，写成了博客，今天进行更新一下。应该是可以解决日常的乱码问题了。现在作以下总结希望对需要的人有所帮助。我也是刚学，所以有不足之处希望谅解。 
一、表单提交时出现乱码： 
在进行表单提交的时候，经常提交一些中文，自然就避免不了出现中文乱码的情况，对于表单来说有两种提交方式：get和post提交方式。所以
    
                                
    • 
                                
  • 面试经典六问
                                    atongyeye
工作面试
                                    
    题记：因为我不善沟通，所以在面试中经常碰壁，看了网上太多面试宝典，基本上不太靠谱。只好自己总结，并试着根据最近工作情况完成个人答案。以备不时之需。 
 
以下是人事了解应聘者情况的最典型的六个问题： 
 
 
1 简单自我介绍  
 
关于这个问题，主要为了弄清两件事，一是了解应聘者的背景，二是应聘者将这些背景信息组织成合适语言的能力。 
 
我的回答：(针对技术面试回答，如果是人事面试，可以就掌
    
                                
    • 
                                
  • contentResolver.query()参数详解
                                    百合不是茶
androidquery()详解
                                    
    收藏csdn的博客,介绍的比较详细,新手值得一看 1.获取联系人姓名 
一个简单的例子，这个函数获取设备上所有的联系人ID和联系人NAME。    
[java]  
view plain 
copy       
 
 public void fetchAllContacts() {   
    
    
                                
    • 
                                
  • ora-00054:resource busy and acquire with nowait specified解决方法
                                    bijian1013
oracle数据库killnowait
                                    
            当某个数据库用户在数据库中插入、更新、删除一个表的数据，或者增加一个表的主键时或者表的索引时，常常会出现ora-00054:resource busy and acquire with nowait specified这样的错误。主要是因为有事务正在执行（或者事务已经被锁），所有导致执行不成功。 
1.下面的语句
    
                                
    • 
                                
  • web 开发乱码
                                    征客丶
springWeb
                                    
    以下前端都是 utf-8 字符集编码 
 
一、后台接收 
1.1、 get 请求乱码 
get 请求中，请求参数在请求头中； 
乱码解决方法： 
a、通过在web 服务器中配置编码格式：tomcat 中，在 Connector 中添加URIEncoding="UTF-8"； 
 
1.2、post 请求乱码 
post 请求中，请求参数分两部份， 
1.2.1、url？参数，
    
                                
    • 
                                
  • 【Spark十六】： Spark SQL第二部分数据源和注册表的几种方式
                                    bit1129
spark
                                    
    Spark SQL数据源和表的Schema 
 
  case class  
  apply schema  
  parquet  
  json  
 JSON数据源 准备源数据 
{"name":"Jack", "age": 12, "addr":{"city":"beijing&
    
                                
    • 
                                
  • JVM学习之:调优总结 -Xms -Xmx -Xmn -Xss
                                    BlueSkator
-Xss-Xmn-Xms-Xmx
                                    
      
堆大小设置JVM 中最大堆大小有三方面限制：相关操作系统的数据模型（32-bt还是64-bit）限制；系统的可用虚拟内存限制；系统的可用物理内存限制。32位系统下，一般限制在1.5G~2G；64为操作系统对内存无限制。我在Windows Server 2003 系统，3.5G物理内存，JDK5.0下测试，最大可设置为1478m。典型设置： 
 
 java -Xmx355
    
                                
    • 
                                
  • jqGrid 各种参数 详解(转帖)
                                    BreakingBad
jqGrid
                                    
      
jqGrid 各种参数 详解   分类： 
源代码分享 
个人随笔请勿参考 
解决开发问题 2012-05-09 20:29   84282人阅读   
评论(22)   
收藏   
举报   
jquery 
服务器 
parameters 
function 
ajax 
string      
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-代理模式-Proxy
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/*
 * 下面
    
                                
    • 
                                
  • 应用升级iOS8中遇到的一些问题
                                    chenhbc
ios8升级iOS8
                                    
    1、很奇怪的问题，登录界面，有一个判断，如果不存在某个值，则跳转到设置界面，ios8之前的系统都可以正常跳转，iOS8中代码已经执行到下一个界面了，但界面并没有跳转过去，而且这个值如果设置过的话，也是可以正常跳转过去的，这个问题纠结了两天多，之前的判断我是在 
-(void)viewWillAppear:(BOOL)animated 
 中写的，最终的解决办法是把判断写在 
-(void
    
                                
    • 
                                
  • 工作流与自组织的关系？
                                    comsci
设计模式工作
                                    
      目前的工作流系统中的节点及其相互之间的连接是事先根据管理的实际需要而绘制好的，这种固定的模式在实际的运用中会受到很多限制，特别是节点之间的依存关系是固定的，节点的处理不考虑到流程整体的运行情况，细节和整体间的关系是脱节的，那么我们提出一个新的观点，一个流程是否可以通过节点的自组织运动来自动生成呢？这种流程有什么实际意义呢？ 
 
  这里有篇论文，摘要是：“针对网格中的服务
    
                                
    • 
                                
  • Oracle11.2新特性之INSERT提示IGNORE_ROW_ON_DUPKEY_INDEX
                                    daizj
oracle
                                    
    insert提示IGNORE_ROW_ON_DUPKEY_INDEX 
 
转自：http://space.itpub.net/18922393/viewspace-752123 
 
在 insert into tablea ...select * from tableb中，如果存在唯一约束，会导致整个insert操作失败。使用IGNORE_ROW_ON_DUPKEY_INDEX提示，会忽略唯一
    
                                
    • 
                                
  • 二叉树:堆
                                    dieslrae
二叉树
                                    
        这里说的堆其实是一个完全二叉树,每个节点都不小于自己的子节点,不要跟jvm的堆搞混了.由于是完全二叉树,可以用数组来构建.用数组构建树的规则很简单: 
    一个节点的父节点下标为: (当前下标 - 1)/2 
    一个节点的左节点下标为: 当前下标 * 2 + 1 
  &
    
                                
    • 
                                
  • C语言学习八结构体
                                    dcj3sjt126com
c
                                    
    为什么需要结构体，看代码 
# include <stdio.h>

struct Student	//定义一个学生类型，里面有age, score, sex, 然后可以定义这个类型的变量
{
	int age;
	float score;
	char sex;
}

int main(void)
{
	struct Student st = {80, 66.6,
    
                                
    • 
                                
  • centos安装golang
                                    dcj3sjt126com
centos
                                    
    #在国内镜像下载二进制包 
wget -c  http://www.golangtc.com/static/go/go1.4.1.linux-amd64.tar.gz 
tar -C /usr/local -xzf go1.4.1.linux-amd64.tar.gz 
  
#把golang的bin目录加入全局环境变量 
cat >>/etc/profile<
    
                                
    • 
                                
  • 10.性能优化-监控-MySQL慢查询
                                    frank1234
性能优化MySQL慢查询
                                    
    1.记录慢查询配置 
show variables where variable_name like 'slow%' ; --查看默认日志路径 
查询结果：--不用的机器可能不同 
slow_query_log_file=/var/lib/mysql/centos-slow.log 
 
修改mysqld配置文件：/usr /my.cnf[一般在/etc/my.cnf，本机在/user/my.cn
    
                                
    • 
                                
  • Java父类取得子类类名
                                    happyqing
javathis父类子类类名
                                    
      
在继承关系中，不管父类还是子类，这些类里面的this都代表了最终new出来的那个类的实例对象，所以在父类中你可以用this获取到子类的信息！ 
  
package com.urthinker.module.test;

import org.junit.Test;

abstract class BaseDao<T> {
	public void 
    
                                
    • 
                                
  • Spring3.2新注解@ControllerAdvice
                                    jinnianshilongnian
@Controller
                                    
    @ControllerAdvice，是spring3.2提供的新注解，从名字上可以看出大体意思是控制器增强。让我们先看看@ControllerAdvice的实现： 
  
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Co
    
                                
    • 
                                
  • Java spring mvc多数据源配置
                                    liuxihope
spring
                                    
    转自：http://www.itpub.net/thread-1906608-1-1.html 
 
 
1、首先配置两个数据库 
 
<bean id="dataSourceA"         class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close&quo
    
                                
    • 
                                
  • 第12章 Ajax（下）
                                    onestopweb
Ajax
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • BW / Universe Mappings
                                    blueoxygen
BO
                                    
          
BW Element    
OLAP Universe Element      
Cube  Dimension    
Class      
Charateristic    
A class with dimension and detail objects (Detail objects for key and desription)      
Hi
    
                                
    • 
                                
  • Java开发熟手该当心的11个错误
                                    tomcat_oracle
java多线程工作单元测试
                                    
    #1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收 
测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目 可以在属性文件中配置，那么使它成为
    
                                
    • 
                                
  • 推行国产操作系统的优劣
                                    yananay
windowslinux国产操作系统
                                    
    最近刮起了一股风，就是去“国外货”。从应用程序开始，到基础的系统，数据库，现在已经刮到操作系统了。原因就是“棱镜计划”，使我们终于认识到了国外货的危害，开始重视起了信息安全。操作系统是计算机的灵魂。既然是灵魂，为了信息安全，那我们就自然要使用和推行国货。可是，一味地推行，是否就一定正确呢？ 
 
先说说信息安全。其实从很早以来大家就在讨论信息安全。很多年以前，就据传某世界级的网络设备制造商生产的交
    
                                
    •