JavaSocket实战之三：传输对象

前面两篇文章介绍了怎样建立Java Socket通信，这一篇说一下怎样使用Java Socket来传输对象。

创新互联公司成立十年来，这条路我们正越走越好，积累了技术与客户资源，形成了良好的口碑。为客户提供网站制作、网站建设、网站策划、网页设计、域名注册、网络营销、VI设计、网站改版、漏洞修补等服务。网站是否美观、功能强大、用户体验好、性价比高、打开快等等，这些对于网站建设都非常重要，创新互联公司通过对建站技术性的掌握、对创意设计的研究为客户提供一站式互联网解决方案，携手广大客户，共同发展进步。

首先需要一个普通的对象类，由于需要序列化这个对象以便在网络上传输，所以实现java.io.Serializable接口就是必不可少的了，如下：

 
 
 
    
  
  
  
  1. package com.googlecode.garbagecan.test.socket.sample3;  
    2.   
  
  
  2.  
    3.   
  
  
  3. public class User implements java.io.Serializable {  
    4.   
  
  
  4.     private static final long serialVersionUID = 1L;  
    5.   
  
  
  5.     private String name;  
    6.   
  
  
  6.     private String password;  
    7.   
  
  
  7.  
    8.   
  
  
  8.     public User() {  
    9.   
  
  
  9.           
    10.   
  
  
  10.     }  
    11.   
  
  
  11.       
    12.   
  
  
  12.     public User(String name, String password) {  
    13.   
  
  
  13.         this.name = name;  
    14.   
  
  
  14.         this.password = password;  
    15.   
  
  
  15.     }  
    16.   
  
  
  16.       
    17.   
  
  
  17.     public String getName() {  
    18.   
  
  
  18.         return name;  
    19.   
  
  
  19.     }  
    20.   
  
  
  20.  
    21.   
  
  
  21.     public void setName(String name) {  
    22.   
  
  
  22.         this.name = name;  
    23.   
  
  
  23.     }  
    24.   
  
  
  24.  
    25.   
  
  
  25.     public String getPassword() {  
    26.   
  
  
  26.         return password;  
    27.   
  
  
  27.     }  
    28.   
  
  
  28.  
    29.   
  
  
  29.     public void setPassword(String password) {  
    30.   
  
  
  30.         this.password = password;  
    31.   
  
  
  31.     }  
    32.   
  
  
  32. } 
    33.

对于Server端的代码，代码中分别使用了ObjectInputStream和ObjectOutputStream来接收和发送socket中的InputStream和OutputStream，然后转换成Java对象，如下：

 
 
 
    
  
  
  
  1. package com.googlecode.garbagecan.test.socket.sample3;  
    2.   
  
  
  2.  
    3.   
  
  
  3. import java.io.*;  
    4.   
  
  
  4. import java.net.ServerSocket;  
    5.   
  
  
  5. import java.net.Socket;  
    6.   
  
  
  6. import java.util.logging.Level;  
    7.   
  
  
  7. import java.util.logging.Logger;  
    8.   
  
  
  8.  
    9.   
  
  
  9. public class MyServer {  
    10.   
  
  
  10.  
    11.   
  
  
  11.     private final static Logger logger = Logger.getLogger(MyServer.class.getName());  
    12.   
  
  
  12.       
    13.   
  
  
  13.     public static void main(String[] args) throws IOException {  
    14.   
  
  
  14.         ServerSocket server = new ServerSocket(10000);  
    15.   
  
  
  15.  
    16.   
  
  
  16.         while (true) {  
    17.   
  
  
  17.             Socket socket = server.accept();  
    18.   
  
  
  18.             invoke(socket);  
    19.   
  
  
  19.         }  
    20.   
  
  
  20.     }  
    21.   
  
  
  21.  
    22.   
  
  
  22.     private static void invoke(final Socket socket) throws IOException {  
    23.   
  
  
  23.         new Thread(new Runnable() {  
    24.   
  
  
  24.             public void run() {  
    25.   
  
  
  25.                 ObjectInputStream is = null;  
    26.   
  
  
  26.                 ObjectOutputStream os = null;  
    27.   
  
  
  27.                 try {  
    28.   
  
  
  28.                     is = new ObjectInputStream(new BufferedInputStream(socket.getInputStream()));  
    29.   
  
  
  29.                     os = new ObjectOutputStream(socket.getOutputStream());  
    30.   
  
  
  30.  
    31.   
  
  
  31.                     Object obj = is.readObject();  
    32.   
  
  
  32.                     User user = (User)obj;  
    33.   
  
  
  33.                     System.out.println("user: " + user.getName() + "/" + user.getPassword());  
    34.   
  
  
  34.  
    35.   
  
  
  35.                     user.setName(user.getName() + "_new");  
    36.   
  
  
  36.                     user.setPassword(user.getPassword() + "_new");  
    37.   
  
  
  37.  
    38.   
  
  
  38.                     os.writeObject(user);  
    39.   
  
  
  39.                     os.flush();  
    40.   
  
  
  40.                 } catch (IOException ex) {  
    41.   
  
  
  41.                     logger.log(Level.SEVERE, null, ex);  
    42.   
  
  
  42.                 } catch(ClassNotFoundException ex) {  
    43.   
  
  
  43.                     logger.log(Level.SEVERE, null, ex);  
    44.   
  
  
  44.                 } finally {  
    45.   
  
  
  45.                     try {  
    46.   
  
  
  46.                         is.close();  
    47.   
  
  
  47.                     } catch(Exception ex) {}  
    48.   
  
  
  48.                     try {  
    49.   
  
  
  49.                         os.close();  
    50.   
  
  
  50.                     } catch(Exception ex) {}  
    51.   
  
  
  51.                     try {  
    52.   
  
  
  52.                         socket.close();  
    53.   
  
  
  53.                     } catch(Exception ex) {}  
    54.   
  
  
  54.                 }  
    55.   
  
  
  55.             }  
    56.   
  
  
  56.         }).start();  
    57.   
  
  
  57.     }  
    58.   
  
  
  58. } 
    59.

