@Override public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) { JavaType javaType = mapper.getTypeFactory().constructType(type); ObjectReader reader = mapper.readerFor(javaType); return new JacksonResponseBodyConverter<>(reader); }
@Override public Object getObject(String string, Type type) { try { JavaType javaType = mapper.getTypeFactory().constructType(type); ObjectReader objectReader = mapper.readerFor(javaType); return objectReader.readValue(string); } catch (Exception e) { e.printStackTrace(); } return null; }
public <T> T readValue(Class<T> type, InputStream entityStream) throws IOException { ObjectReader reader = DeserializerStringCache.init( Optional.ofNullable(objectReaderByClass.get(type)).map(Supplier::get).orElseGet(()->mapper.readerFor(type)) ); try { return reader.readValue(entityStream); } finally { DeserializerStringCache.clear(reader, CacheScope.GLOBAL_SCOPE); } }
public <T> T readValue(Class<T> type, String text) throws IOException { ObjectReader reader = DeserializerStringCache.init( Optional.ofNullable(objectReaderByClass.get(type)).map(Supplier::get).orElseGet(()->mapper.readerFor(type)) ); try { return reader.readValue(text); } finally { DeserializerStringCache.clear(reader, CacheScope.GLOBAL_SCOPE); } }
private Map<String, StatsDMetric> readMap(ObjectMapper mapper, String dimensionMapPath) { try { InputStream is; if (Strings.isNullOrEmpty(dimensionMapPath)) { log.info("Using default metric dimension and types"); is = this.getClass().getClassLoader().getResourceAsStream("defaultMetricDimensions.json"); } else { log.info("Using metric dimensions at types at [%s]", dimensionMapPath); is = new FileInputStream(new File(dimensionMapPath)); } return mapper.readerFor(new TypeReference<Map<String, StatsDMetric>>() { }).readValue(is); } catch (IOException e) { throw new ISE(e, "Failed to parse metric dimensions and types"); } } }
private Map<String, Set<String>> readMap(ObjectMapper mapper, String metricMapPath) { try { InputStream is; if (Strings.isNullOrEmpty(metricMapPath)) { log.info("Using default metric map"); is = this.getClass().getClassLoader().getResourceAsStream("defaultMetrics.json"); } else { log.info("Using default metric map located at [%s]", metricMapPath); is = new FileInputStream(new File(metricMapPath)); } return mapper.readerFor(new TypeReference<Map<String, Set<String>>>() { }).readValue(is); } catch (IOException e) { throw new ISE(e, "Failed to parse metrics and dimensions"); } } }
@Test public void testSerialization() throws Exception { ObjectMapper objectMapper = new ObjectMapper(); BingTile tile = fromCoordinates(1, 2, 3); String json = objectMapper.writeValueAsString(tile); assertEquals("{\"x\":1,\"y\":2,\"zoom\":3}", json); assertEquals(tile, objectMapper.readerFor(BingTile.class).readValue(json)); }
@Test public void testSerDesBoundFilter() throws IOException { Injector defaultInjector = GuiceInjectors.makeStartupInjector(); ObjectMapper mapper = defaultInjector.getInstance(Key.get(ObjectMapper.class, Json.class)); String serBetweenDimFilter = mapper.writeValueAsString(boundDimFilter); BoundDimFilter actualBoundDimFilter = mapper.readerFor(DimFilter.class).readValue(serBetweenDimFilter); Assert.assertEquals(boundDimFilter, actualBoundDimFilter); }
@Test public void testSerDes() throws IOException { ObjectMapper mapper = new DefaultObjectMapper(); Assert.assertEquals(lookupExtractor, mapper.readerFor(LookupExtractor.class).readValue(mapper.writeValueAsBytes(lookupExtractor))); }
@Test public void testDeserialization() throws IOException { final InDimFilter actualInDimFilter = mapper.readerFor(DimFilter.class).readValue(actualInFilter); final InDimFilter expectedInDimFilter = new InDimFilter("dimTest", Arrays.asList("good", "bad"), null); Assert.assertEquals(expectedInDimFilter, actualInDimFilter); }
@Test public void shouldParsePayload() throws Exception { ObjectMapper mapper = mock(ObjectMapper.class); ObjectReader reader = mock(ObjectReader.class); when(mapper.readerFor(Payload.class)).thenReturn(reader); JWTParser parser = new JWTParser(mapper); parser.parsePayload("{}"); verify(reader).readValue("{}"); }
@Test public void shouldParseHeader() throws Exception { ObjectMapper mapper = mock(ObjectMapper.class); ObjectReader reader = mock(ObjectReader.class); when(mapper.readerFor(Header.class)).thenReturn(reader); JWTParser parser = new JWTParser(mapper); parser.parseHeader("{}"); verify(reader).readValue("{}"); }
@Before public void setUp() { log4jObjectMapper = newObjectMapper(); writer = log4jObjectMapper.writer(); reader = log4jObjectMapper.readerFor(Level.class); }
@Test public void TestSerDesr() throws IOException { LookupConfig lookupConfig = new LookupConfig(temporaryFolder.newFile().getAbsolutePath()); Assert.assertEquals( lookupConfig, mapper.readerFor(LookupConfig.class).readValue(mapper.writeValueAsString(lookupConfig)) ); }
@Test public void testSerDeserMapLookupExtractorFactory() throws IOException { ObjectMapper mapper = new DefaultObjectMapper(); mapper.registerSubtypes(MapLookupExtractorFactory.class); LookupExtractorFactory lookupExtractorFactory = new MapLookupExtractorFactory(ImmutableMap.of("key", "value"), true); Assert.assertEquals(lookupExtractorFactory, mapper.readerFor(LookupExtractorFactory.class).readValue(mapper.writeValueAsString(lookupExtractorFactory))); } }
@Test public void testContainer() throws IOException { final Fixture expected = new Fixture(); final String str = writer.writeValueAsString(expected); Assert.assertTrue(str.contains("DEBUG")); final ObjectReader fixtureReader = log4jObjectMapper.readerFor(Fixture.class); final Fixture actual = fixtureReader.readValue(str); Assert.assertEquals(expected, actual); }
@Before public void setUp() { final ObjectMapper log4jObjectMapper = newObjectMapper(); writer = log4jObjectMapper.writer(); reader = log4jObjectMapper.readerFor(Log4jMarker.class); MarkerManager.clear(); }
getObjectMapper().readerFor(javaType));
@Parameters @Test public void testSerDesr(DimensionSpec lookupDimSpec) throws IOException { ObjectMapper mapper = new DefaultObjectMapper(); mapper.registerSubtypes(new NamedType(LookupDimensionSpec.class, "lookup")); InjectableValues injectableValues = new InjectableValues.Std().addValue( LookupReferencesManager.class, LOOKUP_REF_MANAGER ); String serLookup = mapper.writeValueAsString(lookupDimSpec); Assert.assertEquals(lookupDimSpec, mapper.readerFor(DimensionSpec.class).with(injectableValues).readValue(serLookup)); }