2. 程式人生 > >Java Socket實戰傳輸壓縮物件

Java Socket實戰傳輸壓縮物件

阿新 • • 發佈：2019-02-13

有些情況下比如網路環境不好或者物件比較大的情況下需要把資料物件進行壓縮然後在傳輸，此時就需要壓縮這些物件流，此時就可以GZIPInputStream和GZIPOutputStream來處理一下socket的InputStream和OutputStream。

仍然需要一個實現了java.io.Serializable介面的簡單Java物件

[java] view plaincopyprint?
  1. package com.googlecode.garbagecan.test.socket.sample4;  
  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. }  
package com.googlecode.garbagecan.test.socket.sample4;

public class User implements java.io.Serializable {
	private static final long serialVersionUID = 1L;
	private String name;
	private String password;

	public User() {
		
	}
	
	public User(String name, String password) {
		this.name = name;
		this.password = password;
	}
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}
	
}
在Server端使用，socket的InputStream首先被包裝成GZIPInputStream，然後又被包裝成ObjectInputStream，而socket的OutputStream首先被包裝成GZIPOutputStream，然後又被包裝成ObjectOutputStream，如下： [java] view plaincopyprint?
  1. package com.googlecode.garbagecan.test.socket.sample4;  
  2. import java.io.IOException;  
  3. import java.io.ObjectInputStream;  
  4. import java.io.ObjectOutputStream;  
  5. import java.net.ServerSocket;  
  6. import java.net.Socket;  
  7. import java.util.logging.Level;  
  8. import java.util.logging.Logger;  
  9. import java.util.zip.GZIPInputStream;  
  10. import java.util.zip.GZIPOutputStream;  
  11. publicclass MyServer {  
  12. privatefinalstatic Logger logger = Logger.getLogger(MyServer.class.getName());  
  13. publicstaticvoid main(String[] args) throws IOException {  
  14.         ServerSocket server = new ServerSocket(10000);  
  15. while (true) {  
  16.             Socket socket = server.accept();  
  17.             socket.setSoTimeout(10 * 1000);  
  18.             invoke(socket);  
  19.         }  
  20.     }  
  21. privatestaticvoid invoke(final Socket socket) throws IOException {  
  22. new Thread(new Runnable() {  
  23. publicvoid run() {  
  24.                 GZIPInputStream gzipis = null;  
  25.                 ObjectInputStream ois = null;  
  26.                 GZIPOutputStream gzipos = null;  
  27.                 ObjectOutputStream oos = null;  
  28. try {  
  29.                     gzipis = new GZIPInputStream(socket.getInputStream());  
  30.                     ois = new ObjectInputStream(gzipis);  
  31.                     gzipos = new GZIPOutputStream(socket.getOutputStream());  
  32.                     oos = new ObjectOutputStream(gzipos);  
  33.                     Object obj = ois.readObject();  
  34.                     User user = (User)obj;  
  35.                     System.out.println("user: " + user.getName() + "/" + user.getPassword());  
  36.                     user.setName(user.getName() + "_new");  
  37.                     user.setPassword(user.getPassword() + "_new");  
  38.                     oos.writeObject(user);  
  39.                     oos.flush();  
  40.                     gzipos.finish();  
  41.                 } catch (IOException ex) {  
  42.                     logger.log(Level.SEVERE, null, ex);  
  43.                 } catch(ClassNotFoundException ex) {  
  44.                     logger.log(Level.SEVERE, null, ex);  
  45.                 } finally {  
  46. try {  
  47.                         ois.close();  
  48.                     } catch(Exception ex) {}  
  49. try {  
  50.                         oos.close();  
  51.                     } catch(Exception ex) {}  
  52. try {  
  53.                         socket.close();  
  54.                     } catch(Exception ex) {}  
  55.                 }  
  56.             }  
  57.         }).start();  
  58.     }  
  59. }  
package com.googlecode.garbagecan.test.socket.sample4;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;

public class MyServer {

	private final static Logger logger = Logger.getLogger(MyServer.class.getName());
	
	public static void main(String[] args) throws IOException {
		ServerSocket server = new ServerSocket(10000);

		while (true) {
			Socket socket = server.accept();
			socket.setSoTimeout(10 * 1000);
			invoke(socket);
		}
	}

