解决dwr1.0版本在jdk1.3环境下中文问题
在weblogic7中使用dwr1.0，在向后台保存数据时，如果是中文，则是乱码。
现对dwr的源代码做如下修改，即可。
/**************dwr的LocalUtil类*********************/
package uk.ltd.getahead.dwr.util;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URLDecoder;
import javax.servlet.http.HttpServletResponse;
import uk.ltd.getahead.dwr.ConversionConstants;
import com.minght.sys.util.MHT_URLDecoder;
/**
* Various utilities, mostly to make up for JDK 1.4 functionallity that is not
* in JDK 1.3
* @author Joe Walker [joe at getahead dot ltd dot uk]
*/
public final class LocalUtil
{
/**
* splitInbound() returns the type info in this parameter
*/
public static final int INBOUND_INDEX_TYPE = 0;
/**
* splitInbound() returns the value info in this parameter
*/
public static final int INBOUND_INDEX_VALUE = 1;
/**
* Prevent instansiation
*/
** LocalUtil()
{
}
/**
* Replacement for String#replaceAll(String, String) in JDK 1.4
* @param text source text
* @param repl the stuff to get rid of
* @param with the stuff to replace it with
* @return replaced text or null if any args are null
*/
public static String replace(String text, String repl, String with)
{
if (text == null || repl == null || with == null || repl.length() == 0)
{
return text;
}
StringBuffer buf = new StringBuffer(text.length());
int searchFrom = 0;
while (true)
{
int foundAt = text.indexOf(repl, searchFrom);
if (foundAt == -1)
{
break;
}
buf.append(text.substring(searchFrom, foundAt)).append(with);
searchFrom = foundAt repl.length();
}
buf.append(text.substring(searchFrom));
return buf.toString();
}
/**
* True if c1 is java.lang.Boolean and c2 is boolean, etc.
* @param c1 the first class to test
* @param c2 the second class to test
* @return true if the classes are equivalent
*/
public static boolean isEquivalent(Class c1, Class c2)
{
if (c1 == Boolean.class || c1 == Boolean.TYPE)
{
return c2 == Boolean.class || c2 == Boolean.TYPE;
}
else if (c1 == Byte.class || c1 == Byte.TYPE)
{
return c2 == Byte.class || c2 == Byte.TYPE;
}
else if (c1 == Character.class || c1 == Character.TYPE)
{
return c2 == Character.class || c2 == Character.TYPE;
}
else if (c1 == Short.class || c1 == Short.TYPE)
{
return c2 == Short.class || c2 == Short.TYPE;
}
else if (c1 == Integer.class || c1 == Integer.TYPE)
{
return c2 == Integer.class || c2 == Integer.TYPE;
}
else if (c1 == Long.class || c1 == Long.TYPE)
{
return c2 == Long.class || c2 == Long.TYPE;
}
else if (c1 == Float.class || c1 == Float.TYPE)
{
return c2 == Float.class || c2 == Float.TYPE;
}
else if (c1 == Double.class || c1 == Double.TYPE)
{
return c2 == Double.class || c2 == Double.TYPE;
}
else if (c1 == Void.class || c1 == Void.TYPE)
{
return c2 == Void.class || c2 == Void.TYPE;
}
return false;
}
/**
* @param type The class to de-primitivize
* @return The non-privitive version of the class
*/
public static Class getNonPrimitiveType(Class type)
{
if (!type.isPrimitive())
{
return type;
}
else if (type == Boolean.TYPE)
{
return Boolean.class;
}
else if (type == Byte.TYPE)
{
return Byte.class;
}
else if (type == Character.TYPE)
{
return Character.class;
}
else if (type == Short.TYPE)
{
return Short.class;
}
else if (type == Integer.TYPE)
{
return Integer.class;
}
else if (type == Long.TYPE)
{
return Long.class;
}
else if (type == Float.TYPE)
{
return Float.class;
}
else if (type == Double.TYPE)
{
return Double.class;
}
else if (type == Void.TYPE)
{
return Void.class;
}
return null;
}
/**
* Add headers to prevent browers and proxies from caching this reply.
* @param resp The response to add headers to
*/
public static void addNoCacheHeaders(HttpServletResponse resp)
{
// Set standard HTTP/1.1 no-cache headers.
resp.setHeader("Cache-Control", "no-store, no-cache, must-revalidate"); //$NON-NLS-1$ //$NON-NLS-2$
// Set IE extended HTTP/1.1 no-cache headers (use addHeader).
resp.addHeader("Cache-Control", "post-check=0, pre-check=0"); //$NON-NLS-1$ //$NON-NLS-2$
// Set standard HTTP/1.0 no-cache header.
resp.setHeader("Pragma", "no-cache"); //$NON-NLS-1$ //$NON-NLS-2$
// Set to expire far in the past. Prevents caching at the proxy server
resp.setHeader("Expires", "Sat, 6 May 1995 12:00:00 GMT"); //$NON-NLS-1$ //$NON-NLS-2$
}
/**
* URL decode a value. This method gets around the lack of a
* decode(String, String) method in JDK 1.3.
* @param value The string to decode
* @return The decoded string
*/
public static String decode(String value)
{
log.warn("decode before:" value);
if (!testedDecoder)
{
try
{
decode14 = URLDecoder.class.getMethod("decode", new Class[] { String.class, String.class }); //$NON-NLS-1$
}
catch (Exception ex)
{
if (!warn13)
{
log.warn("URLDecoder.decode(String), String) is not available. Falling back to 1.3 variant."); //$NON-NLS-1$
warn13 = true;
}
}
testedDecoder = true;
}
if (decode14 != null)
{
try
{
return (String) decode14.invoke(null, new Object[] { value, "UTF-8" }); //$NON-NLS-1$
}
catch (Exception ex)
{
log.warn("Failed to use JDK 1.4 decoder", ex); //$NON-NLS-1$
}
}
try{
value = MHT_URLDecoder.decode(value, "UTF-8");
}catch(Exception ex){
log.warn("decode to UTF-8 error ." ,ex);
}
return value;
}
/**
* Set a property on an object using reflection
* @param object The object to call the setter on
* @param key The name of the property to set.
* @param value The new value to use for the property
* @throws NoSuchMethodException Passed on from reflection code
* @throws SecurityException Passed on from reflection code
* @throws IllegalAccessException Passed on from reflection code
* @throws IllegalArgumentException Passed on from reflection code
* @throws InvocationTargetException Passed on from reflection code
*/
public static void setProperty(Object object, String key, Object value) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException
{
Class real = object.getClass();
String setterName = "set" key.substring(0, 1).toUpperCase() key.substring(1); //$NON-NLS-1$
Method method = real.getMethod(setterName, new Class[] { value.getClass() });
if (method == null)
{
throw new NoSuchMethodException("Missing property: " key); //$NON-NLS-1$
}
method.invoke(object, new Object[] { value });
}
/**
* The javascript outbound marshaller prefixes the toString value with a
* colon and the original type information. This undoes that.
* @param data The string to be split up
* @return A string array containing the split data
*/
public static String[] splitInbound(String data)
{
String[] reply = new String[2];
int colon = data.indexOf(ConversionConstants.INBOUND_TYPE_SEPARATOR);
if (colon == -1)
{
log.error("Missing : in conversion data (" data ')'); //$NON-NLS-1$
reply[LocalUtil.INBOUND_INDEX_TYPE] = ConversionConstants.TYPE_STRING;
reply[LocalUtil.INBOUND_INDEX_VALUE] = data;
}
else
{
reply[LocalUtil.INBOUND_INDEX_TYPE] = data.substring(0, colon);
reply[LocalUtil.INBOUND_INDEX_VALUE] = data.substring(colon 1);
}
return reply;
}
/**
* The log stream
*/
** static final Logger log = Logger.getLogger(LocalUtil.class);
** static boolean warn13 = false;
** static boolean testedDecoder = false;
** static Method decode14 = null;
}
/********************************自建类**************************************************/
package com.minght.sys.util;
import java.io.*;
/ * *
@author minghaitang
* @version 1.0
*/
public class MHT_URLDecoder {
// The platform default encoding
static String dfltEncName = "GBK";
public static String decode(String s) {
String str = null;
try {
str = decode(s, dfltEncName);
} catch (UnsupportedEncodingException e) {
// The system should always have the platform default
}
return str;
}
public static String decode(String s, String enc)
throws UnsupportedEncodingException{
boolean needToChange = false;
StringBuffer sb = new StringBuffer();
int numChars = s.length();
int i = 0;
if (enc.length() == 0) {
throw new UnsupportedEncodingException ("URLDecoder: empty string enc parameter");
}
while (i < numChars) {
char c = s.charAt(i);
switch (c) {
case ' ':
sb.append(' ');
i ;
needToChange = true;
break;
case '%':
/*
* Starting with this instance of %, process all
* consecutive substrings of the form %xy. Each
* substring %xy will yield a byte. Convert all
* consecutive bytes obtained this way to whatever
* character(s) they represent in the provided
* encoding.
*/
try {
// (numChars-i)/3 is an upper bound for the number
// of remaining bytes
byte[] bytes = new byte[(numChars-i)/3];
int pos = 0;
while ( ((i 2) < numChars)
