有時在應用中需要將java物件序列化儲存起來，有的需要壓縮，有的需要加密

EncryptUtil.java

Java程式碼  

1. package org.test.demo;  
2. import java.io.UnsupportedEncodingException;  
3. import java.security.InvalidKeyException;  
4. import java.security.NoSuchAlgorithmException;  
5. import java.security.SecureRandom;  
6. import javax.crypto.BadPaddingException;  
7. import javax.crypto.Cipher;  
8. import javax.crypto.IllegalBlockSizeException;  
9. import javax.crypto.KeyGenerator;  
10. import javax.crypto.NoSuchPaddingException;  
11. import javax.crypto.SecretKey;  
12. import javax.crypto.spec.SecretKeySpec;  
13. public class EncryptUtil {  
14.     private final static String ENCRYPTKEY="0123456789"
    ;  
15.     /** 
16.      *  
17.       * @Title: getEncryptKey 
18.       * @Description: 檢驗加密key  
19.       * @param encryptKey 
20.       * @return 
21.       * String 
22.       * 
23.      */  
24.     private static String getEncryptKey(String encryptKey){  
25.         if(null==encryptKey || "".equals(encryptKey)) return ENCRYPTKEY;  
26.         return encryptKey;  
27.     }  
28.     /** 
29.      *  
30.       * @Title: encrypt 
31.       * @Description: 加密:普通java字串加密成16進位制字串(String -> Byte -> HexStr) 
32.       * @param content 要加密處理的字串 
33.       * @param encryptKey 加密金鑰 
34.       * @return 
35.       * String 
36.       * 
37.      */  
38.     public static String encrypt(String content, String encryptKey){  
39.         byte[] encryptResult = encryptStrToByte(content, getEncryptKey(encryptKey));  
40.         return parseByte2HexStr(encryptResult);  
41.     }  
42.     /** 
43.      *  
44.       * @Title: decrypt 
45.       * @Description: 加密:16進位制字串解密成普通java字串(HexStr -> Byte ->String)  
46.       * @param content 要解密處理的16進位制字串 
47.       * @param encryptKey 解密金鑰 
48.       * @return 
49.       * String 
50.       * 
51.      */  
52.     public static String decrypt(String content, String encryptKey){  
53.         byte[] decryptFrom = parseHexStr2Byte(content);  
54.         byte[] decryptResult = decrypt(decryptFrom,getEncryptKey(encryptKey));  
55.         return new String(decryptResult);  
56.     }  
57.     /** 
58.     * 加密:字串 --> 二進位制 
59.     * @param content 需要加密的內容 
60.     * @param password 加密密碼 
61.     * @return 
62.     */  
63.     private static byte[] encryptStrToByte(String content, String password) {  
64.         try {  
65.             KeyGenerator kgen = KeyGenerator.getInstance("AES");  
66.             kgen.init(128, new SecureRandom(password.getBytes()));  
67.             SecretKey secretKey = kgen.generateKey();  
68.             byte[] enCodeFormat = secretKey.getEncoded();  
69.             SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");  
70.             Cipher cipher = Cipher.getInstance("AES");// 建立密碼器  
71.             byte[] byteContent = content.getBytes("utf-8");  
72.             cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化  
73.             byte[] result = cipher.doFinal(byteContent);  
74.             return result; // 加密  
75.         } catch (NoSuchAlgorithmException e) {  
76.             e.printStackTrace();  
77.         } catch (NoSuchPaddingException e) {  
78.             e.printStackTrace();  
79.         } catch (InvalidKeyException e) {  
80.             e.printStackTrace();  
81.         } catch (UnsupportedEncodingException e) {  
82.             e.printStackTrace();  
83.         } catch (IllegalBlockSizeException e) {  
84.             e.printStackTrace();  
85.         } catch (BadPaddingException e) {  
86.             e.printStackTrace();  
87.         }  
88.         return null;  
89.     }  
90.     /**解密 
91.     * @param content 待解密內容 
92.     * @param password 解密金鑰 
93.     * @return 
94.     */  
95.     private static byte[] decrypt(byte[] content, String password) {  
96.         try {  
97.             KeyGenerator kgen = KeyGenerator.getInstance("AES");  
98.             kgen.init(128, new SecureRandom(password.getBytes()));  
99.             SecretKey secretKey = kgen.generateKey();  
100.             byte[] enCodeFormat = secretKey.getEncoded();  
101.             SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");  
102.             Cipher cipher = Cipher.getInstance("AES");// 建立密碼器  
103.             cipher.init(Cipher.DECRYPT_MODE, key);// 初始化  
104.             byte[] result = cipher.doFinal(content);  
105.             return result; // 加密  
106.         } catch (NoSuchAlgorithmException e) {  
107.             e.printStackTrace();  
108.         } catch (NoSuchPaddingException e) {  
109.             e.printStackTrace();  
110.         } catch (InvalidKeyException e) {  
111.             e.printStackTrace();  
112.         } catch (IllegalBlockSizeException e) {  
113.             e.printStackTrace();  
114.         } catch (BadPaddingException e) {  
115.             e.printStackTrace();  
116.         }  
117.         return null;  
118.     }  
119.     /**將二進位制轉換成16進位制 
120.     * @param buf 
121.     * @return 
122.     */  
123.     private static String parseByte2HexStr(byte buf[]) {  
124.         StringBuffer sb = new StringBuffer();  
125.         for (int i = 0; i < buf.length; i++) {  
126.             String hex = Integer.toHexString(buf[i] & 0xFF);  
127.             if (hex.length() == 1) {  
128.                 hex = '0' + hex;  
129.             }  
130.             sb.append(hex.toUpperCase());  
131.         }  
132.         return sb.toString();  
133.     }  
134.     /** 
135.      * 將16進位制轉換為二進位制 
136.      *  
137.      * @param hexStr 
138.      * @return 
139.      */  
140.     private static byte[] parseHexStr2Byte(String hexStr) {  
141.         if (hexStr.length() < 1)  
142.             return null;  
143.         byte[] result = new byte[hexStr.length() / 2];  
144.         for (int i = 0; i < hexStr.length() / 2; i++) {  
145.             int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);  
146.             int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2),  
147.                     16);  
148.             result[i] = (byte) (high * 16 + low);  
149.         }  
150.         return result;  
151.     }  
152. }  

