Java 类com.fasterxml.jackson.databind.ObjectWriter 实例源码

@Test
public void testBadSendMessage() throws Exception {
    SendMessageDTO message = new SendMessageDTO();
    message.setTo("JonkiPro2");

    ObjectMapper mapper = new ObjectMapper();
    mapper.configure(SerializationFeature.WRAP_ROOT_VALUE, false);
    ObjectWriter ow = mapper.writer().withDefaultPrettyPrinter();
    String requestJson = ow.writeValueAsString(message);

    mockMvc
            .perform(post("/api/v1.0/messages/")
                    .with(user(USERNAME).password(PASSWORD).roles(ROLE))
                    .contentType(MediaType.APPLICATION_JSON_UTF8_VALUE)
                    .content(requestJson))
            .andExpect(status().isBadRequest());
}

public boolean exportStatus(String outputFile) {
    Repository frozenRepository = this.repository.getSnapshotTo(this.repository.getRoot());

    File dumpFile = new File(outputFile);

    try(FileWriter fw = new FileWriter(dumpFile.getAbsoluteFile()); BufferedWriter bw = new BufferedWriter(fw)) {
        JsonNodeFactory jsonFactory = new JsonNodeFactory(false);
        ObjectNode mainNode = jsonFactory.objectNode();
        for (ByteArrayWrapper address : frozenRepository.getAccountsKeys()) {
            if(!address.equals(new ByteArrayWrapper(ZERO_BYTE_ARRAY))) {
                mainNode.set(Hex.toHexString(address.getData()), createAccountNode(mainNode, address.getData(), frozenRepository));
            }
        }
        ObjectMapper mapper = new ObjectMapper();
        ObjectWriter writer = mapper.writerWithDefaultPrettyPrinter();
        bw.write(writer.writeValueAsString(mainNode));
        return true;
    } catch (IOException e) {
        logger.error(e.getMessage(), e);
        panicProcessor.panic("dumpstate", e.getMessage());
        return false;
    }
}

public void saveProfile() throws IOException {
    ObjectMapper mapper = new ObjectMapper();
    ObjectWriter ow = mapper.writer().withDefaultPrettyPrinter();
    ow.writeValue(new File(profileFileName), localClient().getProfile());
}

@Test
public void testWriteValueOutputStreamObject() {
  boolean status = true;
  String[] stringArray = new String[1];
  stringArray[0] = "abc";

  new MockUp<ObjectWriter>() {
    @Mock
    public void writeValue(OutputStream out,
        Object value) throws IOException, JsonGenerationException, JsonMappingException {

    }
  };
  try {
    StandardObjectWriter.writeValue(outputStream,
        stringArray);
  } catch (IOException e) {
    status = false;
  }

  Assert.assertTrue(status);
}

@Override
public boolean execute(String[] tokens, String line) throws Exception {
    if (tokens.length < 2) {
        err.println("Usage: " + syntaxString());
        return false;
    }
    if (!checkStoreSettings()) return false;

    StringReader sr = new StringReader(line);
    while (sr.read() != ' ');
    JsonParser jp = mjf.createParser(sr);

    JsonNode keyNode = validateJson(jp);
    if (keyNode == null) return false;

    ObjectWriter writer = mapper.writerWithDefaultPrettyPrinter();
    out.println("Deleting Key:");
    out.println(writer.writeValueAsString(keyNode));
    out.println("");

    storeClient.delete(keyNode);
    out.println("Success");

    return false;
}

public static void write(SecurityAnalysisResult result, Writer writer) throws IOException {
    Objects.requireNonNull(result);
    Objects.requireNonNull(writer);

    ObjectMapper objectMapper = new ObjectMapper();
    SimpleModule module = new SimpleModule();
    module.addSerializer(SecurityAnalysisResult.class, new SecurityAnalysisResultSerializer());
    module.addSerializer(NetworkMetadata.class, new NetworkMetadataSerializer());
    module.addSerializer(PostContingencyResult.class, new PostContingencyResultSerializer());
    module.addSerializer(LimitViolationsResult.class, new LimitViolationsResultSerializer());
    module.addSerializer(LimitViolation.class, new LimitViolationSerializer());
    module.addSerializer(ContingencyElement.class, new ContingencyElementSerializer());
    objectMapper.registerModule(module);

    ObjectWriter objectWriter = objectMapper.writerWithDefaultPrettyPrinter();
    objectWriter.writeValue(writer, result);

}

