Java Socket实战之八 socket提升

最新推荐文章于 2023-05-30 17:41:20 发布
最新推荐文章于 2023-05-30 17:41:20 发布
阅读量111 收藏
点赞数
文章标签： java

Java Socket实战之八 socket提升

一直没时间继续写，这两天总算找了点时间把当时的一些想法简单实现了一下，比较初略，主要是记下自己的想法，下次有机会了再慢慢细化吧。

对于Socket编程来说，通常我们遇到的最大的麻烦就是要定义自己的协议，用来在server端和client端处理请求和响应，当socket处理的请求对象越来越多以后，如果规则定义不清楚就会导致代码急剧膨胀，并且维护性变差，所以这里我想了一个简单的方式来处理这种情况。

下面大概说一下我的想法

1. 首先会有几个和业务相关的类，User，MyUserService和MyUserServiceImpl。User就是我们通常的实体类；MyUserService是我们针对User实体类提供的业务逻辑接口，比较简单就写了三个方法；MyUserServiceImpl是业务逻辑实现类。

[java] view plain copy print ?
  1. packagecom.googlecode.garbagecan.test.socket.sample10;
  3. publicclassUserimplementsjava.io.Serializable{
  4. privatestaticfinallongserialVersionUID=1L;
  5. privateStringname;
  6. privateStringpassword;
  8. publicUser(){
  10. }
  12. publicUser(Stringname,Stringpassword){
  13. this.name=name;
  14. this.password=password;
  15. }
  17. publicStringgetName(){
  18. returnname;
  19. }
  21. publicvoidsetName(Stringname){
  22. this.name=name;
  23. }
  25. publicStringgetPassword(){
  26. returnpassword;
  27. }
  29. publicvoidsetPassword(Stringpassword){
  30. this.password=password;
  31. }
  33. }

MyUserService.java
[java] view plain copy print ?
  1. packagecom.googlecode.garbagecan.test.socket.sample10;
  3. importjava.util.List;
  5. publicinterfaceMyUserService{
  7. List<User>list(intsize);
  9. UserfindByName(Stringname);
  11. voidtest();
  12. }

MyUserServiceImpl.java
[java] view plain copy print ?
  1. packagecom.googlecode.garbagecan.test.socket.sample10;
  3. importjava.util.ArrayList;
  4. importjava.util.List;
  6. publicclassMyUserServiceImplimplementsMyUserService{
  8. @Override
  9. publicList<User>list(intsize){
  10. List<User>users=newArrayList<User>();
  11. for(inti=0;i<size;i++){
  12. users.add(newUser("user_"+i,"password_"+i));
  13. }
  14. returnusers;
  15. }
  17. @Override
  18. publicUserfindByName(Stringname){
  19. returnnewUser(name,null);
  20. }
  22. @Override
  23. publicvoidtest(){
  24. //donothing
  25. }
  27. }

2. 服务器端类，主要有三个类MyServer，MyServerSimpleImpl和MyServerNIOImpl。MyServer是服务器端接口类，用来启动Socket server；MyServerSimpleImpl和MyServerNIOImpl是两个实现类，其中MyServerSimpleImpl是使用简单的Socket实现的，MyServerNIOImpl是使用java nio包里的类实现的，这个实现会有更好的性能。

MyServer.java

[java] view plain copy print ?
  1. packagecom.googlecode.garbagecan.test.socket.sample10;
  3. publicinterfaceMyServer{
  5. publicvoidstartup()throwsException;
  7. publicvoidshutdown()throwsException;
  8. }

