基于Gson的json转换工具类

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang3.StringUtils;

import java.io.UnsupportedEncodingException;

/**
 * Json处理工具类
 * 
 * @author ljz
 *
 */
public class JsonUtils {
   
   /**
    * 对象转换为Json字符串
    * @param obj
    * @return
    */
   public static String toJson(Object obj){
      Gson gson = new Gson();
      
      return gson.toJson(obj);
   }
   
   /**
    * 通过Json字符串转换为指定对象
    * @param jsonData
    * @param type
    * @return
    */
   public static <T> T fromJson(String jsonData, Class<T> type){
      Gson gson = new Gson();
      
      return gson.fromJson(jsonData, type);
   }
   
   /**
    * 对象转换为base64加密字符串
    * 
    * @param enc 使用编码
    * @return 对象的json的base64加密串
    * @throws UnsupportedEncodingException 
    */
   public static String toJsonWithBase64(Object obj, String enc) {
      //对象转换成Json字符串
      String jsonStr = JsonUtils.toJson(obj);
      String jsonStrWithBase64 = null;
      
      try {
         //base64加密
         jsonStrWithBase64 = Base64.encodeBase64String(jsonStr.getBytes(enc));
      } catch (UnsupportedEncodingException e){
         throw new RuntimeException(e);
      }
      
      return jsonStrWithBase64;
   }
   
   /**
    * base64加密字符串转换为对象
    * 
    * @param enc 使用编码
    * @return 对象的json的base64加密串
    * @throws UnsupportedEncodingException 
    */
   public static <T> T fromJsonWithBase64(String base64JsonData, Class<T> type, String enc) {
      //对象转换成Json字符串
      String jsonStrWithBase64 = null;
      
      try {
         //base64加密
         jsonStrWithBase64 = new String(Base64.decodeBase64(base64JsonData.getBytes(enc)), enc);
      } catch (UnsupportedEncodingException e){
         throw new RuntimeException(e);
      }
      
      T obj = JsonUtils.fromJson(jsonStrWithBase64, type);
      
      return obj;
   }
   
   /**
    * 对象转换为base64加密字符串（使用UTF-8编码）
    * 
    * @return 对象的json的base64加密串
    * @throws UnsupportedEncodingException 
    */
   public static String toJsonWithBase64(Object obj) {
      return JsonUtils.toJsonWithBase64(obj, "UTF-8");
   }
   
   /**
    * base64加密字符串转换为对象（使用UTF-8编码）
    * 
    * @return 对象的json的base64加密串
    * @throws UnsupportedEncodingException 
    */
   public static <T> T fromJsonWithBase64(String base64JsonData, Class<T> type) {
      return JsonUtils.fromJsonWithBase64(base64JsonData, type, "UTF-8");
   }
   
   public static void main(String[] args) {
      System.out.println(Base64.decodeBase64("111111".getBytes()));
   }
   
   /**
     * 格式化
     * @param jsonStr
     * @return
     */
    public static String formatJson(String jsonStr) {
        if (StringUtils.isBlank(jsonStr)) return "";
        StringBuilder sb = new StringBuilder();
        char last = '\0';
        char current = '\0';
        int indent = 0;
        for (int i = 0; i < jsonStr.length(); i++) {
            last = current;
            current = jsonStr.charAt(i);
            switch (current) {
                case '{':
                case '[':
                    sb.append(current);
                    sb.append('\n');
                    indent++;
                    addIndentBlank(sb, indent);
                    break;
                case '}':
                case ']':
                    sb.append('\n');
                    indent--;
                    addIndentBlank(sb, indent);
                    sb.append(current);
                    break;
                case ',':
                    sb.append(current);
                    if (last != '\\') {
                        sb.append('\n');
                        addIndentBlank(sb, indent);
                    }
                    break;
                default:
                    sb.append(current);
            }
        }

        return sb.toString();
    }
    
    /**
     * 添加space
     * @param sb
     * @param indent
     */
    private static void addIndentBlank(StringBuilder sb, int indent) {
        for (int i = 0; i < indent; i++) {
            sb.append('\t');
        }
    }
    
    public static String fromBase64WithJson(String base64JsonData) {
        // 对象转换成Json字符串
        String jsonStrWithBase64 = null;
        try {
            // base64解密
            jsonStrWithBase64 = new String(Base64.decodeBase64(base64JsonData.getBytes("utf-8")), "utf-8");
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException(e);
        }
        return jsonStrWithBase64;
    }
    
    /**
     * 通过Json字符串转换为指定对象
     * @param jsonData
     * @param type
     * @return
     */
    public static <T> T fromJsonToDate(String jsonData, Class<T> type) {
        GsonBuilder builder = new GsonBuilder();
        builder.setDateFormat("yyyy-MM-dd HH:mm:ss");
        Gson gson = builder.create();
        return gson.fromJson(jsonData, type);
    }
    
    public static <T> T fromJsonsToDate(String jsonData, Class<T> type) {
       GsonBuilder builder = new GsonBuilder();
       builder.setDateFormat("yyyy-MM-dd");
       Gson gson = builder.create();
       return gson.fromJson(jsonData, type);
    }
}