@Override
public void close() throws IOException {
    try {
        final EncryptedDataContainer encrypted = cipher.doFinal();
        super.write(encrypted.getContent());
        final String tag = CryptoUtils.byteArrayToString(encrypted.getTag());
        final ObjectReader reader = session.getClient().getJSON().getContext(null).readerFor(FileKey.class);
        final FileKey fileKey = reader.readValue(status.getFilekey().array());
        fileKey.setTag(tag);
        final ObjectWriter writer = session.getClient().getJSON().getContext(null).writerFor(FileKey.class);
        final ByteArrayOutputStream out = new ByteArrayOutputStream();
        writer.writeValue(out, fileKey);
        status.setFilekey(ByteBuffer.wrap(out.toByteArray()));
    }
    catch(CryptoSystemException e) {
        throw new IOException(e);
    }
    finally {
        super.close();
    }
}

@Override
public String getText(JsonNode jsonNode, int prettyIndent) throws ServiceException {

    ObjectMapper mapper = new ObjectMapper();
    try {
        ObjectWriter writer;
        if (prettyIndent > 0)
            writer = mapper.writer(new JacksonPrettyPrinter(prettyIndent));
        else
            writer = mapper.writer();

        return writer.writeValueAsString(jsonNode);
    }
    catch (JsonProcessingException ex) {
        throw new ServiceException(Status.INTERNAL_ERROR, ex.getMessage(), ex);
    }
}

@Override
public Void pre(final Transfer.Type type, final Map<Path, TransferStatus> files, final ConnectionCallback callback) throws BackgroundException {
    try {
        switch(type) {
            case download:
                break;
            default:
                if(session.userAccount().isEncryptionEnabled()) {
                    for(Map.Entry<Path, TransferStatus> entry : files.entrySet()) {
                        if(containerService.getContainer(entry.getKey()).getType().contains(Path.Type.vault)) {
                            final TransferStatus status = entry.getValue();
                            final FileKey fileKey = TripleCryptConverter.toSwaggerFileKey(Crypto.generateFileKey());
                            final ObjectWriter writer = session.getClient().getJSON().getContext(null).writerFor(FileKey.class);
                            final ByteArrayOutputStream out = new ByteArrayOutputStream();
                            writer.writeValue(out, fileKey);
                            status.setFilekey(ByteBuffer.wrap(out.toByteArray()));
                        }
                    }
                }
        }
        return null;
    }
    catch(IOException e) {
        throw new DefaultIOExceptionMappingService().map(e);
    }
}

@Override
public String getConfiguration() {
    try {

        ObjectWriter writer = mapper.writerWithDefaultPrettyPrinter();

        return writer.writeValueAsString(currentConfig);
    } catch (JsonProcessingException e) {
        logger.error("Error writing configuration to string", e);
        return e.toString();
    }
}

protected void writeEmptyHostJsonFile(final ObjectWriter objectWriter) throws IOException {
    info("");
    info(SAVE_HOST_JSON);
    final File hostJsonFile = Paths.get(getDeploymentStageDirectory(), HOST_JSON).toFile();
    writeObjectToFile(objectWriter, new Object(), hostJsonFile);
    info(SAVE_SUCCESS + hostJsonFile.getAbsolutePath());
}

