Java SocketChannel 与 SocketChannel通信模板

最新推荐文章于 2024-05-14 23:27:32 发布
原创 最新推荐文章于 2024-05-14 23:27:32 发布 · 1.5k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#非阻塞通信源码 #java #channel #selector

本文介绍了如何使用Java中的Selector类实现并发服务器，通过非阻塞模式处理多个客户端连接，提高服务器性能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

[TOC]
抢先体验运行效果

Server

public class SelectorServer {
    private static Selector selector ;
    public static void main(String[] args) {
        ServerSocketChannel serverChannel = null;
        try {
            serverChannel = ServerSocketChannel.open();
            serverChannel.socket().setReuseAddress(true);
            serverChannel.socket().bind(new InetSocketAddress(3467));
            serverChannel.configureBlocking(false); // none blocking mode
            selector = SelectorProvider.provider()
                    .openSelector();
            Iterator<SelectionKey> selectorKeys = null;
            serverChannel.register(selector, SelectionKey.OP_ACCEPT);
            while (true) {
                // selector mode
                // 阻塞选择操作， n 已经准备好的通道的个数。
                int n = selector.select();
                if (n == 0) {
                    continue;
                }
                selectorKeys = selector.selectedKeys().iterator();
                SelectionKey oneKey = null; 
                while (selectorKeys.hasNext()) {
                    try{
                        oneKey = selectorKeys.next();
                        selectorKeys.remove();
                        handleSelectorKey(oneKey);
                    }finally{
                        try{
                            if(oneKey != null && oneKey.isWritable()){
                                oneKey.cancel();
                                oneKey.channel().close();
                            }
                        }catch(IOException e){
                            e.printStackTrace();
                        }

                    }
                }
            }

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClosedSelectorException e) {
            e.printStackTrace();
        }
        finally {

        }

    }
    static ByteBuffer readerBuffer ;
    private synchronized static void handleSelectorKey(SelectionKey key) {
        if(key == null){
            return;
        }

        if (key.isAcceptable()) {
            System.out.println("selection acceptable --> " + key.isValid());
            handleSelectionAcceptable(key);
        }

        if (key.isConnectable()) {
            System.out.println("selection connectable --> " + key.isValid());
            handleSelectionAcceptable(key);
        }

        if (key.isReadable()) {
            System.out.println("selection readable --> " + key.isValid());
            synchronized (SelectorServer.class) {
                readerBuffer = handleSelectionReadable(key);
            }

        }

        if (key.isWritable()) {
            System.out.println("selection writeable --> " + key.isValid());
            synchronized (SelectorServer.class) {
            handleSelectionWriteable(key,readerBuffer);
            }
        }
    }

    public static void handleSelectionAcceptable(SelectionKey key) {
        if(key == null) return;
        try{
            ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
            SocketChannel sc = (SocketChannel) ssc.accept();

            System.out.println("receive connection request " +
                    sc.socket().getInetAddress()+":"+sc.socket().getPort());

            sc.configureBlocking(false);
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            buffer.put("attachment added by myself .".getBytes());
            buffer.flip();
            sc.register(selector, SelectionKey.OP_READ,buffer);
        }catch(IOException e){

        }
    }

    public static void handleSelectionCollectable(SelectionKey key) {

    }

    public  static ByteBuffer handleSelectionReadable(SelectionKey key) {
        ByteBuffer buffer = (ByteBuffer) key.attachment();
        if(buffer != null){
            System.out.println("attachment data===== : " + getString(buffer));
            buffer.rewind();
        }
        SocketChannel sc = (SocketChannel) key.channel();
        ByteBuffer readBuffer = ByteBuffer.allocate(1024);
        try {
            sc.read(readBuffer);
            sc.register(selector, SelectionKey.OP_WRITE,buffer);
        } catch (IOException e) {
            e.printStackTrace();
        }
        readBuffer.flip();
        String data = getString(readBuffer);
        System.out.println("receive data from client --->: "
                + data+"  == "+ sc.socket().getInetAddress()
                +"  :"+sc.socket().getPort());
        readBuffer.rewind();
        return readBuffer;
    }

