Visonwu
Visonwu

Netty之Channel

分析的netty版本4.1.17

一、Channel

Netty的抽象了一个顶层接口Channel相比原来NIO提供的Channel有更多的功能，当然也是相对复杂的。

1. Channel的功能

1.1 网络的IO操作

网络的IO操作包含read,write,flush,close,disconnect,connect,bind,config,localAddress,remoteAdress等IO的功能操作。

1.2 其他功能

  • eventLoop():这个比较重要，channel是需要注册到eventLoop多路复用器上的，通过这个方法可以获取当前channel所注册的eventLoop；当然eventLoop除了处理IO操作还可以执行定时任务和自定义的NIOTask。

  • metadata()：在Netty中每一个channel都对应一个物理连接，这个元数据表示的就是每一个连接对应的TCP参数配置，通过这个方法可以获取相对应的配置信息。

  • parent():对于服务端Channel来讲，它的父channel是空，而客户端的channel，它的父channel就是创建它的ServerSocketChannel.

  • id():这个返回的是ChannelId对象，它是由mac地址，进程id，自增序列，系统时间数，随机数等构成的。

2.Channel结构和源码

2.1NioServerSocketChannel继承结构

YqoDb9.png

2.2 NioSocketChannel继承结构

YqoBDJ.png

简单的看看上面两个图的，做下对比：

两个相同之处很明显AbstractChannel---->AbstractNioChannel及DefaultAttributeMap

主要不同点是 NioSocketChannel继承的是AbstractNioByteChannel接口是SockerChannel;NioServerSocketChannle继承是的AbstractNioMessageChannle以及实现接口ServerSocketChannel

2.3 channel的生命周期

Netty 有一个简单但强大的状态模型，并完美映射到ChannelInboundHandler 的各个方法。下面是Channel 生命周期中四个不同的状态：

状态描述

  • channelUnregistered() :Channel已创建，还未注册到一个EventLoop上

  • channelRegistered(): Channel已经注册到一个EventLoop上

  • channelActive() :Channel是活跃状态（连接到某个远端），可以收发数据

  • channelInactive(): Channel未连接到远端

一个Channel 正常的生命周期如下图所示。随着状态发生变化相应的事件产生。这些事件被转发到ChannelPipeline中的ChannelHandler 来触发相应的操作。

image

2.4 相关源码

1）AbstractChannel

列出了主要的成员变量，和主要网络IO操作的实现

   重点看了下网络读写操作，网络I/O操作时讲到它会触发ChannelPipeline中对应的事件方法。Netty 基于事件驱动，我们也可以理解为当Chnanel进行I/O操作时会产生对应的I/O事件，然后驱动事件在ChannelPipeline中传播，由对应的ChannelHandler对事件进行拦截和处理，不关心的事件可以直接忽略。采用事件驱动的方式可以非常轻松地通过事件定义来划分事件拦截切面，方便业务的定制和功能扩展，相比AOP，其性能更高，但是功能却基本等价。

public abstract class AbstractChannel extends DefaultAttributeMap implements Channel {

    private static final InternalLogger logger = InternalLoggerFactory.getInstance(AbstractChannel.class);

    private static final ClosedChannelException FLUSH0_CLOSED_CHANNEL_EXCEPTION = ThrowableUtil.unknownStackTrace(
            new ClosedChannelException(), AbstractUnsafe.class, "flush0()");
    private static final ClosedChannelException ENSURE_OPEN_CLOSED_CHANNEL_EXCEPTION = ThrowableUtil.unknownStackTrace(
            new ClosedChannelException(), AbstractUnsafe.class, "ensureOpen(...)");
    private static final ClosedChannelException CLOSE_CLOSED_CHANNEL_EXCEPTION = ThrowableUtil.unknownStackTrace(
            new ClosedChannelException(), AbstractUnsafe.class, "close(...)");
    private static final ClosedChannelException WRITE_CLOSED_CHANNEL_EXCEPTION = ThrowableUtil.unknownStackTrace(
            new ClosedChannelException(), AbstractUnsafe.class, "write(...)");
    private static final NotYetConnectedException FLUSH0_NOT_YET_CONNECTED_EXCEPTION = ThrowableUtil.unknownStackTrace(
            new NotYetConnectedException(), AbstractUnsafe.class, "flush0()");

    private final Channel parent;     //父channel
    private final ChannelId id;        //channel 的唯一id
    private final Unsafe unsafe;     //unsafe底层io操作应用
    private final DefaultChannelPipeline pipeline;  //执行channel链
    private final VoidChannelPromise unsafeVoidPromise = new VoidChannelPromise(this, false);
    private final CloseFuture closeFuture = new CloseFuture(this);

    private volatile SocketAddress localAddress;  
    private volatile SocketAddress remoteAddress;
    private volatile EventLoop eventLoop;   //channel所注册的eventLoop
    private volatile boolean registered;       //变量是否完成注册
    private boolean closeInitiated;

    /** Cache for the string representation of this channel */
    private boolean strValActive;
    private String strVal;

    protected AbstractChannel(Channel parent) {
        this.parent = parent;
        id = newId();    
        unsafe = newUnsafe();
        pipeline = newChannelPipeline();
    }
  ...
    //主要的IO操作，发先都是通过pipeline事件传播实现
    @Override
    public ChannelFuture connect(SocketAddress remoteAddress, SocketAddress localAddress) {
        return pipeline.connect(remoteAddress, localAddress);
    }


   @Override
    public Channel flush() {
        pipeline.flush();
        return this;
    }

    @Override
    public ChannelFuture bind(SocketAddress localAddress, ChannelPromise promise) {
        return pipeline.bind(localAddress, promise);
    }

    @Override
    public ChannelFuture writeAndFlush(Object msg, ChannelPromise promise) {
        return pipeline.writeAndFlush(msg, promise);
    }

    @Override
    public Channel read() {
        pipeline.read();
        return this;
    }

2) AbstractNioChannel

会使用到nio的相关类，Selector做相关操作位的使用

public abstract class AbstractNioChannel extends AbstractChannel {

    private static final InternalLogger logger =
            InternalLoggerFactory.getInstance(AbstractNioChannel.class);

    private static final ClosedChannelException DO_CLOSE_CLOSED_CHANNEL_EXCEPTION = ThrowableUtil.unknownStackTrace(
            new ClosedChannelException(), AbstractNioChannel.class, "doClose()");

    private final SelectableChannel ch; //Socketchannle和ServerSocketChannel的公共操作类，用来设置SelectableChannel相关参数和IO操作
    protected final int readInterestOp;    //代表JDK的SelectionKey的OP_READ
    volatile SelectionKey selectionKey;  //JDK的selectionKey
    boolean readPending;
    private final Runnable clearReadPendingRunnable = new Runnable() {
        @Override
        public void run() {
            clearReadPending0();
        }
    };

    /**
     * The future of the current connection attempt.  If not null, subsequent
     * connection attempts will fail.
     */
    private ChannelPromise connectPromise; 
    private ScheduledFuture connectTimeoutFuture;   //连接超时定时器future
    private SocketAddress requestedRemoteAddress;   //请求通信地址

核心API
A：doRegister() ：定义一个布尔类型的局部变量selected来标识注册操作是否成功，调用nio的AbstractSelectableChannel的register方法，将当前的Channel注册到EventLoop的多路复用器selector上。

  //核心操作，注册操作

