How to use

addSerializationExclusionStrategy

method

in

com.google.gson.GsonBuilder

public GsonUtil setSerializationExclusionStrategy(ExclusionStrategy excludeStratege) {
  _gsonBuilder.addSerializationExclusionStrategy(excludeStratege);
  return this;
}

private static Gson gson() {
  return new GsonBuilder()
      .addSerializationExclusionStrategy(ALLCLASSES_SKIPNONPUBLIC)
      .registerTypeAdapter(Table.class, TableSerializer.INSTANCE)
      .registerTypeAdapter(RectangularTextContainer.class, RectangularTextContainerSerializer.INSTANCE)
      .registerTypeAdapter(Cell.class, RectangularTextContainerSerializer.INSTANCE)
      .registerTypeAdapter(TextChunk.class, RectangularTextContainerSerializer.INSTANCE)
      .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();

  }
}

@Override
public <T> String serializeAllExceptFilter(Object src,
    Class<T> filterClass, String... filterAttr) throws Exception {
  return gson
      .addSerializationExclusionStrategy(
          exclude(filterClass, filterAttr)).create().toJson(src);
}
 

@Override
public <T> String serializeAllExceptFilter(Object src, Boolean notused,
    String... filterAttr) throws Exception {
  return gson
      .addSerializationExclusionStrategy(
          exclude(null, filterAttr)).create().toJson(src);
}
 

public GsonSerializerBuilder addSerializationExclusionStrategy(ExclusionStrategy strategy) {
  return new GsonSerializerBuilder(builder
      .addSerializationExclusionStrategy(strategy));
}

@Override
public <T> String serializeOnlyFilter(Object src, Boolean notused,
    String... filterAttr) throws Exception {
  return  gson
      .addSerializationExclusionStrategy(
          include(null,filterAttr)).create().toJson(src);
}

@Override
public <T> String serializeOnlyFilter(Object src, String... filterAttr)
    throws Exception {
  return  gson
      .addSerializationExclusionStrategy(
          include(null,filterAttr)).create().toJson(src);
}

@Override
public <T> String serializeOnlyFilter(Object src, Class<T> filterClass,
    String... filterAttr) throws Exception {
  return  gson
  .addSerializationExclusionStrategy(
      include(filterClass, filterAttr)).create().toJson(src);
}
 

@Override
public <T> String serializeAllExceptFilter(Object src, String... filterAttr)
    throws Exception {
  return gson
      .addSerializationExclusionStrategy(
          exclude(null, filterAttr)).create().toJson(src);
}

Gson getGson() {
  GsonBuilder gsonBuilder = new GsonBuilder();
  gsonBuilder.addSerializationExclusionStrategy(new ExclusionStrategy() {
    @Override
    public boolean shouldSkipField(FieldAttributes fa) {
      return (fa.hasModifier(Modifier.TRANSIENT) || fa.hasModifier(Modifier.VOLATILE));
    }
    @Override
    public boolean shouldSkipClass(Class<?> type) {
      return IGNORED_CLASSES.contains(type)
          || (type.getPackage() != null
          && IGNORED_PACKAGES.contains(type.getPackage().getName()));
    }
  });
  gsonBuilder.disableInnerClassSerialization();
  Gson gson = gsonBuilder.create();
  return gson;
}

public Gson create() {
  for (JsonSerializer<?> adapter : serializers) {
    builder.registerTypeHierarchyAdapter(getAdapterType(adapter), adapter);
  }
  for (ExclusionStrategy exclusion : exclusions) {
    builder.addSerializationExclusionStrategy(exclusion);
  }
  return builder.create();
}

private static Gson createGson() {
  return new GsonBuilder()
      .setPrettyPrinting()
      .registerTypeAdapter(DefinitionReference.class, new DefinitionReferenceJsonSerializer())
      .registerTypeAdapter(Optional.class, new OptionJsonSerializer())
      .addSerializationExclusionStrategy(new JsonExclusionStrategy())
      .create();
}

