胡晗-
胡晗-

4.Netty服务端源码分析

Netty线程模型图
4.Netty服务端源码分析_第1张图片
 
 
源码执行过程流程图
4.Netty服务端源码分析_第2张图片
图片链接：https://www.processon.com/view/link/5fc6f349e401fd0eb98da1e1
 
Netty服务端代码 
// 管理连接线程组
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
// 处理io任务线程组
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
    // 启动服务端
    ServerBootstrap serverBootstrap = new ServerBootstrap();
    serverBootstrap.group(bossGroup, workerGroup)
            .channel(NioServerSocketChannel.class)
            // 等待队列
            .option(ChannelOption.SO_BACKLOG,1024)
            // 创建通道初始化对象，设置初始化参数
            .childHandler(new ChannelInitializer() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    // 给worker group的channel设置处理器
                    ch.pipeline().addLast(new NettyServerHandler());
                    ch.pipeline().addLast(new Server2Handler());
                    ch.pipeline().addLast(new Server3Handler());
                }
            });
    // 启动服务并绑定端口
    ChannelFuture channelFuture = serverBootstrap.bind(9000).sync();
    System.out.println("netty server start ...");
    // 监听通道关闭
    channelFuture.channel().closeFuture().sync();
} catch (InterruptedException e) {
    e.printStackTrace();
} finally {
    bossGroup.shutdownGracefully();
    workerGroup.shutdownGracefully();
}

 

EventLoopGroup继承关系
4.Netty服务端源码分析_第3张图片
 
NioServerSocketChannel继承关系
4.Netty服务端源码分析_第4张图片
 
1.创建线程组
创建两个类型为NioEventLoopGroup的线程组，一个用于处理客户端的连接事件，起名为bossGroup，一个用于处理客户端的读写请求，起名为workerGroup
从父类MultithreadEventLoopGroup的构造方法可以看到优先会使用用户指定的线程，如果不指定会使用默认的线程数 
protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) {
    super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args);
}

 

 
在静态代码块里，会初始化默认线程数，可以看出来是先取io.netty.eventLoopThreads属性配置的值，如果没有配置则默认是取可用CPU的2倍 
private static final int DEFAULT_EVENT_LOOP_THREADS;


static {
    DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt(
            "io.netty.eventLoopThreads", NettyRuntime.availableProcessors() * 2));


    if (logger.isDebugEnabled()) {
        logger.debug("-Dio.netty.eventLoopThreads: {}", DEFAULT_EVENT_LOOP_THREADS);
    }
}

 

 
从构造方法一路往上追溯到MultithreadEventExecutorGroup的构造方法中（部分异常处理代码有删减） 
protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                        EventExecutorChooserFactory chooserFactory, Object... args) {

    if (executor == null) {
        executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
    }


    children = new EventExecutor[nThreads];


    for (int i = 0; i < nThreads; i ++) {
        boolean success = false;
        try {
            children[i] = newChild(executor, args);
            success = true;
        } 

    chooser = chooserFactory.newChooser(children);
}

 

 
可以看到这里初始化了一个属性名为children的EventExecutor数组，里面每个对象都有newChild方法来初始化，实际上是创建了一个NioEventLoop对象 
protected EventLoop newChild(Executor executor, Object... args) throws Exception {
    EventLoopTaskQueueFactory queueFactory = args.length == 4 ? (EventLoopTaskQueueFactory) args[3] : null;
    return new NioEventLoop(this, executor, (SelectorProvider) args[0],
        ((SelectStrategyFactory) args[1]).newSelectStrategy(), (RejectedExecutionHandler) args[2], queueFactory);
}

 

内部创建了seletor和taskQueue等 
NioEventLoop(NioEventLoopGroup parent, Executor executor, SelectorProvider selectorProvider,
             SelectStrategy strategy, RejectedExecutionHandler rejectedExecutionHandler,
             EventLoopTaskQueueFactory queueFactory) {
    super(parent, executor, false, newTaskQueue(queueFactory), newTaskQueue(queueFactory),
            rejectedExecutionHandler);
    this.provider = ObjectUtil.checkNotNull(selectorProvider, "selectorProvider");
    this.selectStrategy = ObjectUtil.checkNotNull(strategy, "selectStrategy");
    final SelectorTuple selectorTuple = openSelector();
    this.selector = selectorTuple.selector;
    this.unwrappedSelector = selectorTuple.unwrappedSelector;
}

 

  
protected SingleThreadEventLoop(EventLoopGroup parent, Executor executor,
                                boolean addTaskWakesUp, Queue taskQueue, Queue tailTaskQueue,
                                RejectedExecutionHandler rejectedExecutionHandler) {
    super(parent, executor, addTaskWakesUp, taskQueue, rejectedExecutionHandler);
    tailTasks = ObjectUtil.checkNotNull(tailTaskQueue, "tailTaskQueue");
}

4.Netty服务端源码分析_第5张图片

 
 
 
2.构建ServerBootStrap对象
构造方法是空实现，不做任何处理 
private final Map, Object> childOptions = new LinkedHashMap, Object>();
private final Map, Object> childAttrs = new ConcurrentHashMap, Object>();
private final ServerBootstrapConfig config = new ServerBootstrapConfig(this);
private volatile EventLoopGroup childGroup;
private volatile ChannelHandler childHandler;


public ServerBootstrap() { }

 

 
通过group方法把bossGroup赋值给group字段，workerGroup赋值childGroup字段 
public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) {
    super.group(parentGroup);
    if (this.childGroup != null) {
        throw new IllegalStateException("childGroup set already");
    }
    this.childGroup = ObjectUtil.checkNotNull(childGroup, "childGroup");
    return this;
}

 

 
通过channel方法给channelFactory属性指定Channel工厂，后续通过无参构造方法来反射创建实例 
public B channel(Class channelClass) {
    return channelFactory(new ReflectiveChannelFactory(
            ObjectUtil.checkNotNull(channelClass, "channelClass")
    ));
}

public ReflectiveChannelFactory(Class clazz) {
    ObjectUtil.checkNotNull(clazz, "clazz");
    try {
        this.constructor = clazz.getConstructor();
    } catch (NoSuchMethodException e) {
        throw new IllegalArgumentException("Class " + StringUtil.simpleClassName(clazz) +
                " does not have a public non-arg constructor", e);
    }
}
@Override
public T newChannel() {
    try {
        return constructor.newInstance();
    } catch (Throwable t) {
        throw new ChannelException("Unable to create Channel from class " + constructor.getDeclaringClass(), t);
    }
}

 

 
通过option方法配置参数 
public  B option(ChannelOption option, T value) {
    ObjectUtil.checkNotNull(option, "option");
    synchronized (options) {
        if (value == null) {
            options.remove(option);
        } else {
            options.put(option, value);
        }
    }
    return self();
}

 

 
新建一个ChannelInitializer赋值给childHandler属性，后面启动的时候会用到，暂时先跳过。内部实现就是一个简单的赋值，这里记录一下具体的调用 
.childHandler(new ChannelInitializer() {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        // 给worker group的channel设置处理器
        ch.pipeline().addLast(new NettyServerHandler());
        ch.pipeline().addLast(new Server2Handler());
        ch.pipeline().addLast(new Server3Handler());
    }
});

 

 
3.启动服务并绑定端口 
serverBootstrap.bind(9000).sync()

 

沿着方法的调用进入到AbstractBootstrap#doBind方法，这里有两个方法比较重要，一个是initAndRegister()，另外一个是doBind0(regFuture, channel, localAddress, promise)
其中doBind方法比较简单，里面没有什么很复杂的逻辑，最终是调用java的api sun.nio.ch.ServerSocketChannelImpl#bind来实现的，这里我们主要看一下initAndRegister方法
 
initAndRegister 
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();
            }
        }
        return regFuture;
    }

 

