public final Buffer flip(){
  limit = position;
  position = 0;
  mark = -1;
  return this;
}

String str = "test";
FileOutputStream fis = new FileOutputStream("./test.txt");
FileChannel fc = fis.getChannel();
ByteBuffer buf = ByteBuffer.allocate(1024);
buf.put(str.getBytes());
buf.flip();
fc.write(buf);
fis.close;

File file = new File("./test.txt")
FileInputStream fis = new FileInputStream(file);
FileChannel fc = fis.getChannel();
ByteBuffer buf = ByteBuffer.allocate((int)file.lenght);
fc.read(buf);
System.out.println(new String(buf.array()))
fis.close;

FileInputStream fis1 = new FileInputStream("./test.txt");
FileChannel fc1 = fis1.getChannel();
FileOutputStream fis2 = new FileOutputStream("./test.txt");
FileChannel fc2 = fis2.getChannel();
ByteBuffer buf = ByteBuffer.allocate(512);
while(true){
  buf.clear(); // 复位很重要 会导致limt和position相同导致死循环
  int read = fc2.read(buf);
  if(read == -1){
    break;
  }
  buf.flip();
  fc2.write(buf);
}
fis1.close;
fis2.close;

FileInputStream fis1 = new FileInputStream("./test.txt");
FileChannel fc1 = fis1.getChannel();
FileOutputStream fis2 = new FileOutputStream("./test.txt");
FileChannel fc2 = fis2.getChannel();
fc2.transferFrom(fc1,0,fc1.size());
fis1.close;
fis2.close;

package com.lwl.NIO;

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;

public class NIOServer {
    public static void main(String[] args) throws Exception{
        //创建一个服务端channel
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        //创建一个selector
        Selector selector = Selector.open();
        //绑定一个端口，在服务端监听
        serverSocketChannel.socket().bind(new InetSocketAddress(6666));
        //设置为非阻塞
        serverSocketChannel.configureBlocking(false);
        //serverSocketChannel注册到selector,并设置关心事件
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

//        System.out.println("注册SelectionKey的数量" + selector.keys().size());

        //循环等待客户链接
        while (true){//一次循环解决一个事件集合里的全部事件，下次循环会再继续监听
            if (selector.select(1000) == 0){//无事发生,继续循环等待
//                selector.selectedKeys().size() // 有事件发生的事件的数量
                System.out.println("服务器等待了一秒，无事发生，当前以注册的selectionKey数量为：" + selector.keys().size());
                continue;
            }
            //返回》0，有事发生,获取客户端发生关注事件的集合
            //通过selectionKeys可以反向获取Channel
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            //遍历selectionKeys，获取当前事件集
            Iterator<SelectionKey> Keyiterator = selectionKeys.iterator();
            while (Keyiterator.hasNext()){
                //获取当前事件
                SelectionKey selectionKey = Keyiterator.next();
                //查看key发生的事件并作相应的处理
                if(selectionKey.isAcceptable()) {//有新客户端链接
                    //为这个客户端生成一个channel
                    SocketChannel socketchannel = serverSocketChannel.accept();
                    socketchannel.configureBlocking(false);
                    System.out.println("客户端连接成功，" + socketchannel.hashCode());
                    //将当前channel注册到selector,并关心这个事件有没有发生读事件OP_READ，同时给channel关联一个buffer
                    socketchannel.register(selector, SelectionKey.OP_READ,ByteBuffer.allocate(1024));
                }
                if(selectionKey.isReadable()){
                    //发生了读事件,通过key反向得到channel和绑定的buffer
                    SocketChannel socketchannel = (SocketChannel)selectionKey.channel();
                    //获取与该channel关联的buffer，在和连接时就已经绑定了，40行处
                    ByteBuffer buffer = (ByteBuffer) selectionKey.attachment();
                    socketchannel.read(buffer);//从客户端读到的数据
                    System.out.println("from 客户端 : " + new String(buffer.array()));
                    buffer.clear();
                }
            }
            //及时将当前的SelectionKey,防止操作
            Keyiterator.remove();
        }
    }
}

