洛城铁匠
洛城铁匠

netty理论之源码分析① Bootstrap和ServerBootstrap

首先来复习一下nio的概念:

  从Java1.4开始， Java引入了non-blocking IO，简称NIO。

NIO 由以下几个核心部分组成：Channels，Buffers，Selectors

虽然Java NIO 中除此之外还有很多类和组件，但在我看来，Channel，Buffer 和 Selector 构成了核心的API。其它组件，如Pipe和FileLock，只不过是与三个核心组件共同使用的工具类。因此，在概述中我将集中在这三个组件上。其它组件会在单独的章节中讲到。NIO与传统socket最大的不同就是引入了Channel和多路复用selector的概念。传统的socket是基于stream的，它是单向的，有InputStream表示read和OutputStream表示写。而Channel是双工的，既支持读也支持写，channel的读/写都是面向Buffer。 NIO中引入的多路复用Selector机制（如果是linux系统，则应用的epoll事件通知机制）可使一个线程同时监听多个Channel上发生的事件。 虽然Java NIO相比于以往确实是一个大的突破，但是如果要真正上手进行开发，且想要开发出好的一个服务端网络程序，那么你得要花费一点功夫了，毕竟Java NIO只是提供了一大堆的API而已，对于一般的软件开发人员来说只能呵呵了。因此，社区中就涌现了很多基于Java NIO的网络应用框架，其中以Apache的Mina，以及Netty最为出名，从本篇开始我们将深入的分析一下Netty的内部实现细节 。

在分析源码之前，我们还是先看看Netty官方的样例代码，了解一下Netty一般是如何进行服务端及客户端开发的。

Netty服务端示例：

EventLoopGroup bossGroup = new NioEventLoopGroup(); // (1)
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
    ServerBootstrap b = new ServerBootstrap(); // (2)
    b.group(bossGroup, workerGroup)　　// (3)
     .channel(NioServerSocketChannel.class) // (4)
     .handler(new LoggingHandler())    // (5)
     .childHandler(new ChannelInitializer() { // (6)
         @Override
         public void initChannel(SocketChannel ch) throws Exception {
             ch.pipeline().addLast(new DiscardServerHandler());
         }
     })
     .option(ChannelOption.SO_BACKLOG, 128)          // (7)
     .childOption(ChannelOption.SO_KEEPALIVE, true); // (8)

     // Bind and start to accept incoming connections.
     ChannelFuture f = b.bind(port).sync(); // (9)

     // Wait until the server socket is closed.
     // In this example, this does not happen, but you can do that to gracefully
     // shut down your server.
     f.channel().closeFuture().sync();
} finally {
    workerGroup.shutdownGracefully();
    bossGroup.shutdownGracefully();
}

根据注释中的备注分析一波服务端的代码

1、 初始化用于Acceptor的主”线程池”以及用于I/O工作的从”线程池”； 
2、 初始化ServerBootstrap实例，此实例是netty服务端应用开发的入口，也是本篇介绍的重点， 下面我们会深入分析； 
3、通过ServerBootstrap的group方法，设置（1）中初始化的主从”线程池”； 
4、指定通道channel的类型，由于是服务端，故而是NioServerSocketChannel； 
5、设置ServerSocketChannel的处理器（此处不详述，后面的系列会进行深入分析） 
6、设置子通道也就是SocketChannel的处理器， 其内部是实际业务开发的”主战场”（此处不详述，后面的系列会进行深入分析） 
7、配置ServerSocketChannel的选项 
8、 配置子通道也就是SocketChannel的选项 
9、 绑定并侦听某个端口

接着，我们再看看客户端端是如何开发的：

Netty客户端示例：

public class TimeClient {
    public static void main(String[] args) throws Exception {
        String host = args[0];
        int port = Integer.parseInt(args[1]);
        EventLoopGroup workerGroup = new NioEventLoopGroup(); // (1)

        try {
            Bootstrap b = new Bootstrap(); // (2)
            b.group(workerGroup); // (3)
            b.channel(NioSocketChannel.class); // (4)
            b.option(ChannelOption.SO_KEEPALIVE, true); // (5)
            b.handler(new ChannelInitializer() { // (6)
                @Override
                public void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new TimeClientHandler());
                }
            });

            // Start the client.
            ChannelFuture f = b.connect(host, port).sync(); // (7)

            // Wait until the connection is closed.
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
        }
    }
}

根据注释中的备注分析一波客户端的代码：

1、 初始化用于连接及I/O工作的”线程池”； 
2、 初始化Bootstrap实例， 此实例是netty客户端应用开发的入口，也是本篇介绍的重点， 下面我们会深入分析； 
3、 通过Bootstrap的group方法，设置（1）中初始化的”线程池”； 
4、 指定通道channel的类型，由于是客户端，故而是NioSocketChannel； 
5、 设置SocketChannel的选项（此处不详述，后面的系列会进行深入分析）； 
6、 设置SocketChannel的处理器， 其内部是实际业务开发的”主战场”（此处不详述，后面的系列会进行深入分析）； 
7、 连接指定的服务地址；

在分析之前先来，相信大家都清楚了ServerBootstrap和Bootstrap的大致关系

1.如图AbstractBootstrap类是ServerBootstrap及Bootstrap的基类

netty理论之源码分析① Bootstrap和ServerBootstrap_第1张图片

2.ServerBootstrap绑定到指定端口来监听客户端连接请求，Bootstrap连接至远程服务端。并且ServerBootstrap包含两个EventLoopGroup，而Bootstrap只包含一个EventLoopGroup。ServerBootstrap包含两组通道，第一组包含一个ServerChannel，表示服务器绑定到本地端口的监听套接字；第二组包含用来处理客户端连接所创建的所有通道，每接受一个连接时便会创建一个通道，下图显示了ServerBootstrap的两个EventLoopGroup。

一、先从AbstractBootstrap讲起

我们先看一下AbstractBootstrap类的主要代码：

public abstract class AbstractBootstrap, C extends Channel> implements Cloneable {

    volatile EventLoopGroup group;
    private volatile ChannelFactory channelFactory;
    private final Map, Object> options = new LinkedHashMap, Object>();
    private final Map, Object> attrs = new LinkedHashMap, Object>();
    private volatile ChannelHandler handler;


    public B group(EventLoopGroup group) {
        if (group == null) {
            throw new NullPointerException("group");
        }
        if (this.group != null) {
            throw new IllegalStateException("group set already");
        }
        this.group = group;
        return self();
    }

    private B self() {
        return (B) this;
    }