 //1) 如果当前注册返回的selectionKey已经被取消，则抛出CancelledKeyException异常，捕获该异常进行处理。
// 2) 如果是第一次处理该异常，调用多路复用器的selectNow()方法将已经取消的selectionKey从多路复用器中删除掉。操作成功之后，将selected置为true， 说明之前失效的selectionKey已经被删除掉。继续发起下一次注册操作，如果成功则退出,
//3) 如果仍然发生CancelledKeyException异常,说明我们无法删除已经被取消的selectionKey,按照JDK的API说明，这种意外不应该发生。如果发生这种问题，则说明可能NIO的相关类库存在不可恢复的BUG,直接抛出CancelledKeyException异常到上层进行统一处理。

  
    protected void doRegister() throws Exception {
        boolean selected = false;
        for (;;) {
            try {
                selectionKey = javaChannel().register(eventLoop().unwrappedSelector(), 0, this);
                return;
            } catch (CancelledKeyException e) {
                if (!selected) {
                    // Force the Selector to select now as the "canceled" SelectionKey may still be
                    // cached and not removed because no Select.select(..) operation was called yet.
                    eventLoop().selectNow();
                    selected = true;
                } else {
                    // We forced a select operation on the selector before but the SelectionKey is still cached
                    // for whatever reason. JDK bug ?
                    throw e;
                }
            }
        }
    }

}

channel注册时候通过操作位表示对某个事件感兴趣：

//SelectionKey
public static final int OP_READ = 1 << 0;   //读操作位
public static final int OP_WRITE = 1 << 2;  //写操作位
public static final int OP_CONNECT = 1 << 3;  //客户端连接操作位
public static final int OP_ACCEPT = 1 << 4;  //服务端接受连接操作位

//如果注册的操作位为0表示只是完成注册功能，说明对任何事件都不感兴趣

注册时可以指定附件，后续获取到事件通知时可以从SelectionKey中获取到附件，上面是将当前AbstractNioSocket实现子类自身当做附件，如果注册成功则可以通过返回的SelectionKey从多路复用器中获取channel对象。

B:doBeginRead() 读之前的准备

  @Override
    protected void doBeginRead() throws Exception {
        // Channel.read() or ChannelHandlerContext.read() was called
        final SelectionKey selectionKey = this.selectionKey;
        if (!selectionKey.isValid()) {
            return;   //key无效的话直接返回
        }

        readPending = true;  //表示读pending中

        final int interestOps = selectionKey.interestOps();
        if ((interestOps & readInterestOp) == 0) {  //表示当前没有读操作位
            selectionKey.interestOps(interestOps | readInterestOp);  //设置读操作位
        }

    
    }

  //SelectionKey中定义的是否可读操作
  public final boolean isReadable() {
        return (readyOps() & OP_READ) != 0;
    }

3) AbstractNioByteChannel

先看成员变量

public abstract class AbstractNioByteChannel extends AbstractNioChannel {
    private static final ChannelMetadata METADATA = new ChannelMetadata(false, 16);
    private static final String EXPECTED_TYPES =
            " (expected: " + StringUtil.simpleClassName(ByteBuf.class) + ", " +
            StringUtil.simpleClassName(FileRegion.class) + ')';

    private Runnable flushTask;  //flush工作的task任务,主要是继续写半包消息

}

接下来看核心API doWrite操作

配置中设置循环次数是避免半包中数据量过大，IO线程一直尝试写操作，此时IO线程无法处理其他IO操作或者定时任务，比如新的消息或者定时任务，如果网络IO慢或者对方读取慢等造成IO线程假死的状态

    @Override
    protected void doWrite(ChannelOutboundBuffer in) throws Exception {
        int writeSpinCount = -1; //        写自选次数

        boolean setOpWrite = false;  //写操作位为0
        for (;;) {
            Object msg = in.current();
            if (msg == null) {  //从环形数组ChannelOutboundBuffer弹出一条消息，如果为null，表示消息已经发送完成，
                // Wrote all messages.
                clearOpWrite();  //清除写标志位，退出循环
                // Directly return here so incompleteWrite(...) is not called.
                return;
            }

            if (msg instanceof ByteBuf) {
                ByteBuf buf = (ByteBuf) msg;
                int readableBytes = buf.readableBytes();
                if (readableBytes == 0) { //如果可读字节为0，则丢弃该消息，循环处理其他消息
                    in.remove();
                    continue;
                }

                boolean done = false;    //消息是否全部发送完毕表示
                long flushedAmount = 0;  //发送的字节数量
                if (writeSpinCount == -1) {
                    //如果为-1的时候从配置中获取写循环次数
                    writeSpinCount = config().getWriteSpinCount();
                }
                for (int i = writeSpinCount - 1; i >= 0; i --) {
                    int localFlushedAmount = doWriteBytes(buf);  //由子类实现写
                    if (localFlushedAmount == 0) {  //这里表示本次发送字节为0，发送TCP缓冲区满了，所以此时为了避免空循环一直发送，这里就将半包写表示设置为true并退出循环
                        setOpWrite = true;
                        break;
                    }
                    //发送成功就对发送的字节计数
                    flushedAmount += localFlushedAmount;
                    if (!buf.isReadable()) { //如果没有可读字节，表示已经发送完毕
                        done = true; //表示发送完成，并退出循环
                        break;
                    }
                }
                //通知promise当前写的进度
                in.progress(flushedAmount); 

                if (done) {  //如果发送完成，移除缓冲的数据
                    in.remove();
                } else {
                    如果没有完成会调用incompleteWrite方法
                    // Break the loop and so incompleteWrite(...) is called.
                    break;
                }
            } else if (msg instanceof FileRegion) {  //这个是文件传输和上面类似
                FileRegion region = (FileRegion) msg;
                boolean done = region.transferred() >= region.count();

                if (!done) {
                    long flushedAmount = 0;
                    if (writeSpinCount == -1) {
                        writeSpinCount = config().getWriteSpinCount();
                    }

                    for (int i = writeSpinCount - 1; i >= 0; i--) {
                        long localFlushedAmount = doWriteFileRegion(region);
                        if (localFlushedAmount == 0) {
                            setOpWrite = true;
                            break;
                        }

                        flushedAmount += localFlushedAmount;
                        if (region.transferred() >= region.count()) {
                            done = true;
                            break;
                        }
                    }

                    in.progress(flushedAmount);
                }

                if (done) {
                    in.remove();
                } else {
                    // Break the loop and so incompleteWrite(...) is called.
                    break;
                }
            } else {
                // Should not reach here.
                throw new Error();
            }
        }
        //如果没有完成写看看需要做的事情
        incompleteWrite(setOpWrite);
    }

//未完成写操作，看看操作
  protected final void incompleteWrite(boolean setOpWrite) {
        // Did not write completely.
        if (setOpWrite) {  //如果当前的写操作位true，那么当前多路复用器继续轮询处理
            setOpWrite();
        } else {  //否则重新新建一个task任务，让eventLoop后面点执行flush操作，这样其他任务才能够执行
            // Schedule flush again later so other tasks can be picked up in the meantime
            Runnable flushTask = this.flushTask;
            if (flushTask == null) {
                flushTask = this.flushTask = new Runnable() {
                    @Override
                    public void run() {
                        flush();
                    }
                };
            }
            eventLoop().execute(flushTask);
        }
    }

4) AbstractNioMessageChannel

