@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 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<>(); } }
@Override public Parser<?, RequestBody> requestBodyParser(Type type) { JavaType javaType = mapper.getTypeFactory().constructType(type); ObjectWriter writer = mapper.writerFor(javaType); return new JacksonRequestBodyParser<>(writer); }
@Autowired public JacksonRequestStreamHandler(ObjectMapper mapper, RequestHandler<IN, OUT> innerHandler) { this.innerHandler = innerHandler; Map<TypeVariable<?>, Type> arguments = TypeUtils.getTypeArguments(innerHandler.getClass(), RequestHandler.class); Type inputType = arguments.get(PARAMETERS[0]); Type outputType = arguments.get(PARAMETERS[1]); this.reader = mapper.readerFor(mapper.constructType(inputType)); this.writer = mapper.writerFor(mapper.constructType(outputType)); }
@Override public void encode(BsonWriter writer, T value, EncoderContext encoderContext) { final BsonGenerator generator = new BsonGenerator(0, mapper, writer); try { mapper.writerFor(getEncoderClass()).writeValue(generator, value); } catch (IOException e) { throw new RuntimeException("Couldn't serialize [" + value + "] as " + getEncoderClass(), e); } }
) throws JsonProcessingException final String checkpoints = sortingMapper.writerFor(new TypeReference<TreeMap<Integer, Map<String, String>>>()
private Long saveDerivedSchema(Connection conn) throws SQLException { PreparedStatement insert = conn.prepareStatement( "INSERT into `schemas` SET base_schema_id = ?, deltas = ?, binlog_file = ?, " + "binlog_position = ?, server_id = ?, charset = ?, version = ?, " + "position_sha = ?, gtid_set = ?, last_heartbeat_read = ?", Statement.RETURN_GENERATED_KEYS); String deltaString; try { deltaString = mapper.writerFor(listOfResolvedSchemaChangeType).writeValueAsString(deltas); } catch ( JsonProcessingException e ) { throw new RuntimeException("Couldn't serialize " + deltas + " to JSON."); } BinlogPosition binlogPosition = position.getBinlogPosition(); return executeInsert( insert, this.baseSchemaID, deltaString, binlogPosition.getFile(), binlogPosition.getOffset(), serverID, schema.getCharset(), SchemaStoreVersion, getPositionSHA(), binlogPosition.getGtidSetStr(), position.getLastHeartbeatRead() ); }
protected LambdaContainerHandler(Class<RequestType> requestClass, Class<ResponseType> responseClass, RequestReader<RequestType, ContainerRequestType> requestReader, ResponseWriter<ContainerResponseType, ResponseType> responseWriter, SecurityContextWriter<RequestType> securityContextWriter, ExceptionHandler<ResponseType> exceptionHandler) { log.info("Starting Lambda Container Handler"); requestTypeClass = requestClass; responseTypeClass = responseClass; this.requestReader = requestReader; this.responseWriter = responseWriter; this.securityContextWriter = securityContextWriter; this.exceptionHandler = exceptionHandler; objectReader = getObjectMapper().readerFor(requestTypeClass); objectWriter = getObjectMapper().writerFor(responseTypeClass); }
@Override public <T> String toJson(T obj, Class<T> clazz) { try { return normalOM.writerFor(clazz).writeValueAsString(obj); } catch (JsonProcessingException ex) { ex.printStackTrace(); return null; } }
public PolicyTestRequest body(Object entity) { try { String body = mapper.writerFor(entity.getClass()).writeValueAsString(entity); return body(body); } catch (Exception e) { throw new RuntimeException(e); } }
@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 void pre() throws Exception { configureObjectMapper(); jsonWriter = jsonObjectMapper.writerFor(VariantStatsWrapper.class); }
@Override public void writeTo(Object o, Class type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException { mapper.writerFor(mapper.constructType(genericType)) .writeValue(entityStream, o); } }
public SocketServlet(JobsService jobsService, final TokenManager tokenManager) { this.jobsService = jobsService; this.tokenManager = Preconditions.checkNotNull(tokenManager, "token manager is required"); this.reader = JSONUtil.mapper().readerFor(SocketMessage.class); this.writer = JSONUtil.mapper().writerFor(SocketMessage.class); }
private ObjectWriter getObjectWriter(ResolvableType type) { ObjectWriter objectWriter = this.objectMapper.writerFor(getType(type)); if (this.view != null) { return objectWriter.withView(this.view); } return objectWriter; }
private void initialize() throws IOException { this.generator = new JsonFactory().createGenerator(outputStream).configure(Feature.AUTO_CLOSE_TARGET, false); initializer.execute(this.generator); this.writer = new ObjectMapper() .writerFor(clazz) .with(SerializationFeature.FLUSH_AFTER_WRITE_VALUE) .writeValuesAsArray(this.generator); } };
public JacksonMessageSerializer(Type type) { JavaType javaType = objectMapper.constructType(type); serializer = new JacksonSerializer(objectMapper.writerFor(javaType)); deserializer = new JacksonDeserializer(objectMapper.readerFor(javaType)); }
protected void verifySerialization(TypeReference<?> typeReference, List<Tuple2<?, String>> testValues) throws IOException { ObjectWriter writer = mapper().writerFor(typeReference); for (Tuple2<?, String> testValue : testValues) { Object src = testValue._1(); String expectedJson = testValue._2(); String json = writer.writeValueAsString(src); Assert.assertEquals(expectedJson, json); Object dst = mapper().readValue(json, typeReference); Assert.assertEquals(src, dst); } }