Java UnmarshallerHandler类代码示例

import javax.xml.bind.UnmarshallerHandler; //导入依赖的package包/类
protected org.kuali.rice.core.impl.config.property.Config unmarshal(Unmarshaller unmarshaller, InputStream in)
        throws SAXException, ParserConfigurationException, IOException,
        IllegalStateException, JAXBException {
    SAXParserFactory spf = SAXParserFactory.newInstance();
    spf.setNamespaceAware(true);

    XMLFilter filter = new ConfigNamespaceURIFilter();
    filter.setParent(spf.newSAXParser().getXMLReader());

    UnmarshallerHandler handler = unmarshaller.getUnmarshallerHandler();
    filter.setContentHandler(handler);

    filter.parse(new InputSource(in));

    return (org.kuali.rice.core.impl.config.property.Config) handler.getResult();
}
 

import javax.xml.bind.UnmarshallerHandler; //导入依赖的package包/类
public static <T> T getPersistence(final Class<T> clazz, final InputStream persistenceDescriptor) throws Exception {
    final JAXBContext jc = clazz.getClassLoader() == JaxbPersistenceFactory.class.getClassLoader() ?
            JaxbJavaee.getContext(clazz) : JAXBContextFactory.newInstance(clazz);
    final Unmarshaller u = jc.createUnmarshaller();
    final UnmarshallerHandler uh = u.getUnmarshallerHandler();

    // create a new XML parser
    final SAXParserFactory factory = SAXParserFactory.newInstance();
    factory.setNamespaceAware(true);
    factory.setValidating(true);
    final SAXParser parser = factory.newSAXParser();

    final XMLReader xmlReader = parser.getXMLReader();

    // Create a filter to intercept events
    final PersistenceFilter xmlFilter = new PersistenceFilter(xmlReader);

    // Be sure the filter has the JAXB content handler set (or it wont work)
    xmlFilter.setContentHandler(uh);
    final SAXSource source = new SAXSource(xmlFilter, new InputSource(persistenceDescriptor));

    return (T) u.unmarshal(source);
}
 

import javax.xml.bind.UnmarshallerHandler; //导入依赖的package包/类
public final Object unmarshal( Node node ) throws JAXBException {
    try {
        DOMScanner scanner = new DOMScanner();
        UnmarshallerHandler handler = new InterningUnmarshallerHandler( 
            createUnmarshallerHandler(new DOMLocator(scanner)));
        
        if(node instanceof Element)
            scanner.parse((Element)node,handler);
        else
        if(node instanceof Document)
            scanner.parse(((Document)node).getDocumentElement(),handler);
        else
            // no other type of input is supported
            throw new IllegalArgumentException();
        
        return handler.getResult();
    } catch( SAXException e ) {
        throw createUnmarshalException(e);
    }
}
 

import javax.xml.bind.UnmarshallerHandler; //导入依赖的package包/类
@SuppressWarnings({ "unchecked", "resource" })
public T unmarshall(final InputStream inputStream) throws JAXBException, TransformerException {
  final Unmarshaller unmarshaller = this.jaxbContext.createUnmarshaller();
  final UnmarshallerHandler unmarshallerHandler = unmarshaller.getUnmarshallerHandler();
  final Transformer transformer = this.inputTransformerTemplate.newTransformer();
  final SAXResult saxResult = new SAXResult(unmarshallerHandler);
  final StreamSource streamSource = new StreamSource(new NoneClosingInputStream(inputStream));
  transformer.transform(streamSource, saxResult);
  final Object result = unmarshallerHandler.getResult();
  return (T) result;
}
 

