markdown复制代码    1
   / \
  2   2
 / \ / \
3  4 4  3

markdown复制代码    1
   / \
  2   2
   \   \
   3    3

java复制代码    public boolean isSymmetric(TreeNode root) {
        if(root == null)
            return true;
        return dfs(root.left, root.right);
    }

    public boolean dfs(TreeNode left, TreeNode right) {
        if (left == null && right == null)
            return true;
        else if (left == null || right == null)
            return false;
        else if (left.val != right.val)
            return false;
        return dfs(left.left, right.right) && dfs(left.right, right.left);
    }

java复制代码    public static void main(String[] args) {
        TreeNode treeNode = new TreeNode(1,
                new TreeNode(2, new TreeNode(3), new TreeNode(4)),
                new TreeNode(2, new TreeNode(4), new TreeNode(3)));
        boolean flag = new Number101().isSymmetric(treeNode);
        System.out.println(flag);
    }

css复制代码 import pandas as pd
 a=pd.DataFrame(data=[['A',19],['B',19],['C',20],['A',19],['C',20]],
                columns=['name','age'])
 print(a)
 print('--------------------------')
 a=a.duplicated()
 print(a)

css复制代码 import pandas as pd
 a=pd.DataFrame(data=[['A',19],['B',19],['C',20],['A',19],['C',20]],
                columns=['name','age'])
 print(a)
 print('--------------------------')
 a=any(a.duplicated())
 print(a)

css复制代码 import pandas as pd
 a=pd.DataFrame(data=[['A',19],['B',19],['C',20],['A',19],['C',20]],
                columns=['name','age'])
 print(a)
 print('--------------------------')
 b=a.drop_duplicates(inplace=False)
 a.drop_duplicates(inplace=True)
 print(a)
 print('--------------------------')
 print(b)

python复制代码 import pandas as pd
 a=pd.read_csv(r'text.csv')
 print(a)

python复制代码 import pandas as pd
 a=pd.read_csv(r'text.csv')
 print(a.isnull())

python复制代码 import pandas as pd
 a=pd.read_csv(r'text.csv')
 print(a.isnull().any())
 print(a.isnull().any(axis=1))

python复制代码 import pandas as pd
 a=pd.read_csv(r'text.csv')
 del a['name']
 print(a)

python复制代码 import pandas as pd
 a=pd.read_csv(r'text.csv')
 b=a.dropna(axis=0)
 print(b)
 c=a.dropna(axis=1)
 print(c)

python复制代码import pandas as pd
a=pd.read_csv(r'text.csv')
a=a.fillna('wu')
print(a)

python复制代码import pandas as pd
a=pd.read_csv(r'text.csv')
print(a)
print('---------------------')
b=a.fillna(method='pad')
print(b)
print('---------------------')
c=a.fillna(method='bfill')
print(c)

python复制代码import pandas as pd
a=pd.read_csv(r'text.csv')
print(a)
print('---------------------')
a=a.fillna(a.mean())
print(a)

python复制代码import pandas as pd
a=pd.read_csv(r'text.csv')
print(a)
print('---------------------')
a=a.fillna(a.median( ))
print(a)

python复制代码import pandas as pd
a=pd.read_csv(r'text.csv')
print(a)
print('---------------------')
for i in a.columns:
    a[i] = a[i].fillna(a[i].mode()[0])
print(a)

css复制代码import pandas as pd
data={'sex':[1,0,1,1,0]}
a=pd.DataFrame(data)
a['sex-T']=a['sex'].map({1:'男',0:'女'})
print(a)

ini复制代码import pandas as pd
data={'sex':['男','女','男','女','保密']}
a=pd.DataFrame(data)
a=pd.get_dummies(a)
print(a)

ini复制代码import bisect 

l = [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] 
bisect.bisect(l, 55) # returns 7

python复制代码import timeit 
import bisect

print(timeit.timeit('bisect.bisect([1, 4, 9, 16, 25, 36, 49, 64, 81, 100], 55)','import bisect'))  
# 0.2991909169941209
print(timeit.timeit('next(i for i,n in enumerate([1, 4, 9, 16, 25, 36, 49, 64, 81, 100]) if n > 55)'))  
# 0.7511563330190256
print(timeit.timeit('next(([1, 4, 9, 16, 25, 36, 49, 64, 81, 100].index(n) for n in [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] if n > 55))')) 
# 0.6965440830099396

