Gson简单过滤工具类封装

为手机app封装接口，需要把结果转换成json，这里用到了gson，但是有很多属性是不能对外暴露的，因此要过滤掉，gson自带的策略能够实现，但是代码一大坨

@Test
public void testStrategy(){

final Set<String> excludeAttr = Sets.newHashSet();//需要排除的属性
excludeAttr.add("age");

final Map<String,String> translateNameMap = Maps.newHashMap();//需要更改名称的属性
translateNameMap.put("name", "employeeName");

Gson gson = new GsonBuilder().serializeNulls()
.addSerializationExclusionStrategy(
new ExclusionStrategy() {
@Override
public boolean shouldSkipField(FieldAttributes attr) {
return excludeAttr.contains(attr.getName()) ? true
: false;
}
@Override
public boolean shouldSkipClass(Class<?> clazz) {
return false;
}
}).setFieldNamingStrategy(
new FieldNamingStrategy() {
@Override
public String translateName(Field field) {
return translateNameMap.get(field.getName()) == null ? field
.getName() : translateNameMap.get(field.getName());

}
}).create();

Employee employee = new Employee();
employee.setId("1");employee.setName("dean");
employee.setAge(32);employee.setEntryDate(new Date());
String json = gson.toJson(employee);
System.out.println(json);

List<Employee> employeeList = Lists.newArrayList();
employeeList.add(employee);
String json1 = gson.toJson(employeeList);
System.out.println(json1);
}

重用性不够高，于是自己封装了一个简单的工具类

