java bean 转为JSON,不依赖于其它第三方库的工具类

这是一个工具类,不依赖于其它第三方的库,用于响应AJAX的请求时,把服务器端的一个对象(一般是POJO类,或是集合),封装成JSON格式,来响应AJAX的请求,也就是把这个对象,原样搬到客户端的浏览器内存中,可以用JS访问。

 

后面有可下载的ZIP包, 内有所有代码,包括测试的类。

伦理电影 www.akdy.cn

这是 JsonUtil类部分:

Java代码   收藏代码
  1. package json;  
  2.   
  3. import java.lang.reflect.Method;  
  4. import java.util.Collection;  
  5. import java.util.Map;  
  6. import java.util.Set;  
  7.   
  8. /**  
  9.  *  
  10.  * JSON 即 JavaScript Object Natation,它是一种轻量级的数据交换格式 除了字符 ",\,/ 
  11.  * 和一些控制符(\b,\f,\n,\r,\t)需要编码外,其他 Unicode 字符可以直接输出 Object 对象在 JSON 中是用 {} 
  12.  * 包含一系列无序的 Key-Value 键值对表示的,实际上此处的 Object 相当于 Java 中的 Map<String, Object>,而不是 
  13.  * Java 的 Class 。注意 Key 只能用 String 表示。 
  14.  *  
  15.  * Prototype提供了 evalJSON() 方法,能直接将服务器返回的 JSON 文本变成一个 JavaScript 变量 
  16.  *  
  17.  *  
  18.  */  
  19. public final class JsonUtil  
  20. {  
  21.   
  22.     /** 
  23.      * 把对象封装为JSON格式 
  24.      *  
  25.      * @param o 
  26.      *            对象 
  27.      * @return JSON格式 
  28.      */  
  29.     @SuppressWarnings("unchecked")  
  30.     public static String toJson(final Object o)  
  31.     {  
  32.         if (o == null)  
  33.         {  
  34.             return "null";  
  35.         }  
  36.         if (o instanceof String) //String  
  37.         {  
  38.             return string2Json((String) o);  
  39.         }  
  40.         if (o instanceof Boolean) //Boolean  
  41.         {  
  42.             return boolean2Json((Boolean) o);  
  43.         }  
  44.         if (o instanceof Number) //Number  
  45.         {  
  46.             return number2Json((Number) o);  
  47.         }  
  48.         if (o instanceof Map) //Map  
  49.         {  
  50.             return map2Json((Map<String, Object>) o);  
  51.         }  
  52.         if (o instanceof Collection) //List  Set  
  53.         {  
  54.             return collection2Json((Collection) o);  
  55.         }  
  56.         if (o instanceof Object[]) //对象数组  
  57.         {  
  58.             return array2Json((Object[]) o);  
  59.         }  
  60.   
  61.         if (o instanceof int[])//基本类型数组  
  62.         {  
  63.             return intArray2Json((int[]) o);  
  64.         }  
  65.         if (o instanceof boolean[])//基本类型数组  
  66.         {  
  67.             return booleanArray2Json((boolean[]) o);  
  68.         }  
  69.         if (o instanceof long[])//基本类型数组  
  70.         {  
  71.             return longArray2Json((long[]) o);  
  72.         }  
  73.         if (o instanceof float[])//基本类型数组  
  74.         {  
  75.             return floatArray2Json((float[]) o);  
  76.         }  
  77.         if (o instanceof double[])//基本类型数组  
  78.         {  
  79.             return doubleArray2Json((double[]) o);  
  80.         }  
  81.         if (o instanceof short[])//基本类型数组  
  82.         {  
  83.             return shortArray2Json((short[]) o);  
  84.         }  
  85.         if (o instanceof byte[])//基本类型数组  
  86.         {  
  87.             return byteArray2Json((byte[]) o);  
  88.         }  
  89.         if (o instanceof Object) //保底收尾对象  
  90.         {  
  91.             return object2Json(o);  
  92.         }  
  93.   
  94.         throw new RuntimeException("不支持的类型: " + o.getClass().getName());  
  95.     }  
  96.   
  97.     /** 
  98.      * 将 String 对象编码为 JSON格式,只需处理好特殊字符 
  99.      *  
  100.      * @param s 
  101.      *            String 对象 
  102.      * @return JSON格式 
  103.      */  
  104.     static String string2Json(final String s)  
  105.     {  
  106.         final StringBuilder sb = new StringBuilder(s.length() + 20);  
  107.         sb.append('\"');  
  108.         for (int i = 0; i < s.length(); i++)  
  109.         {  
  110.             final char c = s.charAt(i);  
  111.             switch (c)  
  112.             {  
  113.             case '\"':  
  114.                 sb.append("\\\"");  
  115.                 break;  
  116.             case '\\':  
  117.                 sb.append("\\\\");  
  118.                 break;  
  119.             case '/':  
  120.                 sb.append("\\/");  
  121.                 break;  
  122.             case '\b':  
  123.                 sb.append("\\b");  
  124.                 break;  
  125.             case '\f':  
  126.                 sb.append("\\f");  
  127.                 break;  
  128.             case '\n':  
  129.                 sb.append("\\n");  
  130.                 break;  
  131.             case '\r':  
  132.                 sb.append("\\r");  
  133.                 break;  
  134.             case '\t':  
  135.                 sb.append("\\t");  
  136.                 break;  
  137.             default:  
  138.                 sb.append(c);  
  139.             }  
  140.         }  
  141.         sb.append('\"');  
  142.         return sb.toString();  
  143.     }  
  144.   
  145.     /** 
  146.      * 将 Number 表示为 JSON格式 
  147.      *  
  148.      * @param number 
  149.      *            Number 
  150.      * @return JSON格式 
  151.      */  
  152.     static String number2Json(final Number number)  
  153.     {  
  154.         return number.toString();  
  155.     }  
  156.   
  157.     /** 
  158.      * 将 Boolean 表示为 JSON格式 
  159.      *  
  160.      * @param bool 
  161.      *            Boolean 
  162.      * @return JSON格式 
  163.      */  
  164.     static String boolean2Json(final Boolean bool)  
  165.     {  
  166.         return bool.toString();  
  167.     }  
  168.   
  169.     /** 
  170.      * 将 Collection 编码为 JSON 格式 (List,Set) 
  171.      *  
  172.      * @param c 
  173.      * @return 
  174.      */  
  175.     static String collection2Json(final Collection<Object> c)  
  176.     {  
  177.         final Object[] arrObj = c.toArray();  
  178.         return toJson(arrObj);  
  179.     }  
  180.   
  181.     /** 
  182.      * 将 Map<String, Object> 编码为 JSON 格式 
  183.      *  
  184.      * @param map 
  185.      * @return 
  186.      */  
  187.     static String map2Json(final Map<String, Object> map)  
  188.     {  
  189.         if (map.isEmpty())  
  190.         {  
  191.             return "{}";  
  192.         }  
  193.         final StringBuilder sb = new StringBuilder(map.size() << 4); //4次方  
  194.         sb.append('{');  
  195.         final Set<String> keys = map.keySet();  
  196.         for (final String key : keys)  
  197.         {  
  198.             final Object value = map.get(key);  
  199.             sb.append('\"');  
  200.             sb.append(key); //不能包含特殊字符  
  201.             sb.append('\"');  
  202.             sb.append(':');  
  203.             sb.append(toJson(value)); //循环引用的对象会引发无限递归  
  204.             sb.append(',');  
  205.         }  
  206.         // 将最后的 ',' 变为 '}':   
  207.         sb.setCharAt(sb.length() - 1'}');  
  208.         return sb.toString();  
  209.     }  
  210.   
  211.     /** 
  212.      * 将数组编码为 JSON 格式 
  213.      *  
  214.      * @param array 
  215.      *            数组 
  216.      * @return JSON 格式 
  217.      */  
  218.     static String array2Json(final Object[] array)  
  219.     {  
  220.         if (array.length == 0)  
  221.         {  
  222.             return "[]";  
  223.         }  
  224.         final StringBuilder sb = new StringBuilder(array.length << 4); //4次方  
  225.         sb.append('[');  
  226.         for (final Object o : array)  
  227.         {  
  228.             sb.append(toJson(o));  
  229.             sb.append(',');  
  230.         }  
  231.         // 将最后添加的 ',' 变为 ']':   
  232.         sb.setCharAt(sb.length() - 1']');  
  233.         return sb.toString();  
  234.     }  
  235.   
  236.     static String intArray2Json(final int[] array)  
  237.     {  
  238.         if (array.length == 0)  
  239.         {  
  240.             return "[]";  
  241.         }  
  242.         final StringBuilder sb = new StringBuilder(array.length << 4);  
  243.         sb.append('[');  
  244.         for (final int o : array)  
  245.         {  
  246.             sb.append(Integer.toString(o));  
  247.             sb.append(',');  
  248.         }  
  249.         // set last ',' to ']':  
  250.         sb.setCharAt(sb.length() - 1']');  
  251.         return sb.toString();  
  252.     }  
  253.   
  254.     static String longArray2Json(final long[] array)  
  255.     {  
  256.         if (array.length == 0)  
  257.         {  
  258.             return "[]";  
  259.         }  
  260.         final StringBuilder sb = new StringBuilder(array.length << 4);  
  261.         sb.append('[');  
  262.         for (final long o : array)  
  263.         {  
  264.             sb.append(Long.toString(o));  
  265.             sb.append(',');  
  266.         }  
  267.         // set last ',' to ']':  
  268.         sb.setCharAt(sb.length() - 1']');  
  269.         return sb.toString();  
  270.     }  
  271.   
  272.     static String booleanArray2Json(final boolean[] array)  
  273.     {  
  274.         if (array.length == 0)  
  275.         {  
  276.             return "[]";  
  277.         }  
  278.         final StringBuilder sb = new StringBuilder(array.length << 4);  
  279.         sb.append('[');  
  280.         for (final boolean o : array)  
  281.         {  
  282.             sb.append(Boolean.toString(o));  
  283.             sb.append(',');  
  284.         }  
  285.         // set last ',' to ']':  
  286.         sb.setCharAt(sb.length() - 1']');  
  287.         return sb.toString();  
  288.     }  
  289.   
  290.     static String floatArray2Json(final float[] array)  
  291.     {  
  292.         if (array.length == 0)  
  293.         {  
  294.             return "[]";  
  295.         }  
  296.         final StringBuilder sb = new StringBuilder(array.length << 4);  
  297.         sb.append('[');  
  298.         for (final float o : array)  
  299.         {  
  300.             sb.append(Float.toString(o));  
  301.             sb.append(',');  
  302.         }  
  303.         // set last ',' to ']':  
  304.         sb.setCharAt(sb.length() - 1']');  
  305.         return sb.toString();  
  306.     }  
  307.   
  308.     static String doubleArray2Json(final double[] array)  
  309.     {  
  310.         if (array.length == 0)  
  311.         {  
  312.             return "[]";  
  313.         }  
  314.         final StringBuilder sb = new StringBuilder(array.length << 4);  
  315.         sb.append('[');  
  316.         for (final double o : array)  
  317.         {  
  318.             sb.append(Double.toString(o));  
  319.             sb.append(',');  
  320.         }  
  321.         // set last ',' to ']':  
  322.         sb.setCharAt(sb.length() - 1']');  
  323.         return sb.toString();  
  324.     }  
  325.   
  326.     static String shortArray2Json(final short[] array)  
  327.     {  
  328.         if (array.length == 0)  
  329.         {  
  330.             return "[]";  
  331.         }  
  332.         final StringBuilder sb = new StringBuilder(array.length << 4);  
  333.         sb.append('[');  
  334.         for (final short o : array)  
  335.         {  
  336.             sb.append(Short.toString(o));  
  337.             sb.append(',');  
  338.         }  
  339.         // set last ',' to ']':  
  340.         sb.setCharAt(sb.length() - 1']');  
  341.         return sb.toString();  
  342.     }  
  343.   
  344.     static String byteArray2Json(final byte[] array)  
  345.     {  
  346.         if (array.length == 0)  
  347.         {  
  348.             return "[]";  
  349.         }  
  350.         final StringBuilder sb = new StringBuilder(array.length << 4);  
  351.         sb.append('[');  
  352.         for (final byte o : array)  
  353.         {  
  354.             sb.append(Byte.toString(o));  
  355.             sb.append(',');  
  356.         }  
  357.         // set last ',' to ']':  
  358.         sb.setCharAt(sb.length() - 1']');  
  359.         return sb.toString();  
  360.     }  
  361.   
  362.     public static String object2Json(final Object bean)  
  363.     {  
  364.         //数据检查  
  365.         if (bean == null)  
  366.         {  
  367.             return "{}";  
  368.         }  
  369.         final Method[] methods = bean.getClass().getMethods(); //方法数组  
  370.         final StringBuilder sb = new StringBuilder(methods.length << 4); //4次方  
  371.         sb.append('{');  
  372.   
  373.         for (final Method method : methods)  
  374.         {  
  375.             try  
  376.             {  
  377.                 final String name = method.getName();  
  378.                 String key = "";  
  379.                 if (name.startsWith("get"))  
  380.                 {  
  381.                     key = name.substring(3);  
  382.   
  383.                     //防死循环  
  384.                     final String[] arrs =  
  385.                     { "Class" };  
  386.                     boolean bl = false;  
  387.                     for (final String s : arrs)  
  388.                     {  
  389.                         if (s.equals(key))  
  390.                         {  
  391.                             bl = true;  
  392.                             continue;  
  393.                         }  
  394.                     }  
  395.                     if (bl)  
  396.                     {  
  397.                         continue//防死循环  
  398.                     }  
  399.                 }  
  400.                 else if (name.startsWith("is"))  
  401.                 {  
  402.                     key = name.substring(2);  
  403.                 }  
  404.                 if (key.length() > 0 && Character.isUpperCase(key.charAt(0)) && method.getParameterTypes().length == 0)  
  405.                 {  
  406.                     if (key.length() == 1)  
  407.                     {  
  408.                         key = key.toLowerCase();  
  409.                     }  
  410.                     else if (!Character.isUpperCase(key.charAt(1)))  
  411.                     {  
  412.                         key = key.substring(01).toLowerCase() + key.substring(1);  
  413.                     }  
  414.                     final Object elementObj = method.invoke(bean);  
  415.   
  416.                     //System.out.println("###" + key + ":" + elementObj.toString());  
  417.   
  418.                     sb.append('\"');  
  419.                     sb.append(key); //不能包含特殊字符  
  420.                     sb.append('\"');  
  421.                     sb.append(':');  
  422.                     sb.append(toJson(elementObj)); //循环引用的对象会引发无限递归  
  423.                     sb.append(',');  
  424.                 }  
  425.             }  
  426.             catch (final Exception e)  
  427.             {  
  428.                 //e.getMessage();  
  429.                 throw new RuntimeException("在将bean封装成JSON格式时异常:" + e.getMessage(), e);  
  430.             }  
  431.         }  
  432.         if (sb.length() == 1)  
  433.         {  
  434.             return bean.toString();  
  435.         }  
  436.         else  
  437.         {  
  438.             sb.setCharAt(sb.length() - 1'}');  
  439.             return sb.toString();  
  440.         }  
  441.     }  
  442.   
  443.     private JsonUtil()  
  444.     {  
  445.     }  
  446. }  

 

你可能感兴趣的:(java bean 转为JSON,不依赖于其它第三方库的工具类)