bash复制代码print(bisect.bisect_left([2,4,7,9],2)) 
# 0
print(bisect.bisect_left([2,4,7,9],3)) 
# 1
print(bisect.bisect_right([2,4,7,9],2)) 
# 1
print(bisect.bisect_right([2,4,7,9],3)) 
# 1

ini复制代码arr=[2,4,7,9]
bisect.insort(arr,6)
arr # [2, 4, 6, 7, 9]

js复制代码go get github.com/chenjiandongx/collections

js复制代码import "github.com/chenjiandongx/collections"

js复制代码var q  = Q()

func Q() *collections.Queue {
   q := collections.NewQueue()
   return q
}

func main() {
   for i :=0; i < 10;i++{
      q.Put(i)
   }
   for i:=0;i <10 ;i++  {
      if item,ok:=q.Get(); ok{
         fmt.Println(item)
      }
   }
}

js复制代码func main() {
   q := collections.NewLifoQueue()
   for i := 0; i < 10; i++ {
      q.Put(i)
   }
   for i := 0; i < 10; i++ {
      if item, ok := q.Get(); ok {
         fmt.Println(item)
      }
   }
}

js复制代码var (
   q = collections.NewQueue()
)

func main() {
   go QueueApi()
   Web()
}

func Web() {
   r := gin.Default()
   r.GET("/api/devops", func(c *gin.Context) {

      args1 := c.Query("args1")
      args2 := c.Query("args2")
      data := map[string]string{
         "parameters1": args1,
         "parameters2": args2,
      }
      q.Put(data)

      c.JSON(http.StatusOK, gin.H{
         "message": "commit success",
         "data":    "ok",
         "code":    200,
      })
   })

   r.Run(":8080")
}

func QueueApi() {
   fmt.Println("开始监听队列....")
   for {
      select {
      case <-time.After(time.Second * 5):
         if item, ok := q.Get(); ok {
            result := item.(map[string]string)
            var wg sync.WaitGroup
            wg.Add(1)
            go func() {
               defer wg.Done()
               //TODO  具体执行的逻辑
               time.Sleep(10 * time.Second)
               fmt.Println(result)
            }()
            wg.Wait()
         }
      }
   }
}

js复制代码#测试
curl --location --request GET 'localhost:8080?args1=hello&args2=world'

java复制代码CacheKey cacheKey = new CacheKey();
/MappedStatement的id
// id就是Sql语句的所在位置包名+类名+ SQL名称
cacheKey.update(ms.getId());
// offset就是0
cacheKey.update(rowBounds.getOffset());
// limit就是Integer.MAXVALUE
cacheKey.update(rowBounds.getLimit());
//具体的SQL语句
cacheKey.update(boundSql.getSql());
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
// mimic DefaultParameterHandler logic
for (ParameterMapping parameterMapping : parameterMappings) {
  if (parameterMapping.getMode() != ParameterMode.OUT) {
    Object value;
       ...
    //后⾯是update了sql中带的参数
    cacheKey.update(value);
  }
}
if (configuration.getEnvironment() != null) {
  // issue #176
  cacheKey.update(configuration.getEnvironment().getId());
}
return cacheKey;

java复制代码public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
   /拿到转换后的sql
  BoundSql boundSql = ms.getBoundSql(parameter);
  //创建缓存
  CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
  //调用具体实现方法
  return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}

java复制代码@SuppressWarnings("unchecked")
Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler,CacheKey key,BoundSql boundSql) throws SQLException {
    ...
    //判断缓存的map集合中是否存有插入的sql数据，如果有就直接去除，如果没有就查询数据库
    list=resultHandler==null? (List<E>) localCache.getObject(key) : null;
    if (list!=null) {
        //这个主要是处理存储过程⽤的。
        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
    } else {
        list=queryFromDatabase(ms, parameter, rowBounds, resultHandler, key,boundSql);
    }
        ...
    }

