public abstract class JavaDynamicScript {

    public abstract Object script(Map<String, Object> context);

}

import com.jinzl.compiler.dto.JavaDynamicScript;
import java.util.Map;
public class HelloWorldScript extends JavaDynamicScript {

    private String content;

    @Override
    public Object script(Map<String, Object> context) {
        System.out.println("脚本开始执行");
        System.out.println("内部变量content: " + content);
        System.out.println("执行上下文context: " + context);
        System.out.println("脚本结束执行");
        return content;
    }
}

public class JavaCodeCompiler {

    public JavaCodeCompiler() throws MalformedURLException {}

    private JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

    private final String libDir = StringUtils.substringBeforeLast(ResourceUtils.extractArchiveURL(JavaDynamicScript.class.getResource("")).getPath(), "/");
    private final String classPath = System.getProperty("java.class.path");
    private static final String JAVA_CODE_FILE_PATH = "string";

    private static final StringJavaFileManager STRING_JAVA_FILE_MANAGER = CompilerConfig.standardFileManager();


    public boolean compiler(String fullClassName, String sourceCode, DiagnosticCollector<JavaFileObject> diagnosticCollector){
        long startTime = System.currentTimeMillis();
        long compilerTakeTime;

        JavaFileObject javaFileObject = new StringJavaFileObject(JAVA_CODE_FILE_PATH, fullClassName, sourceCode);
        Iterable<String> options = Arrays.asList("-classpath", classPath, "-extdirs", libDir);

        JavaCompiler.CompilationTask task = compiler.getTask(null, STRING_JAVA_FILE_MANAGER, diagnosticCollector, options, null, Arrays.asList(javaFileObject));
        compilerTakeTime = System.currentTimeMillis() - startTime;

        System.out.println("script compile success, class=" + fullClassName + ", time=" + compilerTakeTime);
        return task.call();
    }

}

public class StringJavaFileObject extends SimpleJavaFileObject {

    private String contents;

    public StringJavaFileObject(String path, String className, String contents){
        super(URI.create(path + ":///" + className.replaceAll("\\.", "/") + Kind.SOURCE.extension), Kind.SOURCE);
        this.contents = contents;
    }

    @Override
    public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
        return contents;
    }
}

@Test
public void generalMethodTest(){

    System.out.println(AviatorEvaluator.execute("1 + 2 + 3"));

    String name = "jinzl";
    Map<String, Object> params = new HashMap<>();
    params.put("name", name);
    System.out.println(AviatorEvaluator.execute("'Hello, ' + name", params));
    // Aviator 2.2之后新增exec方法，可以方便的传入变量
    System.out.println(AviatorEvaluator.exec("'Hello, ' + name", name));

    params.put("a", 3);
    params.put("b", 4);
    System.out.println(AviatorEvaluator.execute("a + b / 3.0", params));

}

@Test
public void customMethodTest(){
    AviatorEvaluator.addFunction(new AddFunction());
    System.out.println(AviatorEvaluator.execute("add(1, 2)"));
    System.out.println(AviatorEvaluator.execute("add(add(1, 2), 100)"));
}

class AddFunction extends AbstractFunction{

    @Override
    public AviatorObject call(Map<String, Object> env, AviatorObject arg1, AviatorObject arg2) {
        Number left = FunctionUtils.getNumberValue(arg1, env);
        Number right = FunctionUtils.getNumberValue(arg2, env);
        return new AviatorDouble(left.doubleValue() + right.doubleValue());
    }

    @Override
    public String getName() {
        return "add";
    }
}

@Test
public void cacheCompiledTest(){
    String expression = "a - (b - c) > 200";
    // 编译表达式
    // Expression compiledExp = AviatorEvaluator.compile(expression);
    Expression compiledExp = AviatorEvaluator.compile(expression, true);
    Map<String, Object> env = new HashMap<>();
    env.put("a", 200);
    env.put("b", 300);
    env.put("c", 400);
    // 执行表达式
    Boolean result = (Boolean)compiledExp.execute(env);
    System.out.println(result);
}

Expression compiledExp = AviatorEvaluator.compile(expression, true);