    public static String getString(ByteBuffer buffer)
    {
        if(buffer ==null){
            return "";
        }
        Charset charset = null;
        CharsetDecoder decoder = null;
        CharBuffer charBuffer = null;
        try
        {
            charset = Charset.forName("UTF-8");
            decoder = charset.newDecoder();
             charBuffer = decoder.decode(buffer);//用这个的话，只能输出来一次结果，第二次显示为空
            String s = charBuffer.toString();
            System.out.println("buffer to string : len : " + s.length() +"  ;data: " + s);
            return charBuffer.toString().trim();
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
            return "";
        }
    }


    public  static void handleSelectionWriteable(SelectionKey key,ByteBuffer readBuffer) {
        String toClientData = "echo server : "+getString(readBuffer);
        byte serverEcho[] = toClientData.getBytes(Charset.forName("utf-8"));

        ByteBuffer writeBuffer = ByteBuffer.wrap(serverEcho);
        SocketChannel sc = (SocketChannel) key.channel();

        try {
            sc.write(writeBuffer);
            System.out.println("to client data--->: " + toClientData
                    +"  == "+ sc.socket().getInetAddress()
                    +"  :"+sc.socket().getPort());
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println(e);
        }finally {

        }
    }

}

client

public class SocketChannelClient extends Thread{
    public static final String SERVER_ADDRESS = "localhost";
    public static final int SERVER_PORT = 3467;
    private final String address;
    private final int port ;
    SocketChannel socketChannel;
    Selector selector;
    public SocketChannelClient(String remoteAdress , int remotePort){
        address = remoteAdress;
        port = remotePort;
    }


    public static void main(String[] args) {

        SocketChannelClient client = new SocketChannelClient(SocketChannelClient.SERVER_ADDRESS,
                 SocketChannelClient.SERVER_PORT);
         client.start();
    }
    @Override
    public void run() {
        try{
            socketChannel = SocketChannel.open(new InetSocketAddress(address,port));
            socketChannel.configureBlocking(false);
            selector = SelectorProvider.provider().openSelector();
            socketChannel.register(selector, SelectionKey.OP_READ|SelectionKey.OP_WRITE);
            Iterator<SelectionKey> keyIterator;
            SelectionKey oneKey = null;
            while(true){
                int n = selector.select();
                if(n == 0){
                    continue;
                }
                keyIterator = selector.selectedKeys().iterator();
                while(keyIterator.hasNext()){
                    try{
                        oneKey = keyIterator.next();
                        keyIterator.remove();
                        handleSelectorKey(oneKey);
                    }finally{
                        try{
                            if(oneKey != null && oneKey.isReadable()){
                                oneKey.channel().close();
                                oneKey = null;
                            }
                        }catch(IOException e){
                            e.printStackTrace();
                        }

                    }
                }
            }

        }catch(IOException e){
            e.printStackTrace();
        }

    }
    private synchronized void handleSelectorKey(SelectionKey key) {
        if(key == null){
            return;
        }
        if (key.isAcceptable()) {
            System.out.println("selection acceptable --> " + key);
            handleSelectionAcceptable(key);
        }

        if (key.isConnectable()) {
            System.out.println("selection connectable --> " + key);
            handleSelectionAcceptable(key);
        }

        if (key.isReadable()) {
            System.out.println("selection readable --> " + key);
            handleSelectionReadable(key);
        }

        if (key.isWritable()) {
            System.out.println("selection writeable --> " + key);
            handleSelectionWriteable(key);
        }
    }

    public  void handleSelectionAcceptable(SelectionKey key) {
        if(key == null) return;
        try{
            ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
            SocketChannel sc = (SocketChannel) ssc.accept();

            System.out.println("receive connection request " +
                    sc.socket().getInetAddress()+":"+sc.socket().getPort());

            sc.configureBlocking(false);
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            sc.register(selector, SelectionKey.OP_READ,buffer);
        }catch(IOException e){

        }
    }

