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

静态如下：

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

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

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

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

最后是测试：

Java代码  收藏代码
  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.           
  12.         String userJson = Jacksons.me().readAsString(user);  
  13.         String articleJson = Jacksons.me().readAsString(article);  
  14.         System.out.println(userJson);  
  15.         System.out.println(articleJson);  
  16.     }  
  17. }  

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