java复制代码private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
  List<E> list;
  localCache.putObject(key, EXECUTION_PLACEHOLDER);
  try {
    list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
  } finally {
  
    localCache.removeObject(key);
  }
  //把数据库查询结果存到一级缓存中
  localCache.putObject(key, list);
  if (ms.getStatementType() == StatementType.CALLABLE) {
  
    localOutputParameterCache.putObject(key, parameter);
  }
  return list;
}

java复制代码private Map<Object, Object> cache = new HashMap<Object, Object>();
@Override
    public void putObject(Object key, Object value) { 
        cache.put(key, value);
    }

java复制代码package com.kevin.annotation;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface Kevin {
    String name() default "kevin";
}

java复制代码package com.kevin;

import com.kevin.annotation.Kevin;

@Kevin
public class Test {

  public static void showKevin(Class c) {
      System.out.println(c.getName());
      boolean isExist = c.isAnnotationPresent(Kevin.class);

      if (isExist) {
          Kevin kevin = (Kevin) c.getAnnotation(Kevin.class);
          System.out.println(kevin.name());
      }
  }

  public static void main(String[] args) {
      Test.showKevin(Test.class);
  }
}

java复制代码
com.kevin.Test
kevin

Process finished with exit code 0

kotlin复制代码package com.kevin.demo;

public class Demo1 {

    @Override
    public String toString(){
        return "demo1";
    }
}

csharp复制代码package com.kevin.demo;

public class Demo1 {

    @Deprecated
    public void goHome(){
        System.out.println("过时的方法");
    }
}

typescript复制代码    @SuppressWarnings("deprecation")
    public static void main(String[] args) {
        Demo1 demo1 = new Demo1();
        demo1.goHome();
    }

less复制代码@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

less复制代码@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
    String[] value();
}

less复制代码@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Documented {
}

less复制代码public class Demo1 {

        @Inherited
        @Retention(RetentionPolicy.RUNTIME)
        static @interface Test {
        }

        @Test
        static class Base {
        }

        static class Child extends Base {
        }

        public static void main(String[] args) {
            System.out.println(Child.class.isAnnotationPresent(Test.class));
        }

}

xml复制代码        <dependency>
            <groupId>org.flywaydb</groupId>
            <artifactId>flyway-core</artifactId>
            <version>6.4.4</version>
        </dependency>

yaml复制代码spring:
 flyway: # flyway 数据库 DDL 版本控制
    enabled: true # 正式环境才开启
    clean-disabled: true # 禁用数据库清理
    encoding: UTF-8
    locations: classpath:/db #脚本存放地址
    table: flyway_schema_history_systemportal #flyway记录表，记录了当前执行到了那个脚本
    baseline-version: 1 # 基线版本默认开始序号 默认为 1
    baseline-on-migrate: true #  针对非空数据库是否默认调用基线版本,为空的话默认会调用基线版本
    placeholder-replacement: false
    placeholders: # 定义 afterMigrateError.sql 要清理的元数据表表名
      flyway-table: ${spring.flyway.table}

sql复制代码  ALTER TABLE "systemportal"."task_plan"
  ALTER COLUMN "update_user" TYPE varchar(255) USING "update_user"::varchar(255);

java复制代码@Component
public class RuntimeConfig implements ApplicationListener<ContextRefreshedEvent> {

    @Autowired
    private Scheduler scheduler;

    @Autowired
    private QrtzJobDao qrtzJobDao;

    @Override
    public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
        this.initJob();
    }

    public void initJob() {
        QrtzJobVO qrtzJobVO = new QrtzJobVO();
        List<QrtzJobVO> scheduleJobList = qrtzJobDao.queryQrtzJobAll(qrtzJobVO);
        scheduleJobList.forEach(scheduleJob -> {
            CronTrigger cronTrigger = ScheduleUtils.getCronTrigger(this.scheduler, scheduleJob.getJobId());
            if (cronTrigger == null) {
                ScheduleUtils.createScheduleJob(this.scheduler, scheduleJob);
            } else {
                ScheduleUtils.updateScheduleJob(this.scheduler, scheduleJob);
            }
        });
    }
}

ini复制代码Input: preorder = [1,2,4,5,3,6,7], postorder = [4,5,2,6,7,3,1]
Output: [1,2,3,4,5,6,7]

