Java Code Examples for com.fasterxml.jackson.databind.ObjectWriter#writeValue()

/**
 * Write the actual JSON content to the stream.
 * @param stream the output stream to use
 * @param object the value to be rendered, as returned from {@link #filterModel}
 * @throws IOException if writing failed
 */
protected void writeContent(OutputStream stream, Object object) throws IOException {
	JsonGenerator generator = this.objectMapper.getFactory().createGenerator(stream, this.encoding);
	writePrefix(generator, object);

	Object value = object;
	Class<?> serializationView = null;
	FilterProvider filters = null;

	if (value instanceof MappingJacksonValue) {
		MappingJacksonValue container = (MappingJacksonValue) value;
		value = container.getValue();
		serializationView = container.getSerializationView();
		filters = container.getFilters();
	}

	ObjectWriter objectWriter = (serializationView != null ?
			this.objectMapper.writerWithView(serializationView) : this.objectMapper.writer());
	if (filters != null) {
		objectWriter = objectWriter.with(filters);
	}
	objectWriter.writeValue(generator, value);

	writeSuffix(generator, object);
	generator.flush();
}
 

/**
 * Map the given object to a {@link BytesMessage}.
 * @param object the object to be mapped
 * @param session current JMS session
 * @param objectWriter the writer to use
 * @return the resulting message
 * @throws JMSException if thrown by JMS methods
 * @throws IOException in case of I/O errors
 * @since 4.3
 * @see Session#createBytesMessage
 */
protected BytesMessage mapToBytesMessage(Object object, Session session, ObjectWriter objectWriter)
		throws JMSException, IOException {

	ByteArrayOutputStream bos = new ByteArrayOutputStream(1024);
	if (this.encoding != null) {
		OutputStreamWriter writer = new OutputStreamWriter(bos, this.encoding);
		objectWriter.writeValue(writer, object);
	}
	else {
		// Jackson usually defaults to UTF-8 but can also go straight to bytes, e.g. for Smile.
		// We use a direct byte array argument for the latter case to work as well.
		objectWriter.writeValue(bos, object);
	}

	BytesMessage message = session.createBytesMessage();
	message.writeBytes(bos.toByteArray());
	if (this.encodingPropertyName != null) {
		message.setStringProperty(this.encodingPropertyName,
				(this.encoding != null ? this.encoding : DEFAULT_ENCODING));
	}
	return message;
}
 

/**
 * Converts the json records into CSV format and writes to a file.
 *
 * @param hasHeader  whether the CSV file should have a header line.
 * @param sep  the column separator to use.
 * @param lines  the records in JSON format.
 * @param fs  {@link FileSystem} instance.
 * @param targetPath  File path.
 * @throws IOException
 */
public static void saveCsvToDFS(
    boolean hasHeader, char sep,
    String[] lines, FileSystem fs, String targetPath) throws IOException {
  Builder csvSchemaBuilder = CsvSchema.builder();

  ArrayNode arrayNode = mapper.createArrayNode();
  Arrays.stream(lines).forEachOrdered(
      line -> {
        try {
          arrayNode.add(mapper.readValue(line, ObjectNode.class));
        } catch (IOException e) {
          throw new HoodieIOException(
              "Error converting json records into CSV format: " + e.getMessage());
        }
      });
  arrayNode.get(0).fieldNames().forEachRemaining(csvSchemaBuilder::addColumn);
  ObjectWriter csvObjWriter = new CsvMapper()
      .writerFor(JsonNode.class)
      .with(csvSchemaBuilder.setUseHeader(hasHeader).setColumnSeparator(sep).build());
  PrintStream os = new PrintStream(fs.create(new Path(targetPath), true));
  csvObjWriter.writeValue(os, arrayNode);
  os.flush();
  os.close();
}
 

/**
 * Properties of file2 have precedence over the ones in file1
 */
@Override
public void merge(Path file1Path, Path file2Path, Path output) {
	ObjectMapper mapper = new ObjectMapper();
	ObjectWriter writer = mapper.writer(new DefaultPrettyPrinter());
	try (InputStream in1 = Files.newInputStream(file1Path)) {
		try (InputStream in2 = Files.newInputStream(file2Path)) {
			JsonNode file1 = mapper.readTree(in1);
			JsonNode file2 = mapper.readTree(in2);
			JsonNode merged = merge(file1, file2);
			writer.writeValue(output.toFile(), merged);
		}
	}
	catch (IOException e) {
		throw new UncheckedIOException(e);
	}
}
 

