Example usage for com.fasterxml.jackson.databind JsonSerializer JsonSerializer

List of usage examples for com.fasterxml.jackson.databind JsonSerializer JsonSerializer

Introduction

In this page you can find the example usage for com.fasterxml.jackson.databind JsonSerializer JsonSerializer.

Prototype

JsonSerializer

Source Link

Usage

From source file:com.wiiyaya.consumer.web.initializer.config.WebConfig.java

/**
 * ???// w ww. j  a  v a 2 s  . c  om
 */
@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    StringHttpMessageConverter stringConverter = new StringHttpMessageConverter(ConfigConstant.SYSTEM_CHARSET);
    stringConverter.setWriteAcceptCharset(false);

    converters.add(new ByteArrayHttpMessageConverter());
    converters.add(stringConverter);
    converters.add(new ResourceHttpMessageConverter());
    converters.add(new SourceHttpMessageConverter<Source>());
    converters.add(new AllEncompassingFormHttpMessageConverter());
    converters.add(new Jaxb2RootElementHttpMessageConverter());

    MappingJackson2HttpMessageConverter jacksonConverter = new MappingJackson2HttpMessageConverter();
    ObjectMapper om = jacksonConverter.getObjectMapper();
    om.setDateFormat(new SimpleDateFormat(ConfigConstant.SYSTEM_DATE_FORMAT));
    om.setLocale(ConfigConstant.SYSTEM_LOCALE);
    om.setTimeZone(TimeZone.getTimeZone(ConfigConstant.SYSTEM_TIME_ZONE));
    om.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>() {
        @Override
        public void serialize(Object value, JsonGenerator gen, SerializerProvider serializers)
                throws IOException, JsonProcessingException {
            gen.writeString(StringUtils.EMPTY);
        }
    });
    om.configure(Feature.WRITE_NUMBERS_AS_STRINGS, true);
    om.configure(Feature.WRITE_BIGDECIMAL_AS_PLAIN, true);

    List<MediaType> mediaTypeList = new ArrayList<MediaType>();
    mediaTypeList.add(new MediaType("text", "plain", ConfigConstant.SYSTEM_CHARSET));
    jacksonConverter.setSupportedMediaTypes(mediaTypeList);
    converters.add(jacksonConverter);
}

From source file:com.google.api.server.spi.response.ServletResponseResultWriter.java

private static SimpleModule getWriteBlobAsBase64Module() {
    JsonSerializer<Blob> dateSerializer = new JsonSerializer<Blob>() {
        @Override/*from  w w  w .  ja va 2  s  .  c  om*/
        public void serialize(Blob value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
            byte[] bytes = value.getBytes();
            jgen.writeBinary(bytes, 0, bytes.length);
        }
    };
    SimpleModule writeBlobAsBase64Module = new SimpleModule("writeBlobAsBase64Module",
            new Version(1, 0, 0, null, null, null));
    writeBlobAsBase64Module.addSerializer(Blob.class, dateSerializer);
    return writeBlobAsBase64Module;
}

From source file:org.jongo.query.BsonQueryFactoryTest.java

@Test
public void canHandlePOJOSerializedAsNegativeNumber() throws Exception {

    Mapping mapping = new Mapping.Builder().addSerializer(Coordinate.class, new JsonSerializer<Coordinate>() {
        @Override/* w ww  . j av  a2  s.c om*/
        public void serialize(Coordinate value, JsonGenerator jgen, SerializerProvider provider)
                throws IOException {
            jgen.writeNumber(value.lat);
        }
    }).build();
    QueryFactory customFactory = new BsonQueryFactory(new JacksonEngine(mapping));

    DBObject query = customFactory.createQuery("{coordinate:#}", new Coordinate(-400, -1)).toDBObject();

    assertThat(query.get("coordinate")).isEqualTo(-400);
}

From source file:org.jongo.query.BsonQueryFactoryTest.java

@Test
public void canHandlePOJOSerializedAsNumber() throws Exception {

    Mapping mapping = new Mapping.Builder().addSerializer(Coordinate.class, new JsonSerializer<Coordinate>() {
        @Override//w  ww  . jav a2s. c o  m
        public void serialize(Coordinate value, JsonGenerator jgen, SerializerProvider provider)
                throws IOException {
            jgen.writeNumber(value.lat);
        }
    }).build();
    QueryFactory customFactory = new BsonQueryFactory(new JacksonEngine(mapping));

    DBObject query = customFactory.createQuery("{coordinate:#}", new Coordinate(1, 1)).toDBObject();

    assertThat(query.get("coordinate")).isEqualTo(1);
}

From source file:io.coala.json.DynaBean.java

/**
 * @param <T>//from   ww  w . j a  v  a  2 s  .c om
 * @param wrapperType
 * @return
 */