package com.lwl.NIO;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.Channel;
import java.nio.channels.SocketChannel;
import java.util.Scanner;

public class NIOClient {
    public static void main(String[] args) throws IOException {
        //得到一个网络通道
        SocketChannel socketChannel = SocketChannel.open();
        //非阻塞
        socketChannel.configureBlocking(false);
        //提供服务器的ip和端口
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 6666);
        //链接服务器
        if(!socketChannel.connect(inetSocketAddress)){
            while (!socketChannel.finishConnect()){
                System.out.println("链接需要时间，客户端不会阻塞");
            }
        }
//        String str = "hello world!";
        Scanner scanner = new Scanner(System.in);
        String str;
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        while (scanner.hasNext()){
            str = scanner.next();
            System.out.println(str);
            buffer.put(str.getBytes());
            buffer.flip();
            socketChannel.write(buffer);
            buffer.clear();
        }
        //生成一个和数组一样大的buffer
//        ByteBuffer byteBuffer = ByteBuffer.wrap(str.getBytes());
//        //发送数据，将buffer写入channel
//        socketChannel.write(byteBuffer);

        //代码会停在这
        System.in.read();
    }
}

package cn.org.alan.netty.simple;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

/**
 * 说明：
 *
 * @Author Alan
 * @Version 1.0
 * @Date 2026/1/16 下午11:50
 */
public class NettyServer {
    public static void main(String[] args) throws InterruptedException {
        // 创建BossGroup 和 workerGroup
        // 说明
        // 1. 创建两个线程组BossGroup 和 workerGroup
        // 2. bossGroup只是处理连接请求，真正的客户端业务处理会交给workerGroup完成
        // 3. 两个都是无限循环
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            // 创建服务器端的启动对象，配置参数
            ServerBootstrap bootstrap = new ServerBootstrap();

            // 使用链式编程来进行设置
            bootstrap.group(bossGroup,workerGroup) // 设置两个线程组
                    .channel(NioServerSocketChannel.class) // 使用NioSocketChannel作为服务器通道的实现
                    .option(ChannelOption.SO_BACKLOG,128) // 设置线程队列得到连接的个数
                    .childOption(ChannelOption.SO_KEEPALIVE,true) // 设置保持连接活动连接状态
                    .childHandler(new ChannelInitializer<SocketChannel>() {// 创建一个通道初始化对象（匿名对象）
                        // 给pipline设置处理器
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new NettyServerHandler()); // 向管道的最后追加一个处理器
                        }
                    }); // 给我们的workerGroup的EventLoop对应的管道设置处理器
            // 指定相关端口,并且同步处理 生成了一个ChannelFuture对象
            ChannelFuture sync = bootstrap.bind(6668).sync();

            // 对关闭通道进行[监听]
            sync.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

package cn.org.alan.netty.simple;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

/**
 * 说明：
 *  我们自定义一个Handler需要继续netty规定好的某个HandlerAdapter(规范)
 *  这时我们定自定义一个Handler,才能成为一个handler
 * @Author Alan
 * @Version 1.0
 * @Date 2026/1/17 上午12:04
 */
public class NettyServerHandler extends ChannelInboundHandlerAdapter {
    // 读取实际数据（这里可以读取客户端发送的消息）

