Gson 仅当不是 null 或不为空时序列化字段

Question

I have requirement where I need to convert java object to json.

I am using Gson for that but i need the converter to only serialize the non null or not empty values.

For example:

//my java object looks like
class TestObject{
    String test1;
    String test2;
    OtherObject otherObject = new OtherObject();
}

now my Gson instance to convert this object to json looks like

Gson gson = new Gson();
TestObject obj = new TestObject();
obj.test1 = "test1";
obj.test2 = "";

String jsonStr = gson.toJson(obj);
println jsonStr;

In the above print, the result is

{"test1":"test1", "test2":"", "otherObject":{}}

Here i just wanted the result to be

{"test1":"test1"}

Since the test2 is empty and otherObject is empty, i don't want them to be serialized to json data.

Btw, I am using Groovy/Grails so if there is any plugin for this that would be good, if not any suggestion to customize the gson serialization class would be good.

Answer 1

Create your own TypeAdapter

public class MyTypeAdapter extends TypeAdapter<TestObject>() {

    @Override
    public void write(JsonWriter out, TestObject value) throws IOException {
        out.beginObject();
        if (!Strings.isNullOrEmpty(value.test1)) {
            out.name("test1");
            out.value(value.test1);
        }

        if (!Strings.isNullOrEmpty(value.test2)) {
            out.name("test2");
            out.value(value.test1);
        }
        /* similar check for otherObject */         
        out.endObject();    
    }

    @Override
    public TestObject read(JsonReader in) throws IOException {
        // do something similar, but the other way around
    }
}

You can then register it with Gson .

Gson gson = new GsonBuilder().registerTypeAdapter(TestObject.class, new MyTypeAdapter()).create();
TestObject obj = new TestObject();
obj.test1 = "test1";
obj.test2 = "";
System.out.println(gson.toJson(obj));

produces

 {"test1":"test1"}

The GsonBuilder class has a bunch of methods to create your own serialization/deserialization strategies, register type adapters, and set other parameters.

Strings is a Guava class. You can do your own check if you don't want that dependency.

Answer 2

What I personally don't like in TypeAdapter using answer is the fact you need to describe every field of your entire class which could have lets say 50 fields (which means 50 if blocks in TypeAdapter ).
My solution is based on Reflection and a fact Gson will not serialize null values fields by default.
I have a special class which holds data for API to create document called DocumentModel, which has about 50 fields and I don't like to send String fields with "" (empty but not null) values or empty arrays to server. So I created a special method which returns me a copy of my object with all empty fields nulled. Note - by default all arrays in my DocumentModel instance are initialized as empty (zero length) arrays and thus they are never null, you should probably check your arrays for null before checking their length.

public DocumentModel getSerializableCopy() {
    Field fields[] = new Field[]{};
    try {
        // returns the array of Field objects representing the public fields
        fields = DocumentModel.class.getDeclaredFields();
    } catch (Exception e) {
        e.printStackTrace();
    }
    DocumentModel copy = new DocumentModel();
    Object value;
    for (Field field : fields) {
        try {
            value = field.get(this);
            if (value instanceof String && TextUtils.isEmpty((String) value)) {
                field.set(copy, null);
            // note: here array is not being checked for null!
            else if (value instanceof Object[] && ((Object[]) value).length == 0) {
                field.set(copy, null);
            } else
                field.set(copy, value);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
    return copy;
}

Using this method I don't care if some fields was added or removed after this method was written or whatever. The only problem left - is checking custom type fields, which are not String or array, but this depends to particular class and should be extra coded in if/else blocks.

Answer 3

It seems to me the problem is not with gson. Gson correctly keeps track of the difference between null and an empty string. Are you sure you want to erase that distinction? Are you sure all classes that use TestObject don't care?

What you could do if you don't care about the difference is to change the empty strings to null within a TestObject before serializing it. Or better, make the setters in TestObject such that an empty string is set to null; that way you define rigidly within the class that an empty string is the same as null. You'll have to make sure the values cannot be set outside the setters.

Answer 4

I have ran into the same problem and found 2 distinct solutions

---

1. Write a custom TypeAdapter for each field class

TypeAdapter example for String class:

@SuppressWarnings("rawtypes")
public class JSONStringAdapter extends TypeAdapter {

    @Override
    public String read(JsonReader jsonReader) throws IOException {
            
        String value = jsonReader.nextString();
        if(value == null || value.trim().length() == 0) {
            return null;
        } else {
            return value;
        }
    }

    @Override
    public void write(JsonWriter jsonWriter, Object object) throws IOException {
    
        String value = String.valueOf(object);
        if(value == null || value.trim().length() == 0) {    
            jsonWriter.nullValue();
        } else {
            jsonWriter.value(value);
       }
    }
}

Use:

public class Doggo {

    @JsonAdapter(JSONStringAdapter.class)
    private String name;

    public Doggo(String name) {
        this.name = name;
    }
}

public class Main {

    public static void main(String[] args) {
        Doggo aDoggo = new Doggo("");
        String jsonString = new Gson().toJson(aDoggo);
    }
}    

---

2. Process the object manually before generating the JSON string

Seems to work on anything, haven't tested the performance:

public static boolean removeEmpty(JSONObject source) {
    
    if (null == source || source.length() == 0) {
        return true;
    }
    
    boolean isJsonObjectEmpty = false; 

    for (String key : JSONObject.getNames(source)) {
        Object value = source.get(key);
        
        boolean isValueEmpty = isValueEmpty(value);
        if(isValueEmpty) {
            source.remove(key);
        }
    }
    
    if(source.length() == 0) {
        isJsonObjectEmpty = true;
    }
    
    return isJsonObjectEmpty;
}

private static boolean isValueEmpty(Object value) {

    if (null == value) {
        return true;
    }
    
    if (value instanceof JSONArray) {
        
        JSONArray arr =  (JSONArray) value;
        if(arr.length() > 0) {
            
            List<Integer> indextesToRemove = new ArrayList<>();
            for(int i = 0; i< arr.length(); i++) {
                
                boolean isValueEmpty = isValueEmpty(arr.get(i));
                if(isValueEmpty) {
                    indextesToRemove.add(i);
                };
            }
            
            for(Integer index : indextesToRemove) {
                arr.remove(index);
            }
            
            if(arr.length() == 0) {
                return true;
            }
            
        } else {
            return true;
        }
        
    } else if (value instanceof JSONObject) {
    
        return removeEmpty((JSONObject) value);
         
    } else {
        
        if (JSONObject.NULL.equals(value) 
            || null == value 
            || value.toString().trim().length() == 0)
        ) {
            return true;
        }
    }
    
    return false;
}

Use:

public class Doggo {

    private String name;

    public Doggo(String name) {
        this.name = name;
    }
}


public class Main {

    public static void main(String[] args) {
        Doggo aDoggo = new Doggo("");
        
        // if you are not using Type Adapters for your fields
        JSONObject aJSONObject1 = new JSONObject(aDoggo);
        removeEmpty(aJSONObject1);
        String jsonString1 = aJSONObject1.toString();

        // if you are using Type Adapters for your fields
        Gson gsonParser = new Gson();
        JSONObject aJSONObject2 = new JSONObject(gsonParser .toJson(aDoggo));
        removeEmpty(aJSONObject2);
        String jsonString2 = aJSONObject2.toString();
    }
}