Client也和Server端类似，同样使用ObjectOutputStream和ObjectInputStream来处理，如下：

 
 
 
    
  
  
  
  1. package com.googlecode.garbagecan.test.socket.sample3;  
    2.   
  
  
  2.  
    3.   
  
  
  3. import java.io.BufferedInputStream;  
    4.   
  
  
  4. import java.io.IOException;  
    5.   
  
  
  5. import java.io.ObjectInputStream;  
    6.   
  
  
  6. import java.io.ObjectOutputStream;  
    7.   
  
  
  7. import java.net.Socket;  
    8.   
  
  
  8. import java.util.logging.Level;  
    9.   
  
  
  9. import java.util.logging.Logger;  
    10.   
  
  
  10.  
    11.   
  
  
  11. public class MyClient {  
    12.   
  
  
  12.       
    13.   
  
  
  13.     private final static Logger logger = Logger.getLogger(MyClient.class.getName());  
    14.   
  
  
  14.       
    15.   
  
  
  15.     public static void main(String[] args) throws Exception {  
    16.   
  
  
  16.         for (int i = 0; i < 100; i++) {  
    17.   
  
  
  17.             Socket socket = null;  
    18.   
  
  
  18.             ObjectOutputStream os = null;  
    19.   
  
  
  19.             ObjectInputStream is = null;  
    20.   
  
  
  20.               
    21.   
  
  
  21.             try {  
    22.   
  
  
  22.                 socket = new Socket("localhost", 10000);  
    23.   
  
  
  23.       
    24.   
  
  
  24.                 os = new ObjectOutputStream(socket.getOutputStream());  
    25.   
  
  
  25.                 User user = new User("user_" + i, "password_" + i);  
    26.   
  
  
  26.                 os.writeObject(user);  
    27.   
  
  
  27.                 os.flush();  
    28.   
  
  
  28.                   
    29.   
  
  
  29.                 is = new ObjectInputStream(new BufferedInputStream(socket.getInputStream()));  
    30.   
  
  
  30.                 Object obj = is.readObject();  
    31.   
  
  
  31.                 if (obj != null) {  
    32.   
  
  
  32.                     user = (User)obj;  
    33.   
  
  
  33.                     System.out.println("user: " + user.getName() + "/" + user.getPassword());  
    34.   
  
  
  34.                 }  
    35.   
  
  
  35.             } catch(IOException ex) {  
    36.   
  
  
  36.                 logger.log(Level.SEVERE, null, ex);  
    37.   
  
  
  37.             } finally {  
    38.   
  
  
  38.                 try {  
    39.   
  
  
  39.                     is.close();  
    40.   
  
  
  40.                 } catch(Exception ex) {}  
    41.   
  
  
  41.                 try {  
    42.   
  
  
  42.                     os.close();  
    43.   
  
  
  43.                 } catch(Exception ex) {}  
    44.   
  
  
  44.                 try {  
    45.   
  
  
  45.                     socket.close();  
    46.   
  
  
  46.                 } catch(Exception ex) {}  
    47.   
  
  
  47.             }  
    48.   
  
  
  48.         }  
    49.   
  
  
  49.     }  
    50.   
  
  
  50. } 
    51.

***测试上面的代码，首先运行Server类，然后运行Client类，就可以分别在Server端和Client端控制台看到接收到的User对象实例了。

原文链接：http://blog.csdn.net/kongxx/article/details/7259827

文章名称：JavaSocket实战之三：传输对象
标题路径：http://www.csdahua.cn/qtweb/news45/224695.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

品牌网站建设知识

行业网站建设

旅游网站建设方案　　 　成都网站推广公司　　 　成都做商城网站　　 　成都商城开发　　 　成都网络推广　　 　贵阳托管服务器　　 　java虚拟主机　　 　成都网站推广　　 　成都外贸网站建设　　 　网络推广　　 　重庆app软件开发　　 　酒柜书柜鞋柜定制　　 　雅安机房托管　　 　腾讯免备案空间　　 　zaowang.cn　　 　物流公司网站建设方案　　 　成都小程序开发　　 　彭州网站建设　　 　云服务器　　 　资阳做网站