#2021 feature - Updated JSON library to the latest version

rsanchez

2014-10-22 ffc60638fba7475b4cb6a863aa8f27c7e5a9b059

#2021 feature - Updated JSON library to the latest version

 pom.xml
..
..
@@ -47,11 +47,6 @@
47
47
 			<version>1.2</version>
48
48
 		</dependency>
49
49
 		<dependency>
50
-			<groupId>org.codehaus.jackson</groupId>
51
-			<artifactId>jackson-mapper-asl</artifactId>
52
-			<version>1.9.13</version>
53
-		</dependency>
54
-		<dependency>
55
50
 			<groupId>org.apache.logging.log4j</groupId>
56
51
 			<artifactId>log4j-core</artifactId>
57
52
 			<version>2.0.2</version>
..
..
@@ -61,6 +56,11 @@
61
56
 			<artifactId>httpclient</artifactId>
62
57
 			<version>4.4-beta1</version>
63
58
 		</dependency>
59
+		<dependency>
60
+			<groupId>com.fasterxml.jackson.core</groupId>
61
+			<artifactId>jackson-databind</artifactId>
62
+			<version>2.4.3</version>
63
+		</dependency>
64
64
 	</dependencies>
65
65
 
66
66
 	<distributionManagement>
 src/main/java/net/curisit/securis/ConnectionManager.java
..
..
@@ -1,6 +1,5 @@
1
1
 package net.curisit.securis;
2
2
 
3
-import java.awt.PageAttributes.MediaType;
4
3
 import java.io.IOException;
5
4
 import java.io.UnsupportedEncodingException;
6
5
 import java.security.KeyManagementException;
..
..
@@ -9,8 +8,6 @@
9
8
 import java.security.NoSuchAlgorithmException;
10
9
 import java.security.cert.CertificateException;
11
10
 import java.security.cert.X509Certificate;
12
-
13
-import javax.activation.MimeType;
14
11
 
15
12
 import net.curisit.securis.beans.RequestBean;
16
13
 import net.curisit.securis.utils.JsonUtils;
..
..
@@ -36,57 +33,56 @@
36
33
  */
37
34
 public class ConnectionManager {
38
35
 
39
-	private static final Logger LOG = LogManager.getLogger(ConnectionManager.class);
40
-    private  static final int HTTP_STATUS_APP_ERRROR = 418;
41
-    private  static final String JSON_MEDIA_TYPE= "application/json";
36
+    private static final Logger LOG = LogManager.getLogger(ConnectionManager.class);
37
+    private static final int HTTP_STATUS_APP_ERRROR = 418;
38
+    private static final String JSON_MEDIA_TYPE = "application/json";
42
39
     private static final String ERROR_MESSAGE_HEADER = "X-SECURIS-ERROR-MSG";
43
40
     private static final String ERROR_CODE_MESSAGE_HEADER = "X-SECURIS-ERROR-CODE";
44
41
 
45
-	private static ConnectionManager singleton;
42
+    private static ConnectionManager singleton;
46
43
 
47
-	private final String serverUrl;
48
-	private final CloseableHttpClient httpClient;
49
-	
50
-	private ConnectionManager() throws SeCurisException {
51
-		String aux = Params.get(Params.KEYS.LICENSE_SERVER_URL, Params.DEFAUT_SERVER_URL);
52
-		if (aux.endsWith("/")) {
53
-		    serverUrl = aux.substring(0, aux.length()-2);
54
-		} else {
55
-		    serverUrl = aux;
56
-		}
57
-		httpClient = createHttpClient();
58
-	}
59
-	
60
-	private CloseableHttpClient createHttpClient() throws SeCurisException {
61
-	       SSLContextBuilder builder = new SSLContextBuilder();
62
-	        SSLConnectionSocketFactory sslsf = null; 
63
-	        try {
64
-	            builder.loadTrustMaterial((KeyStore)null, new TrustStrategy() {
65
-	                @Override
66
-	                public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
67
-	                    return true;
68
-	                }
69
-	            });
70
-	            sslsf = new SSLConnectionSocketFactory(builder.build());
71
-	        } catch (NoSuchAlgorithmException | KeyStoreException | KeyManagementException e1) {
72
-	            LOG.error(e1);
73
-	            throw new SeCurisException("Error creating SSL socket factory");
74
-	        }
75
-	        return HttpClientBuilder.create().setSSLSocketFactory(sslsf).build();
76
-	}
44
+    private final String serverUrl;
45
+    private final CloseableHttpClient httpClient;
77
46
 