MyServerSimpleImpl.java
[java] view plain copy print ?
  1. packagecom.googlecode.garbagecan.test.socket.sample10;
  3. importcom.googlecode.garbagecan.test.socket.IOUtil;
  5. importjava.io.ObjectInputStream;
  6. importjava.io.ObjectOutputStream;
  7. importjava.lang.reflect.Method;
  8. importjava.net.ServerSocket;
  9. importjava.net.Socket;
  11. publicclassMyServerSimpleImplimplementsMyServer{
  13. privateintport;
  15. publicMyServerSimpleImpl(intport){
  16. this.port=port;
  17. }
  19. publicvoidstartup()throwsException{
  20. newThread(newRunnable(){
  21. @Override
  22. publicvoidrun(){
  23. try{
  24. ServerSocketserver=newServerSocket(port);
  26. while(true){
  27. Socketsocket=server.accept();
  28. invoke(socket);
  29. }
  30. }catch(Exceptionex){
  31. ex.printStackTrace();
  32. }
  33. }
  34. }).start();
  35. }
  37. @Override
  38. publicvoidshutdown()throwsException{
  39. //Implementme
  40. }
  42. privatevoidinvoke(finalSocketsocket){
  43. newThread(newRunnable(){
  44. publicvoidrun(){
  45. ObjectInputStreamois=null;
  46. ObjectOutputStreamoos=null;
  48. try{
  49. ois=newObjectInputStream(socket.getInputStream());
  50. oos=newObjectOutputStream(socket.getOutputStream());
  52. Objectobj=ois.readObject();
  53. MyRequestrequest=(MyRequest)obj;
  54. MyResponseresponse=execute(request);
  55. oos.writeObject(response);
  56. oos.flush();
  57. }catch(Exceptionex){
  58. ex.printStackTrace();
  59. }finally{
  60. IOUtil.closeQuietly(ois);
  61. IOUtil.closeQuietly(oos);
  62. IOUtil.closeQuietly(socket);
  63. }
  64. }
  65. }).start();
  66. }
  68. privateMyResponseexecute(MyRequestrequest)throwsException{
  69. Classclazz=request.getRequestClass();
  71. StringmethodName=request.getRequestMethod();
  72. Class<?>[]parameterTypes=request.getRequestParameterTypes();
  73. Methodmethod=clazz.getDeclaredMethod(methodName,parameterTypes);
  75. Object[]parameterValues=request.getRequestParameterValues();
  76. finalObjectobj=method.invoke(clazz.newInstance(),parameterValues);
  78. returnnewMyGenericResponse(obj);
  79. }
  81. }