GZipUtils.java

Java程式碼  

1. package org.test.demo;  
2. import java.io.ByteArrayInputStream;    
3. import java.io.ByteArrayOutputStream;    
4. import java.io.File;    
5. import java.io.FileInputStream;    
6. import java.io.FileOutputStream;    
7. import java.io.IOException;  
8. import java.io.InputStream;    
9. 相關推薦

   java物件序列化、gzip壓縮解壓縮、加密解密

   有時在應用中需要將java物件序列化儲存起來，有的需要壓縮，有的需要加密 EncryptUtil.java Java程式碼   package org.test.demo;   import java.io.UnsupportedE

   Java 物件序列化機制詳解

   物件序列化的目標：將物件儲存到磁碟中，或允許在網路中直接傳輸物件。 物件序列化機制允許把記憶體中的Java物件轉換成平臺無關的二進位制流，從而允許把這種二進位制流持久的儲存在磁碟上，通過網路將這種二進位制流傳輸到另一個網路節點。其他程式一旦獲得了這種二進位制流，都可以講這種

   tar、zip、gzip等解壓縮命令

   解壓縮tar命令：壓縮：tar cf 壓縮後的文件名.tar.gz 壓縮前的文件或者目錄解壓：tar xf 壓縮後的文件名.tar.gz查看壓縮裏的內容：tar tf 壓縮後的文件名.tar.gz zip命令：壓縮目錄：zip –r /opt/etc.zip /etc 解壓：unzip /opt/etc.

   java物件序列化機制

   1.定義 java物件序列化機制允許實現了Serializable/Externalizable介面的java物件永久性地儲存到計算機的磁碟中，或則允許java物件直接在網路中傳輸，擺脫平臺的限制。反序列化即使將IO流中的位元組序列轉化為java物件。 2.原理 3.使用 序列化: 1）一個實現了S

   java - 物件序列化

   在java中可以將物件進行序列化操作 要使物件能夠被序列化，那麼被序列化的物件要實現介面Serializable，此介面位於java.io包中 pakacge demo; import java.io.Serializable; /** * 實現了Serializable 介面的

   java物件序列化與複製圖片

   下面程式碼包括賦值多個圖片，物件的序列化，目的是將物件狀態存入檔案，再把物件狀態從檔案中讀取。 DataInputStream dis; DataOutputStream dos; FileInputStream fi = null;

   記一次使用Jackson對Java物件序列化和反序列化的踩坑經歷

   背景大概是這樣，專案中的兩個服務A和B依賴了同一個common包的Java類，A對該類json序列化，而B對其反序列化。在一次common包升級過程中，這個Java類中增加了一個屬性，由於B其實用不到這個屬性，就只把A給升級打包了，這就導致B在反序列化時出現了一個異常：com.fasterxml.j

   關於 Java 物件序列化您不知道的 5 件事

   關於本系列 您覺得自己懂 Java 程式設計？事實上，大多數程式設計師對於 Java 平臺都是淺嘗則止，只學習了足以完成手頭上任務的知識而已。在本 系列 中，Ted Neward 深入挖掘 Java 平臺的核心功能，揭示一些鮮為人知的事實，幫助您解決最棘手的程式設計挑戰。 大約一年前，一個負責管理應用程式

   Java物件序列化

   什麼是物件序列化？ 物件序列化是指將物件轉換為二進位制資料流的操作，從而使物件的狀態資訊轉換為可以儲存或傳輸的形式。通俗點，我覺得就是把物件的狀態轉換為一個字串（這個字串是亂碼的，誰也看不懂）。 為什麼要有物件序列化？ 比如有一個建立一個物件: Book book=n

   Java 物件序列化方法

   舉個例子直接說明，下面是一個學生物件 import java.io.Serializable; import lombok.Data; import com.baomidou.mybatisplus.enums.IdType; import java.math.BigDecimal; i

   Java 物件序列化和反序列化 （實現 Serializable 介面）

   序列化和反序列化的概念 把物件轉換為位元組序列的過程稱為物件的序列化。 把位元組序列恢復為物件的過程稱為物件的反序列化。 物件的序列化主要有兩種用途： 把物件的位元組序列永久地儲存到硬碟上，通常存放在一個檔案中； 在網路上傳送物件的位元組序列。 JDK

   Java 物件序列化與反序化 (json格式)

   將 物件序列化與反序化 (json格式) 實體類 package com.nf.redisDemo1.entity; public class News { private long id; private String title; private S

   Java深度歷險（十）——Java物件序列化與RMI

   對於一個存在於Java虛擬機器中的物件來說，其內部的狀態只保持在記憶體中。JVM停止之後，這些狀態就丟失了。在很多情況下，物件的內部狀態是需要被持久化下來的。提到持久化，最直接的做法是儲存到檔案系統或是資料庫之中。這種做法一般涉及到自定義儲存格式以及繁瑣的資料轉換。物件關

   java物件序列化並存儲到檔案和資料庫

   Java中要實現將物件儲存起來持久化，需要讓物件實現Serializable介面，這樣就能將java物件用二進位制流儲存並恢復。下面我將以儲存到檔案和儲存到mysql來進行解析。先給出序列化類的定義:package model; import java.io.Seriali

   Java物件序列化原理以及Serializable介面

   Java物件的序列化就是把一個物件變成二進位制的資料流的一中方法，通過物件的序列化可以方便的實現物件的傳輸和儲存。 原理是：物件------------->轉換----------------->將物件轉變為二進位制的資料             在物件序列化時

   理解Java物件序列化

   1. 什麼是Java物件序列化     Java平臺允許我們在記憶體中建立可複用的Java物件，但一般情況下，只有當JVM處於執行時，這些物件才可能存在，即，這些物件的生命週期不會比JVM的生命週期更長。但在現實應用中，就可能要求在JVM停止執行之後能夠儲存(持久化)

   java物件序列化的理解

   JAVA RMI(Remote Method Invocation)遠端方法呼叫 在RMI 中物件和簡單的資料值可以作為方法呼叫的引數和結果傳遞。一個物件就是java類的例項。 java序列化： 將一個物件或一組有關的物件做成適合於磁碟儲存或訊息傳

   理解Java物件序列化——Serializable介面

   概述：當一個類實現了Serializable介面(該介面僅為標記介面,不包含任何方法定義),表示該類可以序列化.序列化的目的是將一個實現了Serializable介面的物件轉換成一個位元組序列,可以。 把該位元組序列儲存起來(例如:儲存在一個檔案裡),以後可以隨時將該位元組序列恢復為原來的物件。甚至可以將該位

   java物件序列化技術

   一、簡介 序列化用於儲存或傳輸物件的資訊。java的API提供了序列換技術，使用簡單，但往往空間佔用大。 Kryo是一個java物件的序列化框架。它的目標是序列化更快、序列化物件更小、簡單易用的API。Kryo可以將物件持久化到檔案、資料庫、或則用於網路傳輸。Kryo可以

   【Java】將Java物件序列化/反序列化為JSON，並寫入redis

   RedisUtil類和spring_config.xml配置檔案在這篇文章：【Redis】Spring整合Redis  中給出了，這裡不再贅述。① 依賴匯入 <!-- fastjson -->