Nio Socket 连接

最新推荐文章于 2022-08-23 10:21:09 发布
最新推荐文章于 2022-08-23 10:21:09 发布
阅读量96 收藏
点赞数
原文链接：http://www.cnblogs.com/xiaolei2017/p/9619067.html
版权 
首先介绍一下几个辅助类
辅助类SerializableUtil，这个类用来把java对象序列化成字节数组，或者把字节数组反序列化成java对象。
[java] view plain copy  
package com.googlecode.garbagecan.test.socket;  
  
import java.io.ByteArrayInputStream;  
import java.io.ByteArrayOutputStream;  
import java.io.IOException;  
import java.io.ObjectInputStream;  
import java.io.ObjectOutputStream;  
  
public class SerializableUtil {  
      
    public static byte[] toBytes(Object object) {  
        ByteArrayOutputStream baos = new ByteArrayOutputStream();  
        ObjectOutputStream oos = null;  
        try {  
            oos = new ObjectOutputStream(baos);  
            oos.writeObject(object);  
            byte[] bytes = baos.toByteArray();  
            return bytes;  
        } catch(IOException ex) {  
            throw new RuntimeException(ex.getMessage(), ex);  
        } finally {  
            try {  
                oos.close();  
            } catch (Exception e) {}  
        }  
    }  
      
    public static Object toObject(byte[] bytes) {  
        ByteArrayInputStream bais = new ByteArrayInputStream(bytes);  
        ObjectInputStream ois = null;  
        try {  
            ois = new ObjectInputStream(bais);  
            Object object = ois.readObject();  
            return object;  
        } catch(IOException ex) {  
            throw new RuntimeException(ex.getMessage(), ex);  
        } catch(ClassNotFoundException ex) {  
            throw new RuntimeException(ex.getMessage(), ex);  
        } finally {  
            try {  
                ois.close();  
            } catch (Exception e) {}  
        }  
    }  
}  
辅助类MyRequestObject和MyResponseObject，这两个类是普通的java对象，实现了Serializable接口。MyRequestObject类是Client发出的请求，MyResponseObject是Server端作出的响应。
[java] view plain copy  
package com.googlecode.garbagecan.test.socket.nio;  
  
import java.io.Serializable;  
  
public class MyRequestObject implements Serializable {  
  
    private static final long serialVersionUID = 1L;  
  
    private String name;  
      
    private String value;  
  
    private byte[] bytes;  
      
    public MyRequestObject(String name, String value) {  
        this.name = name;  
        this.value = value;  
        this.bytes = new byte[1024];  
    }  
      
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    public String getValue() {  
        return value;  
    }  
  
    public void setValue(String value) {  
        this.value = value;  
    }  
      
    @Override  
    public String toString() {  
        StringBuffer sb = new StringBuffer();  
        sb.append("Request [name: " + name  + ", value: " + value + ", bytes: " + bytes.length+ "]");  
        return sb.toString();  
    }  
}  
  
package com.googlecode.garbagecan.test.socket.nio;  
  
import java.io.Serializable;  
  
public class MyResponseObject implements Serializable {  
  
    private static final long serialVersionUID = 1L;  
  
    private String name;  
      
    private String value;  
  
    private byte[] bytes;  
      
    public MyResponseObject(String name, String value) {  
        this.name = name;  
        this.value = value;  
        this.bytes = new byte[1024];  
    }  
      
    public String getName() {  
        return name;  
    }  
  
    public void setName(String name) {  
        this.name = name;  
    }  
  
    public String getValue() {  
        return value;  
    }  
  
    public void setValue(String value) {  
        this.value = value;  
    }  
      
    @Override  
    public String toString() {  
        StringBuffer sb = new StringBuffer();  
        sb.append("Response [name: " + name  + ", value: " + value + ", bytes: " + bytes.length+ "]");  
        return sb.toString();  
    }  
}  

下面主要看一下Server端的代码，其中有一些英文注释对理解代码很有帮助，注释主要是来源jdk的文档和例子，这里就没有再翻译
[java] view plain copy  
package com.googlecode.garbagecan.test.socket.nio;  
  
import java.io.ByteArrayOutputStream;  
import java.io.IOException;  
import java.net.InetSocketAddress;  
import java.nio.ByteBuffer;  
import java.nio.channels.ClosedChannelException;  
import java.nio.channels.SelectionKey;  
import java.nio.channels.Selector;  
import java.nio.channels.ServerSocketChannel;  
import java.nio.channels.SocketChannel;  
import java.util.Iterator;  
import java.util.logging.Level;  
import java.util.logging.Logger;  
  
import com.googlecode.garbagecan.test.socket.SerializableUtil;  
  
public class MyServer3 {  
  