MyServerNIOImpl.java
[java] view plain copy print ?
  1. packagecom.googlecode.garbagecan.test.socket.sample10;
  3. importcom.googlecode.garbagecan.test.socket.SerializableUtil;
  5. importjava.io.ByteArrayOutputStream;
  6. importjava.io.IOException;
  7. importjava.lang.reflect.Method;
  8. importjava.net.InetSocketAddress;
  9. importjava.nio.ByteBuffer;
  10. importjava.nio.channels.SelectionKey;
  11. importjava.nio.channels.Selector;
  12. importjava.nio.channels.ServerSocketChannel;
  13. importjava.nio.channels.SocketChannel;
  14. importjava.util.Iterator;
  15. importjava.util.logging.Level;
  16. importjava.util.logging.Logger;
  18. publicclassMyServerNIOImplimplementsMyServer{
  20. privatefinalstaticLoggerlogger=Logger.getLogger(MyServerNIOImpl.class.getName());
  22. privateintport;
  24. publicMyServerNIOImpl(intport){
  25. this.port=port;
  26. }
  28. publicvoidstartup()throwsException{
  29. newThread(newRunnable(){
  30. @Override
  31. publicvoidrun(){
  32. Selectorselector=null;
  33. ServerSocketChannelserverSocketChannel=null;
  35. try{
  36. selector=Selector.open();
  37. serverSocketChannel=ServerSocketChannel.open();
  38. serverSocketChannel.configureBlocking(false);
  40. serverSocketChannel.socket().setReuseAddress(true);
  41. serverSocketChannel.socket().bind(newInetSocketAddress(port));
  43. serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);
  45. while(selector.select()>0){
  46. try{
  47. Iterator<SelectionKey>it=selector.selectedKeys().iterator();
  48. while(it.hasNext()){
  49. SelectionKeyreadyKey=it.next();
  50. it.remove();
  51. invoke((ServerSocketChannel)readyKey.channel());
  52. }
  53. }catch(Exceptionex){
  54. logger.log(Level.SEVERE,ex.getMessage(),ex);
  55. }
  56. }
  57. }catch(Exceptionex){
  58. logger.log(Level.SEVERE,ex.getMessage(),ex);
  59. }finally{
  60. try{
  61. selector.close();
  62. }catch(Exceptionex){}
  63. try{
  64. serverSocketChannel.close();
  65. }catch(Exceptionex){}
  66. }
  67. }
  68. }).start();
  69. }
  71. @Override
  72. publicvoidshutdown()throwsException{
  73. //Implementme
  74. }
  76. privatevoidinvoke(ServerSocketChannelserverSocketChannel)throwsException{
  77. SocketChannelsocketChannel=null;
  78. try{
  79. socketChannel=serverSocketChannel.accept();
  80. MyRequestmyRequest=receiveData(socketChannel);
  81. MyResponsemyResponse=execute(myRequest);
  82. sendData(socketChannel,myResponse);
  83. }finally{
  84. try{
  85. socketChannel.close();
  86. }catch(Exceptionex){}
  87. }
  88. }
  90. privateMyResponseexecute(MyRequestrequest)throwsException{
  91. Classclazz=request.getRequestClass();
  93. StringmethodName=request.getRequestMethod();
  94. Class<?>[]parameterTypes=request.getRequestParameterTypes();
  95. Methodmethod=clazz.getDeclaredMethod(methodName,parameterTypes);
  97. Object[]parameterValues=request.getRequestParameterValues();
  98. finalObjectobj=method.invoke(clazz.newInstance(),parameterValues);
  100. returnnewMyGenericResponse(obj);
  101. }
  103. privateMyRequestreceiveData(SocketChannelsocketChannel)throwsIOException{
  104. MyRequestmyRequest=null;
  105. ByteArrayOutputStreambaos=newByteArrayOutputStream();
  106. ByteBufferbuffer=ByteBuffer.allocate(1024);
  108. try{
  109. byte[]bytes;
  110. intsize=0;
  111. while((size=socketChannel.read(buffer))>=0){
  112. buffer.flip();
  113. bytes=newbyte[size];
  114. buffer.get(bytes);
  115. baos.write(bytes);
  116. buffer.clear();
  117. }
  118. bytes=baos.toByteArray();
  119. Objectobj=SerializableUtil.toObject(bytes);
  120. myRequest=(MyRequest)obj;
  121. }finally{
  122. try{
  123. baos.close();
  124. }catch(Exceptionex){}
  125. }
  126. returnmyRequest;
  127. }
  129. privatevoidsendData(SocketChannelsocketChannel,MyResponsemyResponse)throwsIOException{
  130. byte[]bytes=SerializableUtil.toBytes(myResponse);
  131. ByteBufferbuffer=ByteBuffer.wrap(bytes);
  132. socketChannel.write(buffer);
  133. }
  134. }

3. 客户端类，主要有三个类MyClient，MyClientSimpleImpl和MyClientNIOImpl。MyClient是客户端接口类，用来向Server端发送请求并获取相应；MyClientSimpleImpl和MyClientNIOImpl是两个实现类，其中MyClientSimpleImpl是使用简单Socket实现的，MyClientNIOImpl是使用java nio包里的类实现的，这个实现会有更好的性能。

MyClient.java

[java] view plain copy print ?
  1. packagecom.googlecode.garbagecan.test.socket.sample10;
  3. publicinterfaceMyClient{
  5. public<T>Texecute(MyRequestrequest,MyResponseHandler<T>handler);
  7. publicMyResponseexecute(MyRequestrequest);
  9. }