这里我们从三个分支分别去看他的调用方向：channelFactory.newChannel()、init(channel)、config().group().register(channel)
 
3.1channelFactory.newChannel()----新建ServerSocketChannel对象
第二步我们构建ServerBootstrap对象的时候给channelFactory属性赋值的是一个反射创建NioServerSocketChannel对象的工厂，所以这里我们调用new Channel会通过它的无参构造方法反射创建一个NioServerSocketChannel对象 
public NioServerSocketChannel() {
    this(newSocket(DEFAULT_SELECTOR_PROVIDER));
}

 

new Socket方法会通过默认的SelectProvider来new 一个java nio包下的ServerSocketChannel对象，进入this方法 
public NioServerSocketChannel(ServerSocketChannel channel) {
    super(null, channel, SelectionKey.OP_ACCEPT);
    config = new NioServerSocketChannelConfig(this, javaChannel().socket());
}

 

NioServerSocketChannelConfig没什么逻辑，就是把当前对象（NioServerSocketChannel）和ServerSocketChannel的socket封装了一下，接下来进入super
一直进到AbstractNioChannel的构造方法，可以看到当前channel设置了对OP_ACCEPT事件感兴趣，并且配置了非阻塞 
protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
    super(parent);
    this.ch = ch;
    this.readInterestOp = readInterestOp;
    try {
        ch.configureBlocking(false);
    } catch (IOException e) {
        try {
            ch.close();
        } catch (IOException e2) {
            logger.warn(
                        "Failed to close a partially initialized socket.", e2);
        }


        throw new ChannelException("Failed to enter non-blocking mode.", e);
    }
}

 

再往上进入父类的构造方法，这里新建了一个unsafe对象，因为这里最终的实现类是NioServerSocketChannel，通过UML结构图可以看出来他最终调用的实现类是AbstractNioMessageChannel#newUnsafe，所以这里的unsafe对象是NioMessageUnsafe对象。 
protected AbstractChannel(Channel parent) {
    this.parent = parent;
    id = newId();
    unsafe = newUnsafe();
    pipeline = newChannelPipeline();
}

 

这里还初始化了一个ChannelPipeline对象,里面是由ChannelHandlerContext组成的双向链表，context里面放的是channelHandler对象，现在里面只有head和tail
4.Netty服务端源码分析_第6张图片
  
protected DefaultChannelPipeline(Channel channel) {
    this.channel = ObjectUtil.checkNotNull(channel, "channel");
    succeededFuture = new SucceededChannelFuture(channel, null);
    voidPromise =  new VoidChannelPromise(channel, true);


    tail = new TailContext(this);
    head = new HeadContext(this);


    head.next = tail;
    tail.prev = head;
}

 

 
3.2 init(channel)---Channel初始化 
void init(Channel channel) {
    setChannelOptions(channel, newOptionsArray(), logger);
    setAttributes(channel, attrs0().entrySet().toArray(EMPTY_ATTRIBUTE_ARRAY));


    ChannelPipeline p = channel.pipeline();


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


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


            ch.eventLoop().execute(new Runnable() {
                @Override
                public void run() {
                    pipeline.addLast(new ServerBootstrapAcceptor(
                            ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
                }
            });
        }
    });
}

 

这里先是设置了attr和options，childGroup就是我们定义的workerGroup，childHandler就是我们自定义的匿名ChannelInitializer对象，最后向我们上面初始化的ServerSocketChannel的pipeline对象中加入了一个匿名ChannelInitializer对象
 
我们看一下addLast方法，可以看到这里先是把handler包装了一个channelHandlerContext然后听过addLast0方法加入pipeline 
public final ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler) {
    final AbstractChannelHandlerContext newCtx;
    synchronized (this) {
        checkMultiplicity(handler);


        newCtx = newContext(group, filterName(name, handler), handler);


        addLast0(newCtx);


        // If the registered is false it means that the channel was not registered on an eventLoop yet.
        // In this case we add the context to the pipeline and add a task that will call
        // ChannelHandler.handlerAdded(...) once the channel is registered.
        if (!registered) {
            newCtx.setAddPending();
            callHandlerCallbackLater(newCtx, true);
            return this;
        }


        EventExecutor executor = newCtx.executor();
        if (!executor.inEventLoop()) {
            callHandlerAddedInEventLoop(newCtx, executor);
            return this;
        }
    }
    callHandlerAdded0(newCtx);
    return this;
}

 

addLast0方法，可以看出来我们并不是真的加到链表的最后面，而是加到tail的前面一个 
private void addLast0(AbstractChannelHandlerContext newCtx) {
    AbstractChannelHandlerContext prev = tail.prev;
    newCtx.prev = prev;
    newCtx.next = tail;
    prev.next = newCtx;
    tail.prev = newCtx;
}

 

 
加入了一个ChannelInitializer对象以后，现在ServerSocketChannel的pipeline里面是这个样子
4.Netty服务端源码分析_第7张图片
 
在ServerSocketChannel注册到selector上的时候，会调用这里的ChannelInitializer对象里面的initChannel方法，具体的触发时间和调用逻辑在后面触发的时候再看
 
3.3config().group().register(channel)
这里的config()返回的是新建ServerBootStrap对象的时候新建的包含this的ServerBootStrapConfig对象，config().group返回的是ServerBootStrap的group对象，也就是我们初始化的时候新建的bossGroup,从这里暂时可以看出是要把channel注册到bossGroup上面。因为bossGroup是NioEventLoopGroup类型的，根据UML类图可以看出这里调用的是MultithreadEventLoopGroup的register方法， 
@Override
public ChannelFuture register(Channel channel) {
    return next().register(channel);
}

 

 
next()是根据对应的策略选择出bossGroup里面的某一个NioEventLoop，根据uml类图来判断调用逻辑 
@Override
public ChannelFuture register(Channel channel) {
    return register(new DefaultChannelPromise(channel, this));
}

 

 
  
@Override
public ChannelFuture register(final ChannelPromise promise) {
    ObjectUtil.checkNotNull(promise, "promise");
    promise.channel().unsafe().register(this, promise);
    return promise;
}

 

promise.channel()返回的就是我们传进来的serverSocketChannel对象，unsafe方法就是new serverSocketChannel对象时创建的NioMessageUnsafe对象（参考3.1） 
public final void register(EventLoop eventLoop, final ChannelPromise promise) {
    ObjectUtil.checkNotNull(eventLoop, "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);
        }
    }
}

 

当前运行的是main线程，并不是NioEventLoop里面的线程，所以这里会走else逻辑 
eventLoop.execute(new Runnable() {
    @Override
    public void run() {
        register0(promise);
    }
});

 

这里分成两个部分分别来看
3.3.1 eventLoop.execute 
private void execute(Runnable task, boolean immediate) {
    boolean inEventLoop = inEventLoop();
    addTask(task);
    if (!inEventLoop) {
        startThread();
        if (isShutdown()) {
            boolean reject = false;
            try {
                if (removeTask(task)) {
                    reject = true;
                }
            } catch (UnsupportedOperationException e) {
                // The task queue does not support removal so the best thing we can do is to just move on and
                // hope we will be able to pick-up the task before its completely terminated.
                // In worst case we will log on termination.
            }
            if (reject) {
                reject();
            }
        }
    }


    if (!addTaskWakesUp && immediate) {
        wakeup(inEventLoop);
    }
}

 

这里先把register0这个任务放到taskQueue里面等待异步执行， 
final boolean offerTask(Runnable task) {
    if (isShutdown()) {
        reject();
    }
    return taskQueue.offer(task);
}

 

同样的因为这里是main线程会走if条件里面的逻辑，执行启动线程startThread方法
CAS设置启动状态，然后执行doStartThread方法 
private void startThread() {
    if (state == ST_NOT_STARTED) {
        if (STATE_UPDATER.compareAndSet(this, ST_NOT_STARTED, ST_STARTED)) {
            boolean success = false;
            try {
                doStartThread();
                success = true;
            } finally {
                if (!success) {
                    STATE_UPDATER.compareAndSet(this, ST_STARTED, ST_NOT_STARTED);
                }
            }
        }
    }
}

 

