是否有将YAML或XML文件转换为Java代码的工具或库？

Question

是否有工具或库可以将序列化为YAML的对象或XML文件转换为创建该对象的Java代码？

从技术角度来看，我认为这里没有困难。 Yaml和XStream（或其他类似工具）都需要通过反射查找Java类名称，查找构造函数，调用它，然后查找设置器并调用它们。 反射调用可以被相同的Java代码生成所代替。 但是，这需要一些工作。

是否存在这样的工具？ 还是有人正在开发它并想与公众共享？

PS任何能够将给定Java对象转换为Java代码的库都可以满足我的需求。

澄清

我希望该工具能够转换示例YAML：

--- !pl.example.Contact
name: Nathan Sweet
age: 28

或XML：

<contact>
  <name>Nathan Sweet</name>
  <age>28</age>
</contact>

进入代码：

pl.example.Contact contact = new pl.example.Contact();
contact.setName("Nathan Sweet");
contact.setAge(28);

Answer 1

我曾经问过有关将YAML或XML转换为Java代码的问题，但是我真正需要的是生成将创建给定Java对象的Java代码。 可以通过许多Java YAML库之一来读取现有的YAML。

但是，我找不到任何可以从给定Java对象创建Java代码的库。 也许我在搜索错误的关键字，也许我太早完成搜索，但是我什么都没找到。

我自己编写了该工具。 该代码非常原始，在很多情况下可能还不够（它不支持抽象类和接口等），但是对于我要完成的任务来说已经足够了。 因此，我将解决方案的源代码发布为我的问题的答案：

import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.util.*;

import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.lang.StringEscapeUtils;

public class BeanCodeGenerator {

    private class Context {
        private int index;
        private StringBuilder sb = new StringBuilder();
        private String br = "\n\t\t";
    }

    public String generateBeanMethod(Object bean, String methodName) {
        Context ctx = new Context();
        Class type = _getBeanClass(bean);
        ctx.sb.append("\tpublic ").append(type.getCanonicalName()).append(" ").append(methodName)
            .append("() {").append(ctx.br);

        String vname = "null";
        try {
            vname = _valueStr(bean, type, ctx);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        ctx.sb.append("return ").append(vname).append(";\n");
        ctx.sb.append("\t}\n");
        return ctx.sb.toString();
    }

    private String _outputBean(Object bean, Context ctx) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        // output block of code creating bean
        String vname = "v" + ctx.index;
        String cname = bean.getClass().getCanonicalName();
        ctx.sb.append(cname).append(" ").append(vname).append(" = new ").append(cname).append("();").append(ctx.br);
        PropertyDescriptor[] props = PropertyUtils.getPropertyDescriptors(bean);
        for (PropertyDescriptor prop : props) {
            if (prop.getReadMethod() == null || prop.getWriteMethod() == null)
                continue; // skip such 'properties'
            Object value = prop.getReadMethod().invoke(bean);
            if (value == null)
                continue;
            String valueStr = _valueStr(value, prop.getReadMethod().getReturnType(), ctx);
            if (valueStr != null) {
                ctx.sb.append(vname).append(".").append(prop.getWriteMethod().getName()).append("(")
                    .append(valueStr).append(");").append(ctx.br);
            }
        }
        return vname;
    }

    private Class _getBeanClass(Object bean) {
        if (bean == null)
            return null;
       if (_isCollection(bean)) {
           if (bean instanceof List)
               return ArrayList.class;
           if (bean instanceof Set)
               return HashSet.class;
           if (bean instanceof Map)
               return HashMap.class;
       }
       return bean.getClass();
    }