public abstract class AbstractNioMessageChannel extends AbstractNioChannel {
    boolean inputShutdown;  //只有一个成员变量，表示是否数据读取完毕

}

主要实现方法是doWrite

    @Override
    protected void doWrite(ChannelOutboundBuffer in) throws Exception {
        final SelectionKey key = selectionKey();
        final int interestOps = key.interestOps();

        for (;;) {
            Object msg = in.current();
            if (msg == null) {
                // Wrote all messages.
                if ((interestOps & SelectionKey.OP_WRITE) != 0) {
                    key.interestOps(interestOps & ~SelectionKey.OP_WRITE);
                }
                break;
            }
            try {
                boolean done = false;
                for (int i = config().getWriteSpinCount() - 1; i >= 0; i--) {
                    if (doWriteMessage(msg, in)) {
                        done = true;
                        break;
                    }
                }

                if (done) {
                    in.remove();
                } else {
                    // Did not write all messages.
                    if ((interestOps & SelectionKey.OP_WRITE) == 0) {
                        key.interestOps(interestOps | SelectionKey.OP_WRITE);
                    }
                    break;
                }
            } catch (Exception e) {
                if (continueOnWriteError()) {
                    in.remove(e);
                } else {
                    throw e;
                }
            }
        }
    }

通过代码分析我们发现，AbstractNioMessageChannel 和AbstractNioByteChannel的消息发送实现比较相似，不同之处在于:一个发送的是ByteBuf或者FileRegion，它们可以直接被发送;另一个发送的则是POJO对象。

5) NioServerSocketChannel

先看成员变量

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

    private static final ChannelMetadata METADATA = new ChannelMetadata(false, 16);  //有channel的元数据
    private static final SelectorProvider DEFAULT_SELECTOR_PROVIDER = SelectorProvider.provider();

    private static final InternalLogger logger = InternalLoggerFactory.getInstance(NioServerSocketChannel.class);

    private static ServerSocketChannel newSocket(SelectorProvider provider) {
        try {
            /**
             *  Use the {@link SelectorProvider} to open {@link SocketChannel} and so remove condition in
             *  {@link SelectorProvider#provider()} which is called by each ServerSocketChannel.open() otherwise.
             *
             *  See #2308.
             */
            return provider.openServerSocketChannel();  //打开ServerSocketChannel
        } catch (IOException e) {
            throw new ChannelException(
                    "Failed to open a server socket.", e);
        }
    }

    private final ServerSocketChannelConfig config;  //用于配置serversocketchannel的tcp相关参数

再看看对应的接口实现操作：

    @Override
    public boolean isActive() {
        return javaChannel().socket().isBound(); //判断端口是否属于绑定状态S
    }

    @Override
    public InetSocketAddress remoteAddress() {
        return null;
    }

    @Override
    protected ServerSocketChannel javaChannel() {
        return (ServerSocketChannel) super.javaChannel();
    }

    @Override
    protected SocketAddress localAddress0() {
        return SocketUtils.localSocketAddress(javaChannel().socket());
    }

    @Override
    protected void doBind(SocketAddress localAddress) throws Exception {
        if (PlatformDependent.javaVersion() >= 7) {
            javaChannel().bind(localAddress, config.getBacklog());  
        } else {
            //绑定端口以及最大接受的客户端数量
            javaChannel().socket().bind(localAddress, config.getBacklog());
        }
    }

看重点的API接口
doReadMessage():下面很明显通过Nio的接受客户端连接并新建一个NioSocketChannel并封装父类和nio的SocketChannel放到buf中，返回1表示服务端接受成功

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

        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;
    }


剩下其他的一些connect，remoteAddress0等是serverSocket不支持的所以调用直接抛异常。


6) NioSocketChannel


这个类相对比较重要，通信主要是它实现的。
 先看成员变量


public class NioSocketChannel extends AbstractNioByteChannel implements io.netty.channel.socket.SocketChannel {
    private static final InternalLogger logger = InternalLoggerFactory.getInstance(NioSocketChannel.class);
    private static final SelectorProvider DEFAULT_SELECTOR_PROVIDER = SelectorProvider.provider();

 private final SocketChannelConfig config;  //这个是socketchannel配置信息

    private static SocketChannel newSocket(SelectorProvider provider) {
        try {
            /**
             *  Use the {@link SelectorProvider} to open {@link SocketChannel} and so remove condition in
             *  {@link SelectorProvider#provider()} which is called by each SocketChannel.open() otherwise.
             *
             *  See #2308.
             */
            return provider.openSocketChannel();  //open一个soketChannel
        } catch (IOException e) {
            throw new ChannelException("Failed to open a socket.", e);
        }
    }

   



A: connect操作


    @Override
    protected boolean doConnect(SocketAddress remoteAddress, SocketAddress localAddress) throws Exception {
        if (localAddress != null) {
            doBind0(localAddress);  //先看本地地址是否为null，不为空直接绑定
        }

        boolean success = false;
        try {
            //连接远程地址，
            boolean connected = SocketUtils.connect(javaChannel(), remoteAddress);
            if (!connected) { //  连接没有应答，再次 注册连接连接标识位
                selectionKey().interestOps(SelectionKey.OP_CONNECT);
            }
            success = true;
            return connected; //返回连接失败
        } finally {   //如果服务端拒绝或者REST抛出连接异常，则直接关闭连接
            if (!success) {
                doClose();
            }
        }
    }



B:doWrite 看写标识


 @Override
    protected void doWrite(ChannelOutboundBuffer in) throws Exception {
        for (;;) {
            int size = in.size();
            if (size == 0) {  //flushed字节为0直接清除可写标识位,标识没有可写的。
                // All written so clear OP_WRITE
                clearOpWrite();
                break;
            }
            long writtenBytes = 0;   //已经写出的字节数
            boolean done = false;   //是否写完
            boolean setOpWrite = false;  //写标识

            // Ensure the pending writes are made of ByteBufs only.
            ByteBuffer[] nioBuffers = in.nioBuffers();
            int nioBufferCnt = in.nioBufferCount();
            long expectedWrittenBytes = in.nioBufferSize();
            SocketChannel ch = javaChannel();

            // Always us nioBuffers() to workaround data-corruption.
            // See https://github.com/netty/netty/issues/2761
            switch (nioBufferCnt) {
                case 0:  //标识没有可写
                    // We have something else beside ByteBuffers to write so fallback to normal writes.
                    super.doWrite(in);
                    return;
                case 1:
                    // Only one ByteBuf so use non-gathering write
                    ByteBuffer nioBuffer = nioBuffers[0];
                    for (int i = config().getWriteSpinCount() - 1; i >= 0; i --) {
                        final int localWrittenBytes = ch.write(nioBuffer);
                        if (localWrittenBytes == 0) {
                            setOpWrite = true;
                            break;
                        }
                        expectedWrittenBytes -= localWrittenBytes;
                        writtenBytes += localWrittenBytes;
                        if (expectedWrittenBytes == 0) {
                            done = true;
                            break;
                        }
                    }
                    break;
                default:
                  //默认的写方法
                    for (int i = config().getWriteSpinCount() - 1; i >= 0; i --) {
                        final long localWrittenBytes = ch.write(nioBuffers, 0, nioBufferCnt);
                        if (localWrittenBytes == 0) {
                            setOpWrite = true;
                            break;
                        }
                        expectedWrittenBytes -= localWrittenBytes;
                        writtenBytes += localWrittenBytes;
                        if (expectedWrittenBytes == 0) {
                            done = true;
                            break;
                        }
                    }
                    break;
            }

            // Release the fully written buffers, and update the indexes of the partially written buffer.
            in.removeBytes(writtenBytes);

            if (!done) {
                // Did not write all buffers completely.
                incompleteWrite(setOpWrite);
                break;
            }
        }
    }




这个是AbstractNioByteChannel的写类似。


C:读写
 具体的读写操作还是如下，还是比较简单的。