MyClientSimpleImpl.java
[java] view plain copy print ?
  1. packagecom.googlecode.garbagecan.test.socket.sample10;
  3. importcom.googlecode.garbagecan.test.socket.IOUtil;
  5. importjava.io.IOException;
  6. importjava.io.ObjectInputStream;
  7. importjava.io.ObjectOutputStream;
  8. importjava.net.InetSocketAddress;
  9. importjava.net.Socket;
  10. importjava.net.SocketAddress;
  12. publicclassMyClientSimpleImplimplementsMyClient{
  14. privateStringhost;
  15. privateintport;
  17. publicMyClientSimpleImpl(Stringhost,intport){
  18. this.host=host;
  19. this.port=port;
  20. }
  22. public<T>Texecute(MyRequestrequest,MyResponseHandler<T>handler){
  23. MyResponseresponse=execute(request);
  24. returnhandler.handle(response);
  25. }
  27. publicMyResponseexecute(MyRequestrequest){
  28. MyResponseresponse=null;
  29. Socketsocket=null;
  30. ObjectOutputStreamoos=null;
  31. ObjectInputStreamois=null;
  33. try{
  34. socket=newSocket();
  35. SocketAddresssocketAddress=newInetSocketAddress(host,port);
  36. socket.connect(socketAddress,10*1000);
  38. oos=newObjectOutputStream(socket.getOutputStream());
  39. oos.writeObject(request);
  40. oos.flush();
  42. ois=newObjectInputStream(socket.getInputStream());
  43. Objectobj=ois.readObject();
  44. if(obj!=null){
  45. response=(MyResponse)obj;
  46. }
  47. }catch(IOExceptionex){
  48. ex.printStackTrace();
  49. }catch(ClassNotFoundExceptionex){
  50. ex.printStackTrace();
  51. }finally{
  52. IOUtil.closeQuietly(ois);
  53. IOUtil.closeQuietly(oos);
  54. IOUtil.closeQuietly(socket);
  55. }
  56. returnresponse;
  57. }
  59. }

MyClientNIOImpl.java
[java] view plain copy print ?
  1. packagecom.googlecode.garbagecan.test.socket.sample10;
  3. importcom.googlecode.garbagecan.test.socket.SerializableUtil;
  5. importjava.io.ByteArrayOutputStream;
  6. importjava.io.IOException;
  7. importjava.net.InetSocketAddress;
  8. importjava.net.SocketAddress;
  9. importjava.nio.ByteBuffer;
  10. importjava.nio.channels.SocketChannel;
  11. importjava.util.logging.Level;
  12. importjava.util.logging.Logger;
  14. publicclassMyClientNIOImplimplementsMyClient{
  16. privatefinalstaticLoggerlogger=Logger.getLogger(MyClientNIOImpl.class.getName());
  18. privateStringhost;
  19. privateintport;
  21. publicMyClientNIOImpl(Stringhost,intport){
  22. this.host=host;
  23. this.port=port;
  24. }
  26. @Override
  27. public<T>Texecute(MyRequestrequest,MyResponseHandler<T>handler){
  28. MyResponseresponse=execute(request);
  29. returnhandler.handle(response);
  30. }
  32. @Override
  33. publicMyResponseexecute(MyRequestrequest){
  34. MyResponseresponse=null;
  35. SocketChannelsocketChannel=null;
  36. try{
  37. socketChannel=SocketChannel.open();
  38. SocketAddresssocketAddress=newInetSocketAddress(host,port);
  39. socketChannel.connect(socketAddress);
  40. sendData(socketChannel,request);
  41. response=receiveData(socketChannel);
  42. }catch(Exceptionex){
  43. logger.log(Level.SEVERE,null,ex);
  44. }finally{
  45. try{
  46. socketChannel.close();
  47. }catch(Exceptionex){}
  48. }
  49. returnresponse;
  50. }
  52. privatevoidsendData(SocketChannelsocketChannel,MyRequestmyRequest)throwsIOException{
  53. byte[]bytes=SerializableUtil.toBytes(myRequest);
  54. ByteBufferbuffer=ByteBuffer.wrap(bytes);
  55. socketChannel.write(buffer);
  56. socketChannel.socket().shutdownOutput();
  57. }
  59. privateMyResponsereceiveData(SocketChannelsocketChannel)throwsIOException{
  60. MyResponsemyResponse=null;
  61. ByteArrayOutputStreambaos=newByteArrayOutputStream();
  63. try{
  64. ByteBufferbuffer=ByteBuffer.allocateDirect(1024);
  65. byte[]bytes;
  66. intcount=0;
  67. while((count=socketChannel.read(buffer))>=0){
  68. buffer.flip();
  69. bytes=newbyte[count];
  70. buffer.get(bytes);
  71. baos.write(bytes);
  72. buffer.clear();
  73. }
  74. bytes=baos.toByteArray();
  75. Objectobj=SerializableUtil.toObject(bytes);
  76. myResponse=(MyResponse)obj;
  77. socketChannel.close();
  78. }finally{
  79. try{
  80. baos.close();
  81. }catch(Exceptionex){}
  82. }
  83. returnmyResponse;
  84. }
  85. }