这里使用线程池去执行后面的任务，main线程会立刻返回，我们来看线程内部执行的任务（视角从main线程切换到线程池上的线程） 
private void doStartThread() {
    assert thread == null;
    executor.execute(new Runnable() {
        @Override
        public void run() {
            thread = Thread.currentThread();
            if (interrupted) {
                thread.interrupt();
            }


            boolean success = false;
            updateLastExecutionTime();
            try {
                SingleThreadEventExecutor.this.run();
                success = true;
            }

 

 
我们这里看主流程SingleThreadEventExecutor.this.run()，其他的异常处理和状态流转先忽略。 
protected void run() {
    int selectCnt = 0;
    for (;;) {
        try {
            int strategy;
            try {
                strategy = selectStrategy.calculateStrategy(selectNowSupplier, hasTasks());
                switch (strategy) {
                case SelectStrategy.CONTINUE:
                    continue;


                case SelectStrategy.BUSY_WAIT:
                    // fall-through to SELECT since the busy-wait is not supported with NIO


                case SelectStrategy.SELECT:
                    long curDeadlineNanos = nextScheduledTaskDeadlineNanos();
                    if (curDeadlineNanos == -1L) {
                        curDeadlineNanos = NONE; // nothing on the calendar
                    }
                    nextWakeupNanos.set(curDeadlineNanos);
                    try {
                        if (!hasTasks()) {
                            strategy = select(curDeadlineNanos);
                        }
                    } finally {
                        // This update is just to help block unnecessary selector wakeups
                        // so use of lazySet is ok (no race condition)
                        nextWakeupNanos.lazySet(AWAKE);
                    }
                    // fall through
                default:
                }
            } catch (IOException e) {
                // If we receive an IOException here its because the Selector is messed up. Let's rebuild
                // the selector and retry. https://github.com/netty/netty/issues/8566
                rebuildSelector0();
                selectCnt = 0;
                handleLoopException(e);
                continue;
            }


            selectCnt++;
            cancelledKeys = 0;
            needsToSelectAgain = false;
            final int ioRatio = this.ioRatio;
            boolean ranTasks;
            if (ioRatio == 100) {
                try {
                    if (strategy > 0) {
                        processSelectedKeys();
                    }
                } finally {
                    // Ensure we always run tasks.
                    ranTasks = runAllTasks();
                }
            } else if (strategy > 0) {
                final long ioStartTime = System.nanoTime();
                try {
                    processSelectedKeys();
                } finally {
                    // Ensure we always run tasks.
                    final long ioTime = System.nanoTime() - ioStartTime;
                    ranTasks = runAllTasks(ioTime * (100 - ioRatio) / ioRatio);
                }
            } else {
                ranTasks = runAllTasks(0); // This will run the minimum number of tasks
            }


            if (ranTasks || strategy > 0) {
                if (selectCnt > MIN_PREMATURE_SELECTOR_RETURNS && logger.isDebugEnabled()) {
                    logger.debug("Selector.select() returned prematurely {} times in a row for Selector {}.",
                            selectCnt - 1, selector);
                }
                selectCnt = 0;
            } else if (unexpectedSelectorWakeup(selectCnt)) { // Unexpected wakeup (unusual case)
                selectCnt = 0;
            }
        } catch (CancelledKeyException e) {
            // Harmless exception - log anyway
            if (logger.isDebugEnabled()) {
                logger.debug(CancelledKeyException.class.getSimpleName() + " raised by a Selector {} - JDK bug?",
                        selector, e);
            }
        } catch (Throwable t) {
            handleLoopException(t);
        }
        // Always handle shutdown even if the loop processing threw an exception.
        try {
            if (isShuttingDown()) {
                closeAll();
                if (confirmShutdown()) {
                    return;
                }
            }
        } catch (Throwable t) {
            handleLoopException(t);
        }
    }
}

 

可以看到NioEventLoop启动的这个线程，for死循环执行这段逻辑，第一次循环的时候，此时taskQueue里面是有刚才加入的register0的这个任务，所以hastask()方法返回true，此时selector上并没有connect或读写事件（netty服务端还没启动完成），所以strategy的值为0;switch内部没有任何操作，此时ioRatio为初始值50，所以会进入到runAllTasks方法
 
runAllTasks
执行任务队列中的所有任务，此时任务队列中只有一个任务，就是刚才加入的register0 
protected boolean runAllTasks(long timeoutNanos) {
    fetchFromScheduledTaskQueue();
    Runnable task = pollTask();
    if (task == null) {
        afterRunningAllTasks();
        return false;
    }


    final long deadline = timeoutNanos > 0 ? ScheduledFutureTask.nanoTime() + timeoutNanos : 0;
    long runTasks = 0;
    long lastExecutionTime;
    for (;;) {
        safeExecute(task);


        runTasks ++;


        // Check timeout every 64 tasks because nanoTime() is relatively expensive.
        // XXX: Hard-coded value - will make it configurable if it is really a problem.
        if ((runTasks & 0x3F) == 0) {
            lastExecutionTime = ScheduledFutureTask.nanoTime();
            if (lastExecutionTime >= deadline) {
                break;
            }
        }


        task = pollTask();
        if (task == null) {
            lastExecutionTime = ScheduledFutureTask.nanoTime();
            break;
        }
    }


    afterRunningAllTasks();
    this.lastExecutionTime = lastExecutionTime;
    return true;
}

 

 
3.3.2 register0(promise);
doRegister方法把ServerSocketChannel注册到bossGroup里面的某一个NioEventLoop上的unwrappedSelector上 
private void register0(ChannelPromise promise) {
    try {
        // check if the channel is still open as it could be closed in the mean time when the register
        // call was outside of the eventLoop
        if (!promise.setUncancellable() || !ensureOpen(promise)) {
            return;
        }
        boolean firstRegistration = neverRegistered;
        doRegister();
        neverRegistered = false;
        registered = true;


        // Ensure we call handlerAdded(...) before we actually notify the promise. This is needed as the
        // user may already fire events through the pipeline in the ChannelFutureListener.
        pipeline.invokeHandlerAddedIfNeeded();


        safeSetSuccess(promise);
        pipeline.fireChannelRegistered();
        // Only fire a channelActive if the channel has never been registered. This prevents firing
        // multiple channel actives if the channel is deregistered and re-registered.
        if (isActive()) {
            if (firstRegistration) {
                pipeline.fireChannelActive();
            } else if (config().isAutoRead()) {
                // This channel was registered before and autoRead() is set. This means we need to begin read
                // again so that we process inbound data.
                //
                // See https://github.com/netty/netty/issues/4805
                beginRead();
            }
        }
    } catch (Throwable t) {
        // Close the channel directly to avoid FD leak.
        closeForcibly();
        closeFuture.setClosed();
        safeSetFailure(promise, t);
    }
}

 

 
接下来调用pipeline中的invokeHandlerAddedIfNeeded方法，此时的pipeline是这个样子的（参照3.2末尾）
4.Netty服务端源码分析_第8张图片
 
从pendingHandlerCallbackHead开始通过链表依次调用execute方法，此时链表里面只有一个对象，因为pipeline里面只有一个handler(除header和tail) 
private void callHandlerAddedForAllHandlers() {
    final PendingHandlerCallback pendingHandlerCallbackHead;
    synchronized (this) {
        assert !registered;


        // This Channel itself was registered.
        registered = true;


        pendingHandlerCallbackHead = this.pendingHandlerCallbackHead;
        // Null out so it can be GC'ed.
        this.pendingHandlerCallbackHead = null;
    }


    // This must happen outside of the synchronized(...) block as otherwise handlerAdded(...) may be called while
    // holding the lock and so produce a deadlock if handlerAdded(...) will try to add another handler from outside
    // the EventLoop.
    PendingHandlerCallback task = pendingHandlerCallbackHead;
    while (task != null) {
        task.execute();
        task = task.next;
    }
}

 

 
pendingHandlerCallbackHead对象是什么？从哪里初始化的？
在3.2中channel初始化的时候，向pipeline中新增了一个ChannelInitializer对象，执行addLast方法的时候,因为channel还没有注册到bossGroup中的nioEventloop的selector上，所以走了if的逻辑 
if (!registered) {
    newCtx.setAddPending();
    callHandlerCallbackLater(newCtx, true);
    return this;
}

 

执行callHandlerCallbackLater方法
新建一个PendingHandlerAddedTask对象，加在链表的末尾。这个对象继承自runnable，内部封装了channelHandlerContext属性.
所以这个时候链表里面只有一个PendingHandlerAddedTask对象，对应的channelHandlerContext内部封装了ChannelInitializer对象（ChannelHandler子类） 
private void callHandlerCallbackLater(AbstractChannelHandlerContext ctx, boolean added) {
    assert !registered;


    PendingHandlerCallback task = added ? new PendingHandlerAddedTask(ctx) : new PendingHandlerRemovedTask(ctx);
    PendingHandlerCallback pending = pendingHandlerCallbackHead;
    if (pending == null) {
        pendingHandlerCallbackHead = task;
    } else {
        // Find the tail of the linked-list.
        while (pending.next != null) {
            pending = pending.next;
        }
        pending.next = task;
    }
}

 

所以上面的task.execute方法最终是调用PendingHandlerAddedTask.execute方法 
@Override
void execute() {
    EventExecutor executor = ctx.executor();
    if (executor.inEventLoop()) {
        callHandlerAdded0(ctx);
    } else {
        try {
            executor.execute(this);
        } catch (RejectedExecutionException e) {
            if (logger.isWarnEnabled()) {
                logger.warn(
                        "Can't invoke handlerAdded() as the EventExecutor {} rejected it, removing handler {}.",
                        executor, ctx.name(), e);
            }
            atomicRemoveFromHandlerList(ctx);
            ctx.setRemoved();
        }
    }
}

 

不论是哪个线程在执行，最终都是进入callHandlerAdded0方法 => ctx.callHandlerAdded() => handler().handlerAdded(this)
因为这里的handler最终实现是ChannelInitializer对象，所以进入对应的方法如下： 
public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
    if (ctx.channel().isRegistered()) {
        // This should always be true with our current DefaultChannelPipeline implementation.
        // The good thing about calling initChannel(...) in handlerAdded(...) is that there will be no ordering
        // surprises if a ChannelInitializer will add another ChannelInitializer. This is as all handlers
        // will be added in the expected order.
        if (initChannel(ctx)) {


            // We are done with init the Channel, removing the initializer now.
            removeState(ctx);
        }
    }
}

 

此时ServerSocketChannel已经注册完成，所以会执行对应的initChannel方法，进入具体实现 
private boolean initChannel(ChannelHandlerContext ctx) throws Exception {
    if (initMap.add(ctx)) { // Guard against re-entrance.
        try {
            initChannel((C) ctx.channel());
        } catch (Throwable cause) {
            // Explicitly call exceptionCaught(...) as we removed the handler before calling initChannel(...).
            // We do so to prevent multiple calls to initChannel(...).
            exceptionCaught(ctx, cause);
        } finally {
            ChannelPipeline pipeline = ctx.pipeline();
            if (pipeline.context(this) != null) {
                pipeline.remove(this);
            }
        }
        return true;
    }
    return false;
}

 

可以看出这里会调用ChannelInitializer对象的initChannel方法，从3.2初始化channel可以看到往pipeline中加入了ServerBootstrapAcceptor对象，最终在finally模块中从pipeline删掉自己,所以现在pipeline中是这样的
4.Netty服务端源码分析_第9张图片
 
 
接着回到register0方法中，回调pipeline中channelHandler的channelRegistered方法，如果channel激活，触发channelActive方法，因为这里唯一的handler(ServerBootstrapAcceptor对象)没有具体实现，所以不深入下去
pipeline.fireChannelRegistered();
 
此时SingleThreadEventExecutor.this.run()方法内部死循环还在执行，服务端已经启动成功了，客户端还没有启动，所以方法会阻塞在selector.select上等待客户端连接和写数据，接下来我们启动客户端
 
启动客户端会接收到连接请求，服务端进入processSelectedKeys方法处理 
private void processSelectedKeys() {
    if (selectedKeys != null) {
        processSelectedKeysOptimized();
    } else {
        processSelectedKeysPlain(selector.selectedKeys());
    }
}

 

当有connect或read/write事件发生时,selectedKeys不为null，执行processSelectedKeysOptimized方法，for循环处理每一个连接事件 
private void processSelectedKeysOptimized() {
    for (int i = 0; i < selectedKeys.size; ++i) {
        final SelectionKey k = selectedKeys.keys[i];
        // null out entry in the array to allow to have it GC'ed once the Channel close
        // See https://github.com/netty/netty/issues/2363
        selectedKeys.keys[i] = null;


        final Object a = k.attachment();


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


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


            selectAgain();
            i = -1;
        }
    }
}

 

接着进入processSelectedKey方法 如果是connect事件，完成连接，建立socketChannel通道，如果是write事件，写完数据flush缓冲区 
private void processSelectedKey(SelectionKey k, AbstractNioChannel ch) {
        final AbstractNioChannel.NioUnsafe unsafe = ch.unsafe();
        if (!k.isValid()) {
            final EventLoop eventLoop;
            try {
                eventLoop = ch.eventLoop();
            } catch (Throwable ignored) {
                return;
            }
            if (eventLoop == this) {
                unsafe.close(unsafe.voidPromise());
            }
            return;
        }
        try {
            int readyOps = k.readyOps();
            if ((readyOps & SelectionKey.OP_CONNECT) != 0) {
                int ops = k.interestOps();
                ops &= ~SelectionKey.OP_CONNECT;
                k.interestOps(ops);


                unsafe.finishConnect();
            }
            if ((readyOps & SelectionKey.OP_WRITE) != 0) {
                ch.unsafe().forceFlush();
            }
            if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {
                unsafe.read();
            }
        } catch (CancelledKeyException ignored) {
            unsafe.close(unsafe.voidPromise());
        }
    }

 

因为我们这里的channel是serverSocketChannel，所以我们主要看read和accept事件，进入unsafe.read方法 
public void read() {
    assert eventLoop().inEventLoop();
    final ChannelConfig config = config();
    final ChannelPipeline pipeline = pipeline();
    final RecvByteBufAllocator.Handle allocHandle = unsafe().recvBufAllocHandle();
    allocHandle.reset(config);


    boolean closed = false;
    Throwable exception = null;
    try {
        try {
            do {
                int localRead = doReadMessages(readBuf);
                if (localRead == 0) {
                    break;
                }
                if (localRead < 0) {
                    closed = true;
                    break;
                }


                allocHandle.incMessagesRead(localRead);
            } while (allocHandle.continueReading());
        } catch (Throwable t) {
            exception = t;
        }


        int size = readBuf.size();
        for (int i = 0; i < size; i ++) {
            readPending = false;
            pipeline.fireChannelRead(readBuf.get(i));
        }
        readBuf.clear();
        allocHandle.readComplete();
        pipeline.fireChannelReadComplete();


        if (exception != null) {
            closed = closeOnReadError(exception);


            pipeline.fireExceptionCaught(exception);
        }


        if (closed) {
            inputShutdown = true;
            if (isOpen()) {
                close(voidPromise());
            }
        }
    } finally {
        // Check if there is a readPending which was not processed yet.
        // This could be for two reasons:
        // * The user called Channel.read() or ChannelHandlerContext.read() in channelRead(...) method
        // * The user called Channel.read() or ChannelHandlerContext.read() in channelReadComplete(...) method
        //
        // See https://github.com/netty/netty/issues/2254
        if (!readPending && !config.isAutoRead()) {
            removeReadOp();
        }
    }
}

 

我们首先来看doReadMessages方法，接收客户端连接生成SocketChannel建立连接，然后封装NioSocketChannel对象，加入到buf里面 
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;
} 
     
 
 
     
    
   
 NioSocketChannel对象初始化过程和NioServerSocketChannel对象类似，此时对象内部也有一个初始化的pipeline 
   
 
   
 4.Netty服务端源码分析_第10张图片 
   
 
   

       
   
 
   
 接下来执行pipeline的fireChannelRead方法，注意这里的pipeline是serverSocketChannel里面的pipeline，参数readbuf.get(i)是刚才建立连接的NioSocketChannel,此时pipeline里面只有一个ServerBootStrapAcceptor对象，所以我们直接看这个对象的channelRead方法 
   
 
   
 
    
 
     
public void channelRead(ChannelHandlerContext ctx, Object msg) {
    final Channel child = (Channel) msg;


    child.pipeline().addLast(childHandler);


    setChannelOptions(child, childOptions, logger);
    setAttributes(child, childAttrs);


    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);
    }
}
 
     
 
 
    
 
   
 
   
 可以看到这里先向NioSocketChannel的pipeline中加入了childHandler，就是最前面我们自己自定义的ChannelInitializer对象，里面写了业务处理逻辑流程。接下来设置attr和options。 
   
 
   
 最关键的一点，我们这里发现NioSocketChannel被注册到了childGroup上（也就是workerGroup上）。注册过程和前面相同，只不过换了一个group，这里就不赘述了。 
   
 
   

       
   
 
   
 最后如果客户端向服务端写数据，workerGroup上的NioEventLoop的selector探测到了，还是调用前面的unsafe.read方法，不过这里的channel是NioSocketChannel，所以对应的unsafe对象换成了NioByteUnsafe，所以实现逻辑换成了如下，触发pipeline上的channelHandler的channelRead方法和fireChannelReadComplete方法，最终调用我们写的业务逻辑 
   
 
   
 
    
 
     
