@Override protected ObjectMapper createInstance() { return new CsvMapper(); }
@Override public void write(final Map<String, Object> row) throws IOException { final byte[] bytes; if (shouldWriteHeader) { // Write the header once (mapper.writer will clone the writer). Add a small marker in front of the header // to easily split it write(String.format("-- %s ", currentTableName).getBytes()); bytes = mapper.writer(currentCSVSchema.withHeader()).writeValueAsBytes(row); shouldWriteHeader = false; } else { bytes = writer.writeValueAsBytes(row); } write(bytes); }
String input = "1,2\n3,4"; StringReader reader = new StringReader(input); CsvMapper m = new CsvMapper(); CsvSchema schema = m.schemaFor(FooBar.class).withoutHeader().withLineSeparator("\n").withColumnSeparator(','); try { MappingIterator<FooBar> r = m.reader(FooBar.class).with(schema).readValues(reader); while (r.hasNext()) { System.out.println(r.nextValue()); } } catch (JsonProcessingException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); }
public static final synchronized <T> String serialize(final T object, final Boolean withHeaders) throws IOException { CsvMapper csvMapper = new CsvMapper(); CsvSchema csvSchema = csvMapper.schemaFor(object.getClass()); if (withHeaders) { csvSchema = csvSchema.withHeader(); } else { csvSchema = csvSchema.withoutHeader(); } return csvMapper.writer(csvSchema).writeValueAsString(object); }
@Test public final void testRunSorterFirstColumnThenSecond() throws Exception { CsvFactory csvFactory = new CsvFactory(); csvFactory.enable(CsvParser.Feature.TRIM_SPACES); // csvFactory.enable(CsvParser.Feature.WRAP_AS_ARRAY); csvFactory.configure(JsonParser.Feature.ALLOW_YAML_COMMENTS, true); CsvMapper mapper = new CsvMapper(csvFactory); mapper.enable(CsvParser.Feature.TRIM_SPACES); // mapper.enable(CsvParser.Feature.WRAP_AS_ARRAY); mapper.configure(JsonParser.Feature.ALLOW_YAML_COMMENTS, true); // mapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, // true); CsvSchema schema = CsvSchema.builder().setUseHeader(false).build(); verifyCSV(testInput3, 1, 2, 5, mapper, schema); try (Reader inputReader = Files.newBufferedReader(testInput3, StandardCharsets.UTF_8)) { CSVSorter.runSorter(inputReader, testOutput, 1, schema, CSVSorter.getComparator(0, 1), true); } verifyCSV(testOutput, 1, 2, 5, mapper, schema); }
private static OffsetSerDe csvOffsetSerDe() { CsvMapper csvMapper = new CsvMapper().configure(CsvGenerator.Feature.STRICT_CHECK_FOR_QUOTING, true); CsvSchema schema = csvMapper.schemaFor(OffsetInfo.class).withLineSeparator(""); return new OffsetSerDe( csvMapper.writer(schema), csvMapper.reader(schema).forType(OffsetInfo.class)); }
rep = new JacksonRepresentation<MyBean[]>(MediaType.TEXT_CSV, tab) { @Override protected ObjectWriter createObjectWriter() { CsvMapper csvMapper = (CsvMapper) getObjectMapper(); CsvSchema csvSchema = csvMapper.schemaFor(MyBean.class); ObjectWriter result = csvMapper.writer(csvSchema); return result; } };
String lineSep = "\n"; CsvMapper mapper = new CsvMapper(); mapper.enable(JsonGenerator.Feature.IGNORE_UNKNOWN); CsvSchema schema = mapper.schemaFor(entry.getClass()); for (int i = 0; i < itemList.size(); i++) { if (i == 0) { schema = schema.withoutHeader(); String csv = mapper.writer(schema .withColumnSeparator(delimiter) .withoutQuoteChar()
/** * @param listOfMap * @param writer * @throws IOException */ public static void csvWriter(List<HashMap<String, String>> listOfMap, Writer writer) throws IOException { CsvSchema schema = null; CsvSchema.Builder schemaBuilder = CsvSchema.builder(); if (listOfMap != null && !listOfMap.isEmpty()) { for (String col : listOfMap.get(0).keySet()) { schemaBuilder.addColumn(col); } schema = schemaBuilder.build().withLineSeparator(System.lineSeparator()).withHeader(); } CsvMapper mapper = new CsvMapper(); mapper.writer(schema).writeValues(writer).writeAll(listOfMap); writer.flush(); }
private static <T> List<T> importCsvRules(Class<T> type, Class<?> mixin, String rulesString) throws Exception { CsvSchema csvSchema = CsvSchema.emptySchema().withHeader().withColumnSeparator(';'); CsvMapper mapper = new CsvMapper(); mapper.addMixIn(type, mixin); mapper.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT); mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, true); MappingIterator<T> readValues = mapper.readerFor(type).with(csvSchema).readValues(rulesString); return readValues.readAll(); }
public static LinkRelationTypes load() throws IOException { CsvMapper mapper = new CsvMapper(); mapper.enable(Feature.WRAP_AS_ARRAY); URL resource = LinkRelationTypes.class.getResource("/link-relations.csv"); MappingIterator<String[]> itr = mapper.readerFor(String[].class).readValues(resource); // Skip header itr.next(); Map<String, LinkRelationType> rels = new LinkedHashMap<>(); while (itr.hasNext()) { String[] row = itr.next(); String name = row[0]; String description = row[1]; String href = toHref(row[2]); rels.put(name, new LinkRelationType(name, description, href)); } return new LinkRelationTypes(rels); }
/** * Write a row to the destination. * * @param row The row to write. * @throws java.io.IOException Exception thrown when there's problems * writing to the output. */ @Override protected void writeToOutput(final Map<String, Object> row) throws IOException { if (writer == null) { CsvMapper mapper = new CsvMapper(); mapper.disable(SerializationFeature.CLOSE_CLOSEABLE); mapper.getFactory() .configure(JsonGenerator.Feature.AUTO_CLOSE_TARGET, false); CsvSchema schema = buildCsvSchema(row); writer = mapper.writer(schema); writer.writeValue(getWriter(), row.keySet()); } writer.writeValue(getWriter(), row.values()); }
FilterProvider filterProvider = new SimpleFilterProvider().addFilter( CSV_FILTER_NAME, csvReponseFilter ); CsvMapper csvMapper = new CsvMapper(); csvMapper.setFilters( filterProvider ); csvMapper.setAnnotationIntrospector( new CsvAnnotationIntrospector() ); ObjectWriter objectWriter = csvMapper.writer(csvSchema); objectWriter.writeValue( outputStream, objects);
private byte[] rulesToCsv(List<?> list, Class<?> type, Class<?> mixin) throws IOException { CsvMapper csvMapper = new CsvMapper(); CsvSchema csvSchema = csvMapper.schemaFor(type).withHeader().withColumnSeparator(';'); ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); try (SequenceWriter csvWriter = csvMapper .addMixIn(type, mixin) .writerWithDefaultPrettyPrinter() .with(csvSchema) .forType(type) .writeValues(outputStream)) { for (Object nextRow : list) { csvWriter.write(nextRow); } } return outputStream.toByteArray(); }
@Test public void testName() throws Exception { CsvMapper mapper = new CsvMapper(); mapper.registerModule(new SimpleModule().addDeserializer(EventList.class, new CsvEventDeserializer(metastore, new ProjectConfig(), new TestingConfigManager(), new SchemaChecker(metastore, build), build))); "1/2/09 4:53,Product2,1500\n"; EventList actual = mapper.reader(EventList.class).with(ContextAttributes.getEmpty() .withSharedAttribute("project", "project") .withSharedAttribute("collection", "collection")