Gson Java如何处理循环引用

在Java中，使用Gson库处理循环引用时，可以通过自定义TypeAdapter来实现。下面是一个简单的示例，展示了如何使用Gson处理循环引用的情况：

首先，创建一个实体类，例如Person，它包含一个指向自身的引用：

public class Person {
    private String name;
    private Person friend;

    // 构造函数、getter和setter方法
}

然后，创建一个自定义的TypeAdapter<Person>来处理循环引用：

import com.google.gson.TypeAdapter;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;

public class PersonAdapter extends TypeAdapter<Person> {
    @Override
    public void write(JsonWriter out, Person value) throws IOException {
        if (value == null) {
            out.nullValue();
            return;
        }

        out.beginObject();
        out.name("name").value(value.getName());

        if (value.getFriend() != null) {
            out.name("friend").value(value.getFriend().getName());
        } else {
            out.name("friend").nullValue();
        }

        out.endObject();
    }

    @Override
    public Person read(JsonReader in) throws IOException {
        if (in.peek() == null) {
            in.nextNull();
            return null;
        }

        Person person = new Person();
        in.beginObject();
        while (in.hasNext()) {
            String name = in.nextName();
            switch (name) {
                case "name":
                    person.setName(in.nextString());
                    break;
                case "friend":
                    String friendName = in.nextString();
                    if (!friendName.isEmpty()) {
                        person.setFriend(new Person(friendName));
                    }
                    break;
                default:
                    in.skipValue();
                    break;
            }
        }
        in.endObject();
        return person;
    }
}

在这个示例中，我们自定义了write和read方法来处理循环引用。在write方法中，我们将friend对象转换为字符串（如果它不为空），以避免无限递归。在read方法中，我们检查friend字符串是否为空，如果不为空，则创建一个新的Person对象并将其设置为friend。

最后，将自定义的PersonAdapter注册到GsonBuilder中，并使用它来序列化和反序列化Person对象：

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class Main {
    public static void main(String[] args) {
        Gson gson = new GsonBuilder()
                .registerTypeAdapter(Person.class, new PersonAdapter())
                .create();

        Person person1 = new Person("Alice", null);
        Person person2 = new Person("Bob", person1);
        person1.setFriend(person2);

        String json = gson.toJson(person1);
        System.out.println(json); // 输出：{"name":"Alice","friend":{"name":"Bob"}}

        Person deserializedPerson1 = gson.fromJson(json, Person.class);
        System.out.println(deserializedPerson1.getName()); // 输出：Alice
        System.out.println(deserializedPerson1.getFriend().getName()); // 输出：Bob
    }
}

这样，我们就可以使用Gson处理循环引用的场景了。