private static Gson createGson() {
  return new GsonBuilder()
      .setPrettyPrinting()
      .registerTypeAdapter(DefinitionReference.class, new DefinitionReferenceJsonSerializer())
      .registerTypeAdapter(Optional.class, new OptionJsonSerializer())
      .addSerializationExclusionStrategy(new JsonExclusionStrategy())
      .create();
}

public static GsonBuilder createDefaultGsonBuilder(EnumSet<JsonOptions> options) {
  GsonBuilder bldr = new GsonBuilder();
  registerCommonGsonTypeAdapters(bldr);
  if (!options.contains(JsonOptions.COMPACT)) {
    bldr.setPrettyPrinting();
  }
  bldr.disableHtmlEscaping();
  if (options.contains(JsonOptions.EXCLUDE_SENSITIVE)) {
    bldr.addSerializationExclusionStrategy(new SensitiveAnnotationExclusionStrategy());
  }
  if (options.contains(JsonOptions.EXCLUDE_BUILTIN)) {
    bldr.addSerializationExclusionStrategy(new BuiltInServiceDocumentFieldsExclusionStrategy());
  }
  return bldr;
}

public JsonConverter() {
  GsonBuilder builder = new GsonBuilder();
  builder.addSerializationExclusionStrategy(new ExclusionStrategy() {
    @Override
    public boolean shouldSkipField(FieldAttributes f) {
      return f.getAnnotations().contains(Transient.class) || f.hasModifier(Modifier.TRANSIENT);
    }
    @Override
    public boolean shouldSkipClass(Class<?> clazz) {
      return false;
    }
  });
  builder.addSerializationExclusionStrategy(new AnnotationExclusionStrategy());
  builder.serializeNulls();
  builder.setPrettyPrinting();
  builder.registerTypeAdapter(ParameterValue.class, new InheritanceAdapter());
  builder.registerTypeAdapter(DashboardLayout.class, new InheritanceAdapter());
  gson = builder.create();
}

public static Gson createGson(Policy policy) {
  Gson gson = cache.get(policy);
  if (gson != null) {
    return gson;
  }
  gson = createGsonBuilder()
      .addDeserializationExclusionStrategy(new AnnotatedStrategy(policy))
      .addSerializationExclusionStrategy(new AnnotatedStrategy(policy))
      .create();
  cache.put(policy, gson);
  return gson;
}

public GsonSerializerBuilder excludeFieldsNamed(String... fieldNames) {
  return new GsonSerializerBuilder(builder
      .addSerializationExclusionStrategy(new FieldNameExclusionStrategy(fieldNames)));
}

@Override
public Gson create() {
  for (JsonSerializer<?> adapter : jsonSerializers) {
    registerAdapter(getAdapterType(adapter), adapter);
  }
  for (JsonDeserializer<?> adapter : jsonDeserializers) {
    registerAdapter(getAdapterType(adapter), adapter);
  }
  
  for (ExclusionStrategy exclusion : exclusions) {
    getGsonBuilder().addSerializationExclusionStrategy(exclusion);
  }
  
  return getGsonBuilder().create();
}

  public static void main(String[] args) throws IOException {
    // JSON converter
    Gson jsonConverter = new GsonBuilder()
        .addSerializationExclusionStrategy(new ZemberekExclusionStrategy())
        .disableInnerClassSerialization()
        .create();
    // Turkish default morphology
    TurkishMorphology morphology = TurkishMorphology.createWithDefaults();

    new FindPOSController(jsonConverter, morphology);
    new SentenceBoundaryDetectionController(jsonConverter);
    new TurkishTokenizationController(jsonConverter);
    new SpellingController(jsonConverter, morphology);
    new StemmingAndLemmatizationController(jsonConverter, morphology);
    new AnalyzeWordController(jsonConverter, morphology);
    new AnalyzeSentenceController(jsonConverter, morphology);
    new GenerateWordsController(jsonConverter);
  }
}