    /**
     * ChannelHandlerContext ctx：上下文对象，含有，管道pipline,通道channel,地址
     * Object msg：是客户端发送的数据 默认Object
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("server ctx = "+ ctx);
        // 将msg转成一个ByteBuf
        // ByteBuf是netty提供的，不是NIO的ByteBuffer
        ByteBuf buf = (ByteBuf) msg;
        System.out.println("客户端发送的消息是："+ buf.toString(CharsetUtil.UTF_8));
        System.out.println("客户端地址："+ ctx.channel().remoteAddress());
        // super.channelRead(ctx, msg);
    }
    // 数据读取完毕
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        // writeAndFlush是write+flush
        // 将数据写入到缓存，并刷新
        // 一般将，我们对发送到数据进行编码
        ctx.writeAndFlush(Unpooled.copiedBuffer("hello",CharsetUtil.UTF_8));
        // super.channelReadComplete(ctx);
    }
    // 处理异常，一般需要关闭通道
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
        // super.exceptionCaught(ctx, cause);
    }
}

package cn.org.alan.netty.simple;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

/**
 * 说明：
 *
 * @Author Alan
 * @Version 1.0
 * @Date 2026/1/17 上午12:16
 */
public class NettyClient {
    public static void main(String[] args) throws InterruptedException {
        // 客户端需要一个事件循环组
        NioEventLoopGroup eventExecutors = new NioEventLoopGroup();
        // 创建客户端启动对象
        // 客户端使用的不是serverBootstrap而是Bootstrap
        try {
            Bootstrap bootstrap = new Bootstrap();
            // 设置相关参数
            bootstrap.group(eventExecutors) // 设置线程组
                    .channel(NioSocketChannel.class)// 设置客户端通道实现类
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new NettyClientHandler()); // 加入自己的处理器
                        }
                    });
            System.out.println("客户端启动成功");
            // 启动客户端去连接服务端
            // 关于ChannelFuture要分析，涉及netty端异步模型
            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 6668).sync();
            // 给关闭通道进行监听
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            eventExecutors.shutdownGracefully();
        }
    }
}

package cn.org.alan.netty.simple;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

/**
 * 说明：
 *
 * @Author Alan
 * @Version 1.0
 * @Date 2026/1/17 上午12:22
 */
public class NettyClientHandler extends ChannelInboundHandlerAdapter {
    // 当通道就绪就会触发方法
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("client "+ ctx);
        ctx.writeAndFlush(Unpooled.copiedBuffer("hello,server", CharsetUtil.UTF_8));
        // super.channelActive(ctx);
    }
    /**
     * 当通道有读取时间时，会触发
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 将msg转成一个ByteBuf
        // ByteBuf是netty提供的，不是NIO的ByteBuffer
        ByteBuf buf = (ByteBuf) msg;
        System.out.println("服务器回复的消息："+ buf.toString(CharsetUtil.UTF_8));
        System.out.println("服务器地址："+ ctx.channel().remoteAddress());
        // super.channelRead(ctx, msg);
    }
    // 处理异常，一般需要关闭通道
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
        // super.exceptionCaught(ctx, cause);
    }
}

package cn.org.alan.netty.heartbeat;

import cn.org.alan.netty.simple.NettyServerHandler;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import io.netty.handler.timeout.IdleStateHandler;

import java.util.concurrent.TimeUnit;

/**
 * 说明：
 *
 * @Author Alan
 * @Version 1.0
 * @Date 2026/1/17 下午4:10
 */
public class MyServer {
    public static void main(String[] args) {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup,workerGroup)
                    .channel(NioServerSocketChannel.class) 
                    .handler(new LoggingHandler(LogLevel.INFO))
                    .option(ChannelOption.SO_BACKLOG,128) 
                    .childOption(ChannelOption.SO_KEEPALIVE,true)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {

                            ChannelPipeline pipeline = ch.pipeline();
                            // IdleStateHandler 时Netty提供的处理空闲状态的处理器
                            // long readerIdleTime 表示多长时间没有读，就会发送一个心跳检测是否连接
                            // long writerIdleTime 表示多长时间没有写，就会发送一个心跳检测是否连接
                            // long allIdleTime 表示多长时间即没有读页没有写，就会发送一个心跳检测是否连接
                            // TimeUnit unit 时间单位
                            // 当IdleStateHandler触发后，就会传递给管道下一个handler去处理，通过调用触发下一个handler的userEventTiggered
                            // 在该方法中去处理IdleStateHandler(读空闲，写空闲，读写空闲)
                            pipeline.addLast(new IdleStateHandler(3,5,7, TimeUnit.SECONDS));
                            // 加入一个对空闲检测进一步处理的handler（自定义)
                            pipeline.addLast(new MyserverHandler());
                        }
                    }); 

            ChannelFuture sync = bootstrap.bind(7000).sync();
            sync.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

