Java JacksonXmlModule类代码示例

import com.fasterxml.jackson.dataformat.xml.JacksonXmlModule; //导入依赖的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.jackson.dataformat.xml.JacksonXmlModule; //导入依赖的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.jackson.dataformat.xml.JacksonXmlModule; //导入依赖的package包/类
/**
 * Creates properly configured Jackson XML Mapper instances.
 * @return XmlMapper instance.
 */
public static XmlMapper newInstance() {
    // Create new mapper
    final JacksonXmlModule module = new JacksonXmlModule();
    module.setDefaultUseWrapper(false);
    XmlMapper mapper = new XmlMapper(module);

    // Configure it
    mapper
        .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
        .setPropertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE)
        .registerModule(new JodaModule())
        .setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));

    return mapper;
}
 

import com.fasterxml.jackson.dataformat.xml.JacksonXmlModule; //导入依赖的package包/类
public POMXmlMapper() {
        JacksonXmlModule xmlModule = new JacksonXmlModule();
        xmlModule.setDefaultUseWrapper(false);

        registerModule(xmlModule);
//        registerModule(new JaxbAnnotationModule());
        registerModule(new HealthTimeModule());
        registerModule(new MetricsModule(TimeUnit.SECONDS, TimeUnit.MILLISECONDS, false));

        configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        configure(JsonGenerator.Feature.AUTO_CLOSE_TARGET, false);
        setSerializationInclusion(JsonInclude.Include.NON_NULL);

//        setAnnotationIntrospector(new JaxbAnnotationIntrospector(TypeFactory.defaultInstance()));

        addMixInAnnotations(IPOMObject.class, POMObjectJacksonXmlAnnotations.class);
    }
 

import com.fasterxml.jackson.dataformat.xml.JacksonXmlModule; //导入依赖的package包/类
@Override
public void exportStream(OutputStream outputStream, Iterator<T> iterator) throws IOException, ClassNotFoundException, IllegalAccessException {
    JacksonXmlModule module = new JacksonXmlModule();
    module.setDefaultUseWrapper(false);
    XmlMapper xmlMapper = new XmlMapper(module);
    XmlFactory factory = new XmlFactory();
    ToXmlGenerator generator = factory.createGenerator(outputStream);

    generator.setCodec(xmlMapper);
    generator.writeRaw("<xml>");

    while (iterator.hasNext()) {

        generator.writeRaw(xmlMapper.writeValueAsString(iterator.next()));
    }
    generator.writeRaw("</xml>");

    generator.flush();
}
 

import com.fasterxml.jackson.dataformat.xml.JacksonXmlModule; //导入依赖的package包/类
/**
 * Creates a new {@link com.fasterxml.jackson.dataformat.xml.XmlMapper} using Woodstox
 * with Logback and Joda Time support.
 * Also includes all {@link io.dropwizard.jackson.Discoverable} interface implementations.
 *
 * @return XmlMapper
 */
public static XmlMapper newXMLMapper(JacksonXmlModule jacksonXmlModule) {

    final XmlFactory woodstoxFactory = new XmlFactory(new WstxInputFactory(), new WstxOutputFactory());
    final XmlMapper mapper = new XmlMapper(woodstoxFactory, jacksonXmlModule);

    mapper.registerModule(new GuavaModule());
    mapper.registerModule(new LogbackModule());
    mapper.registerModule(new GuavaExtrasModule());
    mapper.registerModule(new JodaModule());
    mapper.registerModule(new FuzzyEnumModule());
    mapper.setPropertyNamingStrategy(new AnnotationSensitivePropertyNamingStrategy());
    mapper.setSubtypeResolver(new DiscoverableSubtypeResolver());

    return mapper;
}
 

import com.fasterxml.jackson.dataformat.xml.JacksonXmlModule; //导入依赖的package包/类
public Response(Map<String, String> headers, int httpStatus, String payload) {

        // configure the JacksonXml mapper in a cleaner way...
        JacksonXmlModule module = new JacksonXmlModule();
        // Check out: https://github.com/FasterXML/jackson-dataformat-xml
        // setDefaultUseWrapper produces more similar output to
        // the Json output. You can change that with annotations in your
        // models.
        module.setDefaultUseWrapper(false);
        this.xmlMapper = new XmlMapper(module);

        this.objectMapper = new ObjectMapper();

        this.headers = headers;
        this.httpStatus = httpStatus;
        this.payload = payload;

    }
 

