Java Socket实战之六 使用NIO包实现Socket通信

于 2015-04-29 11:21:00 发布
阅读量92 收藏
点赞数
文章标签： java

Java Socket实战之六 使用NIO包实现Socket通信

前面几篇文章介绍了使用java.io和java.net类库实现的Socket通信，下面介绍一下使用java.nio类库实现的Socket。

java.nio包是Java在1.4之后增加的，用来提高I/O操作的效率。在nio包中主要包括以下几个类或接口:

* Buffer：缓冲区，用来临时存放输入或输出数据。

* Charset：用来把Unicode字符编码和其它字符编码互转。

* Channel：数据传输通道，用来把Buffer中的数据写入到数据源，或者把数据源中的数据读入到Buffer。

* Selector：用来支持异步I/O操作，也叫非阻塞I/O操作。


nio包中主要通过下面两个方面来提高I/O操作效率:

* 通过Buffer和Channel来提高I/O操作的速度。

* 通过Selector来支持非阻塞I/O操作。


下面来看一下程序中是怎么通过这些类库实现Socket功能。

首先介绍一下几个辅助类

辅助类SerializableUtil，这个类用来把java对象序列化成字节数组，或者把字节数组反序列化成java对象。

[java] view plain copy print ?
  1. packagecom.googlecode.garbagecan.test.socket;
  3. importjava.io.ByteArrayInputStream;
  4. importjava.io.ByteArrayOutputStream;
  5. importjava.io.IOException;
  6. importjava.io.ObjectInputStream;
  7. importjava.io.ObjectOutputStream;
  9. publicclassSerializableUtil{
  11. publicstaticbyte[]toBytes(Objectobject){
  12. ByteArrayOutputStreambaos=newByteArrayOutputStream();
  13. ObjectOutputStreamoos=null;
  14. try{
  15. oos=newObjectOutputStream(baos);
  16. oos.writeObject(object);
  17. byte[]bytes=baos.toByteArray();
  18. returnbytes;
  19. }catch(IOExceptionex){
  20. thrownewRuntimeException(ex.getMessage(),ex);
  21. }finally{
  22. try{
  23. oos.close();
  24. }catch(Exceptione){}
  25. }
  26. }
  28. publicstaticObjecttoObject(byte[]bytes){
  29. ByteArrayInputStreambais=newByteArrayInputStream(bytes);
  30. ObjectInputStreamois=null;
  31. try{
  32. ois=newObjectInputStream(bais);
  33. Objectobject=ois.readObject();
  34. returnobject;
  35. }catch(IOExceptionex){
  36. thrownewRuntimeException(ex.getMessage(),ex);
  37. }catch(ClassNotFoundExceptionex){
  38. thrownewRuntimeException(ex.getMessage(),ex);
  39. }finally{
  40. try{
  41. ois.close();
  42. }catch(Exceptione){}
  43. }
  44. }
  45. }

辅助类MyRequestObject和MyResponseObject，这两个类是普通的java对象，实现了Serializable接口。MyRequestObject类是Client发出的请求，MyResponseObject是Server端作出的响应。
[java] view plain copy print ?
  1. packagecom.googlecode.garbagecan.test.socket.nio;
  3. importjava.io.Serializable;
  5. publicclassMyRequestObjectimplementsSerializable{
  7. privatestaticfinallongserialVersionUID=1L;
  9. privateStringname;
  11. privateStringvalue;
  13. privatebyte[]bytes;
  15. publicMyRequestObject(Stringname,Stringvalue){
  16. this.name=name;
  17. this.value=value;
  18. this.bytes=newbyte[1024];
  19. }
  21. publicStringgetName(){
  22. returnname;
  23. }
  25. publicvoidsetName(Stringname){
  26. this.name=name;
  27. }
  29. publicStringgetValue(){
  30. returnvalue;
  31. }
  33. publicvoidsetValue(Stringvalue){
  34. this.value=value;
  35. }
  37. @Override
  38. publicStringtoString(){
  39. StringBuffersb=newStringBuffer();
  40. sb.append("Request[name:"+name+",value:"+value+",bytes:"+bytes.length+"]");
  41. returnsb.toString();
  42. }
  43. }
  45. packagecom.googlecode.garbagecan.test.socket.nio;
  47. importjava.io.Serializable;
  49. publicclassMyResponseObjectimplementsSerializable{
  51. privatestaticfinallongserialVersionUID=1L;
  53. privateStringname;
  55. privateStringvalue;
  57. privatebyte[]bytes;
  59. publicMyResponseObject(Stringname,Stringvalue){
  60. this.name=name;
  61. this.value=value;
  62. this.bytes=newbyte[1024];
  63. }
  65. publicStringgetName(){
  66. returnname;
  67. }
  69. publicvoidsetName(Stringname){
  70. this.name=name;
  71. }
  73. publicStringgetValue(){
  74. returnvalue;
  75. }
  77. publicvoidsetValue(Stringvalue){
  78. this.value=value;
  79. }
  81. @Override
  82. publicStringtoString(){
  83. StringBuffersb=newStringBuffer();
  84. sb.append("Response[name:"+name+",value:"+value+",bytes:"+bytes.length+"]");
  85. returnsb.toString();
  86. }
  87. }