    private String _valueStr(Object value, Class type, Context ctx) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        String valueStr = _outputValue(value, type);
        if (valueStr == null) {
            if (_isBean(value)) {
                ctx.index++;
                valueStr = _outputBean(value, ctx);
            } else if (_isCollection(value)) {
                ctx.index++;
                valueStr = _outputCollection(value, ctx);
            }
        }
        if (valueStr == null)
            valueStr = "null";
        return valueStr;
    }

    private String _outputCollection(Object collection, Context ctx) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        String vname = "v" + ctx.index;
        if (collection instanceof List) {
            ctx.sb.append("java.util.ArrayList ").append(vname).append(" = new java.util.ArrayList();").append(ctx.br);
            List list = (List) collection;
            for (Object value : list) {
                if (value == null) {
                    ctx.sb.append(vname).append(".add(null);").append(ctx.br);
                    continue;
                }
                String valueStr = _valueStr(value, value.getClass(), ctx);;
                ctx.sb.append(vname).append(".add(").append(valueStr).append(");").append(ctx.br);
            }
        } else if (collection instanceof Set) {
            ctx.sb.append("java.util.HashSet ").append(vname).append(" = new java.util.HashSet();").append(ctx.br);
            Set set = (Set) collection;
            for (Object value : set) {
                if (value == null) {
                    ctx.sb.append(vname).append(".add(null);").append(ctx.br);
                    continue;
                }
                String valueStr = _valueStr(value, value.getClass(), ctx);;
                ctx.sb.append(vname).append(".add(").append(valueStr).append(");").append(ctx.br);
            }
        } else if (collection instanceof Map) {
            ctx.sb.append("java.util.HashMap ").append(vname).append(" = new java.util.HashMap();").append(ctx.br);
            Map map = (Map) collection;
            for (Object item : map.entrySet()) {
                Map.Entry entry = (Map.Entry) item;
                String valueStr = "null";
                String keyStr = "null";
                if (entry.getKey() != null) {
                    keyStr = _valueStr(entry.getKey(), entry.getKey().getClass(), ctx);
                }
                if (entry.getValue() != null) {
                    valueStr = _valueStr(entry.getValue(), entry.getValue().getClass(), ctx);
                }
                ctx.sb.append(vname).append(".put(").append(keyStr).append(", ").append(valueStr).append(");").append(ctx.br);
            }
        }
        return vname;
    }

    private boolean _isBean(Object value) throws SecurityException {
        if (value == null)
            return false;
        if (_isCollection(value))
            return false;
        Class type = value.getClass();
        try {
            type.getConstructor();
            return true;
        } catch (NoSuchMethodException e) {
            return false;
        }
    }

    private boolean _isCollection(Object value) {
        if (value == null)
            return false;
        Class type = value.getClass();
        return List.class.isAssignableFrom(type) || Set.class.isAssignableFrom(type) || Map.class.isAssignableFrom(type); 
    }

    // output simple value, returns null for non-singleliners
    private String _outputValue(Object value, Class type) {
        if (value == null)
            return null;
        Class vtype = value.getClass();
        if (type == long.class) {
            return value.toString() + "L";
        }
        if (type == float.class) {
            return value.toString() + "F";
        }
        if (type == short.class) {
            return "(short) " + value.toString() + "";
        }
        if (type.isPrimitive()) {
            return value.toString();
        }
        if (String.class.isAssignableFrom(type)) {
            return '"' + StringEscapeUtils.escapeJava(value.toString()) + '"';
        }
        if (Integer.class == type || Double.class == type || Boolean.class == type) {
            return type.getName() + ".valueOf(" + value.toString() + ")";
        }
        if (Long.class == type) {
            return type.getName() + ".valueOf(" + value.toString() + "L)";
        }
        if (Short.class == type) {
            return type.getName() + ".valueOf((short)" + value.toString() + ")";
        }
        if (Float.class == type) {
            return type.getName() + ".valueOf(" + value.toString() + "F)";
        }
        if (Date.class.isAssignableFrom(type)) {
            Date date = (Date) value;
            return "new java.util.Date(" + date.getTime() + "L)";
        }
        return null;
    }

}

Answer 2

您可以在此处检查YamlBeans库。

它可以读写Yaml格式的bean。

这是他们的文档示例：

name: Nathan Sweet
age: 28

public class Contact {
        public String name;
        public int age;
}

YamlReader reader = new YamlReader(new FileReader("contact.yml")); 
Contact contact = reader.read(Contact.class);
System.out.println(contact.age);

此外，似乎Yaml对JAXB的支持

编辑：

根据您的澄清，不，我不知道有任何一个lib可以立即执行此操作，但是要做起来并不难（取决于您要加载的对象的复杂程度）。

Answer 3

是的，您可以使用swagger集线器，它可以为您提供来自YAML的客户端和服务器的代码（多种语言）。 我也使用相同的工具，它具有为REST API甚至生成代码的功能。

网址： http ： //editor.swagger.io/

教程网址： https ： //swagger.io/tools/open-source/getting-started/