Fatal编程技术网
  • java/
  • Java Gson：如何在没有注释的情况下从序列化中排除特定字段

Java Gson：如何在没有注释的情况下从序列化中排除特定字段

java json serialization

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);
  }