78
-	public synchronized static ConnectionManager getInstance() throws SeCurisException {
79
-	    if (singleton == null) {
80
-	        singleton = new ConnectionManager();
81
-	    }
82
-		return singleton;
83
-	}
47
+    private ConnectionManager() throws SeCurisException {
48
+        String aux = Params.get(Params.KEYS.LICENSE_SERVER_URL, Params.DEFAUT_SERVER_URL);
49
+        if (aux.endsWith("/")) {
50
+            serverUrl = aux.substring(0, aux.length() - 2);
51
+        } else {
52
+            serverUrl = aux;
53
+        }
54
+        httpClient = createHttpClient();
55
+    }
84
56
 
57
+    private CloseableHttpClient createHttpClient() throws SeCurisException {
58
+        SSLContextBuilder builder = new SSLContextBuilder();
59
+        SSLConnectionSocketFactory sslsf = null;
60
+        try {
61
+            builder.loadTrustMaterial((KeyStore) null, new TrustStrategy() {
62
+                @Override
63
+                public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
64
+                    return true;
65
+                }
66
+            });
67
+            sslsf = new SSLConnectionSocketFactory(builder.build());
68
+        } catch (NoSuchAlgorithmException | KeyStoreException | KeyManagementException e1) {
69
+            LOG.error(e1);
70
+            throw new SeCurisException("Error creating SSL socket factory");
71
+        }
72
+        return HttpClientBuilder.create().setSSLSocketFactory(sslsf).build();
73
+    }
85
74
 
86
-	public <T> T executePost(String command, Class<T> returnType, RequestBean req) throws SeCurisException {
75
+    public synchronized static ConnectionManager getInstance() throws SeCurisException {
76
+        if (singleton == null) {
77
+            singleton = new ConnectionManager();
78
+        }
79
+        return singleton;
80
+    }
81
+
82
+    public <T> T executePost(String command, Class<T> returnType, RequestBean req) throws SeCurisException {
87
83
         HttpPost postRequest = new HttpPost(String.format("%s/%s", serverUrl, command));
88
84
         postRequest.addHeader("accept", JSON_MEDIA_TYPE);
89
-        
85
+
90
86
         postRequest.addHeader("content-type", JSON_MEDIA_TYPE);
91
87
         try {
92
88
             postRequest.setEntity(new StringEntity(JsonUtils.toJSON(req)));
..
..
@@ -96,23 +92,23 @@
96
92
         HttpResponse response;
97
93
         try {
98
94
             response = httpClient.execute(postRequest);
99
-            
95
+
100
96
             checkErrors(command, response);
101
-            
97
+
102
98
             String jsonLic = IOUtils.toString(response.getEntity().getContent());
103
99
             LOG.debug("Response content read OK: {}", jsonLic);
104
100
             T responseBean = JsonUtils.json2object(jsonLic, returnType);
105
101
 
106
102
             LOG.debug("Response bean read OK: {}", responseBean);
107
-            
103
+
108
104
             return responseBean;
109
105
         } catch (IOException e) {
110
106
             LOG.error("Error accessing SeCuris server", e);
111
107
             throw new SeCurisException("Error accessing SeCuris server");
112
108
         }
113
- 	}
109
+    }
114
110
 
115
-	private void checkErrors(String command, HttpResponse response) throws SeCurisException {
111
+    private void checkErrors(String command, HttpResponse response) throws SeCurisException {
116
112
         if (response.getStatusLine().getStatusCode() != 200) {
117
113
             if (response.getStatusLine().getStatusCode() == HTTP_STATUS_APP_ERRROR) {
118
114
                 String errorCode = response.getFirstHeader(ERROR_CODE_MESSAGE_HEADER).getValue();
..
..
@@ -123,7 +119,7 @@
123
119
             throw new SeCurisException("Error executing command " + command + ", status: " + response.getStatusLine().getStatusCode());
124
120
         }
125
121
 
126
-	}
122
+    }
127
123
 
128
124
     public <T> T executeGet(String command, Class<T> returnType) throws SeCurisException {
129
125
         HttpGet getRequest = new HttpGet(String.format("%s/%s", serverUrl, command));
..
..
@@ -140,19 +136,18 @@
140
136
             T responseBean = JsonUtils.json2object(jsonLic, returnType);
141
137
 
142
138
             LOG.debug("Response bean read OK: {}", responseBean);
143
-            
139
+
144
140
             return responseBean;
145
141
         } catch (IOException e) {
146
142
             LOG.error("Error acessing SeCuris server", e);
147
143
             throw new SeCurisException("Error accessing SeCuris server");
148
144
         }
149
145
     }
150
-     
151
-	public static class Command {
146
+
147
+    public static class Command {
152
148
         public static final String TEST = "ping";
153
149
         public static final String CREATE_LIC = "request";
154
150
         public static final String RENEW_LIC = "renew";
155
-	}
156
-
151
+    }
157
152
 
158
153
 }
 src/main/java/net/curisit/securis/LicenseManager.java
