Java XMLResourceIdentifier.getExpandedSystemId方法代码示例

import com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier; //导入方法依赖的package包/类
/**
 * An external entity declaration.
 *
 * @param name     The name of the entity. Parameter entity names start
 *                 with '%', whereas the name of a general entity is just
 *                 the entity name.
 * @param identifier    An object containing all location information
 *                      pertinent to this entity.
 * @param augs Additional information that may include infoset
 *                      augmentations.
 *
 * @throws XNIException Thrown by handler to signal an error.
 */
public void externalEntityDecl(String name, XMLResourceIdentifier identifier,
                               Augmentations augs) throws XNIException {
    try {
        // SAX2 extension
        if (fDeclHandler != null) {
            String publicId = identifier.getPublicId();
            String systemId = fResolveDTDURIs ?
                identifier.getExpandedSystemId() : identifier.getLiteralSystemId();
            fDeclHandler.externalEntityDecl(name, publicId, systemId);
        }
    }
    catch (SAXException e) {
        throw new XNIException(e);
    }

}
 

import com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier; //导入方法依赖的package包/类
/**
 * An unparsed entity declaration.
 *
 * @param name     The name of the entity.
 * @param identifier    An object containing all location information
 *                      pertinent to this entity.
 * @param notation The name of the notation.
 *
 * @param augs Additional information that may include infoset
 *                      augmentations.
 *
 * @throws XNIException Thrown by handler to signal an error.
 */
public void unparsedEntityDecl(String name, XMLResourceIdentifier identifier,
                               String notation,
                               Augmentations augs) throws XNIException {
    try {
        // SAX2 extension
        if (fDTDHandler != null) {
            String publicId = identifier.getPublicId();
            String systemId = fResolveDTDURIs ?
                identifier.getExpandedSystemId() : identifier.getLiteralSystemId();
            fDTDHandler.unparsedEntityDecl(name, publicId, systemId, notation);
        }
    }
    catch (SAXException e) {
        throw new XNIException(e);
    }

}
 

import com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier; //导入方法依赖的package包/类
/**
 * A notation declaration
 *
 * @param name     The name of the notation.
 * @param identifier    An object containing all location information
 *                      pertinent to this notation.
 * @param augs Additional information that may include infoset
 *                      augmentations.
 *
 * @throws XNIException Thrown by handler to signal an error.
 */
public void notationDecl(String name, XMLResourceIdentifier identifier,
                         Augmentations augs) throws XNIException {
    try {
        // SAX1 and SAX2
        if (fDTDHandler != null) {
            String publicId = identifier.getPublicId();
            String systemId = fResolveDTDURIs ?
                identifier.getExpandedSystemId() : identifier.getLiteralSystemId();
            fDTDHandler.notationDecl(name, publicId, systemId);
        }
    }
    catch (SAXException e) {
        throw new XNIException(e);
    }

}
 

import com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier; //导入方法依赖的package包/类
/**
 * Caches an unparsed entity.
 * @param name the name of the unparsed entity
 * @param identifier the location of the unparsed entity
 * @param augmentations any Augmentations that were on the original unparsed entity declaration
 */
protected void addUnparsedEntity(
    String name,
    XMLResourceIdentifier identifier,
    String notation,
    Augmentations augmentations) {
    UnparsedEntity ent = new UnparsedEntity();
    ent.name = name;
    ent.systemId = identifier.getLiteralSystemId();
    ent.publicId = identifier.getPublicId();
    ent.baseURI = identifier.getBaseSystemId();
    ent.expandedSystemId = identifier.getExpandedSystemId();
    ent.notation = notation;
    ent.augmentations = augmentations;
    fUnparsedEntities.add(ent);
}
 

import com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier; //导入方法依赖的package包/类
/**
 * Resolves an external parsed entity. If the entity cannot be
 * resolved, this method should return null.
 *
 * @param resourceIdentifier        contains the physical co-ordinates of the resource to be resolved
 *
 * @throws XNIException Thrown on general error.
 * @throws IOException  Thrown if resolved entity stream cannot be
 *                      opened or some other i/o error occurs.
 */
public XMLInputSource resolveEntity(XMLResourceIdentifier resourceIdentifier)
    throws XNIException, IOException {

    // When both pubId and sysId are null, the user's entity resolver
    // can do nothing about it. We'd better not bother calling it.
    // This happens when the resourceIdentifier is a GrammarDescription,
    // which describes a schema grammar of some namespace, but without
    // any schema location hint. -Sg
    String pubId = resourceIdentifier.getPublicId();
    String sysId = resourceIdentifier.getExpandedSystemId();
    if (pubId == null && sysId == null)
        return null;

    // resolve entity using SAX entity resolver
    if (fEntityResolver != null && resourceIdentifier != null) {
        try {
            InputSource inputSource = fEntityResolver.resolveEntity(pubId, sysId);
            if (inputSource != null) {
                String publicId = inputSource.getPublicId();
                String systemId = inputSource.getSystemId();
                String baseSystemId = resourceIdentifier.getBaseSystemId();
                InputStream byteStream = inputSource.getByteStream();
                Reader charStream = inputSource.getCharacterStream();
                String encoding = inputSource.getEncoding();
                XMLInputSource xmlInputSource =
                    new XMLInputSource(publicId, systemId, baseSystemId);
                xmlInputSource.setByteStream(byteStream);
                xmlInputSource.setCharacterStream(charStream);
                xmlInputSource.setEncoding(encoding);
                return xmlInputSource;
            }
        }

        // error resolving entity
        catch (SAXException e) {
            Exception ex = e.getException();
            if (ex == null) {
                ex = e;
            }
            throw new XNIException(ex);
        }
    }

    // unable to resolve entity
    return null;

}
 

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包/类
/**
 * Caches a notation.
 * @param name the name of the notation
 * @param identifier the location of the notation
 * @param augmentations any Augmentations that were on the original notation declaration
 */
protected void addNotation(
    String name,
    XMLResourceIdentifier identifier,
    Augmentations augmentations) {
    Notation not = new Notation();
    not.name = name;
    not.systemId = identifier.getLiteralSystemId();
    not.publicId = identifier.getPublicId();
    not.baseURI = identifier.getBaseSystemId();
    not.expandedSystemId = identifier.getExpandedSystemId();
    not.augmentations = augmentations;
    fNotations.add(not);
}
 

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;

}