public static ObjectReader getObjectReader() { return DEFAULT_OBJECT_MAPPER.reader(); }
public static <T> ObjectReader getObjectReader(Class<T> type) { final ObjectReader objectReader; if (getMapper().version().compareTo(new Version(2, 6, 0, null, "com.fasterxml.jackson.core", "jackson-databind")) >= 0) { objectReader = getMapper().readerFor(type); } else { objectReader = getMapper().reader(type); } return objectReader; } private static class AfterburnerModuleRegisterer {
public static ObjectReader reader() { return OBJECT_MAPPER.reader(); }
import com.fasterxml.jackson.databind.DeserializationFeature; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.ObjectReader; ObjectMapper objectMapper = new ObjectMapper(); objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); ObjectReader objectReader = objectMapper.reader(MyMappingClass.class); MyMappingClass myMappingClass = objectReader.readValue(json);
private boolean isAccumuloTable(byte[] data) throws IOException { // AccumuloTable does not contain a 'data' node return !mapper.reader().readTree(new String(data)).has("data"); }
private boolean isAccumuloView(byte[] data) throws IOException { // AccumuloView contains a 'data' node return mapper.reader().readTree(new String(data)).has("data"); }
/** * Initialize the JacksonProvider with a custom ObjectMapper. * @param objectMapper the ObjectMapper to use */ public JacksonJsonProvider(ObjectMapper objectMapper) { this(objectMapper, objectMapper.reader().withType(Object.class)); }
private Object getObjectFromPayload(Type type, ByteBuffer payload) throws IOException { if (type == void.class || payload.remaining() == 0) { return null; } JavaType javaType = mapper.getTypeFactory().constructType(type); return mapper.reader(javaType).readValue(BinaryUtils.copyAllBytesFrom(payload)); } }
private void addDeserializers(ObjectMapper mapper) { SimpleModule module = new SimpleModule(); ObjectReader reader = mapper.reader(); module.addDeserializer(Payload.class, new PayloadDeserializer(reader)); module.addDeserializer(Header.class, new HeaderDeserializer(reader)); mapper.registerModule(module); }
@Override public Object fromHash(Map<String, Object> hash) { try { if (flatten) { return typingMapper.reader().forType(Object.class) .readValue(untypedMapper.writeValueAsBytes(doUnflatten(hash))); } return typingMapper.treeToValue(untypedMapper.valueToTree(hash), Object.class); } catch (IOException e) { throw new MappingException(e.getMessage(), e); } }
@Override public void fillResponseFromJson(MatrixResponse matrixResponse, String responseAsString) throws IOException { fillResponseFromJson(matrixResponse, objectMapper.reader().readTree(responseAsString)); }
public void fillResponseFromJson(MatrixResponse matrixResponse, String responseAsString) throws IOException { fillResponseFromJson(matrixResponse, objectMapper.reader().readTree(responseAsString)); }
public EurekaJacksonCodec(String versionDeltaKey, String appsHashCodeKey) { this.versionDeltaKey = versionDeltaKey; this.appHashCodeKey = appsHashCodeKey; this.mapper = new ObjectMapper(); this.mapper.setSerializationInclusion(Include.NON_NULL); SimpleModule module = new SimpleModule("eureka1.x", VERSION); module.addSerializer(DataCenterInfo.class, new DataCenterInfoSerializer()); module.addSerializer(InstanceInfo.class, new InstanceInfoSerializer()); module.addSerializer(Application.class, new ApplicationSerializer()); module.addSerializer(Applications.class, new ApplicationsSerializer(this.versionDeltaKey, this.appHashCodeKey)); module.addDeserializer(LeaseInfo.class, new LeaseInfoDeserializer()); module.addDeserializer(InstanceInfo.class, new InstanceInfoDeserializer(this.mapper)); module.addDeserializer(Application.class, new ApplicationDeserializer(this.mapper)); module.addDeserializer(Applications.class, new ApplicationsDeserializer(this.mapper, this.versionDeltaKey, this.appHashCodeKey)); this.mapper.registerModule(module); Map<Class<?>, Supplier<ObjectReader>> readers = new HashMap<>(); readers.put(InstanceInfo.class, ()->mapper.reader().forType(InstanceInfo.class).withRootName("instance")); readers.put(Application.class, ()->mapper.reader().forType(Application.class).withRootName("application")); readers.put(Applications.class, ()->mapper.reader().forType(Applications.class).withRootName("applications")); this.objectReaderByClass = readers; Map<Class<?>, ObjectWriter> writers = new HashMap<>(); writers.put(InstanceInfo.class, mapper.writer().forType(InstanceInfo.class).withRootName("instance")); writers.put(Application.class, mapper.writer().forType(Application.class).withRootName("application")); writers.put(Applications.class, mapper.writer().forType(Applications.class).withRootName("applications")); this.objectWriterByClass = writers; }
/** * @param ipAddress IPv4 or IPv6 address to lookup. * @return An object of type T with the data for the IP address or null if no information could be found for the given IP address * @throws IOException if there is an error opening or reading from the file. */ private <T> T get(InetAddress ipAddress, Class<T> cls, boolean hasTraits, String type) throws IOException { String databaseType = this.getMetadata().getDatabaseType(); if (!databaseType.contains(type)) { String caller = Thread.currentThread().getStackTrace()[2].getMethodName(); throw new UnsupportedOperationException("Invalid attempt to open a " + databaseType + " database using the " + caller + " method"); } ObjectNode node = (ObjectNode) this.reader.get(ipAddress); if (node == null) { return null; } InjectableValues inject = new JsonInjector(ipAddress.getHostAddress()); return this.om.reader(inject).treeToValue(node, cls); }
public Consumer<DataBuffer> pojoConsumer(Pojo expected) { return dataBuffer -> { try { Pojo actual = this.mapper.reader().forType(Pojo.class) .readValue(DataBufferTestUtils.dumpBytes(dataBuffer)); assertEquals(expected, actual); release(dataBuffer); } catch (IOException ex) { throw new UncheckedIOException(ex); } }; }
private <T> Consumer<DataBuffer> expect(T expected, Class<T> expectedType) { return dataBuffer -> { try { Object actual = this.mapper.reader().forType(expectedType) .readValue(dataBuffer.asInputStream()); assertEquals(expected, actual); } catch (IOException e) { throw new UncheckedIOException(e); } finally { release(dataBuffer); } }; }
@Before public void setUp() throws Exception { deserializer = new PayloadDeserializer(new ObjectMapper().reader()); }
@Before public void setUp() throws Exception { mapper = getDefaultObjectMapper(); objectReader = mapper.reader(); expiresAt = Mockito.mock(Date.class); notBefore = Mockito.mock(Date.class); issuedAt = Mockito.mock(Date.class); Map<String, JsonNode> tree = new HashMap<>(); tree.put("extraClaim", new TextNode("extraValue")); payload = new PayloadImpl("issuer", "subject", Collections.singletonList("audience"), expiresAt, notBefore, issuedAt, "jwtId", tree, objectReader); }
@Before public void setUp() throws Exception { mapper = getDefaultObjectMapper(); objectReader = mapper.reader(); }
@Test public void testSimpleMapping() throws JsonGenerationException, JsonMappingException, IOException { ObjectMapper m = new JsonMapperProvider().get(); assertTrue(m.canSerialize(Any.class)); Struct struct1 = Struct.newBuilder().putFields( "some-key", Value.newBuilder().setStringValue("some-value").build() ).build(); Any source = Any.pack(struct1); StringWriter buf = new StringWriter(); m.writer().writeValue(buf, source); Any dest = m.reader().forType(Any.class).readValue(buf.toString()); assertEquals(source.getTypeUrl(), dest.getTypeUrl()); Struct struct2 = dest.unpack(Struct.class); assertTrue(struct2.containsFields("some-key")); assertEquals( struct1.getFieldsOrThrow("some-key").getStringValue(), struct2.getFieldsOrThrow("some-key").getStringValue() ); } }