前面兩篇文章介紹了怎樣建立Java Socket通訊，這一篇說一下怎樣使用Java Socket來傳輸物件。

首先需要一個普通的物件類，由於需要序列化這個物件以便在網路上傳輸，所以實現java.io.Serializable介面就是必不可少的了，如下：

1. package com.googlecode.garbagecan.test.socket.sample3;  
2. publicclass User implements java.io.Serializable {  
3. privatestaticfinallong serialVersionUID = 1L;  
4. private String name;  
5. private String password;  
6. public User() {  
7.     }  
8. public User(String name, String password) {  
9. this.name = name;  
10. this.password = password;  
11.     }  
12. public String getName() {  
13. return name;  
14.     }  
15. publicvoid setName(String name) {  
16. this.name = name;  
17.     }  
18. public
     String getPassword() {  
19. return password;  
20.     }  
21. publicvoid setPassword(String password) {  
22. this.password = password;  
23.     }  
24. } 

對於Server端的程式碼，程式碼中分別使用了ObjectInputStream和ObjectOutputStream來接收和傳送socket中的InputStream和OutputStream，然後轉換成Java物件，如下：

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

Client也和Server端類似，同樣使用ObjectOutputStream和ObjectInputStream來處理，如下：

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

最後測試上面的程式碼，首先執行Server類，然後執行Client類，就可以分別在Server端和Client端控制檯看到接收到的User物件例項了。