Springboot單例模式實戰封裝json轉換

1、定義

        保證一個類僅有一個實例,並提供一個全局訪問點.

2、優勢

      (1)在內存裏只有一個實例,減小了內存開銷
      (2)能夠避免對資源的多重佔用
      (3)設置全局訪問點,嚴格控制訪問 (對外不會new出來,只能經過這個方法建立對象)

3、缺點

     沒有接口,擴展困難.

4、舉例實現，實際中經常使用

     

封裝成轉換json的類，傳入一個對象，轉換爲json形式，就能夠封裝成一個util

 

        最好的實現方式是枚舉的實現方式。

1、枚舉的實現方式：

  1 @Slf4j
  2 public enum EnumJacksonUtil {
  3 
  4     /**
  5      * 方法集合
  6      */
  7     INSTANCE {
  8 
  9         /**
 10          * 轉成json
 11          * @param object 傳入的實體類
 12          * @return
 13          */
 14         @Override
 15         public String toJsonString(Object object) {
 16             String json = null;
 17             if (!StringUtils.isEmpty(object)) {
 18                 try {
 19                     log.info("傳入對象:" + object);
 20                     json = mapper.writeValueAsString(object);
 21                     log.info("轉換結果:" + json);
 22                 } catch (JsonProcessingException e) {
 23                     log.info("json轉換異常{}" + object);
 24                     e.getMessage();
 25                 }
 26             }
 27             return json;
 28         }
 29 
 30         /**
 31          *
 32          * @param jsonStr 傳入的字符串
 33          * @param cls   傳入的實體類
 34          * @return
 35          */
 36         @Override
 37         public <T> T stringToBean(String jsonStr, Class<T> cls) {
 38             T t = null;
 39             if (!StringUtils.isEmpty(mapper)) {
 40                 try {
 41                     mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
 42                     mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 43                     t = mapper.readValue(jsonStr, cls);
 44                 } catch (IOException e) {
 45                     log.info("json轉換異常{}" + jsonStr);
 46                     e.getMessage();
 47                 }
 48             }
 49             return t;
 50         }
 51 
 52         /**
 53          * 將json數據轉換成pojo對象list
 54          * @param jsonData
 55          * @param beanType
 56          * @param <T>
 57          * @return
 58          */
 59         @Override
 60         public <T> List<T> jsonToList(String jsonData, Class<T> beanType) {
 61             JavaType javaType = mapper.getTypeFactory().constructParametricType(List.class, beanType);
 62             try {
 63                 List<T> list = mapper.readValue(jsonData, javaType);
 64                 return list;
 65             } catch (Exception e) {
 66                 e.printStackTrace();
 67             }
 68 
 69             return null;
 70         }
 71     };
 72 
 73     /**
 74      * springboot轉換json的類
 75      */
 76     private static ObjectMapper mapper;
 77 
 78     static {
 79         mapper = new ObjectMapper();
 80     }
 81 
 82     /**
 83      * 轉成json
 84      *
 85      * @param object 傳入的實體類
 86      * @return
 87      */
 88     public abstract String toJsonString(Object object);
 89 
 90     /**
 91      * 轉成bean
 92      *
 93      * @param jsonStr 傳入的字符串
 94      * @param cls     傳入的實體類
 95      * @return
 96      */
 97     public abstract <T> T stringToBean(String jsonStr, Class<T> cls);
 98 
 99     /**
100      * 將json數據轉換成pojo對象list
101      *
102      * @param jsonData
103      * @param beanType
104      * @param <T>
105      * @return
106      */
107     public abstract <T> List<T> jsonToList(String jsonData, Class<T> beanType);
108 
109 
110     public static EnumJacksonUtil getInstance() {
111         return INSTANCE;
112     }
113 
114 }

View Code

     測試方式：

 1 @RunWith(SpringRunner.class)
 2 @SpringBootTest
 3 public class EnumApplicationTests {
 4 
 5     @Test
 6     public void contextLoads() {
 7 
 8         Thermo thermo = new Thermo( );
 9         thermo.setName("塞米菲");
10         thermo.setDescribe("一塊兒一個");
11 
12         EnumJacksonUtil enumJacksonUtil = EnumJacksonUtil.getInstance();
13         System.out.println( enumJacksonUtil.toJsonString(thermo));
14     }
15 
16 }

View Code

2、通常單例的實現方式

 1 @Slf4j
 2 public class JacksonUtil {
 3 
 4     private static ObjectMapper mapper;
 5 
 6     static {
 7         //noinspection ConstantConditions
 8         if (mapper == null) {
 9             mapper = new ObjectMapper();
10         }
11     }
12 
13     /**
14      * 轉成json
15      *
16      * @param object
17      * @return
18      */
19     public static String toJsonString(Object object) {
20         String json = null;
21         if (object != null) {
22             try {
23                 json = mapper.writeValueAsString(object);
24             } catch (JsonProcessingException e) {
25                 log.info("json轉換異常{}" + object);
26                 e.getMessage();
27             }
28         }
29         return json;
30     }
31 
32     /**
33      * 轉成bean
34      *
35      * @param jsonStr
36      * @param cls
37      * @return
38      */
39     public static <T> T stringToBean(String jsonStr, Class<T> cls) {
40         T t = null;
41         if (mapper != null) {
42             try {
43                 mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
44                 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
45                 t = mapper.readValue(jsonStr, cls);
46             } catch (IOException e) {
47                 e.getMessage();
48             }
49         }
50         return t;
51     }
52 }

View Code

      測試方法：

1 @Test
2     public void contextLoad2s() {
3 
4         Thermo thermo = new Thermo( );
5         thermo.setName("塞米菲");
6         thermo.setDescribe("一塊兒一個");
7         
8         System.out.println(JacksonUtil.toJsonString(thermo));
9     }

View Code