package cn.org.alan.netty.heartbeat;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.timeout.IdleStateEvent;
import io.netty.handler.timeout.IdleStateHandler;

/**
 * 说明：
 *
 * @Author Alan
 * @Version 1.0
 * @Date 2026/1/17 下午4:21
 */
public class MyserverHandler extends ChannelInboundHandlerAdapter {
    /**
     *
     * @param ctx 上下文
     * @param evt 事件
     * @throws Exception
     */
    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if(evt instanceof IdleStateEvent){
            // 将evt向下转型 IdleStateHandler
            IdleStateEvent event = (IdleStateEvent) evt;
            String  eventType = null;
            switch (event.state()){
                case READER_IDLE :
                    eventType = "读空闲";
                    break;
                case WRITER_IDLE:
                    eventType = "写空闲";
                    break;
                case ALL_IDLE:
                    eventType = "读写空闲";
                    break;
            }
            System.out.println(ctx.channel().remoteAddress() + "--超时事件发生--"+eventType);
        }
        super.userEventTriggered(ctx, evt);
    }
}

package cn.org.alan.netty.websocket;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import io.netty.handler.stream.ChunkedWriteHandler;
import io.netty.handler.timeout.IdleStateHandler;

import java.util.concurrent.TimeUnit;

/**
 * 说明：
 *
 * @Author Alan
 * @Version 1.0
 * @Date 2026/1/17 下午4:10
 */
public class MyServer {
    public static void main(String[] args) {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .handler(new LoggingHandler(LogLevel.INFO))
                    .option(ChannelOption.SO_BACKLOG, 128)
                    .childOption(ChannelOption.SO_KEEPALIVE, true)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {

                            ChannelPipeline pipeline = ch.pipeline();
                            // 因为基于http协议，使用http的编码和解码器
                            pipeline.addLast(new HttpServerCodec());
                            // 是以块方式写，添加CHunkedWriteHandler处理器
                            pipeline.addLast(new ChunkedWriteHandler());
                            // 因为http数据在传输过程中时分段的，HttpObjectAggregator 就是可以将多个段聚合
                            // 这就是为什么，当浏览器发送大量数据时，就会发出多长http请求
                            pipeline.addLast(new HttpObjectAggregator(8192));
                            // 对应websocket它的数据时以帧(frame)形式传递
                            // 可以看到WebSocketFrame下面有6个子类
                            // 浏览器请求时，ws://localhost:7000/xxx 表示请求到url
                            pipeline.addLast(new WebSocketServerProtocolHandler("/hello"));
                            pipeline.addLast(new MyserverHandler());
                        }
                    });

            ChannelFuture sync = bootstrap.bind(7000).sync();
            sync.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

package cn.org.alan.netty.websocket;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketFrame;
import io.netty.handler.timeout.IdleStateEvent;

import java.time.LocalDate;

/**
 * 说明：
 *
 * @Author Alan
 * @Version 1.0
 * @Date 2026/1/17 下午4:21
 */
public class MyserverHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) throws Exception {
        System.out.println("服务端收到消息:"+msg.text() );
        // 回复浏览器
        ctx.channel().writeAndFlush(new TextWebSocketFrame("服务器事件+"+ LocalDate.now()));
    }
    // 当web客户端连接后，触发方法
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        System.out.println("handlerAdded被调用"+ctx.channel().id().asLongText());
        System.out.println("handlerAdded被调用"+ctx.channel().id().asShortText());
    }

    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        System.out.println("handlerRemoved被调用"+ctx.channel().id().asShortText());
    }

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