    public B channel(Class channelClass) {
        if (channelClass == null) {
            throw new NullPointerException("channelClass");
        }
        return channelFactory(new ReflectiveChannelFactory(channelClass));
    }

    @Deprecated
    public B channelFactory(ChannelFactory channelFactory) {
        if (channelFactory == null) {
            throw new NullPointerException("channelFactory");
        }
        if (this.channelFactory != null) {
            throw new IllegalStateException("channelFactory set already");
        }

        this.channelFactory = channelFactory;
        return self();
    }

    public B channelFactory(io.netty.channel.ChannelFactory channelFactory) {
        return channelFactory((ChannelFactory) channelFactory);
    }

    public  B option(ChannelOption option, T value) {
        if (option == null) {
            throw new NullPointerException("option");
        }
        if (value == null) {
            synchronized (options) {
                options.remove(option);
            }
        } else {
            synchronized (options) {
                options.put(option, value);
            }
        }
        return self();
    }

    public  B attr(AttributeKey key, T value) {
        if (key == null) {
            throw new NullPointerException("key");
        }
        if (value == null) {
            synchronized (attrs) {
                attrs.remove(key);
            }
        } else {
            synchronized (attrs) {
                attrs.put(key, value);
            }
        }
        return self();
    }

    public B validate() {
        if (group == null) {
            throw new IllegalStateException("group not set");
        }
        if (channelFactory == null) {
            throw new IllegalStateException("channel or channelFactory not set");
        }
        return self();
    }

    public ChannelFuture bind(int inetPort) {
        return bind(new InetSocketAddress(inetPort));
    }

    public ChannelFuture bind(SocketAddress localAddress) {
        validate();
        if (localAddress == null) {
            throw new NullPointerException("localAddress");
        }
        return doBind(localAddress);
    }

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

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

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

        return regFuture;
    }

    abstract void init(Channel channel) throws Exception;

    private static void doBind0(
            final ChannelFuture regFuture, final Channel channel,
            final SocketAddress localAddress, final ChannelPromise promise) {

        // This method is invoked before channelRegistered() is triggered.  Give user handlers a chance to set up
        // the pipeline in its channelRegistered() implementation.
        channel.eventLoop().execute(new Runnable() {
            @Override
            public void run() {
                if (regFuture.isSuccess()) {
                    channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
                } else {
                    promise.setFailure(regFuture.cause());
                }
            }
        });
    }

    public B handler(ChannelHandler handler) {
        if (handler == null) {
            throw new NullPointerException("handler");
        }
        this.handler = handler;
        return self();
    }public abstract AbstractBootstrapConfig config();

}

现在我们以示例代码为出发点，来详细分析一下引导类内部实现细节：

1、 首先看看服务端的b.group(bossGroup, workerGroup)：

调用ServerBootstrap的group方法，设置react模式的主线程池 以及 IO 操作线程池，ServerBootstrap中的group代码如下：

public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) {
        super.group(parentGroup);
        if (childGroup == null) {
            throw new NullPointerException("childGroup");
        }
        if (this.childGroup != null) {
            throw new IllegalStateException("childGroup set already");
        }
        this.childGroup = childGroup;
        return this;
    }

在group方法中，会继续调用父类的group方法，而通过类继承图我们知道，super.group(parentGroup)其实调用的就是AbstractBootstrap的group方法。AbstractBootstrap中group代码如下：

public B group(EventLoopGroup group) {
    if (group == null) {
        throw new NullPointerException("group");
    }
    if (this.group != null) {
        throw new IllegalStateException("group set already");
    }
    this.group = group;
    return self();
}

通过以上分析，我们知道了AbstractBootstrap中定义了主线程池group的引用，而子线程池childGroup的引用是定义在ServerBootstrap中。

当我们查看客户端Bootstrap的group方法时，我们发现，其是直接调用的父类AbstractBoostrap的group方法。

2、示例代码中的 channel()方法

无论是服务端还是客户端，channel调用的都是基类的channel方法，其实现细节如下：

public B channel(Class channelClass) {
    if (channelClass == null) {
        throw new NullPointerException("channelClass");
    }
    return channelFactory(new ReflectiveChannelFactory(channelClass));
}


=====================================================

public B channelFactory(ChannelFactory channelFactory) {
    if (channelFactory == null) {
        throw new NullPointerException("channelFactory");
    }
    if (this.channelFactory != null) {
        throw new IllegalStateException("channelFactory set already");
    }

    this.channelFactory = channelFactory;
    return self();
}

3、option / handler / attr 方法

option： 设置通道的选项参数， 对于服务端而言就是ServerSocketChannel， 客户端而言就是SocketChannel；

handler： 设置主通道的处理器， 对于服务端而言就是ServerSocketChannel，也就是用来处理Acceptor的操作；对于客户端的SocketChannel，主要是用来处理 业务操作；

attr： 设置通道的属性；

option / handler / attr方法都定义在AbstractBootstrap中， 所以服务端和客户端的引导类方法调用都是调用的父类的对应方法。

4、childHandler / childOption / childAttr 方法（只有服务端ServerBootstrap才有child类型的方法）

对于服务端而言，有两种通道需要处理， 一种是ServerSocketChannel：用于处理用户连接的accept操作， 另一种是SocketChannel，表示对应客户端连接。而对于客户端，一般都只有一种channel，也就是SocketChannel。

因此以child开头的方法，都定义在ServerBootstrap中，表示处理或配置服务端接收到的对应客户端连接的SocketChannel通道。

childHandler / childOption / childAttr 在ServerBootstrap中的对应代码如下：

public ServerBootstrap childHandler(ChannelHandler childHandler) {
    if (childHandler == null) {
        throw new NullPointerException("childHandler");
    }
    this.childHandler = childHandler;
    return this;
}

=======================================================================

public  ServerBootstrap childOption(ChannelOption childOption, T value) {
    if (childOption == null) {
        throw new NullPointerException("childOption");
    }
    if (value == null) {
        synchronized (childOptions) {
            childOptions.remove(childOption);
        }
    } else {
        synchronized (childOptions) {
            childOptions.put(childOption, value);
        }
    }
    return this;
}


===========================================================================


public  ServerBootstrap childAttr(AttributeKey childKey, T value) {
    if (childKey == null) {
        throw new NullPointerException("childKey");
    }
    if (value == null) {
        childAttrs.remove(childKey);
    } else {
        childAttrs.put(childKey, value);
    }
    return this;
}

上面是引导类的属性配置都设置完毕了。

二、接下来介绍Bootstrap和ServerBootStrap（部分介绍和一重复）