4. 接下来是MyRequest和MyResponse和MyResponseHandler接口，其中MyRequest接口中定义了四个方法，分别用来获取远程业务逻辑实现类，方法名，参数类型列表和参数列表。MyResponse接口定义了一个方法用来从response类中获取结果。MyResponseHandler接口使用范型的方式来获取最终的结果对象。

MyRequest.java

[java] view plain copy print ?
  1. packagecom.googlecode.garbagecan.test.socket.sample10;
  3. importjava.io.Serializable;
  5. publicinterfaceMyRequestextendsSerializable{
  7. Class<?>getRequestClass();
  9. StringgetRequestMethod();
  11. Class<?>[]getRequestParameterTypes();
  13. Object[]getRequestParameterValues();
  15. }

MyResponse.java
[java] view plain copy print ?
  1. packagecom.googlecode.garbagecan.test.socket.sample10;
  3. importjava.io.Serializable;
  5. publicinterfaceMyResponseextendsSerializable{
  7. ObjectgetResult();
  8. }

MyResponseHandler.java
[java] view plain copy print ?
  1. packagecom.googlecode.garbagecan.test.socket.sample10;
  3. publicinterfaceMyResponseHandler<T>{
  4. Thandle(MyResponseresponse);
  5. }

这几个接口的实现类分别对应MyGenericRequest，MyGenericResponse和MyGenericResponseHandler。

另外这里由于使用的反射类来在服务器端生成service实例，所以目前这里有个限制就是服务器端的Service实现类必须有默认构造函数。当然这是可以重构使其支持更多的方式。比如说支持从工厂方法获取实例，或者根据名字在服务器端直接获取已经创建好的，由于这个例子只是一个简单的原型，所以就不做具体深入的说明和实现了。

MyGenericRequest.java

[java] view plain copy print ?
  1. packagecom.googlecode.garbagecan.test.socket.sample10;
  3. publicclassMyGenericRequestimplementsMyRequest{
  5. privatestaticfinallongserialVersionUID=1L;
  7. privateClass<?>requestClass;
  8. privateStringrequestMethod;
  9. privateClass<?>[]requestParameterTypes;
  10. privateObject[]requestParameterValues;
  12. publicMyGenericRequest(Class<?>requestClass,StringrequestMethod,Class<?>[]requestParameterTypes,Object[]requestParameterValues){
  13. this.requestClass=requestClass;
  14. this.requestMethod=requestMethod;
  15. this.requestParameterTypes=requestParameterTypes;
  16. this.requestParameterValues=requestParameterValues;
  17. }
  19. @Override
  20. publicClass<?>getRequestClass(){
  21. returnrequestClass;
  22. }
  24. @Override
  25. publicStringgetRequestMethod(){
  26. returnrequestMethod;
  27. }
  29. @Override
  30. publicClass<?>[]getRequestParameterTypes(){
  31. returnrequestParameterTypes;
  32. }
  34. @Override
  35. publicObject[]getRequestParameterValues(){
  36. returnrequestParameterValues;
  37. }
  38. }

