Java XMLResourceIdentifier.getNamespace方法代码示例

import com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier; //导入方法依赖的package包/类
/**
 * <p>Resolves an identifier using the catalog. This method interprets that
 * the namespace of the identifier corresponds to uri entries in the catalog.
 * Where both a namespace and an external identifier exist, the namespace
 * takes precedence.</p>
 *
 * @param resourceIdentifier the identifier to resolve
 *
 * @throws XNIException thrown on general error
 * @throws IOException thrown if some i/o error occurs
 */
public String resolveIdentifier(XMLResourceIdentifier resourceIdentifier)
    throws IOException, XNIException {

    String resolvedId = null;

    // The namespace is useful for resolving namespace aware
    // grammars such as XML schema. Let it take precedence over
    // the external identifier if one exists.
    String namespace = resourceIdentifier.getNamespace();
    if (namespace != null) {
        resolvedId = resolveURI(namespace);
    }

    // Resolve against an external identifier if one exists. This
    // is useful for resolving DTD external subsets and other
    // external entities. For XML schemas if there was no namespace
    // mapping we might be able to resolve a system identifier
    // specified as a location hint.
    if (resolvedId == null) {
        String publicId = resourceIdentifier.getPublicId();
        String systemId = getUseLiteralSystemId()
            ? resourceIdentifier.getLiteralSystemId()
            : resourceIdentifier.getExpandedSystemId();
        if (publicId != null && systemId != null) {
            resolvedId = resolvePublic(publicId, systemId);
        }
        else if (systemId != null) {
            resolvedId = resolveSystem(systemId);
        }
    }
    return resolvedId;
}
 

import com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier; //导入方法依赖的package包/类
/**
 * Resolves the specified public and system identifiers. This
 * method first attempts to resolve the entity based on the
 * EntityResolver registered by the application. If no entity
 * resolver is registered or if the registered entity handler
 * is unable to resolve the entity, then default entity
 * resolution will occur.
 *
 * @param publicId     The public identifier of the entity.
 * @param systemId     The system identifier of the entity.
 * @param baseSystemId The base system identifier of the entity.
 *                     This is the system identifier of the current
 *                     entity and is used to expand the system
 *                     identifier when the system identifier is a
 *                     relative URI.
 *
 * @return Returns an input source that wraps the resolved entity.
 *         This method will never return null.
 *
 * @throws IOException  Thrown on i/o error.
 * @throws XNIException Thrown by entity resolver to signal an error.
 */
public XMLInputSource resolveEntity(XMLResourceIdentifier resourceIdentifier) throws IOException, XNIException {
    if(resourceIdentifier == null ) return null;
    String publicId = resourceIdentifier.getPublicId();
    String literalSystemId = resourceIdentifier.getLiteralSystemId();
    String baseSystemId = resourceIdentifier.getBaseSystemId();
    String expandedSystemId = resourceIdentifier.getExpandedSystemId();
    String namespace = resourceIdentifier.getNamespace();

    // if no base systemId given, assume that it's relative
    // to the systemId of the current scanned entity
    // Sometimes the system id is not (properly) expanded.
    // We need to expand the system id if:
    // a. the expanded one was null; or
    // b. the base system id was null, but becomes non-null from the current entity.
    boolean needExpand = (expandedSystemId == null);
    // REVISIT:  why would the baseSystemId ever be null?  if we
    // didn't have to make this check we wouldn't have to reuse the
    // fXMLResourceIdentifier object...
    if (baseSystemId == null && fCurrentEntity != null && fCurrentEntity.entityLocation != null) {
        baseSystemId = fCurrentEntity.entityLocation.getExpandedSystemId();
        if (baseSystemId != null)
            needExpand = true;
    }
    if (needExpand)
        expandedSystemId = expandSystemId(literalSystemId, baseSystemId,false);

    // give the entity resolver a chance
    XMLInputSource xmlInputSource = null;

    if (fEntityResolver != null) {
        resourceIdentifier.setBaseSystemId(baseSystemId);
        resourceIdentifier.setExpandedSystemId(expandedSystemId);
        xmlInputSource = fEntityResolver.resolveEntity(resourceIdentifier);
    }

    // do default resolution
    // REVISIT: what's the correct behavior if the user provided an entity
    // resolver (fEntityResolver != null), but resolveEntity doesn't return
    // an input source (xmlInputSource == null)?
    // do we do default resolution, or do we just return null? -SG
    if (xmlInputSource == null) {
        // REVISIT: when systemId is null, I think we should return null.
        //          is this the right solution? -SG
        //if (systemId != null)
        xmlInputSource = new XMLInputSource(publicId, literalSystemId, baseSystemId);
    }

    if (DEBUG_RESOLVER) {
        System.err.println("XMLEntityManager.resolveEntity(" + publicId + ")");
        System.err.println(" = " + xmlInputSource);
    }

    return xmlInputSource;

}