Android Gson堆栈溢出错误

每当我尝试将

JSON字符串

序列化到有两个

构造函数的
POJO对象
时，就会出现
堆栈溢出
错误

public class ObjectClass extends BaseObservable implements Serializable {

    @Inject Realm realm;
    private String TAG = "ObjectClass";

    private String name;
    private String address;

    public ObjectClass() {
    }

    public ObjectClass(Context context) {
        ((MainApplication) context.getApplicationContext()).getMainAppComponent().inject(this);
    }

    public String getName() {
        return name;
    }

    public void setname(String name) {
        this.name = name;
    }

    @Bindable
    public String getAddress() {
        return address;
    }

    public void setaddress(String address) {
        this.address = address;
        Realmaddress result = realm.where(Realmaddress.class).equalTo("id", address).findFirst();
        if (result != null)
            Log.e(TAG, result.toString());
    }
}

我应该删除这个构造函数吗

public ObjectClass(Context context) {
    ((MainApplication) context.getApplicationContext()).getMainAppComponent().inject(this);
}

一切正常。但是，如果我离开它，我会遇到堆栈溢出错误

String testJson = "{\n" +
                "\t\"name\" : \"Test Name\",\n" +
                "\t\"address\" : \"Test Address\"\n" +
                "}"

Gson gson = new GsonBuilder().setDateFormat("yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'SSS'Z'").setPrettyPrinting().create();
    ObjectClass objectClass = gson.fromJson(testJson, ObjectClass.class);

一切都挂起，过了一会儿，我得到了一个
StackOverflow
错误

编辑1

所以，经过深入调试。我注意到建造师不是问题所在。这是
@injectrealm@Expose（反序列化=false，序列化=false）
@注入领域这并不能解决问题

编辑2

我将我的
GSON排除策略
编辑成这样。但是，即使它进入if块并记录它的存在，它也不会修复它

public class CustomGsonParser {

    public static Gson returnCustomParser(){
        return new GsonBuilder()
                .setExclusionStrategies(new ExclusionStrategy() {
                    @Override
                    public boolean shouldSkipField(FieldAttributes f) {
                        if (f.getAnnotation(Inject.class) != null ||
                                f.getDeclaringClass().equals(RealmObject.class) ||
                                f.getDeclaringClass().equals(Realm.class)) {
                            Log.e("GSONBuild", "Exists Inject");
                            return true;
                        }
                        return false;
                    }

                    @Override
                    public boolean shouldSkipClass(Class<?> clazz) {
                        if (clazz.equals(Inject.class))
                            return true;
                        return false;
                    }
                })
                .create();
    }
}

public类CustomGsonParser{
公共静态Gson returnCustomParser（）{
返回新的GsonBuilder（）
.SetExclutionStrategy（新的ExclutionStrategy）（）{
@凌驾
公共布尔值shouldSkipField（字段属性f）{
如果（f.getAnnotation（Inject.class）！=null||
f、 getDeclaringClass（）.equals（RealmObject.class）||
f、 getDeclaringClass（）.equals（Realm.class））{
Log.e（“GSONBuild”、“存在注入”）；
返回true；
}
返回false；
}
@凌驾
公共布尔shouldSkipClass（类clazz）{
if（clazz.equals（Inject.class））
返回true；
返回false；
}
})
.create（）；
}
}
当您使用
依赖项注入时
下面的行中有一些东西没有正确地
序列化
，它正在无限
序列化
，因此当您的内存在某个时间间隔内耗尽时，会出现
堆栈溢出
错误

((MainApplication) context.getApplicationContext()).getMainAppComponent().inject(this);

如果上面的句子在您的代码中不可用，请将其删除，或者以其他方式执行。
当您使用依赖项注入时，
下面的行中有一些东西没有正确地进行
序列化，它进入无限
序列化
，因此您得到
堆栈溢出
错误当你的记忆在某段时间内耗尽时

((MainApplication) context.getApplicationContext()).getMainAppComponent().inject(this);

如果上面的句子在您的代码中不可用，请删除它，或者以其他方式执行。
因此，我注意到
领域
实际上是主要原因。我还是不知道为什么。因此，我所做的是传递上下文，不再
依赖注入
模型。我使用上下文创建一个
领域
实例。因此，我的
对象类现在看起来像这样

public class ObjectClass extends BaseObservable implements Serializable {

    private String TAG = "ObjectClass";

    private String name;
    private String address;
    @Expose(deserialize = false, serialize = false)
    private Context context;

    public ObjectClass() {
    }

    public ObjectClass(Context context) {
        this.context = context;
    }

    public String getName() {
        return name;
    }

    public void setname(String name) {
        this.name = name;
    }

    @Bindable
    public String getAddress() {
        return address;
    }

    public void setaddress(String address) {
        this.address = address;
        Realmaddress result = RealmUtils.getInstance(context).where(Realmaddress.class).equalTo("id", address).findFirst();
        if (result != null)
            Log.e(TAG, result.toString());
    }
}

所以，我注意到，
Realm
实际上是主要原因。我还是不知道为什么。因此，我所做的是传递上下文，不再
依赖注入
模型。我使用上下文创建一个
领域
实例。因此，我的
对象类现在看起来像这样

public class ObjectClass extends BaseObservable implements Serializable {

    private String TAG = "ObjectClass";

    private String name;
    private String address;
    @Expose(deserialize = false, serialize = false)
    private Context context;

    public ObjectClass() {
    }

    public ObjectClass(Context context) {
        this.context = context;
    }

    public String getName() {
        return name;
    }

    public void setname(String name) {
        this.name = name;
    }

    @Bindable
    public String getAddress() {
        return address;
    }

    public void setaddress(String address) {
        this.address = address;
        Realmaddress result = RealmUtils.getInstance(context).where(Realmaddress.class).equalTo("id", address).findFirst();
        if (result != null)
            Log.e(TAG, result.toString());
    }
}

嗯，它正在被使用。你是什么意思？我需要
领域
，因为对象正被
databinder
使用。我能让Gson忽略这个而不去关心它吗？@iTookajanleko从另一个意义上说，在这种情况下，你可以使用接口来传递/发送你的数据。你是什么意思？我需要
领域
，因为对象正被
databinder
使用。我能让
Gson
忽略这一点而不去关心它吗？@itookajanleko从另一个角度讲，在这种情况下，您可以使用接口传递/发送数据