Java 类javax.xml.namespace.NamespaceContext 实例源码

@Test
public void testNamespaceContext() {
    try {
        XMLInputFactory xif = XMLInputFactory.newInstance();
        xif.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE, Boolean.TRUE);
        InputStream is = new java.io.ByteArrayInputStream(getXML().getBytes());
        XMLStreamReader sr = xif.createXMLStreamReader(is);
        while (sr.hasNext()) {
            int eventType = sr.next();
            if (eventType == XMLStreamConstants.START_ELEMENT) {
                if (sr.getLocalName().equals(childElement)) {
                    NamespaceContext context = sr.getNamespaceContext();
                    Assert.assertTrue(context.getPrefix(namespaceURI).equals(prefix));
                }
            }
        }
    } catch (Exception ex) {
        ex.printStackTrace();
    }
}

private void switchToXML11Scanner() throws IOException {

        int oldEntityDepth = fScanner.fEntityDepth;
        com.sun.org.apache.xerces.internal.xni.NamespaceContext oldNamespaceContext
                = fScanner.fNamespaceContext;

        fScanner = new XML11NSDocumentScannerImpl();

        //get the new scanner state to old scanner's previous state
        fScanner.reset(fPropertyManager);
        fScanner.setPropertyManager(fPropertyManager);
        fEntityScanner = fEntityManager.getEntityScanner();
        fEntityScanner.registerListener(fScanner);
        fEntityManager.fCurrentEntity.mayReadChunks = true;
        fScanner.setScannerState(XMLEvent.START_DOCUMENT);

        fScanner.fEntityDepth = oldEntityDepth;
        fScanner.fNamespaceContext = oldNamespaceContext;
        fEventType = fScanner.next();
    }

@Test
public void test() {
    try {
        XMLOutputFactory xof = XMLOutputFactory.newInstance();
        StreamResult sr = new StreamResult();
        XMLStreamWriter xsw = xof.createXMLStreamWriter(sr);
        NamespaceContext nc = xsw.getNamespaceContext();
        System.out.println(nc.getPrefix(XMLConstants.XML_NS_URI));
        System.out.println("  expected result: " + XMLConstants.XML_NS_PREFIX);
        System.out.println(nc.getPrefix(XMLConstants.XMLNS_ATTRIBUTE_NS_URI));
        System.out.println("  expected result: " + XMLConstants.XMLNS_ATTRIBUTE);

        Assert.assertTrue(nc.getPrefix(XMLConstants.XML_NS_URI) == XMLConstants.XML_NS_PREFIX);
        Assert.assertTrue(nc.getPrefix(XMLConstants.XMLNS_ATTRIBUTE_NS_URI) == XMLConstants.XMLNS_ATTRIBUTE);

    } catch (Throwable ex) {
        Assert.fail(ex.toString());
    }
}

public void run() {
    NamespaceContext ns = nsc;
    if(xsw!=null)   ns = xsw.getNamespaceContext();
    if(xew!=null)   ns = xew.getNamespaceContext();

    // StAX javadoc isn't very clear on the behavior,
    // so work defensively in anticipation of broken implementations.
    if(ns==null)
        return;

    // we can't enumerate all the in-scope namespace bindings in StAX,
    // so we only look for the known static namespace URIs.
    // this is less than ideal, but better than nothing.
    for( String nsUri : serializer.grammar.nameList.namespaceURIs ) {
        String p = ns.getPrefix(nsUri);
        if(p!=null)
            serializer.addInscopeBinding(nsUri,p);
    }
}

@Override
public void startDocument(LocatorEx locator, NamespaceContext nsContext) throws SAXException {
    if(locator!=null)
        this.locator = locator;
    this.environmentNamespaceContext = nsContext;
    // reset the object
    result = null;
    current = root;

    patchersLen=0;
    aborted = false;
    isUnmarshalInProgress = true;
    nsLen=0;

    if(expectedType!=null)
        root.loader = EXPECTED_TYPE_ROOT_LOADER;
    else
        root.loader = DEFAULT_ROOT_LOADER;

    idResolver.startDocument(this);
}

protected final void handleStartDocument(NamespaceContext nsc) throws SAXException {
    visitor.startDocument(new LocatorEx() {
        public ValidationEventLocator getLocation() {
            return new ValidationEventLocatorImpl(this);
        }
        public int getColumnNumber() {
            return getCurrentLocation().getColumnNumber();
        }
        public int getLineNumber() {
            return getCurrentLocation().getLineNumber();
        }
        public String getPublicId() {
            return getCurrentLocation().getPublicId();
        }
        public String getSystemId() {
            return getCurrentLocation().getSystemId();
        }
    },nsc);
}

protected final void handleStartDocument(NamespaceContext nsc) throws SAXException {
    visitor.startDocument(new LocatorEx() {
        public ValidationEventLocator getLocation() {
            return new ValidationEventLocatorImpl(this);
        }
        public int getColumnNumber() {
            return getCurrentLocation().getColumnNumber();
        }
        public int getLineNumber() {
            return getCurrentLocation().getLineNumber();
        }
        public String getPublicId() {
            return getCurrentLocation().getPublicId();
        }
        public String getSystemId() {
            return getCurrentLocation().getSystemId();
        }
    },nsc);
}

