Java Gson:如何在没有注释的情况下从序列化中排除特定字段
我正在努力学习格森,我正在与场外排斥作斗争。这是我的课Java Gson:如何在没有注释的情况下从序列化中排除特定字段,java,json,serialization,gson,Java,Json,Serialization,Gson,我正在努力学习格森,我正在与场外排斥作斗争。这是我的课 public class Student { private Long id; private String firstName = "Philip"; private String middleName = "J."; private String initials
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
,但我似乎无法排除某些字段的属性,如country.name
使用方法public boolean shouldSkipField(FieldAttributes fa)
,FieldAttributes不包含足够的信息,无法将字段与类似country.name的筛选器匹配
注:我想避免注释,因为我想改进这一点,并使用正则表达式过滤掉字段
编辑:我试图看看是否有可能模仿
使用Gson
<interceptor-ref name="json">
<param name="enableSMD">true</param>
<param name="excludeProperties">
login.password,
studentList.*\.sin
</param>
</interceptor-ref>
真的
login.password,
学生名单。*\.sin
编辑:
我重新提出问题,补充了以下内容:
为了进一步澄清这个问题,我添加了第二个相同类型的字段。基本上我想排除country.name,但不排除countrOfBirth.name。我也不想把国家排除在外。
因此,类型是相同的,这是我要确定并排除的对象图中的实际位置。因此,您要排除firstName
和country.name
。以下是您的排除策略
应该是什么样子
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"));
}
}
这将返回:
{ "middleName": "J.", "initials": "P.F", "lastName": "Fry", "country": { "id": 91}}
我假设country对象在student类中初始化为id=91L
你会喜欢的。例如,您不希望序列化名称中包含“name”字符串的任何字段。这样做:
public boolean shouldSkipField(FieldAttributes f) {
return f.getName().toLowerCase().contains("name");
}
这将返回:
{ "initials": "P.F", "country": { "id": 91 }}
编辑:根据要求添加更多信息
这个excludestrategy
就可以了,但是您需要传递“完全限定字段名”。见下文:
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));
}
}
它返回:
{ "firstName": "Philip" , "middleName": "J.", "initials": "P.F", "lastName": "Fry", "country": { "id": 91 }}
一般来说,任何不希望序列化的字段都应该使用“transient”修饰符,这也适用于json序列化程序(至少我使用过的一些字段,包括gson)
如果您不希望名称显示在序列化的json中,请给它一个transient关键字,例如:
private transient String name;
Nishant提供了一个很好的解决方案,但有一个更简单的方法。只需使用@Expose注释标记所需的字段,例如:
@Expose private Long id;
省略任何不希望序列化的字段。然后按以下方式创建Gson对象:
Gson gson = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create();
我提出了一个类工厂来支持这个功能。传入要排除的字段或类的任意组合
public class GsonFactory {
public static Gson build(final List<String> fieldExclusions, final List<Class<?>> 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();
}
}
公共类GsonFactory{
公共静态Gson构建(最终列表字段排除,最终列表或可以说哪些字段不会公开:
Gson gson = gsonBuilder.excludeFieldsWithModifiers(Modifier.TRANSIENT).create();
在属性上的类上:
private **transient** boolean nameAttribute;
我遇到了这个问题,在这个问题上,我只想从序列化中排除少量字段,因此我开发了一个相当简单的解决方案,使用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();
newgsonbuilder()
.AddSerializationExclutionStrategy(新的ExclutionStrategy)(){
@凌驾
公共布尔值shouldSkipField(FieldAttributes FieldAttributes){
最终Expose=fieldAttributes.getAnnotation(Expose.class);
返回expose!=null&!expose.serialize();
}
@凌驾
公共布尔值shouldSkipClass(类aClass){
返回false;
}
})
.AddDeserializationExclutionStrategy(新的ExclutionStrategy()){
@凌驾
公共布尔值shouldSkipField(FieldAttributes FieldAttributes){
最终Expose=fieldAttributes.getAnnotation(Expose.class);
返回expose!=null&!expose.deserialize();
}
@凌驾
公共布尔值shouldSkipClass(类aClass){
返回false;
}
})
.create();
现在,我可以轻松排除带有@Expose(serialize=false)
或@Expose(deserialize=false)
注释的几个字段(请注意,这两个@Expose
属性的默认值都是true
)。当然,您可以使用@Expose(serialize=false,deserialize=false)
,但更简洁的方法是声明字段transient
(这仍然对这些自定义排除策略有效)。您可以使用gson浏览json树
试着这样做:
gson.toJsonTree(student).getAsJsonObject()
.get("country").getAsJsonObject().remove("name");
您还可以添加一些属性:
gson.toJsonTree(student).getAsJsonObject().addProperty("isGoodStudent", false);
使用gson 2.2.4进行测试。在阅读了所有可用答案后,我发现,在我的情况下,最灵活的方法是使用自定义@Exclude
注释。因此,我为此实现了简单的策略(我不想使用@Expose
标记所有字段,也不想使用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;
}
}
另一种方法(如果您需要在运行时决定排除字段,则特别有用)是向gson实例注册TypeAdapter。示例如下:
Gson gson = new GsonBuilder()
.registerTypeAdapter(BloodPressurePost.class, new BloodPressurePostSerializer())
在下面的例子中,服务器期望两个值中的一个,但由于它们都是int,因此gson将序列化它们
@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();
Gson gson = new GsonBuilder()
.registerTypeAdapter(BloodPressurePost.class, new BloodPressurePostSerializer())
public class BloodPressurePostSerializer implements JsonSerializer<BloodPressurePost> {
@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;
}
}
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);
@Target (ElementType.FIELD)
public @interface SkipSerialisation {
}
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;
}
compile 'com.squareup.retrofit2:retrofit:2.0.2'
compile 'com.squareup.retrofit2:converter-gson:2.0.2'
@Expose
int number;
public class AdapterRestApi {
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);
}
@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
}
}
val gson = GsonBuilder()
.setExclusionStrategies(SkipFieldsStrategy())
//.serializeNulls()
//.setDateFormat(DateFormat.LONG)
//.setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE)
//.setPrettyPrinting()
//.registerTypeAdapter(Id.class, IdTypeAdapter())
.create()
return GsonConverterFactory.create(gson)
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"}
/**
* 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);
}