private void writeValue(ObjectWriter writer, PropertyFilter filter, Object value, OutputStream outputStream) throws IOException {
  JsonGenerator generator = writer.getFactory().createGenerator(outputStream);
  // Important: we are NOT to close the underlying stream after
  // mapping, so we need to instruct generator
  generator.disable(JsonGenerator.Feature.AUTO_CLOSE_TARGET);
  generator = new PropertyFilteringJsonGenerator(generator, filter);

  boolean ok = false;

  try {
    writer.writeValue(generator, value);
    ok = true;
  } finally {
    if (ok) {
      generator.close();
    } else {
      try {
        generator.close();
      } catch (Exception ignored) {}
    }
  }
}
 

private static void serialize0(final ObjectWriter writer, final Object toSerialize, final Buffer destination) {
    try {
        writer.writeValue(asOutputStream(destination), toSerialize);
    } catch (IOException e) {
        throwException(e);
    }
}
 

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

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

public static void main(String[] args) throws Exception {
	NodeList data = getDocument(GenWorlds.class.getResourceAsStream("/worlds.xml"));
	ArrayList<Region> regions = parseData(data);
	
	ObjectWriter writer = GenData.getWriter();
	writer.writeValue(new FileOutputStream("./dist/GameServer/system/static/world-data.json"), regions);
	
	System.out.println("Regions: "+regions);
}
 

/**
 * Writes parameters as JSON to an output stream.
 */
