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));
     }