MyGenericResponse.java
[java] view plain copy print ?
  1. packagecom.googlecode.garbagecan.test.socket.sample10;
  3. publicclassMyGenericResponseimplementsMyResponse{
  5. privateObjectobj=null;
  7. publicMyGenericResponse(Objectobj){
  8. this.obj=obj;
  9. }
  11. @Override
  12. publicObjectgetResult(){
  13. returnobj;
  14. }
  15. }

MyGenericResponseHandler.java
[java] view plain copy print ?
  1. packagecom.googlecode.garbagecan.test.socket.sample10;
  3. publicclassMyGenericResponseHandler<T>implementsMyResponseHandler<T>{
  4. @Override
  5. publicThandle(MyResponseresponse){
  6. return(T)response.getResult();
  7. }
  8. }

5. 下面是两个辅助类

SerializableUtil.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. }

IOUtil.java
[java] view plain copy print ?
  1. packagecom.googlecode.garbagecan.test.socket;
  3. importjava.io.InputStream;
  4. importjava.io.OutputStream;
  5. importjava.net.Socket;
  7. publicclassIOUtil{
  9. publicstaticvoidcloseQuietly(InputStreamis){
  10. try{
  11. is.close();
  12. }catch(Exceptione){
  13. }
  14. }
  16. publicstaticvoidcloseQuietly(OutputStreamos){
  17. try{
  18. os.close();
  19. }catch(Exceptione){
  20. }
  21. }
  23. publicstaticvoidcloseQuietly(Socketsocket){
  24. try{
  25. socket.close();
  26. }catch(Exceptione){
  27. }
  28. }
  29. }

6. 最后是一个测试类，其中包含了两种实现的测试test1()和test2()。其中只是创建server和client的部分不同。下面说一下客户端怎样发送请求并获取服务器端响应。

首先创建一个MyRequest的实例，在其中告诉服务器端希望服务器端使用那个类的那个方法来处理这个相应，然后是参数类型列表和参数列表。 然后使用MyClient的execute()方法来发送上面创建的请求，并获取服务器端响应。也可以使用MyGenericResponseHandler接口来直接获取相应中的结果。

[java] view plain copy print ?
  1. packagecom.googlecode.garbagecan.test.socket.sample10;
  3. importjava.util.List;
  5. publicclassTest{
  7. privatestaticintport=10000;
  9. publicstaticvoidmain(String[]args)throwsException{
  10. //test1();
  11. test2();
  12. }
  14. publicstaticvoidtest1()throwsException{
  15. MyServermyServer=newMyServerSimpleImpl(port);
  16. myServer.startup();
  17. Thread.sleep(3000);
  19. MyClientmyClient=newMyClientSimpleImpl("localhost",port);
  21. MyRequestrequest=null;
  22. MyResponseresponse=null;
  24. request=newMyGenericRequest(MyUserServiceImpl.class,"list",newClass<?>[]{int.class},newObject[]{2});
  25. response=myClient.execute(request);
  26. System.out.println(response.getResult());
  27. List<User>users=myClient.execute(request,newMyGenericResponseHandler<List<User>>());
  28. System.out.println(users);
  30. request=newMyGenericRequest(MyUserServiceImpl.class,"findByName",newClass<?>[]{String.class},newObject[]{"kongxx"});
  31. response=myClient.execute(request);
  32. System.out.println(response.getResult());
  33. Useruser=myClient.execute(request,newMyGenericResponseHandler<User>());
  34. System.out.println(user);
  36. response=myClient.execute(newMyGenericRequest(MyUserServiceImpl.class,"test",newClass<?>[]{},newObject[]{}));
  37. System.out.println(response.getResult());
  38. }
  40. publicstaticvoidtest2()throwsException{
  41. MyServermyServer=newMyServerNIOImpl(port);
  42. myServer.startup();
  43. Thread.sleep(3000);
  45. MyClientmyClient=newMyClientNIOImpl("localhost",port);
  47. MyRequestrequest=null;
  48. MyResponseresponse=null;
  50. request=newMyGenericRequest(MyUserServiceImpl.class,"list",newClass<?>[]{int.class},newObject[]{2});
  51. response=myClient.execute(request);
  52. System.out.println(response.getResult());
  53. List<User>users=myClient.execute(request,newMyGenericResponseHandler<List<User>>());
  54. System.out.println(users);
  56. request=newMyGenericRequest(MyUserServiceImpl.class,"findByName",newClass<?>[]{String.class},newObject[]{"kongxx"});
  57. response=myClient.execute(request);
  58. System.out.println(response.getResult());
  59. Useruser=myClient.execute(request,newMyGenericResponseHandler<User>());
  60. System.out.println(user);
  62. response=myClient.execute(newMyGenericRequest(MyUserServiceImpl.class,"test",newClass<?>[]{},newObject[]{}));
  63. System.out.println(response.getResult());
  64. }
  65. }