    private final static Logger logger = Logger.getLogger(MyServer3.class.getName());  
      
    public static void main(String[] args) {  
        Selector selector = null;  
        ServerSocketChannel serverSocketChannel = null;  
          
        try {  
            // Selector for incoming time requests  
            selector = Selector.open();  
  
            // Create a new server socket and set to non blocking mode  
            serverSocketChannel = ServerSocketChannel.open();  
            serverSocketChannel.configureBlocking(false);  
              
            // Bind the server socket to the local host and port  
            serverSocketChannel.socket().setReuseAddress(true);  
            serverSocketChannel.socket().bind(new InetSocketAddress(10000));  
              
            // Register accepts on the server socket with the selector. This  
            // step tells the selector that the socket wants to be put on the  
            // ready list when accept operations occur, so allowing multiplexed  
            // non-blocking I/O to take place.  
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);  
      
            // Here's where everything happens. The select method will  
            // return when any operations registered above have occurred, the  
            // thread has been interrupted, etc.  
            while (selector.select() > 0) {  
                // Someone is ready for I/O, get the ready keys  
                Iterator<SelectionKey> it = selector.selectedKeys().iterator();  
      
                // Walk through the ready keys collection and process date requests.  
                while (it.hasNext()) {  
                    SelectionKey readyKey = it.next();  
                    it.remove();  
                      
                    // The key indexes into the selector so you  
                    // can retrieve the socket that's ready for I/O  
                    execute((ServerSocketChannel) readyKey.channel());  
                }  
            }  
        } catch (ClosedChannelException ex) {  
            logger.log(Level.SEVERE, null, ex);  
        } catch (IOException ex) {  
            logger.log(Level.SEVERE, null, ex);  
        } finally {  
            try {  
                selector.close();  
            } catch(Exception ex) {}  
            try {  
                serverSocketChannel.close();  
            } catch(Exception ex) {}  
        }  
    }  
  
    private static void execute(ServerSocketChannel serverSocketChannel) throws IOException {  
        SocketChannel socketChannel = null;  
        try {  
            socketChannel = serverSocketChannel.accept();  
            MyRequestObject myRequestObject = receiveData(socketChannel);  
            logger.log(Level.INFO, myRequestObject.toString());  
              
            MyResponseObject myResponseObject = new MyResponseObject(  
                    "response for " + myRequestObject.getName(),   
                    "response for " + myRequestObject.getValue());  
            sendData(socketChannel, myResponseObject);  
            logger.log(Level.INFO, myResponseObject.toString());  
        } finally {  
            try {  
                socketChannel.close();  
            } catch(Exception ex) {}  
        }  
    }  
      
    private static MyRequestObject receiveData(SocketChannel socketChannel) throws IOException {  
        MyRequestObject myRequestObject = null;  
        ByteArrayOutputStream baos = new ByteArrayOutputStream();  
        ByteBuffer buffer = ByteBuffer.allocate(1024);  
          
        try {  
            byte[] bytes;  
            int size = 0;  
            while ((size = socketChannel.read(buffer)) >= 0) {  
                buffer.flip();  
                bytes = new byte[size];  
                buffer.get(bytes);  
                baos.write(bytes);  
                buffer.clear();  
            }  
            bytes = baos.toByteArray();  
            Object obj = SerializableUtil.toObject(bytes);  
            myRequestObject = (MyRequestObject)obj;  
        } finally {  
            try {  
                baos.close();  
            } catch(Exception ex) {}  
        }  
        return myRequestObject;  
    }  
  
    private static void sendData(SocketChannel socketChannel, MyResponseObject myResponseObject) throws IOException {  
        byte[] bytes = SerializableUtil.toBytes(myResponseObject);  
        ByteBuffer buffer = ByteBuffer.wrap(bytes);  
        socketChannel.write(buffer);  
    }  
}  
下面是Client的代码，代码比较简单就是启动了100个线程来访问Server
[java] view plain copy  
package com.googlecode.garbagecan.test.socket.nio;  
  
import java.io.ByteArrayOutputStream;  
import java.io.IOException;  
import java.net.InetSocketAddress;  
import java.net.SocketAddress;  
import java.nio.ByteBuffer;  
import java.nio.channels.SocketChannel;  
import java.util.logging.Level;  
import java.util.logging.Logger;  
  
import com.googlecode.garbagecan.test.socket.SerializableUtil;  
  
public class MyClient3 {  
  
    private final static Logger logger = Logger.getLogger(MyClient3.class.getName());  
      
    public static void main(String[] args) throws Exception {  
        for (int i = 0; i < 100; i++) {  
            final int idx = i;  
            new Thread(new MyRunnable(idx)).start();  
        }  
    }  
      
    private static final class MyRunnable implements Runnable {  
          
        private final int idx;  
  
