Jackson 过滤属性

jackson过滤属性分为静态和动态两种。

静态如下：

定义两个Bean 先，这两个bean 是父子关系。

1. public class User {
2. private String name;
3. private Date createDate;
4. private Set<Article> articles = Sets.newHashSet();
5. public String getName() {
6. return name;
7. }
8. public void setName(String name) {
9. this.name = name;
10. }
11. public Date getCreateDate() {
12. return createDate;
13. }
14. public void setCreateDate(Date createDate) {
15. this.createDate = createDate;
16. }
17. public Set<Article> getArticles() {
18. return articles;
19. }
20. public void setArticles(Set<Article> articles) {
21. this.articles = articles;
22. }
23. }

1. public class Article {
2. private String title;
3. private User user;
4. public String getTitle() {
5. return title;
6. }
7. public void setTitle(String title) {
8. this.title = title;
9. }
10. public User getUser() {
11. return user;
12. }
13. public void setUser(User user) {
14. this.user = user;
15. }
16. }

然后自己写的一个Jackson实用类

1. public class Jacksons {
2. private ObjectMapper objectMapper;
3. public static Jacksons me() {
4. return new Jacksons();
5. }
6. private Jacksons() {
7. objectMapper = new ObjectMapper();
8. // 设置输入时忽略在JSON字符串中存在但Java对象实际没有的属性
9. objectMapper.disable(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES);
10. objectMapper.configure(SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS, false);
11. objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd"));
12. }
13. public Jacksons filter(String filterName, String... properties) {
14. FilterProvider filterProvider = new SimpleFilterProvider().addFilter(filterName,
15. SimpleBeanPropertyFilter.serializeAllExcept(properties));
16. objectMapper.setFilters(filterProvider);
17. return this;
18. }
19. public Jacksons addMixInAnnotations(Class<?> target, Class<?> mixinSource) {
20. objectMapper.getSerializationConfig().addMixInAnnotations(target, mixinSource);
21. objectMapper.getDeserializationConfig().addMixInAnnotations(target, mixinSource);
22. return this;
23. }
24. public Jacksons setDateFormate(DateFormat dateFormat) {
25. objectMapper.setDateFormat(dateFormat);
26. return this;
27. }
28. public <T> T json2Obj(String json, Class<T> clazz) {
29. try {
30. return objectMapper.readValue(json, clazz);
31. } catch (Exception e) {
32. e.printStackTrace();
33. throw new RuntimeException("解析json错误");
34. }
35. }
36. public String readAsString(Object obj) {
37. try {
38. return objectMapper.writeValueAsString(obj);
39. } catch (Exception e) {
40. e.printStackTrace();
41. throw new RuntimeException("解析对象错误");
42. }
43. }
44. @SuppressWarnings("unchecked")
45. public List<Map<String, Object>> json2List(String json) {
46. try {
47. return objectMapper.readValue(json, List.class);
48. } catch (Exception e) {
49. e.printStackTrace();
50. throw new RuntimeException("解析json错误");
51. }
52. }
53. }

最后是测试：

1. public class Test {
2. public static void main(String args[]) {
3. User user = new User();
4. user.setName("chris");
5. user.setCreateDate(new Date());
6. Article article = new Article();
7. article.setTitle("title");
8. article.setUser(user);
9. Set<Article> articles = Sets.newHashSet(article);
10. user.setArticles(articles);
11. String userJson = Jacksons.me().readAsString(user);
12. String articleJson = Jacksons.me().readAsString(article);
13. System.out.println(userJson);
14. System.out.println(articleJson);
15. }
16. }

1.父子关系引用

直接输出肯定是报循环错误，Jackson 提供了两个注解

@JsonManagedReference

public Set<Article> getArticles() {

return articles;

}

@JsonBackReference

public User getUser() {

return user;

}

打印结果为：{"name":"chris","createDate":"2012-04-18","articles":[{"title":"title"}]}， {"title":"title"}

2.@JsonIgnore注解

只说父子引用关系的。父子两边都加@JsonIgnore打印字符串为:

{"name":"chris","createDate":"2012-04-18"}，{"title":"title"}

单向User加该注解

@JsonIgnore

public Set<Article> getArticles() {

return articles;

}

打印结果为:

{"name":"chris","createDate":"2012-04-18"}

{"title":"title","user":{"name":"chris","createDate":"2012-04-18"}}

单向Article 加该注解

@JsonIgnore

public User getUser() {

return user;

}

打印结果:

{"name":"chris","createDate":"2012-04-18","articles":[{"title":"title"}]}

{"title":"title"}

3.@JsonIgnoreType（没用过）

4.@JsonIgnoreProperties

这个加在类级别上, 用法很简单@JsonIgnoreProperties({"property1", "property2"})

动态过滤属性：

这个比较麻烦方法如下（有如下两种方法）：

1.使用@JsonFilter注解

使用方法为先给ObjectMapper添加一个filter，然后还要在需要过滤的类上加@JsonFilter("filterName")注解。

比如说要过滤User 上的name属性，先

Jacksons.me().filter("myFilter", "name").readAsString(user)，具体看Jacksons代码。并在User类上加@JsonFilter("myFilter")。

有点不爽的是如果用另外一个没有添加该filter的ObjectMapper解析的话会报错。

如果这个User类已经添加了@JsonFilter("myFilter")注解，但在另外一个地方又要解析它并不想过滤name 属性，那只能是

Jacksons.me().filter("myFilter", "")，然后在读出来。

如果要过滤多个属性可以如下：

Set<String> rolePros = new HashSet<String>();
rolePros.add("rank");
rolePros.add("areaId");
rolePros.add("areaName");
rolePros.add("areaCode");

Set<String> titleFilter = new HashSet<String>();
titleFilter.add("status");
titleFilter.add("ottVisible");
titleFilter.add("dvbVisible");
titleFilter.add("roleRelationList");

objectMapper = new ObjectMapper();
FilterProvider filterProvider = new SimpleFilterProvider().
addFilter("RoleFilter",SimpleBeanPropertyFilter.serializeAllExcept(rolePros)).
addFilter("TitleFilter", SimpleBeanPropertyFilter.serializeAllExcept(titleFilter));
objectMapper.setFilters(filterProvider);

写完这个后，还需要在需过滤的Bean上加@JsonFilter(filterName),

2.添加混入注解(暂时这么翻译)

定义一个接口或类先, 在该类上添加@JsonIgnoreProperties("name"), 然后在ObjectMapper的配置项上添加混入注解

输出为:

String mixInUser = Jacksons.me().addMixInAnnotations(User.class, MixInUser.class).readAsString(user);

System.out.println(mixInUser);

引自：http://yxb1990.iteye.com/blog/1489712