Bootstrap是netty中用于创建Server、Client端代码的构造工具类，里面包括了启动Server、Client需要的配置信息等。下面用一段代码来初步了解下。

// 创建ServerBootstrap
ServerBootstrap bootstrap = new ServerBootstrap();
// 创建用户acceptor和dispatcher io event的io线程池
EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
	// 设置server的channel类型为NioServerSocketChannel
    bootstrap.channel(NioServerSocketChannel.class)
            // 设置对应的io线程池
            .group(bossGroup, workerGroup)
            // 设置新建连接的处理器
            .childHandler(new ChannelInitializer() {
                protected void initChannel(SocketChannel ch) throws Exception {
                    // 对于新建的连接，在它的ChannelPipeline上增加一个EchoHandler
                    ch.pipeline().addLast(new EchoHandler());
                }
            });
    // 绑定到8090
    ChannelFuture bind = bootstrap.bind(8090);
    // netty中大多数操作都是异步的，所以上面的bind方法会立刻返回并返回一个Future, 需要sync阻塞等待bind成功
    bind.sync();
    // 一直阻塞当前线程知道server channel关闭
    bind.channel().closeFuture().sync();
} finally {
	// 关闭线程池
    bossGroup.shutdownGracefully().sync();
    workerGroup.shutdownGracefully().sync();
}

BootStrap源码分析

下图简单描述了一下BootStrap

netty理论之源码分析① Bootstrap和ServerBootstrap_第2张图片

主要的代码类为

  • io.netty.bootstrap.Bootstrap
  • io.netty.bootstrap.ServerBootstrap
  • io.netty.bootstrap.AbstractBootstrap
  • io.netty.bootstrap.AbstractBootstrapConfig
  • io.netty.bootstrap.ServerBootstrapConfig
  • io.netty.bootstrap.BootstrapConfig

AbstractBootstrap

AbstractBootstrap通过提供chain方法链提供方面的Channel配置方式。
这里要了解一种很多代码中用到的看上去不太好懂的Hierarchical Builder模式。（完整AbstractBootstrap代码如上）


public abstract class AbstractBootstrap, C extends Channel> implements Cloneable {
...
/**
     * The {@link EventLoopGroup} which is used to handle all the events for the to-be-created
     * {@link Channel}
     */
public B group(EventLoopGroup group) {
if (group == null) {
throw new NullPointerException("group");
}
if (this.group != null) {
throw new IllegalStateException("group set already");
}
this.group = group;
return self();
}
@SuppressWarnings("unchecked")
private B self() {
return (B) this;
}

这里的AbstractBootstrap 返回了B类型的对象，这样又可以通过其他方法返回B的串联起来，这些方法最后都调用了B self()返回this, 这个this的类型是子类型，这样子类就可以直接使用而不必强行转换父类型到子类型了。
这时ServerBootstrap继承AbstractBootstrap并将B设置为自己时，就可以方便的在AbstractBootstrap基础上增加配置方法了。


public class ServerBootstrap extends AbstractBootstrap {
	public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) {
super.group(parentGroup);
if (childGroup == null) {
throw new NullPointerException("childGroup");
}
if (this.childGroup != null) {
throw new IllegalStateException("childGroup set already");
}
this.childGroup = childGroup;
return this;
}
...
}

这里的ServerBootstrap在AbstractBootstrap的基础上又添加了group(parentGroup, childGroup)的方法。所以这种写法很适合多级Builder。
当子类继承

AbstractBootstrapConfig

AbstratBootstrapConfig向外暴露AbstractBootstrap的配置。


public abstract class AbstractBootstrapConfig, C extends Channel> {
protected final B bootstrap;
protected AbstractBootstrapConfig(B bootstrap) {
this.bootstrap = ObjectUtil.checkNotNull(bootstrap, "bootstrap");
}
/**
     * Returns the configured local address or {@code null} if non is configured yet.
     */
public final SocketAddress localAddress() {
return bootstrap.localAddress();
}

AbstractBootstrapConfig提供基础的AbstractBootstrap拥有的配置，具体子类又可以提供其具体AbstractBootstrap的配置，
例如ServerBootstrapConfig中B为ServerBoostrap，就可以返回更多的ServerBootstrap中的方法例如childGroup等。


ublic final class ServerBootstrapConfig extends AbstractBootstrapConfig {
ServerBootstrapConfig(ServerBootstrap bootstrap) {
super(bootstrap);
}
/**
     * Returns the configured {@link EventLoopGroup} which will be used for the child channels or {@code null}
     * if non is configured yet.
     */
@SuppressWarnings("deprecation")
public EventLoopGroup childGroup() {
return bootstrap.childGroup();
}
...

ServerBootstrap bind过程

通常在给ServerBootstrap配置好各种参数后的最后一步就是bind。
Server的bind将创建一个本地的ServerSocket绑定到对应端口上，并且配置接受到新的socket后的处理等。
下面看一下具体的bind过程。

AbstractBootstrap中


/**
     * Create a new {@link Channel} and bind it.
     */
public ChannelFuture bind(SocketAddress localAddress) {
validate();
if (localAddress == null) {
throw new NullPointerException("localAddress");
}
return doBind(localAddress);
}


=====================================================

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

  • 负责通过ChannelFactory创建Channel

  • 初始化 init Channel

  • 注册Channel到EventLoopGroup上


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();
}
}
// If we are here and the promise is not failed, it's one of the following cases:
// 1) If we attempted registration from the event loop, the registration has been completed at this point.
//    i.e. It's safe to attempt bind() or connect() now because the channel has been registered.
// 2) If we attempted registration from the other thread, the registration request has been successfully
//    added to the event loop's task queue for later execution.
//    i.e. It's safe to attempt bind() or connect() now:
//         because bind() or connect() will be executed *after* the scheduled registration task is executed
//         because register(), bind(), and connect() are all bound to the same thread.
return regFuture;
}

通过ServerBootstrap.channel(NioServerSocketChannel.class)这样配置的ServerBootstrap
使用的是ReflectiveChannelFactory, 通过对应的类的构造器反射创建Channel对象。

ServerBootstrap的init方法中将前面配置的Bootstrap的attr、option等设置到Channel上
然后给当前ServerChannel增加一个ChannelInitializer, initChannel会在Channel注册完成后调用，
这里会给Channel添加Bootstrap中配置的Handler，然后给继续在pipeline上添加一个ServerBootstrapAcceptor。
ServerBootstrapAcceptor就是ServerSocket接受到新建的socket连接的处理。
注意到这里给pipeline添加ServerBootstrapAcceptor放到的channel的eventloop中去执行，这样做的原因是


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(childOptions.size()));
}
synchronized (childAttrs) {
currentChildAttrs = childAttrs.entrySet().toArray(newAttrArray(childAttrs.size()));
}
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。
											ServerBootstrapAcceptor就是ServerSocket接受到新建的socket连接的处理。(
ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
}
});
}
});
} 
  