ini复制代码Input: preorder = [1], postorder = [1]
Output: [1]

sql复制代码1 <= preorder.length <= 30
1 <= preorder[i] <= preorder.length
All the values of preorder are unique.
postorder.length == preorder.length
1 <= postorder[i] <= postorder.length
All the values of postorder are unique.
It is guaranteed that preorder and postorder are the preorder traversal and postorder traversal of the same binary tree.

python复制代码class TreeNode(object):
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
class Solution(object):
    def constructFromPrePost(self, preorder, postorder):
        """
        :type preorder: List[int]
        :type postorder: List[int]
        :rtype: TreeNode
        """
        def dfs(pre, post):
            if not pre:
                return None
            if len(pre)==1:
                return TreeNode(post.pop())
            node = TreeNode(post.pop())
            idx = pre.index(post[-1])
            node.right = dfs(pre[idx:], post)
            node.left = dfs(pre[1:idx], post)
            return node
        return dfs(preorder, postorder)

erlang复制代码Runtime: 40 ms, faster than 75.96% of Python online submissions for Construct Binary Tree from Preorder and Postorder Traversal.
Memory Usage: 13.8 MB, less than 5.77% of Python online submissions for Construct Binary Tree from Preorder and Postorder Traversal.

java复制代码public class NettyBasicServerExample {

    public void bind(int port){
        //netty的服务端编程要从EventLoopGroup开始，
        // 我们要创建两个EventLoopGroup，
        // 一个是boss专门用来接收连接，可以理解为处理accept事件，
        // 另一个是worker，可以关注除了accept之外的其它事件，处理子任务。
        //上面注意，boss线程一般设置一个线程，设置多个也只会用到一个，而且多个目前没有应用场景，
        // worker线程通常要根据服务器调优，如果不写默认就是cpu的两倍。
        EventLoopGroup bossGroup=new NioEventLoopGroup();

        EventLoopGroup workerGroup=new NioEventLoopGroup();
        try {
            //服务端要启动，需要创建ServerBootStrap，
            // 在这里面netty把nio的模板式的代码都给封装好了
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup)
                //配置Server的通道，相当于NIO中的ServerSocketChannel
                .channel(NioServerSocketChannel.class)
                .handler(new LoggingHandler(LogLevel.INFO)) //设置ServerSocketChannel对应的Handler
                //childHandler表示给worker那些线程配置了一个处理器，
                // 这个就是上面NIO中说的，把处理业务的具体逻辑抽象出来，放到Handler里面
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        socketChannel.pipeline()
                            .addLast(new NormalInBoundHandler("NormalInBoundA",false))
                            .addLast(new NormalInBoundHandler("NormalInBoundB",false))
                            .addLast(new NormalInBoundHandler("NormalInBoundC",true));
                        socketChannel.pipeline()
                            .addLast(new NormalOutBoundHandler("NormalOutBoundA"))
                            .addLast(new NormalOutBoundHandler("NormalOutBoundB"))
                            .addLast(new NormalOutBoundHandler("NormalOutBoundC"))
                            .addLast(new ExceptionHandler());
                    }
                });
            //绑定端口并同步等待客户端连接
            ChannelFuture channelFuture=bootstrap.bind(port).sync();
            System.out.println("Netty Server Started,Listening on :"+port);
            //等待服务端监听端口关闭
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //释放线程资源
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) {
        new NettyBasicServerExample().bind(8080);
    }
}

java复制代码public class NormalInBoundHandler extends ChannelInboundHandlerAdapter {
    private final String name;
    private final boolean flush;

    public NormalInBoundHandler(String name, boolean flush) {
        this.name = name;
        this.flush = flush;
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("InboundHandler:"+name);
        if(flush){
            ctx.channel().writeAndFlush(msg);
        }else {
            throw new RuntimeException("InBoundHandler:"+name);
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println("InboundHandlerException:"+name);
        super.exceptionCaught(ctx, cause);
    }
}

java复制代码public class NormalOutBoundHandler extends ChannelOutboundHandlerAdapter {
    private final String name;

    public NormalOutBoundHandler(String name) {
        this.name = name;
    }

    @Override
    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
        System.out.println("OutBoundHandler:"+name);
        super.write(ctx, msg, promise);
    }
}