        private MyRunnable(int idx) {  
            this.idx = idx;  
        }  
  
        public void run() {  
            SocketChannel socketChannel = null;  
            try {  
                socketChannel = SocketChannel.open();  
                SocketAddress socketAddress = new InetSocketAddress("localhost", 10000);  
                socketChannel.connect(socketAddress);  
  
                MyRequestObject myRequestObject = new MyRequestObject("request_" + idx, "request_" + idx);  
                logger.log(Level.INFO, myRequestObject.toString());  
                sendData(socketChannel, myRequestObject);  
                  
                MyResponseObject myResponseObject = receiveData(socketChannel);  
                logger.log(Level.INFO, myResponseObject.toString());  
            } catch (Exception ex) {  
                logger.log(Level.SEVERE, null, ex);  
            } finally {  
                try {  
                    socketChannel.close();  
                } catch(Exception ex) {}  
            }  
        }  
  
        private void sendData(SocketChannel socketChannel, MyRequestObject myRequestObject) throws IOException {  
            byte[] bytes = SerializableUtil.toBytes(myRequestObject);  
            ByteBuffer buffer = ByteBuffer.wrap(bytes);  
            socketChannel.write(buffer);  
            socketChannel.socket().shutdownOutput();  
        }  
  
        private MyResponseObject receiveData(SocketChannel socketChannel) throws IOException {  
            MyResponseObject myResponseObject = null;  
            ByteArrayOutputStream baos = new ByteArrayOutputStream();  
              
            try {  
                ByteBuffer buffer = ByteBuffer.allocateDirect(1024);  
                byte[] bytes;  
                int count = 0;  
                while ((count = socketChannel.read(buffer)) >= 0) {  
                    buffer.flip();  
                    bytes = new byte[count];  
                    buffer.get(bytes);  
                    baos.write(bytes);  
                    buffer.clear();  
                }  
                bytes = baos.toByteArray();  
                Object obj = SerializableUtil.toObject(bytes);  
                myResponseObject = (MyResponseObject) obj;  
                socketChannel.socket().shutdownInput();  
            } finally {  
                try {  
                    baos.close();  
                } catch(Exception ex) {}  
            }  
            return myResponseObject;  
        }  
    }  
}  

最后测试上面的代码，首先运行Server类，然后运行Client类，就可以分别在Server端和Client端控制台看到发送或接收到的MyRequestObject或MyResponseObject对象了。

关于NIO和IO的比较，下面的两篇文章对理解很有帮助，可以参考一下。
http://tutorials.jenkov.com/java-nio/nio-vs-io.html
https://blogs.oracle.com/slc/entry/javanio_vs_javaio

 

转载于:https://www.cnblogs.com/xiaolei2017/p/9619067.html

