import com.fasterxml.aalto.stax.InputFactoryImpl; //导入依赖的package包/类
protected XmlMapper getXmlMapper() {
    final XmlMapper xmlMapper = new XmlMapper(
            new XmlFactory(new InputFactoryImpl(), new OutputFactoryImpl()), new JacksonXmlModule());
    xmlMapper.setInjectableValues(new InjectableValues.Std().addValue(ODataClient.class, client));
    xmlMapper.addHandler(new DeserializationProblemHandler() {

        @Override
        public boolean handleUnknownProperty(final DeserializationContext ctxt, final JsonParser jp,
                final JsonDeserializer<?> deserializer, final Object beanOrClass, final String propertyName)
                throws IOException, JsonProcessingException {

            // skip any unknown property
            LOG.warn("Skipping unknown property {}", propertyName);
            ctxt.getParser().skipChildren();
            return true;
        }
    });
    return xmlMapper;
}
 

import com.fasterxml.aalto.stax.InputFactoryImpl; //导入依赖的package包/类
protected XmlMapper getXmlMapper() {
  final XmlMapper xmlMapper = new XmlMapper(
      new XmlFactory(new InputFactoryImpl(), new OutputFactoryImpl()), new JacksonXmlModule());

  xmlMapper.setInjectableValues(new InjectableValues.Std().addValue(Boolean.class, Boolean.FALSE));

  xmlMapper.addHandler(new DeserializationProblemHandler() {
    @Override
    public boolean handleUnknownProperty(final DeserializationContext ctxt, final JsonParser jp,
        final com.fasterxml.jackson.databind.JsonDeserializer<?> deserializer,
        final Object beanOrClass, final String propertyName)
        throws IOException, JsonProcessingException {

      // skip any unknown property
      ctxt.getParser().skipChildren();
      return true;
    }
  });
  return xmlMapper;
}
 

import com.fasterxml.aalto.stax.InputFactoryImpl; //导入依赖的package包/类
/**
 * Use the {@link FirstLevelSplitter} and split an XML string
 * @param xml the XML string
 * @return the chunks created by the splitter
 * @throws Exception if the XML string could not be parsed
 */
private List<Result<XMLChunkMeta>> split(String xml) throws Exception {
  Window window = new Window();
  window.append(Buffer.buffer(xml));
  AsyncXMLInputFactory xmlInputFactory = new InputFactoryImpl();
  AsyncXMLStreamReader<AsyncByteArrayFeeder> reader =
      xmlInputFactory.createAsyncForByteArray();
  byte[] xmlBytes = xml.getBytes(StandardCharsets.UTF_8);
  reader.getInputFeeder().feedInput(xmlBytes, 0, xmlBytes.length);
  FirstLevelSplitter splitter = new FirstLevelSplitter(window);
  List<Result<XMLChunkMeta>> chunks = new ArrayList<>();
  while (reader.hasNext()) {
    int event = reader.next();
    if (event == AsyncXMLStreamReader.EVENT_INCOMPLETE) {
      reader.close();
      continue;
    }
    int pos = reader.getLocation().getCharacterOffset();
    Result<XMLChunkMeta> chunk = splitter.onEvent(
        new XMLStreamEvent(event, pos, reader));
    if (chunk != null) {
      chunks.add(chunk);
    }
  }
  return chunks;
}
 

import com.fasterxml.aalto.stax.InputFactoryImpl; //导入依赖的package包/类
public static Edmx toMetadata(final InputStream input) {
    try {
        final XmlMapper xmlMapper = new XmlMapper(
                new XmlFactory(new InputFactoryImpl(), new OutputFactoryImpl()), new JacksonXmlModule());
        xmlMapper.addHandler(new DeserializationProblemHandler() {

            @Override
            public boolean handleUnknownProperty(final DeserializationContext ctxt, final JsonParser jp,
                    final JsonDeserializer<?> deserializer, final Object beanOrClass, final String propertyName)
                    throws IOException, JsonProcessingException {

                // 1. special handling of AbstractAnnotatedEdm's fields
                if (beanOrClass instanceof AbstractAnnotatedEdm
                        && AbstractAnnotatedEdmUtils.isAbstractAnnotatedProperty(propertyName)) {

                    AbstractAnnotatedEdmUtils.parseAnnotatedEdm((AbstractAnnotatedEdm) beanOrClass, jp);
                } // 2. skip any other unknown property
                else {
                    ctxt.getParser().skipChildren();
                }

                return true;
            }
        });
        return xmlMapper.readValue(input, Edmx.class);
    } catch (Exception e) {
        throw new IllegalArgumentException("Could not parse as Edmx document", e);
    }
}
 

