自己编写的一个Json工具类，实现了反射将整个Object转换为Json对象的功能，支持Hibernate的延迟加载对象[修订081217]

最后更新：09-02-08
bug fix:支持了Hibernate one-to-many映射到List的处理


由于Json自己的String转换有问题，无法正确的转换中文为uxxxx的字符，因此改用DWR包内的JavascriptUtil处理String类型。可以直接引用，还可以拆离出来，因为仅是一个转换工具类，跟DWR的没有依赖关系。这样就可以采用ISO-8859-1编码来传递所有UNICODE了。

 代码：  

 

 

1. package com.aherp.framework.util;
3. import org.json.JSONString;
5. public class JSONStringObject implements JSONString {
7.     private String jsonString = null;
8.     
9.     public JSONStringObject(String jsonString){
10.         this.jsonString = jsonString;
11.     }
13.     @Override
14.     public String toString() {
15.         return jsonString;
16.     }
18.     public String toJSONString() {
19.         return jsonString;
20.     }
21. }

 

 

1. package com.aherp.framework.util;
3. import java.lang.reflect.Array;
4. import java.lang.reflect.Method;
5. import java.util.Calendar;
6. import java.util.Date;
7. import java.util.Map;
8. import java.util.Map.Entry;
10. import org.json.JSONArray;
11. import org.json.JSONException;
12. import org.json.JSONObject;
13. import org.json.JSONString;
15. /**
16.  * JSON工具类，反射的方式转换整个对象
17.  * @author Jim Wu
18.  *
19.  */
20. public class JSONUtil {
22.     private static JSONUtil instance = null;
23.     
24.     public JSONUtil(){}
25.     
26.     /**
27.      * 代理类是否输出的检查，返回true则允许继续转换
28.      * @param bean
29.      * @return 是否允许继续转换
30.      */
31.     protected boolean canProxyOutput(Object bean) {
32.         return true;
33.     }
35.     /**
36.      * 代理类时做的检查.返回应该检查的对象.
37.      * @param bean
38.      * @return 实际获取的对象 
39.      */
40.     protected Object proxyConvert(Object bean){
41.         return bean;
42.     }
45.     static public String toJSONString(Object obj) throws JSONException{
46.         return toJSONString(obj, false);
47.     }
48.     
49.     static public String toJSONString(Object obj, boolean useClassConvert) throws JSONException{
50.         if(instance == null)
51.             instance = new JSONUtil();
52.         return instance.getJSONObject(obj, useClassConvert).toString();
53.     }
55.     @SuppressWarnings("unchecked")
56.     private String getJSONArray(Object arrayObj, boolean useClassConvert) throws JSONException{
57.         
58.         if(arrayObj == null)
59.             return "null";
60.         
61.         arrayObj = proxyConvert(arrayObj);
62.         
63.         JSONArray jSONArray = new JSONArray();
64.         if(arrayObj instanceof Iterable){
65.             for(Object rowObj: ((Iterable)arrayObj)){
66.                 if(canProxyOutput(rowObj)){
67.                     if(rowObj == null)
68.                         jSONArray.put(new JSONStringObject(null));
69.                     else if(rowObj.getClass().isArray() || rowObj instanceof Iterable)
70.                         jSONArray.put(getJSONArray(rowObj, useClassConvert));
71.                     else
72.                         jSONArray.put(getJSONObject(rowObj, useClassConvert));
73.                 }
74.             }
75.         }
76.         if(arrayObj.getClass().isArray()){
77.             int arrayLength = Array.getLength(arrayObj);
78.             for(int i = 0; i < arrayLength; i ++){
79.                 Object rowObj = Array.get(arrayObj, i);
80.                 if(canProxyOutput(rowObj)){
81.                     if(rowObj == null)
82.                         jSONArray.put(new JSONStringObject(null));
83.                     else if(rowObj.getClass().isArray() || rowObj instanceof Iterable)
84.                         jSONArray.put(getJSONArray(rowObj, useClassConvert));
85.                     else
86.                         jSONArray.put(getJSONObject(rowObj, useClassConvert));
87.                 }
88.             }
89.         }
90.         return jSONArray.toString();
91.     }
93.     @SuppressWarnings("unchecked")
94.     JSONStringObject getJSONObject(Object value, boolean useClassConvert) throws JSONException{
96.         //处理原始类型
97.         if (value == null) {
98.             return new JSONStringObject("null");
99.         }
100.         value = proxyConvert(value);
101.         if (value instanceof JSONString) {
102.             Object o;
103.             try {
104.                 o = ((JSONString)value).toJSONString();
105.             } catch (Exception e) {
106.                 throw new JSONException(e);
107.             }
108.             throw new JSONException("Bad value from toJSONString: " + o);
109.         }
110.         if (value instanceof Number) {
111.             return new JSONStringObject(JSONObject.numberToString((Number) value));
112.         }
113.         if (value instanceof Boolean || value instanceof JSONObject ||
114.                 value instanceof JSONArray) {
115.             return new JSONStringObject(value.toString());
116.         }
117.         if (value instanceof String)
118.             return new JSONStringObject('"' + JavascriptUtil.escapeJavaScript(value.toString()) + '"');
119.         if (value instanceof Map) {
120.             
121.             JSONObject jSONObject = new JSONObject();
123.             for(Object rowObj: ((Map)value).entrySet()){
124.                 Entry entry = (Entry)rowObj;
125.                 Object valueObj = entry.getValue();
126.                 if(canProxyOutput(valueObj))
127.                     jSONObject.put(entry.getKey().toString(), getJSONObject(valueObj, useClassConvert));
128.             }
130.             return new JSONStringObject(jSONObject.toString());
131.         }
132.         if(value instanceof Date){
133.             Calendar calendar = Calendar.getInstance();
134.             calendar.setTime(calendar.getTime());
135.             StringBuilder sb = new StringBuilder("new Date(");
136.             sb.append(calendar.get(Calendar.YEAR));
137.             sb.append(",");
138.             sb.append(calendar.get(Calendar.MONTH));
139.             sb.append(",");
140.             sb.append(calendar.get(Calendar.DAY_OF_MONTH));
141.             sb.append(",");
142.             sb.append(calendar.get(Calendar.HOUR_OF_DAY));
143.             sb.append(",");
144.             sb.append(calendar.get(Calendar.MINUTE));
145.             sb.append(",");
146.             sb.append(calendar.get(Calendar.SECOND));
147.             sb.append(")");
148.             return new JSONStringObject(sb.toString());
149.         }
151.         //class
152.         if(value instanceof Class)
153.             return new JSONStringObject(JavascriptUtil.escapeJavaScript(((Class)value).getSimpleName()));
154.         
155.         //数组
156.         if (value instanceof Iterable || value.getClass().isArray()) {
157.             return new JSONStringObject(getJSONArray(proxyConvert(value), useClassConvert));
158.         }
160.         return reflectObject(value, useClassConvert);
161.     }
163.     @SuppressWarnings("unchecked")
164.     private JSONStringObject reflectObject(Object bean, boolean useClassConvert){
165.         JSONObject jSONObject = new JSONObject();
167.         Class klass = bean.getClass();
168.         for (Method method: klass.getMethods()) {
169.             try {
170.                 String name = method.getName();
171.                 String key = "";
172.                 if (name.startsWith("get")) {
173.                     key = name.substring(3);
174.                 } else if (name.startsWith("is")) {
175.                     key = name.substring(2);
176.                 }
177.                 if (key.length() > 0 &
178.                         Character.isUpperCase(key.charAt(0)) &
179.                         method.getParameterTypes().length == 0) {
180.                     if (key.length() == 1) {
181.                         key = key.toLowerCase();
182.                     } else if (!Character.isUpperCase(key.charAt(1))) {
183.                         key = key.substring(0, 1).toLowerCase() +
184.                             key.substring(1);
185.                     }
186.                     Object elementObj = method.invoke(bean);
187.                     if(!useClassConvert && elementObj instanceof Class)
188.                         continue;
190.                     if(canProxyOutput(elementObj))
191.                         jSONObject.put(key, getJSONObject(elementObj, useClassConvert));
192.                 }
193.             } catch (Exception e) {
194.                 /* forget about it */
195.             }
196.         }
197.         return new JSONStringObject(jSONObject.toString());
198.     }
199. }