weixin_30608503
关注
java nio socket,Java----NioSocket的简单使用
weixin_39585974的博客
03-19 585
一、自己理解的概念nioSocket(即new io socket)是一种同步非阻塞的I/O，其使用buffer来缓存数据和channel来传输数据，使用select来分拣消息。其使用的ServerSocketChannel和SocketChannel对应于之前学习的ServerSocket和Socket。在我看的书(《看透Spring MVC源代码分析与实践》)中形容为：当今的快递物流，现实中的...
服务器nio协议,java Nio使用NioSocket客户端与服务端交互实现方式
weixin_35900054的博客
08-11 1060
NioSocket 客户端与服务端交互实现java Nio是jdk1.4新增的io方式—–nio(new IO)，这种方式在目前来说算不算new，更合适的解释应该是non-block IO。non-block是相对于传统的io方式来讲的。传统的Io方式是阻塞的，我们拿网络io来举例，传统的io模型如下：服务端主线程负责不断地server.accept()，如果没有客户端请求主线程就会阻塞，当客户端...
java.nio(socket异步通讯完整版)
05-20
重新写的Java.nio的socket异步通讯，包含客户端及服务端完整版， 注：解析信息CLASS及进制转换CLASS需要自己去写，项目直接导入，需要自己写一些解析及转换类，这样你才能读懂SOCKET的异步，否则光拿代码没用 注释很详细，自己研究吧，包括了 缓冲解决办法
基于Nio的socket连接 随记
天水一方
05-13 126
随便了解了下,也用搜到的代码理解了一下,稍微做了一些修改 [code="java"] package com.orz.gen; import java.io.IOException; import java.net.InetAddress; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import ...
NIO Socket
一点红 的博客
05-28 413
public class NIOServer { // 通道管理器(Selector) private static Selector selector; public static void main(String[] args) throws IOException { // 创建通道管理器(Selector) selector =...
通过一个Socket连接的例子来认识 NIO
WayJasy的博客
03-27 211
众所周知，NIO（new IO 也叫做 NoBlocking IO），非阻塞IO，是由BIO演变而来的，它的优势就在于数据传输过程中，由BIO的阻塞式变为非阻塞式，那么什么是阻塞和非阻塞？ 先来一个BIO的例子。 /** * 服务端 */ public class Server { static byte[] bytes = new byte[1024]; public sta...
java nio 客户端连接_Java nio 客户端连接Server
weixin_29544469的博客
02-16 188
在做通信系统的开发过程中，经常需要使用Socket通信。java新的io机制给我提供了一个很好的异步socket通信方式，这段时间用java写了一个客户端用来连接server。发现运行效率还比较让人满意。下面是我实现的部分功能。连接服务器的socket，多线程启动。如果连接失败就重连。Java代码 publicclassCommonSocketextendsThread{priva...
NioSocket，包括server端和client端
01-25
在Java编程中，NIO（New Input/Output）提供了一种不同于传统IO模型的I/O操作方式，其核心特点是能够进行多路复用，即一个线程可以同时处理多个连接，这使得NioSocket在高并发场景下具有较好的性能表现。 服务器端...
Java NIO Socket基本
03-28
**Socket编程在NIO中的应用**： 1. **ServerSocketChannel**：用于监听客户端连接，通过调用`ServerSocketChannel.open()`创建，然后绑定到指定的IP和端口，并调用`accept()`方法接收客户端连接。 2. **...
一般Socket客户端与Mina NIO Socket客户端对比示例
05-24
`TestConnector.java`和`SocketTest.java`可能包含了此类客户端的示例代码，展示如何创建和管理Socket连接，以及发送和接收数据的基本流程。 相比之下，Mina NIO是一种基于Java NIO API的网络通信框架，它利用了多...
基于java NIO的socket通信demo
10-31
java NIO 创建的服务端，能够异步响应客户端的请求，客户端采用nio异步请求服务端，通信之间的乱码使用charset解决
三种连接方式比较及实现（nio，长连接，短连接）
MagicSound的博客
08-03 1659
长链接： 在csframework中，使用的就是长连接，每当接收到一个客户端，服务器端会开启一个长期线程去持续监听该客户端的soket，程序也就会阻塞在该socket的read方法上，当用户多了，服务器端所开的线程也就多了，因为每个线程还要申请PCB、占用CPU时间，故这种方式资源开销巨大，但也是接受效率最高的方法。 解决：分布式服务器 短连接： 像RMI调用，即在远程方法调用前进行客户端与服务器连接，方法调用完成就断开连接，这种占用资源最少，不需要线程去持续监听，但每次都需要客户端与服务器的断开、连接，时
【JAVA】【NIO】9、Java NIO SocketChannel
三也_攻城狮
03-20 1316
Java NIO的SocketChannel是连接tcp网络套接字的channel。有如下两种方式去创建： 1、打开一个SocketChannel，连接到网络上的一个server 2、当ServerSocketChannel收到一个连接，SocketChannel就创建了 打开SocketChannel SocketChannel socketChannel = SocketChannel
(六) socket·NIO socket 实现 控制台 一问一答式聊天
༺ bestcxx的专栏 ༻
02-23 517
文章目录服务器端客户端 服务器端 package com.yeepay.g3.facade.test; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; import jav...
初探连接器的奥秘之NIO如何具体实现(二)
小派师兄
08-23 217
初探连接器的奥秘之NIO如何具体实现
NIO--Socket通道
weixin_49702090的博客
06-19 755
NIO ServerSocketChnnel介绍
java nio socket长连接_nio实现Socket长连接和心跳
weixin_30424461的博客
02-12 945
前段时间用bio方式，也就是传统io实现了socket的长连接和心跳，总觉着服务端开启多线程管理socket连接的方式过于消耗资源，数据并发的情况下可能会影响到性能，因此就尝试使用nio改进原来的代码。然而改进的过程却不像我起初设想的那般容易，可以说一波三折，原因主要是nio读写都是字节流，LZ一开始依然通过ObjectOutputStream.writeObject直接向Socket服务端发送数...
java Nio 使用 NioSocket 客户端与服务端交互实现
热门推荐
wkNote
07-07 2万+
NioSocket 客户端与服务端交互实现 &amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;java Nio是jdk1.4新增的io方式—–nio（new IO），这种方式在目前来说算不算new，更合适的解释应该是non-block IO。 &amp;amp;nbsp;&amp;amp;
NIO实现socket
最新发布
05-08
在实现socket时，NIO可以使用Selector、Channel和Buffer等组件来实现。 具体实现步骤如下： 1. 创建一个ServerSocketChannel对象并绑定到指定的端口上； 2. 将ServerSocketChannel对象设置为非阻塞模式，即...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值