    public  void handleSelectionCollectable(SelectionKey key) {

    }

    public  void handleSelectionReadable(SelectionKey key) {
        SocketChannel sc = (SocketChannel) key.channel();
        ByteBuffer readBuffer = ByteBuffer.allocate(1024);
        try {
            sc.read(readBuffer);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {

        }
        readBuffer.flip();
        System.out.println("receive data from server --->: "
                + getString(readBuffer));
    }
    public static String getString(ByteBuffer buffer)
    {
        Charset charset = null;
        CharsetDecoder decoder = null;
        CharBuffer charBuffer = null;
        try
        {
            charset = Charset.forName("UTF-8");
            decoder = charset.newDecoder();
            charBuffer = decoder.decode(buffer.asReadOnlyBuffer());
            return charBuffer.toString();
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
            return "";
        }
    }
    static int talkValue = 0;
    ByteBuffer sendBuffer;
    public  void handleSelectionWriteable(SelectionKey key) {
         sendBuffer = ByteBuffer.wrap(("talk to server "+(++talkValue)).getBytes(Charset.forName("utf-8")));
        key.attach(sendBuffer);
        SocketChannel sc = (SocketChannel) key.channel();
        try {
            sc.write(sendBuffer);
            key.interestOps(SelectionKey.OP_READ);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
        }
    }

}
Java——SocketChannel
赫家旺的博客
04-14 1079
       SocketChannel是NIO形式的客户端服务器通信的形式，支持异步非阻塞连接，通过管道与缓存的形式进行通信，与Java的Socket是有区别的，socket是通过请求——连接的形式进行通信，而SocketChannel是通过建立管道的形式进行通信，原则上，SocketChannel要比Socket快，这只是自己的理解，不知道正确与否了。。。下面总结下SocketChannel...
JAVA NIO 异步通信模板服务端
10-20
总之，JAVA NIO异步通信模板服务端是利用Java NIO库实现的高效并发服务，通过非阻塞I/O和选择器机制，可以轻松处理大量并发连接，同时保持较低的资源消耗。在实际开发中，这样的模板可以作为基础，根据具体需求进行...
java的ServerSocketChannel与SocketChannel的使用
09-16
java的ServerSocketChannel与SocketChannel的使用
Java NIO SocketChannel
太阳火神的美丽人生
11-20 1578
Java NIO SocketChannel
【Java】【NIO】【04】通过SocketChannel读写Socket
天天向上 Up Up Up (*^▽^*)
03-25 411
【代码】【Java】【NIO】【04】通过SocketChannel读写Socket。
JavaNIO(4)、SocketChannel
wu1308156206的博客
07-15 454
SocketChannel
JAVA NIO异步通信模板实现高效服务端开发
### JAVA NIO 异步通信模板服务端知识点详解 #### 标题解读 标题“JAVA NIO 异步通信模板服务端”所涉及的技术点主要围绕着Java非阻塞I/O（NIO）以及异步通信在服务端实现的应用。它指出这一服务端模板是基于CMD...
Java NIO实现的Socket通信示例教程
在Java NIO中，可以利用SocketChannel实现基于NIO的Socket通信。SocketChannel是一种连接到TCP网络套接字的通道。NIO的Socket通信利用了Selector机制，可以实现单线程管理多个网络连接的功能，这样就可以在多用户...
JAVA NIO 异步通信客户端
10-20
JAVA NIO（非阻塞I/O）是一种在Java平台中用于高效处理I/O...在压缩包中的`JavaNioTamplateClient`可能是实现以上概念的一个示例代码，通过阅读和理解这个模板，你可以更好地学习和实践JAVA NIO异步通信客户端的开发。
Java NIO系列教程(8)-SocketChannel的最佳实践
最新发布
2401_84831793的博客
05-14 975
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
java中ServerSocketChannel原理 清晰明了
liaomin416100569的专栏
03-25 4800
1 NIO介绍NIO非堵塞应用通常适用用在I/O读写等方面，我们知道，系统运行的性能瓶颈通常在I/O读写，包括对端口和文件的操作上，过去，在打开一个I/O通道后，read()将一直等待在端口一边读取字节内容，假如没有内容进来，read()也是傻傻的等，这会影响我们程序继续做其他事情，那么改进做法就是开设线程，让线程去等待，但是这样做也是相当耗费资源的。 Java NIO非堵塞技术实际是
java socketchannel_Java NIO SocketChannel
weixin_39895096的博客
02-21 220
Java NIO SocketChannel用于将通道与TCP(传输控制协议)网络套接字连接。它相当于网络编程中使用的Java网络套接字(Socket)。Java NIO中有两种可用于创建SocketChannel的方法：当传入连接到达ServerSocketChannel时，可以创建它。打开一个SocketChannel，并在网络上与服务器连接。我们来看看使用选择器的SocketChannel客...
Accept建立连接
04stone37
04-25 665
三次握手过程 服务端绑定和监听某个端口，创建SYN队列和ACCEPT队列； 客户端调用connect()发起连接，发送SYN包到服务端，状态变为SYN_SEND； 服务端监听到连接请求后，连接先被放入SYN队列（即未完成握手队列）中，同时返回SYN+ACK包给客户端，状态变为SYN_RCVD； 客户端收到SYN+ACK包之后，状态变为ESTABLISHED，并发送ACK包到服务端； 当服务端收到AC
Java中socket的代码模板
hubbybob1专栏
07-10 1688
java的的socket的代码编写与C 语言的不太一样，C 语言的代码简练有深度，java的写起来复杂，但是不是那么难懂，因此在这里记录一下模板，防止以后忘记，总共四个文件，分别是ServiceServer.java（用于创建socket服务器），ServiceTask.java（服务器所提供的业务），DataProcess.java（服务器业务数据处理），ServiceCliect.java（s...
java NIO 之 ServerSocketChannel
yjc0403的博客
03-02 187
java NIO 之 ServerSocketChannel     Java NIO中的 ServerSocketChannel 是一个可以监听新进来的TCP连接的通道, 就像标准IO中的ServerSocket一样。ServerSocketChannel类在 java.nio.channels包中。   代码例子： ServerSocketChannel serverSocke...
JAVA-NIO之SocketChannel
ignorewho的博客
05-25 272
SocketChannel：基于tcp网络套接字的通道创建方式1、打开一个SocketChannel并连接到服务器2、一个新连接到达ServerSocketChannel时，创建一个SocketChannel非阻塞模式下1、connect()：调用该方法可能在连接建立之前就返回值了，需要通过finishConnect（）进一步判断2、write()：调用该方法可能在未写入数据前就返回了，需要在循环...
NIO学习之ServerSocketChannel和SocketChannel
m0_53157173的博客
12-07 3442
NIO学习Socket 通道ServerSocketChannelSocketChannel与ServerSocketChannel区别 Socket 通道 (1）新的 socket 通道类可以运行非阻塞模式并且是可选择的，可以激活大程序（如网络服务器和中间件组件）巨大的可伸缩性和灵活性。本节中我们会看到，再也没有为每个 socket 连接使用一个线程的必要了，也避免了管理大量线程所需的上下文交换开销。 借助新的 NIO 类，一个或几个线程就可以管理成百上千的活动 socket 连接了并且只有很少甚至可能
Java NIO系列教程（八） SocketChannel
灬一抹丶清风的博客
04-15 176
Java NIO中的SocketChannel是一个连接到TCP网络套接字的通道。可以通过以下2种方式创建SocketChannel： 打开一个SocketChannel并连接到互联网上的某台服务器。 一个新连接到达ServerSocketChannel时，会创建一个SocketChannel。 打开 SocketChannel 下面是SocketChannel的打开方式： SocketCha...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值