import javax.xml.bind.UnmarshallerHandler; //导入依赖的package包/类
public static Object unmarshal(String path, String contextPath, String namespace)
        throws JAXBException, SAXException, ParserConfigurationException,
        IOException {
    UnmarshallerHandler unmarshallerHandler = JAXBContext
            .newInstance(contextPath).createUnmarshaller()
            .getUnmarshallerHandler();
    XMLFilter xmlFilter = new NamespaceFilter(namespace);
    xmlFilter.setParent(
            SAXParserFactory.newInstance().newSAXParser().getXMLReader());
    xmlFilter.setContentHandler(unmarshallerHandler);
    xmlFilter.parse(new InputSource(Thread.currentThread()
            .getContextClassLoader().getResource(path).getPath()));
    return unmarshallerHandler.getResult();
}
 

import javax.xml.bind.UnmarshallerHandler; //导入依赖的package包/类
/**
 * Parses the given XML to a Java model (JAXB unmarshalling).
 * Performs XSD validation.
 *
 * @param xml         an input XML content
 * @param xmlPath     a path to the input xml
 * @param xsds        a full path to all XSDs corresponding to the given XML
 * @param pkg         a package containing the corresponding Java model classes.
 * @param resultClass a corresponding Java model class.
 * @param <T>         a corresponding Java model class.
 * @return a corresponding Java model instance.
 * @throws XmlParsingException if input is not a valid XML or it doesn't pass XSD validation
 */
public static <T> T parse(InputStream xml, String xmlPath, String[] xsds, String pkg, Class<T> resultClass) throws XmlParsingException {
    try {
        // 1. create JAXB unmarshaller
        JAXBContext jaxbContext = JAXBContext.newInstance(pkg);
        Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
        UnmarshallerHandler unmarshallerHandler = unmarshaller.getUnmarshallerHandler();

        // 2. create a an error and content handler (which is also a bridge between a sax parser and unmarshaller)
        XmlParsingHandler contentErrorHandler = new XmlParsingHandlerWrapper(unmarshallerHandler, xmlPath);

        // 3. do parse
        doParse(xml, xsds, contentErrorHandler);

        // 4. get unmarshall result
        Object result = JAXBIntrospector.getValue(unmarshallerHandler.getResult());
        if (!resultClass.isInstance(result)) {
            throw new RuntimeException(String.format("A root element in '%s' must be an instance of %s type.",
                    xmlPath, resultClass.getSimpleName()));

        }
        //noinspection unchecked
        return (T) result;
    } catch (JAXBException e) {
        throw new RuntimeException(e);
    }
}
 

import javax.xml.bind.UnmarshallerHandler; //导入依赖的package包/类
@Override
protected void parsingCompleted(Exchange exchange, Message msg, AsyncXMLReader xmlReader){
    UnmarshallerHandler handler = (UnmarshallerHandler)xmlReader.getContentHandler();
    try{
        String contentType = msg.getPayload().getMediaType().withCharset(IOUtil.UTF_8.name()).toString();
        msg.setPayload(new JAXBPayload(contentType, handler.getResult(), jaxbContext));
    }catch(Throwable thr){
        exchange.resume(thr);
        return;
    }
    super.parsingCompleted(exchange, msg, xmlReader);
}
 

