Java ObjectMapper.enable方法代码示例

import com.fasterxml.jackson.databind.ObjectMapper; //导入方法依赖的package包/类
public String getJsonSchema() {
	ObjectMapper mapper = new ObjectMapper();
	try {
		mapper.enable(SerializationFeature.INDENT_OUTPUT);
		return mapper.writeValueAsString(jsonSchema);
	} catch (JsonProcessingException e) {
		throw new RuntimeException(e);
	}
}
 

import com.fasterxml.jackson.databind.ObjectMapper; //导入方法依赖的package包/类
private void writeTypescriptConfig() throws IOException {
	ObjectMapper mapper = new ObjectMapper();
	mapper.enable(SerializationFeature.INDENT_OUTPUT);
	ObjectNode root = mapper.createObjectNode();
	ObjectNode compilerOptions = root.putObject("compilerOptions");
	compilerOptions.put("baseUrl", "");
	compilerOptions.put("declaration", true);
	compilerOptions.put("emitDecoratorMetadata", true);
	compilerOptions.put("experimentalDecorators", true);
	compilerOptions.put("module", "es6");
	compilerOptions.put("moduleResolution", "node");
	compilerOptions.put("sourceMap", true);
	compilerOptions.put("target", "es5");
	ArrayNode typeArrays = compilerOptions.putArray("typeRoots");
	typeArrays.add("node_modules/@types");
	ArrayNode libs = compilerOptions.putArray("lib");
	libs.add("es6");
	libs.add("dom");

	File outputSourceDir = new File(outputDir, config.getSourceDirectoryName());
	File file = new File(outputSourceDir, "tsconfig.json");
	file.getParentFile().mkdirs();
	mapper.writer().writeValue(file, root);
}
 

import com.fasterxml.jackson.databind.ObjectMapper; //导入方法依赖的package包/类
@Override
public void configure(Map configs, boolean isKey) {
    String documentBasePackage = (String) configs.get("documentBasePackage");

    SimpleModule module = new SimpleModule();
    Set<Class<?>> annotatedClasses = ClassUtils.getAnnotatedClasses(documentBasePackage, Document.class);
    annotatedClasses.forEach(aClass -> module.addSerializer(aClass, new MetaableJkesJsonSerializer<>()));

    ObjectMapper mapper = new ObjectMapper();
    mapper.registerModule(module);

    // mapper.enable(SerializationFeature.INDENT_OUTPUT);
    mapper.enable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS); // Feature is enabled by default, so that date/time are by default serialized as timestamps.
    mapper.disable(SerializationFeature.WRITE_NULL_MAP_VALUES);

    this.mapper = mapper;
}
 

import com.fasterxml.jackson.databind.ObjectMapper; //导入方法依赖的package包/类
@Override
public void generate(Object obj, OutputStream os, boolean prettyPrint) {
    ObjectMapper mapper = new ObjectMapper();

    mapper.configure(SerializationFeature.CLOSE_CLOSEABLE, false);
    mapper.configure(SerializationFeature.FLUSH_AFTER_WRITE_VALUE, false);
    mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
    mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);

    if (prettyPrint) {
        mapper.enable(SerializationFeature.INDENT_OUTPUT);
    }

    SimpleModule module = new SimpleModule();
    module.addSerializer(CfnObject.class, new CfnObjectSerializer(resourceSpecificationService));
    module.addSerializer(IntrinsicFunction.class, new IntrinsicFunctionSerializer());
    mapper.registerModule(module);

    try {
        mapper.writeValue(os, obj);

        os.flush();
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
 

import com.fasterxml.jackson.databind.ObjectMapper; //导入方法依赖的package包/类
public DebugEndpoint() {
    om = new ObjectMapper();
    om.enable(SerializationFeature.INDENT_OUTPUT);
}
 

import com.fasterxml.jackson.databind.ObjectMapper; //导入方法依赖的package包/类
private JsonNode loadJson(InputStream inputStream) throws IOException {
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.enable(JsonParser.Feature.ALLOW_COMMENTS);
    return objectMapper.readTree(inputStream);
}
 

import com.fasterxml.jackson.databind.ObjectMapper; //导入方法依赖的package包/类
private static String jsonBeautify(String input) {
	ObjectMapper objectMapper = new ObjectMapper();
	objectMapper.enable(SerializationFeature.INDENT_OUTPUT);
    objectMapper.setDefaultPrettyPrinter(PrettyPrinter.instance);		
	JsonNode tree;
	String output;
	try {
		tree = objectMapper.readTree(input);
		output = objectMapper.writeValueAsString(tree);
	} catch (IOException e) {
		return input;
	}
	return output;
}
 

import com.fasterxml.jackson.databind.ObjectMapper; //导入方法依赖的package包/类
private String toJson(final Object object) throws JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper();
    mapper.enable(SerializationFeature.INDENT_OUTPUT);
    String jsonRep = "";
    jsonRep = mapper.writeValueAsString(object);
    return jsonRep;
}
 