调用测试程序

import  java.util.ArrayList;
import  java.util.HashMap;
import  java.util.List;


public   class  AObj  ... {
    private int ii = 7;
    private boolean bb = true;
    private String ss = "你好";
    private List aList = new ArrayList();

    public AObj()...{
        aList.add("hello");
        aList.add(false);
        aList.add(new BObj());
        aList.add(new HashMap());
    }
    
    public boolean isBb() ...{
        return bb;
    }
    public void setBb(boolean bb) ...{
        this.bb = bb;
    }
    public int getIi() ...{
        return ii;
    }
    public void setIi(int ii) ...{
        this.ii = ii;
    }
    public String getSs() ...{
        return ss;
    }
    public void setSs(String ss) ...{
        this.ss = ss;
    }
    public List getAList() ...{
        return aList;
    }
    public void setAList(List list) ...{
        aList = list;
    }
}

 

import  java.math.BigDecimal;
import  java.util.HashMap;


public   class  BObj  ... {

    private HashMap innerhm = new HashMap();
    
    public BObj()...{
        double dd = 7.4354;
        innerhm.put("gigi", "高兴");
        innerhm.put("sina", new BigDecimal(dd));
    }

    public HashMap getInnerhm() ...{
        return innerhm;
    }

    public void setInnerhm(HashMap innerhm) ...{
        this.innerhm = innerhm;
    }
}

 

