MOXy를 사용하여 클래스에서 XML 바인딩 파일을 생성하는 방법이 있습니까?

Question

기존 클래스의 객체를 마샬링/언 마샬링하려면 MOXy를 사용하고 싶습니다.

내 수업에서 XML 바인딩 파일 (주석을 사용하고 싶지 않기 때문에)을 생성 할 의향이 있는지 알고 싶습니다.

또는 우리 모두가 우리의 작은 손으로 그것을해야합니까 :)?

Answer 1

기본적으로 JAXB/MOXy에서는 메타 데이터를 지정할 필요가 없습니다 (http://blog.bdoughan.com/2012/07/jaxb-no-annotations-required.html 참조). 기본 비헤이비어를 무시할 메타 데이터 만 지정하면됩니다.

MOXy 외부 매핑 문서를 만드는 가장 쉬운 방법은 무엇인지 궁금합니다. 나는 이클립스와 다음, 아마 당신의 마음에 드는 IDE 유사한 설정 단계가 않습니다

1. MOXY의 매핑 문서에 대한 XML 스키마를 가져옵니다

   <EclipseLink_Home>/xsds/eclipselink_oxm_2_5.xsd 
   

2. 당신의 IDE와 XML 스키마를 등록

   1. Eclipse | 환경 설정 | XML | XML 카탈로그 | 추가

3. IDE에서 만들기 및 XML 문서를 만들고 루트 요소로 다음을 지정하십시오.

   <xml-bindings xmlns="http://www.eclipse.org/eclipselink/xsds/persistence/oxm"/> 
   

4. 는 XML 문서를 생성하기 위해 IDE에서 제공하는 자동 완성 기능을 사용합니다.

Answer 2

또 다른 옵션은 jaxb 클래스를 생성하고 외부 매핑을 생성하는 바인딩 (주석)을 읽는 것입니다 (이후에는 주석을 제거 할 수 있음). PoC 코드 :

public class MoxyBindingGenerator { 
    private static final String PACKAGE = "com.company.binding.jaxbclasses"; 
    private static ObjectFactory xmlBindingsFactory = new ObjectFactory(); 

    public static void main(String[] args) throws Exception { 
     Collection<TypeInfo> typeInfos = readAnnotations(); 

     XmlBindings xmlBindings = xmlBindingsFactory.createXmlBindings(); 
     xmlBindings.setPackageName(PACKAGE); 

     JavaTypes javaTypes = xmlBindingsFactory.createXmlBindingsJavaTypes(); 
     xmlBindings.setJavaTypes(javaTypes); 
     List<JavaType> javaTypesList = javaTypes.getJavaType(); 

     XmlEnums xmlEnums = xmlBindingsFactory.createXmlBindingsXmlEnums(); 
     xmlBindings.setXmlEnums(xmlEnums); 
     List<XmlEnum> xmlEnumsList = xmlEnums.getXmlEnum(); 

     typeInfos.stream().forEach(typeInfo -> { 
      if (!typeInfo.isEnumerationType()) { 
       fillJavaTypes(javaTypesList, typeInfo); 
      } 
      else { 
       fillEnumTypes(xmlEnumsList, typeInfo); 
      } 
     }); 

     saveToFile(xmlBindings); 
    } 

    private static Collection<TypeInfo> readAnnotations() throws JAXBException, Exception { 
     JAXBContext jaxbContext = (JAXBContext) javax.xml.bind.JAXBContext.newInstance(PACKAGE); 
     Object contextState = getPrivateField(jaxbContext, "contextState"); 
     Generator generator = (Generator) getPrivateField(contextState, "generator"); 
     AnnotationsProcessor annotationsProcessor = generator.getAnnotationsProcessor(); 
     Collection<TypeInfo> typeInfos = annotationsProcessor.getTypeInfo().values(); 
     return typeInfos; 
    } 

    private static void fillEnumTypes(List<XmlEnum> xmlEnumsList, TypeInfo typeInfo) { 
     EnumTypeInfo et = (EnumTypeInfo) typeInfo; 

     XmlEnum xmlEnum = xmlBindingsFactory.createXmlEnum(); 
     xmlEnum.setJavaEnum(et.getJavaClassName()); 
     List<String> xmlEnumNames = et.getFieldNames(); 
     List<Object> xmlEnumValues = et.getXmlEnumValues(); 
     for (int i = 0; i < xmlEnumNames.size(); i++) { 
      String xmlEnumName = xmlEnumNames.get(i); 
      Object xmlEnumObject = xmlEnumValues.get(i); 

      XmlEnumValue xmlEnumValue = xmlBindingsFactory.createXmlEnumValue(); 
      xmlEnumValue.setJavaEnumValue(xmlEnumName); 
      xmlEnumValue.setValue(xmlEnumObject.toString()); 
      xmlEnum.getXmlEnumValue().add(xmlEnumValue); 
     } 
     xmlEnumsList.add(xmlEnum); 
    } 

    private static void fillJavaTypes(List<JavaType> javaTypesList, TypeInfo typeInfo) { 
     JavaType javaType = xmlBindingsFactory.createJavaType(); 
     javaType.setName(typeInfo.getJavaClassName()); 
     fillXmlType(javaType, typeInfo); 
     if (typeInfo.getXmlRootElement() != null) { 
      XmlRootElement xmlRootElement = typeInfo.getXmlRootElement(); 
      xmlRootElement.setNamespace(null); 
      javaType.setXmlRootElement(xmlRootElement); 
     } 
     JavaAttributes javaAttributes = xmlBindingsFactory.createJavaTypeJavaAttributes(); 
     javaType.setJavaAttributes(javaAttributes); 
     List<JAXBElement<? extends JavaAttribute>> javaAttributeList = javaAttributes.getJavaAttribute(); 
     typeInfo.getNonTransientPropertiesInPropOrder().stream().forEach(field -> { 
      fillFields(javaAttributeList, field); 
     }); 
     javaTypesList.add(javaType); 
    } 

    private static void fillFields(List<JAXBElement<? extends JavaAttribute>> javaAttributeList, Property field) { 
     if (field.getXmlElements() != null && field.getXmlElements().getXmlElement().size() > 0) { 
      XmlElements xmlElements = xmlBindingsFactory.createXmlElements(); 
      xmlElements.setJavaAttribute(field.getPropertyName()); 
      List<XmlElement> elements = field.getXmlElements().getXmlElement(); 
      elements.stream().forEach(e -> { 
       e.setDefaultValue(null); 
       e.setNamespace(null); 
       xmlElements.getXmlElement().add(e); 
      }); 
      JAXBElement<XmlElements> value = xmlBindingsFactory.createXmlElements(xmlElements); 
      javaAttributeList.add(value); 
     } 
     else if (!field.isAttribute()) { 
      XmlElement value = xmlBindingsFactory.createXmlElement(); 
      value.setJavaAttribute(field.getPropertyName()); 
      value.setName(field.getSchemaName().getLocalPart()); 
      if (field.isNillable()) 
       value.setNillable(field.isNillable()); 
      if (field.isRequired()) 
       value.setRequired(field.isRequired()); 
      javaAttributeList.add(xmlBindingsFactory.createXmlElement(value)); 
     } 
     else { 
      XmlAttribute value = xmlBindingsFactory.createXmlAttribute(); 
      value.setJavaAttribute(field.getPropertyName()); 
      value.setName(field.getSchemaName().getLocalPart()); 
      javaAttributeList.add(xmlBindingsFactory.createXmlAttribute(value)); 
     } 
    } 

    private static void saveToFile(XmlBindings xmlBindings) 
      throws JAXBException, PropertyException, FileNotFoundException, IOException { 
     JAXBContext xmlModelJaxbContext = 
      (JAXBContext) javax.xml.bind.JAXBContext.newInstance("org.eclipse.persistence.jaxb.xmlmodel"); 
     JAXBMarshaller marshaller = xmlModelJaxbContext.createMarshaller(); 
     marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true); 
     FileOutputStream fos = new FileOutputStream(new File(System.getProperty("user.home"), "binding-imspoor-oxm.xml")); 
     marshaller.marshal(xmlBindings, fos); 
     fos.close(); 
    } 

    private static void fillXmlType(JavaType javaType, TypeInfo typeInfo) { 
     XmlType orgXmlType = typeInfo.getXmlType(); 
     if (orgXmlType != null) { 
      boolean add = false; 
      XmlType xmlType = xmlBindingsFactory.createXmlType(); 
      if (!StringUtils.isEmpty(orgXmlType.getName())) { 
       xmlType.setName(orgXmlType.getName()); 
       add = true; 
      } 
      if (orgXmlType.getPropOrder() != null && orgXmlType.getPropOrder().size() > 1) { 
       xmlType.getPropOrder().addAll(orgXmlType.getPropOrder()); 
       add = true; 
      } 
      if (add) 
       javaType.setXmlType(xmlType); 
     } 
    } 

    private static Object getPrivateField(Object obj, String fieldName) throws Exception { 
     Field declaredField = obj.getClass().getDeclaredField(fieldName); 
     declaredField.setAccessible(true); 
     return declaredField.get(obj); 
    } 
}