public static void write(LoadFlowParameters parameters, OutputStream outputStream) {
    try {
        ObjectMapper objectMapper = createObjectMapper();
        ObjectWriter writer = objectMapper.writerWithDefaultPrettyPrinter();
        writer.writeValue(outputStream, parameters);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

protected void writeAvroSchemaToFile( String schemaFilename ) throws KettleFileException, IOException {
  ObjectNode schemaObjectNode = this.getSchemaObjectNode();
  if ( schemaObjectNode != null && schemaFilename != null ) {
    ObjectMapper mapper = new ObjectMapper();
    ObjectWriter writer = mapper.writer( new DefaultPrettyPrinter() );
    writer.writeValue( KettleVFS.getOutputStream( schemaFilename, variableSpace, false ), schemaObjectNode );
  }
}
 

/**
 * Writes parameters as JSON to an output stream.
 */
public static void write(DynamicSimulationParameters parameters, OutputStream outputStream) {
    try {
        ObjectMapper objectMapper = createObjectMapper();
        ObjectWriter writer = objectMapper.writerWithDefaultPrettyPrinter();
        writer.writeValue(outputStream, parameters);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

public void generateCsvReport(List<ZeroCodeCsvReport> zeroCodeCsvReportRows) {

        /*
         * Write to a CSV file
         */
        CsvSchema schema = CsvSchema.builder()
                .setUseHeader(true)
                .addColumn("scenarioName")
                .addColumn("scenarioLoop", CsvSchema.ColumnType.NUMBER)
                .addColumn("stepName")
                .addColumn("stepLoop", CsvSchema.ColumnType.NUMBER)
                .addColumn("correlationId")
                .addColumn("requestTimeStamp")
                .addColumn("responseDelayMilliSec", CsvSchema.ColumnType.NUMBER)
                .addColumn("responseTimeStamp")
                .addColumn("result")
                .addColumn("method")
                .build();

        CsvMapper csvMapper = new CsvMapper();
        csvMapper.enable(CsvParser.Feature.WRAP_AS_ARRAY);

        ObjectWriter writer = csvMapper.writer(schema.withLineSeparator("\n"));
        try {
            writer.writeValue(
                    new File(TARGET_FULL_REPORT_DIR +
                            TARGET_FULL_REPORT_CSV_FILE_NAME
                            //"_" +
                            //LocalDateTime.now().toString().replace(":", "-") +
                            //".csv"
                    ),
                    zeroCodeCsvReportRows);

        } catch (IOException e) {
            e.printStackTrace();
            throw new RuntimeException("Exception while Writing full CSV report. Details: " + e);
        }
    }
 

/**
 * Writes parameters as JSON to an output stream.
 */
public static void write(SensitivityComputationParameters parameters, OutputStream outputStream) {
    Objects.requireNonNull(parameters);
    Objects.requireNonNull(outputStream);

    try {
        ObjectMapper objectMapper = createObjectMapper();
        ObjectWriter writer = objectMapper.writerWithDefaultPrettyPrinter();
        writer.writeValue(outputStream, parameters);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}
 

/**
 * Write sensitivity computation results in JSON format to writer
 * @param result The sensitivity computation results to export
 * @param writer The writer to write to
 * @throws IOException
 */
public static void write(SensitivityComputationResults result, Writer writer) throws IOException {
    Objects.requireNonNull(result);
    Objects.requireNonNull(writer);

    ObjectWriter objectWriter = JsonUtil.createObjectMapper().writerWithDefaultPrettyPrinter();
    objectWriter.writeValue(writer, result);
}
 

private void writeObjectToFile(final ObjectWriter objectWriter, final Object object, final File targetFile)
        throws IOException {
    targetFile.getParentFile().mkdirs();
    targetFile.createNewFile();
    objectWriter.writeValue(targetFile, object);
}
 

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

@Override
public void writeEvents( OutputStream outputStream, Events events, boolean withHeader )
    throws IOException
{
    ObjectWriter writer = CSV_MAPPER.writer( CSV_SCHEMA.withUseHeader( withHeader ) );

    List<CsvEventDataValue> dataValues = new ArrayList<>();

    for ( Event event : events.getEvents() )
    {
        CsvEventDataValue templateDataValue = new CsvEventDataValue();
        templateDataValue.setEvent( event.getEvent() );
        templateDataValue.setStatus( event.getStatus() != null ? event.getStatus().name() : null );
        templateDataValue.setProgram( event.getProgram() );
        templateDataValue.setProgramStage( event.getProgramStage() );
        templateDataValue.setEnrollment( event.getEnrollment() );
        templateDataValue.setOrgUnit( event.getOrgUnit() );
        templateDataValue.setEventDate( event.getEventDate() );
        templateDataValue.setDueDate( event.getDueDate() );
        templateDataValue.setStoredBy( event.getStoredBy() );
        templateDataValue.setCompletedDate( event.getCompletedDate() );
        templateDataValue.setCompletedBy( event.getCompletedBy() );

        if ( event.getGeometry() != null )
        {
            templateDataValue.setGeometry( event.getGeometry().toText() );

            if ( event.getGeometry().getGeometryType().equals( "Point" ) )
            {
                templateDataValue.setLongitude( event.getGeometry().getCoordinate().x );
                templateDataValue.setLatitude( event.getGeometry().getCoordinate().y );
            }
        }

        for ( DataValue value : event.getDataValues() )
        {
            CsvEventDataValue dataValue = new CsvEventDataValue( templateDataValue );
            dataValue.setDataElement( value.getDataElement() );
            dataValue.setValue( value.getValue() );
            dataValue.setProvidedElsewhere( value.getProvidedElsewhere() );

            if ( value.getStoredBy() != null )
            {
                dataValue.setStoredBy( value.getStoredBy() );
            }

            dataValues.add( dataValue );
        }
    }

    writer.writeValue( outputStream, dataValues );
}
 

private void writeWidgetMetadataInFile(Widget widget, Path path) throws IOException {
    ObjectWriter writer = new ObjectMapper().writer();
    writer.writeValue(path.toFile(), widget);
}
 

public static void writeToJsonFile(final ExportMetadata instance, final Path metadata) throws IOException {
	ObjectMapper mapper = new ObjectMapper();
	ObjectWriter writer = mapper.writer(new DefaultPrettyPrinter());
	writer.writeValue(metadata.toFile(), instance);
}
 

/**
 * Map the given object to a {@link TextMessage}.
 * @param object the object to be mapped
 * @param session current JMS session
 * @param objectWriter the writer to use
 * @return the resulting message
 * @throws JMSException if thrown by JMS methods
 * @throws IOException in case of I/O errors
 * @since 4.3
 * @see Session#createBytesMessage
 */
protected TextMessage mapToTextMessage(Object object, Session session, ObjectWriter objectWriter)
		throws JMSException, IOException {

	StringWriter writer = new StringWriter();
	objectWriter.writeValue(writer, object);
	return session.createTextMessage(writer.toString());
}