static class TypeAdapterForSomeObject extends TypeAdapter<SomeObject> {

    @Override
    public void write(JsonWriter out, SomeObject value) throws IOException {
        boolean oldSerializeNulls = out.getSerializeNulls();
        try {
            out.setSerializeNulls(true);
            // serialization impl...
        } finally {
            out.setSerializeNulls(oldSerializeNulls);
        }
    }

    // ...

}

public class Tests {

     // define value requiring explicit nulls
    static class Inner {
        String prop;
        Inner(String prop) {
            this.prop = prop;
        }
    }

    // define adapter to switch on explicit null
    static class TypeAdapterForInner extends TypeAdapter<Inner> {

        @Override
        public void write(JsonWriter out, Inner value) throws IOException {
            boolean oldSerializeNulls = out.getSerializeNulls();
            try {
                out.setSerializeNulls(true);
                out.beginObject().name("prop").value(value.prop).endObject();
            } finally {
                out.setSerializeNulls(oldSerializeNulls);
            }
        }

        @Override
        public Inner read(JsonReader in) throws IOException {
            in.beginObject();
            in.nextName();
            String value = null;
            if (in.peek() == JsonToken.STRING) {
                value = in.nextString();
            } else {
                in.nextNull();
            }
            in.endObject();
            return new Inner(value);
        }

    }

    // define wrapper type hierarchy for use  by RuntimeTypeAdapterFactory
    static abstract class Outer {
        Inner wrapped;
        Outer(Inner wrapped) {
            this.wrapped = wrapped;
        }
    }

    static class OuterA extends Outer {
        OuterA(Inner wrapped) {
            super(wrapped);
        }
    }

    static class OuterB extends Outer {
        OuterB(Inner wrapped) {
            super(wrapped);
        }
    }

    @Test
    public void testSerializingToPreserveNullsInEmbeddedObjects() {
        TypeAdapterFactory metaWrapperAdapter = RuntimeTypeAdapterFactory.of(Outer.class, "kind")
                .registerSubtype(OuterA.class, "a")
                .registerSubtype(OuterB.class, "b");

        Gson gson = new GsonBuilder()
                .registerTypeAdapterFactory(metaWrapperAdapter)
                .registerTypeAdapter(Inner.class, new TypeAdapterForInner().nullSafe())
                .create();

        // verify, null serialization works for unwrapped, inner value
        Inner inner = new Inner(null);        
        assertJsonEquivalent(
                "{ prop: null }",
                gson.toJson(inner));

        OuterB outer = new OuterB(inner); 
        // will fail; actual = "{ type: 'b', wrapped: {} }"
        assertJsonEquivalent(
                "{ type: 'b', wrapped: { prop: null } }",
                gson.toJson(outer, Outer.class));
    }

    private static void assertJsonEquivalent(String expected, String actual) {
        JsonElement expectedElem = new JsonParser().parse(expected);
        JsonElement actualElem = new JsonParser().parse(actual);
        assertEquals(expectedElem, actualElem);
    }

}