import com.fasterxml.aalto.stax.InputFactoryImpl; //导入依赖的package包/类
public static XmlMapper createDefaultMapper() {
    XmlFactory f = new XmlFactory(new InputFactoryImpl(), new OutputFactoryImpl());
    
    XmlMapper mapper = new XmlMapper(f);
    mapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    mapper.configure(MapperFeature.AUTO_DETECT_GETTERS, false);
    mapper.configure(MapperFeature.AUTO_DETECT_IS_GETTERS, false);
    mapper.configure(MapperFeature.AUTO_DETECT_SETTERS, false);
    return mapper;
}
 

import com.fasterxml.aalto.stax.InputFactoryImpl; //导入依赖的package包/类
protected XMLODataError toODataErrorFromXML(final InputStream input) {
    try {
        final XmlMapper xmlMapper = new XmlMapper(
                new XmlFactory(new InputFactoryImpl(), new OutputFactoryImpl()), new JacksonXmlModule());
        return xmlMapper.readValue(input, XMLODataError.class);
    } catch (Exception e) {
        throw new IllegalArgumentException("While deserializing XML error", e);
    }
}
 

import com.fasterxml.aalto.stax.InputFactoryImpl; //导入依赖的package包/类
private static XMLODataError toODataErrorFromXML(final InputStream input) {
    try {
        final XmlMapper xmlMapper = new XmlMapper(
                new XmlFactory(new InputFactoryImpl(), new OutputFactoryImpl()), new JacksonXmlModule());
        return xmlMapper.readValue(input, XMLODataError.class);
    } catch (Exception e) {
        throw new IllegalArgumentException("While deserializing XML error", e);
    }
}
 

import com.fasterxml.aalto.stax.InputFactoryImpl; //导入依赖的package包/类
public StreamingXmlGraphParser(WayTag[] includedWayTags, WayTag[] excludedWayTags) {
    this.inputFactory = InputFactoryImpl.newFactory();
    this.includedWayTags = includedWayTags;
    this.excludedWayTags = excludedWayTags;
}
 

import com.fasterxml.aalto.stax.InputFactoryImpl; //导入依赖的package包/类
public XmlInputStream(InputStream inputStream) throws IOException {

        if(inputStream == null) {
            throw new IllegalArgumentException("inputStream should never be null");
        } else {
            this.is = inputStream;

            try {

                AsyncXMLInputFactory f = new InputFactoryImpl();
                f.configureForSpeed();

                Reader reader = new InputStreamReader(is,encoding);

                stream = (EventReaderImpl) f.createXMLEventReader(reader);


                //this.stream = ms_fact.createXMLEventReader(this.is);

            } catch (XMLStreamException var3) {
                throw new IOException(var3);
            }
        }
    }
 

import com.fasterxml.aalto.stax.InputFactoryImpl; //导入依赖的package包/类
@Test
public void testFullXml() throws Exception {
	InputFactoryImpl inputFactory = new InputFactoryImpl();
	AsyncXMLStreamReader streamReader = inputFactory.createAsyncXMLStreamReader();
	AsyncInputFeeder asyncInputFeeder = streamReader.getInputFeeder();
	
	byte[] xmlData = 
			(	"<?xml version='1.0'?>"
			+	"<someRootElement someAttribute='someAttributeValue' xmlns='http://someDomain.com/somePath'>"
			+		"<!-- Some Comment -->"
			+ 		"<someChildElement someChildElementAttribute='someChildElementAttributeValue'/>"
			+ 	"</someRootElement>").getBytes(StandardCharsets.UTF_8);
	
	asyncInputFeeder.feedInput(xmlData, 0, xmlData.length);
	
	StAXElementBuilder elementBuilder = new StAXElementBuilder(true);
	
	int event = -1;
	int elementsActive = 0;
	
	while ((event = streamReader.next()) > 0) {
		elementsActive += (event == 1 ? 1 : 0);
		elementsActive -= (event == 2 ? 1 : 0);

		elementBuilder.process(streamReader);
		
		if (event != 7 && elementsActive < 1) {
			break;
		}
	}
	
	Element someRootElement = elementBuilder.getElement();
	
	Assert.assertNotNull(someRootElement);
	Assert.assertEquals("someRootElement", someRootElement.getName());
	Assert.assertEquals("someAttributeValue", someRootElement.getAttributeValue("someAttribute"));
	Assert.assertEquals("http://someDomain.com/somePath", someRootElement.getNamespaceURI());
	
	Element someChildElement = someRootElement.getChildren().get(0);

	Assert.assertNotNull(someChildElement);
	Assert.assertEquals("someChildElement", someChildElement.getName());
	Assert.assertEquals("someChildElementAttributeValue", someChildElement.getAttributeValue("someChildElementAttribute"));
}