转载自：https://www.ibm.com/developerworks/cn/java/j-lo-jsonlib/index.html
概述
如今大量的 Web 站点应用了 AJAX 技术，通过更少的数据通讯，服务器能够更快的反馈用户请求，再通过 Javascript 的控制，让使用者有了更好的用户体验。JSON 是一种轻量级的数据交换语言，它是 Javascript 的一个子集，又有良好的可读性，经常用于客户端和服务器间的数据交换。因此，在服务器端，常常需要将实体对象（JavaBean）转换为 JSON 格式数据。本文介绍了如何使用 Json-lib 转换 JavaBean 为 JSON 格式数据，并给出解决方法，以及利用 annotation 来增强 Json-lib 的两个功能：一是灵活的筛选 JavaBean 属性；二是通过 JsonValueProcessor 来自定义如何转换 JavaBean 属性到 JSON 数据。
JSON 数据格式
JSON 的数据格式简单易读，它存在于两种基本形式：
这两种形式的有机组合，就形成了 JSON 数据。
使用 Json-lib 转换 JavaBean 为 JSON 数据
Json-lib 是一个 java 工具库，它提供 api 来转换 JavaBean，Map，Collection 等对象为 JSON 数据，或反过来通过 JSON 数据得到 JavaBean。
Json-lib 的使用很容易，只要使用 JSONSerializer 的 toJSON 方法就可以转换任意的 Java Object 为 JSON 对象了，再调用 JSON 对象的 toString 方法可以得到转换后的字符串。不过还有一些进一步的问题需要我们自己来解决。
清单 1. 使用 JSONSerializer
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
import net.sf.json.JSONSerializer;
List list = new ArrayList();
list.add( "first" );
list.add( "second" );
JSON json = JSONSerializer.toJSON( list );
System.out.println( json.toString() );
// prints ["first","second"]
class MyBean{
private String name = "json";
private int pojoId = 1;
// getters & setters
...
}
json = JSONSerializer.toJSON( new MyBean() );
System.out.println( json.toString() );
// prints {"name":"json","pojoId":1}
|
问题 1: 需要有选择的提取 JavaBean 中的属性
清单 1 中的例子转换后的 JSON 数据中包含了 JavaBean 中的全部属性，可是我们常常需要有选择的提取 JavaBean 中的特定属性出来。例如：
问题 2: 需要自定义某些属性的转换方式
对于普通的 Object 类型（如 Long，String 等），json-lib 有缺省的值转换处理方式，但是对于一些特殊的类型，我们希望用自定义的方式来转换该属性的值。例如：
Json-lib 已经预留出一些接口，让用户修改它的缺省行为。下面我们来看看如何利用 annotation 来配合 Json-lib 解决这两个问题。
使用 annotation 筛选 JavaBean 属性
JSONSerializer 提供了一个 toJSON 的重载方法，增加一个参数 JsonConfig，可以通过这个参数对 Json-lib 的缺省方式做自定义的配置。
清单 2. 自定义 JSONSerializer 的属性过滤器
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
import net.sf.json.JSONSerializer;
import net.sf.json.JsonConfig;
import net.sf.json.util.PropertyFilter;
// 定义属性过滤器
PropertyFilter filter = new PropertyFilter(
public boolean apply(Object source, String name, Object value) {
if ( name.equals( “pojoId” ) ) {
return true; // 返回 true, 表示这个属性将被过滤掉
}
return false;
}
);
// 注册属性过滤器
JsonConfig config = new JsonConfig();
config.setJsonPropertyFilter( filter );
System.out.println( JSONSerializer.toJSON( new MyBean(), config ) );
// prints {"name":"json"}
|
从清单 2 中可以看出来，Json-lib 通过 PropertyFilter 的 apply 方法进行属性过滤，可以象例子中一样，把所有需要过滤的属性名称写进去，但是这样做太烦琐，也不好维护，对不同的 Bean 要做不同的处理。下面让我们看看怎么利用 annotation 来更方便的处理。
首先，需要定义一个 annotation，并给 MyBean 的 get 方法加上标注。
清单 3. 定义一个 annotation: Invisible
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
import java.lang.annotation.Target;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.ElementType;
import java.lang.annotation.RetentionPolicy;
@Documented
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Invisible {
public String[] value();
}
// 为myBean中需要过滤的属性get方法（或者is方法）加上Invisible标注
public class MyBean{
private String name = "json";
private int pojoId = 1;
// getters & setters
public String getName() { return name; }
@Invisible(“LIST”) // 在 “LIST” 情况下不要这个属性
public int getPojoId() { return pojoId; }
}
|
然后，我们需要一些能处理 annotation 的 PropertyFilter 类。
清单 4. 处理 annotation 的 PropertyFilter 类
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
|
import java.util.Map;
import java.lang.reflect.Method;
import net.sf.json.util.PropertyFilter;
// 先实现一个abstract类，将读取Bean属性的Method找到并传递给子类处理
public abstract class AbstractMethodFilter implements PropertyFilter {
// 这个方法留给子类实现，以便适应不同的过滤需求
public abstract boolean apply(final Method method);
public boolean apply(final Object source, final String name, final Object value) {
if (source instanceof Map) {
return false;
}
String propName = name.substring(0, 1).toUpperCase() + name.substring(1);
Class clz = source.getClass();
String methodName = "get" + propName;
Method method = null;
try {
method = clz.getMethod(methodName, (Class[]) null); // 寻找属性的get方法
} catch (NoSuchMethodException nsme) {
String methodName2 = "is" + propName; // 也许是个is方法
try {
method = clz.getMethod(methodName2, (Class[]) null);
} catch (NoSuchMethodException ne) {
// 没有找到属性的get或者is方法，打印错误，返回true
System.err.println(“No such methods: ”
+ methodName + “ or “ + methodName2);
return true;
}
}
return apply(method);
}
} // END: AbstractMethodFilter
public class InvisibleFilter extends AbstractMethodFilter {
// 过滤条件，标注中有符合这个条件的property将被过滤掉
private String _sGUIID;
public InvisibleFilter(final String guiid) {
_sGUIID = guiid;
}
public boolean apply(final Method method) {
if (_sGUIID == null || _sGUIID.equals(“”)) {
return false; // 表示不做限制
}
if (method.isAnnotationPresent(Invisible.class)) {
Invisible anno = method.getAnnotation(Invisible.class);
String[] value = anno.value();
for (int i = 0; i < value.length; i++) {
if (_sGUIID.equals(value[i])) {
return true;
}
}
}
return false;
}
}
|
现在只要把这个 filter 注册到 JsonConfig 中，就实现了属性的过滤，请看清单 5。
清单 5. 使用 InvisibleFilter 来过滤不需要的属性
|
1
2
3
4
5
|
JsonConfig config = new JsonConfig();
config.setJsonPropertyFilter( new InvisibleFilter(“LIST”)); //标注了LIST的属性将被过滤掉
System.out.println( JSONSerializer.toJSON( new MyBean(), config ) );
// prints {"name":"json"}
|
增加其他的 annotation 及 Filter 就可以实现不同的属性过滤方式了。
使用 annotation 自定义 Bean 属性的转换方式
Json-lib 通过 JsonConfig 提供了自定义属性转换方式的接口。
清单 6. 注册 JsonValueProcessor
|
1
2
|
JsonConfig config = new JsonConfig();
config.registerJsonValueProcessor(java.util.Date.class, new JsDateJsonValueProcessor());
|
注册后 Json-lib 在遇到 java.uitl.Date 类型的属性时，会应用 JsDateJsonValueProcessor 的处理方法。
所以，只要实现自己的 JsonValueProcessor 就可以自定义各种 Object 的转换方式了。
根据上一节的讨论，Json-lib 在转换 Bean 属性之前，会将属性数据传递给 PropertyFilter 来判断是否需要过滤掉。因此，我们可以通过一个 Filter 对象获得 Bean 的属性的标注数据，并将它传递给特定的 Processor，Processor 根据得到的标注值知道应该怎么处理这个属性。下面以整型代码为例，说明处理的方法。
一般情况下，一个项目中会涉及许多种不同的代码，我们会为每一种代码定义一个主代码号（代码往往都是整型的），为它的子项定义几个子代码号。例如，我们定义性别的主代码号为 100，并定义男：1，女：2。
首先，需要一个代码标注（IntegerCode）及一个处理这种标注的 PropertyFilter。
清单 7. IntegerCode 及 IntegerCodeFilter
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
@Documented
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface IntegerCode {
public int value();
}
public class IntegerCodeFilter extends AbstractMethodFilter {
// 代码处理器
private IntegerCodeProcessor _processor;
public IntegerCodeFilter(final IntegerCodeProcessor processor) {
_processor = processor;
}
// 不过滤属性，但当发现IntegerCode标注时，将数据传递给Processor
public boolean apply(final Method method) {
if (_processor == null) {
return false; // 表示没有特别的处理
}
if (method.isAnnotationPresent(IntegerCode.class)) {
IntegerCode anno = method.getAnnotation(IntegerCode.class);
int code = anno.value();
_processor.setMainCode(code); // 将code设置为主代码
}
return false;
}
}
|
现在，我们需要一个 JsonValueProcessor 来处理 IntegerCode 数据。
清单 8. IntegerCodeProcessor
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
|
public class IntegerCodeProcessor implements JsonValueProcessor {
private int _iMainCode;
public void setMainCode(final int mainCode) { _iMainCode = mainCode; }
public IntegerCodeProcessor() {
super();
} // END: IntegerCodeProcessor
private void reset() {
_iMainCode = -1;
}
public Object processArrayValue(Object value, JsonConfig jsonConfig) {
return process(value, jsonConfig);
} // END: processArrayValue
public Object processObjectValue(
String key, Object value, JsonConfig jsonConfig ) {
return process( value, jsonConfig );
} // END: processObjectValue
private Object process(Object value, JsonConfig jsonConfig) {
if (value == null) {
return null;
}
String ret = null;
if (value instanceof Integer && _iMainCode >= 0) {
int code = value.intValue();
switch (_iMainCode) {
case 100: // 这里使用简单的case 处理不同的代码
if (code == 1) { // 好一点的方式是从资源文件中读取对应值
ret = "man";
} else if (code == 2) {
ret = "woman";
} else {
ret = value.toString();
}
break;
default:
ret = value.toString();
break;
}
} else {
ret = value.toString();
}
reset(); // 处理后重置，以免影响其他 Integer 属性
return ret;
} // END: process
}
|
现在，我们创建一个 JavaBean：Student 来测试这个 Processor。
清单 9. 测试 IntegerCodeProcessor
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public class Student {
private String name = "camry";
private int gender = 1;
// getters & setters
public String getName() { return name; }
@IntegerCode(100) // 性别主代码为 100
public int getGender() { return gender; }}
}
...
IntegerCodeProcessor processor = new IntegerCodeProcessor();
IntegerCodeFilter filter = new IntegerCodeFilter(processor);
JsonConfig config = new JsonConfig();
config.setJsonPropertyFilter( filter );
config.registerJsonValueProcessor(Integer.class, processor);
System.out.println( JSONSerializer.toJSON( new Student(), config ) );
// prints {“gender”:”man”, "name":"camry"}
|
结束语
Json-lib 可以很方便的进行 JavaBean 到 JSON 数据的转换，再结合 annotation 为 JavaBean 的属性定义元数据，可以减少代码，提高效率。
相关主题