	private static void invoke(final Socket socket) throws IOException {
		new Thread(new Runnable() {
			public void run() {
				GZIPInputStream gzipis = null;
				ObjectInputStream ois = null;
				GZIPOutputStream gzipos = null;
				ObjectOutputStream oos = null;
				
				try {
					gzipis = new GZIPInputStream(socket.getInputStream());
					ois = new ObjectInputStream(gzipis);
					gzipos = new GZIPOutputStream(socket.getOutputStream());
					oos = new ObjectOutputStream(gzipos);

					Object obj = ois.readObject();
					User user = (User)obj;
					System.out.println("user: " + user.getName() + "/" + user.getPassword());

					user.setName(user.getName() + "_new");
					user.setPassword(user.getPassword() + "_new");

					oos.writeObject(user);
					oos.flush();
					gzipos.finish();
				} catch (IOException ex) {
					logger.log(Level.SEVERE, null, ex);
				} catch(ClassNotFoundException ex) {
					logger.log(Level.SEVERE, null, ex);
				} finally {
					try {
						ois.close();
					} catch(Exception ex) {}
					try {
						oos.close();
					} catch(Exception ex) {}
					try {
						socket.close();
					} catch(Exception ex) {}
				}
			}
		}).start();
	}
}
Client也和Server端類似，同樣要不socket的XXXStream包裝成GZIPXXXStream，然後再包裝成ObjectXXXStream，如下： [java] view plaincopyprint?
  1. package com.googlecode.garbagecan.test.socket.sample4;  
  2. import java.io.IOException;  
  3. import java.io.ObjectInputStream;  
  4. import java.io.ObjectOutputStream;  
  5. import java.net.InetSocketAddress;  
  6. import java.net.Socket;  
  7. import java.net.SocketAddress;  
  8. import java.util.logging.Level;  
  9. import java.util.logging.Logger;  
  10. import java.util.zip.GZIPInputStream;  
  11. import java.util.zip.GZIPOutputStream;  
  12. publicclass MyClient {  
  13. privatefinalstatic Logger logger = Logger.getLogger(MyClient.class.getName());  
  14. publicstaticvoid main(String[] args) throws Exception {  
  15. for (int i = 0; i < 10; i++) {  
  16.             Socket socket = null;  
  17.             GZIPOutputStream gzipos = null;  
  18.             ObjectOutputStream oos = null;  
  19.             GZIPInputStream gzipis = null;  
  20.             ObjectInputStream ois = null;  
  21. try {  
  22.                 socket = new Socket();  
  23.                 SocketAddress socketAddress = new InetSocketAddress("localhost", 10000);   
  24.                 socket.connect(socketAddress, 10 * 1000);  
  25.                 socket.setSoTimeout(10 * 1000);  
  26.                 gzipos = new GZIPOutputStream(socket.getOutputStream());  
  27.                 oos = new ObjectOutputStream(gzipos);  
  28.                 User user = new User("user_" + i, "password_" + i);  
  29.                 oos.writeObject(user);  
  30.                 oos.flush();  
  31.                 gzipos.finish();  
  32.                 gzipis = new GZIPInputStream(socket.getInputStream());  
  33.                 ois = new ObjectInputStream(gzipis);  
  34.                 Object obj = ois.readObject();  
  35. if (obj != null) {  
  36.                     user = (User)obj;  
  37.                     System.out.println("user: " + user.getName() + "/" + user.getPassword());  
  38.                 }  
  39.             } catch(IOException ex) {  
  40.                 logger.log(Level.SEVERE, null, ex);  
  41.             } finally {  
  42. try {  
  43.                     ois.close();  
  44.                 } catch(Exception ex) {}  
  45. try {  
  46.                     oos.close();  
  47.                 } catch(Exception ex) {}  
  48. try {  
  49.                     socket.close();  
  50.                 } catch(Exception ex) {}  
  51.             }  
  52.         }  
  53.     }  
  54. }  
package com.googlecode.garbagecan.test.socket.sample4;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;

public class MyClient {
	
	private final static Logger logger = Logger.getLogger(MyClient.class.getName());
	
	public static void main(String[] args) throws Exception {
		for (int i = 0; i < 10; i++) {
			Socket socket = null;
			GZIPOutputStream gzipos = null;
			ObjectOutputStream oos = null;
			GZIPInputStream gzipis = null;
			ObjectInputStream ois = null;
			
			try {
				socket = new Socket();
				SocketAddress socketAddress = new InetSocketAddress("localhost", 10000); 
				socket.connect(socketAddress, 10 * 1000);
				socket.setSoTimeout(10 * 1000);
				
				gzipos = new GZIPOutputStream(socket.getOutputStream());
				oos = new ObjectOutputStream(gzipos);
				User user = new User("user_" + i, "password_" + i);
				oos.writeObject(user);
				oos.flush();
				gzipos.finish();
				
				gzipis = new GZIPInputStream(socket.getInputStream());
				ois = new ObjectInputStream(gzipis);
				Object obj = ois.readObject();
				if (obj != null) {
					user = (User)obj;
					System.out.println("user: " + user.getName() + "/" + user.getPassword());
				}
			} catch(IOException ex) {
				logger.log(Level.SEVERE, null, ex);
			} finally {
				try {
					ois.close();
				} catch(Exception ex) {}
				try {
					oos.close();
				} catch(Exception ex) {}
				try {
					socket.close();
				} catch(Exception ex) {}
			}
		}
	}
}


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


相關推薦

Java Socket實戰傳輸壓縮物件

有些情況下比如網路環境不好或者物件比較大的情況下需要把資料物件進行壓縮然後在傳輸，此時就需要壓縮這些物件流，此時就可以GZIPInputStream和GZIPOutputStream來處理一下socket的InputStream和OutputStream。 仍然需要一個實現了java.io.Serializ

Java Socket實戰之四 傳輸壓縮物件

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