// 1. 加上注解标识，表明该 handler 是可以多个 channel 共享的
@ChannelHandler.Sharable
public class LoginRequestHandler extends SimpleChannelInboundHandler<LoginRequestPacket> {

    // 2. 构造单例
    public static final LoginRequestHandler INSTANCE = new LoginRequestHandler();

    protected LoginRequestHandler() {
    }

}
...
serverBootstrap
    .childHandler(new ChannelInitializer<NioSocketChannel>() {
        protected void initChannel(NioSocketChannel ch) {
            // ...单例模式，多个 channel 共享同一个 handler
            ch.pipeline().addLast(LoginRequestHandler.INSTANCE);
            // ...
        }
    });

@ChannelHandler.Sharable
public class PacketCodecHandler extends MessageToMessageCodec<ByteBuf, Packet> {
    public static final PacketCodecHandler INSTANCE = new PacketCodecHandler();

    private PacketCodecHandler() {

    }

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf byteBuf, List<Object> out) {
        out.add(PacketCodec.INSTANCE.decode(byteBuf));
    }

    @Override
    protected void encode(ChannelHandlerContext ctx, Packet packet, List<Object> out) {
        ByteBuf byteBuf = ctx.channel().alloc().ioBuffer();
        PacketCodec.INSTANCE.encode(byteBuf, packet);
        out.add(byteBuf);
    }
}

@ChannelHandler.Sharable
public class IMHandler extends SimpleChannelInboundHandler<Packet> {
    public static final IMHandler INSTANCE = new IMHandler();

    private Map<Byte, SimpleChannelInboundHandler<? extends Packet>> handlerMap;

    private IMHandler() {
        handlerMap = new HashMap<>();

        handlerMap.put(MESSAGE_REQUEST, MessageRequestHandler.INSTANCE);
        handlerMap.put(CREATE_GROUP_REQUEST, CreateGroupRequestHandler.INSTANCE);
        handlerMap.put(JOIN_GROUP_REQUEST, JoinGroupRequestHandler.INSTANCE);
        handlerMap.put(QUIT_GROUP_REQUEST, QuitGroupRequestHandler.INSTANCE);
        handlerMap.put(LIST_GROUP_MEMBERS_REQUEST, ListGroupMembersRequestHandler.INSTANCE);
        handlerMap.put(GROUP_MESSAGE_REQUEST, GroupMessageRequestHandler.INSTANCE);
        handlerMap.put(LOGOUT_REQUEST, LogoutRequestHandler.INSTANCE);
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Packet packet) throws Exception {
        handlerMap.get(packet.getCommand()).channelRead(ctx, packet);
    }
}

List<Channel> channelList = 已有数据可读的 channel
for (Channel channel in channelist) {
   for (ChannelHandler handler in channel.pipeline()) {
       handler.channelRead0();
   } 
}

ThreadPool threadPool = xxx;

protected void channelRead0(ChannelHandlerContext ctx, T packet) {
    threadPool.submit(new Runnable() {
        // 1. balabala 一些逻辑
        // 2. 数据库或者网络等一些耗时的操作
        // 3. writeAndFlush()
        // 4. balabala 其他的逻辑
    })
}

public class IMIdleStateHandler extends IdleStateHandler {

    private static final int READER_IDLE_TIME = 15;

    public IMIdleStateHandler() {
        super(READER_IDLE_TIME, 0, 0, TimeUnit.SECONDS);
    }

    @Override
    protected void channelIdle(ChannelHandlerContext ctx, IdleStateEvent evt) {
        System.out.println(READER_IDLE_TIME + "秒内未读到数据，关闭连接");
        ctx.channel().close();
    }
}

public class HeartBeatTimerHandler extends ChannelInboundHandlerAdapter {

    private static final int HEARTBEAT_INTERVAL = 5;

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ctx.executor().scheduleAtFixedRate(() -> {
            ctx.writeAndFlush(new HeartBeatRequestPacket());
        }, HEARTBEAT_INTERVAL, HEARTBEAT_INTERVAL, TimeUnit.SECONDS);

        super.channelActive(ctx);
    }
}

public class EchoClient {

    private String host;
    private Integer port;
    private NioEventLoopGroup nioEventLoopGroup = null;

    public EchoClient(String host, Integer port){
        this.host = host;
        this.port = port;
    }