java复制代码bootstrap.group(bossGroup, workerGroup)
    //配置Server的通道，相当于NIO中的ServerSocketChannel
    .channel(NioServerSocketChannel.class)
    .handler(new LoggingHandler(LogLevel.INFO)) //设置ServerSocketChannel对应的Handler
    //childHandler表示给worker那些线程配置了一个处理器，
    // 这个就是上面NIO中说的，把处理业务的具体逻辑抽象出来，放到Handler里面
    .childHandler(new ChannelInitializer<SocketChannel>() {
    });

java复制代码public abstract class AbstractBootstrap<B extends AbstractBootstrap<B, C>, C extends Channel> implements Cloneable {
    @SuppressWarnings("unchecked")
    private static final Map.Entry<ChannelOption<?>, Object>[] EMPTY_OPTION_ARRAY = new Map.Entry[0];
    @SuppressWarnings("unchecked")
    private static final Map.Entry<AttributeKey<?>, Object>[] EMPTY_ATTRIBUTE_ARRAY = new Map.Entry[0];
    /**
     * 这里的EventLoopGroup 作为服务端 Acceptor 线程，负责处理客户端的请求接入
     * 作为客户端 Connector 线程，负责注册监听连接操作位，用于判断异步连接结果。
     */
    volatile EventLoopGroup group; //
    @SuppressWarnings("deprecation")
    private volatile ChannelFactory<? extends C> channelFactory;  //channel工厂，很明显应该是用来制造对应Channel的
    private volatile SocketAddress localAddress;  //SocketAddress用来绑定一个服务端地址

    // The order in which ChannelOptions are applied is important they may depend on each other for validation
    // purposes.
    /**
     * ChannelOption 可以添加Channer 添加一些配置信息
     */
    private final Map<ChannelOption<?>, Object> options = new LinkedHashMap<ChannelOption<?>, Object>();
    private final Map<AttributeKey<?>, Object> attrs = new ConcurrentHashMap<AttributeKey<?>, Object>();
    /**
     *  ChannelHandler 是具体怎么处理Channer 的IO事件。
     */
    private volatile ChannelHandler handler;
}

java复制代码public class ServerBootstrap extends AbstractBootstrap<ServerBootstrap, ServerChannel> {

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

    // The order in which child ChannelOptions are applied is important they may depend on each other for validation
    // purposes.
    //SocketChannel相关的属性配置
    private final Map<ChannelOption<?>, Object> childOptions = new LinkedHashMap<ChannelOption<?>, Object>();
    private final Map<AttributeKey<?>, Object> childAttrs = new ConcurrentHashMap<AttributeKey<?>, Object>();
    private final ServerBootstrapConfig config = new ServerBootstrapConfig(this); //配置类
    private volatile EventLoopGroup childGroup;  //工作线程组
    private volatile ChannelHandler childHandler; //负责SocketChannel的IO处理相关的Handler

    public ServerBootstrap() { }
}

java复制代码 ChannelFuture channelFuture=bootstrap.bind(port).sync();

java复制代码public ChannelFuture bind(SocketAddress localAddress) {
    validate();
    return doBind(ObjectUtil.checkNotNull(localAddress, "localAddress"));
}

java复制代码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;
    }
}

java复制代码final ChannelFuture initAndRegister() {
    Channel channel = null;
    try {
        //通过ChannelFactory创建一个具体的Channel实现
        channel = channelFactory.newChannel();
        init(channel); //初始化
    } catch (Throwable t) {
        //省略....
    }
    //这个代码应该和我们猜想是一致的，就是将当前初始化的channel注册到selector上，这个过程同样也是异步的
    ChannelFuture regFuture = config().group().register(channel);
    if (regFuture.cause() != null) { //获取regFuture的执行结果
        if (channel.isRegistered()) { 
            channel.close();
        } else {
            channel.unsafe().closeForcibly();
        }
    }
    return regFuture;
}

java复制代码bootstrap.group(bossGroup, workerGroup)
    //配置Server的通道，相当于NIO中的ServerSocketChannel
    .channel(NioServerSocketChannel.class)

