Question

我正在开发一些JavaSE GUI应用程序，它必须从/向XML文件存储和加载它的数据（源代码可在此处获取：https://github.com/SP8EBC/MKS_JG）

在数据结构的某个地方，我有一个HashMap，它将基类型绑定到Short。实际上，这个基类型是一个抽象类，所以我的软件将子类的对象添加为键。为了编组和解组这些类型，我开发了一个适配器，但不幸的是，无论我用注释做什么，这个适配器从未使用过，因此输出XML文件是错误的。我在方法和调试软件中放置了一些断点，这些断点更新了。

我的问题是：我应该在代码中做些什么来使用我的适配器正确处理这个HashMap？

具有基类的HashMap所在的类是这样的：

@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class Competition {
 // some other fields and methods 
    @XmlElement
    public HashMap<LugerCompetitor, Short> startList;
}

此时基类的声明如下所示

@XmlAccessorType(XmlAccessType.PUBLIC_MEMBER)
@XmlJavaTypeAdapter(value = LugerCompetitorAdapter.class)
public abstract class LugerCompetitor {
    /**
     * .... some commentary in polish 
     */ 
    public abstract CompetitionTypes getCompetitorType();

    public abstract void setStartNumber(short num);
    @XmlTransient
    public abstract short getStartNumber();

    public abstract String toString();
}

其中一个子类看起来像这样

public class LugerDouble extends LugerCompetitor {

    /**
     * Saneczkarz na górze
     */
    public Luger upper;

    /**
     * Saneczkarz na dole
     */
    public Luger lower;

    short startNum;

    @Override
    public CompetitionTypes getCompetitorType() {
        // TODO Auto-generated method stub
        return null;
    }

    public String toString() {
        String out;

        out = upper.surname + " / " + lower.surname;

        return out;
    }

    @Override
    public short getStartNumber() {
        return this.startNum;
    }

    @Override
    public void setStartNumber(short num) {
        this.startNum = num;

    }

}

正如您所看到的，我编写了一个适配器，它应该将完全不同的子对象转换为XML文件中标准化的内容。适配器如下所示：

public class LugerCompetitorAdapter extends XmlAdapter<LugerCompetitorAdapter.AdaptedCompetitorLuger, LugerCompetitor> {

    public static class AdaptedCompetitorLuger {

        @XmlAttribute
        public long lugerSystemId;          // LugerSingle

        @XmlAttribute
        public long bottomLugerSystemId;    // Dwójka sankowa - dół

        @XmlAttribute
        public long upperLugerSystemId;     // Dwójka sankowa - góra

        @XmlAttribute
        public long maleLugerSystemId;      // Sztafeta albo drużyna

        @XmlAttribute
        public long femaleSystemId;         // jw

        @XmlAttribute       
        public long doubleSystemId;         // jw


    }

    @Override
    public AdaptedCompetitorLuger marshal(LugerCompetitor v) throws Exception {

        AdaptedCompetitorLuger adaptedCompetitorLuger = new AdaptedCompetitorLuger();

        if (v instanceof LugerSingle) {
            adaptedCompetitorLuger.lugerSystemId = ((LugerSingle)v).single.getSystemId();
            return adaptedCompetitorLuger;
        }
        if (v instanceof LugerDouble) {
            adaptedCompetitorLuger.bottomLugerSystemId = ((LugerDouble)v).lower.getSystemId();
            adaptedCompetitorLuger.upperLugerSystemId = ((LugerDouble)v).upper.getSystemId();
            return adaptedCompetitorLuger;


        }

        return null;
    }

    @Override
    public LugerCompetitor unmarshal(AdaptedCompetitorLuger v) throws Exception {
        return null;
    }

}

编辑（已添加解决方案）

所以我用另一种方式制作了我想要的东西。我刚刚为整个HashMap创建了一个适配器，而不是尝试执行marschall和unmarschall LugerCompetitor本身。我的解决方案如下所示，它在我生成XML时似乎有效。仍需要制定相反的方向。

@Component
public class StartListAdapter extends XmlAdapter<StartListAdapter.AdaptedStartList, Map<LugerCompetitor, Short>> {

    RTE_ST rte_st;

    @Autowired
    @Lazy
    public void setRTE(RTE_ST rte) {
        rte_st = rte;
    }

    public static class AdaptedStartList {
        @XmlElement(name="startListEntry")
        public List<AdaptedEntry> adaptedList = new ArrayList<AdaptedEntry>();
    }

    public static class AdaptedEntry {

        @XmlElement(required = false, nillable = true )
        public Long lugerSystemId;          // konkurencja pojedyncza K albo M

        @XmlElement(required = false, nillable = true )
        public Long lowerLugerSystemId; // dwójki sankowe - sankarz na dole

        @XmlElement(required = false, nillable = true )
        public Long upperLugerSystemId;     // j/w ale sankarz na górze

        @XmlElement(required = false, nillable = true )
        public Long maleLugerSystemId;      // M podczas sztafety albo konkurencji drużynowej

        @XmlElement(required = false, nillable = true )
        public Long femaleLugerSystemId;    // K j/w

        @XmlElement(required = true)
        public short startNumber;
    }

    @Override
    public AdaptedStartList marshal(Map<LugerCompetitor, Short> arg0) throws Exception {
        AdaptedStartList out = new AdaptedStartList();

        for (Entry<LugerCompetitor, Short> e : arg0.entrySet()) {
            AdaptedEntry adaptedEntry = new AdaptedEntry();

            LugerCompetitor k = e.getKey();

            if (k instanceof LugerSingle) {
                adaptedEntry.lugerSystemId = ((LugerSingle)k).single.getSystemId();
                adaptedEntry.startNumber = e.getValue();
            }
            else if (k instanceof LugerDouble) {
                adaptedEntry.lowerLugerSystemId = ((LugerDouble)k).lower.getSystemId();
                adaptedEntry.upperLugerSystemId = ((LugerDouble)k).upper.getSystemId();
                adaptedEntry.startNumber = e.getValue();

            }

            out.adaptedList.add(adaptedEntry);
        }

        return out;
    }

    @Override
    public Map<LugerCompetitor, Short> unmarshal(AdaptedStartList arg0) throws Exception {
        return null;
    }

}

Answer 1

首先，如果可能但不是必需的，将LugerCompetitor转换为接口。你可以避免所有公共抽象的混乱：

public interface LugerCompetitor {
    /**
     * .... some commentary in polish 
     */ 
    CompetitionTypes getCompetitorType();

    void setStartNumber(short num);
    @XmlTransient
    short getStartNumber();
}

然后你可以定义一个元素来表示LugerCompetitor和Short值：

@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class LugerCompetitorValue {
    @XmlElement
    @XmlJavaTypeAdapter(LugerCompetitorAdapter.class)
    public LugerCompetitor competitor;

    @XmlElement
    public Short value;

}

并为您的班级添加LugerCompetitorValue集合：

@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class Competition {
 // some other fields and methods 
    @XmlElement
    public List<LugetCompetitorValue> lugerCompetitorValues;
}

然后适配器应该开始工作。但问题是，您希望如何在客户端解组数据？

JAXB和基本类型的XmlAdapter映射在哈希映射内部

1 个答案: