程序博客网 > 数据线线接口有哪几种

自定义JSON与Object互转工具类（一）

来源：互联网 发布：数据线线接口有哪几种 编辑：程序博客网 时间：2024/06/03 17:02

在服务器与客户端交互的过程中，使用JSON格式的数据传输已经是相当普遍的选择。

谷歌也专门为之提供了GSON包。

这里我们不讨论GSON的使用，而是自定义一个工具类，来实现JSON与Object之间的互转。

废话不多说，先来看一个实例：

首先定义一个POJO对象User

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. public class User {  
  2.     private int id;  
  3.     private String name;  
  4.     private String pwd;  
  5.     public int getId() {  
  6.         return id;  
  7.     }  
  8.     public void setId(int id) {  
  9.         this.id = id;  
  10.     }  
  11.     public String getName() {  
  12.         return name;  
  13.     }  
  14.     public void setName(String name) {  
  15.         this.name = name;  
  16.     }  
  17.     public String getPwd() {  
  18.         return pwd;  
  19.     }  
  20.     public void setPwd(String pwd) {  
  21.         this.pwd = pwd;  
  22.     }  
  23.     @Override  
  24.     public String toString() {  
  25.         return "User [id=" + id + ", name=" + name + ", pwd=" + pwd + "]";  
  26.     }  
  27. }  

测试：

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. public static void main(String[] args) {  
  2.     User user = new User();  
  3.     user.setId(1);  
  4.     user.setName("Fancyy");  
  5.     user.setPwd("123456");  
  6.       
  7.     String json = JSON.toJson(user);  
  8.       
  9.     System.out.println(JSON.format(json));  
  10. }  
输出结果：
[plain] view plaincopy在CODE上查看代码片派生到我的代码片
  1. {  
  2.   "id"   : "1",  
  3.   "name" : "Fancyy",  
  4.   "pwd"  : "123456"  
  5. }  

是不是很方便。


继续测试：

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. public static void main(String[] args) {  
  2.     User user = new User();  
  3.     user.setId(1);  
  4.     user.setName("Fancyy");  
  5.     user.setPwd("123456");  
  6.       
  7.     String json = JSON.toJson(user);  
  8.       
  9.     User userCopy = (User) JSON.toObject(json, User.class);  
  10.     System.out.println(userCopy);  
  11. }  
输出结果：

[plain] view plaincopy在CODE上查看代码片派生到我的代码片
  1. User [id=1, name=Fancyy, pwd=123456]  
是不是又回来了！


好的，下面让我们定义一个复杂一点的POJO实体类

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. public class News {  
  2.     private int id;  
  3.     private String title;  
  4.     private String content;  
  5.     private User author;  
  6.     private List<User> reader;  
  7.     public int getId() {  
  8.         return id;  
  9.     }  
  10.     public void setId(int id) {  
  11.         this.id = id;  
  12.     }  
  13.     public String getTitle() {  
  14.         return title;  
  15.     }  
  16.     public void setTitle(String title) {  
  17.         this.title = title;  
  18.     }  
  19.     public String getContent() {  
  20.         return content;  
  21.     }  
  22.     public void setContent(String content) {  
  23.         this.content = content;  
  24.     }  
  25.     public User getAuthor() {  
  26.         return author;  
  27.     }  
  28.     public void setAuthor(User author) {  
  29.         this.author = author;  
  30.     }  
  31.     public List<User> getReader() {  
  32.         return reader;  
  33.     }  
  34.     public void setReader(List<User> reader) {  
  35.         this.reader = reader;  
  36.     }  
  37.     @Override  
  38.     public String toString() {  
  39.         return "News [author=" + author + ", content=" + content + ", id=" + id  
  40.                 + ", reader=" + reader + ", title=" + title + "]";  
  41.     }  
  42. }  


继续测试：

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. public static void main(String[] args) {  
  2.     News news = new News();  
  3.     news.setId(1);  
  4.     news.setTitle("新年放假通知");  
  5.     news.setContent("从今天开始放假啦。");  
  6.     news.setAuthor(createAuthor());  
  7.     news.setReader(createReaders());  
  8.       
  9.     String json = JSON.toJson(news);  
  10.       
  11.     System.out.println(JSON.format(json));  
  12. }  
  13.   
  14. private static List<User> createReaders() {  
  15.     List<User> readers = new ArrayList<User>();  
  16.     User readerA = new User();  
  17.     readerA.setId(2);  
  18.     readerA.setName("Jack");  
  19.     readers.add(readerA);  
  20.       
  21.     User readerB = new User();  
  22.     readerB.setId(1);  
  23.     readerB.setName("Lucy");  
  24.     readers.add(readerB);  
  25.       
  26.     return readers;  
  27. }  
  28.   
  29. private static User createAuthor() {  
  30.     User author = new User();  
  31.     author.setId(1);  
  32.     author.setName("Fancyy");  
  33.     author.setPwd("123456");  
  34.     return author;  
  35. }  