下面主要看一下Server端的代码，其中有一些英文注释对理解代码很有帮助，注释主要是来源jdk的文档和例子，这里就没有再翻译
[java] view plain copy print ?
  1. packagecom.googlecode.garbagecan.test.socket.nio;
  3. importjava.io.ByteArrayOutputStream;
  4. importjava.io.IOException;
  5. importjava.net.InetSocketAddress;
  6. importjava.nio.ByteBuffer;
  7. importjava.nio.channels.ClosedChannelException;
  8. importjava.nio.channels.SelectionKey;
  9. importjava.nio.channels.Selector;
  10. importjava.nio.channels.ServerSocketChannel;
  11. importjava.nio.channels.SocketChannel;
  12. importjava.util.Iterator;
  13. importjava.util.logging.Level;
  14. importjava.util.logging.Logger;
  16. importcom.googlecode.garbagecan.test.socket.SerializableUtil;
  18. publicclassMyServer3{
  20. privatefinalstaticLoggerlogger=Logger.getLogger(MyServer3.class.getName());
  22. publicstaticvoidmain(String[]args){
  23. Selectorselector=null;
  24. ServerSocketChannelserverSocketChannel=null;
  26. try{
  27. //Selectorforincomingtimerequests
  28. selector=Selector.open();
  30. //Createanewserversocketandsettononblockingmode
  31. serverSocketChannel=ServerSocketChannel.open();
  32. serverSocketChannel.configureBlocking(false);
  34. //Bindtheserversockettothelocalhostandport
  35. serverSocketChannel.socket().setReuseAddress(true);
  36. serverSocketChannel.socket().bind(newInetSocketAddress(10000));
  38. //Registeracceptsontheserversocketwiththeselector.This
  39. //steptellstheselectorthatthesocketwantstobeputonthe
  40. //readylistwhenacceptoperationsoccur,soallowingmultiplexed
  41. //non-blockingI/Ototakeplace.
  42. serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);
  44. //Here'swhereeverythinghappens.Theselectmethodwill
  45. //returnwhenanyoperationsregisteredabovehaveoccurred,the
  46. //threadhasbeeninterrupted,etc.
  47. while(selector.select()>0){
  48. //SomeoneisreadyforI/O,getthereadykeys
  49. Iterator<SelectionKey>it=selector.selectedKeys().iterator();
  51. //Walkthroughthereadykeyscollectionandprocessdaterequests.
  52. while(it.hasNext()){
  53. SelectionKeyreadyKey=it.next();
  54. it.remove();
  56. //Thekeyindexesintotheselectorsoyou
  57. //canretrievethesocketthat'sreadyforI/O
  58. execute((ServerSocketChannel)readyKey.channel());
  59. }
  60. }
  61. }catch(ClosedChannelExceptionex){
  62. logger.log(Level.SEVERE,null,ex);
  63. }catch(IOExceptionex){
  64. logger.log(Level.SEVERE,null,ex);
  65. }finally{
  66. try{
  67. selector.close();
  68. }catch(Exceptionex){}
  69. try{
  70. serverSocketChannel.close();
  71. }catch(Exceptionex){}
  72. }
  73. }
  75. privatestaticvoidexecute(ServerSocketChannelserverSocketChannel)throwsIOException{
  76. SocketChannelsocketChannel=null;
  77. try{
  78. socketChannel=serverSocketChannel.accept();
  79. MyRequestObjectmyRequestObject=receiveData(socketChannel);
  80. logger.log(Level.INFO,myRequestObject.toString());
  82. MyResponseObjectmyResponseObject=newMyResponseObject(
  83. "responsefor"+myRequestObject.getName(),
  84. "responsefor"+myRequestObject.getValue());
  85. sendData(socketChannel,myResponseObject);
  86. logger.log(Level.INFO,myResponseObject.toString());
  87. }finally{
  88. try{
  89. socketChannel.close();
  90. }catch(Exceptionex){}
  91. }
  92. }
  94. privatestaticMyRequestObjectreceiveData(SocketChannelsocketChannel)throwsIOException{
  95. MyRequestObjectmyRequestObject=null;
  96. ByteArrayOutputStreambaos=newByteArrayOutputStream();
  97. ByteBufferbuffer=ByteBuffer.allocate(1024);
  99. try{
  100. byte[]bytes;
  101. intsize=0;
  102. while((size=socketChannel.read(buffer))>=0){
  103. buffer.flip();
  104. bytes=newbyte[size];
  105. buffer.get(bytes);
  106. baos.write(bytes);
  107. buffer.clear();
  108. }
  109. bytes=baos.toByteArray();
  110. Objectobj=SerializableUtil.toObject(bytes);
  111. myRequestObject=(MyRequestObject)obj;
  112. }finally{
  113. try{
  114. baos.close();
  115. }catch(Exceptionex){}
  116. }
  117. returnmyRequestObject;
  118. }
  120. privatestaticvoidsendData(SocketChannelsocketChannel,MyResponseObjectmyResponseObject)throwsIOException{
  121. byte[]bytes=SerializableUtil.toBytes(myResponseObject);
  122. ByteBufferbuffer=ByteBuffer.wrap(bytes);
  123. socketChannel.write(buffer);
  124. }
  125. }

