类A声明多个JSON字段

我有一个类A，其中包含一些私有字段，而同一类扩展了另一个类B，它也具有一些在A类中的私有字段。

public class A extends B {
    private BigDecimal netAmountTcy;
    private BigDecimal netAmountPcy;   
    private BigDecimal priceTo;  
    private String segment;

    private BigDecimal taxAmountTcy;
    private BigDecimal taxAmountPcy;   
    private BigDecimal tradeFeesTcy;
    private BigDecimal tradeFeesPcy;

// getter and setter for the above fields

}

B班有一些私人班级成员

现在，当我尝试从上述类A创建JSON字符串时，出现以下异常：

class com.hexgen.ro.request.A declares multiple JSON fields named netAmountPcy

如何解决这个问题？

由于它们是私有字段，所以我猜创建json字符串时应该不会有任何问题，但我不确定。

我创建如下的json字符串：

Gson gson = new Gson();
 tempJSON = gson.toJson(obj);

这里obj是A类的对象

由于它们是私有字段，因此在创建json字符串时应该没有任何问题

我认为这句话是不对的，GSON在序列化时会查找对象的私有字段，这意味着包括了超类的所有私有字段，而当您使用相同名称的字段时，它将引发错误。

如果您不想包含任何特定字段，则必须用transient关键字标记它，例如：

private transient BigDecimal tradeFeesPcy;

这有点晚了，但我也遇到了同样的问题。唯一的事情是我不能修改超类，因为那不是我的代码。我解决此问题的方法是创建一个排除策略，该策略将跳过任何在超类中具有相同名称的字段的字段。这是我该课程的代码：

public class SuperclassExclusionStrategy implements ExclusionStrategy
{
    public boolean shouldSkipClass(Class<?> arg0)
    {
        return false;
    }

    public boolean shouldSkipField(FieldAttributes fieldAttributes)
    {
        String fieldName = fieldAttributes.getName();
        Class<?> theClass = fieldAttributes.getDeclaringClass();

        return isFieldInSuperclass(theClass, fieldName);            
    }

    private boolean isFieldInSuperclass(Class<?> subclass, String fieldName)
    {
        Class<?> superclass = subclass.getSuperclass();
        Field field;

        while(superclass != null)
        {   
            field = getField(superclass, fieldName);

            if(field != null)
                return true;

            superclass = superclass.getSuperclass();
        }

        return false;
    }

    private Field getField(Class<?> theClass, String fieldName)
    {
        try
        {
            return theClass.getDeclaredField(fieldName);
        }
        catch(Exception e)
        {
            return null;
        }
    }
}

然后，我在构建器中设置“序列化和反序列化”排除策略，如下所示：

    builder.addDeserializationExclusionStrategy(new SuperclassExclusionStrategy());
    builder.addSerializationExclusionStrategy(new SuperclassExclusionStrategy());

希望这可以帮助某人！

如果您具有不同的字段，但它们具有相同的，也会发生相同的错误消息@SerializedName。

@SerializedName("date_created")
private Date DateCreated;
@SerializedName("date_created")
private Integer matchTime;

复制/粘贴您可以简单地犯这样的错误。因此，请调查该类及其祖先，并进行检查。

在proguard.config的底部添加以下行 （如果您在项目中使用proguard）

-keepclassmembers class * {
    private <fields>;    
}

在我的情况下，我很笨，无法使用X类注册适配器，并尝试使用Y类将fromJson序列化：

final GsonBuilder gsonBuilder = new GsonBuilder();
gsonBuilder.registerTypeAdapter(Game.class, new TournamentSerializer());
final Gson gson = gsonBuilder.create();

createdTournament = gson.fromJson(jsonResponse.toString(), Tournament.class);

我使用GsonBuilder并ExclusionStrategy避免了如下所示的冗余字段，这很简单明了。

Gson json = new GsonBuilder()
          .setExclusionStrategies(new ExclusionStrategy() {
             @Override
             public boolean shouldSkipField(FieldAttributes f) {
                if(f.getName().equals("netAmountPcy")){
                   return true;
                }
                return false;
             }

             @Override
             public boolean shouldSkipClass(Class<?> clazz) {
                return false;
             }
          }).create();

根据@ Adrian-Lee的建议，为Kotlin解决方案，您必须调整一些Null Checks

class SuperclassExclusionStrategy : ExclusionStrategy {

    override fun shouldSkipClass(clazz: Class<*>?): Boolean {
        return false
    }

    override fun shouldSkipField(f: FieldAttributes?): Boolean {
        val fieldName = f?.name
        val theClass = f?.declaringClass

        return isFieldInSuperclass(theClass, fieldName)
    }

    private fun isFieldInSuperclass(subclass: Class<*>?, fieldName: String?): Boolean {
        var superclass: Class<*>? = subclass?.superclass
        var field: Field?

        while (superclass != null) {
            field = getField(superclass, fieldName)

            if (field != null)
                return true

            superclass = superclass.superclass
        }

        return false
    }

    private fun getField(theClass: Class<*>, fieldName: String?): Field? {
        return try {
            theClass.getDeclaredField(fieldName)
        } catch (e: Exception) {
            null
        }

    }
}

我不认为您应该使成员成为临时成员，这可能会导致错误，因为将来可能需要的成员可能会被隐藏。

我如何解决此问题的方法是使用自定义命名策略，并将完整的类名附加到Json，这样做的缺点是会导致Json更大，如果您需要它来使用Rest Api之类的东西，那将会很奇怪客户端以这种方式命名字段，但我只需要序列化即可写入android上的磁盘。

所以这是Kotlin中自定义命名策略的实现

import com.google.gson.FieldNamingStrategy
import java.lang.reflect.Field

  class GsonFieldNamingStrategy : FieldNamingStrategy {
     override fun translateName(field: Field?): String? {
        return "${field?.declaringClass?.canonicalName}.${field?.name}"
    }
}

因此，对于所有字段，将附加完整的规范名称，这将使子类的名称与父类的名称不同，但是在反序列化时，将使用子类的值。