static final <T> JsonSerializer<T> createJsonSerializer(final Class<T> type) {
    return new JsonSerializer<T>() {
        @Override
        public void serialize(final T value, final JsonGenerator jgen, final SerializerProvider serializers)
                throws IOException, JsonProcessingException {
            // non-Proxy objects get default treatment
            if (!Proxy.isProxyClass(value.getClass())) {
                @SuppressWarnings("unchecked")
                final JsonSerializer<T> ser = (JsonSerializer<T>) serializers
                        .findValueSerializer(value.getClass());
                if (ser != this)
                    ser.serialize(value, jgen, serializers);
                else
                    LOG.warn("Problem serializing: {}", value);
                return;
            }

            // BeanWrapper gets special treatment
            if (DynaBeanInvocationHandler.class.isInstance(Proxy.getInvocationHandler(value))) {
                final DynaBeanInvocationHandler handler = (DynaBeanInvocationHandler) Proxy
                        .getInvocationHandler(value);

                // Wrapper extensions get special treatment
                if (Wrapper.class.isAssignableFrom(handler.type)) {
                    final Object wrap = handler.bean.get("wrap");
                    serializers.findValueSerializer(wrap.getClass(), null).serialize(wrap, jgen, serializers);
                    return;
                }
                // Config (Accessible) extensions get special treatment
                else if (Accessible.class.isAssignableFrom(handler.type)) {
                    final Map<String, Object> copy = new HashMap<>(handler.bean.any());
                    final Accessible config = (Accessible) handler.config;
                    for (String key : config.propertyNames())
                        copy.put(key, config.getProperty(key));
                    serializers.findValueSerializer(copy.getClass(), null).serialize(copy, jgen, serializers);
                    return;
                } else if (Config.class.isAssignableFrom(handler.type))
                    throw new JsonGenerationException("BeanWrapper should extend " + Accessible.class.getName()
                            + " required for serialization: " + Arrays.asList(handler.type.getInterfaces()),
                            jgen);

                // BeanWrappers that do not extend OWNER API's Config
                serializers.findValueSerializer(handler.bean.getClass(), null).serialize(handler.bean, jgen,
                        serializers);
                return;
            }

            // Config (Accessible) gets special treatment
            if (Accessible.class.isInstance(value)) {
                final Accessible config = (Accessible) value;
                final Properties entries = new Properties();
                for (String key : config.propertyNames())
                    entries.put(key, config.getProperty(key));
                serializers.findValueSerializer(entries.getClass(), null).serialize(entries, jgen, serializers);
                return;
            }

            if (Config.class.isInstance(value))
                throw new JsonGenerationException("Config should extend " + Accessible.class.getName()
                        + " required for serialization: " + Arrays.asList(value.getClass().getInterfaces()),
                        jgen);

            throw new JsonGenerationException(
                    "No serializer found for proxy of: " + Arrays.asList(value.getClass().getInterfaces()),
                    jgen);
        }
    };
}

From source file:com.acmemotors.batch.LoaderJobConfiguration.java

@Bean
@StepScope/*ww  w. j  av  a2  s  .co  m*/
public ItemProcessor<Map<String, Object>, String> processor(
        @Value("#{jobParameters['delay']}") final long delay) {
    return item -> {
        DefaultSerializerProvider provider = new DefaultSerializerProvider.Impl();

        provider.setNullValueSerializer(new JsonSerializer<Object>() {
            @Override
            public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider)
                    throws IOException {
                if (value == null) {
                    jgen.writeString("");
                } else {
                    if (value instanceof String) {
                        jgen.writeString((String) value);
                    } else {
                        if (value instanceof Integer) {
                            jgen.writeNumber((Integer) value);
                        } else {
                            jgen.writeNumber((Double) value);
                        }
                    }
                }
            }
        });

        ObjectMapper mapper = new ObjectMapper();
        mapper.setSerializerProvider(provider);

        String processedItem = mapper.writeValueAsString(item);

        Thread.sleep(delay);

        return processedItem;
    };
}

From source file:org.pentaho.pdi.engine.serializers.DataEventSerializer.java