ServerBootstrapAcceptor
 首先给接受到的Channel(child)添加配置的childHandler、设置ChannelOption、ChannelAttribute等。
 然后注册到childGroup上，对应于上面示例代码中的workerGroup。
 
  

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);
} 
  
注册到EventLoopGruop上
 
  
	
ChannelFuture regFuture = config().group().register(channel);
 
  
NioEventLoopGroup继承于MultithreadEventLoopGroup，next()方法会round-robin的方式选出一个NioEventLoop，
 然后设置Channel的eventLoop为这个NioEventLoop然后发出channelRegister事件等。@Override
 public ChannelFuture register(Channel channel) {
 return next().register(channel);
 }
 
  
MultithreadEventLoopGroup
 
  

@Override
public ChannelFuture register(Channel channel) {
return next().register(channel);
}
	public EventExecutor next() {
return chooser.next();
}
 
  
chooser的作用是从EventExecutor中选出一个作为next的返回结果
 
  

public EventExecutorChooser newChooser(EventExecutor[] executors) {
if (isPowerOfTwo(executors.length)) {
return new PowerOfTwoEventExecutorChooser(executors);
} else {
return new GenericEventExecutorChooser(executors);
}
}
 
  
NioEventLoop继承于SingleThreadEventLoop
 
  

public ChannelFuture register(final ChannelPromise promise) {
ObjectUtil.checkNotNull(promise, "promise");
promise.channel().unsafe().register(this, promise);
return promise;
}
 
  
AbstractChannel
 这里register中的处理是
 设置当前Channel的eventLoop，fireChannelRegister事件，如果当前Channel是active状态并且是第一次注册则fireChannelActive事件
 
  

public final void register(EventLoop eventLoop, final ChannelPromise promise) {
if (eventLoop == null) {
throw new NullPointerException("eventLoop");
}
if (isRegistered()) {
promise.setFailure(new IllegalStateException("registered to an event loop already"));
return;
}
if (!isCompatible(eventLoop)) {
promise.setFailure(
new IllegalStateException("incompatible event loop type: " + eventLoop.getClass().getName()));
return;
}
AbstractChannel.this.eventLoop = eventLoop;
if (eventLoop.inEventLoop()) {
register0(promise);
} else {
try {
eventLoop.execute(new Runnable() {
@Override
public void run() {
register0(promise);
}
});
} catch (Throwable t) {
logger.warn(
"Force-closing a channel whose registration task was not accepted by an event loop: {}",
AbstractChannel.this, t);
closeForcibly();
closeFuture.setClosed();
safeSetFailure(promise, t);
}
}
}
 
  
initAndRegister完成后，会进行doBind0
 
  
private static void doBind0(
					final ChannelFuture regFuture, final Channel channel,
					final SocketAddress localAddress, final ChannelPromise promise) {
			// This method is invoked before channelRegistered() is triggered.  Give user handlers a chance to set up
			// the pipeline in its channelRegistered() implementation.
			channel.eventLoop().execute(new Runnable() {
					@Override
					public void run() {
							if (regFuture.isSuccess()) {
									channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
							} else {
									promise.setFailure(regFuture.cause());
							}
					}
			});
	}
 
  
doBind0调用AbstractChannel的bind方法，然后调用pipeline.bind。
 后面会讲到ChannelPipeline，ChannelPipeline中有一个特殊的ChannelHandler是HeadContext，作为pipelien的head节点。
 
  
public void bind(
ChannelHandlerContext ctx, SocketAddress localAddress, ChannelPromise promise)
throws Exception {
unsafe.bind(localAddress, promise);
}
 
  
unsafe是一个接口，不同的io channel有不同的实现，
 NioServerSocketChannel
 可以看到java7以上使用jdk的ServerSocketChannel.bind方法，小于的版本得到对应的socket后进行bind
 
  
protected void doBind(SocketAddress localAddress) throws Exception {
if (PlatformDependent.javaVersion() >= 7) {
javaChannel().bind(localAddress, config.getBacklog());
} else {
javaChannel().socket().bind(localAddress, config.getBacklog());
}
}
 
  
 
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(netty)

        

            

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

                        
    本文还有配套的精品资源，点击获取简介：Java面试宝典是求职或晋升的必备参考资料，涵盖了Java、Redis、SpringBoot、Netty、虚拟机、前端、SpringCloud、MySQL和RocketMQ等热门技术领域的最新知识。掌握这些知识点不仅有助于面试成功，还能提升专业技能，在IT行业保持竞争力。1.Java基础与核心技术Java作为一门面向对象的编程语言，在IT行业中广泛应用。本章将
    
                    
    • 
                    
  • JDK 官方迁移指南中文版（基于 JDK 8 → JDK 11 → JDK 17）
                        金州小铁匠
java开发语言
                        
    JDK官方迁移指南中文版（基于JDK8→JDK11→JDK17）一、迁移前的准备工作环境评估与兼容性检查操作系统支持：确保当前系统支持目标JDK版本。例如，JDK17要求Windows10/11、macOSBigSur或更高版本，以及主流Linux发行版。第三方依赖审查：检查项目中使用的框架（如SpringBoot）、工具（如Maven/Gradle）和库（如Netty、Lombok）是否兼容目标
    
                    
    • 
                    
  • Netty解决TCP粘包拆包问题
                        is_Peng
Java基础javanettysocket网络通信网络
                        
    什么是TCP粘包/拆包TCP是一种面向连接的、可靠的、基于字节流的传输层通信协议。TCP是基于字节流传输的，就像河流一样，数据“流”式传输，数据中间没有分界。TCP底层并不了解上层业务数据的具体含义，它会根据TCP缓冲区的实际情况进行包的划分，所以一个完整的数据包可能会拆分成多个包传输，或者多个数据包可能会合并成一个包传输，这就是所谓的TCP的粘包/拆包问题。如下图所示：正常业务逻辑上，Clien
    
                    
    • 
                    
  • Spark源码分析
                        数据年轮
Sparkspark源码spark大数据源码分析
                        
    过程描述:1.通过Shell脚本启动Master，Master类继承Actor类，通过ActorySystem创建并启动。2.通过Shell脚本启动Worker，Worker类继承Actor类，通过ActorySystem创建并启动。3.Worker通过Akka或者Netty发送消息向Master注册并汇报自己的资源信息(内存以及CPU核数等)，以后就是定时汇报，保持心跳。4.Master接受消息
    
                    
    • 
                    
  • 分库分表后，有哪些查询问题？该如何解决？
                        码炫课堂-码哥
