Springboot单例模式实战封装json转换

一、定义

        保证一个类仅有一个实例,并提供一个全局访问点.

二、优点

      (1)在内存里只有一个实例,减少了内存开销
      (2)可以避免对资源的多重占用
      (3)设置全局访问点,严格控制访问 (对外不会new出来,只能通过这个方法创建对象)

三、缺点

     没有接口,扩展困难.

四、举例实现，实际中常用

     

封装成转换json的类，传入一个对象，转换为json形式，就可以封装成一个util

        最好的实现方式是枚举的实现方式。

一、枚举的实现方式：

@Slf4j
public enum EnumJacksonUtil {

    /**
     * 方法集合
     */
    INSTANCE {

        /**
         * 转成json
         * @param object 传入的实体类
         * @return
         */
        @Override
        public String toJsonString(Object object) {
            String json = null;
            if (!StringUtils.isEmpty(object)) {
                try {
                    log.info("传入对象:" + object);
                    json = mapper.writeValueAsString(object);
                    log.info("转换结果:" + json);
                } catch (JsonProcessingException e) {
                    log.info("json转换异常{}" + object);
                    e.getMessage();
                }
            }
            return json;
        }

        /**
         *
         * @param jsonStr 传入的字符串
         * @param cls   传入的实体类
         * @return
         */
        @Override
        public <T> T stringToBean(String jsonStr, Class<T> cls) {
            T t = null;
            if (!StringUtils.isEmpty(mapper)) {
                try {
                    mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
                    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
                    t = mapper.readValue(jsonStr, cls);
                } catch (IOException e) {
                    log.info("json转换异常{}" + jsonStr);
                    e.getMessage();
                }
            }
            return t;
        }

        /**
         * 将json数据转换成pojo对象list
         * @param jsonData
         * @param beanType
         * @param <T>
         * @return
         */
        @Override
        public <T> List<T> jsonToList(String jsonData, Class<T> beanType) {
            JavaType javaType = mapper.getTypeFactory().constructParametricType(List.class, beanType);
            try {
                List<T> list = mapper.readValue(jsonData, javaType);
                return list;
            } catch (Exception e) {
                e.printStackTrace();
            }

            return null;
        }
    };

    /**
     * springboot转换json的类
     */
    private static ObjectMapper mapper;

    static {
        mapper = new ObjectMapper();
    }

    /**
     * 转成json
     *
     * @param object 传入的实体类
     * @return
     */
    public abstract String toJsonString(Object object);

    /**
     * 转成bean
     *
     * @param jsonStr 传入的字符串
     * @param cls     传入的实体类
     * @return
     */
    public abstract <T> T stringToBean(String jsonStr, Class<T> cls);

    /**
     * 将json数据转换成pojo对象list
     *
     * @param jsonData
     * @param beanType
     * @param <T>
     * @return
     */
    public abstract <T> List<T> jsonToList(String jsonData, Class<T> beanType);


    public static EnumJacksonUtil getInstance() {
        return INSTANCE;
    }

}

     测试方式：

@RunWith(SpringRunner.class)
@SpringBootTest
public class EnumApplicationTests {

    @Test
    public void contextLoads() {

        Thermo thermo = new Thermo( );
        thermo.setName("塞米菲");
        thermo.setDescribe("一起一个");

        EnumJacksonUtil enumJacksonUtil = EnumJacksonUtil.getInstance();
        System.out.println( enumJacksonUtil.toJsonString(thermo));
    }

}

二、一般单例的实现方式

@Slf4j
public class JacksonUtil {

    private static ObjectMapper mapper;

    static {
        //noinspection ConstantConditions
        if (mapper == null) {
            mapper = new ObjectMapper();
        }
    }

    /**
     * 转成json
     *
     * @param object
     * @return
     */
    public static String toJsonString(Object object) {
        String json = null;
        if (object != null) {
            try {
                json = mapper.writeValueAsString(object);
            } catch (JsonProcessingException e) {
                log.info("json转换异常{}" + object);
                e.getMessage();
            }
        }
        return json;
    }

    /**
     * 转成bean
     *
     * @param jsonStr
     * @param cls
     * @return
     */
    public static <T> T stringToBean(String jsonStr, Class<T> cls) {
        T t = null;
        if (mapper != null) {
            try {
                mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
                mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
                t = mapper.readValue(jsonStr, cls);
            } catch (IOException e) {
                e.getMessage();
            }
        }
        return t;
    }
}

      测试方法：

@Test
    public void contextLoad2s() {

        Thermo thermo = new Thermo( );
        thermo.setName("塞米菲");
        thermo.setDescribe("一起一个");
        
        System.out.println(JacksonUtil.toJsonString(thermo));
    }