private NodeList evaluateXPathMultiNode(Node bindings, Node target, String expression, NamespaceContext namespaceContext) {
    NodeList nlst;
    try {
        xpath.setNamespaceContext(namespaceContext);
        nlst = (NodeList) xpath.evaluate(expression, target, XPathConstants.NODESET);
    } catch (XPathExpressionException e) {
        reportError((Element) bindings, WsdlMessages.INTERNALIZER_X_PATH_EVALUATION_ERROR(e.getMessage()), e);
        return null; // abort processing this <jaxb:bindings>
    }

    if (nlst.getLength() == 0) {
        reportError((Element) bindings, WsdlMessages.INTERNALIZER_X_PATH_EVALUATES_TO_NO_TARGET(expression));
        return null; // abort
    }

    return nlst;
}

@Test
public void testNamespaceContext() {
    is = new java.io.ByteArrayInputStream(getXML().getBytes());
    try {
        XMLStreamReader sr = factory.createFilteredReader(factory.createXMLStreamReader(is), (StreamFilter) filter);
        while (sr.hasNext()) {
            int eventType = sr.next();
            if (eventType == XMLStreamConstants.START_ELEMENT) {
                if (sr.getLocalName().equals(childElement)) {
                    NamespaceContext context = sr.getNamespaceContext();
                    Assert.assertTrue(context.getPrefix(namespaceURIApple).equals(prefixApple));
                }
            }
        }
    } catch (Exception ex) {
        Assert.fail("Exception: " + ex.getMessage());
    }
}

private void switchToXML11Scanner() throws IOException{

        int oldEntityDepth = fScanner.fEntityDepth;
        com.sun.org.apache.xerces.internal.xni.NamespaceContext oldNamespaceContext = fScanner.fNamespaceContext;

        fScanner = new XML11NSDocumentScannerImpl();

        //get the new scanner state to old scanner's previous state
        fScanner.reset(fPropertyManager);
        fScanner.setPropertyManager(fPropertyManager);
        fEntityScanner = (XMLEntityScanner)fEntityManager.getEntityScanner()  ;
        fEntityManager.fCurrentEntity.mayReadChunks = true;
        fScanner.setScannerState(XMLEvent.START_DOCUMENT);

        fScanner.fEntityDepth = oldEntityDepth;
        fScanner.fNamespaceContext = oldNamespaceContext;
        fEventType = fScanner.next();
    }

private static NamespaceContext getNamespaceContext() {
    //schema related
    namespaces.put("xsd","http://www.w3.org/2001/XMLSchema");
    prefixes.put("http://www.w3.org/2001/XMLSchema", "xsd");

    //wsdl related
    namespaces.put("wsdl", "http://schemas.xmlsoap.org/wsdl/");
    prefixes.put("http://schemas.xmlsoap.org/wsdl/", "wsdl");
    return new HashNamespaceResolver(namespaces, prefixes);
}

private NamespaceContext namespaceContextForSaml() {
    NamespaceContextImpl context = new NamespaceContextImpl();
    context.startPrefixMapping("soapenv", "http://schemas.xmlsoap.org/soap/envelope/");
    context.startPrefixMapping("saml2p", "urn:oasis:names:tc:SAML:2.0:protocol");
    context.startPrefixMapping("saml2", "urn:oasis:names:tc:SAML:2.0:assertion");
    context.startPrefixMapping("ds", "http://www.w3.org/2000/09/xmldsig#");
    return context;
}

public XPath getXPath(NamespaceContext namespaceContext)
{
    XPathFactory xPathFactory = buildXPathFactory();
    configure(xPathFactory);
    XPath xPath = buildXPath(xPathFactory);
    configure(xPath, namespaceContext);
    return xPath;
}

@Theory
public void shouldParsePrefixedXPath(@FromDataPoints("Positive-Prefixed") Triple<String, Expr, Expr> data,
                                     @FromDataPoints("namespaceContexts") NamespaceContext context)
        throws XPathExpressionException {
    Expr actualExpr = new XPathParser(context).parse(data.getFirst());
    assertThat(actualExpr).hasToString(null == context ? data.getSecond().toString() : data.getThird().toString());
}

/**
 * @since 2.0.2
 */
public void marshal(T object,OutputStream output, NamespaceContext nsContext, AttachmentMarshaller am) throws JAXBException {
    Marshaller m = context.marshallerPool.take();
    m.setAttachmentMarshaller(am);
    marshal(m,object,output,nsContext);
    m.setAttachmentMarshaller(null);
    context.marshallerPool.recycle(m);
}

public XSComponent selectSingle(String scd, NamespaceContext nsContext) {
    try {
        return SCD.create(scd,nsContext).selectSingle(this);
    } catch (ParseException e) {
        throw new IllegalArgumentException(e);
    }
}

public XSComponent selectSingle(String scd, NamespaceContext nsContext) {
    try {
        return SCD.create(scd,nsContext).selectSingle(this);
    } catch (ParseException e) {
        throw new IllegalArgumentException(e);
    }
}