@Override
public HashMap<String, String> getStringMap(Object object) {
    try {
        TypeReference<HashMap<String, String>> typeRef
                = new TypeReference<HashMap<String, String>>() {
        };
        ObjectWriter objectWriter = mapper.writerFor(object.getClass());
        return mapper.readValue(objectWriter.writeValueAsString(object), typeRef);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return new HashMap<>();
}

@Test
public void testJSONGeneratorConfigured() throws IOException {
  JSONPrettyPrintFilter filter = new JSONPrettyPrintFilter();
  ContainerRequest request = ContainerRequestBuilder.from("http://localhost/foo/bar?pretty", "GET").accept("random/media").build();
  ContainerResponse response = new ContainerResponse(request, Response.ok().build());
  filter.filter(request, response);

  ObjectWriterModifier modifier = ObjectWriterInjector.get();
  assertNotNull(modifier);
  JsonGenerator g = mock(JsonGenerator.class);
  modifier.modify(mock(JsonEndpointConfig.class), new MultivaluedHashMap<String, Object>(), new Object(), mock(ObjectWriter.class), g);

  verify(g).useDefaultPrettyPrinter();
}

@Override
public Converter<?, RequestBody> requestBodyConverter(Type type,
    Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
  JavaType javaType = mapper.getTypeFactory().constructType(type);
  ObjectWriter writer = mapper.writerFor(javaType);
  return new JacksonRequestBodyConverter<>(writer);
}

@Override
public String getString(Object object) {
    try {
        ObjectWriter objectWriter = mapper.writerFor(object.getClass());
        return objectWriter.writeValueAsString(object);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return "";
}

@Override
public boolean execute(String[] tokens, String line) throws Exception {
    if (tokens.length < 3) {
        err.println("Usage: " + syntaxString());
        return false;

    }
    if (!checkStoreSettings()) return false;

    StringReader sr = new StringReader(line);
    while (sr.read() != ' ');
    JsonParser jp = mjf.createParser(sr);

    JsonNode keyNode = validateJson(jp);
    if (keyNode == null) return false;
    JsonNode valueNode = validateJson(jp);
    if (valueNode == null) return false;

    ObjectWriter writer = mapper.writerWithDefaultPrettyPrinter();
    out.println("Putting Key:");
    out.println(writer.writeValueAsString(keyNode));
    out.println("\nValue:");
    out.println(writer.writeValueAsString(valueNode));
    out.flush();

    storeClient.put(keyNode, valueNode);
    out.println("Success");

    return false;
}

@Test
public void parseSimplePlan() throws Exception{
  LogicalPlanPersistence lpp = new LogicalPlanPersistence(DEFAULT_SABOT_CONFIG, CLASSPATH_SCAN_RESULT);

  PhysicalPlanReader reader = new PhysicalPlanReader(DEFAULT_SABOT_CONFIG, CLASSPATH_SCAN_RESULT, lpp, CoordinationProtos.NodeEndpoint.getDefaultInstance(), null, Mockito.mock(SabotContext.class));
  ObjectWriter writer = lpp.getMapper().writer();
  PhysicalPlan plan = reader.readPhysicalPlan(Files.toString(FileUtils.getResourceAsFile("/physical_test1.json"), Charsets.UTF_8));
  String unparse = plan.unparse(writer);
}

static byte[] serialize(final Object value) {
    final ObjectWriter writer = MAPPER.writerFor(value.getClass());

    try {
        return writer.writeValueAsBytes(value);
    } catch (final JsonProcessingException e) {
        throw new IllegalArgumentException("Unable to serialize given value: " + value, e);
    }
}

@Override
public String toString() {
    ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
    try {
        return ow.writeValueAsString(this);
    } catch (JsonProcessingException e) {
        return "Could Not Marshal Object to JSON";
    }
}

@CsapDoc ( notes = {
        "Health Check for eman. Alert Level can be used to customize thresholds.",
        CsapDoc.INDENT + "A configured limit of 100, with alertLevel=1.5 will become 150"
} , produces = "plain/txt" )
@RequestMapping ( "/emanStatus" )
public String emanStatus (
                            @RequestParam ( value = "alertLevel" , required = false , defaultValue = "1.0" ) double alertLevelForFiltering ) {

    logger.debug( "AlertLevel : {}", alertLevelForFiltering );
    String result = "Failure";
    try {
        // check vm connections
        ObjectNode errorNode = csapApp.buildErrorsForAdminOrAgent( alertLevelForFiltering );

        if ( errorNode.size() == 0 ) {
            result = "Success";
        } else {
            ObjectWriter writer = jacksonMapper.writerWithDefaultPrettyPrinter();
            result = "Failure\n" + writer.writeValueAsString( errorNode );
        }

    } catch (Exception e) {
        logger.error( "Failed: ", e );
    }

    return result;
}

private String getErrors(TransformException exception) throws JsonProcessingException {
    ObjectWriter jsonObjectWriter = new ObjectMapper()
            .setSerializationInclusion(JsonInclude.Include.NON_NULL)
            .writer()
            .withDefaultPrettyPrinter();
    return jsonObjectWriter.writeValueAsString(exception.getDetails());
}

/**
 * Write out the errors to a file.
 *
 * @param allErrors The errors to write.
 * @param outFile The location to write.
 */
private void writeOutErrors(AllErrors allErrors, Path outFile) {
    try (Writer writer = Files.newBufferedWriter(outFile)) {
        ObjectWriter jsonObjectWriter = new ObjectMapper()
                .setSerializationInclusion(JsonInclude.Include.NON_NULL)
                .writer()
                .withDefaultPrettyPrinter();
        jsonObjectWriter.writeValue(writer, allErrors);
    } catch (IOException exception) {
        DEV_LOG.error("Could not write out error JSON to file", exception);
    }
}

public static void write(LoadFlowResult result, Path jsonFile) {
    Objects.requireNonNull(result);
    Objects.requireNonNull(jsonFile);

    try (OutputStream os = Files.newOutputStream(jsonFile)) {
        ObjectMapper objectMapper = new ObjectMapper();
        SimpleModule module = new SimpleModule();
        module.addSerializer(LoadFlowResult.class, new LoadFlowResultSerializer());
        objectMapper.registerModule(module);
        ObjectWriter writer = objectMapper.writerWithDefaultPrettyPrinter();
        writer.writeValue(os, result);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}

/**
 * Serialize a list of objects with a particular set of attributes
 * @param view
 * @return
 * @throws IOException 
 */
public JsonNode jsonSerialization(Class view) throws IOException
{
    ObjectMapper mapper = new ObjectMapper();

    DateFormat myDateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS");
    mapper.setDateFormat(myDateFormat); 
    mapper.disable(MapperFeature.DEFAULT_VIEW_INCLUSION);

    ObjectWriter writer = mapper.writerWithView(view);
    JsonNode response = mapper.readTree(writer.writeValueAsString(this));
    return response;
}

protected ObjectWriter getWriter(Format format, int prettyIndent) {
    ObjectMapper mapper = getMapper(format);
    if (prettyIndent > 0)
        return mapper.writer(new JacksonPrettyPrinter(prettyIndent));
    else
        return mapper.writer();        
}

@Override
public ObjectWriter modify(EndpointConfigBase<?> endpointConfigBase, MultivaluedMap<String, Object> multivaluedMap,
                           Object o, ObjectWriter objectWriter, JsonGenerator jsonGenerator) throws IOException {

    jsonGenerator.useDefaultPrettyPrinter();
    return objectWriter;
}

@Override
public String toString() {
    ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
    try {
        return ow.writeValueAsString(this);
    } catch (JsonProcessingException e) {
        return "Could Not Marshal Object to JSON";
    }
}

/**
 * Returns an ObjectWriter with the project default settings.
 * @param features the SerializationFeatures to be enabled, overwriting the project defaults
 * @return ObjectWriter
 */
public static ObjectWriter writer(SerializationFeature... features) {
    if (features.length == 0) {
        return mapper.writer();
    } else if (features.length == 1) {
        return mapper.writer(features[0]);
    } else {
        return mapper.writer(features[0], Arrays.copyOfRange(features, 1, features.length));
    }
}

@Override
public String toString() {
    ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
    try {
        return ow.writeValueAsString(this);
    } catch (JsonProcessingException e) {
        return "Could Not Marshal Object to JSON";
    }
}

@Override
public String toString() {
    ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
    try {
        return ow.writeValueAsString(this);
    } catch (JsonProcessingException e) {
        return "Could Not Marshal Object to JSON";
    }
}

private String toJson(Object src) {
    try {
        ObjectWriter defaultPrettyPrinter = objectMapper.writerWithDefaultPrettyPrinter();
        return defaultPrettyPrinter.writeValueAsString(src);
    } catch (Exception e) {
        log.error("Error during converting object to JSON", e);
        return "{}";
    }
}

@Override
public String toString() {
    ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
    try {
        return ow.writeValueAsString(this);
    } catch (JsonProcessingException e) {
        return "Could Not Marshal Object to JSON";
    }
}

@Override
public String toString() {
    ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
    try {
        return ow.writeValueAsString(this);
    } catch (JsonProcessingException e) {
        return "Could Not Marshal Object to JSON";
    }
}

@Override
public String toString() {
    ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
    try {
        return ow.writeValueAsString(this);
    } catch (JsonProcessingException e) {
        return "Could Not Marshal Object to JSON";
    }
}

@Override
public String toString() {
    ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
    try {
        return ow.writeValueAsString(this);
    } catch (JsonProcessingException e) {
        return "Could Not Marshal Object to JSON";
    }
}

@Override
public String toString() {
    ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
    try {
        return ow.writeValueAsString(this);
    } catch (JsonProcessingException e) {
        return "Could Not Marshal Object to JSON";
    }
}

/** Converts a physical plan to a string. (Opposite of {@link #parse}.) */
public String unparse(ObjectWriter writer) {
  try {
    return writer.writeValueAsString(this);
  } catch (JsonProcessingException e) {
    throw new RuntimeException(e);
  }
}

@Override
public String toString() {
    ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
    try {
        return ow.writeValueAsString(this);
    } catch (JsonProcessingException e) {
        return "Could Not Marshal Object to JSON";
    }
}

@Override
public String toString() {
    ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
    try {
        return ow.writeValueAsString(this);
    } catch (JsonProcessingException e) {
        return "Could Not Marshal Object to JSON";
    }
}

@Override
public String toString() {
    ObjectWriter ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
    try {
        return ow.writeValueAsString(this);
    } catch (JsonProcessingException e) {
        return "Could Not Marshal Object to JSON";
    }
}