【无标题】

基于IO、NIO、Netty的TCP聊天程序

一、IO与NIO
1.面向流与面向缓冲区
在Java IO中读取数据和写入数据是**面向流（Stream）**的,这表示当我们从流中读取数据，写入数据时也将其写入流，流的含义在于没有缓存 ，就好像我们站在流水线前，所有的数据沿着流水线依次到达我们的面前，我们只能读取当前的数据。如果需要获取某个数据的前一项或后一项数据那就必须自己缓存数据，而不能直接从流中获取。

而在Java NIO中数据的读写是面向**缓冲区（Buffer）**的，读取时可以将整块的数据读取到缓冲区中，在写入时则可以将整个缓冲区中的数据一起写入。这就好像是将流水线传输变成了卡车运送，面向流的数据读写只提供了一个数据流切面，而面向缓冲区的IO则使我们能够看到数据的上下文，也就是说在缓冲区中获取某项数据的前一项数据或者是后一项数据十分方便。这种便利是有代价的，因为我们必须管理好缓冲区，这包括不能让新的数据覆盖了缓冲区中还没有被处理的有用数据；将缓冲区中的数据正确的分块,分清哪些被处理过哪些还没有等等。

2.阻塞与非阻塞
传统的 IO 流都是阻塞式的。也就是说，当一个线程调用 read() 或 write()时，该线程被阻塞，直到有一些数据被读取或写入，该线程在此期间不能执行其他任务。因此，在完成网络通信进行 IO 操作时，由于线程会阻塞，所以服务器端必须为每个客户端都提供一个独立的线程进行处理，当服务器端需要处理大量客户端时，性能急剧下降。

Java NIO 是非阻塞模式的。当线程从某通道进行读写数据时，若没有数据可用时，该线程可以进行其他任务。线程通常将非阻塞 IO 的空闲时间用于在其他通道上执行 IO 操作，所以单独的线程可以管理多个输入和输出通道。因此，NIO 可以让服务器端使用一个或有限几个线程来同时处理连接到服务器端的所有客户端。
服务器：

把发送过来的套接字输出

客户端：

最后效果

Web聊天室

1.Demo类：
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.env.Environment;

import java.net.InetAddress;
import java.net.UnknownHostException;

@SpringBootApplication
public class Demo {
public static void main(String[] args) throws UnknownHostException {
ConfigurableApplicationContext application = SpringApplication.run(Demo.class, args);
Environment env = application.getEnvironment();
String host = InetAddress.getLocalHost().getHostAddress();
String port = env.getProperty(“server.port”);
System.out.println("[----------------------------------------------------------]");
System.out.println(“聊天室启动成功！点击进入:\t http://” + host + “:” + port);
System.out.println("[----------------------------------------------------------");
WebSocketServer.inst().run(53134);
}

}
2.SessionGroup类

import com.google.gson.Gson;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.ChannelGroupFuture;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import io.netty.util.concurrent.ImmediateEventExecutor;
import org.springframework.util.StringUtils;

import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;


public class SessionGroup {
   
    private static SessionGroup singleInstance = new SessionGroup();

    // 组的映射
    private ConcurrentHashMap<String, ChannelGroup> groupMap = new ConcurrentHashMap<>();

    public static SessionGroup inst() {
   
        return singleInstance;
    }

    public void shutdownGracefully() {
   

        Iterator<ChannelGroup> groupIterator = groupMap.values().iterator();
        while (groupIterator.hasNext()) {
   
            ChannelGroup group = groupIterator.next();
            group.close();
        }
    }

    public void sendToOthers(Map<String, String> result, SocketSession s) {
   
        // 获取组
        ChannelGroup group = groupMap.get(s.getGroup());
        if (null == group) {
   
            return;
        }
        Gson gson=new Gson();
        String json = gson.toJson(result);
        // 自己发送的消息不返回给自己
//      Channel channel = s.getChannel();
        // 从组中移除通道
//      group.remove(channel);
        ChannelGroupFuture future = group.writeAndFlush(new TextWebSocketFrame(json));
        future.addListener(f -> {
   
            System.out.println("完成发送："+json);
//          group.add(channel);//发送消息完毕重新添加。

        });
    }

    public void addSession(SocketSession session) {
   

        String groupName = session.getGroup();
        if (StringUtils.isEmpty(groupName)) {
   
            // 组为空，直接返回
            return;
        }
        ChannelGroup group = groupMap.get(groupName);
        if (null == group) {
   
            group = new DefaultChannelGroup(ImmediateEventExecutor.INSTANCE);
            groupMap.put(groupName, group);
        }
        group.add(session.getChannel());
    }

    /**
     * 关闭连接， 关闭前发送一条通知消息
     */
    public void closeSession(SocketSession session, String echo) {
   
        ChannelFuture sendFuture = session.getChannel().writeAndFlush(new TextWebSocketFrame(echo));
        sendFuture.addListener(new ChannelFutureListener() {
   
            public void operationComplete(ChannelFuture future) {
   
                System.out.println("关闭连接："+echo);
                future.channel().close();
            }
        });
    }

    /**
     * 关闭连接
     */
    public void closeSession(SocketSession session) {
   

        ChannelFuture sendFuture = session.getChannel().close();
        sendFuture.addListener(new ChannelFutureListener() {
   
            public void operationComplete(ChannelFuture future) {
   
                System.out.println("发送所有完成："+session.getUser().getNickname());
            }
        });

    }

    /**
     * 发送消息
     * @param ctx 上下文
     * @param msg 待发送的消息
     */
    public void sendMsg(ChannelHandlerContext ctx, String msg) {
   
        ChannelFuture sendFuture = ctx.writeAndFlush(new TextWebSocketFrame(msg));
        sendFuture.addListener(f -> {
   //发送监听
            System.out.println("对所有发送完成："+msg);
        });
    }

}

SocketSession：

import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.