   @Override
    protected int doReadBytes(ByteBuf byteBuf) throws Exception {
        final RecvByteBufAllocator.Handle allocHandle = unsafe().recvBufAllocHandle();
        allocHandle.attemptedBytesRead(byteBuf.writableBytes());
        return byteBuf.writeBytes(javaChannel(), allocHandle.attemptedBytesRead());
    }

    @Override
    protected int doWriteBytes(ByteBuf buf) throws Exception {
        final int expectedWrittenBytes = buf.readableBytes();
        return buf.readBytes(javaChannel(), expectedWrittenBytes);
    }



3.Unsafe


Unsafe就是channel的辅助接口，我们实际的IO操作最后还是交给Unsafe操作，Unsafe接口的定义就是放在Channel中的;具体如下：



public interface Channel extends AttributeMap, ChannelOutboundInvoker, Comparable {

  .....
    /**
     * Returns an internal-use-only object that provides unsafe operations.
     */
    Unsafe unsafe();

    interface Unsafe {

        /**
         * Return the assigned {@link RecvByteBufAllocator.Handle} which will be used to allocate {@link ByteBuf}'s when
         * receiving data.
         */
        RecvByteBufAllocator.Handle recvBufAllocHandle();

        /**
         * Return the {@link SocketAddress} to which is bound local or
         * {@code null} if none.
         */
        SocketAddress localAddress();

        /**
         * Return the {@link SocketAddress} to which is bound remote or
         * {@code null} if none is bound yet.
         */
        SocketAddress remoteAddress();

        /**
         * Register the {@link Channel} of the {@link ChannelPromise} and notify
         * the {@link ChannelFuture} once the registration was complete.
         */
        void register(EventLoop eventLoop, ChannelPromise promise);

        /**
         * Bind the {@link SocketAddress} to the {@link Channel} of the {@link ChannelPromise} and notify
         * it once its done.
         */
        void bind(SocketAddress localAddress, ChannelPromise promise);

        /**
         * Connect the {@link Channel} of the given {@link ChannelFuture} with the given remote {@link SocketAddress}.
         * If a specific local {@link SocketAddress} should be used it need to be given as argument. Otherwise just
         * pass {@code null} to it.
         *
         * The {@link ChannelPromise} will get notified once the connect operation was complete.
         */
        void connect(SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise);

        /**
         * Disconnect the {@link Channel} of the {@link ChannelFuture} and notify the {@link ChannelPromise} once the
         * operation was complete.
         */
        void disconnect(ChannelPromise promise);

        /**
         * Close the {@link Channel} of the {@link ChannelPromise} and notify the {@link ChannelPromise} once the
         * operation was complete.
         */
        void close(ChannelPromise promise);

        /**
         * Closes the {@link Channel} immediately without firing any events.  Probably only useful
         * when registration attempt failed.
         */
        void closeForcibly();

        /**
         * Deregister the {@link Channel} of the {@link ChannelPromise} from {@link EventLoop} and notify the
         * {@link ChannelPromise} once the operation was complete.
         */
        void deregister(ChannelPromise promise);

        /**
         * Schedules a read operation that fills the inbound buffer of the first {@link ChannelInboundHandler} in the
         * {@link ChannelPipeline}.  If there's already a pending read operation, this method does nothing.
         */
        void beginRead();

        /**
         * Schedules a write operation.
         */
        void write(Object msg, ChannelPromise promise);

        /**
         * Flush out all write operations scheduled via {@link #write(Object, ChannelPromise)}.
         */
        void flush();

        /**
         * Return a special ChannelPromise which can be reused and passed to the operations in {@link Unsafe}.
         * It will never be notified of a success or error and so is only a placeholder for operations
         * that take a {@link ChannelPromise} as argument but for which you not want to get notified.
         */
        ChannelPromise voidPromise();

        /**
         * Returns the {@link ChannelOutboundBuffer} of the {@link Channel} where the pending write requests are stored.
         */
        ChannelOutboundBuffer outboundBuffer();
    }
}



总结下：
 netty自定义了channel接口，通过组合的jdk的channel实现IO操作操作功能；当然channel需要注册到eventLoop的多路复用器上。一个channel对应一条实际的物理连接；这里主要详解了NioServersocketChannel和NioSocketChannel。下一章节我们看看EventLoop的实现细节


参考《Netty权威指南》
























你可能感兴趣的:(Netty之Channel)






    

  • 大数据新视界 --大数据大厂之揭秘大数据时代 Excel 魔法：大厂数据分析师进阶秘籍
青云交
大数据新视界Excel数据分析函数公式数据透视表图表功能规划求解数据分析工具库大数据新视界数据库

    亲爱的朋友们，热烈欢迎你们来到青云交的博客！能与你们在此邂逅，我满心欢喜，深感无比荣幸。在这个瞬息万变的时代，我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而我的博客，正是这样一个温暖美好的所在。在这里，你们不仅能够收获既富有趣味又极为实用的内容知识，还可以毫无拘束地畅所欲言，尽情分享自己独特的见解。我真诚地期待着你们的到来，愿我们能在这片小小的天地里共同成长，共同进步。本博客的精华专栏：Ja
    

    • 

  • AI 模型：全能与专精之辩 —— 一场科技界的 “超级大比拼”
青云交
AIjava学习人工智能全能与专精精度速度鲁棒性道德规范发展趋势AI模型OpenAI

    亲爱的朋友们，热烈欢迎你们来到青云交的博客！能与你们在此邂逅，我满心欢喜，深感无比荣幸。在这个瞬息万变的时代，我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而我的博客，正是这样一个温暖美好的所在。在这里，你们不仅能够收获既富有趣味又极为实用的内容知识，还可以毫无拘束地畅所欲言，尽情分享自己独特的见解。我真诚地期待着你们的到来，愿我们能在这片小小的天地里共同成长，共同进步。本博客的精华专栏：Ja
    

    • 

  • Java面试题--JVM大厂篇之深入解析JVM中的Serial GC：工作原理与代际区别
青云交
Java大厂面试题Java虚拟机（JVM）专栏Java技术栈SerialGC工作原理年轻代垃圾回收MinorGC老年代垃圾回收MajorGCFullGC年轻代和老年代的区别SerialGC垃圾收集器单线程垃圾收集器

    目录引言：正文：一、SerialGC工作原理年轻代垃圾回收（MinorGC）：老年代垃圾回收（MajorGC或FullGC）：二、年轻代和老年代的区别年轻代（YoungGeneration）：老年代（OldGeneration）：结束语：引言：Java虚拟机（JVM）作为Java程序的运行环境，其性能和稳定性在很大程度上依赖于垃圾收集器（GC）的效率。SerialGC是JVM中最古老也是最简单的一
    

    • 

  • 公共部门为什么要进行人力资源战略规划？
林品如大号

