javautils.java

Java有关XML编程需要用到axis 的源代码 把里面bin下的包导入相应的Java工程 进行使用

/*
 * Copyright 2001-2004 The Apache Software Foundation.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.axis.utils;

import org.apache.axis.attachments.AttachmentPart;
import org.apache.axis.attachments.OctetStream;
import org.apache.axis.components.image.ImageIO;
import org.apache.axis.components.image.ImageIOFactory;
import org.apache.axis.components.logger.LogFactory;
import org.apache.axis.types.HexBinary;
import org.apache.commons.logging.Log;

import javax.activation.DataHandler;
import javax.xml.soap.SOAPException;
import javax.xml.transform.Source;
import javax.xml.transform.stream.StreamSource;
import java.awt.*;
import java.beans.Introspector;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;
import java.io.ByteArrayOutputStream;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.text.Collator;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.WeakHashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Set;

/** Utility class to deal with Java language related issues, such
 * as type conversions.
 *
 * @author Glen Daniels ([e-mail])
 */
public class JavaUtils
{
    private JavaUtils() {
    }

    protected static Log log =
        LogFactory.getLog(JavaUtils.class.getName());
    
    public static final char NL = '\n';

    public static final char CR = '\r';

    /**
     * The prefered line separator
     */
    public static final String LS = System.getProperty("line.separator",
                                                       (new Character(NL)).toString());


    public static Class getWrapperClass(Class primitive)
    {
        if (primitive == int.class)
            return java.lang.Integer.class;
        else if (primitive == short.class)
            return java.lang.Short.class;
        else if (primitive == boolean.class)
            return java.lang.Boolean.class;
        else if (primitive == byte.class)
            return java.lang.Byte.class;
        else if (primitive == long.class)
            return java.lang.Long.class;
        else if (primitive == double.class)
            return java.lang.Double.class;
        else if (primitive == float.class)
            return java.lang.Float.class;
        else if (primitive == char.class)
            return java.lang.Character.class;
        
        return null;
    }
    
    public static String getWrapper(String primitive)
    {
        if (primitive.equals("int"))
            return "Integer";
        else if (primitive.equals("short"))
            return "Short";
        else if (primitive.equals("boolean"))
            return "Boolean";
        else if (primitive.equals("byte"))
            return "Byte";
        else if (primitive.equals("long"))
            return "Long";
        else if (primitive.equals("double"))
            return "Double";
        else if (primitive.equals("float"))
            return "Float";
        else if (primitive.equals("char"))
            return "Character";
        
        return null;
    }

    public static Class getPrimitiveClass(Class wrapper)
    {
        if (wrapper == java.lang.Integer.class)
            return int.class;
        else if (wrapper == java.lang.Short.class)
            return short.class;
        else if (wrapper == java.lang.Boolean.class)
            return boolean.class;
        else if (wrapper == java.lang.Byte.class)
            return byte.class;
        else if (wrapper == java.lang.Long.class)
            return long.class;
        else if (wrapper == java.lang.Double.class)
            return double.class;
        else if (wrapper == java.lang.Float.class)
            return float.class;
        else if (wrapper == java.lang.Character.class)
            return char.class;
        
        return null;
    }
    
    public static Class getPrimitiveClassFromName(String primitive) {
        if (primitive.equals("int"))
            return int.class;
        else if (primitive.equals("short"))
            return short.class;
        else if (primitive.equals("boolean"))
            return boolean.class;
        else if (primitive.equals("byte"))
            return byte.class;
        else if (primitive.equals("long"))
            return long.class;
        else if (primitive.equals("double"))
            return double.class;
        else if (primitive.equals("float"))
            return float.class;
        else if (primitive.equals("char"))
            return char.class;
        
        return null;
    }

    /*
         * Any builtin type that has a constructor that takes a String is a basic
         * type.
         * This is for optimization purposes, so that we don't introspect
         * primitive java types or some basic Axis types.
         */
    public static boolean isBasic(Class javaType) {
        return (javaType.isPrimitive() ||
                javaType == String.class ||
                javaType == Boolean.class ||
                javaType == Float.class ||
                javaType == Double.class ||
                Number.class.isAssignableFrom(javaType) ||
                javaType == org.apache.axis.types.Day.class ||
                javaType == org.apache.axis.types.Duration.class ||
                javaType == org.apache.axis.types.Entities.class ||
                javaType == org.apache.axis.types.Entity.class ||
                javaType == HexBinary.class ||
                javaType == org.apache.axis.types.Id.class ||
                javaType == org.apache.axis.types.IDRef.class ||
                javaType == org.apache.axis.types.IDRefs.class ||
                javaType == org.apache.axis.types.Language.class ||
                javaType == org.apache.axis.types.Month.class ||
                javaType == org.apache.axis.types.MonthDay.class ||
                javaType == org.apache.axis.types.Name.class ||
                javaType == org.apache.axis.types.NCName.class ||
                javaType == org.apache.axis.types.NegativeInteger.class ||
                javaType == org.apache.axis.types.NMToken.class ||
                javaType == org.apache.axis.types.NMTokens.class ||
                javaType == org.apache.axis.types.NonNegativeInteger.class ||
                javaType == org.apache.axis.types.NonPositiveInteger.class ||
                javaType == org.apache.axis.types.NormalizedString.class ||
                javaType == org.apache.axis.types.PositiveInteger.class ||
                javaType == org.apache.axis.types.Time.class ||
                javaType == org.apache.axis.types.Token.class ||
                javaType == org.apache.axis.types.UnsignedByte.class ||
                javaType == org.apache.axis.types.UnsignedInt.class ||
                javaType == org.apache.axis.types.UnsignedLong.class ||
                javaType == org.apache.axis.types.UnsignedShort.class ||
                javaType == org.apache.axis.types.URI.class ||
                javaType == org.apache.axis.types.Year.class ||
                javaType == org.apache.axis.types.YearMonth.class);
    }