java复制代码public B channel(Class<? extends C> channelClass) {
    return channelFactory(new ReflectiveChannelFactory<C>(
        ObjectUtil.checkNotNull(channelClass, "channelClass")
    ));
}

java复制代码@Override
public T newChannel() {
    try {
        return constructor.newInstance();
    } catch (Throwable t) {
        throw new ChannelException("Unable to create Channel from class " + constructor.getDeclaringClass(), t);
    }
}

java复制代码public class ReflectiveChannelFactory<T extends Channel> implements ChannelFactory<T> {

    private final Constructor<? extends T> constructor;

    public ReflectiveChannelFactory(Class<? extends T> 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);
        }
    }
}

java复制代码public class NioServerSocketChannel extends AbstractNioMessageChannel
                             implements io.netty.channel.socket.ServerSocketChannel {
    private static ServerSocketChannel newSocket(SelectorProvider provider) {
        try {
            return provider.openServerSocketChannel();
        } catch (IOException e) {
            throw new ChannelException(
                    "Failed to open a server socket.", e);
        }
    }
    public NioServerSocketChannel() {
        this(newSocket(DEFAULT_SELECTOR_PROVIDER));
    }
}

java复制代码public ServerSocketChannel openServerSocketChannel() throws IOException {
    return new ServerSocketChannelImpl(this);
}

java复制代码public NioServerSocketChannel(ServerSocketChannel channel) {
    super(null, channel, SelectionKey.OP_ACCEPT);
    config = new NioServerSocketChannelConfig(this, javaChannel().socket());
}

java复制代码protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
    super(parent);
    this.ch = ch;
    this.readInterestOp = readInterestOp; //设置关心事件，此时是一个连接事件，所以是OP_ACCEPT
    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);
    }
}

java复制代码final ChannelFuture initAndRegister() {
//省略....
    //这个代码应该和我们猜想是一致的，就是将当前初始化的channel注册到selector上，这个过程同样也是异步的
    ChannelFuture regFuture = config().group().register(channel);
    if (regFuture.cause() != null) { //获取regFuture的执行结果
        if (channel.isRegistered()) { 
            channel.close();
        } else {
            channel.unsafe().closeForcibly();
        }
    }
    return regFuture;
}

java复制代码@Override
public ChannelFuture register(Channel channel) {
    return next().register(channel);
}

java复制代码@Override
public ChannelFuture register(Channel channel) {
    return register(new DefaultChannelPromise(channel, this));
}

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

java复制代码@Override
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)) { //判断eventLoop类型是否是EventLoop对象类型，如果不是则抛出异常
        promise.setFailure(
            new IllegalStateException("incompatible event loop type: " + eventLoop.getClass().getName()));
        return;
    }

    AbstractChannel.this.eventLoop = eventLoop;
	//Reactor内部线程调用，也就是说当前register方法是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);
        }
    }
}

java复制代码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();  //调用JDK层面的register()方法进行注册
        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(); //触发Handler，如果有必要的情况下

        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()) { //此时是ServerSocketChannel的注册，所以连接还处于非活跃状态
            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);
    }
}

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

java复制代码private static void doBind0(
    final ChannelFuture regFuture, final Channel channel,
    final SocketAddress localAddress, final ChannelPromise promise) {

    //获取当前channel中的eventLoop实例，执行一个异步任务。
    //需要注意，以前我们在课程中讲过，eventLoop在轮询中一方面要执行select遍历，另一方面要执行阻塞队列中的任务，而这里就是把任务添加到队列中异步执行。
    channel.eventLoop().execute(new Runnable() {
        @Override
        public void run() {
            //如果ServerSocketChannel注册成功，则调用该channel的bind方法
            if (regFuture.isSuccess()) {
                channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
            } else {
                promise.setFailure(regFuture.cause());
            }
        }
    });
}

java复制代码protected void doBind(SocketAddress localAddress) throws Exception {
    if (PlatformDependent.javaVersion() >= 7) {
        javaChannel().bind(localAddress, config.getBacklog());
    } else {
        javaChannel().socket().bind(localAddress, config.getBacklog());
    }
}

