[java] gson을 사용한 다형성

업데이트 된 답변-다른 모든 답변의 가장 좋은 부분

다양한 사용 사례에 대한 솔루션을 설명하고 있으며 무한 재귀 문제도 해결할 것입니다.

• 사례 1 : 당신은 클래스의 컨트롤에 자신 쓸 수, 즉 Cat, Dog클래스뿐 아니라 IAnimal인터페이스를. @ marcus-junius-brutus (최고 평점 답변)에서 제공하는 솔루션을 따르기 만하면됩니다.

  다음과 같은 공통 기본 인터페이스가 있으면 무한 재귀가 없습니다. IAnimal

  그러나 IAnimal이러한 인터페이스 를 구현하지 않으려면 어떻게해야 합니까?

  그런 다음 @ marcus-junius-brutus (최고 평점 답변)는 무한 재귀 오류를 생성합니다. 이 경우 아래와 같이 할 수 있습니다.

  다음과 같이 기본 클래스와 래퍼 하위 클래스 내에 복사 생성자 를 만들어야 합니다.

.

// Base class(modified)
public class Cat implements IAnimal {

    public String name;

    public Cat(String name) {
        super();
        this.name = name;
    }
    // COPY CONSTRUCTOR
    public Cat(Cat cat) {
        this.name = cat.name;
    }

    @Override
    public String sound() {
        return name + " : \"meaow\"";
    };
}



    // The wrapper subclass for serialization
public class CatWrapper extends Cat{


    public CatWrapper(String name) {
        super(name);
    }

    public CatWrapper(Cat cat) {
        super(cat);
    }
}

그리고 유형에 대한 직렬 변환기 Cat:

public class CatSerializer implements JsonSerializer<Cat> {

    @Override
    public JsonElement serialize(Cat src, Type typeOfSrc, JsonSerializationContext context) {

        // Essentially the same as the type Cat
        JsonElement catWrapped = context.serialize(new CatWrapper(src));

        // Here, we can customize the generated JSON from the wrapper as we want.
        // We can add a field, remove a field, etc.


        return modifyJSON(catWrapped);
    }

    private JsonElement modifyJSON(JsonElement base){
        // TODO: Modify something
        return base;
    }
}

그렇다면 왜 복사 생성자일까요?

글쎄, 일단 복사 생성자를 정의하면 기본 클래스가 아무리 변경 되더라도 래퍼는 동일한 역할을 계속합니다. 둘째, 복사 생성자를 정의하지 않고 단순히 기본 클래스를 하위 클래스로 지정하면 확장 된 클래스, 즉 CatWrapper. 구성 요소가 래퍼 유형이 아닌 기본 클래스 측면에서 대화 할 가능성이 높습니다.

쉬운 대안이 있습니까?

물론, 이제 Google에서 도입했습니다. 다음은 RuntimeTypeAdapterFactory구현입니다.

RuntimeTypeAdapterFactory<Animal> runtimeTypeAdapterFactory = RuntimeTypeAdapterFactory
.of(Animal.class, "type")
.registerSubtype(Dog.class, "dog")
.registerSubtype(Cat.class, "cat");

Gson gson = new GsonBuilder()
    .registerTypeAdapterFactory(runtimeTypeAdapterFactory)
    .create();

여기에서 “type”이라는 필드를 도입 Animal하고 동일한 내부 값을 Dog“dog”, Cat“cat”으로 설정해야합니다.

완전한 예 : https://static.javadoc.io/org.danilopianini/gson-extras/0.2.1/com/google/gson/typeadapters/RuntimeTypeAdapterFactory.html

• 사례 2 : 당신이 수업을 통제하고 있지 않습니다 . 회사에 가입하거나 클래스가 이미 정의 된 라이브러리를 사용하고 관리자가 어떤 식 으로든 변경하는 것을 원하지 않습니다. 클래스를 하위 클래스로 분류하고 공통 마커 인터페이스를 구현하도록 할 수 있습니다 (메소드가 없습니다). ) 같은 AnimalInterface.

  전의:

.

// The class we are NOT allowed to modify

public class Dog implements IAnimal {

    public String name;
    public int ferocity;

    public Dog(String name, int ferocity) {
        super();
        this.name = name;
        this.ferocity = ferocity;
    }

    @Override
    public String sound() {
        return name + " : \"bark\" (ferocity level:" + ferocity + ")";
    }
}


// The marker interface

public interface AnimalInterface {
}

// The subclass for serialization

public class DogWrapper  extends Dog implements AnimalInterface{

    public DogWrapper(String name, int ferocity) {
        super(name, ferocity);
    }

}

// The subclass for serialization

public class CatWrapper extends Cat implements AnimalInterface{


    public CatWrapper(String name) {
        super(name);
    }
}

그래서, 우리는 사용하는 것 CatWrapper대신 Cat, DogWrapper대신 Dog과
AlternativeAnimalAdapter대신IAnimalAdapter

// The only difference between `IAnimalAdapter` and `AlternativeAnimalAdapter` is that of the interface, i.e, `AnimalInterface` instead of `IAnimal`

public class AlternativeAnimalAdapter implements JsonSerializer<AnimalInterface>, JsonDeserializer<AnimalInterface> {

    private static final String CLASSNAME = "CLASSNAME";
    private static final String INSTANCE  = "INSTANCE";

    @Override
    public JsonElement serialize(AnimalInterface src, Type typeOfSrc,
                                 JsonSerializationContext context) {

        JsonObject retValue = new JsonObject();
        String className = src.getClass().getName();
        retValue.addProperty(CLASSNAME, className);
        JsonElement elem = context.serialize(src);
        retValue.add(INSTANCE, elem);
        return retValue;
    }

    @Override
    public AnimalInterface deserialize(JsonElement json, Type typeOfT,
            JsonDeserializationContext context) throws JsonParseException  {
        JsonObject jsonObject = json.getAsJsonObject();
        JsonPrimitive prim = (JsonPrimitive) jsonObject.get(CLASSNAME);
        String className = prim.getAsString();

        Class<?> klass = null;
        try {
            klass = Class.forName(className);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            throw new JsonParseException(e.getMessage());
        }
        return context.deserialize(jsonObject.get(INSTANCE), klass);
    }
}

테스트를 수행합니다.

public class Test {

    public static void main(String[] args) {

        // Note that we are using the extended classes instead of the base ones
        IAnimal animals[] = new IAnimal[]{new CatWrapper("Kitty"), new DogWrapper("Brutus", 5)};
        Gson gsonExt = null;
        {
            GsonBuilder builder = new GsonBuilder();
            builder.registerTypeAdapter(AnimalInterface.class, new AlternativeAnimalAdapter());
            gsonExt = builder.create();
        }
        for (IAnimal animal : animals) {
            String animalJson = gsonExt.toJson(animal, AnimalInterface.class);
            System.out.println("serialized with the custom serializer:" + animalJson);
            AnimalInterface animal2 = gsonExt.fromJson(animalJson, AnimalInterface.class);
        }
    }
}

산출:

serialized with the custom serializer:{"CLASSNAME":"com.examples_so.CatWrapper","INSTANCE":{"name":"Kitty"}}
serialized with the custom serializer:{"CLASSNAME":"com.examples_so.DogWrapper","INSTANCE":{"name":"Brutus","ferocity":5}}

---