输出结果：
[plain] view plaincopy在CODE上查看代码片派生到我的代码片
  1. {  
  2.   "id"      : "1",  
  3.   "title"   : "新年放假通知",  
  4.   "content" : "从今天开始放假啦。",  
  5.   "author"  : {  
  6.     "id"      : "1",  
  7.     "name"    : "Fancyy",  
  8.     "pwd"     : "123456"  
  9.   },  
  10.   "reader"  : [  
  11.     {  
  12.       "id"      : "2",  
  13.       "name"    : "Jack"  
  14.     },  
  15.     {  
  16.       "id"      : "1",  
  17.       "name"    : "Lucy"  
  18.     }  
  19.   ]  
  20. }  
继续反向测试：

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. public static void main(String[] args) {  
  2.     News news = new News();  
  3.     news.setId(1);  
  4.     news.setTitle("新年放假通知");  
  5.     news.setContent("从今天开始放假啦。");  
  6.     news.setAuthor(createAuthor());  
  7.     news.setReader(createReaders());  
  8.       
  9.     String json = JSON.toJson(news);  
  10.       
  11.     News newsCopy = (News) JSON.toObject(json, News.class);  
  12.       
  13.     System.out.println(newsCopy);  
  14. }  

输出结果：

[plain] view plaincopy在CODE上查看代码片派生到我的代码片
  1. News [author=User [id=1, name=Fancyy, pwd=123456], content=从今天开始放假啦。, id=1, reader=[User [id=2, name=Jack, pwd=null], User [id=1, name=Lucy, pwd=null]], title=新年放假通知]  

完美反转。


在看看对于List对象的解析情况：

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. public static void main(String[] args) {  
  2.     List<User> users = new ArrayList<User>();  
  3.     for (int i = 0; i < 3; i++) {  
  4.         User user = new User();  
  5.         user.setId(i);  
  6.         user.setName("Fancyy_" + i);  
  7.         user.setPwd("FancyyPwd_" + i);  
  8.         users.add(user);  
  9.     }  
  10.     String json = JSON.toJson(users);  
  11.     System.out.println(JSON.format(json));  
  12. }  
输出结果：
[plain] view plaincopy在CODE上查看代码片派生到我的代码片
  1. [  
  2.   {  
  3.     "id"   : "0",  
  4.     "name" : "Fancyy_0",  
  5.     "pwd"  : "FancyyPwd_0"  
  6.   },  
  7.   {  
  8.     "id"   : "1",  
  9.     "name" : "Fancyy_1",  
  10.     "pwd"  : "FancyyPwd_1"  
  11.   },  
  12.   {  
  13.     "id"   : "2",  
  14.     "name" : "Fancyy_2",  
  15.     "pwd"  : "FancyyPwd_2"  
  16.   }  
  17. ]  
反转结果呢：

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. public static void main(String[] args) {  
  2.     List<User> users = new ArrayList<User>();  
  3.     for (int i = 0; i < 3; i++) {  
  4.         User user = new User();  
  5.         user.setId(i);  
  6.         user.setName("Fancyy_" + i);  
  7.         user.setPwd("FancyyPwd_" + i);  
  8.         users.add(user);  
  9.     }  
  10.     String json = JSON.toJson(users);  
  11.     List<User> usersCopy = (List<User>) JSON.toObject(json, User.class);  
  12.     System.out.println(usersCopy);  
  13. }  
输出：

[plain] view plaincopy在CODE上查看代码片派生到我的代码片
  1. [User [id=0, name=Fancyy_0, pwd=FancyyPwd_0], User [id=1, name=Fancyy_1, pwd=FancyyPwd_1], User [id=2, name=Fancyy_2, pwd=FancyyPwd_2]]  

是不是各种都很方便。