java复制代码.childHandler(new ChannelInitializer<SocketChannel>() {
    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        socketChannel.pipeline()
            .addLast(new NormalInBoundHandler("NormalInBoundA",false))
            .addLast(new NormalInBoundHandler("NormalInBoundB",false))
            .addLast(new NormalInBoundHandler("NormalInBoundC",true));
        socketChannel.pipeline()
            .addLast(new NormalOutBoundHandler("NormalOutBoundA"))
            .addLast(new NormalOutBoundHandler("NormalOutBoundB"))
            .addLast(new NormalOutBoundHandler("NormalOutBoundC"))
            .addLast(new ExceptionHandler());
    }
});

java复制代码final ChannelFuture initAndRegister() {
        Channel channel = null;
        try {
            channel = channelFactory.newChannel(); //这是是创建channel
            init(channel); //这里是初始化
        } catch (Throwable t) {
            //省略....
        }
        ChannelFuture regFuture = config().group().register(channel); //这是是注册
        if (regFuture.cause() != null) {
            if (channel.isRegistered()) {
                channel.close();
            } else {
                channel.unsafe().closeForcibly();
            }
        }

        return regFuture;
    }

java复制代码@Override
void init(Channel channel) {
    setChannelOptions(channel, newOptionsArray(), logger);
    setAttributes(channel, newAttributesArray());

    ChannelPipeline p = channel.pipeline();

    final EventLoopGroup currentChildGroup = childGroup;
    final ChannelHandler currentChildHandler = childHandler;  //childHandler就是在服务端配置时添加的ChannelInitializer
    final Entry<ChannelOption<?>, Object>[] currentChildOptions = newOptionsArray(childOptions);
    final Entry<AttributeKey<?>, Object>[] currentChildAttrs = newAttributesArray(childAttrs);
    // 此时的Channel是NioServerSocketChannel，这里是为NioServerSocketChannel添加处理器链。
    p.addLast(new ChannelInitializer<Channel>() {
        @Override
        public void initChannel(final Channel ch) {
            final ChannelPipeline pipeline = ch.pipeline();
            ChannelHandler handler = config.handler(); //如果在ServerBootstrap构建时，通过.handler添加了处理器，则会把相关处理器添加到NioServerSocketChannel中的pipeline中。
            if (handler != null) {
                pipeline.addLast(handler);
            }

            ch.eventLoop().execute(new Runnable() { //异步天剑一个ServerBootstrapAcceptor处理器，从名字来看，
                @Override
                public void run() {
                    pipeline.addLast(new ServerBootstrapAcceptor(
                        //currentChildHandler，表示SocketChannel的pipeline，当收到客户端连接时，就会把该handler添加到当前SocketChannel的pipeline中
                        ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
                }
            });
        }
    });
}

java复制代码protected AbstractChannel(Channel parent) {
    this.parent = parent;
    id = newId();
    unsafe = newUnsafe();
    pipeline = newChannelPipeline();
}

java复制代码public void channelRead(ChannelHandlerContext ctx, Object msg) {
    final Channel child = (Channel) msg;

    child.pipeline().addLast(childHandler);  //在这里，将handler添加到SocketChannel的pipeline中

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

    try {
        //把当前客户端的链接SocketChannel注册到某个EventLoop中。
        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);
    }
}

java复制代码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(); //执行pipeline中的ChannelRegistered()事件。
        // 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);
    }
}

java复制代码@Override
public final ChannelPipeline fireChannelRegistered() {
    AbstractChannelHandlerContext.invokeChannelRegistered(head);
    return this;
}

java复制代码static void invokeChannelRegistered(final AbstractChannelHandlerContext next) {
    EventExecutor executor = next.executor();
    if (executor.inEventLoop()) {
        next.invokeChannelRegistered();
    } else {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                next.invokeChannelRegistered();
            }
        });
    }
}

java复制代码private void invokeChannelRegistered() {
    if (invokeHandler()) {
        try {
            ((ChannelInboundHandler) handler()).channelRegistered(this);
        } catch (Throwable t) {
            invokeExceptionCaught(t);
        }
    } else {
        fireChannelRegistered();
    }
}