java面试题面试分库分表
                        
    作者简介：大家好，我是码炫码哥，前中兴通讯、美团架构师，现任某互联网公司CTO，兼职码炫课堂主讲源码系列专题代表作：《jdk源码&多线程&高并发》，《深入tomcat源码解析》，《深入netty源码解析》，《深入dubbo源码解析》，《深入springboot源码解析》，《深入spring源码解析》，《深入redis源码解析》等联系qq：184480602，加我进群，大家一起学习，一起进步，一起对
    
                    
    • 
                    
  • 2024Java零基础自学路线（Java基础、Java高并发、MySQL、Spring、Redis、设计模式、Spring Cloud）
                        ekskef_sef
面试学习路线阿里巴巴javaspringmysql
                        
    目录一、Java基础1、Java基础3、Java8新特性4、Java集合5、Java高并发6、Java代码实例二、MySQL数据库三、SpringBoot框架（35天）四、微服务SpringCloud四、Redis中间件五、MongoDB数据库六、Netty网络编程七、23种设计模式八、Dubbo九、JavaScript零基础入门十、Vue基础知识十一、数据结构与算法大家好，我是哪吒。现在网上的学
    
                    
    • 
                    
  • UDP协议转换TCP协议
                        在下陈平安
网络通信
                        
    UDP协议转换TCP协议项目背景：项目类似中间件作用是数据搬运，可以搬运文件，视频，音频。从互联网把数据搬运到内网中。有的时候拉取视频流数据的时候使用UDP拉取会存在丢包的情况通过TCP拉拉取视频流数据再通过UDP发送这样可以保证质量也能提高效率。着重说明协议转换使用的技术1.netty2.scoket过程描述测试利用两个视频开源平台LiveGBS一个放在内网中充当视频播放设备此处命名为SPA2一
    
                    
    • 
                    
  • 2024最强Java面试八股文（精简、纯手打）
                        m0_74823021
面试学习路线阿里巴巴java面试开发语言
                        
    2024最新最全国内大厂Java面试高频题库本小册内容涵盖：Java基础，JVM，多线程，数据库（MySQL/Redis）SSM，Dubbo，网络，MQ，Zookeeper，Netty，微服务，大数据，算法，项目，设计模式等，篇幅足足近2千页，大家面试前拿去提前刷刷，一、基础篇1.接口和抽象类的区别相似点：（1）接口和抽象类都不能被实例化（2）实现接口或继承抽象类的普通子类都必须实现这些抽象方法不
    
                    
    • 
                    
  • async-http-client使用示例
                        光芒再现0394
http网络协议网络
                        
    文章目录概要整体架构流程技术名词解释技术细节小结概要async-http-client是一个用于Java平台的高性能、非阻塞HTTP客户端库，它允许开发者以异步的方式发送HTTP请求并处理响应，从而提高应用程序的性能和响应性。主要特点异步处理：基于Netty框架实现，支持异步发送HTTP请求和处理响应，避免了传统同步请求中的阻塞。支持多种请求方法：支持GET、POST、PUT、DELETE等常见的
    
                    
    • 
                    
  • Netty HTTP2 示例-响应式编程-013
                        ApiHug
ApiHugintellij-ideajavaspringspringboot
                        
    ApiHug×{Postman|Swagger|Api...}=快↑准√省↓GitHub-apihug/apihug.com:AllaboutheApihugapihug.com:有爱，有温度，有质量，有信任ApiHug-APIdesignCopilot-IntelliJIDEsPlugin|MarketplaceTheNextGenerationAPIDevelopmentPlatform-Ap
    
                    
    • 
                    
  • Reactor Netty TCP 服务器端-响应式编程-011
                        ApiHug
intellij-ideaspringspringbootApiHug
                        
    ApiHug×{Postman|Swagger|Api...}=快↑准√省↓GitHub-apihug/apihug.com:AllaboutheApihugapihug.com:有爱，有温度，有质量，有信任ApiHug-APIdesignCopilot-IntelliJIDEsPlugin|MarketplaceTheNextGenerationAPIDevelopmentPlatform-Ap
    
                    
    • 
                    
  • 面试官：谈谈你对IO多路复用的理解？
                        
java后端
                        
    “IO多路复用”是编程中常见的技术词汇，使用这种技术的框架有很多，如，Redis、Kafka、Netty、Nginx中都用到了此技术。那问题来了，什么是IO多路复用？它的具体实现技术有哪些？这些技术之间有什么区别？今天我们就来简单的探讨一下。1.什么是IO多路复用？IO多路复用技术是一种允许单个线程管理多个网络连接的技术，它使得服务器能够高效地处理大量的并发连接而不需要为每个连接创建一个独立的线程
    
                    
    • 
                    
  • dubbo实战之一：准备和初体验，Java进阶
                        阿伦Java
javazookeeperrpc
                        
    org.apache.dubbodubbo-dependencies-bom${dubbo.version}pomimportio.nettynetty-all4.1.25.Finalorg.apache.dubbodubbo${dubbo.version}org.apache.dubbodubbo-dependencies-zookeeper${dubbo.version}pomorg.apac
    
                    
    • 
                    
  • RocketMQ中的NameServer主要数据结构
                        小园子的小菜
MQrocketmqjava-rocketmqjava中间件
                        
    1.前言NameServer是RocketMQ中的一个比较重要的组件，我们这篇博客针对NameSever中包含的组件进行分析，分析一下NameServer中包含的组件以及组件的作用。以前我有一篇博客中rocketMq源码分析之搭建本地环境-CSDN博客，在这篇博客中就简单看了下NameSever中会有两个组件：NamesrvConfig和NettyServerConfig。在这里就不在进行介绍。2
    
                    
    • 
                    
  • Orleans7.0 游戏服务器全栈开发实战
                        
unity
                        
    本课程目标是从零开始搭建一套基于微软Orleans和DotNetty开源方案的游戏服务器框架，框架遵守Actor模型，可以充分利用多核，方便水平扩展。并且使用.NET平台，开发和部署都非常便捷。为了演示功能，也实现了一个简单的Unity客户端框架，最后使用这个框架实现了一个井字棋的对战小案例，来教会大家学以致用。这个案例演示了如何登录、开房间、匹配、对战、结算以及断线重连等一系列回合制游戏的关键节
    
                    
    • 
                    
  • Netty中用了哪些设计模式？
                        java1234_小锋
