关于如何处理JSONObject.fromObject(Object obj)无法转换特殊日期（java.sql.Date,java.sql.Timestamp）格式的问题。

2023-07-29 18:54:04

转:关于如何处理JSONObject.fromObject(Object obj)无法转换特殊日期（java.sql.Date,java.sql.Timestamp）格式的问题。

关于JSONObject的封装，或者说使用，现在市面上很多。这里不做过多的描述，但是有种情况却不得不说明下，JSONObject进行对对象进行JSON格式转换，但是在转换过程中，遇到了

Java.sql.Date类型的属性无法完成转换，并且抛出异常：net.sf.json.JSONException:

java.lang.reflect.InvocationTargetException

很多人遇到这个问题后，应该会查询百度等搜索引擎，那么可能得到一种类型转换的说法，我们也得到这样的说法，

后来多方测试，也确实是这个问题。如何解决？

或许很多人会说，那既然时间格式无法转换，我们可以转换设计类型嘛，数据库中我们不用date或datetime，直接用

varchar，而java中直接用String好了。确实这不失一个解决问题的办法，但是如果我们不改呢？

下面是我给出的设计图：

关于如何处理JSONObject.fromObject(Object obj)无法转换特殊日期（java.sql.Date,java.sql.Timestamp）格式的问题。

在这个设计图中，我给出了一个接口JsonValueProcessor ，这个接口可以自定义一些JSON类型转换器，正好，我就

分别定义了3种不同类型的类型转换器。

分析上图，我定义了3种角色：

1、类型转换器抽象接口：分别定义了2个接口方法，一个用于处理数组，一个用于处理属性类型；

2、类型转换器具体实现类：实现了上述抽象接口类的接口方法；

3、调用者：用户通过调用“调用者”的方法，完成由对象向JSONObject转换。

类型转换器抽象接口，由json-lib.jar提供，我们不必定义。

处理java.sql.Date类型属性的类型转换器：

  1. package com.lovo.util;
  2. import java.text.SimpleDateFormat;
  3. import java.util.Date;
  4. import net.sf.json.JsonConfig;
  5. import net.sf.json.processors.JsonValueProcessor;
  6. /**
  7. * 定义一个自己的时间适配处理器
  8. * @author Administrator
  9. *
  10. */
  11. public class SQLDateProcessor implements JsonValueProcessor{
  12. private String format = "yyyy-MM-dd hh:mm:ss";//自定义时间格式化的样式
  13. public SQLDateProcessor() {
  14. super();
  15. // TODO Auto-generated constructor stub
  16. }
  17. public SQLDateProcessor(String format) {
  18. this.format = format;
  19. }
  20. public Object processArrayValue(Object arg0, JsonConfig arg1) {
  21. // TODO Auto-generated method stub
  22. return arg0;
  23. }
  24. /**
  25. * 处理对象的值
  26. * str 这个参数是当前需要处理的属性名
  27. */
  28. public Object processObjectValue(String str, Object obj, JsonConfig arg2) {
  29. // TODO Auto-generated method stub
  30. String ret = "";
  31. if(obj instanceof java.sql.Date){
  32. SimpleDateFormat sdf = new SimpleDateFormat(format);
  33. ret = sdf.format(new Date(((java.sql.Date) obj).getTime()));
  34. }
  35. return ret;
  36. }
  37. }

处理java.util.Date类型的类型转换器：

  1. package com.lovo.util;
  2. import java.text.SimpleDateFormat;
  3. import java.util.Date;
  4. import net.sf.json.JsonConfig;
  5. import net.sf.json.processors.JsonValueProcessor;
  6. /**
  7. * 定义一个自己的时间适配处理器
  8. * @author Administrator
  9. *
  10. */
  11. public class UtilDateProcessor implements JsonValueProcessor{
  12. private String format = "yyyy-MM-dd hh:mm:ss";//自定义时间格式化的样式
  13. public UtilDateProcessor() {
  14. super();
  15. // TODO Auto-generated constructor stub
  16. }
  17. public UtilDateProcessor(String format) {
  18. this.format = format;
  19. }
  20. public Object processArrayValue(Object arg0, JsonConfig arg1) {
  21. // TODO Auto-generated method stub
  22. return arg0;
  23. }
  24. /**
  25. * 处理对象的值
  26. * str 这个参数是当前需要处理的属性名
  27. */
  28. public Object processObjectValue(String str, Object obj, JsonConfig arg2) {
  29. // TODO Auto-generated method stub
  30. String ret = "";
  31. if(obj instanceof java.util.Date){
  32. SimpleDateFormat sdf = new SimpleDateFormat(format);
  33. ret = sdf.format(((Date) obj).getTime());
  34. }
  35. return ret;
  36. }
  37. }

处理java.sql.Timestamp类型的类型转换器：

  1. package com.lovo.util;
  2. import java.text.SimpleDateFormat;
  3. import java.util.Date;
  4. import net.sf.json.JsonConfig;
  5. import net.sf.json.processors.JsonValueProcessor;
  6. /**
  7. * 定义一个自己的时间适配处理器
  8. * @author Administrator
  9. *
  10. */
  11. public class TimestampProcessor implements JsonValueProcessor{
  12. private String format = "yyyy-MM-dd hh:mm:ss";//自定义时间格式化的样式
  13. public TimestampProcessor() {
  14. super();
  15. // TODO Auto-generated constructor stub
  16. }
  17. public TimestampProcessor(String format) {
  18. this.format = format;
  19. }
  20. public Object processArrayValue(Object arg0, JsonConfig arg1) {
  21. // TODO Auto-generated method stub
  22. return arg0;
  23. }
  24. /**
  25. * 处理对象的值
  26. *  str 这个参数是当前需要处理的属性名
  27. */
  28. public Object processObjectValue(String str, Object obj, JsonConfig arg2) {
  29. // TODO Auto-generated method stub
  30. String ret = "";
  31. if(obj instanceof java.sql.Timestamp){
  32. SimpleDateFormat sdf = new SimpleDateFormat(format);
  33. ret = sdf.format(((Date) obj).getTime());
  34. }
  35. return ret;
  36. }
  37. }