import javax.xml.bind.UnmarshallerHandler; //导入依赖的package包/类
public static Model unmarshal(InputSource inputSource){
    try {
        JAXBContext jc = JAXBContext.newInstance(Model.class);
        XMLFilter filter = new NamespaceFilter();
        filter.setParent(SAXParserFactory.newInstance().newSAXParser().getXMLReader());
        UnmarshallerHandler unmarshallerHandler = jc.createUnmarshaller().getUnmarshallerHandler();
        filter.setContentHandler(unmarshallerHandler);
        filter.parse(inputSource);
        return (Model) ((JAXBElement)unmarshallerHandler.getResult()).getValue();
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
}
 

import javax.xml.bind.UnmarshallerHandler; //导入依赖的package包/类
public UnmarshallerHandler getUnmarshallerHandler() {
    
    // use InterningUnmarshallerHandler since we don't know
    // if the caller will intern Strings before firing SAX events.
    
    // we don't know the Locator to be used,
    // but SAXLocator would always be a good default,
    // as the source of SAX2 events can always set org.xml.sax.Locator.
    return new InterningUnmarshallerHandler( 
            createUnmarshallerHandler(new SAXLocator()));
}
 

import javax.xml.bind.UnmarshallerHandler; //导入依赖的package包/类
public UnmarshallerHandler getUnmarshallerHandler() {
    return getUnmarshallerHandler(true,null);
}
 

import javax.xml.bind.UnmarshallerHandler; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public static synchronized void init(URI uri, Class<?> callingClass) throws XMLSecurityException {
    if (initialized == null || uri != null && !uri.equals(initialized)) {
        try {
            JAXBContext jaxbContext = JAXBContext.newInstance(ObjectFactory.class);
            final Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
            SchemaFactory schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
            Schema schema = schemaFactory.newSchema(
                    ClassLoaderUtils.getResource("schemas/security-config.xsd", Init.class));
            unmarshaller.setSchema(schema);
            final UnmarshallerHandler unmarshallerHandler = unmarshaller.getUnmarshallerHandler();

            SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
            saxParserFactory.setXIncludeAware(false);
            saxParserFactory.setNamespaceAware(true);
            SAXParser saxParser = saxParserFactory.newSAXParser();
            if (uri == null) {
                URL resource = ClassLoaderUtils.getResource("security-config.xml", Init.class);
                if (resource == null) {
                    //kind of chicken-egg problem here
                    I18n.init("en", "US");
                    throw new XMLSecurityConfigurationException("empty", "security-config.xml not found in classpath");
                }
                uri = resource.toURI();
            }
            saxParser.parse(uri.toURL().toExternalForm(), new XIncludeHandler(unmarshallerHandler));
            JAXBElement<ConfigurationType> configurationTypeJAXBElement = (JAXBElement<ConfigurationType>) unmarshallerHandler.getResult();

            ConfigurationProperties.init(configurationTypeJAXBElement.getValue().getProperties(), callingClass);
            SecurityHeaderHandlerMapper.init(configurationTypeJAXBElement.getValue().getSecurityHeaderHandlers(), callingClass);
            JCEAlgorithmMapper.init(configurationTypeJAXBElement.getValue().getJCEAlgorithmMappings());
            TransformerAlgorithmMapper.init(configurationTypeJAXBElement.getValue().getTransformAlgorithms(), callingClass);
            ResourceResolverMapper.init(configurationTypeJAXBElement.getValue().getResourceResolvers(), callingClass);

            I18n.init(ConfigurationProperties.getProperty("DefaultLanguageCode"), ConfigurationProperties.getProperty("DefaultCountryCode"));

        } catch (Exception e) {
            //kind of chicken-egg problem here
            I18n.init("en", "US");
            throw new XMLSecurityConfigurationException(e);
        }
        initialized = uri;
    }
}
 

import javax.xml.bind.UnmarshallerHandler; //导入依赖的package包/类
public Unmarshaller initializeUnmarshaller(MzMLIndexer index, MzMLNamespaceFilter xmlFilter, MzMLObjectCache cache, boolean useCacheForSpectra) {

        try {
            // Lazy caching of the JAXB Context.
            if(jc == null) {
                jc = JAXBContext.newInstance(ModelConstants.PACKAGE);
            }

            //create unmarshaller
            Unmarshaller unmarshaller = jc.createUnmarshaller();

            /*
               Sometimes it's convenient to maintain application states inside adapters; for example, if you have
               an adapter that converts string on XML into a java.lang.Class object, you might want to have a
                ClassLoader in an adapter.

               In JAXB, this is done by allowing applications to set configured instances of XmlAdapters
               to the unmarshaller/marshaller. This is also an opportunity to pass in a sub-class of the
               declared adapter, if you so wish.

               If the application doesn't provide a configured instance, JAXB will create
               one by calling the default constructor.
                */

            //it is not possible to concurrently reuse a common unmarshaller
            //across all the Adapters because of internal state conflicts
            //when trying to unmarshall a referenced object from within a
            //parent object.

            //create a cache object that will be common to all adapters in this unmarshaller
//            unmarshaller.setAdapter(new CVAdapter(index, cache));
//            unmarshaller.setAdapter(new DataProcessingAdapter(index, cache));
//            unmarshaller.setAdapter(new InstrumentConfigurationAdapter(index, cache));
//            unmarshaller.setAdapter(new ReferenceableParamGroupAdapter(index, cache));
//            unmarshaller.setAdapter(new SampleAdapter(index, cache));
//            unmarshaller.setAdapter(new SoftwareAdapter(index, cache));
//            unmarshaller.setAdapter(new SourceFileAdapter(index, cache));
//            unmarshaller.setAdapter(new SpectrumAdapter(index, cache, useCacheForSpectra));
//            unmarshaller.setAdapter(new ScanSettingsAdapter(index, cache));
//            unmarshaller.setEventHandler(new DefaultValidationEventHandler());

            unmarshaller.setListener(new RawXMLListener(index,cache));

            UnmarshallerHandler uh = unmarshaller.getUnmarshallerHandler();

            // Create a new XML parser
            SAXParserFactory factory = SAXParserFactory.newInstance();

//            WstxInputFactory inputFactory = new WstxInputFactory();
//            inputFactory.configureForSpeed();
//            SAXParserFactory factory = new WstxSAXParserFactory(inputFactory);

         //   SAXParserFactory factory = new WstxSAXParserFactory();

            factory.setNamespaceAware(true);
            SAXParser parser = factory.newSAXParser();
            XMLReader xmlReader = parser.getXMLReader();

            // Create a filter to intercept events -- and patch the missing namespace
            xmlFilter.setParent(xmlReader);
            xmlFilter.setContentHandler(uh);

            logger.debug("Unmarshaller Initialized");

            return unmarshaller;

        } catch (JAXBException | SAXException | ParserConfigurationException e) {
            logger.error("UnmarshallerFactory.initializeUnmarshaller", e);
            throw new IllegalStateException("Could not initialize unmarshaller");
        }

    }
 

import javax.xml.bind.UnmarshallerHandler; //导入依赖的package包/类
protected T unmarshall(File filename, InputSource xml, HashMap<String,String> extra_overrides)
    throws Exception
{
    SAXParserFactory spf = SAXParserFactory.newInstance();
    spf.setXIncludeAware(true);
    spf.setNamespaceAware(true);
    spf.setFeature("http://apache.org/xml/features/xinclude/fixup-base-uris", false);

    StreamSource schemaSource = new StreamSource(this.getClass().getResourceAsStream("/sdrun.xsd"));

    SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
    Schema schema = factory.newSchema(schemaSource);
    spf.setSchema(schema);

    NamespaceFiller filter = new NamespaceFiller(this.propertyOverrides(), extra_overrides);
    XMLReader xr = spf.newSAXParser().getXMLReader();
    filter.setParent(xr);

    Unmarshaller u = jc.createUnmarshaller();
    UnmarshallerHandler uh = u.getUnmarshallerHandler();
    u.setSchema(schema);
    u.setEventHandler(new DefaultValidationEventHandler());

    filter.setContentHandler(uh);
    try {
        filter.parse(xml);
    } catch(SAXParseException e) {
        filter.log_error(e);
        throw new XMLUnmarshallingFailure();
    }

    T result = (T) uh.getResult();
    if (result == null || filter.failed())
        throw new XMLUnmarshallingFailure();

    if (filter.conversion_hint)
        log.log(Logging.NOTICE,
                "Use the following command to convert old style files to the new format:\n" +
                "sed '1d; 2i <?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\\n<SDRun xmlns:xi=\"http://www.w3.org/2001/XInclude\" xmlns=\"{}\">\n" +
                "s#<(reactionScheme|morphology|stimulation|initialConditions|outputScheme)File>\\s*(\\w+)\\s*</.*>#<xi:include href=\"\\2.xml\" />#' -r -i.bak \"{}\"",
                NEURORD_NS,
                filename != null ? filename : "...");

    return result;
}