java设计模式java面试
                        
    大家好，我是锋哥。今天分享关于【Netty中用了哪些设计模式？】面试题。希望对大家有帮助；Netty中用了哪些设计模式？1000道互联网大厂Java工程师精选面试题-Java资源分享网Netty是一个基于Java的高性能网络应用框架，它通过对网络通信的抽象和优化，广泛应用于分布式系统、实时通信、游戏服务器等领域。在Netty的设计中，使用了多种设计模式来提高代码的可维护性、扩展性和灵活性。以下是N
    
                    
    • 
                    
  • 2025春招，Netty面试题汇总
                        
javanetty面试
                        
    大家好，我是V哥。2025年春招Java面试，肯定绕不开Netty的相关问题，V哥替大家跟几位大厂技术主管交流后，整理的一些2025年可能会遇到的Netty面试题，涵盖基础概念、核心组件、性能优化、故障排查等方面，分享给大家，收藏起来备用。基础概念类请简要介绍一下Netty是什么，以及它的主要应用场景有哪些？参考答案：Netty是一个基于JavaNIO封装的高性能网络编程框架，它简化了网络编程的复
    
                    
    • 
                    
  • Java 技术全栈深度探索：从基础到企业级应用实践
                        智界工具库
java开发语言
                        
    文章简介：本文是一篇全面深入的Java课程文章，围绕众多关键技术领域展开。从RPC框架、注册中心等分布式核心组件，到数据中台、服务容错等企业级架构要点；从Spring生态剖析到电商、直播答题等多类型项目实战；涵盖容器云、监控、测试、CI&CD平台实践以及问题定位与安全分析等运维保障内容；还涉及Netty网络编程、X2C需求设计及大数据集群资源评估等。通过系统的讲解与案例剖析，助力读者深入理解Jav
    
                    
    • 
                    
  • IM 即时通讯系统-51-MPush开源实时消息推送系统
                        老马啸西风
IM开源javaIM分布式
                        
    IM开源系列IM即时通讯系统-41-开源野火IM专注于即时通讯实时音视频技术，提供优质可控的IM+RTC能力IM即时通讯系统-42-基于netty实现的IM服务端,提供客户端jar包,可集成自己的登录系统IM即时通讯系统-43-简单的仿QQ聊天安卓APPIM即时通讯系统-44-仿QQ即时通讯系统服务端IM即时通讯系统-45-merua0oo0IM分布式聊天系统IM即时通讯系统-46-OpenIM提
    
                    
    • 
                    
  • 2024年最全Doris：读取Doris数据的N种方法_访问 doris，阿里大牛教你自己写大数据开发第三方库
                        2401_84181108