public class GsonSimplePreFilter {
// 当includes的size > 0时，属性必须在includes中才会被序列化，excludes优先于includes，全局的excludes和includes优先于过滤类中的excludes和includes
private final Set<String> includes = Sets.newHashSet();
private final Set<String> excludes = Sets.newHashSet();
private final Map<String, String> translateNames = Maps.newHashMap();
private final List<FilterClass> filterClassList = Lists.newArrayList();

private GsonBuilder gsonBuilder;

public GsonSimplePreFilter() {
gsonBuilder = CommonUtils.getDefaultGsonBuilder();
}

public GsonSimplePreFilter(GsonBuilder gsonBuilder) {
this.gsonBuilder = gsonBuilder;
}

public Gson create() {
final int includesCount = includes.size();
final int excludesCount = excludes.size();

return gsonBuilder
.addSerializationExclusionStrategy(new ExclusionStrategy() {
@Override
public boolean shouldSkipField(FieldAttributes attr) {
if (excludesCount > 0
&& excludes.contains(attr.getName())) {
return true;
} else {
if (includesCount > 0
&& !includes.contains(attr.getName())) {
return true;
}
}

for (FilterClass filterClass : filterClassList) {
if (attr.getDeclaringClass().getName()
.equals(filterClass.getClazz().getName())) {
if (filterClass.getExcludes().size() > 0
&& filterClass.getExcludes().contains(
attr.getName())) {
return true;
} else {
if (filterClass.getIncludes().size() > 0
&& !filterClass.getIncludes()
.contains(attr.getName())) {
return true;
}
}
}
}

return false;
}

@Override
public boolean shouldSkipClass(Class<?> clazz) {
return false;
}
}).setFieldNamingStrategy(new FieldNamingStrategy() {
@Override
public String translateName(Field field) {
if (translateNames.get(field.getName()) != null) {
return translateNames.get(field.getName());
} else {
for (FilterClass filterClass : filterClassList) {
if (field
.getDeclaringClass()
.getName()
.equals(filterClass.getClazz()
.getName())) {
if (filterClass.getTranslateNames().get(
field.getName()) != null) {
return filterClass.getTranslateNames()
.get(field.getName());
}
}
}
}
return field.getName();
}
}).create();
}

/**
* 需要保留的属性
*
* @param attr
* @return
*/
public GsonSimplePreFilter setIncludes(String... attr) {
includes.addAll(Arrays.asList(attr));
return this;
}

/**
* 需要排除的属性
*
* @param attr
* @return
*/
public GsonSimplePreFilter setExcludes(String... attr) {
excludes.addAll(Arrays.asList(attr));
return this;
}

/**
* 转换属性名称
*
* @param old
*            转换前
* @param now
*            转换后
* @return
*/
public GsonSimplePreFilter setTranslateNames(String old, String now) {
translateNames.put(old, now);
return this;
}

public Set<String> getIncludes() {
return includes;
}

public Set<String> getExcludes() {
return excludes;
}

public Map<String, String> getTranslateNames() {
return translateNames;
}

public List<FilterClass> getFilterClassList() {
return filterClassList;
}

public FilterClassBuidler createBuilder() {
return new FilterClassBuidler(this);
}

/**
* 静态内部类构造器
*
*/
public static final class FilterClassBuidler {

private GsonSimplePreFilter gsonFilter;
private FilterClass filterClass;

FilterClassBuidler(GsonSimplePreFilter instant) {
gsonFilter = instant;
}

/**
* 设置要进行过滤的类
* @param clazz
* @return
*/
public FilterClassBuidler setFilterClass(Class<?> clazz) {
filterClass = new FilterClass();
filterClass.setClazz(clazz);
gsonFilter.getFilterClassList().add(filterClass);
return this;
}

/**
* 设置要过滤的类中需要被排除的属性
* @param attr
* @return
*/
public FilterClassBuidler setClassExcludes(String... attr) {
filterClass.getExcludes().addAll(Arrays.asList(attr));
return this;
}

/**
* 设置要过滤的类中需要被包含的属性
* @param attr
* @return
*/
public FilterClassBuidler setClassIncludes(String... attr) {
filterClass.getIncludes().addAll(Arrays.asList(attr));
return this;
}

/**
* 设置要过滤的类中需要被转换的属性
* @return
*/
public FilterClassBuidler setClassTranslateNames(String old, String now) {
filterClass.getTranslateNames().put(old, now);
return this;
}

/**
* 构造为GsonSimplePreFilter
* @return
*/
public GsonSimplePreFilter buildPreFilter() {
return gsonFilter;
}
}

public static final class FilterClass {
Class<?> clazz;
Set<String> includes = new HashSet<String>();
Set<String> excludes = new HashSet<String>();
Map<String, String> translateNames = new HashMap<String, String>();

public Class<?> getClazz() {
return clazz;
}

public void setClazz(Class<?> clazz) {
this.clazz = clazz;
}

public Set<String> getIncludes() {
return includes;
}

public void setIncludes(Set<String> includes) {
this.includes = includes;
}

public Set<String> getExcludes() {
return excludes;
}

public void setExcludes(Set<String> excludes) {
this.excludes = excludes;
}

public Map<String, String> getTranslateNames() {
return translateNames;
}

public void setTranslateNames(Map<String, String> translateNames) {
this.translateNames = translateNames;
}

}

public static void main(String[] args) {
EduCourse c = new EduCourse();
c.setId("1");
c.setName("2");
c.setRemark("3");
c.setLessonId("zzzz");
// 例子1只序列化name remark字段 并且把字段名称name改成namename
Gson gson = new GsonSimplePreFilter().setIncludes("name", "remark")
.setTranslateNames("name", "namename").create();
System.out.println(gson.toJson(c));
// 例子2 不序列化"id", "remark"
GsonBuilder buidler = new GsonBuilder();
Gson gson1 = new GsonSimplePreFilter(buidler)
.setExcludes("id", "remark")
.setTranslateNames("name", "namename").create();
System.out.println(gson1.toJson(c));

EduStudent student = new EduStudent();
student.setId("222");
student.setName("3333");
student.setAge(33);

//例子3 多个对象，可以全局包含和排除，也可以对局部对象的包含和排除
Map<String, Object> map = Maps.newHashMap();
map.put("course", c);
map.put("student", student);
Gson gson2 = new GsonSimplePreFilter().setExcludes("id").setTranslateNames("name", "namename")
.createBuilder()
.setFilterClass(EduStudent.class).setClassExcludes("state").setClassTranslateNames("age", "age1111")
.setFilterClass(EduCourse.class).setClassExcludes("lessonsNum").setClassTranslateNames("goodsPrice", "goodsPrice2222")
.buildPreFilter()
.create();
System.out.println(gson2.toJson(map));
}
}

可以支持平时大部分使用的场景，特殊情况肯定还是需要特殊处理