iteye_8978
关注
Java网络通信中ServerSocket的设计优化方案
08-26
今天小编就为大家分享一篇关于Java网络通信中ServerSocket的设计优化方案，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
java socket优化_Java Socket编程代码优化
weixin_39622655的博客
02-13 159
1.问题：在学习Java的Socket编程，写了一些代码练习，但是又不知道是否规范，是否有优化的空间？2.代码：package com.nekolr.socket;import com.google.common.util.concurrent.ThreadFactoryBuilder;import java.io.*;import java.net.ServerSocket;import jav...
java socket 优化_Java Socket编程代码优化
weixin_39938165的博客
02-13 131
1.问题：在学习Java的Socket编程，写了一些代码练习，但是又不知道是否规范，是否有优化的空间？2.代码：package com.nekolr.socket;import com.google.common.util.concurrent.ThreadFactoryBuilder;import java.io.*;import java.net.ServerSocket;import jav...
java socket 优化_java socket简单写了一个即时通讯工具(代码有待优化。)
weixin_28814119的博客
02-13 121
package com.supan;import java.net.ServerSocket;import java.net.Socket;public class Server {public static void main(String[] args) throws Exception {ServerSocket server=new ServerSocket(4704);while(tru...
java socket优化_「java socket」详解Java Socket的工作机制 - seo实验室
weixin_42127783的博客
02-24 506
java socket下面的分析主要是参阅了计算机网络(谢希仁第7版)进行总结的，从系统调用—>应用编程接口API—>套接字接口来分析Socket的来龙去脉，当然维基百科上也有对Socket的详细解释1. 系统调用大多数操作系统使用系统调用的机制在应用程序和操作系统之间传递控制权。对程序员来说，系统调用和一般程序设计中的函数调用非常相似2. 应用编程接口API当某个应用进程启动系统调用...
Java Socket实战之二 多线程通信 .
04-06
我们将结合"Java Socket实战之二 多线程通信"这篇博文进行深入解析。 首先，了解Socket的基本概念。Socket在计算机网络中扮演着客户端与服务器之间通信的桥梁角色。它提供了低级别的、面向连接的、基于TCP/IP协议的...
Java高并发异步Socket编程
02-24
DougLee可扩展的网络服务事件驱动Reactor模式基础版多线程版其他变体java.io包中分阻塞IOAPI一览Web服务器，分布式对象系统等等它们的共同特点Read请求解码请求报文业务处理编码响应报文发送响应实际应用中每一个...
Java Socket网络编程.pdf
07-11
Java Socket网络编程是Java平台中的核心特性，它为开发者提供了在TCP/IP协议下创建网络应用的能力。Socket编程主要用于实现客户端和服务器之间的通信，基于客户机/服务器模型。在这个模型中，服务器端通常处于被动...
Socket网络编程进阶与实战 java
最新发布
03-26
Socket网络编程进阶与实战 java
Socket网络编程进阶与实战系统掌握Socket核心技术
07-09
Socket网络编程进阶与实战系统掌握Socket核心技术，本课程将理论结合实践，带你从零开始，系统学习Socket编程技术，让Socket的学习不再那么零散与难以掌握，同时会提炼出Socket网络传输的核心思想与构架，并带你踩坑...
Java_Socket开发高并发小型服务器
10-20
该文档详细描述如何实现高并发编程和运用Socket编程 Socket原理、计算机工作机制、文档包含整个实例源码。详细介绍了整个项目流程
java socket 优化_Java网络通信中ServerSocket的设计优化方案
weixin_29144993的博客
02-13 505
前言：在java的网络通信中，两个不同节点的主机想要进行通信则可以通过建立Socket对象(相当于客户端主机，向服务端请求发送信息)和ServerSocket对象(相当于服务端主机，接收客户端的连接请求并回复信息)实现。1：创建一个Socket对象Socket socket = new Socket("IP",port);指定将要连接的服务端的ip地址和端口号来创建一个Socket对象，在创建结束...
java的socket的坑（陆续补充）
xuemoKingDeath的博客
08-12 387
java的socket断开重连的坑
Java性能优化-04-网络通讯
ycmy2017的博客
02-28 179
java性能优化网络通讯，IO，序列化，通讯协议
TCP协议-Socket连接优化
qq_42538588的博客
05-30 1022
我们探讨Java中Socket连接的性能优化方向分析，以及如何通过优化提高Socket连接的性能。我们分别从代码优化、协议优化和网络优化三个方向阐述了优化的方法和技术，并提出了性能优化的步骤。最后，我们通过数据来说明优化效果，强调了客观评估的重要性。在实践中，我们需要根据具体的应用场景和需求，选择合适的优化方向和方案，并进行相应的调整和改进。同时，我们还需要注意性能优化的成本和收益比，避免过度优化带来的时间和资源浪费。
Java Socket 数据传输 基础以及优化
z1766042975的博客
01-16 896
最近学到Java的TCP的Socket传输数据有些错误和心得在此记下 Java Socket 数据传输 基础以及优化UDP和TCPSocket使用方法总的应用代码,图片传输 UDP和TCP UDP：无连接通信协议，数据的发送端和接收端不用构建逻辑连接（发送时发送端无需确认接收端的存在，接收端无需返回相映给发送端） UDP协议资源消耗小，通信效率高，通常用于音频、视频接收和普通数据的传输 但是又因为UDP面向无连接性，不能保证数据的完整性，因此在传输重要数据的时候不推荐使用UDP协议 TCP：在发送数
使用Java多线程优化基于TCP协议的Server
Dove_Knowledge的博客
08-11 1149
package com.ch10_network; import java.io.IOException; import java.io.OutputStream; import java.io.PrintWriter; import java.net.ServerSocket; import java.net.Socket; import java.util.Date; /** * 给服务
一些小知识小经验（使用java或者c语言实现的socket服务器的优化技巧）
Leaviathan的博客
10-10 2219
CPU使用率总是100%怎么办？ 为什么socket客户端在非正常断开后，服务器在很长一段时间内不会显示客户端断开？（或：为什么保持长连接需要“心跳包”？） 什么是阻塞式IO，什么是非阻塞式IO？区分他们有何用？ 怎么使用java的阻塞式IO实现非阻塞式IO？ 怎么使用c语言实现非阻塞式socket线程？ 服务器怎么在数据库改动后，主动向在线客户端发送数据？
Java Socket实战：打造简易聊天程序
2. **Socket socket**: 当客户端连接后，创建一个Socket对象来与之建立连接。 3. **DataInputStream read** 和 **DataOutputStream write**: 用于在服务器和客户端之间传输数据，读取客户端发送的消息并写入响应。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值