Gson：如何从没有注释的序列化中排除特定字段
我正在尝试学习Gson，并且在领域排除方面苦苦挣扎。 这是我的课
public class Student {
private Long id;
private String firstName = "Philip";
private String middleName = "J.";
private String initials = "P.F";
private String lastName = "Fry";
private Country country;
private Country countryOfBirth;
}
public class Country {
private Long id;
private String name;
private Object other;
}
我可以使用GsonBuilder并为诸如firstName或country的字段名称添加ExclusionStrategy，但是我似乎无法设法排除诸如country.name的某些字段的属性。
使用public boolean shouldSkipField(FieldAttributes fa) ，FieldAttributes包含的信息不足，无法使用country.name这样的过滤器来匹配该字段。
对于解决此问题的任何帮助，我将不胜感激。
PS：我想避免使用注释，因为我想对此进行改进，并使用RegEx过滤掉字段。
谢谢
编辑 ：我试图看看是否有可能模拟Struts2 JSON插件的行为
使用Gson
true
login.password,
studentList.*\.sin
编辑：我重新打开了以下添加的问题：
我添加了第二个具有相同类型的字段，以进一步阐明此问题。 基本上我想排除country.name但不排除countrOfBirth.name 。 我也不想将“国家”作为一种类型排除在外。 因此，类型与我要查明和排除的对象图中的实际位置相同。
#1楼
我想出了一个类工厂来支持此功能。 传入您要排除的字段或类的任意组合。
public class GsonFactory {
public static Gson build(final List fieldExclusions, final List> classExclusions) {
GsonBuilder b = new GsonBuilder();
b.addSerializationExclusionStrategy(new ExclusionStrategy() {
@Override
public boolean shouldSkipField(FieldAttributes f) {
return fieldExclusions == null ? false : fieldExclusions.contains(f.getName());
}
@Override
public boolean shouldSkipClass(Class clazz) {
return classExclusions == null ? false : classExclusions.contains(clazz);
}
});
return b.create();
}
}
要使用，请创建两个列表（每个列表都是可选的），然后创建您的GSON对象：
static {
List fieldExclusions = new ArrayList();
fieldExclusions.add("id");
fieldExclusions.add("provider");
fieldExclusions.add("products");
List> classExclusions = new ArrayList>();
classExclusions.add(Product.class);
GSON = GsonFactory.build(null, classExclusions);
}
private static final Gson GSON;
public String getSomeJson(){
List list = getEntitiesFromDatabase();
return GSON.toJson(list);
}
#2楼
或者可以说Whats字段不会公开：
Gson gson = gsonBuilder.excludeFieldsWithModifiers(Modifier.TRANSIENT).create();
在您的课程上的属性：
private **transient** boolean nameAttribute;
#3楼
我遇到了这个问题，在这个问题中我只想排除序列化中的少数字段，因此我开发了一个相当简单的解决方案，该解决方案使用Gson的@Expose注释和自定义排除策略。
使用@Expose的唯一内置方法是设置GsonBuilder.excludeFieldsWithoutExposeAnnotation() ，但是顾名思义，没有显式@Expose字段将被忽略。 由于只有几个要排除的字段，因此我发现将注释添加到每个字段的前景非常繁琐。
我实际上想要反函数，其中包括所有内容，除非我明确使用@Expose排除它。 我使用以下排除策略来完成此任务：
new GsonBuilder()
.addSerializationExclusionStrategy(new ExclusionStrategy() {
@Override
public boolean shouldSkipField(FieldAttributes fieldAttributes) {
final Expose expose = fieldAttributes.getAnnotation(Expose.class);
return expose != null && !expose.serialize();
}
@Override
public boolean shouldSkipClass(Class aClass) {
return false;
}
})
.addDeserializationExclusionStrategy(new ExclusionStrategy() {
@Override
public boolean shouldSkipField(FieldAttributes fieldAttributes) {
final Expose expose = fieldAttributes.getAnnotation(Expose.class);
return expose != null && !expose.deserialize();
}
@Override
public boolean shouldSkipClass(Class aClass) {
return false;
}
})
.create();
现在，我可以使用@Expose(serialize = false)或@Expose(deserialize = false)批注轻松排除一些字段（请注意，两个@Expose属性的默认值为true ）。 您当然可以使用@Expose(serialize = false, deserialize = false) ，但这可以通过声明字段transient来更简洁地实现（它在这些自定义排除策略中仍然有效）。
#4楼
您可以使用gson探索json树。
尝试这样的事情：
gson.toJsonTree(student).getAsJsonObject()
.get("country").getAsJsonObject().remove("name");
您还可以添加一些属性：
gson.toJsonTree(student).getAsJsonObject().addProperty("isGoodStudent", false);
用gson 2.2.4测试。
#5楼
阅读所有可用的答案后，我发现最灵活的方法是使用自定义@Exclude注释。 因此，我为此实现了一个简单的策略（我不想使用@Expose标记所有字段，也不想使用与应用程序可Serializable化Serializable化冲突的transient ）：
注解：
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Exclude {
}
战略：
public class AnnotationExclusionStrategy implements ExclusionStrategy {
@Override
public boolean shouldSkipField(FieldAttributes f) {
return f.getAnnotation(Exclude.class) != null;
}
@Override
public boolean shouldSkipClass(Class clazz) {
return false;
}
}
用法：
new GsonBuilder().setExclusionStrategies(new AnnotationExclusionStrategy()).create();
#6楼
另一种方法（如果需要在运行时决定排除某个字段，则特别有用）是在您的gson实例中注册TypeAdapter。 下面的例子：
Gson gson = new GsonBuilder()
.registerTypeAdapter(BloodPressurePost.class, new BloodPressurePostSerializer())
在以下情况下，服务器将期望两个值之一，但是由于它们都是整数，因此gson会将它们两个序列化。 我的目标是从发布到服务器的json中忽略任何零（或更少）的值。
public class BloodPressurePostSerializer implements JsonSerializer {
@Override
public JsonElement serialize(BloodPressurePost src, Type typeOfSrc, JsonSerializationContext context) {
final JsonObject jsonObject = new JsonObject();
if (src.systolic > 0) {
jsonObject.addProperty("systolic", src.systolic);
}
if (src.diastolic > 0) {
jsonObject.addProperty("diastolic", src.diastolic);
}
jsonObject.addProperty("units", src.units);
return jsonObject;
}
}
#7楼
我使用了这种策略：我排除了没有标有@SerializedName注释的每个字段，即：
public class Dummy {
@SerializedName("VisibleValue")
final String visibleValue;
final String hiddenValue;
public Dummy(String visibleValue, String hiddenValue) {
this.visibleValue = visibleValue;
this.hiddenValue = hiddenValue;
}
}
public class SerializedNameOnlyStrategy implements ExclusionStrategy {
@Override
public boolean shouldSkipField(FieldAttributes f) {
return f.getAnnotation(SerializedName.class) == null;
}
@Override
public boolean shouldSkipClass(Class clazz) {
return false;
}
}
Gson gson = new GsonBuilder()
.setExclusionStrategies(new SerializedNameOnlyStrategy())
.create();
Dummy dummy = new Dummy("I will see this","I will not see this");
String json = gson.toJson(dummy);
它返回
{“ VisibleValue”：“我会看到的””}
#8楼
我用自定义注释解决了这个问题。 这是我的“ SkipSerialisation”注释类：
@Target (ElementType.FIELD)
public @interface SkipSerialisation {
}
这是我的GsonBuilder：
gsonBuilder.addSerializationExclusionStrategy(new ExclusionStrategy() {
@Override public boolean shouldSkipField (FieldAttributes f) {
return f.getAnnotation(SkipSerialisation.class) != null;
}
@Override public boolean shouldSkipClass (Class clazz) {
return false;
}
});
范例：
public class User implements Serializable {
public String firstName;
public String lastName;
@SkipSerialisation
public String email;
}
#9楼
我只是通过添加@Expose注释来工作，在这里使用的是我的版本
compile 'com.squareup.retrofit2:retrofit:2.0.2'
compile 'com.squareup.retrofit2:converter-gson:2.0.2'
在Model类中：
@Expose
int number;
public class AdapterRestApi {
在Adapter类中：
public EndPointsApi connectRestApi() {
OkHttpClient client = new OkHttpClient.Builder()
.connectTimeout(90000, TimeUnit.SECONDS)
.readTimeout(90000,TimeUnit.SECONDS).build();
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(ConstantRestApi.ROOT_URL)
.addConverterFactory(GsonConverterFactory.create())
.client(client)
.build();
return retrofit.create (EndPointsApi.class);
}
#10楼
因此，您要排除 firstName和country.name 。 这是您的ExclusionStrategy外观
public class TestExclStrat implements ExclusionStrategy {
public boolean shouldSkipClass(Class arg0) {
return false;
}
public boolean shouldSkipField(FieldAttributes f) {
return (f.getDeclaringClass() == Student.class && f.getName().equals("firstName"))||
(f.getDeclaringClass() == Country.class && f.getName().equals("name"));
}
}
如果您仔细查看，它将为Student.firstName和Country.name返回true ，这是您要排除的内容。
您需要像这样应用此ExclusionStrategy ，
Gson gson = new GsonBuilder()
.setExclusionStrategies(new TestExclStrat())
//.serializeNulls() <-- uncomment to serialize NULL fields as well
.create();
Student src = new Student();
String json = gson.toJson(src);
System.out.println(json);
返回：
{ "middleName": "J.", "initials": "P.F", "lastName": "Fry", "country": { "id": 91}}
我假设国家对象在学生课堂中用id = 91L初始化。
您可能会喜欢上。 例如，您不想序列化名称中包含“ name”字符串的任何字段。 做这个：
public boolean shouldSkipField(FieldAttributes f) {
return f.getName().toLowerCase().contains("name");
}
这将返回：
{ "initials": "P.F", "country": { "id": 91 }}
编辑：根据要求添加了更多信息。
此ExclusionStrategy可以完成此操作，但是您需要传递“完全合格的字段名称”。 见下文：
public class TestExclStrat implements ExclusionStrategy {
private Class c;
private String fieldName;
public TestExclStrat(String fqfn) throws SecurityException, NoSuchFieldException, ClassNotFoundException
{
this.c = Class.forName(fqfn.substring(0, fqfn.lastIndexOf(".")));
this.fieldName = fqfn.substring(fqfn.lastIndexOf(".")+1);
}
public boolean shouldSkipClass(Class arg0) {
return false;
}
public boolean shouldSkipField(FieldAttributes f) {
return (f.getDeclaringClass() == c && f.getName().equals(fieldName));
}
}
这就是我们如何通用地使用它。
Gson gson = new GsonBuilder()
.setExclusionStrategies(new TestExclStrat("in.naishe.test.Country.name"))
//.serializeNulls()
.create();
Student src = new Student();
String json = gson.toJson(src);
System.out.println(json);
它返回：
{ "firstName": "Philip" , "middleName": "J.", "initials": "P.F", "lastName": "Fry", "country": { "id": 91 }}
#11楼
我有Kotlin版本
@Retention(AnnotationRetention.RUNTIME)
@Target(AnnotationTarget.FIELD)
internal annotation class JsonSkip
class SkipFieldsStrategy : ExclusionStrategy {
override fun shouldSkipClass(clazz: Class<*>): Boolean {
return false
}
override fun shouldSkipField(f: FieldAttributes): Boolean {
return f.getAnnotation(JsonSkip::class.java) != null
}
}
以及如何将其添加到Retrofit GSONConverterFactory中：
val gson = GsonBuilder()
.setExclusionStrategies(SkipFieldsStrategy())
//.serializeNulls()
//.setDateFormat(DateFormat.LONG)
//.setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE)
//.setPrettyPrinting()
//.registerTypeAdapter(Id.class, IdTypeAdapter())
.create()
return GsonConverterFactory.create(gson)
#12楼
Kotlin的@Transient注释显然也可以解决问题。
data class Json(
@field:SerializedName("serialized_field_1") val field1: String,
@field:SerializedName("serialized_field_2") val field2: String,
@Transient val field3: String
)
输出：
{"serialized_field_1":"VALUE1","serialized_field_2":"VALUE2"}
#13楼
这就是我经常使用的：
Gson中实现的默认行为是忽略空对象字段。
意味着Gson对象不会将具有空值的字段序列化为JSON。 如果Java对象中的字段为null，则Gson会将其排除。
您可以使用此函数将某些对象转换为null或由您自己设置好的对象
/**
* convert object to json
*/
public String toJson(Object obj) {
// Convert emtpy string and objects to null so we don't serialze them
setEmtpyStringsAndObjectsToNull(obj);
return gson.toJson(obj);
}
/**
* Sets all empty strings and objects (all fields null) including sets to null.
*
* @param obj any object
*/
public void setEmtpyStringsAndObjectsToNull(Object obj) {
for (Field field : obj.getClass().getDeclaredFields()) {
field.setAccessible(true);
try {
Object fieldObj = field.get(obj);
if (fieldObj != null) {
Class fieldType = field.getType();
if (fieldType.isAssignableFrom(String.class)) {
if(fieldObj.equals("")) {
field.set(obj, null);
}
} else if (fieldType.isAssignableFrom(Set.class)) {
for (Object item : (Set) fieldObj) {
setEmtpyStringsAndObjectsToNull(item);
}
boolean setFielToNull = true;
for (Object item : (Set) field.get(obj)) {
if(item != null) {
setFielToNull = false;
break;
}
}
if(setFielToNull) {
setFieldToNull(obj, field);
}
} else if (!isPrimitiveOrWrapper(fieldType)) {
setEmtpyStringsAndObjectsToNull(fieldObj);
boolean setFielToNull = true;
for (Field f : fieldObj.getClass().getDeclaredFields()) {
f.setAccessible(true);
if(f.get(fieldObj) != null) {
setFielToNull = false;
break;
}
}
if(setFielToNull) {
setFieldToNull(obj, field);
}
}
}
} catch (IllegalAccessException e) {
System.err.println("Error while setting empty string or object to null: " + e.getMessage());
}
}
}
private void setFieldToNull(Object obj, Field field) throws IllegalAccessException {
if(!Modifier.isFinal(field.getModifiers())) {
field.set(obj, null);
}
}
private boolean isPrimitiveOrWrapper(Class fieldType) {
return fieldType.isPrimitive()
|| fieldType.isAssignableFrom(Integer.class)
|| fieldType.isAssignableFrom(Boolean.class)
|| fieldType.isAssignableFrom(Byte.class)
|| fieldType.isAssignableFrom(Character.class)
|| fieldType.isAssignableFrom(Float.class)
|| fieldType.isAssignableFrom(Long.class)
|| fieldType.isAssignableFrom(Double.class)
|| fieldType.isAssignableFrom(Short.class);
}
#14楼
一般来说，您不希望序列化的任何字段都应使用“ transient”修饰符，这也适用于json序列化器（至少它适用于我使用过的少数几个，包括gson）。
如果您不希望名称出现在序列化的json中，请给它一个瞬态关键字，例如：
private transient String name;
Gson文档中的更多详细信息
#15楼
Nishant提供了一个很好的解决方案，但是有一种更简单的方法。 只需使用@Expose批注标记所需的字段，例如：
@Expose private Long id;
保留所有您不想序列化的字段。 然后以这种方式创建您的Gson对象：
Gson gson = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create();