调用者类：

  1. package com.lovo.util;
  2. import java.util.Iterator;
  3. import java.util.Map;
  4. import net.sf.json.JSONObject;
  5. import net.sf.json.JsonConfig;
  6. import net.sf.json.processors.JsonValueProcessor;
  7. /**
  8. * JSON格式转换类
  9. * @author Administrator
  10. *
  11. */
  12. public class JSONUtil {
  13. /**
  14. * 将一个对象直接转换为一个JSONObject对象，
  15. * 同样适合于JSON格式的字符串
  16. * 但是如果存在java.sql.Date或者java.sql.Timestamp时间格式，调用例外一个toJson转换方法
  17. * @param obj
  18. * @return
  19. */
  20. public static JSONObject toJson(Object obj) {
  21. return JSONObject.fromObject(obj);
  22. }
  23. /**
  24. *
  25. * @param obj 需要转换的参数
  26. * @param processors 类型转换器的集合,参数是一个Map集合，键代表需要转换类型的全路径，值是类型转换器
  27. * @return
  28. * @throws ClassNotFoundException
  29. */
  30. public static JSONObject toJson(Object obj,Map<String,JsonValueProcessor> processors) throws ClassNotFoundException{
  31. //定义一个JSONConfig对象，该对象可以制定一个转换规则
  32. JsonConfig config = new JsonConfig();
  33. if(processors != null && !processors.isEmpty()){
  34. Iterator<java.util.Map.Entry<String, JsonValueProcessor>> it = processors.entrySet().iterator();
  35. while (it.hasNext()) {
  36. Map.Entry<java.lang.String, net.sf.json.processors.JsonValueProcessor> entry = (Map.Entry<java.lang.String, net.sf.json.processors.JsonValueProcessor>) it
  37. .next();
  38. String key = entry.getKey();
  39. JsonValueProcessor processor = processors.get(key);
  40. //反射获取到需要转换的类型
  41. Class<?> cls = Class.forName(key);
  42. config.registerJsonValueProcessor(cls, processor);
  43. }
  44. }
  45. return JSONObject.fromObject(obj, config);
  46. }
  47. }

客户端调用“调用者”类，来完成对象向JSONObject进行转换：

  1. package com.test.util;
  2. import java.sql.Date;
  3. import java.sql.Timestamp;
  4. import java.util.HashMap;
  5. import java.util.Map;
  6. import org.junit.Ignore;
  7. import org.junit.Test;
  8. import com.lovo.util.SQLDateProcessor;
  9. import com.lovo.util.JSONUtil;
  10. import com.lovo.util.TimestampProcessor;
  11. import com.lovo.util.User;
  12. import net.sf.json.JSONObject;
  13. import net.sf.json.processors.JsonValueProcessor;
  14. public class JSONTest {
  15. @Test
  16. public void testJsonObjectOne() {
  17. String shortFormat = "yyyy-MM-dd";
  18. String longFormat = "yyyy-MM-dd hh:mm:ss";
  19. Date sqlDate = new Date(System.currentTimeMillis());
  20. Timestamp createTime = new Timestamp(System.currentTimeMillis());
  21. User user = new User("高高", sqlDate, createTime);
  22. // 定义一个类型转化器集合，键是需要转换的类型全路径，值是用于转换的类型转换器
  23. Map<String, JsonValueProcessor> processors = new HashMap<String, JsonValueProcessor>();
  24. //有了2-3种时间转换器，那么我们设计时，就可以短时间格式用Date,长时间格式就是用Timestamp
  25. processors.put("java.sql.Date", new SQLDateProcessor(shortFormat));
  26. //      processors.put("java.util.Date", new UtilDateProcessor(shortFormat));
  27. processors.put("java.sql.Timestamp", new TimestampProcessor(longFormat));
  28. JSONObject json = null;
  29. try {
  30. json = JSONUtil.toJson(user, processors);
  31. } catch (ClassNotFoundException e) {
  32. // TODO Auto-generated catch block
  33. e.printStackTrace();
  34. }
  35. System.out.println(json.toString());
  36. }
  37. /**
  38. * 将一个JSON格式的字符串转换为JSONObject对象，并获得其值
  39. */
  40. @Ignore
  41. public void testJsonObjectTwo() {
  42. // {"createTime":"2016-06-03 04:05:23","birthday":"2016-06-03","name":"高高"}
  43. String str = "{'createTime':'2016-06-03 04:05:23','birthday':'2016-06-03','name':'1'}";
  44. JSONObject json = null;
  45. try {
  46. json = JSONUtil.toJson(str, null);
  47. } catch (ClassNotFoundException e) {
  48. // TODO Auto-generated catch block
  49. e.printStackTrace();
  50. }
  51. System.out.println(json.get("name"));
  52. System.out.println(json.get("createTime"));
  53. System.out.println(json.get("birthday"));
  54. }
  55. }

得到的结果是：

  1. {"createTime":"2016-06-03 05:09:49","birthday":"2016-06-03","name":"高高"}

在JSONUtil类中，由于我们可以采用JSONConfig类来一次性注册多个类型转换器，所以我将多个类型转换器装配到

Map中，迭代Map集合采用反射机制来获取到需要转换的类型，向JSONConfig类中注册。

在这个过程中，封装了日期格式的传递，方便大家得到自己想要的日期格式。

上一篇：简单的SQL查询，循环插入


下一篇：python 浅析类方法与静态方法