    public void start() throws Exception{
        try {
            // 客户端引导类
            Bootstrap bootstrap = new Bootstrap();
            // EventLoopGroup可以理解为是一个线程池, 这个线程池用来处理连接、接收数据
            // 发送数据
            nioEventLoopGroup = new NioEventLoopGroup();
            bootstrap.group(nioEventLoopGroup) // 多线程处理
                    .channel(NioSocketChannel.class) // 制定通道类型为NioServerSocketChannel
                    .remoteAddress(new InetSocketAddress(host, port))
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new EchoClientHandler()); // 注册handler
                        }
                    });
            // 连接服务器
            ChannelFuture channelFuture = bootstrap.connect().sync();
            channelFuture.channel().closeFuture().sync();
        }finally {
            nioEventLoopGroup.shutdownGracefully().sync();
        }

    }

    public static void main(String[] args) throws Exception {
        EchoClient echoClient = new EchoClient("localhost", 20000);
        echoClient.start();
    }

}

public class EchoClientHandler extends SimpleChannelInboundHandler<ByteBuf> {

    // 客户端连接服务器后被调用
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("客户端连接服务器, 开始发送数据......");
        byte[] req = "QUERY TIME ORDER".getBytes();
        ByteBuf firstMessage = Unpooled.buffer(req.length);
        firstMessage.writeBytes(req);
        ctx.writeAndFlush(firstMessage);
    }

    // 从服务器接收到数据后调用
    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, ByteBuf msg) throws Exception {
        System.out.println("client 读取server数据......");
        // 服务器返回消息后
        byte[] resp = new byte[msg.readableBytes()];
        msg.readBytes(resp);
        String body = new String(resp, "UTF-8");
        System.out.println("服务端数据为: " + body);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println("client exceptioncaught");
        ctx.close();
    }
}

public class EchoServer {

    private final Integer port;

    public EchoServer(Integer port){
        this.port = port;
    }

    public void start() throws Exception{
        EventLoopGroup eventExecutors = null;
        try {
            // server端引导类
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            // 连接池处理数据
            eventExecutors = new NioEventLoopGroup();
            // 装配serverBootstrap
            serverBootstrap.group(eventExecutors)
                    .channel(NioServerSocketChannel.class)
                    .localAddress("localhost", port)
                    .childHandler(new ChannelInitializer<Channel>() {
                        @Override
                        protected void initChannel(Channel channel) throws Exception {
                            // 可添加多个InHandler OutHandler
                            // 添加顺序为: IN-1 OUT-1 OUT-2 IN-2
                            // 执行顺序为: IN-1 IN-2 OUT-2 OUT-1
                            // WARNING: OutHandler不能放在最后, 最后只能是InHandler
                            channel.pipeline().addLast(new EchoServerHandler());
                        }
                    });
            // 最后绑定服务器等待直到绑定完成, 调用sync方法会阻塞直到服务器完成绑定
            ChannelFuture channelFuture = serverBootstrap.bind().sync();
            System.out.println("开始监听, 端口: " + channelFuture.channel());
            channelFuture.channel().closeFuture().sync();
        }finally {
            if(eventExecutors != null){
                eventExecutors.shutdownGracefully().sync();
            }
        }
    }

    public static void main(String[] args) throws Exception {
        EchoServer echoServer = new EchoServer(20000);
        echoServer.start();
    }

}

public class EchoServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("server 读取数据");
        // 读取数据
        ByteBuf buf = (ByteBuf)msg;
        byte[] req = new byte[buf.readableBytes()];
        buf.readBytes(req);
        String body = new String(req, "UTF-8");
        System.out.println("接收client数据: " + body);
        // 向客户端写数据
        System.out.println("server向client发送数据");
        String currentTime = new Date(System.currentTimeMillis()).toString();
        ByteBuf resp = Unpooled.copiedBuffer(currentTime.getBytes());
        ctx.write(resp);
        // 执行下一个handler
//        ctx.fireChannelRead(msg);
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        System.out.println("server 读取数据完毕");
        ctx.flush(); // 刷新后才将数据发出到SocketChannel
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println("server exceptionCaught");
        ctx.close();
    }
}