import com.fasterxml.jackson.dataformat.xml.JacksonXmlModule; //导入依赖的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.jackson.dataformat.xml.JacksonXmlModule; //导入依赖的package包/类
/**
 * Default constructor.
 */
public ResponseHandler() {
    // Create new mapper
    final JacksonXmlModule module = new JacksonXmlModule();
    module.setDefaultUseWrapper(false);
    mapper = new XmlMapper(module);

    // Configure it
    mapper
        .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
        .setPropertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE)
        .registerModule(new JodaModule())
        .setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
}
 

import com.fasterxml.jackson.dataformat.xml.JacksonXmlModule; //导入依赖的package包/类
public static UpgradeProcessorsConfig newInstance(Path configFilePath)
    throws JsonParseException, JsonMappingException, IOException {
  JacksonXmlModule module = new JacksonXmlModule();
  module.setDefaultUseWrapper(false);
  XmlMapper xmlMapper = new XmlMapper(module);

  return xmlMapper.readValue(configFilePath.toFile(), UpgradeProcessorsConfig.class);
}
 

import com.fasterxml.jackson.dataformat.xml.JacksonXmlModule; //导入依赖的package包/类
private void save()
{
    saveTunerConfigurationModel();

    SystemProperties props = SystemProperties.getInstance();

    Path settingsFolder = props.getApplicationFolder("settings");

    String settingsDefault = props.get("settings.defaultFilename",
        "settings.xml");

    String settingsCurrent = props.get("settings.currentFilename",
        settingsDefault);

    Path settingsPath = settingsFolder.resolve(settingsCurrent);

    try(OutputStream out = Files.newOutputStream(settingsPath))
    {
        JacksonXmlModule xmlModule = new JacksonXmlModule();
        xmlModule.setDefaultUseWrapper(false);
        ObjectMapper objectMapper = new XmlMapper(xmlModule);
        objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
        objectMapper.writeValue(out, mSettings);
        out.flush();
    }
    catch(IOException ioe)
    {
        mLog.error("IO error while writing the settings to a file [" + settingsPath + "]", ioe);
    }
    catch(Exception e)
    {
        mLog.error("Error while saving settings file [" + settingsPath + "]", e);
    }
}
 

import com.fasterxml.jackson.dataformat.xml.JacksonXmlModule; //导入依赖的package包/类
/**
 * Erases current settings and loads settings from the settingsPath filename,
 * if it exists.
 */
public void load(Path settingsPath)
{
    mLoadingSettings = true;

    if(Files.exists(settingsPath))
    {
        mLog.info("SettingsManager - loading settings file [" + settingsPath.toString() + "]");

        JacksonXmlModule xmlModule = new JacksonXmlModule();
        xmlModule.setDefaultUseWrapper(false);
        ObjectMapper objectMapper = new XmlMapper(xmlModule);

        try(InputStream in = Files.newInputStream(settingsPath))
        {
            mSettings = objectMapper.readValue(in, Settings.class);
        }
        catch(IOException ioe)
        {
            mLog.error("IO error while reading settings file", ioe);
        }
    }
    else
    {
        mLog.info("SettingsManager - settings does not exist [" +
            settingsPath.toString() + "]");
    }

    if(mSettings == null)
    {
        mSettings = new Settings();
    }

    loadTunerConfigurationModel();

    mLoadingSettings = false;
}
 

import com.fasterxml.jackson.dataformat.xml.JacksonXmlModule; //导入依赖的package包/类
public Ds3SpecParserImpl() {
    module = new JacksonXmlModule();
    module.setDefaultUseWrapper(false);
    mapper = new XmlMapper(module);
    mapper.registerModule(new GuavaModule());
    final SimpleFilterProvider filterProvider = new SimpleFilterProvider().setFailOnUnknownId(false);
    mapper.setFilters(filterProvider);
}
 

import com.fasterxml.jackson.dataformat.xml.JacksonXmlModule; //导入依赖的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.jackson.dataformat.xml.JacksonXmlModule; //导入依赖的package包/类
@Override
protected ObjectMapper getObjectMapper() {
    // Check out: https://github.com/FasterXML/jackson-dataformat-xml
    JacksonXmlModule module = new JacksonXmlModule();
    // setDefaultUseWrapper produces more similar output to
    // the Json output. You can change that with annotations in your
    // models.
    module.setDefaultUseWrapper(false);
    return new XmlMapper(module);
}