public   class  CObj  extends  AObj ... {

    private Object[] oarray = new Object[]...{352, false, "kick"};

    public Object[] getOarray() ...{
        return oarray;
    }

    public void setOarray(Object[] oarray) ...{
        this.oarray = oarray;
    }
}

 

import  org.json.JSONException;

import  com.aherp.framework.util.JSONUtil;

public   class  Test  ... {   
    public static void main(String[] args) throws JSONException ...{
        CObj cObj = new CObj();
        System.out.println(JSONUtil.toJSONString(cObj));
    }   
}    

输出：
{"AList":["hello",false,{"innerhm":{"gigi":"/u9AD8/u5174","sina":7.4353999999999995651478457148186862468719482421875}},{}],"ii":7,"oarray":[352,false,"kick"],"ss":"/u4F60/u597D","bb":true}

如果需要支持Hibernate，那么必须弄清其机制。Hibernate采用CGLIB对VO对象进行字节码增加，实际机制就是使用一个原类型的proxy子类，其子类实现了HibernateProxy接口。其接口有一个isUninitialized的判断方法，用来判断该代理类是否已经初始化（还记得在事务外使用延迟加载的对象会抛no Session的错误吗，正是由于实际使用的对象已经变成原来类的子类proxy了）。而对于one-to-many映射时，很难判断对象只加载一次，因此为了避免递归调用死循环，忽略了Hibernate的one-to-many集合的递归反射。其原理和many-to-one一样，也是一个子类化的proxy，具有PersistentSet的接口。

因此，支持Hibernate的JSONUtil如下：

 

 

1. package com.aherp.framework.util;
3. import org.hibernate.collection.PersistentSet;
4. import org.hibernate.proxy.HibernateProxy;
5. import org.hibernate.proxy.LazyInitializer;
6. import org.json.JSONException;
8. /**
9.  * 支持Hibernate的JSONUtil.
10.  * 自动检测是否已经代理加载，如果未加载，则将对象仅加载为OID
11.  * @author Jim Wu
12.  *
13.  */
14. public class HiJSONUtil extends JSONUtil {
16.     private static HiJSONUtil instance = null;
18.     static public String toJSONString(Object obj) throws JSONException{
19.         return toJSONString(obj, false);
20.     }
21.     
22.     static public String toJSONString(Object obj, boolean useClassConvert) throws JSONException{
23.         if(instance == null)
24.             instance = new HiJSONUtil();
25.         return instance.getJSONObject(obj, useClassConvert).toString();
26.     }
28.     @Override
29.     protected Object proxyConvert(Object bean) {
30.         if(bean instanceof HibernateProxy){
31.             LazyInitializer lazyInitializer = ((HibernateProxy)bean).getHibernateLazyInitializer();
32.             if(lazyInitializer.isUninitialized()){
33.                 return lazyInitializer.getIdentifier();
34.             }else
35.                 return lazyInitializer.getImplementation();
36.         }
37.         if(bean instanceof PersistentSet || bean instanceof PersistentList){
38.             return new String[]{}; //忽略hibernate one-to-many
39.         }
40.         return bean;
41.     }
43.     @Override
44.     protected boolean canProxyOutput(Object bean) {
45.         return !(bean != null && (bean instanceof PersistentSet || bean instanceof PersistentList));
46.     }
47. }
48. ;

但是这样还是有个问题，当one-to-one具备双向映射关系时，会陷入调用递归死循环。因此避免这样的情况。

将本人修改过的JavaScriptUtil也附上

