JAXB编组，忽略nillable

Question

public class Hi {
    ...
    @XmlElement(name = "hello", nillable = true)
    protected Long hello;
    ...
}

对象使用JAXBContext创建的封送器进行封送。生成的xml将变成：

...
<hello xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:nil="true"/>
...

类Hi是从不能更改的xsd生成的。我的问题是，如果“hello”为null，有没有一种方法可以让封送器忽略nillable参数，并且不向xml输出任何内容？

Answer 1

一种方法是实现XMLStreamWriter类型的装饰器，并在其中实现筛选器。

这里有一个非常基本和幼稚的方法（它没有涵盖很多东西，比如命名空间和其他东西），它可以在您的情况下工作，但它并不是完美的，它只是为了展示这个想法：

public class FilteredXMLStreamWriter implements XMLStreamWriter {
    private final XMLStreamWriter writer;
    private final Set<String> pathsToSkip;
    private final Stack<String> path = new Stack<>();
    private boolean ignore;

    public FilteredXMLStreamWriter(XMLStreamWriter writer, Set<String> pathsToSkip) {
        this.writer = writer;
        this.pathsToSkip = pathsToSkip;
    }

    /**
     * Build the current path from the Stack
     */
    private String toPath() {
        StringBuilder sb = new StringBuilder();
        boolean first = true;
        for (String element : path) {
            if (first) {
                first = false;
            } else {
                sb.append('/');
            }
            sb.append(element);
        }
        return sb.toString();
    }

    public void writeStartElement(String prefix, String localName, String namespaceURI) 
        throws XMLStreamException {
        // Add the current
        path.push(localName);
        if (!ignore) {
            this.ignore = pathsToSkip.contains(toPath());
            if (!ignore) {
                this.writer.writeStartElement(prefix, localName, namespaceURI);
            }
        }
    }
    ...

    public void writeEndElement() throws XMLStreamException {
        if (ignore) {
            this.ignore = !pathsToSkip.contains(toPath());
        } else {
            this.writer.writeEndElement();
        }
        path.pop();
    }
    ...

    public void writeCharacters(String text) throws XMLStreamException {
        if (!ignore) {
            this.writer.writeCharacters(text);
        }
    }

    public void writeCharacters(char[] text, int start, int len) 
        throws XMLStreamException {
        if (!ignore) {
            this.writer.writeCharacters(text, start, len);
        }
    }

    ...
}

这里有一个天真的方法来获得要跳过的路径：

private static Set<String> pathsToSkip(Class<?> clazz) {
    // Make sure that the class is annotated with XmlRootElement
    XmlRootElement rootElement = clazz.getAnnotation(XmlRootElement.class);
    if (rootElement == null) {
        throw new IllegalArgumentException("XmlRootElement is missing");
    }
    // Create the root name from the annotation or from the class name
    String rootName = ("##default".equals(rootElement.name()) ?
        clazz.getSimpleName().substring(0, 1).toLowerCase() + clazz.getSimpleName().substring(1) :
        rootElement.name());
    // Set that will contain all the paths
    Set<String> pathsToSkip = new HashSet<>();        
    addPathsToSkip(rootName, clazz, pathsToSkip);
    return pathsToSkip;
}

private static void addPathsToSkip(String parentPath, Class<?> clazz, 
                                   Set<String> pathsToSkip) {
    // Iterate over all the fields
    Field[] fields = clazz.getDeclaredFields();
    for (Field field : fields) {
        XmlElement xmlElement = field.getAnnotation(XmlElement.class);
        if (xmlElement != null) {
            // Create the name of the element from the annotation or the field name
            String elementName = ("##default".equals(xmlElement.name()) ?
                field.getName() :
                xmlElement.name());
            String path = parentPath + "/" + elementName;
            if (xmlElement.nillable()) {
                // It is nillable so we add it to the paths to skip
                pathsToSkip.add(path);
            } else {
                // It is not nillable so we check the fields corresponding 
                // to the field type
                addPathsToSkip(path, field.getType(), pathsToSkip);
            }
        }
    }
}

marshaller.marshal(
    myObject, 
    new FilteredXMLStreamWriter(
        XMLOutputFactory.newInstance().createXMLStreamWriter(sw),
        pathsToSkip(Hi.class)
    )
);