    《礼记·中庸》中提到“凡事预则立，不预则废。”由此可见，事先规划和谋定的预案或战略对于一件事情的成败的重要影响作用。传统意义上的“战略”指的是在一场战争或战斗背后所隐含的筹划、谋略与构想。现实中“战略”的内涵应拓展到更广的事项或决定层面。在中华五千年的浩荡历史长河中，“战略”管理的经典案例比比皆是。古有《曹刿论剑》中“一鼓作气，再而衰，三而竭。彼竭我盈，故克之。”的军事战略；近有毛泽东的《论持久战
    

    • 

  • 潜意识通过负面情绪向你传达哪些信号
云手a

    洛伊德认为：人的情绪如同一座冰山，分为三个部分。第一个部分是意识，浮在海面上，大概只占百分之五；第二部分是潜意识，隐藏在水下的庞然大物，约占95%；第三部分是前意识，是连结意识和潜意识的层面。而人的行为举止，只有少部分是由意识所控制，而大部分是由潜意识所主宰，而且是在人本身没有觉察到的情况下对人的行为举止发生作用的。潜意识隐藏在海面之下，它聚集了人类数百万年来的遗传基因层次的信息，囊括了人类生存最
    

    • 

  • golang面试题 001
Jay_hj11
golang面试Golanggolang后端数据结构开发语言面试

    001gochannelclose后读的问题golangchannel关闭后，其中剩余的数据，是可以继续读取的。请看下面的测试例子。创建一个带有缓冲的channel，向channel中发送数据，然后关闭channel，最后，从channel中读取数据，输出结果。packagemainimport"fmt"//gochannelclose后读的问题funcmain(){ch:=make(chanst
    

    • 

  • 【python】爬取网站数据
进击的C语言
网络

    编码问题因为涉及到中文，所以必然地涉及到了编码的问题，这一次借这个机会算是彻底搞清楚了。问题要从文字的编码讲起。原本的英文编码只有0~255，刚好是8位1个字节。为了表示各种不同的语言，自然要进行扩充。中文的话有GB系列。可能还听说过Unicode和UTF-8，那么，它们之间是什么关系呢？Unicode是一种编码方案，又称万国码，可见其包含之广。但是具体存储到计算机上，并不用这种编码，可以说它起着
    

    • 

  • 【菊言菊语】和爱丽丝一起去“漫游”（五）
山中雏菊

    思考：本节微课讲述了书中一些典故的来历。您对哪一个典故印象深刻？还有哪些书籍或诗词也引用了典故？今天的微课继续跟着爱丽丝一起去漫游，《爱丽丝漫游奇境记》荒诞不经的故事情节让全世界的人们都为之疯狂。书中引用大量典故，这是作者卡罗尔写作的又一特点。第三章《绕圈跑和尾巴》中征服者威廉；第五章《毛毛虫的劝告》中改编的诗歌；第六章《猪和胡椒》中“公爵”“柴郡猫”；第七章《疯狂的茶会》中“疯帽匠”“三月兔”“
    

    • 

  • 三生三世枕上书之再续前缘 远古众神再聚首，东华算计少绾
诗韵_三生三世小说创作者

    接上话凤九听了少绾这话哭笑不得，而正在朝膳房走来的东华的脸却黑了一个八度……随后，东华转身径直去了芬陀利池，钓了一条肥鲫鱼，转身去了膳房。而这边，狐帝狐后还有折颜听说了少绾醒了，如今在太晨宫的消息，想来毕竟当年也算是同窗好友，便一道前往了太晨宫。却独独没有一个人向墨渊透露出半点风声。刚进太晨宫，折颜便说道“少绾，这么多年了，你也可算是醒了”少绾看了折颜，再顺势看到了折颜身后的一个白衣男子，没有理会
    

    • 

  • 大数据新视界 --大数据大厂之数据挖掘入门：用 R 语言开启数据宝藏的探索之旅
青云交
大数据新视界数据库大数据数据挖掘R语言算法案例未来趋势应用场景学习建议大数据新视界

    亲爱的朋友们，热烈欢迎你们来到青云交的博客！能与你们在此邂逅，我满心欢喜，深感无比荣幸。在这个瞬息万变的时代，我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而我的博客，正是这样一个温暖美好的所在。在这里，你们不仅能够收获既富有趣味又极为实用的内容知识，还可以毫无拘束地畅所欲言，尽情分享自己独特的见解。我真诚地期待着你们的到来，愿我们能在这片小小的天地里共同成长，共同进步。本博客的精华专栏：Ja
    

    • 

  • 【网络安全 | 代码审计】JFinal之DenyAccessJsp绕过
秋说
网络安全web安全java代码审计漏洞挖掘

    未经许可，不得转载。文章目录前言代码审计推理绕过Tomcat解析JSP总结概念验证阐发前言JFinal是一个基于Java的轻量级MVC框架，用于快速构建Web应用程序。它的设计理念是追求极简、灵活、高效，旨在提高开发效率，减少冗余代码的编写，适合中小型项目以及对性能有较高要求的项目。在较新的JFinal版本中，默认情况下无法直接通过浏览器地址栏输入.jsp文件名来访问对应的JSP文件。也就是说，主
    

    • 

  • 千万字《计谋之纵横四海》37，中前故意斗地主输掉一百万吗？黑三自信自已推断
黑龙江漫天飞雪

    黑三和小红在屋子里玩手机，这时，张五和李六走了进来。黑三说道：情况怎么样？张五说道：中前和两个人，斗地主，把一百万，全输光了。在网吧里，我俩见证了这一奇迹的时刻。黑三看着手机，没有抬头。小红说道：什么意思？中前成穷鬼了？李六说道：老大，你不明白，你老盯着中前干嘛呀？到底有什么目的呀？黑三说道：一百万，输光了？他既然是赌鬼，怎么可能有一百万？这不蹊跷吗？小红说道：什么意思？黑三：中前是故意输的。小红
    

    • 

  • Unity 热更 之 【HybirdCLR】+【YooAsset】 [安卓 Android端] [代码 + 资源热更] 功能的 简单实现演示
仙魁XAN
Unity进阶unityHybirdCLRYooAssetHotUpdate热更新

    Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示目录Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示一、简单介绍二、HybridCLR三、YooAsset四、HybirdCLR引入工程五、YooAsset引入工程六、Python服务器简单构建七、Hybir
    

    • 

  • Unity 热更 之 【YooAsset 热更】几分钟快速了解 YooAsset [功能面板]、以及 [基础代码] 说明
仙魁XAN
Unity进阶unityYooAssetyoo热更HotUpdate

    Unity热更之【YooAsset热更】几分钟快速了解YooAsset[功能面板]、以及[基础代码]说明目录Unity热更之【YooAsset热更】几分钟快速了解YooAsset[功能面板]、以及[基础代码]说明一、简单介绍二、系统需求三、快速引入工程中四、功能面板全局配置YooAsset->CreateSetting五、功能面板资源配置AssetBundleCollector六、功能面板资源构建
    

    • 

  • 2019-05-28 女性财富力作业
唐平子

    Part1:理解和感悟三个核心习惯。1.我经手的任何事情都是我的个人品牌，我百分之百的为之负责。（1）对于这一点我感触最深的是对自己的个人职业发展负责。在过去，我总是依赖于领导给我分配任务，即便是每年年中个人发展回顾的时候，也没有认真思考和做功课。后面我意识到了这个问题，并做了一些调整。前段时间，我得知我们即将来一个项目，其中一个重要的角色是空缺的，通过跟有经验的同事交流，我发现这是一条新的业务线
    