import com.fasterxml.jackson.databind.ObjectMapper; //导入方法依赖的package包/类
private void writeDataToFile() throws IOException {
    ObjectMapper mapper = new ObjectMapper();
    mapper.enable(SerializationFeature.INDENT_OUTPUT);
    File recordFile = getRecordFile(testName);
    recordFile.createNewFile();
    mapper.writeValue(recordFile, recordedData);
}
 

import com.fasterxml.jackson.databind.ObjectMapper; //导入方法依赖的package包/类
default ConfigurationType fromJson(InputStream inputStream) throws IOException {
    TypeReference<ConfigurationType> typeReference = new TypeReference<ConfigurationType>() {
    };
    ObjectMapper mapper = new ObjectMapper();
    mapper.enable(JsonParser.Feature.ALLOW_COMMENTS);
    return mapper.readValue(inputStream, typeReference);
}
 

import com.fasterxml.jackson.databind.ObjectMapper; //导入方法依赖的package包/类
public static ObjectMapper createMapper(boolean pretty) {
    ObjectMapper mapper = new ObjectMapper();
    if (pretty) {
        mapper.enable(SerializationFeature.INDENT_OUTPUT);
    }
    return mapper;
}
 

import com.fasterxml.jackson.databind.ObjectMapper; //导入方法依赖的package包/类
@VisibleForTesting
public DrillConfig(Config config, boolean enableServerConfigs) {
  super(config);
  logger.debug("Setting up DrillConfig object.");
  logger.trace("Given Config object is:\n{}",
               config.root().render(ConfigRenderOptions.defaults()));
  mapper = new ObjectMapper();

  if (enableServerConfigs) {
    SimpleModule deserModule = new SimpleModule("LogicalExpressionDeserializationModule")
      .addDeserializer(LogicalExpression.class, new LogicalExpression.De(this))
      .addDeserializer(SchemaPath.class, new SchemaPath.De());

    mapper.registerModule(deserModule);
    mapper.enable(SerializationFeature.INDENT_OUTPUT);
    mapper.configure(Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
    mapper.configure(JsonGenerator.Feature.QUOTE_FIELD_NAMES, true);
    mapper.configure(Feature.ALLOW_COMMENTS, true);
    mapper.registerSubtypes(LogicalOperatorBase.getSubTypes(this));
    mapper.registerSubtypes(StoragePluginConfigBase.getSubTypes(this));
    mapper.registerSubtypes(FormatPluginConfigBase.getSubTypes(this));
  }

  RuntimeMXBean bean = ManagementFactory.getRuntimeMXBean();
  this.startupArguments = ImmutableList.copyOf(bean.getInputArguments());
  logger.debug("DrillConfig object initialized.");
}
 

import com.fasterxml.jackson.databind.ObjectMapper; //导入方法依赖的package包/类
@Test
public void toJson() throws Exception {
  String expected = "{\"accessControlType\":\"READ_ONLY\",\"databasePrefix\":\"name_\",\"federationType\":\"FEDERATED\",\"mappedDatabases\":[],\"metastoreTunnel\":null,\"name\":\"name\",\"remoteMetaStoreUris\":\"uri\",\"status\":\"UNKNOWN\"}";
  ObjectMapper mapper = new ObjectMapper();
  // Sorting to get deterministic test behaviour
  mapper.enable(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY);
  String json = mapper.writerFor(FederatedMetaStore.class).writeValueAsString(metaStore);
  assertThat(json, is(expected));
}
 

import com.fasterxml.jackson.databind.ObjectMapper; //导入方法依赖的package包/类
public static ProjectServices getInstance() {
     if(instance == null) {
        instance = new ProjectServices();
        mapper = new ObjectMapper();
        mapper.registerModule(new HueSerDeModule());
        
        mapper.enable(SerializationFeature.INDENT_OUTPUT);
        mapper.enable(JsonParser.Feature.ALLOW_COMMENTS);
        mapper.enable(JsonParser.Feature.ALLOW_SINGLE_QUOTES);
        mapper.enable(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES);
     }
     return instance;
}
 

import com.fasterxml.jackson.databind.ObjectMapper; //导入方法依赖的package包/类
@Before
public void setup(){
	mapper = new ObjectMapper();
       mapper.registerModule(new HueSerDeModule());
       
       mapper.enable(SerializationFeature.INDENT_OUTPUT);
       mapper.enable(JsonParser.Feature.ALLOW_COMMENTS);
       mapper.enable(JsonParser.Feature.ALLOW_SINGLE_QUOTES);
       mapper.enable(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES);
}