程序员大数据
                        
    网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化资料的朋友，可以戳这里获取一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！arrow-memory-netty${arrow.v
    
                    
    • 
                    
  • IM 即时通讯系统-44-仿QQ即时通讯系统服务端
                        老马啸西风
IMIMjava
                        
    IM开源系列IM即时通讯系统-41-开源野火IM专注于即时通讯实时音视频技术，提供优质可控的IM+RTC能力IM即时通讯系统-42-基于netty实现的IM服务端,提供客户端jar包,可集成自己的登录系统IM即时通讯系统-43-简单的仿QQ聊天安卓APPIM即时通讯系统-44-仿QQ即时通讯系统服务端IM即时通讯系统-45-merua0oo0IM分布式聊天系统IM即时通讯系统-46-OpenIM提
    
                    
    • 
                    
  • IM 即时通讯系统-42-基于netty实现的IM服务端,提供客户端jar包,可集成自己的登录系统
                        老马啸西风
java
                        
    IM开源系列IM即时通讯系统-41-开源野火IM专注于即时通讯实时音视频技术，提供优质可控的IM+RTC能力IM即时通讯系统-42-基于netty实现的IM服务端,提供客户端jar包,可集成自己的登录系统IM即时通讯系统-43-简单的仿QQ聊天安卓APPIM即时通讯系统-44-仿QQ即时通讯系统服务端IM即时通讯系统-45-merua0oo0IM分布式聊天系统IM即时通讯系统-46-OpenIM提
    
                    
    • 
                    
  • IM 即时通讯系统-47-beardlessCat IM 使用netty开发分布式Im，提供分布netty集群解决方案
                        老马啸西风
IM分布式javaIM
                        
    IM开源系列IM即时通讯系统-41-开源野火IM专注于即时通讯实时音视频技术，提供优质可控的IM+RTC能力IM即时通讯系统-42-基于netty实现的IM服务端,提供客户端jar包,可集成自己的登录系统IM即时通讯系统-43-简单的仿QQ聊天安卓APPIM即时通讯系统-44-仿QQ即时通讯系统服务端IM即时通讯系统-45-merua0oo0IM分布式聊天系统IM即时通讯系统-46-OpenIM提
    
                    
    • 
                    
  • IM 即时通讯系统-41-开源 野火IM 专注于即时通讯实时音视频技术，提供优质可控的IM+RTC能力
                        
后端java
                        
    IM开源系列IM即时通讯系统-41-开源野火IM专注于即时通讯实时音视频技术，提供优质可控的IM+RTC能力IM即时通讯系统-42-基于netty实现的IM服务端,提供客户端jar包,可集成自己的登录系统IM即时通讯系统-43-简单的仿QQ聊天安卓APPIM即时通讯系统-44-仿QQ即时通讯系统服务端IM即时通讯系统-45-merua0oo0IM分布式聊天系统IM即时通讯系统-46-OpenIM提
    
                    
    • 
                                
  • Hadoop(一)
                                    朱辉辉33
hadooplinux
                                    
    今天在诺基亚第一天开始培训大数据，因为之前没接触过Linux，所以这次一起学了，任务量还是蛮大的。 
首先下载安装了Xshell软件，然后公司给了账号密码连接上了河南郑州那边的服务器，接下来开始按照给的资料学习，全英文的，头也不讲解，说锻炼我们的学习能力，然后就开始跌跌撞撞的自学。这里写部分已经运行成功的代码吧. 
   在hdfs下，运行hadoop fs -mkdir /u
    
                                
    • 
                                
  • maven An error occurred while filtering resources
                                    blackproof
maven报错
                                    
    转：http://stackoverflow.com/questions/18145774/eclipse-an-error-occurred-while-filtering-resources 
  
maven报错： 
maven An error occurred while filtering resources 
  
Maven -> Update Proje
    
                                
    • 
                                
  • jdk常用故障排查命令
                                    daysinsun
jvm
                                    
    linux下常见定位命令： 
1、jps      输出Java进程 
      -q       只输出进程ID的名称，省略主类的名称； 
      -m      输出进程启动时传递给main函数的参数； 
    &nb
    
                                
    • 
                                
  • java 位移运算与乘法运算
                                    周凡杨
java位移运算乘法
                                    
      
对于 JAVA 编程中，适当的采用位移运算，会减少代码的运行时间，提高项目的运行效率。这个可以从一道面试题说起：  
   
   问题：  
用最有效率的方法算出2   乘以8   等於几?”        
答案：2 << 3    
由此就引发了我的思考，为什么位移运算会比乘法运算更快呢？其实简单的想想，计算机的内存是用由 0 和 1 组成的二
    
                                
    • 
                                
  • java中的枚举(enmu)
                                    g21121
java
                                    
    从jdk1.5开始，java增加了enum(枚举)这个类型，但是大家在平时运用中还是比较少用到枚举的，而且很多人和我一样对枚举一知半解，下面就跟大家一起学习下enmu枚举。先看一个最简单的枚举类型，一个返回类型的枚举： 
public enum ResultType {
	
	/**
	 * 成功
	 */
	SUCCESS,
	/**
	 * 失败
	 */
	FAIL,
	
    
                                
    • 
                                
  • MQ初级学习
                                    510888780
activemq
                                    
    1.下载ActiveMQ 
去官方网站下载：http://activemq.apache.org/ 
 
2.运行ActiveMQ 
解压缩apache-activemq-5.9.0-bin.zip到C盘，然后双击apache-activemq-5.9.0-\bin\activemq-admin.bat运行ActiveMQ程序。 
 
启动ActiveMQ以后，登陆：http://localhos
    
                                
    • 
                                
  • Spring_Transactional_Propagation
                                    布衣凌宇
springtransactional
                                    
    //事务传播属性 
@Transactional(propagation=Propagation.REQUIRED)//如果有事务，那么加入事务，没有的话新创建一个 
@Transactional(propagation=Propagation.NOT_SUPPORTED)//这个方法不开启事务 
@Transactional(propagation=Propagation.REQUIREDS_N
    
                                
    • 
                                
  • 我的spring学习笔记12-idref与ref的区别
                                    aijuans
spring
                                    
    idref用来将容器内其他bean的id传给<constructor-arg>/<property>元素，同时提供错误验证功能。例如： 
 
<bean id ="theTargetBean" class="..." />
<bean id ="theClientBean" class=&quo
    
                                
    • 
                                
  • Jqplot之折线图
                                    antlove
jsjqueryWebtimeseriesjqplot
                                    
    timeseriesChart.html 
<script type="text/javascript" src="jslib/jquery.min.js"></script>  
<script type="text/javascript" src="jslib/excanvas.min.js&
    
                                
    • 
                                
  • JDBC中事务处理应用
                                    百合不是茶
javaJDBC编程事务控制语句
                                    
      
解释事务的概念; 事务控制是sql语句中的核心之一;事务控制的作用就是保证数据的正常执行与异常之后可以恢复 
  
事务常用命令: 
            Commit提交 
        
    
                                
    • 
                                
  • [转]ConcurrentHashMap Collections.synchronizedMap和Hashtable讨论
                                    bijian1013
java多线程线程安全HashMap
                                    
    在Java类库中出现的第一个关联的集合类是Hashtable，它是JDK1.0的一部分。 Hashtable提供了一种易于使用的、线程安全的、关联的map功能，这当然也是方便的。然而，线程安全性是凭代价换来的――Hashtable的所有方法都是同步的。此时，无竞争的同步会导致可观的性能代价。Hashtable的后继者HashMap是作为JDK1.2中的集合框架的一部分出现的，它通过提供一个不同步的
    
                                
    • 
                                
  • ng-if与ng-show、ng-hide指令的区别和注意事项
                                    bijian1013
JavaScriptAngularJS
                                    
            angularJS中的ng-show、ng-hide、ng-if指令都可以用来控制dom元素的显示或隐藏。ng-show和ng-hide根据所给表达式的值来显示或隐藏HTML元素。当赋值给ng-show指令的值为false时元素会被隐藏，值为true时元素会显示。ng-hide功能类似，使用方式相反。元素的显示或
    
                                
    • 
                                
  • 【持久化框架MyBatis3七】MyBatis3定义typeHandler
                                    bit1129
TypeHandler
                                    
    什么是typeHandler? 
typeHandler用于将某个类型的数据映射到表的某一列上，以完成MyBatis列跟某个属性的映射 
  内置typeHandler 
MyBatis内置了很多typeHandler，这写typeHandler通过org.apache.ibatis.type.TypeHandlerRegistry进行注册，比如对于日期型数据的typeHandler， 
    
                                
    • 
                                
  • 上传下载文件rz,sz命令
                                    bitcarter
linux命令rz
                                    
    刚开始使用rz上传和sz下载命令： 
因为我们是通过secureCRT终端工具进行使用的所以会有上传下载这样的需求： 
 
我遇到的问题： 
sz下载A文件10M左右，没有问题 
但是将这个文件A再传到另一天服务器上时就出现传不上去，甚至出现乱码，死掉现象，具体问题 
 
解决方法： 
上传命令改为;rz -ybe 
下载命令改为：sz -be filename 
 
如果还是有问题： 
那就是文
    
                                
    • 
                                
  • 通过ngx-lua来统计nginx上的虚拟主机性能数据
                                    ronin47
ngx-lua　统计 解禁ip
                                    
    介绍 
以前我们为nginx做统计,都是通过对日志的分析来完成.比较麻烦,现在基于ngx_lua插件,开发了实时统计站点状态的脚本,解放生产力.项目主页: https://github.com/skyeydemon/ngx-lua-stats 功能 
 
 支持分不同虚拟主机统计, 同一个虚拟主机下可以分不同的location统计. 
 可以统计与query-times request-time 
    
                                
    • 
                                
  • java-68-把数组排成最小的数。一个正整数数组，将它们连接起来排成一个数，输出能排出的所有数字中最小的。例如输入数组{32, 321}，则输出32132
                                    bylijinnan
java
                                    
    
import java.util.Arrays;
import java.util.Comparator;

public class MinNumFromIntArray {

	/**
	 * Q68输入一个正整数数组，将它们连接起来排成一个数，输出能排出的所有数字中最小的一个。
	 * 例如输入数组{32,  321}，则输出这两个能排成的最小数字32132。请给出解决问题
    
                                
    • 
                                
  • Oracle基本操作
                                    ccii
Oracle SQL总结Oracle SQL语法Oracle基本操作Oracle SQL
                                    
    一、表操作 
 
1. 常用数据类型 
NUMBER(p,s)：可变长度的数字。p表示整数加小数的最大位数，s为最大小数位数。支持最大精度为38位 
NVARCHAR2(size)：变长字符串，最大长度为4000字节（以字符数为单位） 
VARCHAR2(size)：变长字符串，最大长度为4000字节（以字节数为单位） 
CHAR(size)：定长字符串，最大长度为2000字节，最小为1字节，默认
    
                                
    • 
                                
  • [强人工智能]实现强人工智能的路线图
                                    comsci
人工智能
                                    
     
    1：创建一个用于记录拓扑网络连接的矩阵数据表 
     2:自动构造或者人工复制一个包含10万个连接(1000*1000)的流程图 
     3：将这个流程图导入到矩阵数据表中 
     4：在矩阵的每个有意义的节点中嵌入一段简单的
    
                                
    • 
                                
  • 给Tomcat，Apache配置gzip压缩(HTTP压缩)功能
                                    cwqcwqmax9
apache
                                    
    背景： 
HTTP 压缩可以大大提高浏览网站的速度，它的原理是，在客户端请求网页后，从服务器端将网页文件压缩，再下载到客户端，由客户端的浏览器负责解压缩并浏览。相对于普通的浏览过程HTML ,CSS,Javascript , Text ，它可以节省40%左右的流量。更为重要的是，它可以对动态生成的，包括CGI、PHP , JSP , ASP , Servlet,SHTML等输出的网页也能进行压缩，
    
                                
    • 
                                
  • SpringMVC and Struts2
                                    dashuaifu
struts2springMVC
                                    
    SpringMVC  VS Struts2

1:
spring3开发效率高于struts
2:
spring3 mvc可以认为已经100%零配置
3:
struts2是类级别的拦截， 一个类对应一个request上下文，
springmvc是方法级别的拦截，一个方法对应一个request上下文，而方法同时又跟一个url对应
所以说从架构本身上 spring3 mvc就容易实现r
    
                                
    • 
                                
  • windows常用命令行命令
                                    dcj3sjt126com
windowscmdcommand
                                    
    在windows系统中，点击开始－运行，可以直接输入命令行，快速打开一些原本需要多次点击图标才能打开的界面，如常用的输入cmd打开dos命令行，输入taskmgr打开任务管理器。此处列出了网上搜集到的一些常用命令。winver 检查windows版本 wmimgmt.msc 打开windows管理体系结构(wmi) wupdmgr windows更新程序 wscrip
    
                                
    • 
                                
  • 再看知名应用背后的第三方开源项目
                                    dcj3sjt126com
ios
                                    
    知名应用程序的设计和技术一直都是开发者需要学习的，同样这些应用所使用的开源框架也是不可忽视的一部分。此前《 
iOS第三方开源库的吐槽和备忘》中作者ibireme列举了国内多款知名应用所使用的开源框架，并对其中一些框架进行了分析，同样国外开发者 
@iOSCowboy也在博客中给我们列出了国外多款知名应用使用的开源框架。另外txx's blog中详细介绍了 
Facebook Paper使用的第三
    
                                
    • 
                                
  • Objective-c单例模式的正确写法
                                    jsntghf
单例iosiPhone
                                    
    一般情况下，可能我们写的单例模式是这样的： 
#import <Foundation/Foundation.h>

@interface Downloader : NSObject

+ (instancetype)sharedDownloader;

@end


#import "Downloader.h"

@implementation
    
                                
    • 
                                
  • jquery easyui datagrid 加载成功，选中某一行
                                    hae
jqueryeasyuidatagrid数据加载
                                    
    1.首先你需要设置datagrid的onLoadSuccess   
$( 
'#dg' 
).datagrid({onLoadSuccess :  
function 
(data){   
     
$( 
'#dg' 
).datagrid( 
'selectRow' 
,3);   
}});       
2.onL
    
                                
    • 
                                
  • jQuery用户数字打分评价效果
                                    ini
JavaScripthtmljqueryWebcss
                                    
    效果体验：http://hovertree.com/texiao/jquery/5.htmHTML文件代码： 
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>jQuery用户数字打分评分代码 - HoverTree</
    
                                
    • 
                                
  • mybatis的paramType
                                    kerryg
DAOsql
                                    
    MyBatis传多个参数： 
1、采用#{0},#{1}获得参数： 
   Dao层函数方法： 
    public User selectUser(String name,String area); 
 对应的Mapper.xml 
   <select id="selectUser" result
    
                                
    • 
                                
  • centos 7安装mysql5.5
                                    MrLee23
centos
                                    
    首先centos7 已经不支持mysql，因为收费了你懂得，所以内部集成了mariadb，而安装mysql的话会和mariadb的文件冲突，所以需要先卸载掉mariadb，以下为卸载mariadb，安装mysql的步骤。 
  
#列出所有被安装的rpm package rpm -qa | grep mariadb 
  
#卸载 
rpm -e mariadb-libs-5.
    
                                
    • 
                                
  • 利用thrift来实现消息群发
                                    qifeifei
thrift
                                    
               Thrift项目一般用来做内部项目接偶用的，还有能跨不同语言的功能，非常方便，一般前端系统和后台server线上都是3个节点，然后前端通过获取client来访问后台server，那么如果是多太server，就是有一个负载均衡的方法，然后最后访问其中一个节点。那么换个思路，能不能发送给所有节点的server呢，如果能就
    
                                
    • 
                                
  • 实现一个sizeof获取Java对象大小
                                    teasp
javaHotSpot内存对象大小sizeof
                                    
       由于Java的设计者不想让程序员管理和了解内存的使用，我们想要知道一个对象在内存中的大小变得比较困难了。本文提供了可以获取对象的大小的方法，但是由于各个虚拟机在内存使用上可能存在不同，因此该方法不能在各虚拟机上都适用，而是仅在hotspot 32位虚拟机上，或者其它内存管理方式与hotspot 32位虚拟机相同的虚拟机上 适用。 
  
  
    
                                
    • 
                                
  • SVN错误及处理
                                    xiangqian0505
SVN提交文件时服务器强行关闭
                                    
    在SVN服务控制台打开资源库“SVN无法读取current” ---摘自网络 写道   SVN无法读取current修复方法 Can't read file : End of file found 
 
文件：repository/db/txn_current、repository/db/current 
  
其中current记录当前最新版本号，txn_current记录版本库中版本
    
                                
    •