XStream 1.4.10版本处理xml使用问题

XStream pom依赖：

<dependency>

    <groupId>com.thoughtworks.xstream</groupId>

    <artifactId>xstream</artifactId>

    <version>1.4.10</version>

</dependency>

1、对象解析成xml字符串时下划线变成双下划线

解决：

xStream = new XStream(new DomDriver("UTF-8", new XmlFriendlyNameCoder("_-", "_")));

或者

xStream = new XStream(new Xpp3Driver(new NoNameCoder()));

2、Security framework of XStream not initialized, XStream is probably vulnerable

解决：

XStream.setupDefaultSecurity(xStream);

xStream.allowTypesByWildcard(new String[] {

      "com.common.util.**"  //你的包路径

});

3、处理既有属性又有值的情况

形如：<Query Code="1">select * from user</Query>

使用自定义转换器实现,如下：

public class QueryConverter implements Converter {

    @Override

    public boolean canConvert(Class type) {

        return type.equals(Query.class);

    }

    /**

     * 将java对象转为xml时使用

     */

    @Override

    public void marshal(Object source, HierarchicalStreamWriter writer, MarshallingContext context) {

        Query query = (Query) source;

        // 设置属性值

        writer.addAttribute("Code", query.getCode());

        // 设置文本值

        writer.setValue(query.getText());

    }

    /**

     * 将xml转为java对象使用

     */

    @Override

    public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {

        Query query = new Query();

        query.setTransactionCode(reader.getAttribute("Code"));

        query.setText(reader.getValue());

        return query;

    }

}

之后通过注解@XStreamConverter(value = QueryConverter.class)

或代码注册转换器使用：

xStream.registerConverter(new xxxConverter());

4、时间转换器

字段为Date类型

public class DateConverter implements Converter {

    @Override

    public boolean canConvert(Class arg0) {

        return Date.class == arg0;

    }

    @Override

    public void marshal(Object arg0, HierarchicalStreamWriter arg1, MarshallingContext arg2) {

    }

    @Override

    public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext arg1) {

        GregorianCalendar calendar = new GregorianCalendar();

        //格式化当前系统日期

        SimpleDateFormat dateFm = new SimpleDateFormat("yyyy-MM-dd");

        try {

            calendar.setTime(dateFm.parse(reader.getValue()));

        } catch (ParseException e) {

            throw new ConversionException(e.getMessage(), e);

        }

        return calendar.getTime();

    }

}

使用：

@XStreamConverter(DateConverter.class)

private Date beginTime;

属性为Date类型处理SingleValueConverter

public class XStreamDateConverter implements SingleValueConverter {

    @Override

    public boolean canConvert(Class arg0) {

        return Date.class == arg0;

    }

    @Override

    public Object fromString(String arg0) {

        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");

        try {

            return format.parse(arg0);

        } catch (ParseException e) {

            e.printStackTrace();

        }

        return null;

    }

    @Override

    public String toString(Object arg0) {

        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");

        try {

            return format.format((Date) arg0);

        } catch (Exception e) {

            e.printStackTrace();

        }

        return "";

    }

}

之后将转化加在Date属性的字段上使用即可

@XStreamConverter(value=XStreamDateConverter.class)

@XStreamAsAttribute

private Date beginTime;

5、针对null值的字段也显示在xml中处理

大概思路就是遍历对象的所有的字段，若当前字段的值为null，则处理成空字符串，示例自定义转换器如下：

public class FieldConverter implements Converter {

    /**

     * 日志记录

     */

    private static final Logger LOGGER = LoggerFactory.getLogger(FieldConverter.class);

    /**

     * 时间格式

     */

    private String formatPattern;

    public FieldConverter() {

    }

    public FieldConverter(String formatPattern) {

        this.formatPattern = formatPattern;

    }

    @Override

    public boolean canConvert(Class type) {

        return true;

    }

    /**

     * 将java对象转为xml时使用

     */

    @Override

    public void marshal(Object source, HierarchicalStreamWriter writer, MarshallingContext context) {

        try {

            handleSource(source, writer);

        } catch (Exception e) {

            LOGGER.error("[FieldConverter] marshal 异常，{}", e);

            throw new IllegalArgumentException("转换xml出错");

        }

    }

    /**

     * @description ：处理对象为xml转换

     * @param source 对象源

     * @param writer 流写出对象

     * @date  2019/9/29 18:48

     * @modifier

     * @return  void

     */

    private void handleSource(Object source, HierarchicalStreamWriter writer) throws IllegalAccessException {

        try {

            Class<?> aClass = source.getClass();

            Field[] declaredFields = aClass.getDeclaredFields();

            for (Field currField : declaredFields) {

                currField.setAccessible(Boolean.TRUE);

                // 字段注解

                boolean isAttr = currField.isAnnotationPresent(XStreamAsAttribute.class);

                boolean isXStreamAlias = currField.isAnnotationPresent(XStreamAlias.class);

                boolean isFieldValue = currField.isAnnotationPresent(FieldValue.class);

                // 当前字段值

                Object curFieldValue = currField.get(source);

                // 字段别名

                String xmlAlias;

                if (isXStreamAlias) {

                    xmlAlias = currField.getAnnotation(XStreamAlias.class).value();

                } else {

                    xmlAlias = currField.getName();

                }

                if (isAttr) {

                    // 字段属性

                    writer.addAttribute(xmlAlias, null == curFieldValue ? "" : String.valueOf(curFieldValue));

                } else if (isFieldValue) {

                    // 字段值

                    writer.setValue(String.valueOf(curFieldValue));

                } else {

                    // 字段简单处理

                    boolean isBaseType = DomainUtil.isBaseType(currField.getType());

                    if (curFieldValue instanceof List) {

                        List<Object> list = (List<Object>) curFieldValue;

                        for (int i = 0; i < list.size(); i++) {

                            writer.startNode(xmlAlias + i);

                            Object curr = list.get(i);

                            isBaseType = DomainUtil.isBaseType(curr.getClass());

                            if (null == curr || isBaseType) {

                                writer.setValue(null == curr ? "" : String.valueOf(curr));

                            } else {

                                handleSource(curr, writer);

                            }

                            writer.endNode();

                        }

                    } else {

                        // 开始节点

                        writer.startNode(xmlAlias);

                        if (null == curFieldValue || isBaseType) {

                            writer.setValue(null == curFieldValue ? "" : String.valueOf(curFieldValue));

                        } else if (currField.getType().equals(Date.class)) { //时间对象

                            SimpleDateFormat format = new SimpleDateFormat(formatPattern);

                            writer.setValue(null == curFieldValue ? "" : format.format(curFieldValue));

                        } else { //对象类型

                            handleSource(curFieldValue, writer);

                        }

                        // 结束节点

                        writer.endNode();

                    }

                }

            }

        } catch (Exception e) {

            LOGGER.error("[FieldConverter] handleSource 异常，{}", e);

            throw e;

        }

    }

    /**

     * 将xml转为java对象使用

     */

    @Override

    public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {

        System.out.println("coming.....");

        return null;

    }

巴特西

XStream 1.4.10版本处理xml使用问题

源码参照 GitHub

最新文章

热门文章