public DataEventSerializer() {
    super(DataEvent.class);

    SimpleModule module = new SimpleModule();
    module.addSerializer(DataEvent.class, new JsonSerializer<DataEvent>() {
        @Override//  ww w. j  av a2 s. c  o m
        public void serialize(DataEvent dataEvent, JsonGenerator jsonGenerator,
                SerializerProvider serializerProvider) throws IOException, JsonProcessingException {
            jsonGenerator.writeStartObject();
            Rows rows = (Rows) dataEvent.getData();
            jsonGenerator.writeStringField("model-id", dataEvent.getSource().getId());
            jsonGenerator.writeStringField("type", rows.getType().toString());
            jsonGenerator.writeStringField("state", rows.getState().toString());

            jsonGenerator.writeArrayFieldStart("rows");
            for (Row row : rows) {
                jsonGenerator.writeStartObject();
                jsonGenerator.writeArrayFieldStart("names");
                for (String name : row.getColumnNames()) {
                    jsonGenerator.writeString(name);
                }
                jsonGenerator.writeEndArray();

                jsonGenerator.writeArrayFieldStart("objects");
                for (Object obj : row.getObjects().get()) {
                    jsonGenerator.writeStartObject();
                    if (obj == null) {
                        jsonGenerator.writeStringField("type", "Null");
                        jsonGenerator.writeEndObject();
                        continue;
                    }
                    switch (obj.getClass().getSimpleName()) {
                    case "String":
                        jsonGenerator.writeStringField("type", "String");
                        jsonGenerator.writeStringField("obj", obj.toString());
                        break;
                    case "Date":
                        jsonGenerator.writeStringField("type", "Date");
                        jsonGenerator.writeStringField("obj", DATE_TIME_INSTANCE.format((Date) obj));
                        break;
                    case "Integer":
                        jsonGenerator.writeStringField("type", "Integer");
                        jsonGenerator.writeNumberField("obj", (Integer) obj);
                        break;
                    case "Long":
                        jsonGenerator.writeStringField("type", "Long");
                        jsonGenerator.writeNumberField("obj", (Long) obj);
                        break;
                    case "Double":
                        jsonGenerator.writeStringField("type", "Double");
                        jsonGenerator.writeNumberField("obj", (Double) obj);
                        break;
                    case "BigDecimal":
                        jsonGenerator.writeStringField("type", "BigDecimal");
                        jsonGenerator.writeStringField("obj", obj.toString());
                        break;
                    case "Boolean":
                        jsonGenerator.writeStringField("type", "Boolean");
                        jsonGenerator.writeBooleanField("obj", (Boolean) obj);
                        break;
                    case "byte[]":
                        jsonGenerator.writeStringField("type", "byte[]");
                        jsonGenerator.writeStringField("obj", new String(((byte[]) obj), "UTF-8"));
                        break;
                    default:
                        if (obj instanceof Serializable) {
                            jsonGenerator.writeStringField("type", "Object");

                            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
                            ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
                            objectOutputStream.writeObject(obj);
                            objectOutputStream.close();
                            outputStream.close();
                            byte[] bytes = outputStream.toByteArray();
                            jsonGenerator.writeStringField("obj", Base64.encodeBase64String(bytes));
                        }
                    }
                    jsonGenerator.writeEndObject();
                }
                jsonGenerator.writeEndArray();
                jsonGenerator.writeEndObject();

            }
            jsonGenerator.writeEndArray();

            jsonGenerator.writeEndObject();
        }
    });
    module.addDeserializer(DataEvent.class, new StdNodeBasedDeserializer<DataEvent>(DataEvent.class) {
        @Override
        public DataEvent convert(JsonNode jsonNode, DeserializationContext deserializationContext)
                throws IOException {

            Rows.TYPE type = Rows.TYPE.valueOf(jsonNode.get("type").asText());
            Rows.STATE state = Rows.STATE.valueOf(jsonNode.get("state").asText());

            List<Row> rows = new ArrayList<>();

            JsonNode json_rows = jsonNode.get("rows");
            for (JsonNode row : json_rows) {

                List<Class> types = new ArrayList<>();
                List<String> names = new ArrayList<>();
                for (JsonNode name : row.get("names")) {
                    names.add(name.asText());
                }
                List<Object> objects = new ArrayList<>();
                for (JsonNode obj : row.get("objects")) {
                    JsonNode t = obj.get("type");
                    JsonNode rawObject = obj.get("obj");

                    Object object = null;
                    String objType = t.asText();
                    switch (objType) {
                    case "Null":
                        types.add(Void.class);
                        break;
                    case "String":
                        types.add(String.class);
                        object = rawObject.asText();
                        break;
                    case "Integer":
                        types.add(Integer.class);
                        object = rawObject.asInt();
                        break;
                    case "Long":
                        types.add(Long.class);
                        object = rawObject.asLong();
                        break;
                    case "Date":
                        types.add(Date.class);
                        try {
                            object = DATE_TIME_INSTANCE.parse(rawObject.asText());
                        } catch (ParseException e) {
                            e.printStackTrace();
                        }
                        break;
                    case "Double":
                        types.add(Double.class);
                        object = rawObject.asDouble();
                        break;
                    case "BigDecimal":
                        types.add(BigDecimal.class);
                        object = new BigDecimal(rawObject.asText());
                        break;
                    case "Boolean":
                        types.add(Boolean.class);
                        object = rawObject.asBoolean();
                        break;
                    case "byte[]":
                        types.add(byte[].class);
                        object = rawObject.asText().getBytes("UTF-8");
                        break;
                    case "Object":
                        try {
                            types.add(Object.class);
                            object = new ObjectInputStream(
                                    new ByteArrayInputStream(Base64.decodeBase64(rawObject.asText())))
                                            .readObject();
                        } catch (ClassNotFoundException e) {
                            e.printStackTrace();
                        }
                        break;
                    }

                    objects.add(object);
                }

                Row r = new DeserializedRow(names, types, objects);
                rows.add(r);
            }
            Rows rowsObj = new Rows(rows, type, state);

            return new DataEvent(new RemoteSource(jsonNode.get("model-id").asText()), rowsObj);

        }
    });
    mapper.registerModule(module);
}