..
..
@@ -147,7 +147,7 @@
147
147
     public void save(SignedLicenseBean signedLic, File file) throws SeCurisException {
148
148
         byte[] json;
149
149
         try {
150
-            json = JsonUtils.toJSON(signedLic, true).getBytes("utf-8");
150
+            json = JsonUtils.toPrettyJSON(signedLic).getBytes("utf-8");
151
151
             Files.write(Paths.get(file.toURI()), json, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
152
152
         } catch (UnsupportedEncodingException e) {
153
153
             LOG.error("Error creating json doc from license: " + signedLic, e);
 src/main/java/net/curisit/securis/LicenseValidator.java
..
..
@@ -61,8 +61,8 @@
61
61
     public void validateHW(RequestBean reqBean, String appCode, String customerCode, String packCode) throws SeCurisException {
62
62
         RequestBean currentHW = ReqGenerator.getInstance().createRequest(appCode, customerCode, packCode);
63
63
         if (!currentHW.match(reqBean)) {
64
-            throw new SeCurisException("Current System info mismatch the License System info:\n Licensed: " + JsonUtils.toJSON(reqBean, true)
65
-                    + "\n Expected: " + JsonUtils.toJSON(currentHW, true));
64
+            throw new SeCurisException("Current System info mismatch the License System info:\n Licensed: \n" + JsonUtils.toPrettyJSON(reqBean)
65
+                    + "\n Expected: \n" + JsonUtils.toPrettyJSON(currentHW));
66
66
         }
67
67
     }
68
68
 
 src/main/java/net/curisit/securis/ReqGenerator.java
..
..
@@ -65,7 +65,7 @@
65
65
     public void save(RequestBean req, File file) throws SeCurisException {
66
66
         byte[] json;
67
67
         try {
68
-            json = JsonUtils.toJSON(req, true).getBytes("utf-8");
68
+            json = JsonUtils.toPrettyJSON(req).getBytes("utf-8");
69
69
             Files.write(Paths.get(file.toURI()), json, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
70
70
         } catch (UnsupportedEncodingException e) {
71
71
             LOG.error("Error creating json doc from request: " + req, e);
 src/main/java/net/curisit/securis/beans/LicenseBean.java
..
..
@@ -4,10 +4,10 @@
4
4
 import java.util.Map;
5
5
 import java.util.TreeMap;
6
6
 
7
-import org.codehaus.jackson.annotate.JsonAutoDetect;
8
-import org.codehaus.jackson.annotate.JsonIgnore;
9
-import org.codehaus.jackson.annotate.JsonProperty;
10
-import org.codehaus.jackson.annotate.JsonPropertyOrder;
7
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
8
+import com.fasterxml.jackson.annotation.JsonIgnore;
9
+import com.fasterxml.jackson.annotation.JsonProperty;
10
+import com.fasterxml.jackson.annotation.JsonPropertyOrder;
11
11
 
12
12
 @JsonAutoDetect
13
13
 @JsonPropertyOrder({
 src/main/java/net/curisit/securis/beans/RequestBean.java
..
..
@@ -2,11 +2,12 @@
2
2
 
3
3
 import java.util.List;
4
4
 
5
-import org.codehaus.jackson.annotate.JsonAutoDetect;
6
-import org.codehaus.jackson.map.annotate.JsonSerialize;
5
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
6
+import com.fasterxml.jackson.annotation.JsonInclude;
7
+import com.fasterxml.jackson.annotation.JsonInclude.Include;
7
8
 
8
9
 @JsonAutoDetect
9
-@JsonSerialize(include = JsonSerialize.Inclusion.NON_NULL)
10
+@JsonInclude(Include.NON_NULL)
10
11
 public class RequestBean {
11
12
     private String customerCode;
12
13
     private String crcLogo;
 src/main/java/net/curisit/securis/beans/SignedLicenseBean.java
..
..
@@ -1,7 +1,8 @@
1
1
 package net.curisit.securis.beans;
2
2
 
3
-import org.codehaus.jackson.annotate.JsonAutoDetect;
4
-import org.codehaus.jackson.annotate.JsonProperty;
3
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
4
+import com.fasterxml.jackson.annotation.JsonProperty;
5
+
5
6
 
6
7
 @JsonAutoDetect
7
8
 public class SignedLicenseBean extends LicenseBean {
 src/main/java/net/curisit/securis/beans/StatusBean.java
..
..
@@ -2,7 +2,7 @@
2
2
 
3
3
 import java.util.Date;
4
4
 
5
-import org.codehaus.jackson.annotate.JsonAutoDetect;
5
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
6
6
 
7
7
 @JsonAutoDetect
8
8
 public class StatusBean extends RequestBean {
 src/main/java/net/curisit/securis/utils/JsonUtils.java
..
..
@@ -8,207 +8,199 @@
8
8
 
9
9
 import org.apache.logging.log4j.LogManager;
10
10
 import org.apache.logging.log4j.Logger;
11
-import org.codehaus.jackson.JsonParseException;
12
-import org.codehaus.jackson.JsonParser;
13
-import org.codehaus.jackson.JsonProcessingException;
14
-import org.codehaus.jackson.map.ObjectMapper;
15
-import org.codehaus.jackson.map.SerializationConfig;
16
-import org.codehaus.jackson.type.TypeReference;
11
+
12
+import com.fasterxml.jackson.core.JsonParseException;
13
+import com.fasterxml.jackson.core.JsonParser;
14
+import com.fasterxml.jackson.core.type.TypeReference;
15
+import com.fasterxml.jackson.databind.ObjectMapper;
16
+import com.fasterxml.jackson.databind.SerializationFeature;
17
+
18
+//import org.codehaus.jackson.map.ObjectMapper;
17
19
 
18
20
 /**
19
21
  * Helper method to perform JSON tasks
20
22
  * 
21
- * @author cproberto
23
+ * @author cproberto, ccalvo
22
24
  */
23
25
 public class JsonUtils {
24
26
 
25
-	private static final Logger LOG = LogManager.getLogger(JsonUtils.class);
27
+    private static final Logger LOG = LogManager.getLogger(JsonUtils.class);
26
28
 
27
-	final private static ObjectMapper MAPPER = new ObjectMapper();
29
+    final private static ObjectMapper MAPPER = new ObjectMapper();
30
+    final private static ObjectMapper MAPPER_PRETTY;
28
31
 
29
-	static {
30
-		MAPPER.configure(JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS, true);
31
-		MAPPER.configure(JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER, true);
32
-		MAPPER.configure(JsonParser.Feature.ALLOW_COMMENTS, true);
33
-		MAPPER.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
34
-		MAPPER.configure(SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS, false);
35
-		MAPPER.configure(SerializationConfig.Feature.INDENT_OUTPUT, false);
36
-		MAPPER.configure(SerializationConfig.Feature.WRITE_DATES_AS_TIMESTAMPS, true);
37
-		MAPPER.configure(SerializationConfig.Feature.WRITE_ENUMS_USING_TO_STRING, true);
32
+    static {
38
33
 
39
-	}
34
+        MAPPER.configure(JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS, true);
35
+        MAPPER.configure(JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER, true);
36
+        MAPPER.configure(JsonParser.Feature.ALLOW_COMMENTS, true);
37
+        MAPPER.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
38
+        MAPPER.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
39
+        MAPPER.disable(SerializationFeature.INDENT_OUTPUT);
40
+        MAPPER.enable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
41
+        MAPPER.enable(SerializationFeature.WRITE_ENUMS_USING_TO_STRING);
42
+        MAPPER_PRETTY = MAPPER.copy();
43
+        MAPPER_PRETTY.enable(SerializationFeature.INDENT_OUTPUT);
44
+    }
40
45
 
41
-	/**
42
-	 * Convert an object in the type pass as parameter, avoiding to use casting in code.
43
-	 * 
44
-	 * @param value
45
-	 * @param type
46
-	 * @return
47
-	 */
48
-	@SuppressWarnings("unchecked")
49
-	public static <T> T value(Object value, Class<T> type) {
46
+    /**
47
+     * Convert an object in the type pass as parameter, avoiding to use casting
48
+     * in code.
49
+     * 
50
+     * @param value
51
+     * @param type
52
+     * @return
53
+     */
54
+    public static <T> T value(Object value, Class<T> type) {
50
55
 
51
-		return (T) value;
52
-	}
56
+        return (T) value;
57
+    }
53
58
 
54
-	public static <T> T parseJSON(String json, Class<T> type) throws SeCurisException {
55
-		try {
56
-			if (json == null){
57
-				return null;
58
-			}
59
-			return MAPPER.readValue(json, type);
60
-		} catch (JsonParseException e) {
61
-			LOG.error("Error parsing JSON string to obejct: {}", json, e);
62
-			if (json.length() > 60)
63
-				json = json.substring(0, 50) + "...";
64
-			throw new SeCurisException("Error parsing JSON string to object: " + json, e);
65
-		} catch (IOException e) {
66
-			LOG.error("Error parsing JSON string to object: {}", json, e);
67
-			if (json.length() > 60)
68
-				json = json.substring(0, 50) + "...";
69
-			throw new SeCurisException("Error parsing JSON string to object: " + json, e);
70
-		}
71
-	}
59
+    public static <T> T parseJSON(String json, Class<T> type) throws SeCurisException {
60
+        try {
61
+            if (json == null)
62
+                return null;
63
+            return MAPPER.readValue(json, type);
64
+        } catch (JsonParseException e) {
65
+            LOG.error("Error parsing JSON string to obejct: {}", json, e);
66
+            if (json.length() > 60)
67
+                json = json.substring(0, 50) + "...";
68
+            throw new SeCurisException("Error parsing JSON string to object: " + json, e);
69
+        } catch (IOException e) {
70
+            LOG.error("Error parsing JSON string to object: {}", json, e);
71
+            if (json.length() > 60)
72
+                json = json.substring(0, 50) + "...";
73
+            throw new SeCurisException("Error parsing JSON string to object: " + json, e);
74
+        }
75
+    }
72
76
 
73
-	/**
74
-	 * Create a JSON string from a object compatible or annotated with Jackson, i.e: <code>
75
-	 * {"f1":2345,"f2":"Test de valor"}
76
-	 * 
77
-	 * @param obj
78
-	 * @return JSON string representation from object
79
-	 */
80
-	public static String toJSON(Object obj) throws SeCurisException {
81
-		// and could also do other configuration...
82
-		try {
83
-			if (obj == null) {
84
-				return null;
85
-			}
86
-			return MAPPER.writeValueAsString(obj);
87
-		} catch (JsonProcessingException e) {
88
-			LOG.error("Error formating JSON from object: {}", obj, e);
89
-			throw new SeCurisException("Error formating JSON from object: " + obj, e);
90
-		} catch (IOException e) {
91
-			LOG.error("Error formating JSON from object: {}", obj, e);
92
-			throw new SeCurisException("Error formating JSON from object: " + obj, e);
93
-		}
94
-	}
77
+    /**
78
+     * Create a JSON string from a object compatible or annotated with Jackson,
79
+     * i.e: <code>
80
+     * {"f1":2345,"f2":"Test de valor"}
81
+     * 
82
+     * @param obj
83
+     * @return JSON string representation from object
84
+     */
85
+    public static String toJSON(Object obj) throws SeCurisException {
86
+        // and could also do other configuration...
87
+        try {
88
+            if (obj == null)
89
+                return null;
90
+            return MAPPER.writeValueAsString(obj);
91
+        } catch (IOException e) {
92
+            LOG.error("Error formating JSON from object: {}", obj, e);
93
+            throw new SeCurisException("Error formating JSON from object: " + obj, e);
94
+        }
95
+    }
95
96
 
96
-	/**
97
-	 * Create a JSON string from a object compatible or annotated with Jackson, i.e: <code>
98
-	 * {"f1":2345,"f2":"Test de valor"}
99
-	 * 
100
-	 * @param obj
101
-	 * @return JSON string representation from object
102
-	 */
103
-	public static String toJSON(Object obj, boolean pretty) throws SeCurisException {
104
-		// and could also do other configuration...
105
-		try {
106
-			if (obj == null) {
107
-				return null;
108
-			}
109
-			MAPPER.enable(SerializationConfig.Feature.INDENT_OUTPUT);
110
-			String json = MAPPER.writeValueAsString(obj);
111
-			MAPPER.disable(SerializationConfig.Feature.INDENT_OUTPUT);
112
-			return json;
113
-		} catch (JsonProcessingException e) {
114
-			LOG.error("Error formating JSON from object: {}", obj, e);
115
-			throw new SeCurisException("Error formating JSON from object: " + obj, e);
116
-		} catch (IOException e) {
117
-			LOG.error("Error formating JSON from object: {}", obj, e);
118
-			throw new SeCurisException("Error formating JSON from object: " + obj, e);
119
-		}
120
-	}
97
+    /**
98
+     * Create a JSON string from a object compatible or annotated with Jackson,
99
+     * i.e: <code>
100
+     * {"f1":2345,"f2":"Test de valor"}
101
+     * 
102
+     * @param obj
103
+     * @return JSON string representation from object
104
+     */
105
+    public static String toPrettyJSON(Object obj) throws SeCurisException {
106
+        // and could also do other configuration...
107
+        try {
108
+            if (obj == null)
109
+                return null;
110
+            return MAPPER_PRETTY.writeValueAsString(obj);
111
+        } catch (IOException e) {
112
+            LOG.error("Error formating JSON from object: {}", obj, e);
113
+            throw new SeCurisException("Error formating JSON from object: " + obj, e);
114
+        }
115
+    }
121
116
 
122
-	/**
123
-	 * Create a Map from a json string, i.e: <code>
124
-	 * {"f1":2345,"f2":"Test de valor"}
125
-	 * </code>
126
-	 * 
127
-	 * @param json
128
-	 *            String with json format
129
-	 * @return
130
-	 */
131
-	@SuppressWarnings("unchecked")
132
-	public static Map<String, Object> json2map(String json) throws JsonParseException {
117
+    /**
118
+     * Create a Map from a json string, i.e: <code>
119
+     * {"f1":2345,"f2":"Test de valor"}
120
+     * </code>
121
+     * 
122
+     * @param json
123
+     *            String with json format
124
+     * @return
125
+     */
126
+    public static Map<String, Object> json2map(String json) throws JsonParseException {
133
127
 
134
-		try {
135
-			if (json == null) {
136
-				return null;
137
-			}
138
-			return MAPPER.readValue(json, Map.class);
139
-		} catch (JsonParseException e) {
140
-			LOG.error("Error parsing JSON string to map: {}", json, e);
141
-			throw e;
142
-		} catch (IOException e) {
143
-			LOG.error("Error parsing JSON string to map: {}", json, e);
144
-		}
145
-		return null;
146
-	}
128
+        try {
129
+            if (json == null)
130
+                return null;
131
+            return MAPPER.readValue(json, Map.class);
132
+        } catch (JsonParseException e) {
133
+            LOG.error("Error parsing JSON string to map: {}", json, e);
134
+            throw e;
135
+        } catch (IOException e) {
136
+            LOG.error("Error parsing JSON string to map: {}", json, e);
137
+        }
138
+        return null;
139
+    }
147
140
 
148
-	/**
149
-	 * Create a JSON strin from a Map object, i.e: <code>
150
-	 * {"f1":2345,"f2":"Test de valor"}
151
-	 * 
152
-	 * @param map
153
-	 * @return
154
-	 */
155
-	public static String map2json(Map<String, Object> map) {
156
-		// and could also do other configuration...
157
-		try {
158
-			if (map == null) {
159
-				return null;
160
-			}
161
-			return MAPPER.writeValueAsString(map);
162
-		} catch (JsonProcessingException e) {
163
-			LOG.error("Error formating JSON from map: {}", map, e);
164
-		} catch (IOException e) {
165
-			LOG.error("Error formating JSON from map: {}", map, e);
166
-		}
141
+    /**
142
+     * Create a JSON strin from a Map object, i.e: <code>
143
+     * {"f1":2345,"f2":"Test de valor"}
144
+     * 
145
+     * @param map
146
+     * @return
147
+     */
148
+    public static String map2json(Map<String, Object> map) {
149
+        // and could also do other configuration...
150
+        try {
151
+            if (map == null)
152
+                return null;
153
+            return MAPPER.writeValueAsString(map);
154
+        } catch (IOException e) {
155
+            LOG.error("Error formating JSON from map: {}", map, e);
156
+        }
167
157
 
168
-		return null;
169
-	}
158
+        return null;
159
+    }
170
160
 
171
-	/**
172
-	 * Create a Map from a json string, i.e: <code>
173
-	 * [{"f1":2345}, {"f2":"Test de valor"}]
174
-	 * </code>
175
-	 * 
176
-	 * @param json
177
-	 *            String with json format
178
-	 * @return
179
-	 */
180
-	@SuppressWarnings("unchecked")
181
-	public static List<Object> json2list(String json) throws SeCurisException {
182
-		try {
183
-			return MAPPER.readValue(json, List.class);
184
-		} catch (JsonParseException e) {
185
-			LOG.error("Error converting JSON string to object {}", json, e);
186
-			throw new SeCurisException("Error converting JSON to object", e);
187
-		} catch (IOException e) {
188
-			LOG.error("Error converting JSON string to object {}", json, e);
189
-			throw new SeCurisException("Error converting JSON to object", e);
190
-		}
191
-	}
161
+    /**
162
+     * Create a Map from a json string, i.e: <code>
163
+     * [{"f1":2345}, {"f2":"Test de valor"}]
164
+     * </code>
165
+     * 
166
+     * @param json
167
+     *            String with json format
168
+     * @return
169
+     */
170
+    public static List<Object> json2list(String json) {
171
+        try {
172
+            return MAPPER.readValue(json, List.class);
173
+        } catch (JsonParseException e) {
174
+            LOG.error("Error converting JSON string to object {}", json, e);
175
+        } catch (IOException e) {
176
+            LOG.error("Error converting JSON string to object {}", json, e);
177
+        }
178
+        return null;
179
+    }
192
180
 
193
-	public static <T> T json2object(String json, Class<T> classObject) throws SeCurisException {
194
-		try {
195
-			return MAPPER.readValue(json, classObject);
196
-		} catch (JsonParseException e) {
197
-			throw new SeCurisException("Error converting JSON to object", e);
198
-		} catch (IOException e) {
199
-			throw new SeCurisException("Error converting JSON to object", e);
200
-		}
201
-	}
181
+    public static <T> T json2object(String json, Class<T> classObject) throws SeCurisException {
182
+        try {
183
+            return MAPPER.readValue(json, classObject);
184
+        } catch (JsonParseException e) {
185
+            throw new SeCurisException("Error converting JSON to object", e);
186
+        } catch (IOException e) {
187
+            throw new SeCurisException("Error converting JSON to object", e);
188
+        }
189
+    }
202
190
 
203
-	public static <T> T json2object(String json, TypeReference<T> typeReference) throws SeCurisException {
204
-		try {
205
-			return MAPPER.readValue(json, typeReference);
206
-		} catch (JsonParseException e) {
207
-			throw new SeCurisException("Error converting JSON to object", e);
208
-		} catch (IOException e) {
209
-			LOG.error("Error converting JSON to object", e);
210
-			throw new SeCurisException("Error converting JSON to object", e);
211
-		}
212
-	}
191
+    public static <T> T json2object(String json, TypeReference<T> typeReference) throws SeCurisException {
192
+        try {
193
+            return MAPPER.readValue(json, typeReference);
194
+        } catch (JsonParseException e) {
195
+            throw new SeCurisException("Error converting JSON to object", e);
196
+        } catch (IOException e) {
197
+            LOG.error("Unexpected error in JSON to Object process", e);
198
+            throw new SeCurisException("Error converting JSON to object", e);
199
+        }
200
+    }
201
+
202
+    public static ObjectMapper getMapper() {
203
+        return MAPPER;
204
+    }
213
205
 
214
206
 }