    • 

  • Rust中的所有权和借用规则详解
代码云1
rust开发语言后端

    Rust是一种系统编程语言，其设计目标包括内存安全、并发安全以及性能。为了实现这些目标，Rust引入了一系列独特的编程概念，其中最为核心的就是所有权（Ownership）和借用（Borrowing）规则。本文将详细解释Rust中的所有权和借用规则，以及它们如何确保内存安全和并发安全。一、所有权规则在Rust中，每一个值都有一个与之关联的所有者。这个所有者可以是变量、数据结构或者是其他形式的存储。所
    

    • 

  • 幸福感恩日记第15篇
豫豫妈

    2018.7.3豫豫妈早课心得：1、这个世界外面没有别人，只有自己。一切都是自己的问题。2、每个人都不是完美的，学会转念，高效沟通。3、讲好每句话也是阴阳并存的，一阴一阳之谓道。4、坚持读经，早起学习，记笔记及时内化，学以致用才能正确的引导孩子。5、一个工具，二个方法，一个核心；五个步骤，僵化学习、固化学习、内化学习、优化学习、变化学习运用易经思维进行学习总结。方法：如果----那么----有点像
    

    • 

  • 2019-06-19
甜乐_ed8c

    李桂芳初十五坚持分享第131天关照自己的内在小孩先处理心情，再处理事情狮子型，乌龟型，壁虎型，海豚型绿巨人→微笑女神理解→接纳→宽恕，与自己和解去融合，我很糟→我在想"我很糟"世界多元，换个视角发现生活之美！
    

    • 

  • 玉苍之南：普洱茶生茶好还是熟茶好？解析熟茶和生普的优缺点2020-08-25
茶鬼人生

    普洱茶生茶好还是熟茶好？很多新手茶友，对于普洱茶生茶、熟茶，经常是“傻傻分不清楚”。那么，这二者究竟哪个更好呢？新鲜的茶叶采摘后以自然的方式陈放，未经过渥堆发酵处理为生茶。生茶茶性较烈，刺激，新制或陈放不久的生茶有苦味，涩味，汤色较浅或黄绿，生茶可清热去火，适合夏天喝。而且长期收藏具有时间越长,品质越佳的特点。普洱茶在制作过程中经过渥堆发酵使茶性趋向温和，称为熟茶。熟普具有温和的茶性，可以暖胃，茶
    

    • 

  • 一手好字的第四十三天
自信的姐姐

    网络图片，侵权必删世事洞明皆学问，透过表象看本质！我知道了自己的短板：基本功字之控笔能力，而解决之道，除了练无它！好吧，既如此，那就按原先的计划执行，时间我有，总能挤出来的，不够就跟老天再借五百年呗！就不信，学不好母语写不好字！无论是啥想法，但节奏不乱，每天该干啥还干啥，不因基本功烂就多练，非也！心急吃不了热豆腐，更何况是练字？练字要的是耐心、天天练、细细品、慢慢改！人会撒谎但字不会，付出了会看得
    

    • 

  • Python进阶之Openpyxl详解
夏天Aileft
Pythonpython开发语言openpyxl

    ✨前言openpyxl是一个用于读取和编辑Excel文件（即.xlsx格式文件）的Python库。以下是openpyxl的详细介绍及常见操作示例✨安装在使用openpyxl之前，需要先安装它。可以通过以下命令安装：pipinstallopenpyxl✨加载工作簿#加载已经存在的工作簿wb=openpyxl.load_workbook('example.xlsx')#创建一个新的工作簿wb=open
    

    • 

  • 艺凡读易中天中华史《百家争鸣》27
艺凡会发光

    易中天中华史《百家争鸣》第五章：生存之道之两种活法两种道艺凡：老子的天，当真无情吗？易中天：无情。老子说得很清楚，天地不仁，以万物为刍狗。艺凡：什么意思？易中天：万物虽为天地所创造，所生成，天地却始用终弃，漠然视之，完全不当回事。这当然不仁，也无情。艺凡：那天地既然无情，为什么又说“天将救之，以慈卫之”，弱者都会得到呵护和救助？易中天：因为天道原本如此。老子说得非常清楚：天下之至柔，驰骋天下之至坚
    

    • 

  • 《都市不俗人》：之245 有情人终成眷属
古韵撷趣

    上篇说到，周红在家中为胡姣过生日，虽然说，只是周红爱人周小乐做的几道家常菜，但亲切的感觉却是显而易见的……席中，周红如曾明所料，主动谈及了，胡姣国庆节后一上班就提交上去的《关于加強公司财务部力量》的建议书……周小乐听到爱人周红叙述，公司领导层的反应后，立马意识到，胡姣有升职的可能……周红也很高兴地回应说：12月初的公司职代会后，财务部的基本框架就会定下来……胡姣主动给周红盛了一碗汤，同时真诚地说：
    

    • 

  • 掌握这些思维、习惯，让你在职业生涯中受益匪浅
伽马有话说

    有哪些对职业生涯有益的思维和习惯呢？这里有四个建议：一、收集各行各业人类失败与灾难的反面案例我们总是高估自己，小瞧别人。有一个有趣的例子。据统计，瑞典有百分之九十的司机都认为他们的驾驶技术在平均水平之上。让我们看看抖音上那些失败的案例吧。有多少视频都是骑着单车到货车的视觉盲区被碾伤碾死；有多少视频都是醉酒开车撞伤路人、撞坏栅栏；有多少视频都是相互赌气，相互别车，最后大打出手。人类失败与灾难案例从来
    

    • 

  • 《论语·公冶长》之十三 - 朱文津
让世界因我的存在而更加美好

    《论语·公冶长》之十三朱文津各位同学大家好！今天我们学习《公冶长篇》第十三章，先恭诵原文——子贡曰：“夫子之文章，可得而闻也；夫子之言性与天道，不可得而闻也。”子贡说：“夫子讲的知识学问，是可以听到的；夫子讲的性与天道，是难得听到的。”所依一：宋代大儒程颢(hào)、程頣（yí）认为：“此子贡闻夫子之至论而叹美之言也。”这是圣门高徒子贡，赞叹夫子讲的性与天道太美了，再没有比这个更高深微妙的道理了。
    

    • 

  • 2023-10-25
帕金森大健康

    睡眠会影响孩子的身高吗孩子长高依赖的因素有哪些？研究显示，孩子的身高，70%取决于父母的遗传基因，30%取决于后天因素。后天影响因素包括饮食、运动、睡眠、心理健康等。其中，睡眠对身高的影响很大。睡眠为什么会影响孩子身高呢生长激素是生长发育过程中非常重要的激素之—，生长激素分泌异常可导致孩子身材矮小。生长激素分泌特点与其他激素不同，它在体内的浓度并不是稳定在某一水平，而是呈现脉冲式分泌，白天的分泌量
    

    • 

  • 西晋极简编年史
江吴童

    泰始元年（265年）司马昭去世，其子司马炎继晋王之位。司马炎篡魏，建立晋朝。司马炎泰始三年（267年）司马炎颁布《泰始律》（即《晋律》）。泰始四年（268年）吴主·孙皓出东关，吴将·施绩入江夏，万彧寇襄阳。吴交州刺史·刘俊及修则、顾容前后三度进攻交趾，为交趾太守·杨稷破之。泰始五年（269年）晋将·羊祜镇守襄阳。羊祜泰始六年（270年）鲜卑·秃发树机能叛，秦州刺史·胡烈兵败被杀。泰始七年（271年
    

