typemappingimpl.java

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

        throws JAXRPCException
    {
        javax.xml.rpc.encoding.SerializerFactory sf = null;

        // If the xmlType was not provided, get one
        if (xmlType == null) {
            xmlType = getTypeQNameRecursive(javaType);

            // If we couldn't find one, we're hosed, since getTypeQName()
            // already asked all of our delegates.
            if (xmlType == null) {
                return null;
            }
        }

        // Try to get the serializer associated with this pair
        Pair pair = new Pair(javaType, xmlType);

        // Now get the serializer with the pair
        sf = (javax.xml.rpc.encoding.SerializerFactory) pair2SF.get(pair);
        if (sf != null)
            return xmlType;

        // If not successful, use the xmlType to get
        // another pair.  For some xmlTypes (like SOAP_ARRAY)
        // all of the possible javaTypes are not registered.
        if (isArray(javaType)) {
            if (encoded) {
                return Constants.SOAP_ARRAY;
            } else {
                pair = (Pair) qName2Pair.get(xmlType);
            }
        }

        if (pair == null) {
            pair = (Pair) class2Pair.get(javaType);
        }

        if (pair != null) {
            xmlType = pair.xmlType;
        }
        return xmlType;
    }

    /**
     * Gets the DeserializerFactory registered for the specified pair
     * of Java type and XML data type.
     *
     * @param javaType - Class of the Java type
     * @param xmlType - Qualified name of the XML data type
     *
     * @return Registered DeserializerFactory
     *
     * @throws JAXRPCException - If there is no registered DeserializerFactory
     * for this pair of Java type and  XML data type
     * java.lang.IllegalArgumentException -
     * If invalid or unsupported XML/Java type is specified
     */
    public javax.xml.rpc.encoding.DeserializerFactory
        getDeserializer(Class javaType, QName xmlType, TypeMappingDelegate start)
        throws JAXRPCException {
        if (javaType == null) {
            javaType = start.getClassForQName(xmlType);
            // If we don't have a mapping, we're hosed since getClassForQName()
            // has already asked all our delegates.
            if (javaType == null) {
                return null;
            }
        }

        Pair pair = new Pair(javaType, xmlType);

        return (javax.xml.rpc.encoding.DeserializerFactory) pair2DF.get(pair);
    }
    
    public DeserializerFactory finalGetDeserializer(Class javaType,
                                                    QName xmlType,
                                                    TypeMappingDelegate start) {
        DeserializerFactory df = null;
        if (javaType != null && javaType.isArray()) {
            Class componentType = javaType.getComponentType();

            // HACK ALERT - Don't return the ArrayDeserializer IF
            // the xmlType matches the component type of the array
	    // or if the componentType is the wrappertype of the
	    // xmlType, because that means we're using maxOccurs 
	    // and/or nillable and we'll want the higher layers to 
	    // get the component type deserializer... (sigh)
            if (xmlType != null) {
                Class actualClass = start.getClassForQName(xmlType);
                if (actualClass == componentType
                    || (actualClass != null && (componentType.isAssignableFrom(actualClass)
                        || Utils.getWrapperType(actualClass.getName()).equals(componentType.getName())))) {
			return null;
                }
            }
            Pair pair = (Pair) qName2Pair.get(Constants.SOAP_ARRAY);
            df = (DeserializerFactory) pair2DF.get(pair);
            if (df instanceof ArrayDeserializerFactory && javaType.isArray()) {
                QName componentXmlType = start.getTypeQName(componentType);
                if (componentXmlType != null) {
                    df = new ArrayDeserializerFactory(componentXmlType);
                }
            }
        }
        return df;
    }

    /**
     * Removes the SerializerFactory registered for the specified
     * pair of Java type and XML data type.
     *
     * @param javaType - Class of the Java type
     * @param xmlType - Qualified name of the XML data type
     *
     * @throws JAXRPCException - If there is error in
     * removing the registered SerializerFactory
     */
    public void removeSerializer(Class javaType, QName xmlType)
        throws JAXRPCException {
        if (javaType == null || xmlType == null) {
            throw new JAXRPCException(
                    Messages.getMessage(javaType == null ?
                                         "badJavaType" : "badXmlType"));
        }

        Pair pair = new Pair(javaType, xmlType);
        pair2SF.remove(pair);
    }

    /**
     * Removes the DeserializerFactory registered for the specified
     * pair of Java type and XML data type.
     *
     * @param javaType - Class of the Java type
     * @param xmlType - Qualified name of the XML data type
     *
     * @throws JAXRPCException - If there is error in
     * removing the registered DeserializerFactory
     */
    public void removeDeserializer(Class javaType, QName xmlType)
        throws JAXRPCException {
        if (javaType == null || xmlType == null) {
            throw new JAXRPCException(
                    Messages.getMessage(javaType == null ?
                                         "badJavaType" : "badXmlType"));
        }
        Pair pair = new Pair(javaType, xmlType);
        pair2DF.remove(pair);
    }


     /********* End JAX-RPC Compliant Method Definitions *****************/

    /**
     * Gets the QName for the type mapped to Class.
     * @param javaType class or type
     * @return xmlType qname or null
     */
    public QName getTypeQNameRecursive(Class javaType) {
        QName ret = null;
        while (javaType != null) {
            ret = getTypeQName(javaType, null);
            if (ret != null)
                return ret;

            // Walk my interfaces...
            Class [] interfaces = javaType.getInterfaces();
            if (interfaces != null) {
                for (int i = 0; i < interfaces.length; i++) {
                    Class iface = interfaces[i];
                    ret = getTypeQName(iface, null);
                    if (ret != null)
                        return ret;
                }
            }

            javaType = javaType.getSuperclass();
        }
        return null;
    }

    /**
     * Get the QName for this Java class, but only return a specific
     * mapping if there is one.  In other words, don't do special array
     * processing, etc.
     * 
     * @param javaType
     * @return
     */
    public QName getTypeQNameExact(Class javaType, TypeMappingDelegate next) {
        if (javaType == null)
            return null;
       
        QName xmlType = null;
        Pair pair = (Pair) class2Pair.get(javaType);

        if (isDotNetSoapEncFixNeeded() && pair != null ) {
            // Hack alert!
            // If we are in .NET bug compensation mode, skip over any
            // SOAP Encoded types we my find and prefer XML Schema types
            xmlType = pair.xmlType;
            if (Constants.isSOAP_ENC(xmlType.getNamespaceURI()) &&
                    !xmlType.getLocalPart().equals("Array")) {
                pair = null;
            }
        }

        if (pair == null && next != null) {
            // Keep checking up the stack...
            xmlType = next.delegate.getTypeQNameExact(javaType,
                                                      next.next);
        }

        if (pair != null) {
            xmlType = pair.xmlType;
        }

        return xmlType;
    }

    /**
     * isDotNetSoapEncFixNeeded - Do we need to compensate for the dotnet bug.
     * check the service specific flag before using the global flag
     * @return
     */
    private boolean isDotNetSoapEncFixNeeded() {
        MessageContext msgContext = MessageContext.getCurrentContext();
        if (msgContext != null) {
            SOAPService service = msgContext.getService();
            if (service != null) {
                String dotNetSoapEncFix = (String) service.getOption(AxisEngine.PROP_DOTNET_SOAPENC_FIX);
                if (dotNetSoapEncFix != null) {
                    return JavaUtils.isTrue(dotNetSoapEncFix);
                }
            }
        }
        return TypeMappingImpl.dotnet_soapenc_bugfix;
    }

    public QName getTypeQName(Class javaType, TypeMappingDelegate next) {
        QName xmlType = getTypeQNameExact(javaType, next);

        /* If auto-typing is on and the array has the default SOAP_ARRAY QName,
         * then generate a namespace for this array intelligently.   Also
         * register it's javaType and xmlType. List classes and derivitives
         * can't be used because they should be serialized as an anyType array.
         */
        if ( shouldDoAutoTypes() &&
             javaType != List.class &&
             !List.class.isAssignableFrom(javaType) &&
             xmlType != null &&
             xmlType.equals(Constants.SOAP_ARRAY) )
        {
            xmlType = new QName(
                Namespaces.makeNamespace( javaType.getName() ),
                Types.getLocalNameFromFullName( javaType.getName() ) );

            internalRegister( javaType,
                              xmlType,
                              new ArraySerializerFactory(),
                              new ArrayDeserializerFactory() );
        }

        // Can only detect arrays via code
        if (xmlType == null && isArray(javaType)) {

            // get the registered array if any
            Pair pair = (Pair) class2Pair.get(Object[].class);
            // TODO: it always returns the last registered one,
            //  so that's why the soap 1.2 typemappings have to 
            //  move to an other registry to differentiate them
            if (pair != null) {
                xmlType = pair.xmlType;
            } else {
                xmlType = Constants.SOAP_ARRAY;
            }
        }

        /* If the class isn't an array or List and auto-typing is turned on,
        * register the class and it's type as beans.
        */
        if (xmlType == null && shouldDoAutoTypes())
        {
            xmlType = new QName(
                Namespaces.makeNamespace( javaType.getName() ),
                Types.getLocalNameFromFullName( javaType.getName() ) );

            /* If doAutoTypes is set, register a new type mapping for the
            * java class with the above QName.  This way, when getSerializer()
            * and getDeserializer() are called, this QName is returned and
            * these methods do not need to worry about creating a serializer.
            */
            internalRegister( javaType,
                              xmlType,
                              new BeanSerializerFactory(javaType, xmlType),
                              new BeanDeserializerFactory(javaType, xmlType) );
        }

        //log.debug("getTypeQName xmlType =" + xmlType);
        return xmlType;
    }

    public Class getClassForQName(QName xmlType, Class javaType,
                                  TypeMappingDelegate next) {
        if (xmlType == null) {
            return null;
        }

        //log.debug("getClassForQName xmlType =" + xmlType);

        if (javaType != null) {
            // Looking for an exact match first
            Pair pair = new Pair(javaType, xmlType);
            if (pair2DF.get(pair) == null) {
                if (next != null) {
                    javaType = next.getClassForQName(xmlType, javaType);
                }
            }
        }

        if (javaType == null) {
            //look for it in our map
            Pair pair = (Pair) qName2Pair.get(xmlType);
            if (pair == null && next != null) {
                //on no match, delegate
                javaType = next.getClassForQName(xmlType);
            } else if (pair != null) {
                javaType = pair.javaType;
            }
        }
        
        //log.debug("getClassForQName javaType =" + javaType);
        if(javaType == null && shouldDoAutoTypes()) {
            String pkg = Namespaces.getPackage(xmlType.getNamespaceURI());
            if (pkg != null) {
                String className = xmlType.getLocalPart();
                if (pkg.length() > 0) {
                    className = pkg + "." + className;
                }
                try {
                    javaType = ClassUtils.forName(className);
                    internalRegister(javaType,
                                     xmlType,
                                     new BeanSerializerFactory(javaType, xmlType),
                                     new BeanDeserializerFactory(javaType, xmlType));
                } catch (ClassNotFoundException e) {
                }
            }
        }
        return javaType;
    }

    public void setDoAutoTypes(boolean doAutoTypes) {
        this.doAutoTypes = doAutoTypes ? Boolean.TRUE : Boolean.FALSE;
    }
    
    public boolean shouldDoAutoTypes() {
        if(doAutoTypes != null) {
            return doAutoTypes.booleanValue();
        }
        MessageContext msgContext = MessageContext.getCurrentContext();
        if(msgContext != null) {
            if (msgContext.isPropertyTrue("axis.doAutoTypes") ||
                    (msgContext.getAxisEngine() != null && JavaUtils.isTrue(msgContext.getAxisEngine().getOption("axis.doAutoTypes")))) {
                doAutoTypes = Boolean.TRUE;
            }
        }
        if(doAutoTypes == null){
            doAutoTypes = AxisProperties.getProperty("axis.doAutoTypes",
                    "false")
                    .equals("true") ?
                    Boolean.TRUE : Boolean.FALSE;
        }
        return doAutoTypes.booleanValue();
    }

    /**
     * Returns an array of all the classes contained within this mapping
     */
    public Class [] getAllClasses(TypeMappingDelegate next)
    {
        java.util.HashSet temp = new java.util.HashSet();
        if (next != null)
        {
            temp.addAll(java.util.Arrays.asList(next.getAllClasses()));
        }
        temp.addAll(class2Pair.keySet());
        return (Class[])temp.toArray(new Class[temp.size()]);
    }
}