do {
    byteBuf = allocHandle.allocate(allocator);
    allocHandle.lastBytesRead(doReadBytes(byteBuf));
    if (allocHandle.lastBytesRead() <= 0) {
        // nothing was read. release the buffer.
        byteBuf.release();
        byteBuf = null;
        close = allocHandle.lastBytesRead() < 0;
        if (close) {
            // There is nothing left to read as we received an EOF.
            readPending = false;
        }
        break;
    }


    allocHandle.incMessagesRead(1);
    readPending = false;
    pipeline.fireChannelRead(byteBuf);
    byteBuf = null;
} while (allocHandle.continueReading());


allocHandle.readComplete();
pipeline.fireChannelReadComplete();


if (close) {
    closeOnRead(pipeline);
}
 
     
 
 
    
 
   
 
   

       
   
 
   
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

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

        

            

                
    
                    
  • netty-简易聊天
                        2401_84046645
程序员java开发语言
                        
    publicvoidsend(Stringtext){channel.writeAndFlush(Unpooled.copiedBuffer(text.getBytes()));}publicvoidcloseConnect(){send(“bye”);channel.close();}}classMyHandlerextendsChannelInboundHandlerAdapter{@Over
    
                    
    • 
                    
  • Netty权威指南：Netty总结-高性能与可靠性
                        Ty_1106
Nettyjava网络rpc
                        
    第二十二章高性能之道22.1RPC调用性能模型分析22.1.1传统RPC调用性能差三宗罪：网络传输采用同步阻塞I/O导致经常性阻塞序列化性能差线程模型问题22.1.2I/O通信性能三要素传输：BIO、NIO或者AIO协议：HTTP公有协议，内部私有协议线程：数据报如何读取，Reactor线程模型22.2Netty高性能之道22.2.1异步非阻塞通信I/O多路复用技术22.2.2高效的Reactor
    
                    
    • 
                    
  • netty4源码阅读与分析---netty线程模型
                        红尘之一骑
javaNIOnetty源码阅读与分析
                        
    本文主要说下我自己对netty线程模型的理解，以及这样的线程模型的好处。通俗的来讲，netty的线程模型描述的就是老板和员工的故事。老板(通常情况下是一个老板)负责接活，与客户沟通，协调(netty的accept),谈成后(通道建立)，他需要从员工中选出一位员工来负责处理后续具体的事宜(worker线程，这里我们有16位员工，编号1-16)，员工做事时按照任务的先后顺序进行处理，这样可以避免错乱，
    
                    
    • 
                    
  • 深度长文解析SpringWebFlux响应式框架15个核心组件源码
                        快乐非自愿
javaspring
                        
    SpringWebFlux介绍SpringWebFlux是SpringFramework5.0版本引入的一个响应式Web框架，它与SpringMVC并存，提供了一种全新的编程范式，支持异步非阻塞的Web应用开发。WebFlux完全基于响应式编程模型，支持ReactiveStreams规范，可以在诸如Netty、Undertow以及Servlet3.1+容器上运行。WebFlux的核心控制器是Dis
    
                    
    • 
                    
  • Java网络编程：IO，NIO与Netty
                        坚持是一种态度
javajava网络编程NettyJavaIONIONIO与Netty
                        
    Java网络编程：IO，NIO与NettyJava网络编程：IO，NIO与NettyJavaI/O相关概念同步与异步阻塞与非阻塞OIONIOAIOreactor模型proactor模型JavaIO应用场景Netty简介NIO与Netty生产使用Java网络编程：IO，NIO与Netty新公司新项目，项目需要在硬件和软件平台进行信息传递，具体来说使用Netty。硬件和软件使用socket连接，硬件作
    
                    
    • 
                    
  • java reactor模式例子_Netty Reactor模式实现原理详解
                        weixin_39923623
javareactor模式例子
                        
    在前面的文章中(Reactor模型详解)，我们讲解了Reactor模式的各种演变形式，本文主要讲解的则是Netty是如何实现Reactor模式的。这里关于Netty实现的Reactor模式，需要说明的是，其实现的模式如下图所示：对于Netty使用的Reactor模式，其主要特点如下：使用一个线程作为mainReactor，专门用于监听客户端的连接事件，当获取到事件之后就将该事件交由Acceptor
    
                    
    • 
                    
  • Netty实战二-实现UDP的单播和广播(1)
                        2401_84048671
程序员udp网络协议网络
                        
    publicclassAnswerHandlerextendsSimpleChannelInboundHandler{/应答的具体内容从常量字符串数组中取得，由nextQuote方法随机获取/privatestaticfinalString[]DICTIONARY={“一个男生暗恋一个女生很久了。一天自习课上，男生偷偷的传了小纸条给女生，上面写着“其实我注意你很久了”。不一会儿，女生传了另一张纸条
    
                    
    • 
                    
  • netty源码解读三（NioEventLoop）
                        orcharddd_real
nettyjavanetty
                        
    NioEventLoop初始化EventExecutor类型的数组数组大小默认为cpu数量的两倍，遍历数组，通过newNioEventLoop(xxx)往数组中添加元素，NioEventLoop继承了EventExecutor；每次需要线程时，执行chooser的next方法从数组中取出一个线程；关键代码打开netty源码，找到example包下的EchoService类，追溯创建boss线程组和
    
                    
    • 
                    
  • Netty源码分析:NioEventLoopGroup
                        HelloWorld_EE
netty源码分析源代码nettyEventLoop
                        
    Netty源码分析:NioEventLoopGroup在工作之余，看到自己公司的超哥（俞超）关于Netty的系列博文，讲解的很好，因此，自己在学习之余也跟了下源代码，来了解Netty，也做了相关的笔记，将形成系列博文，这是第一篇。超哥的博文地址在这里：http://www.jianshu.com/p/c5068caab217Netty版本：4.0.23.Final借用超哥的例子，一般服务端的代码如
    
                    
    • 
                    
  • netty-NioServerSocketChannel和boss NioEventLoopGroup 如何建立关系的
                        一个人的想法
javanetty
                        
    一、EventLoopGroupbossGroup=newNioEventLoopGroup();EventLoopGroupworkerGroup=newNioEventLoopGroup();1、boss或者workerNioEventLoopGroup初始化完成了一个NioEventLoop数组（默认机器核数的2倍）所有NioEventLoop持有了同一个Executor调用execute时
    
                    
    • 
                    
  • 经验笔记：RPC与高性能NIO框架
                        漆黑的莫莫
计算机网络笔记rpcnio
                        
    RPC与高性能NIO框架的经验笔记引言随着互联网技术的发展，分布式系统逐渐成为了现代软件架构的标准之一。在这种架构中，服务之间的通信变得尤为关键，而RPC（远程过程调用）作为一种服务间通信的方式，因其简便的使用方式和高效的性能表现而受到了广泛的关注。在实现RPC的过程中，选择合适的网络通信框架至关重要，尤其是那些基于NIO（非阻塞I/O）的高性能框架，如Netty。本文将首先介绍RPC的概念及其在
    
                    
    • 
                    
  • 基础学习之——Netty
                        北欧人写代码
学习网络服务器
                        
    Netty是一个基于Java的网络通信框架，提供了一种简单、高效、可扩展的方式来开发网络服务器和客户端应用程序。Netty的设计目标是提供一种统一的异步编程模型，使得开发者能够轻松地编写可维护和可重用的代码。Netty的核心组件包括：Channel：网络通信的通道，可以用于读取、写入和关闭操作。EventLoop：负责处理I/O事件，包括接收、发送和处理数据。ChannelHandler：用于处理
    
                    
    • 
                    
  • Springboot-websocket实现及底层原理
                        No.Ada
深入项目底层原理springbootwebsocket后端
                        
    引入依赖SpringBoot中的WebSocket依赖于SpringWebFlux模块，使用了ReactorNetty库来实现底层的WebSocket通信。org.springframework.bootspring-boot-starter-websocket服务端配置/***WebSocket配置类*/@ConfigurationpublicclassWebSocketConfig{/***注
    
                    
    • 
                    
  • 【Netty】实战：基于WebSocket的聊天室
                        马丁的代码日记
netty聊天室网络websockethttp
                        
    本文将使用Netty快速实现一个聊天室应用，该应用基于WebSocket协议，用户可以在浏览器内聊天。实现过程很简单，就几步。一、处理Http请求packagecn.md.netty.websocket.groupchat;importio.netty.channel.*;importio.netty.handler.codec.http.*;importio.netty.handler.ssl.
    
                    
    • 
                    
  • 精通 Spring Cloud Feign：从理论到实战的通信优化之路
                        TopicOnline
springcloud
                        
    一、服务间调用的几种方式使用SpringCloud开发微服务时，在服务消费者调用服务提供者时，底层通过HTTPClient的方式访问。但实际上在服务调用时，有主要以下来实现：使用JDK原生的URLConnection；Apache提供的HTTPClient；Netty提供的异步HTTPClient；Spring提供的RestTemplate。SpringCloud的SpringCloudOpenF
    
                    
    • 
                    
  • Dubbo与Netty
                        蹩脚的小三

                        
    CodecCodecSupportAbstractCodecTransportCodecCodecAdapterDispacherChannelHandlersDispatcherAllDispatcherAllChannelHandlerChannelEventRunnableWrappedChannelHandlerChannelHandlerChannelHandlerAdapterChan
    
                    
    • 
                    
  • netty开发模拟qq斗地主
                        平平无奇的Coding Peasant
nettyqq斗地主
                        
    为什么要搞这样一个项目满足自己的java网络多线程编程的欲望！因为之前一直都是搞web开发，服务器和客户端数据交流人家web服务器早就给你搞好了，比如tomcat,jetty...等等，其实之前脑子里就有想过--是否可以自己开发一个简单的类似tomcat的web服务器，这样做了的话，至少知道其实web开发是建立在网络多线程web服务器之上否则web开发无从谈起！市面上的书籍和互联网上的电子教材以及
    
                    
    • 
                    
  • Netty 知识目录
                        王小工
javajava
                        
    Netty知识结构NettyBootstrap/ServerBootstrapNettyEventLoopGroup/EventLoopNettyChannelNettyChannelPipeline/ChannelHandlerNettyByteBufNettyTCPNettyUDPNettyHTTPNettyWebsocketNettySSL/TLS
    
                    
    • 
                    
  • elasticsearch简单介绍
                        甜美河边的钓鱼人
elasticsearch
                        
    1、elasticsearch简单介绍elasticsearch是基于操作文档的搜索引擎，里面使用了netty，luncen相关技术。它可以用作站内搜索，也可以结合Logstash，kibana等技术进行日志收集分析，使用聚合技术可以进行各种数据的聚合，并且和kibana一起展示条形图，饼图，map地理分布等功能。1.1、elasticsearch的安装因为是练习用的，所以我直接使用windows
    
                    
    • 
                    
  • Netty UDP
                        王小工
javaudp网络协议网络javanio
                        
    Netty在UDP（用户数据报协议，UserDatagramProtocol）通信中的应用非常广泛，特别是在对实时性要求较高、对数据准确性要求相对较低的场景中，如视频传输、语音通信等。以下是对Netty在UDP通信中的详细解析：一、UDP协议简介UDP是一种无连接的协议，它并不在通信双方之间建立连接，而是直接将数据包从发送端发送到接收端。UDP不保证数据包的可靠传输，也不保证数据包的顺序，因此其传
    
                    
    • 
                    
  • 【四、使用Netty编写UDP应用】
                        ThinkLess404
Netty网络编程udp网络协议网络
                        
    编写UDP应用目标创建UDPServer创建ServerHandler创建UDP客户端创建客户端的Handler目标之前的章节我们学习了编码服务端，使用TCP通信，本章我们学习如何使用Netty构建一个UDP应用。创建UDPServerpackagecom.coman404.base;importcom.coman404.base.handler.UDPServerHandler;importio
    
                    
    • 
                    
  • linux部署jar项目报错_linux jar 服务
                        国家级做梦冠军
linux部署jar项目报错
                        
    关于linuxjar服务的搜索结果问题linux重启netty服务一些问题，请大神进linux上部署netty架构的服务时我一般启动的时候用下面脚本nohupjava-jarxxx-xxx.jarstart80808888&关闭的时候杀进程就可以了。今天部署的时候启动服务就报userBind，于是我查...杨冬芳2019-12-0120:26:501161浏览量回答数0问题Linux下Tomcat
    
                    
    • 
                    
  • Spring Cloud全解析：网关之GateWay简介
                        拾光师
springcloudjava
                        
    GateWay简介由于zuul升级为zuul2时，netflix公司内部出现了分歧，所以springcloud自己研发了一套网关gateway，提供一种简单有效的方式来对API进行路由，以及提供一些强大的过滤器功能，如：熔断、限流、重试等，基于WebFlux框架实现的，底层使用了高性能的Reactor模式通信框架Netty特性基于spring5和springboot2构建动态路由：能够匹配任何请求
    
                    
    • 
                    
  • Netty+WebSocket实现高并发网络编程
                        Sunny_yiyi
Java精英阶级JavaWebSocket网络websocket网络协议
                        
    我们来实现一个Netty+WebSocket集成案例，由于Netty+WebSocket集成代码比较麻烦，我们可以利用目前开源的项目netty-websocket-spring-boot-starter轻松实现Netty和WebSocket的集成。我们搭建一个项目，项目叫seckill-message，用于处理通知用户抢单状态。1)pom.xmlorg.yeauty</groupId
    
                    
    • 
                    
  • Spring Boot 一个极简且完整的后台框架
                        搬砖养女人
数据库架构javaspringsqltomcat
                        
    一个完整的极简后台框架，方便做小项目的时候可以快速开发。这里面多贴图片和代码，做个参考吧，代码可以下载下来自己看看，里面这套后台模板不错，喜欢的拿去。先放几张图imageimageimage项目介绍SpringBoot，实现了一个极简单的后台框架image小编提供免费的Java架构学习资料（里面有高可用、高并发、高性能及分布式、Jvm性能调优、Spring源码，MyBatis，Netty,Redi
    
                    
    • 
                    
  • netty编程
                        chenjunxu

                        
    需要导包：netty-all-4.1.25.Final或者导入依赖：io.nettynetty-all4.1.25.Final定义一个server类：publicclassHelloServer{publicstaticvoidmain(String[]args){//定义一对线程组//主线程组,用于接受客户端的连接，但是不做任何处理，跟老板一样，不做事EventLoopGroupbossGrou
    
                    
    • 
                    
  • Simple RPC - 05 从零开始设计一个客户端（下）_ 依赖倒置和SPI
                        小小工匠
【SimpleRPC】rpc网络协议网络
                        
    文章目录Pre概述依赖倒置原则与解耦设计与实现1.定义接口来隔离调用方与实现类2.实现类`DynamicStubFactory`3.调用方与实现类的解耦依赖注入与SPI的解耦依赖注入SPI（ServiceProviderInterface）总结PreSimpleRPC-01框架原理及总体架构初探SimpleRPC-02通用高性能序列化和反序列化设计与实现SimpleRPC-03借助Netty实现异
    
                    
    • 
                    
  • 使用Netty实现 WebSocket至Socket的消息转发服务
                        Leon-aHandler
websocket服务器网络协议nettyspringboot
                        
    业务需求场景：通过网页发送指令至硬件设备，并在连接过程中能够接收来自硬件设备的实时参数信息中转服务器逻辑：服务器内实现了一个websocket服务端和一个socket客户端，设置全局保存的ChannelGroup进行消息的转发。项目框架使用的是Springboot代码地址：https://github.com/Leon-aHandler/Netty-relayDemo
    
                    
    • 
                    
  • Netty Websocket
                        王小工
javawebsocketjavanio
                        
    一、WebSocket协议概述WebSocket是一种在单个TCP连接上进行全双工通信的协议。它允许服务端主动向客户端推送数据，从而实现了实时通信。WebSocket建立在HTTP之上，但与HTTP的轮询（Polling）和长轮询（LongPolling）相比，WebSocket只需一次握手，即可在客户端和服务器之间建立持久的连接，并通过这个连接进行双向数据传输。二、Netty框架简介Netty是
    
                    
    • 
                    
  • Netty 实现 WebSocket 协议
                        最业余的程序猿
nettywebsocket网络协议网络
                        
    要使用Netty框架实现WebSocket服务端与客户端通信，你需要按照以下步骤进行：1、添加依赖首先，在你的项目中引入Netty和其WebSocket支持库的依赖。如果你使用Maven构建项目，可以在pom.xml文件中添加相应的依赖项。Maven:io.nettynetty-all4.1.77.Finalorg.springframework.bootspring-boot-starter-w
    
                    
    • 
                                
  • Algorithm
                                    香水浓
javaAlgorithm
                                    
    冒泡排序 
 

	public static void sort(Integer[] param) {
		for (int i = param.length - 1; i > 0; i--) {
			for (int j = 0; j < i; j++) {
				int current = param[j];
				int next = param[j + 1];
    
                                
    • 
                                
  • mongoDB 复杂查询表达式
                                    开窍的石头
mongodb
                                    
    1:count 
   Pg: db.user.find().count(); 
   统计多少条数据 
2:不等于$ne 
   Pg: db.user.find({_id:{$ne:3}},{name:1,sex:1,_id:0}); 
   查询id不等于3的数据。 
3：大于$gt $gte(大于等于) 
&n
    
                                
    • 
                                
  • Jboss Java heap space异常解决方法, jboss OutOfMemoryError : PermGen space
                                    0624chenhong
jvmjboss
                                    
    转自 
http://blog.csdn.net/zou274/article/details/5552630 
 
解决办法： 
 
window->preferences->java->installed jres->edit jre 
把default vm arguments 的参数设为-Xms64m -Xmx512m 
 
 
 
----------------
    
                                
    • 
                                
  • 文件上传 下载 解析 相对路径
                                    不懂事的小屁孩
文件上传
                                    
    有点坑吧，弄这么一个简单的东西弄了一天多，身边还有大神指导着，网上各种百度着。 
下面总结一下遇到的问题： 
 
文件上传，在页面上传的时候，不要想着去操作绝对路径，浏览器会对客户端的信息进行保护，避免用户信息收到攻击。 
在上传图片，或者文件时，使用form表单来操作。 
前台通过form表单传输一个流到后台，而不是ajax传递参数到后台，代码如下: 
 

<form action=&
    
                                
    • 
                                
  • 怎么实现qq空间批量点赞
                                    换个号韩国红果果
qq
                                    
    纯粹为了好玩！！ 
逻辑很简单 
1 打开浏览器console；输入以下代码。 
先上添加赞的代码 
 

var tools={};
		//添加所有赞
		function  init(){
			document.body.scrollTop=10000;
				setTimeout(function(){document.body.scrollTop=0;},2000);//加
    
                                
    • 
                                
  • 判断是否为中文
                                    灵静志远
中文
                                    
    方法一： 
public class Zhidao { 
 public static void main(String args[]) { 
 String s = "sdf灭礌 kjl d{';\fdsjlk是"; 
 int n=0; 
 for(int i=0; i<s.length(); i++) { 
 n = (int)s.charAt(i); 
 if((
    
                                
    • 
                                
  • 一个电话面试后总结
                                    a-john
面试
                                    
    今天，接了一个电话面试，对于还是初学者的我来说，紧张了半天。 
面试的问题分了层次，对于一类问题，由简到难。自己觉得回答不好的地方作了一下总结： 
  
在谈到集合类的时候，举几个常用的集合类，想都没想，直接说了list,map。 
  
然后对list和map分别举几个类型： 
  
list方面：ArrayList,LinkedList。在谈到他们的区别时，愣住了
    
                                
    • 
                                
  • MSSQL中Escape转义的使用
                                    aijuans
MSSQL
                                    
    IF OBJECT_ID('tempdb..#ABC') is not null
drop table tempdb..#ABC


create table #ABC
(
PATHNAME NVARCHAR(50)
)


insert into #ABC
SELECT N'/ABCDEFGHI' 
UNION ALL SELECT N'/ABCDGAFGASASSDFA' 
UNION ALL
    
                                
    • 
                                
  • 一个简单的存储过程
                                    asialee
mysql存储过程构造数据批量插入
                                    
               今天要批量的生成一批测试数据，其中中间有部分数据是变化的，本来想写个程序来生成的，后来想到存储过程就可以搞定，所以随手写了一个，记录在此： 
  
         
DELIMITER $$  
DROP PROCEDURE IF EXISTS inse
    
                                
    • 
                                
  • annot convert from HomeFragment_1 to Fragment
                                    百合不是茶
android导包错误
                                    
    创建了几个类继承Fragment, 需要将创建的类存储在ArrayList<Fragment>中; 出现不能将new 出来的对象放到队列中,原因很简单; 
    创建类时引入包是:import android.app.Fragment; 
  
   创建队列和对象时使用的包是:import android.support.v4.ap
    
                                
    • 
                                
  • Weblogic10两种修改端口的方法
                                    bijian1013
weblogic端口号配置管理config.xml
                                    
    一.进入控制台进行修改    1.进入控制台:  http://127.0.0.1:7001/console     2.展开左边树菜单         域结构->环境->服务器-->点击AdminServer(管理) &
    
                                
    • 
                                
  • mysql 操作指令
                                    征客丶
mysql
                                    
    一、连接mysql 
进入 mysql 的安装目录； 
$ bin/mysql -p [host IP 如果是登录本地的mysql 可以不写 -p 直接 -u] -u [userName] -p 
输入密码，回车，接连； 
 
二、权限操作［如果你很了解mysql数据库后，你可以直接去修改系统表，然后用 mysql> flush privileges; 指令让权限生效］ 
1、赋权 
mys
    
                                
    • 
                                
  • 【Hive一】Hive入门
                                    bit1129
hive
                                    
    Hive安装与配置 
Hive的运行需要依赖于Hadoop，因此需要首先安装Hadoop2.5.2，并且Hive的启动前需要首先启动Hadoop。 
  Hive安装和配置的步骤 
  
1. 从如下地址下载Hive0.14.0 
  
http://mirror.bit.edu.cn/apache/hive/ 
  
 2.解压hive，在系统变
    
                                
    • 
                                
  • ajax 三种提交请求的方法
                                    BlueSkator
Ajaxjqery
                                    
    1、ajax 提交请求 
$.ajax({
			type:"post",
			url : "${ctx}/front/Hotel/getAllHotelByAjax.do",
			dataType : "json",
			success : function(result) {
				try {
					for(v
    
                                
    • 
                                
  • mongodb开发环境下的搭建入门
                                    braveCS
运维
                                    
      
linux下安装mongodb 
1）官网下载mongodb-linux-x86_64-rhel62-3.0.4.gz 
2）linux 解压   
gzip -d mongodb-linux-x86_64-rhel62-3.0.4.gz; 
mv mongodb-linux-x86_64-rhel62-3.0.4 mongodb-linux-x86_64-rhel62-
    
                                
    • 
                                
  • 编程之美-最短摘要的生成
                                    bylijinnan
java数据结构算法编程之美
                                    
    

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

public class ShortestAbstract {

	/**
	 * 编程之美 最短摘要的生成
	 * 扫描过程始终保持一个[pBegin,pEnd]的range,初始化确保[pBegin,pEnd]的ran
    
                                
    • 
                                
  • json数据解析及typeof
                                    chengxuyuancsdn
jstypeofjson解析
                                    
       
       // json格式
	var people='{"authors": [{"firstName": "AAA","lastName": "BBB"},'
		                    +' {"firstName": "CCC&
    
                                
    • 
                                
  • 流程系统设计的层次和目标
                                    comsci
设计模式数据结构sql框架脚本
                                    
     
                              流程系统设计的层次和目标 
 
 
 
    
                                
    • 
                                
  • RMAN List和report 命令
                                    daizj
oraclelistreportrman
                                    
    LIST 命令 
使用RMAN LIST 命令显示有关资料档案库中记录的备份集、代理副本和映像副本的 
信息。使用此命令可列出： 
• RMAN 资料档案库中状态不是AVAILABLE 的备份和副本 
• 可用的且可以用于还原操作的数据文件备份和副本 
• 备份集和副本，其中包含指定数据文件列表或指定表空间的备份 
• 包含指定名称或范围的所有归档日志备份的备份集和副本 
• 由标记、完成时间、可
    
                                
    • 
                                
  • 二叉树:红黑树
                                    dieslrae
二叉树
                                    
        红黑树是一种自平衡的二叉树,它的查找,插入,删除操作时间复杂度皆为O(logN),不会出现普通二叉搜索树在最差情况时时间复杂度会变为O(N)的问题. 
    红黑树必须遵循红黑规则,规则如下 
    
1、每个节点不是红就是黑。     2、根总是黑的  &
    
                                
    • 
                                
  • C语言homework3，7个小题目的代码
                                    dcj3sjt126com
c
                                    
    1、打印100以内的所有奇数。 
# include <stdio.h>

int main(void)
{
	int i;

	for (i=1; i<=100; i++)
	{
		if (i%2 != 0)
			printf("%d ", i);
	}

	return 0;
}
 
 2、从键盘上输入10个整数，
    
                                
    • 
                                
  • 自定义按钮, 图片在上, 文字在下, 居中显示
                                    dcj3sjt126com
自定义
                                    
    #import <UIKit/UIKit.h>

@interface MyButton : UIButton

-(void)setFrame:(CGRect)frame ImageName:(NSString*)imageName Target:(id)target Action:(SEL)action Title:(NSString*)title Font:(CGFloa
    
                                
    • 
                                
  • MySQL查询语句练习题，测试足够用了
                                    flyvszhb
sqlmysql
                                    
    http://blog.sina.com.cn/s/blog_767d65530101861c.html 
1.创建student和score表 
CREATE  TABLE  student ( 
id  INT(10)  NOT NULL  UNIQUE  PRIMARY KEY  , 
name  VARCHAR
    
                                
    • 
                                
  • 转：MyBatis Generator 详解
                                    happyqing
mybatis
                                    
      
MyBatis Generator 详解 
http://blog.csdn.net/isea533/article/details/42102297 
  
MyBatis Generator详解 
http://git.oschina.net/free/Mybatis_Utils/blob/master/MybatisGeneator/MybatisGeneator.
    
                                
    • 
                                
  • 让程序员少走弯路的14个忠告
                                    jingjing0907
工作计划学习
                                    
      
无论是谁，在刚进入某个领域之时，有再大的雄心壮志也敌不过眼前的迷茫：不知道应该怎么做，不知道应该做什么。下面是一名软件开发人员所学到的经验，希望能对大家有所帮助 
  
1.不要害怕在工作中学习。  
只要有电脑，就可以通过电子阅读器阅读报纸和大多数书籍。如果你只是做好自己的本职工作以及分配的任务，那是学不到很多东西的。如果你盲目地要求更多的工作，也是不可能提升自己的。放
    
                                
    • 
                                
  • nginx和NetScaler区别
                                    流浪鱼
nginx
                                    
    NetScaler是一个完整的包含操作系统和应用交付功能的产品，Nginx并不包含操作系统，在处理连接方面，需要依赖于操作系统，所以在并发连接数方面和防DoS攻击方面，Nginx不具备优势。 
2.易用性方面差别也比较大。Nginx对管理员的水平要求比较高，参数比较多，不确定性给运营带来隐患。在NetScaler常见的配置如健康检查，HA等，在Nginx上的配置的实现相对复杂。 
3.策略灵活度方
    
                                
    • 
                                
  • 第11章 动画效果（下）
                                    onestopweb
动画
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • FAQ - SAP BW BO roadmap
                                    blueoxygen
BOBW
                                    
    http://www.sdn.sap.com/irj/boc/business-objects-for-sap-faq 
  
Besides, I care that how to integrate tightly. 
  
By the way, for BW consultants, please just focus on Query Designer which i
    
                                
    • 
                                
  • 关于java堆内存溢出的几种情况
                                    tomcat_oracle
javajvmjdkthread
                                    
    【情况一】：   　　 
java.lang.OutOfMemoryError: Java heap space：这种是java堆内存不够，一个原因是真不够，另一个原因是程序中有死循环；   　　如果是java堆内存不够的话，可以通过调整JVM下面的配置来解决：   　　<jvm-arg>-Xms3062m</jvm-arg>   　　<jvm-arg>-Xmx
    
                                
    • 
                                
  • Manifest.permission_group权限组
                                    阿尔萨斯
Permission
                                    
    结构 
继承关系 
public static final class Manifest.permission_group extends Object 
java.lang.Object 
android. Manifest.permission_group 常量 
ACCOUNTS 直接通过统计管理器访问管理的统计 
COST_MONEY可以用来让用户花钱但不需要通过与他们直接牵涉的权限 
D
    
                                
    •