下面是Client的代码，代码比较简单就是启动了100个线程来访问Server
[java] view plain copy print ?
  1. packagecom.googlecode.garbagecan.test.socket.nio;
  3. importjava.io.ByteArrayOutputStream;
  4. importjava.io.IOException;
  5. importjava.net.InetSocketAddress;
  6. importjava.net.SocketAddress;
  7. importjava.nio.ByteBuffer;
  8. importjava.nio.channels.SocketChannel;
  9. importjava.util.logging.Level;
  10. importjava.util.logging.Logger;
  12. importcom.googlecode.garbagecan.test.socket.SerializableUtil;
  14. publicclassMyClient3{
  16. privatefinalstaticLoggerlogger=Logger.getLogger(MyClient3.class.getName());
  18. publicstaticvoidmain(String[]args)throwsException{
  19. for(inti=0;i<100;i++){
  20. finalintidx=i;
  21. newThread(newMyRunnable(idx)).start();
  22. }
  23. }
  25. privatestaticfinalclassMyRunnableimplementsRunnable{
  27. privatefinalintidx;
  29. privateMyRunnable(intidx){
  30. this.idx=idx;
  31. }
  33. publicvoidrun(){
  34. SocketChannelsocketChannel=null;
  35. try{
  36. socketChannel=SocketChannel.open();
  37. SocketAddresssocketAddress=newInetSocketAddress("localhost",10000);
  38. socketChannel.connect(socketAddress);
  40. MyRequestObjectmyRequestObject=newMyRequestObject("request_"+idx,"request_"+idx);
  41. logger.log(Level.INFO,myRequestObject.toString());
  42. sendData(socketChannel,myRequestObject);
  44. MyResponseObjectmyResponseObject=receiveData(socketChannel);
  45. logger.log(Level.INFO,myResponseObject.toString());
  46. }catch(Exceptionex){
  47. logger.log(Level.SEVERE,null,ex);
  48. }finally{
  49. try{
  50. socketChannel.close();
  51. }catch(Exceptionex){}
  52. }
  53. }
  55. privatevoidsendData(SocketChannelsocketChannel,MyRequestObjectmyRequestObject)throwsIOException{
  56. byte[]bytes=SerializableUtil.toBytes(myRequestObject);
  57. ByteBufferbuffer=ByteBuffer.wrap(bytes);
  58. socketChannel.write(buffer);
  59. socketChannel.socket().shutdownOutput();
  60. }
  62. privateMyResponseObjectreceiveData(SocketChannelsocketChannel)throwsIOException{
  63. MyResponseObjectmyResponseObject=null;
  64. ByteArrayOutputStreambaos=newByteArrayOutputStream();
  66. try{
  67. ByteBufferbuffer=ByteBuffer.allocateDirect(1024);
  68. byte[]bytes;
  69. intcount=0;
  70. while((count=socketChannel.read(buffer))>=0){
  71. buffer.flip();
  72. bytes=newbyte[count];
  73. buffer.get(bytes);
  74. baos.write(bytes);
  75. buffer.clear();
  76. }
  77. bytes=baos.toByteArray();
  78. Objectobj=SerializableUtil.toObject(bytes);
  79. myResponseObject=(MyResponseObject)obj;
  80. socketChannel.socket().shutdownInput();
  81. }finally{
  82. try{
  83. baos.close();
  84. }catch(Exceptionex){}
  85. }
  86. returnmyResponseObject;
  87. }
  88. }
  89. }

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值