下面贴出JSON类源码：

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. public class JSON {  
  2.     /** 
  3.      * JSON字符串转成Object对象<br> 
  4.      * 此方法假设没有把子类当成父类去使用<br> 
  5.      * 不然会出现解析出来的对象没有子类属性<br> 
  6.      * @param json 
  7.      * @param clazz 
  8.      * @return 
  9.      */  
  10.     public static Object toObject(String json, Class<?> clazz) {  
  11.         return toObject(json, clazz, null, null);  
  12.     }  
  13.       
  14.     /** 
  15.      * JSON字符串转成Object对象<br> 
  16.      * 此方法可以把子类当成父类去使用<br> 
  17.      * 但是需要提供一个map<br> 
  18.      * 告诉程序对应的(子)类<br> 
  19.      * @param json 
  20.      * @param map 
  21.      * @return 
  22.      */  
  23.     public static Object toObject(String json, Map<String,String> map) {  
  24.         return toObject(json, null, null, map);  
  25.     }  
  26.       
  27.     /** 
  28.      * JSON字符串转成Object对象<br> 
  29.      * 此方法可以把子类当成父类去使用<br> 
  30.      * 但是需要提供一个基础的basePackage<br> 
  31.      * 并且在生成JSON的时候,也需要传入这个basePackage 
  32.      * @param json 
  33.      * @return 
  34.      */  
  35.     public static Object toObject(String json, String basePackage) {  
  36.         return toObject(json, null, basePackage, null);  
  37.     }  
  38.       
  39.     /** 
  40.      * JSON字符串转成Object对象<br> 
  41.      * 此方法可以把子类当成父类去使用<br> 
  42.      * 但是需要提供一个基础的basePackage<br> 
  43.      * 并且在生成JSON的时候,也需要传入这个basePackage 
  44.      * @param json 
  45.      * @return 
  46.      */  
  47.     public static Object toObject(String json, Class<?> clazz, String basePackage) {  
  48.         return toObject(json, clazz, basePackage, null);  
  49.     }  
  50.       
  51.     /** 
  52.      * Object对象转成JSON字符串<br> 
  53.      * 此方法假设没有把子类当成父类去使用<br> 
  54.      * 不然反转的时候可能会出现解析出来的对象没有子类属性<br> 
  55.      * @param obj 
  56.      * @return 
  57.      */  
  58.     public static String toJson(Object obj) {   
  59.         return toJson(obj, null, false);  
  60.     }  
  61.       
  62.     /** 
  63.      * Object对象转成JSON字符串<br> 
  64.      * 对应反转方法：toObject(String json, Map<String,String> map) 
  65.      * @param obj 
  66.      * @param createClassInfo 
  67.      * @return 
  68.      */  
  69.     public static String toJson(Object obj, boolean createClassInfo) {   
  70.         return toJson(obj, null, createClassInfo);  
  71.     }  
  72.       
  73.     /** 
  74.      * Object对象转成JSON字符串<br> 
  75.      * 对应反转方法：toObject(String json, String basePackage) 
  76.      * @param obj 
  77.      * @return 
  78.      */  
  79.     public static String toJson(Object obj, String basePackage) {   
  80.         return toJson(obj, basePackage, false);  
  81.     }  
  82.       
  83.     public static String format(String json) {  
  84.         String fillStringUnit = "  ";  
  85.         if (json == null || json.trim().length() == 0) {  
  86.             return null;  
  87.         }  
  88.   
  89.         int fixedLenth = 0;  
  90.         ArrayList<String> tokenList = new ArrayList<String>();  
  91.         {  
  92.             String jsonTemp = json;  
  93.             // 预读取  
  94.             while (jsonTemp.length() > 0) {  
  95.                 String token = getToken(jsonTemp);  
  96.                 jsonTemp = jsonTemp.substring(token.length());  
  97.                 token = token.trim();  
  98.                 tokenList.add(token);  
  99.             }  
  100.         }  
  101.   
  102.         for (int i = 0; i < tokenList.size(); i++) {  
  103.             String token = tokenList.get(i);  
  104.             int length = token.getBytes().length;  
  105.             if (length > fixedLenth && i < tokenList.size() - 1  
  106.                     && tokenList.get(i + 1).equals(":")) {  
  107.                 fixedLenth = length;  
  108.             }  
  109.         }  
  110.   
  111.         StringBuilder buf = new StringBuilder();  
  112.         int count = 0;  
  113.         for (int i = 0; i < tokenList.size(); i++) {  
  114.   
  115.             String token = tokenList.get(i);  
  116.   
  117.             if (token.equals(",")) {  
  118.                 buf.append(token);  
  119.                 doFill(buf, count, fillStringUnit);  
  120.                 continue;  
  121.             }  
  122.             if (token.equals(":")) {  
  123.                 buf.append(" ").append(token).append(" ");  
  124.                 continue;  
  125.             }  
  126.             if (token.equals("{")) {  
  127.                 String nextToken = tokenList.get(i + 1);  
  128.                 if (nextToken.equals("}")) {  
  129.                     i++;  
  130.                     buf.append("{ }");  
  131.                 } else {  
  132.                     count++;  
  133.                     buf.append(token);  
  134.                     doFill(buf, count, fillStringUnit);  
  135.                 }  
  136.                 continue;  
  137.             }  
  138.             if (token.equals("}")) {  
  139.                 count--;  
  140.                 doFill(buf, count, fillStringUnit);  
  141.                 buf.append(token);  
  142.                 continue;  
  143.             }  
  144.             if (token.equals("[")) {  
  145.                 String nextToken = tokenList.get(i + 1);  
  146.                 if (nextToken.equals("]")) {  
  147.                     i++;  
  148.                     buf.append("[ ]");  
  149.                 } else {  
  150.                     count++;  
  151.                     buf.append(token);  
  152.                     doFill(buf, count, fillStringUnit);  
  153.                 }  
  154.                 continue;  
  155.             }  
  156.             if (token.equals("]")) {  
  157.                 count--;  
  158.                 doFill(buf, count, fillStringUnit);  
  159.                 buf.append(token);  
  160.                 continue;  
  161.             }  
  162.   
  163.             buf.append(token);  
  164.             // 左对齐  
  165.             if (i < tokenList.size() - 1 && tokenList.get(i + 1).equals(":")) {  
  166.                 int fillLength = fixedLenth - token.getBytes().length;  
  167.                 if (fillLength > 0) {  
  168.                     for (int j = 0; j < fillLength; j++) {  
  169.                         buf.append(" ");  
  170.                     }  
  171.                 }  
  172.             }  
  173.         }  
  174.         return buf.toString();  
  175.     }  
  176.       
  177.     /** 
  178.      *  
  179.      * @param json 
  180.      *            JSONObject的字符串形式 
  181.      * @param clazz 
  182.      *            Object的class 
  183.      * @return 
  184.      */  
  185.     private static final String ENTER_REPLACE_STR = "\\n";  
  186.     private static Object toObject(String json, Class<?> clazz, String basePackage, Map<String,String> map) {  
  187.         if (json == null || json.equals("")) {  
  188.             return json;  
  189.         } else {  
  190.             json = json.replace("\r\n", ENTER_REPLACE_STR).replace("\n", ENTER_REPLACE_STR);  
  191.         }  
  192.         Object object = null;  
  193.         try {  
  194.             if (json.charAt(0) == '[') {  
  195.                 object = toList(json, clazz, basePackage, map);  
  196.             } else if (json.charAt(0) == '{'){  
  197.                 JSONObject infoObject = new JSONObject(json);  
  198.                 //  
  199.                 //  
  200.                 if (infoObject.has("class")) {  
  201.                     String className = infoObject.getString("class");  
  202.                     if (className != null) {  
  203.                         if (map != null && map.get(className) != null) {  
  204.                             clazz = Class.forName(map.get(className));  
  205.                         } else if (basePackage != null) {  
  206.                             clazz = Class.forName(basePackage + className);  
  207.                         }  
  208.                     }  
  209.                 }  
  210.                 if (clazz == null) {  
  211.                     throw new NullPointerException("clazz, basePackage, map不能全部为空。");  
  212.                 }  
  213.                 object = clazz.newInstance();  
  214.                 //  
  215.                 //  
  216.                 Iterator<?> iterator = infoObject.keys();  
  217.                 while (iterator.hasNext()) {  
  218.                     String key = (String) iterator.next();  
  219.                     Object fieldValue = null;  
  220.                     List<Field> fields = getAllFields(null, clazz);  
  221.                     for (int i = 0; i < fields.size(); i++) {  
  222.                         Field field = fields.get(i);  
  223.                         if (field.getName().equalsIgnoreCase(key)) {  
  224.                             field.setAccessible(true);  
  225.                             fieldValue = getFieldValue(field, infoObject, key, basePackage, map);  
  226.                             if (null != fieldValue) {  
  227.                                 field.set(object, fieldValue);  
  228.                             }  
  229.                             field.setAccessible(false);  
  230.                         }  
  231.                     }  
  232.                 }  
  233.             } else {  
  234.                 return json;  
  235.             }  
  236.         } catch (Exception e) {  
  237.             KLog.e("=====JSON EXCEPTION=====", e);  
  238.         }  
  239.         if (object instanceof List<?>) {  
  240.             List<?> list = (List<?>) object;  
  241.             for (int i = 0; i < list.size(); i++) {  
  242.                 replaceObjectBr(list.get(i));  
  243.             }  
  244.         } else {  
  245.             replaceObjectBr(object);  
  246.         }  
  247.         return object;  
  248.     }  
  249.       
  250.     /** 
  251.      *  
  252.      * @param json 
  253.      *            JSONArray的字符串形式 
  254.      * @param clazz 
  255.      *            List内对象的class 
  256.      * @return 
  257.      */  
  258.     private static List<?> toList(String json, Class<?> clazz, String basePackage, Map<String,String> map) {  
  259.         List<Object> list = null;  
  260.         try {  
  261.             JSONArray jsonArray = (JSONArray) new JSONArray(json);  
  262.             list = new ArrayList<Object>();  
  263.             for (int i = 0; i < jsonArray.length(); i++) {  
  264.                 String jsonvalue = jsonArray.getJSONObject(i).toString();  
  265.                 switch (getJSONType(jsonvalue)) {  
  266.                 case JSON_TYPE_OBJECT: {  
  267. /*                  JSONObject subObject = new JSONObject(jsonvalue); 
  268.                     Class<?> newClazz = null; 
  269.                     if (subObject.has("class")) { 
  270.                         String className = subObject.getString("class"); 
  271.                         if (className != null) { 
  272.                             if (map != null && map.get(className) != null) { 
  273.                                 newClazz = Class.forName(map.get(className)); 
  274.                             } else if (basePackage != null) { 
  275.                                 newClazz = Class.forName(basePackage + className); 
  276.                             } 
  277.                         } 
  278.                     }*/  
  279.                     list.add(toObject(jsonvalue, clazz, basePackage, map));  
  280.                     break;  
  281.                 }  
  282.                 case JSON_TYPE_ARRAY: {  
  283.                     List<?> infoList = toList(jsonvalue, clazz, basePackage, map);  
  284.                     list.add(infoList);  
  285.                     break;  
  286.                 }  
  287.                 default:  
  288.                     break;  
  289.                 }  
  290.             }  
  291.         } catch (Exception e) {  
  292.             KLog.e("=====JSON EXCEPTION=====", e);  
  293.         }  
  294.         return list;  
  295.     }  
  296.       
  297.     private static String toJson(Object obj, String basePackage, boolean createClass) {  
  298.         if (obj instanceof String) {  
  299.             return obj.toString();  
  300.         } else {  
  301.             StringBuffer xmlBuffer = new StringBuffer("");  
  302.             if (obj instanceof List<?>) {  
  303.                 xmlBuffer.append("[");  
  304.                 List<?> list = (List<?>) obj;  
  305.                 for (int i = 0; i < list.size(); i++) {  
  306.                     addObjectToBuffer(xmlBuffer, list.get(i), basePackage, createClass);  
  307.                     if (i < list.size() - 1) {  
  308.                         xmlBuffer.append(",");  
  309.                     }  
  310.                 }  
  311.                 xmlBuffer.append("]");  
  312.             } else {  
  313.                 addObjectToBuffer(xmlBuffer, obj, basePackage, createClass);  
  314.             }  
  315.             return xmlBuffer.toString();  
  316.         }  
  317.     }  
  318.       
  319.     /** 
  320.      * 在JSON->Object的时候 
  321.      * 根据JSON的键(key) 
  322.      * 生成Field的值(value) 
  323.      * @param field 
  324.      * @param infoObject 
  325.      * @param key 
  326.      * @param basePackage 
  327.      * @return 
  328.      * @throws Exception 
  329.      */  
  330.     private static Object getFieldValue(Field field, JSONObject infoObject, String key, String basePackage, Map<String,String> map) throws Exception {  
  331.         Object fieldValue = null;  
  332.         Class<?> fieldClass = field.getType();  
  333.         if (fieldClass.getSimpleName().toString().equals("int")  
  334.                 || fieldClass.getSimpleName().toString().equals(  
  335.                         "Integer")) {  
  336.             fieldValue = infoObject.getInt(key);  
  337.         } else if (fieldClass.getSimpleName().toString()  
  338.                 .equalsIgnoreCase("String")) {  
  339.             fieldValue = infoObject.getString(key);  
  340.         } else if (fieldClass.getSimpleName().toString()  
  341.                 .equalsIgnoreCase("double")) {  
  342.             fieldValue = infoObject.getDouble(key);  
  343.         } else if (fieldClass.getSimpleName().toString()  
  344.                 .equalsIgnoreCase("boolean")) {  
  345.             fieldValue = infoObject.getBoolean(key);  
  346.         } else if (fieldClass.getSimpleName().toString()  
  347.                 .equalsIgnoreCase("long")) {  
  348.             fieldValue = infoObject.getLong(key);  
  349.         } else if (fieldClass.getSimpleName().toString()  
  350.                 .equalsIgnoreCase("Date")) {  
  351.             fieldValue = DateFormatUtil.toDate(infoObject.getString(key));  
  352.         } else {  
  353.             String jsonvalue = infoObject.getString(key);  
  354.             switch (getJSONType(jsonvalue)) {  
  355.             case JSON_TYPE_OBJECT: {  
  356.                 fieldValue = toObject(jsonvalue, fieldClass, basePackage, map);  
  357.                 break;  
  358.             }  
  359.             case JSON_TYPE_ARRAY: {  
  360.                 // 获取泛型的class  
  361.                 Type genericFieldType = field.getGenericType();  
  362.                 if (genericFieldType instanceof ParameterizedType) {  
  363.                     ParameterizedType aType = (ParameterizedType) genericFieldType;  
  364.                     Type[] fieldArgTypes = aType  
  365.                             .getActualTypeArguments();  
  366.                     for (Type fieldArgType : fieldArgTypes) {  
  367.                         Class<?> fieldArgClass = (Class<?>) fieldArgType;  
  368. //                      if (map != null && map.get(key) != null) {  
  369. //                          fieldArgClass = Class.forName(map.get(key));  
  370. //                      }  
  371.                         fieldValue = toList(jsonvalue, fieldArgClass, basePackage, map);  
  372.                     }  
  373.                 }  
  374.                 break;  
  375.             }  
  376.             default:  
  377.                 break;  
  378.             }  
  379.         }  
  380.         return fieldValue;  
  381.     }  
  382.       
  383.     private static List<Field> getAllFields(List<Field> fields, Class<?> clazz) {  
  384.         if (fields == null) {  
  385.             fields = new ArrayList<Field>();  
  386.         }  
  387.         try {  
  388.             if (clazz.getSuperclass() != null) {  
  389.                 Field[] fieldsSelf = clazz.getDeclaredFields();  
  390.                 for (Field field : fieldsSelf) {  
  391.                     if (!Modifier.isFinal(field.getModifiers())) {  
  392.                         fields.add(field);  
  393.                     }  
  394.                 }  
  395.                 getAllFields(fields, clazz.getSuperclass());  
  396.             }  
  397.         } catch (Exception e) {  
  398.             KLog.e("=====JSON Exception=====", e);  
  399.         }  
  400.         return fields;  
  401.     }  
  402.       
  403.     private static void addObjectToBuffer(StringBuffer xmlBuffer, Object obj, String basePackage, boolean createClass) {  
  404.         xmlBuffer.append("{");  
  405.         // 获取所有属性  
  406.         List<Field> fields = new ArrayList<Field>();  
  407.         getAllFields(fields, obj.getClass());  
  408.         for (int i = -1; i < fields.size(); i++) {  
  409.             if (i == -1) {  
  410.                 if (basePackage != null || createClass) {  
  411.                     // 加入类信息  
  412.                     xmlBuffer.append("\"");  
  413.                     xmlBuffer.append("class");  
  414.                     xmlBuffer.append("\":");  
  415.                     xmlBuffer.append("\"");  
  416.                     if (basePackage != null) {  
  417.                         xmlBuffer.append(obj.getClass().getName().replace(basePackage, ""));  
  418.                     } else {  
  419.                         xmlBuffer.append(obj.getClass().getSimpleName());  
  420.                     }  
  421.                     xmlBuffer.append("\",");  
  422.                 }  
  423.                 continue;  
  424.             }  
  425.             Field field = fields.get(i);  
  426.             String fieldName = field.getName();  
  427.             // 拼接GET方法名  
  428.             Object fieldValue = null;  
  429.             Method method = null;  
  430.             try {  
  431.                 String methodName = "get" + ((char) (fieldName.charAt(0) - 32))  
  432.                         + fieldName.substring(1);  
  433.                 // System.out.println("methodName->" + methodName);  
  434.                 method = obj.getClass().getMethod(methodName);  
  435.             } catch (Exception e) {  
  436.                 String methodName = "is" + ((char) (fieldName.charAt(0) - 32))  
  437.                         + fieldName.substring(1);  
  438.                 try {  
  439.                     method = obj.getClass().getMethod(methodName);  
  440.                 } catch (Exception e1) {  
  441.                     KLog.e("=====To JSON Object Exception=====", e);  
  442.                 }  
  443.             }  
  444.             if (method != null) {  
  445.                 try {  
  446.                     fieldValue = method.invoke(obj);  
  447.                 } catch (Exception e) {  
  448.                     KLog.e("=====To JSON Object Exception=====", e);  
  449.                 }  
  450.             }  
  451.             if (null != fieldValue) {  
  452.                 xmlBuffer.append("\"");  
  453.                 xmlBuffer.append(fieldName);  
  454.                 xmlBuffer.append("\":");  
  455.                 if (fieldValue instanceof Date) {  
  456.                     xmlBuffer.append("\"");  
  457.                     xmlBuffer.append((DateFormatUtil.toTimeFormat((Date) fieldValue)));  
  458.                     xmlBuffer.append("\"");  
  459.                 } else if (fieldValue instanceof Integer  
  460.                         || fieldValue instanceof Double  
  461.                         || fieldValue instanceof Long  
  462.                         || fieldValue instanceof Boolean) {  
  463.                     xmlBuffer.append("\"");  
  464.                     xmlBuffer.append(fieldValue.toString());  
  465.                     xmlBuffer.append("\"");  
  466.                 } else if (fieldValue instanceof String) {  
  467.                     xmlBuffer.append("\"");  
  468.                     String str = fieldValue.toString();  
  469.                     xmlBuffer.append(str);  
  470.                     xmlBuffer.append("\"");  
  471.                 } else if (fieldValue instanceof List<?>) {  
  472.                     addListToBuffer(xmlBuffer, fieldValue, basePackage, createClass);  
  473.                 } else {  
  474.                     addObjectToBuffer(xmlBuffer, fieldValue, basePackage, createClass);  
  475.                 }  
  476.                 xmlBuffer.append(",");  
  477.             }  
  478.             if (i == fields.size() - 1 && xmlBuffer.charAt(xmlBuffer.length() - 1) == ',') {  
  479.                 xmlBuffer.deleteCharAt(xmlBuffer.length() - 1);  
  480.             }  
  481.         }  
  482.         xmlBuffer.append("}");  
  483.     }  
  484.   
  485.     private static void addListToBuffer(StringBuffer xmlBuffer, Object fieldvalue, String basePackage,boolean createClass) {  
  486.         xmlBuffer.append("[");  
  487.         List<?> v_list = (List<?>) fieldvalue;  
  488.         for (int i = 0; i < v_list.size(); i++) {  
  489.             addObjectToBuffer(xmlBuffer, v_list.get(i), basePackage, createClass);  
  490.             if (i < v_list.size() - 1) {  
  491.                 xmlBuffer.append(",");  
  492.             }  
  493.         }  
  494.         xmlBuffer.append("]");  
  495.     }  
  496.   
  497.     private static JSON_TYPE getJSONType(String str) {  
  498.         final char[] strChar = str.substring(0, 1).toCharArray();  
  499.         final char firstChar = strChar[0];  
  500.         if (firstChar == '{') {  
  501.             return JSON_TYPE.JSON_TYPE_OBJECT;  
  502.         } else if (firstChar == '[') {  
  503.             return JSON_TYPE.JSON_TYPE_ARRAY;  
  504.         } else {  
  505.             return JSON_TYPE.JSON_TYPE_ERROR;  
  506.         }  
  507.     }  
  508.   
  509.     private static String getToken(String json) {  
  510.         StringBuilder buf = new StringBuilder();  
  511.         boolean isInYinHao = false;  
  512.         while (json.length() > 0) {  
  513.             String token = json.substring(0, 1);  
  514.             json = json.substring(1);  
  515.   
  516.             if (!isInYinHao  
  517.                     && (token.equals(":") || token.equals("{")  
  518.                             || token.equals("}") || token.equals("[")  
  519.                             || token.equals("]") || token.equals(","))) {  
  520.                 if (buf.toString().trim().length() == 0) {  
  521.                     buf.append(token);  
  522.                 }  
  523.   
  524.                 break;  
  525.             }  
  526.   
  527.             if (token.equals("\\")) {  
  528.                 buf.append(token);  
  529.                 buf.append(json.substring(0, 1));  
  530.                 json = json.substring(1);  
  531.                 continue;  
  532.             }  
  533.             if (token.equals("\"")) {  
  534.                 buf.append(token);  
  535.                 if (isInYinHao) {  
  536.                     break;  
  537.                 } else {  
  538.                     isInYinHao = true;  
  539.                     continue;  
  540.                 }  
  541.             }  
  542.             buf.append(token);  
  543.         }  
  544.         return buf.toString();  
  545.     }  
  546.   
  547.     private static void doFill(StringBuilder buf, int count, String fillStringUnit) {  
  548.         buf.append("\n");  
  549.         for (int i = 0; i < count; i++) {  
  550.             buf.append(fillStringUnit);  
  551.         }  
  552.     }  
  553.       
  554.     /** 
  555.      * 替换掉/n  
  556.      * @param obj 此Object不可以是List 
  557.      */  
  558.     private static void replaceObjectBr(Object obj) {  
  559.         // 获取所有属性  
  560.         Field[] fields = obj.getClass().getDeclaredFields();  
  561.         for (int i = 0; i < fields.length; i++) {  
  562.             Field field = fields[i];  
  563.             if (!Modifier.isFinal(field.getModifiers())) {  
  564.                 continue;  
  565.             }  
  566.             field.setAccessible(true);  
  567.             Object fieldValue = null;  
  568.             try {  
  569.                 fieldValue = field.get(obj);  
  570.                 if (fieldValue instanceof Integer) {  
  571.                 } else if (fieldValue instanceof Double) {  
  572.                 } else if (fieldValue instanceof Boolean) {  
  573.                 } else if (fieldValue instanceof Long) {  
  574.                 } else if (fieldValue instanceof Date) {  
  575.                 } else if (fieldValue instanceof String) {  
  576.                     if (fieldValue != null) {  
  577.                         String str = fieldValue.toString();  
  578.                         field.set(obj, str.replaceAll(ENTER_REPLACE_STR, "\n"));  
  579.                     }  
  580.                 }else if (fieldValue instanceof List<?>) {  
  581.                     if (fieldValue != null) {  
  582.                         List<?> list = (List<?>) fieldValue;  
  583.                         for (int j = 0; j < list.size(); j++) {  
  584.                             replaceObjectBr(list.get(j));  
  585.                         }  
  586.                     }  
  587.                 } else {  
  588.                     if (fieldValue != null) {  
  589.                         replaceObjectBr(fieldValue);  
  590.                     }  
  591.                 }  
  592.             } catch (Exception e) {  
  593.                 KLog.e("=====JSON Exception=====", e);  
  594.             } finally {  
  595.                 field.setAccessible(false);  
  596.             }  
  597.         }  
  598.     }  
  599.   
  600.     private enum JSON_TYPE {  
  601.         /** JSONObject */  
  602.         JSON_TYPE_OBJECT,  
  603.         /** JSONArray */  
  604.         JSON_TYPE_ARRAY,  
  605.         /** 不是JSON格式的字符串 */  
  606.         JSON_TYPE_ERROR  
  607.     }  
  608. }  


 