    • 

  • 【Qt】之【Bug】LNK2019: 无法解析的外部符号 __imp_FindWindowW
Htht111
Qtbugqtbug开发语言

    QTerror:LNK2019:无法解析的外部符号__imp__SendMessageW@类型的错误以及pragmacomment的作用（用法）添加头文件出错的cpp文件加入以下代码#pragmacomment(lib,"User32.lib")ps：尝试pro添加-lUser32，没用
    

    • 

  • 数学建模、运筹学之非线性规划
AgentSmart
算法学习算法动态规划线性代数线性规划

    数学建模、运筹学之非线性规划一、最优化问题理论体系二、梯度下降法——无约束非线性规划三、牛顿法——无约束非线性规划四、只包含等值约束的拉格朗日乘子法五、不等值约束非线性规划与KKT条件一、最优化问题理论体系最优化问题旨在寻找全局最优值（或为最大值，或为最小值）。最优化问题一般可以分为两个部分：目标函数与约束条件。该问题的进一步细分也是根据这两部分的差异。最优化问题根据变量的取值范围不同可以划分为一
    

    • 

  • 内网穿透之EW使用、判断服务器是否出网
板栗妖怪
学习内网渗透

    环境搭建使用的是下面文章的环境记一次学习--内网穿透-CSDN博客ew代理然后同样通过thinkphp漏洞写入文件，然后通过蚁剑连接然后上传ew的Linux版本，然后加权执行一层代理正向代理设置正向代理（在ubuntu上），然后kali在proxychain配置文件中连接ubuntu的192.168.244.154的代理端口反向代理在ubuntu上设置反向代理，将连接反弹到kali上的某个端口。然
    

    • 

  • SAX解析xml文件
小猪猪08
xml