1. /*
2.  * Copyright 2005 Joe Walker
3.  *
4.  * Licensed under the Apache License, Version 2.0 (the "License");
5.  * you may not use this file except in compliance with the License.
6.  * You may obtain a copy of the License at
7.  *
8.  *     http://www.apache.org/licenses/LICENSE-2.0
9.  *
10.  * Unless required by applicable law or agreed to in writing, software
11.  * distributed under the License is distributed on an "AS IS" BASIS,
12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13.  * See the License for the specific language governing permissions and
14.  * limitations under the License.
15.  */
16. package com.aherp.framework.util;
18. import java.io.BufferedReader;
19. import java.io.IOException;
20. import java.io.StringReader;
21. import java.util.Arrays;
22. import java.util.Locale;
23. import java.util.SortedSet;
24. import java.util.TreeSet;
26. import org.apache.commons.logging.Log;
27. import org.apache.commons.logging.LogFactory;
29. /**
30.  * Various Javascript code utilities.
31.  * The escape classes were taken from jakarta-commons-lang which in turn borrowed
32.  * from Turbine and other projects. The list of authors below is almost certainly
33.  * far too long, but I'm not sure who really wrote these methods.
34.  * @author Joe Walker [joe at getahead dot ltd dot uk]
35.  * @author Apache Jakarta Turbine
36.  * @author GenerationJavaCore library
37.  * @author Purple Technology
38.  * @author <a href="mailto:[email protected]">Henri Yandell</a>
39.  * @author <a href="mailto:[email protected]">Alexander Day Chaffee</a>
40.  * @author <a href="mailto:[email protected]">Antony Riley</a>
41.  * @author Helge Tesgaard
42.  * @author <a href="[email protected]">Sean Brown</a>
43.  * @author <a href="mailto:[email protected]">Gary Gregory</a>
44.  * @author Phil Steitz
45.  * @author Pete Gieser
46.  */
47. @SuppressWarnings("unchecked")
48. public class JavascriptUtil
49. {
50.     /**
51.      * Flag for use in javascript compression: Remove single line comments.
52.      * For ease of use you may wish to use one of the LEVEL_* compression levels.
53.      * @noinspection PointlessBitwiseExpression
54.      */
55.     public static final int COMPRESS_STRIP_SL_COMMENTS = 1 << 0;
57.     /**
58.      * Flag for use in javascript compression: Remove multi line comments.
59.      * For ease of use you may wish to use one of the LEVEL_* compression levels.
60.      */
61.     public static final int COMPRESS_STRIP_ML_COMMENTS = 1 << 1;
63.     /**
64.      * Flag for use in javascript compression: Remove whitespace at the start and end of a line.
65.      * For ease of use you may wish to use one of the LEVEL_* compression levels.
66.      */
67.     public static final int COMPRESS_TRIM_LINES = 1 << 2;
69.     /**
70.      * Flag for use in javascript compression: Remove blank lines.
71.      * This option will make the javascript harder to debug because line number references
72.      * are likely be altered.
73.      * For ease of use you may wish to use one of the LEVEL_* compression levels.
74.      */
75.     public static final int COMPRESS_STRIP_BLANKLINES = 1 << 3;
77.     /**
78.      * Flag for use in javascript compression: Shrink variable names.
79.      * This option is currently un-implemented.
80.      * For ease of use you may wish to use one of the LEVEL_* compression levels.
81.      */
82.     public static final int COMPRESS_SHRINK_VARS = 1 << 4;
84.     /**
85.      * Flag for use in javascript compression: Remove all lines endings.
86.      * Warning: Javascript can add semi-colons in for you. If you make use of this feature
87.      * then removing newlines may well break.
88.      * For ease of use you may wish to use one of the LEVEL_* compression levels.
89.      */
90.     public static final int COMPRESS_REMOVE_NEWLINES = 1 << 5;
92.     /**
93.      * Compression level that leaves the source un-touched.
94.      */
95.     public static final int LEVEL_NONE = 0;
97.     /**
98.      * Basic compression that leaves the source fully debuggable.
99.      * This includes removing all comments and extraneous whitespace.
100.      */
101.     public static final int LEVEL_DEBUGGABLE = COMPRESS_STRIP_SL_COMMENTS | COMPRESS_STRIP_ML_COMMENTS | COMPRESS_TRIM_LINES;
103.     /**
104.      * Normal compression makes all changes that will work for generic javascript.
105.      * This adds variable name compression and blank line removal in addition to the
106.      * compressions done by LEVEL_DEBUGGABLE.
107.      */
108.     public static final int LEVEL_NORMAL = LEVEL_DEBUGGABLE | COMPRESS_STRIP_BLANKLINES | COMPRESS_SHRINK_VARS;
110.     /**
111.      * LEVEL_ULTRA performs additional compression that makes some assumptions about the
112.      * style of javascript.
113.      * Specifically it assumes that you are not using javascripts ability to infer where the ;
114.      * should go.
115.      */
116.     public static final int LEVEL_ULTRA = LEVEL_NORMAL | COMPRESS_REMOVE_NEWLINES;
118.     /**
119.      * Compress the source code by removing java style comments and removing
120.      * leading and trailing spaces.
121.      * @param text The javascript (or java) program to compress
122.      * @param level The compression level - see LEVEL_* and COMPRESS_* constants.
123.      * @return The compressed version
124.      */
125.     public static String compress(String text, int level)
126.     {
127.         String reply = text;
129.         // First we strip multi line comments. I think this is important:
130.         if ((level & COMPRESS_STRIP_ML_COMMENTS) != 0)
131.         {
132.             reply = stripMultiLineComments(text);
133.         }
135.         if ((level & COMPRESS_STRIP_SL_COMMENTS) != 0)
136.         {
137.             reply = stripSingleLineComments(reply);
138.         }
140.         if ((level & COMPRESS_TRIM_LINES) != 0)
141.         {
142.             reply = trimLines(reply);
143.         }
145.         if ((level & COMPRESS_STRIP_BLANKLINES) != 0)
146.         {
147.             reply = stripBlankLines(reply);
148.         }
150.         if ((level & COMPRESS_SHRINK_VARS) != 0)
151.         {
152.             reply = shrinkVariableNames(reply);
153.         }
155.         if ((level & COMPRESS_REMOVE_NEWLINES) != 0)
156.         {
157.             reply = stripNewlines(reply);
158.         }
160.         return reply;
161.     }
163.     /**
164.      * Remove any leading or trailing spaces from a line of code.
165.      * This function could be improved by making it strip unnecessary double
166.      * spaces, but since we would need to leave double spaces inside strings
167.      * this is not simple and since the benefit is small, we'll leave it for now
168.      * @param text The javascript program to strip spaces from.
169.      * @return The stripped program
170.      */
171.     public static String trimLines(String text)
172.     {
173.         if (text == null)
174.         {
175.             return null;
176.         }
178.         try
179.         {
180.             StringBuffer output = new StringBuffer();
182.             // First we strip multi line comments. I think this is important:
183.             BufferedReader in = new BufferedReader(new StringReader(text));
184.             while (true)
185.             {
186.                 String line = in.readLine();
187.                 if (line == null)
188.                 {
189.                     break;
190.                 }
192.                 output.append(line.trim());
193.                 output.append('/n');
194.             }
196.             return output.toString();
197.         }
198.         catch (IOException ex)
199.         {
200.             log.error("IOExecption unexpected.", ex);
201.             throw new IllegalArgumentException("IOExecption unexpected.");
202.         }
203.     }
205.     /**
206.      * Remove all the single-line comments from a block of text
207.      * @param text The text to remove single-line comments from
208.      * @return The single-line comment free text
209.      */
210.     public static String stripSingleLineComments(String text)
211.     {
212.         if (text == null)
213.         {
214.             return null;
215.         }
217.         try
218.         {
219.             StringBuffer output = new StringBuffer();
221.             BufferedReader in = new BufferedReader(new StringReader(text));
222.             while (true)
223.             {
224.                 String line = in.readLine();
225.                 if (line == null)
226.                 {
227.                     break;
228.                 }
230.                 // Skip @DWR comments
231.                 if (line.indexOf(COMMENT_RETAIN) == -1)
232.                 {
233.                     int cstart = line.indexOf(COMMENT_SL_START);
234.                     if (cstart >= 0)
235.                     {
236.                         line = line.substring(0, cstart);
237.                     }
238.                 }
240.                 output.append(line);
241.                 output.append('/n');
242.             }
244.             return output.toString();
245.         }
246.         catch (IOException ex)
247.         {
248.             log.error("IOExecption unexpected.", ex);
249.             throw new IllegalArgumentException("IOExecption unexpected.");
250.         }
251.     }
253.     /**
254.      * Remove all the multi-line comments from a block of text
255.      * @param text The text to remove multi-line comments from
256.      * @return The multi-line comment free text
257.      */
258.     public static String stripMultiLineComments(String text)
259.     {
260.         if (text == null)
261.         {
262.             return null;
263.         }
265.         try
266.         {
267.             StringBuffer output = new StringBuffer();
269.             // Comment rules:
270.             /*/           This is still a comment
271.             /* /* */      // Comments do not nest
272.             // /* */      This is in a comment
273.             /* // */      // The second // is needed to make this a comment.
275.             // First we strip multi line comments. I think this is important:
276.             boolean inMultiLine = false;
277.             BufferedReader in = new BufferedReader(new StringReader(text));
278.             while (true)
279.             {
280.                 String line = in.readLine();
281.                 if (line == null)
282.                 {
283.                     break;
284.                 }
286.                 if (!inMultiLine)
287.                 {
288.                     // We are not in a multi-line comment, check for a start
289.                     int cstart = line.indexOf(COMMENT_ML_START);
290.                     if (cstart >= 0)
291.                     {
292.                         // This could be a MLC on one line ...
293.                         int cend = line.indexOf(COMMENT_ML_END, cstart + COMMENT_ML_START.length());
294.                         if (cend >= 0)
295.                         {
296.                             // A comment that starts and ends on one line
297.                             // BUG: you can have more than 1 multi-line comment on a line
298.                             line = line.substring(0, cstart) + SPACE + line.substring(cend + COMMENT_ML_END.length());
299.                         }
300.                         else
301.                         {
302.                             // A real multi-line comment
303.                             inMultiLine = true;
304.                             line = line.substring(0, cstart) + SPACE;
305.                         }
306.                     }
307.                     else
308.                     {
309.                         // We are not in a multi line comment and we havn't
310.                         // started one so we are going to ignore closing
311.                         // comments even if they exist.
312.                     }
313.                 }
314.                 else
315.                 {
316.                     // We are in a multi-line comment, check for the end
317.                     int cend = line.indexOf(COMMENT_ML_END);
318.                     if (cend >= 0)
319.                     {
320.                         // End of comment
321.                         line = line.substring(cend + COMMENT_ML_END.length());
322.                         inMultiLine = false;
323.                     }
324.                     else
325.                     {
326.                         // The comment continues
327.                         line = SPACE;
328.                     }
329.                 }
331.                 output.append(line);
332.                 output.append('/n');
333.             }
335.             return output.toString();
336.         }
337.         catch (IOException ex)
338.         {
339.             log.error("IOExecption unexpected.", ex);
340.             throw new IllegalArgumentException("IOExecption unexpected.");
341.         }
342.     }
344.     /**
345.      * Remove all blank lines from a string.
346.      * A blank line is defined to be a line where the only characters are whitespace.
347.      * We always ensure that the line contains a newline at the end.
348.      * @param text The string to strip blank lines from
349.      * @return The blank line stripped reply
350.      */
351.     public static String stripBlankLines(String text)
352.     {
353.         if (text == null)
354.         {
355.             return null;
356.         }
358.         try
359.         {
360.             StringBuffer output = new StringBuffer();
362.             BufferedReader in = new BufferedReader(new StringReader(text));
363.             boolean doneOneLine = false;
364.             while (true)
365.             {
366.                 String line = in.readLine();
367.                 if (line == null)
368.                 {
369.                     break;
370.                 }
372.                 if (line.trim().length() > 0)
373.                 {
374.                     output.append(line);
375.                     output.append('/n');
376.                     doneOneLine = true;
377.                 }
378.             }
380.             if (!doneOneLine)
381.             {
382.                 output.append('/n');
383.             }
385.             return output.toString();
386.         }
387.         catch (IOException ex)
388.         {
389.             log.error("IOExecption unexpected.", ex);
390.             throw new IllegalArgumentException("IOExecption unexpected.");
391.         }
392.     }
394.     /**
395.      * Remove all newline characters from a string.
396.      * @param text The string to strip newline characters from
397.      * @return The stripped reply
398.      */
399.     public static String stripNewlines(String text)
400.     {
401.         if (text == null)
402.         {
403.             return null;
404.         }
406.         try
407.         {
408.             StringBuffer output = new StringBuffer();
410.             BufferedReader in = new BufferedReader(new StringReader(text));
411.             while (true)
412.             {
413.                 String line = in.readLine();
414.                 if (line == null)
415.                 {
416.                     break;
417.                 }
419.                 output.append(line);
420.                 output.append(SPACE);
421.             }
422.             output.append('/n');
424.             return output.toString();
425.         }
426.         catch (IOException ex)
427.         {
428.             log.error("IOExecption unexpected.", ex);
429.             throw new IllegalArgumentException("IOExecption unexpected.");
430.         }
431.     }
433.     /**
434.      * Shrink variable names to a minimum.
435.      * @param text The javascript program to shrink the variable names in.
436.      * @return The shrunk version of the javascript program.
437.      */
438.     public static String shrinkVariableNames(String text)
439.     {
440.         if (text == null)
441.         {
442.             return null;
443.         }
445.         throw new UnsupportedOperationException("Variable name shrinking is not supported");
446.     }
448.     /**
449.      * <p>Escapes the characters in a <code>String</code> using JavaScript String rules.</p>
450.      * <p>Escapes any values it finds into their JavaScript String form.
451.      * Deals correctly with quotes and control-chars (tab, backslash, cr, ff, etc.) </p>
452.      *
453.      * <p>So a tab becomes the characters <code>'//'</code> and
454.      * <code>'t'</code>.</p>
455.      *
456.      * <p>The only difference between Java strings and JavaScript strings
457.      * is that in JavaScript, a single quote must be escaped.</p>
458.      *
459.      * <p>Example:
460.      * <pre>
461.      * input string: He didn't say, "Stop!"
462.      * output string: He didn/'t say, /"Stop!/"
463.      * </pre>
464.      * </p>
465.      *
466.      * @param str  String to escape values in, may be null
467.      * @return String with escaped values, <code>null</code> if null string input
468.      */
469.     public static String escapeJavaScript(String str)
470.     {
471.         if (str == null)
472.         {
473.             return null;
474.         }
476.         StringBuffer writer = new StringBuffer(str.length() * 2);
478.         int sz = str.length();
479.         for (int i = 0; i < sz; i++)
480.         {
481.             char ch = str.charAt(i);
483.             // handle unicode
484.             if (ch > 0xfff)
485.             {
486.                 writer.append("//u");
487.                 writer.append(hex(ch));
488.             }
489.             else if (ch > 0xff)
490.             {
491.                 writer.append("//u0");
492.                 writer.append(hex(ch));
493.             }
494.             else if (ch > 0x7f)
495.             {
496.                 writer.append("//u00");
497.                 writer.append(hex(ch));
498.             }
499.             else if (ch < 32)
500.             {
501.                 switch (ch)
502.                 {
503.                 case '/b':
504.                     writer.append('//');
505.                     writer.append('b');
506.                     break;
507.                 case '/n':
508.                     writer.append('//');
509.                     writer.append('n');
510.                     break;
511.                 case '/t':
512.                     writer.append('//');
513.                     writer.append('t');
514.                     break;
515.                 case '/f':
516.                     writer.append('//');
517.                     writer.append('f');
518.                     break;
519.                 case '/r':
520.                     writer.append('//');
521.                     writer.append('r');
522.                     break;
523.                 default:
524.                     if (ch > 0xf)
525.                     {
526.                         writer.append("//u00");
527.                         writer.append(hex(ch));
528.                     }
529.                     else
530.                     {
531.                         writer.append("//u000");
532.                         writer.append(hex(ch));
533.                     }
534.                     break;
535.                 }
536.             }
537.             else
538.             {
539.                 switch (ch)
540.                 {
541.                 case '/'':
542.                     // If we wanted to escape for Java strings then we would
543.                     // not need this next line.
544.                     writer.append('//');
545.                     writer.append('/'');
546.                     break;
547.                 case '"':
548.                     writer.append('//');
549.                     writer.append('"');
550.                     break;
551.                 case '//':
552.                     writer.append('//');
553.                     writer.append('//');
554.                     break;
555.                 case '<':
556.                     writer.append("//u003c");
557.                     break;
558.                 case '>':
559.                     writer.append("//u003e");
560.                     break;
561.                 default:
562.                     writer.append(ch);
563.                     break;
564.                 }
565.             }
566.         }
568.         return writer.toString();
569.     }
571.     /**
572.      * <p>Returns an upper case hexadecimal <code>String</code> for the given
573.      * character.</p>
574.      * @param ch The character to convert.
575.      * @return An upper case hexadecimal <code>String</code>
576.      */
577.     private static String hex(char ch)
578.     {
579.         return Integer.toHexString(ch).toUpperCase(Locale.ENGLISH);
580.     }
582.     /**
583.      * <p>Unescapes any JavaScript literals found in the <code>String</code>.</p>
584.      * <p>For example, it will turn a sequence of <code>'/'</code> and <code>'n'</code>
585.      * into a newline character, unless the <code>'/'</code> is preceded by another
586.      * <code>'/'</code>.</p>
587.      * @param str  the <code>String</code> to unescape, may be null
588.      * @return A new unescaped <code>String</code>, <code>null</code> if null string input
589.      */
590.     public static String unescapeJavaScript(String str)
591.     {
592.         if (str == null)
593.         {
594.             return null;
595.         }
597.         StringBuffer writer = new StringBuffer(str.length());
598.         int sz = str.length();
599.         StringBuffer unicode = new StringBuffer(4);
600.         boolean hadSlash = false;
601.         boolean inUnicode = false;
603.         for (int i = 0; i < sz; i++)
604.         {
605.             char ch = str.charAt(i);
606.             if (inUnicode)
607.             {
608.                 // if in unicode, then we're reading unicode
609.                 // values in somehow
610.                 unicode.append(ch);
611.                 if (unicode.length() == 4)
612.                 {
613.                     // unicode now contains the four hex digits
614.                     // which represents our unicode chacater
615.                     try
616.                     {
617.                         int value = Integer.parseInt(unicode.toString(), 16);
618.                         writer.append((char) value);
619.                         unicode.setLength(0);
620.                         inUnicode = false;
621.                         hadSlash = false;
622.                     }
623.                     catch (NumberFormatException nfe)
624.                     {
625.                         throw new IllegalArgumentException("Unable to parse unicode value: " + unicode + " cause: " + nfe);
626.                     }
627.                 }
628.                 continue;
629.             }
631.             if (hadSlash)
632.             {
633.                 // handle an escaped value
634.                 hadSlash = false;
635.                 switch (ch)
636.                 {
637.                 case '//':
638.                     writer.append('//');
639.                     break;
640.                 case '/'':
641.                     writer.append('/'');
642.                     break;
643.                 case '/"':
644.                     writer.append('"');
645.                     break;
646.                 case 'r':
647.                     writer.append('/r');
648.                     break;
649.                 case 'f':
650.                     writer.append('/f');
651.                     break;
652.                 case 't':
653.                     writer.append('/t');
654.                     break;
655.                 case 'n':
656.                     writer.append('/n');
657.                     break;
658.                 case 'b':
659.                     writer.append('/b');
660.                     break;
661.                 case 'u':
662.                     // uh-oh, we're in unicode country....
663.                     inUnicode = true;
664.                     break;
665.                 default:
666.                     writer.append(ch);
667.                     break;
668.                 }
669.                 continue;
670.             }
671.             else if (ch == '//')
672.             {
673.                 hadSlash = true;
674.                 continue;
675.             }
676.             writer.append(ch);
677.         }
679.         if (hadSlash)
680.         {
681.             // then we're in the weird case of a / at the end of the
682.             // string, let's output it anyway.
683.             writer.append('//');
684.         }
686.         return writer.toString();
687.     }
689.     /**
690.      * Check to see if the given word is reserved or a bad idea in any known
691.      * version of JavaScript.
692.      * @param name The word to check
693.      * @return false if the word is not reserved
694.      */
695.     public static boolean isReservedWord(String name)
696.     {
697.         return reserved.contains(name);
698.     }
700.     /**
701.      * The array of javascript reserved words
702.      */
703.     private static final String[] RESERVED_ARRAY = new String[]
704.     {
705.         // Reserved and used at ECMAScript 4
706.         "as",
707.         "break",
708.         "case",
709.         "catch",
710.         "class",
711.         "const",
712.         "continue",
713.         "default",
714.         "delete",
715.         "do",
716.         "else",
717.         "export",
718.         "extends",
719.         "false",
720.         "finally",
721.         "for",
722.         "function",
723.         "if",
724.         "import",
725.         "in",
726.         "instanceof",
727.         "is",
728.         "namespace",
729.         "new",
730.         "null",
731.         "package",
732.         "private",
733.         "public",
734.         "return",
735.         "super",
736.         "switch",
737.         "this",
738.         "throw",
739.         "true",
740.         "try",
741.         "typeof",
742.         "use",
743.         "var",
744.         "void",
745.         "while",
746.         "with",
747.         // Reserved for future use at ECMAScript 4
748.         "abstract",
749.         "debugger",
750.         "enum",
751.         "goto",
752.         "implements",
753.         "interface",
754.         "native",
755.         "protected",
756.         "synchronized",
757.         "throws",
758.         "transient",
759.         "volatile",
760.         // Reserved in ECMAScript 3, unreserved at 4 best to avoid anyway
761.         "boolean",
762.         "byte",
763.         "char",
764.         "double",
765.         "final",
766.         "float",
767.         "int",
768.         "long",
769.         "short",
770.         "static",
772.         // I have seen the folowing list as 'best avoided for function names'
773.         // but it seems way to all encompassing, so I'm not going to include it
774.         /*
775.         "alert", "anchor", "area", "arguments", "array", "assign", "blur",
776.         "boolean", "button", "callee", "caller", "captureevents", "checkbox",
777.         "clearinterval", "cleartimeout", "close", "closed", "confirm",
778.         "constructor", "date", "defaultstatus", "document", "element", "escape",
779.         "eval", "fileupload", "find", "focus", "form", "frame", "frames",
780.         "getclass", "hidden", "history", "home", "image", "infinity",
781.         "innerheight", "isfinite", "innerwidth", "isnan", "java", "javaarray",
782.         "javaclass", "javaobject", "javapackage", "length", "link", "location",
783.         "locationbar", "math", "menubar", "mimetype", "moveby", "moveto",
784.         "name", "nan", "navigate", "navigator", "netscape", "number", "object",
785.         "onblur", "onerror", "onfocus", "onload", "onunload", "open", "opener",
786.         "option", "outerheight", "outerwidth", "packages", "pagexoffset",
787.         "pageyoffset", "parent", "parsefloat", "parseint", "password",
788.         "personalbar", "plugin", "print", "prompt", "prototype", "radio", "ref",
789.         "regexp", "releaseevents", "reset", "resizeby", "resizeto",
790.         "routeevent", "scroll", "scrollbars", "scrollby", "scrollto", "select",
791.         "self", "setinterval", "settimeout", "status", "statusbar", "stop",
792.         "string", "submit", "sun", "taint",  "text", "textarea", "toolbar",
793.         "top", "tostring", "unescape", "untaint", "unwatch", "valueof", "watch",
794.         "window",
795.         */
796.     };
798.     private static SortedSet reserved = new TreeSet();
800.     /**
801.      * For easy access ...
802.      */
803.     static
804.     {
805.         // The Javascript reserved words array so we don't generate illegal javascript
806.         reserved.addAll(Arrays.asList(RESERVED_ARRAY));
807.     }
809.     private static final String SPACE = " ";
811.     /**
812.      * How does a multi line comment start?
813.      */
814.     private static final String COMMENT_ML_START = "/*";
816.     /**
817.      * How does a multi line comment end?
818.      */
819.     private static final String COMMENT_ML_END = "*/";
821.     /**
822.      * How does a single line comment start?
823.      */
824.     private static final String COMMENT_SL_START = "//";
826.     /**
827.      * Sometimes we need to retain the comment because it has special meaning
828.      */
829.     private static final String COMMENT_RETAIN = "#DWR";
831.     /**
832.      * The log stream
833.      */
834.     private static final Log log = LogFactory.getLog(JavascriptUtil.class);
835. }
     
     
     需要的JSON类我已经放到共享，你可以从
     http://download.csdn.net/source/879579
     
     下载