3 0
数据线线接口有哪几种 数据线线接口有哪几种
原创粉丝点击
热门IT博客
表格制作软件手机软件表格制作软件手机软件
数据库开发需要学什么数据库开发需要学什么
苏州十大网络教育机构
暗黑三 数据挖掘员
淘宝微淘的好处
us域名注册
淘宝极速退款怎么用
伦敦银交易软件
sql语言具有查询功能吗
淘宝买家恶意申请退款
数据库审计产品资料
淘宝客服资料
炉石传说大数据
windows xp iis配置
java返回值怎么调用
卡iphone7plus在线软件
淘宝店铺地址是什么
win10上安装mac虚拟机
it专业课程
一维数组
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 方块消消乐 消消乐技巧 果冻消消乐 宾杲消消乐 数字消消乐 消消乐有多少关卡 消诮乐 情侣消消乐 水果消消乐闯关版 破解版消消乐 消消乐四星关卡 消消乐在线玩 萌宠消消乐 消消乐730 消消乐360版 消消乐360账号登陆 农场消消乐 萌果消消乐 消乐 旋转消消乐 宝石消消乐 消消乐351关怎么过 消消乐一共多少关 天天消消乐辅助 消消乐2 360消消乐 消消乐多少关 冰雪消消乐 下载消消乐新版本 消消乐单机 消消乐四星攻略 消消乐753关怎么过 免费消消乐 动物消消乐 消消乐在线 曲奇消消乐 消消乐无限 新版消消乐下载 萌萌消消乐下载 迷你消消乐 升心消消乐

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里