io.lsn.java.common.json.mapper.JsonMapper Maven / Gradle / Ivy

Go to download
package io.lsn.java.common.json.mapper;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.PropertyNamingStrategy;
import org.apache.log4j.Logger;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class JsonMapper {

    private static final Logger logger = Logger.getLogger(JsonMapper.class);

    private static JsonMapper instance = new JsonMapper();

    private ObjectMapper objectMapper;
    private ObjectMapper objectMapperSnakeCase;

    public JsonMapper() {
        this.objectMapper = new ObjectMapper();
        this.objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));

        this.objectMapperSnakeCase = new ObjectMapper();
        this.objectMapperSnakeCase.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
        this.objectMapperSnakeCase.setPropertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE);
    }

    public static JsonMapper getInstance() {
        return instance;
    }

    public static void setInstance(JsonMapper instance) {
        JsonMapper.instance = instance;
    }


    /**
     * mao json string to object of given tyoe
     *
     * @param json        json string
     * @param objectClass object class
     * @param mapper      mapper instance
     * @param          class
     * @return
     * @throws IOException
     */
    private  T mapObjectFromJson(String json, Class objectClass, ObjectMapper mapper) throws IOException {
        if (json == null) {
            return null;
        }
        return mapper.readValue(json, objectClass);
    }

    /**
     * wrapper for json map from string using regular (camelCase) mapper
     *
     * @param json        jso string
     * @param objectClass final object class
     * @param          class
     * @return
     * @throws IOException
     */
    public  T mapObjectFromJson(String json, Class objectClass) throws IOException {
        return mapObjectFromJson(json, objectClass, objectMapper);
    }

    /**
     * wrapper for json map from string using snake_case mapper
     *
     * @param json
     * @param objectClass
     * @param 
     * @return
     * @throws IOException
     */
    public  T mapObjectFromJsonSnakeCase(String json, Class objectClass) throws IOException {
        return mapObjectFromJson(json, objectClass, objectMapperSnakeCase);
    }


    /**
     * map json string into the list of object with given class
     *
     * @param json        json string
     * @param objectClass class of returned objects in a collection
     * @param mapper      mapper instance
     * @param          class
     * @return
     */
    private  List mapListFromJson(String json, Class objectClass, ObjectMapper mapper) throws IOException {
        if (json == null) {
            return new ArrayList<>();
        }
        T[] array = mapper.readValue(json, objectClass);
        return new ArrayList<>(Arrays.asList(array));
    }


    /**
     * wrapper for json deserialization with regular mapper (camelCase)
     *
     * @param json        json string
     * @param objectClass class of returned objects in a collection
     * @param          class
     * @return
     */
    public  List mapListFromJson(String json, Class objectClass) throws IOException {
        return mapListFromJson(json, objectClass, objectMapper);
    }


    /**
     * wrapper for json deserialization with snake_case mapper
     *
     * @param json        json string
     * @param objectClass class of returned objects in a collection
     * @param          class
     * @return
     */
    public  List mapListFromJsonSnakeCase(String json, Class objectClass) throws IOException {
        return mapListFromJson(json, objectClass, objectMapperSnakeCase);
    }

    public ObjectMapper getObjectMapper() {
        return objectMapper;
    }

    public ObjectMapper getObjectMapperSnakeCase() {
        return objectMapperSnakeCase;
    }


    /**
     * map single json database object to java entity / wrapper
     *
     * @param jsonString  json string
     * @param objectClass target class
     * @param          target object
     * @return
     */
    public  T mapDbObject(String jsonString, Class objectClass) {
        try {
            return JsonMapper.getInstance().mapObjectFromJsonSnakeCase(jsonString, objectClass);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            return null;
        }
    }


    /**
     * map database json to list of objects / wrapper
     *
     * @param jsonString  json object
     * @param objectClass target class
     * @param          target type
     * @return
     */
    public  List mapDbList(String jsonString, Class objectClass) {
        try {
            return JsonMapper.getInstance().mapListFromJsonSnakeCase(jsonString, objectClass);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            return new ArrayList<>();
        }
    }

    /**
     * clone object with possible type change
     *
     * @param o           object to be cloned
     * @param targetClass target class
     * @param 
     * @return
     */
    public  T cloneWithTypeChange(Object o, Class targetClass) {
        try {
            String json = JsonMapper.getInstance().getObjectMapper().writeValueAsString(o);
            return JsonMapper.getInstance().mapObjectFromJson(json, targetClass);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        return null;
    }

}