    1.创建SAXParserFactory实例
2.通过SAXParserFactory对象获取SAXParser实例
3.创建一个类SAXParserHander继续DefaultHandler，并且实例化这个类
4.SAXParser实例的parse来获取文件
    public static void main(String[] args) {
//
    

    • 

  • 为什么mysql里的ibdata1文件不断的增长？
brotherlamp
linuxlinux运维linux资料linux视频linux运维自学

    我们在 Percona 支持栏目经常收到关于 MySQL 的 ibdata1 文件的这个问题。
当监控服务器发送一个关于 MySQL 服务器存储的报警时，恐慌就开始了 —— 就是说磁盘快要满了。
一番调查后你意识到大多数地盘空间被 InnoDB 的共享表空间 ibdata1 使用。而你已经启用了 innodbfileper_table，所以问题是：
ibdata1存了什么？
当你启用了 i
    

    • 

  • Quartz-quartz.properties配置
eksliang
quartz

    其实Quartz JAR文件的org.quartz包下就包含了一个quartz.properties属性配置文件并提供了默认设置。如果需要调整默认配置，可以在类路径下建立一个新的quartz.properties，它将自动被Quartz加载并覆盖默认的设置。
 
下面是这些默认值的解释
#-----集群的配置
org.quartz.scheduler.instanceName =
    

    • 

  • informatica session的使用
18289753290
workflowsessionlogInformatica

    如果希望workflow存储最近20次的log，在session里的Config  Object设置，log  options做配置，save  session log :sessions  run  ;savesessio log for  these runs:20
session下面的source 里面有个tracing 
    

    • 

  • Scrapy抓取网页时出现CRC check failed 0x471e6e9a != 0x7c07b839L的错误
酷的飞上天空
scrapy

    Scrapy版本0.14.4
出现问题现象：
ERROR: Error downloading <GET http://xxxxx  CRC check failed
 
解决方法
 
1.设置网络请求时的header中的属性'Accept-Encoding': '*;q=0'
 
明确表示不支持任何形式的压缩格式，避免程序的解压
    

    • 

  • java Swing小集锦
永夜-极光
java swing

    1.关闭窗体弹出确认对话框
  1.1   this.setDefaultCloseOperation (JFrame.DO_NOTHING_ON_CLOSE);
  1.2  
this.addWindowListener (
new WindowAdapter () {
public void windo
    

    • 

  • 强制删除.svn文件夹
随便小屋
java

     
        在windows上，从别处复制的项目中可能带有.svn文件夹，手动删除太麻烦，并且每个文件夹下都有。所以写了个程序进行删除。因为.svn文件夹在windows上是只读的，所以用File中的delete()和deleteOnExist()方法都不能将其删除，所以只能采用windows命令方式进行删除
    

    • 

  • GET和POST有什么区别？及为什么网上的多数答案都是错的。
aijuans
get post

    
    如果有人问你，GET和POST，有什么区别？你会如何回答？ 我的经历
     前几天有人问我这个问题。我说GET是用于获取数据的，POST，一般用于将数据发给服务器之用。
    这个答案好像并不是他想要的。于是他继续追问有没有别的区别？我说这就是个名字而已，如果服务器支持，他完全可以把G
    

    • 

  • 谈谈新浪微博背后的那些算法
aoyouzi
谈谈新浪微博背后的那些算法

    本文对微博中常见的问题的对应算法进行了简单的介绍，在实际应用中的算法比介绍的要复杂的多。当然，本文覆盖的主题并不全，比如好友推荐、热点跟踪等就没有涉及到。但古人云“窥一斑而见全豹”，希望本文的介绍能帮助大家更好的理解微博这样的社交网络应用。
微博是一个很多人都在用的社交应用。天天刷微博的人每天都会进行着这样几个操作：原创、转发、回复、阅读、关注、@等。其中，前四个是针对短博文，最后的关注和@则针
    

    • 

  • Connection reset 连接被重置的解决方法
百合不是茶
java字符流连接被重置

    流是java的核心部分,,昨天在做android服务器连接服务器的时候出了问题,就将代码放到java中执行,结果还是一样连接被重置
 
被重置的代码如下;
 
客户端代码;
package 通信软件服务器;
import java.io.BufferedWriter;
import java.io.OutputStream;
import java.io.O
    

    • 

  • web.xml配置详解之filter
bijian1013
javaweb.xmlfilter

    一.定义
<filter>
<filter-name>encodingfilter</filter-name>
<filter-class>com.my.app.EncodingFilter</filter-class>
<init-param>
<param-name>encoding<
    

    • 

  • Heritrix
Bill_chen
多线程xml算法制造配置管理

    作为纯Java语言开发的、功能强大的网络爬虫Heritrix，其功能极其强大，且扩展性良好，深受热爱搜索技术的盆友们的喜爱，但它配置较为复杂，且源码不好理解，最近又使劲看了下，结合自己的学习和理解，跟大家分享Heritrix的点点滴滴。
Heritrix的下载（http://sourceforge.net/projects/archive-crawler/）安装、配置，就不罗嗦了，可以自己找找资
    

    • 

  • 【Zookeeper】FAQ
bit1129
zookeeper

    1.脱离IDE，运行简单的Java客户端程序
#ZkClient是简单的Zookeeper~$ java -cp "./:zookeeper-3.4.6.jar:./lib/*" ZKClient 
 
1. Zookeeper是的Watcher回调是同步操作，需要添加异步处理的代码
2. 如果Zookeeper集群跨越多个机房，那么Leader/
    

    • 

  • The user specified as a definer ('aaa'@'localhost') does not exist
白糖_
localhost

    今天遇到一个客户BUG，当前的jdbc连接用户是root，然后部分删除操作都会报下面这个错误：The user specified as a definer ('aaa'@'localhost') does not exist
最后找原因发现删除操作做了触发器，而触发器里面有这样一句
/*!50017 DEFINER = ''aaa@'localhost' */
 原来最初
    

    • 

  • javascript中showModelDialog刷新父页面
bozch
JavaScript刷新父页面showModalDialog

    在页面中使用showModalDialog打开模式子页面窗口的时候，如果想在子页面中操作父页面中的某个节点，可以通过如下的进行：
      window.showModalDialog('url',self,‘status...’); // 首先中间参数使用self
      在子页面使用w
    

    • 

  • 编程之美-买书折扣
bylijinnan
编程之美

    
import java.util.Arrays;
public class BookDiscount {
/**编程之美 买书折扣
书上的贪心算法的分析很有意思，我看了半天看不懂，结果作者说，贪心算法在这个问题上是不适用的。。
下面用动态规划实现。
哈利波特这本书一共有五卷，每卷都是8欧元，如果读者一次购买不同的两卷可扣除5%的折扣，三卷10%，四卷20%，五卷
    

    • 

  • 关于struts2.3.4项目跨站执行脚本以及远程执行漏洞修复概要
chenbowen00
strutsWEB安全

    因为近期负责的几个银行系统软件，需要交付客户，因此客户专门请了安全公司对系统进行了安全评测，结果发现了诸如跨站执行脚本，远程执行漏洞以及弱口令等问题。
下面记录下本次解决的过程以便后续
1、首先从最简单的开始处理，服务器的弱口令问题，首先根据安全工具提供的测试描述中发现应用服务器中存在一个匿名用户，默认是不需要密码的，经过分析发现服务器使用了FTP协议，
而使用ftp协议默认会产生一个匿名用
    

    • 

  • [电力与暖气]煤炭燃烧与电力加温
comsci

    
      在宇宙中,用贝塔射线观测地球某个部分,看上去,好像一个个马蜂窝,又像珊瑚礁一样,原来是某个国家的采煤区.....
      不过,这个采煤区的煤炭看来是要用完了.....那么依赖将起燃烧并取暖的城市,在极度严寒的季节中...该怎么办呢?
  &nbs
    

    • 

  • oracle O7_DICTIONARY_ACCESSIBILITY参数
daizj
oracle

    O7_DICTIONARY_ACCESSIBILITY参数控制对数据字典的访问.设置为true,如果用户被授予了如select any table等any table权限,用户即使不是dba或sysdba用户也可以访问数据字典.在9i及以上版本默认为false,8i及以前版本默认为true.如果设置为true就可能会带来安全上的一些问题.这也就为什么O7_DICTIONARY_ACCESSIBIL
    

    • 

  • 比较全面的MySQL优化参考
dengkane
mysql

    本文整理了一些MySQL的通用优化方法，做个简单的总结分享，旨在帮助那些没有专职MySQL DBA的企业做好基本的优化工作，至于具体的SQL优化，大部分通过加适当的索引即可达到效果，更复杂的就需要具体分析了，可以参考本站的一些优化案例或者联系我，下方有我的联系方式。这是上篇。
 
1、硬件层相关优化
 
1.1、CPU相关
 
在服务器的BIOS设置中，可
    

    • 

  • C语言homework2，有一个逆序打印数字的小算法
dcj3sjt126com
c

    #h1#
 
0、完成课堂例子
1、将一个四位数逆序打印
1234 ==> 4321
实现方法一：
# include <stdio.h>
int main(void)
{
int i = 1234;
int one = i%10;
int two = i / 10 % 10;
int three = i / 100 % 10;

    

    • 

  • apacheBench对网站进行压力测试
dcj3sjt126com
apachebench

       ab 的全称是 ApacheBench ， 是 Apache 附带的一个小工具 ， 专门用于 HTTP Server 的 benchmark testing ， 可以同时模拟多个并发请求。前段时间看到公司的开发人员也在用它作一些测试，看起来也不错，很简单，也很容易使用，所以今天花一点时间看了一下。
通过下面的一个简单的例子和注释，相信大家可以更容易理解这个工具的使用。 
    

    • 

  • 2种办法让HashMap线程安全
flyfoxs
javajdkjni

    多线程之--2种办法让HashMap线程安全
多线程之--synchronized 和reentrantlock的优缺点
多线程之--2种JAVA乐观锁的比较( NonfairSync VS. FairSync)
 
 
HashMap不是线程安全的,往往在写程序时需要通过一些方法来回避.其实JDK原生的提供了2种方法让HashMap支持线程安全.
 

    

    • 

  • Spring Security（04）——认证简介
234390216
Spring Security认证过程

    认证简介
目录
1.1     认证过程
1.2     Web应用的认证过程
1.2.1    ExceptionTranslationFilter
1.2.2    在request之间共享SecurityContext
 
1
    

    • 

  • Java 位运算
Javahuhui
java位运算

    // 左移( << ) 低位补0
// 0000 0000 0000 0000 0000 0000 0000 0110 然后左移2位后，低位补0：
// 0000 0000 0000 0000 0000 0000 0001 1000
System.out.println(6 << 2);// 运行结果是24
// 右移( >> ) 高位补"
    

    • 

  • mysql免安装版配置
ldzyz007
mysql

    1、my-small.ini是为了小型数据库而设计的。不应该把这个模型用于含有一些常用项目的数据库。
2、my-medium.ini是为中等规模的数据库而设计的。如果你正在企业中使用RHEL,可能会比这个操作系统的最小RAM需求(256MB)明显多得多的物理内存。由此可见，如果有那么多RAM内存可以使用，自然可以在同一台机器上运行其它服务。
3、my-large.ini是为专用于一个SQL数据
    

    • 

  • MFC和ado数据库使用时遇到的问题
你不认识的休道人
sqlC++mfc

    ===================================================================
第一个
===================================================================
try{
CString sql;
sql.Format("select * from p
    

    • 

  • 表单重复提交Double Submits
rensanning
double

    可能发生的场景：
*多次点击提交按钮
*刷新页面
*点击浏览器回退按钮
*直接访问收藏夹中的地址
*重复发送HTTP请求（Ajax）
（1）点击按钮后disable该按钮一会儿，这样能避免急躁的用户频繁点击按钮。
这种方法确实有些粗暴，友好一点的可以把按钮的文字变一下做个提示，比如Bootstrap的做法：
http://getbootstrap.co
    

    • 

  • Java String 十大常见问题
tomcat_oracle
java正则表达式

    　1.字符串比较，使用“==”还是equals()? 　　"=="判断两个引用的是不是同一个内存地址(同一个物理对象)。 　　equals()判断两个字符串的值是否相等。 　　除非你想判断两个string引用是否同一个对象，否则应该总是使用equals()方法。 　　如果你了解字符串的驻留(String Interning)则会更好地理解这个问题。 　
　
    

    • 

  • SpringMVC 登陆拦截器实现登陆控制
xp9802
springMVC

    思路，先登陆后，将登陆信息存储在session中，然后通过拦截器，对系统中的页面和资源进行访问拦截，同时对于登陆本身相关的页面和资源不拦截。
 
实现方法：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 
    

    •