public void marshal(Marshaller m, Object object, OutputStream output, NamespaceContext nsContext) throws JAXBException {
    m.setProperty(Marshaller.JAXB_FRAGMENT,true);
    try {
        ((MarshallerImpl)m).marshal(object,output,nsContext);
    } finally {
        m.setProperty(Marshaller.JAXB_FRAGMENT,false);
    }
}

public Collection<XSComponent> select(String scd, NamespaceContext nsContext) {
    try {
        return SCD.create(scd,nsContext).select(this);
    } catch (ParseException e) {
        throw new IllegalArgumentException(e);
    }
}

/**
 * @since 2.0.2
 */
public void marshal(T object,OutputStream output, NamespaceContext nsContext, AttachmentMarshaller am) throws JAXBException {
    Marshaller m = context.marshallerPool.take();
    m.setAttachmentMarshaller(am);
    marshal(m,object,output,nsContext);
    m.setAttachmentMarshaller(null);
    context.marshallerPool.recycle(m);
}

public Collection<XSComponent> select(String scd, NamespaceContext nsContext) {
    try {
        return SCD.create(scd,nsContext).select(this);
    } catch (ParseException e) {
        throw new IllegalArgumentException(e);
    }
}

public void marshal(Marshaller m, Object object, OutputStream output, NamespaceContext nsContext) throws JAXBException {
    m.setProperty(Marshaller.JAXB_FRAGMENT,true);
    try {
        ((MarshallerImpl)m).marshal(object,output,nsContext);
    } finally {
        m.setProperty(Marshaller.JAXB_FRAGMENT,false);
    }
}

public Collection<XSComponent> select(String scd, NamespaceContext nsContext) {
    try {
        return SCD.create(scd,nsContext).select(this);
    } catch (ParseException e) {
        throw new IllegalArgumentException(e);
    }
}

public XSComponent selectSingle(String scd, NamespaceContext nsContext) {
    try {
        return SCD.create(scd,nsContext).selectSingle(this);
    } catch (ParseException e) {
        throw new IllegalArgumentException(e);
    }
}

public static String _printQName(QName val, NamespaceContext nsc) {
    // Double-check
    String qname;
    String prefix = nsc.getPrefix(val.getNamespaceURI());
    String localPart = val.getLocalPart();

    if (prefix == null || prefix.length() == 0) { // be defensive
        qname = localPart;
    } else {
        qname = prefix + ':' + localPart;
    }

    return qname;
}

/**
 * <p>Establishes a namespace context.</p>
 *
 * @param nsContext Namespace context to use
 */
public void setNamespaceContext(NamespaceContext nsContext) {
    if ( nsContext == null ) {
        String fmsg = XSLMessages.createXPATHMessage(
                XPATHErrorResources.ER_ARG_CANNOT_BE_NULL,
                new Object[] {"NamespaceContext"} );
        throw new NullPointerException( fmsg );
    }
    this.namespaceContext = nsContext;
    this.prefixResolver = new JAXPPrefixResolver ( nsContext );
}

StAXPostInitAction(NamespaceContext nsc,XMLSerializer serializer) {
    this.xsw = null;
    this.xew = null;
    this.nsc = nsc;
    this.serializer = serializer;
}

public NamespaceContext getNamespaceContext() {
    return _nsContext;
}

@Override
public QueryFromNode withNamespaceContext(NamespaceContext namespaceContext)
{
    this.namespaceContext = namespaceContext;
    return this;
}

@Override
public NamespaceContext getNamespaceContext() {
    if (usePayloadReaderDelegate) return payloadReader.getNamespaceContext();
    return super.getNamespaceContext();
}

private SimpleNamespaceContextWrapper(NamespaceContext namespaceContext) {
    this.namespaceContext = namespaceContext;
}

@Override
public void setNamespaceContext(final NamespaceContext context)throws XMLStreamException {
    throw new UnsupportedOperationException();
}

@Override
public StartElement createStartElement(String prefix, String namespaceUri, String localName,
        Iterator attributes, Iterator namespaces, NamespaceContext context) {
    return null;
}

@Override
public void setNamespaceContext(NamespaceContext context)
    throws XMLStreamException {
    xmlStreamWriter.setNamespaceContext(context);
}

public void setNamespaceContext(NamespaceContext namespaceContext) throws XMLStreamException {
    /*
     * It is really unclear from the JavaDoc how to implement this method.
     */
    throw new UnsupportedOperationException();
}

public void setNamespaceContext(NamespaceContext context) {
    _context = context;
}

public final NamespaceContext getNamespaceContext() {
    return _nsContext;
}

public final void marshal(@NotNull BridgeContext context,T object,OutputStream output, NamespaceContext nsContext) throws JAXBException {
    marshal( ((BridgeContextImpl)context).marshaller, object, output, nsContext );
}

public NamespaceContext getNamespaceContext() {
    return _nsContext;
}

@Override
public void setNamespaceContext(final NamespaceContext context)throws XMLStreamException {
    throw new UnsupportedOperationException();
}