Java Socket實戰之三 傳輸物件

                前面兩篇文章介紹了怎樣建立Java Socket通訊，這一篇說一下怎樣使用Java Socket來傳輸物件。首先需要一個普通的物件類，由於需要序列化這個物件以便在網路上傳輸，所以實現java.io.Serializable介面就是必不可少的了，入下：package com.go

（轉載）Java Socket實戰之三：傳輸物件

前面兩篇文章介紹了怎樣建立Java Socket通訊，這一篇說一下怎樣使用Java Socket來傳輸物件。 首先需要一個普通的物件類，由於需要序列化這個物件以便在網路上傳輸，所以實現java.io.Serializable介面就是必不可少的了，如下： package com.googlecode.garb

Java Socket實戰之七 使用Socket通訊傳輸檔案

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

Java Socket實戰之一 單執行緒通訊

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

Java Socket實戰之六 使用NIO包實現Socket通訊

前面幾篇文章介紹了使用java.io和java.net類庫實現的Socket通訊，下面介紹一下使用java.nio類庫實現的Socket。 java.nio包是Java在1.4之後增加的，用來提高I/O操作的效率。在nio包中主要包括以下幾個類或介面: * Bu

java Socket 檔案傳輸

客戶端： import java.io.DataOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.net.I

《java併發程式設計實戰》之 物件共享

解決問題： 如何共享和釋出物件，從而使它們能夠安全地由多個執行緒同時訪問 寫多執行緒注意兩點 防止某個執行緒正在使用物件狀態時，而另一個執行緒同時在修改狀態。 確保當一個執行緒修改了物件狀態後，其他執行緒能夠看到狀態變化。（同步的記憶體可見性） 1.可見性

java開發實戰1200例（II）-------312關閉socket快取

package SetTcpNoDelayTest; import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; import javax.swing.JFrame;

java開發實戰1200例（II）--------313使用socket通訊

//伺服器Frame package ServerClientTest; import java.awt.BorderLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListen

java web實現Gzip壓縮傳輸(轉)

為了減少資料在網路中的傳輸量，從而減少傳輸時長，增加使用者體驗，瀏覽器大都是支援Gzip壓縮技術的。http的請求頭 Accept-Encoding:gzip, deflate 就表示這次請求可以接受Gzip壓縮後的資料，但是這隻表示客戶端接受的資料可以是壓縮資

【Java TCP/IP Socket】深入剖析socket——資料傳輸的底層實現

    底層資料結構     如果不理解套接字的具體實現所關聯的資料結構和底層協議的工作細節，就很難抓住網路程式設計的精妙之處，對於TCP套接字來說，更是如此。套接字所關聯的底層的資料結構集包含了

java Socket 使用通用json包 傳送 json物件

在使用json進行socket進行通訊中，由於伺服器使用的json 和 客戶端使用的json版本不同，因此改用通用的json包來通訊。 可以通用，而且不必使用其他的一些需要引入的其他json依賴包 文章中的例子是將一張圖片傳送到伺服器端，伺服器端收到資訊之後返回給客戶端

Java TCP/IP Socket——深入剖析socket—資料傳輸的底層實現

本文轉自：http://blog.csdn.net/ns_code/article/details/15813809 底層資料結構 如果不理解套接字的具體實現所關聯的資料結構和底層協議的工作細節，就很難抓住網路程式設計的精妙之處，對於TCP套接字來說，更是如此。套接

java socket 連線資料傳輸判斷是否結束

Java當中的Socket類,其實是使用TCP協議進行傳輸的.TCP是可靠的一種傳輸協議.  如果想用TCP協議,並且,服務端和客戶端,在沒有資訊進行傳輸的時候,也不斷開連線,一般情況下,客戶端會在Socket超時之前,想服務端傳送一個用於維持連線的資訊包,來維持連線.但是TCP協議,並不是指長連線.我們每

Java Socket程式設計 檔案傳輸（客戶端從伺服器下載一個檔案）

用於客戶端從伺服器端下載檔案 伺服器（Server） package com.socket.sample; import java.io.BufferedInputStream; import java.io.DataInputStream; import java.i

Java Socket通訊 客戶端與伺服器端的連線 和資訊傳輸

一.建立客戶端和伺服器端的連線。 方法分2步： 1.在客戶端建立Socket物件，用來發送連線請求 2.在伺服器端穿件ServerSocket物件，用來接收請求。 //客戶端 public clas

java web實現Gzip壓縮傳輸

為了減少資料在網路中的傳輸量，從而減少傳輸時長，增加使用者體驗，瀏覽器大都是支援Gzip壓縮技術的。http的請求頭 Accept-Encoding:gzip, deflate 就表示這次請求可以接受Gzip壓縮後的資料，但是這隻表示客戶端接受的資料可以是壓縮資

java併發程式設計實戰：組合物件筆記

設計執行緒安全的類 設計一個執行緒安全的類要報案下面三個要素： 1. 找出構成物件的狀態的所有變數。 - 物件的所有域構成了物件的狀態。如果物件的域是基本變數構成，那麼這些域構成了物件的全部狀態。如果物件的域中引用了其他物件，那麼物件的狀態也包含其引用物件的域。如ArrayLis