    /**
     * It the argument to the convert(...) method implements
     * the ConvertCache interface, the convert(...) method
     * will use the set/get methods to store and retrieve
     * converted values.
     **/
    public interface ConvertCache {
        /**
         * Set/Get converted values of the convert method.
         **/
        public void setConvertedValue(Class cls, Object value);
        public Object getConvertedValue(Class cls);
        /**
         * Get the destination array class described by the xml
         **/
        public Class getDestClass();
    }

    /** Utility function to convert an Object to some desired Class.
     *
     * Right now this works for:
     *     arrays <-> Lists,
     *     Holders <-> held values
     * @param arg the array to convert
     * @param destClass the actual class we want
     */
    public static Object convert(Object arg, Class destClass)
    {
        if (destClass == null) {
            return arg;
        }

        Class argHeldType = null;
        if (arg != null) {
            argHeldType = getHolderValueType(arg.getClass());
        }

        if (arg != null && argHeldType == null && destClass.isAssignableFrom(arg.getClass())) {
            return arg;
        }

        if (log.isDebugEnabled()) {
            String clsName = "null";
            if (arg != null) clsName = arg.getClass().getName();
            log.debug( Messages.getMessage("convert00", clsName, destClass.getName()));
        }

        // See if a previously converted value is stored in the argument.
        Object destValue = null;
        if (arg instanceof ConvertCache) {
            destValue = (( ConvertCache) arg).getConvertedValue(destClass);
            if (destValue != null)
                return destValue;
        }

        // Get the destination held type or the argument held type if they exist
        Class destHeldType = getHolderValueType(destClass);

        // Convert between Axis special purpose HexBinary and byte[]
        if (arg instanceof HexBinary &&
            destClass == byte[].class) {
            return ((HexBinary) arg).getBytes();
        } else if (arg instanceof byte[] &&
                   destClass == HexBinary.class) {
            return new HexBinary((byte[]) arg);
        }

        // Convert between Calendar and Date
        if (arg instanceof Calendar && destClass == Date.class) {
            return ((Calendar) arg).getTime();
        }
        if (arg instanceof Date && destClass == Calendar.class) {
        	Calendar calendar = Calendar.getInstance();
        	calendar.setTime((Date) arg);
            return calendar;
        }

        // Convert between Calendar and java.sql.Date
        if (arg instanceof Calendar && destClass == java.sql.Date.class) {
            return new java.sql.Date(((Calendar) arg).getTime().getTime());
        }

        // Convert between HashMap and Hashtable
        if (arg instanceof HashMap && destClass == Hashtable.class) {
            return new Hashtable((HashMap)arg);
        }

        // Convert an AttachmentPart to the given destination class.
        if (isAttachmentSupported() &&
                (arg instanceof InputStream || arg instanceof AttachmentPart || arg instanceof DataHandler)) {
            try {
                String destName = destClass.getName();
                if (destClass == String.class
                        || destClass == OctetStream.class
                        || destClass == byte[].class
                        || destClass == Image.class
                        || destClass == Source.class
                        || destClass == DataHandler.class
                        || destName.equals("javax.mail.internet.MimeMultipart")) {
                    DataHandler handler = null;
                    if (arg instanceof AttachmentPart) {
                        handler = ((AttachmentPart) arg).getDataHandler();
                    }
                    else if (arg instanceof DataHandler) {
                        handler = (DataHandler) arg;
                    }
                    if (destClass == Image.class) {
                        // Note:  An ImageIO component is required to process an Image
                        // attachment, but if the image would be null
                        // (is.available == 0) then ImageIO component isn't needed
                        // and we can return null.
                        InputStream is = handler.getInputStream();
                        if (is.available() == 0) {
                            return null;
                        }
                        else {
                            ImageIO imageIO = ImageIOFactory.getImageIO();
                            if (imageIO != null) {
                                return getImageFromStream(is);
                            }
                            else {
                                log.info(Messages.getMessage("needImageIO"));
                                return arg;
                            }
                        }
                    }
                    else if (destClass == javax.xml.transform.Source.class) {
                        // For a reason unknown to me, the handler's
                        // content is a String.  Convert it to a
                        // StreamSource.
                        return new StreamSource(handler.getInputStream());
                    }
                    else if (destClass == OctetStream.class || destClass == byte[].class) {
                        InputStream in = null;
                        if (arg instanceof InputStream) {