JAXB中基于Java对象动态获取QName并创建JAXBElement的策略

@XmlRegistry
public class ObjectFactory {

    private final static QName _ABC_QNAME = new QName("http://www", "request1");
    // ... 其他 QName 定义

    /**
     * Create an instance of {@link ABC }
     *
     */
    public ABC createABC() {
        return new ABC();
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link ABC }{@code >}
     *
     * @param value
     *     Java instance representing xml element's value.
     * @return
     *     the new instance of {@link JAXBElement }{@code <}{@link ABC }{@code >}
     */
    @XmlElementDecl(namespace = "http://www", name = "request1")
    public JAXBElement<ABC> createRequest1(ABC value) {
        return new JAXBElement<ABC>(_ABC_QNAME, ABC.class, null, value);
    }
    // ... 其他 create 方法
}

import org.springframework.util.ClassUtils; // Spring环境，获取用户类，避免CGLIB代理等
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBElement;
import javax.xml.bind.Marshaller;
import java.io.OutputStream;
import java.lang.reflect.Method;
import java.util.Map;

// 假设生成的POJO和ObjectFactory在 com.example.generated 包中
// 实际路径需根据你的项目结构调整
import com.example.generated.ObjectFactory;
import com.example.generated.ABC;

public class JaxbMarshallingService {

    private final JAXBContext jaxbContext;
    private final ObjectFactory objectFactory; // ObjectFactory 实例

    /**
     * 构造函数，初始化JAXBContext和ObjectFactory。
     * JAXBContext的创建是昂贵的，建议作为单例或在应用启动时初始化。
     * ObjectFactory通常也是单例。
     * @param jaxbContext JAXB上下文
     * @param objectFactory ObjectFactory实例
     */
    public JaxbMarshallingService(JAXBContext jaxbContext, ObjectFactory objectFactory) {
        this.jaxbContext = jaxbContext;
        this.objectFactory = objectFactory;
    }

    /**
     * 将Java对象编组为XML并写入输出流。
     * 此方法通过反射动态调用ObjectFactory的create方法来获取JAXBElement。
     *
     * @param value 要编组的Java对象
     * @param outputStream 目标输出流
     * @throws Exception 如果编组失败或反射调用出错
     */
    public void encodeValue(Object value, OutputStream outputStream) throws Exception {
        // 1. 获取Java对象的实际类名
        // ClassUtils.getUserClass(value) 可以处理代理对象，如果是非Spring环境，直接使用 value.getClass()
        Class<?> clazz = ClassUtils.getUserClass(value);
        String simpleClassName = clazz.getSimpleName(); // 例如 "ABC"

        // 2. 构造ObjectFactory中对应的create方法名
        // JAXB生成的create方法通常是 create[ElementName]，而非 create[ClassName]
        // 例如，如果XML元素名为 "request1"，对应的POJO是ABC，则方法名可能是 createRequest1
        // 这需要根据你的XSD和ObjectFactory的实际生成情况来确定命名约定。
        // 这里我们假设方法名是 create[ClassName] 或者根据QName的localPart来构建。
        // 为了简化，我们先尝试 create[ClassName]
        String createMethodName = "create" + simpleClassName; // 尝试 "createABC"

        JAXBElement<?> jaxbElement = null;

        try {
            // 3. 通过反射查找并调用ObjectFactory中的create方法
            // 尝试查找 create[ClassName](ClassName value) 形式的方法
            Method createMethod = objectFactory.getClass().getMethod(createMethodName, clazz);
            jaxbElement = (JAXBElement<?>) createMethod.invoke(objectFactory, value);

        } catch (NoSuchMethodException e) {
            // 如果 create[ClassName] 形式的方法不存在，可能需要根据QName的localPart来猜测方法名
            // 例如，如果QName的localPart是"request1"，则方法名可能是"createRequest1"
            // 这需要更复杂的逻辑来从JAXBContext中反向查找QName与Class的映射，或者预先定义一个映射表。
            // 鉴于ObjectFactory中的QName通常是静态常量，我们可以尝试遍历ObjectFactory的QName字段。
            // 但最直接的通常是 create[RootElementName] 或 create[TypeName]。
            // 这里我们简化处理，如果找不到，就抛出异常。
            throw new RuntimeException("ObjectFactory中未找到对应方法: " + createMethodName + "，无法为对象 " + simpleClassName + " 创建JAXBElement。", e);
        } catch (Exception e) {
            // 处理其他反射或方法调用异常
            throw new RuntimeException("通过反射调用ObjectFactory方法失败，对象: " + simpleClassName, e);
        }

        // 4. 初始化Marshaller并进行编组
        if (jaxbElement != null) {
            Marshaller marshaller = jaxbContext.createMarshaller();
            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true); // 可选：格式化输出
            marshaller.marshal(jaxbElement, outputStream);
        } else {
            throw new IllegalStateException("未能成功创建JAXBElement，无法进行编组。");
        }
    }

    // 示例用法
    public static void main(String[] args) throws Exception {
        // 1. 创建JAXBContext
        // JAXBContext需要知道所有可能被编组的类以及ObjectFactory
        // 这里假设 ABC.class 和 ObjectFactory.class 在同一个包或者已经被JAXBContext发现
        // 实际应用中，JAXBContext.newInstance(packageName) 或 JAXBContext.newInstance(Class<?>...)
        // 需要根据你的具体JAXB配置来决定。
        JAXBContext jaxbContext = JAXBContext.newInstance(ABC.class, ObjectFactory.class);

        // 2. 创建ObjectFactory实例
        ObjectFactory objectFactory = new ObjectFactory();

        // 3. 创建服务实例
        JaxbMarshallingService marshallingService = new JaxbMarshallingService(jaxbContext, objectFactory);

        // 4. 创建要编组的Java对象
        ABC abcObject = new ABC();
        abcObject.setABC("JAXB Reflection Demo");

        // 5. 模拟输出流
        java.io.ByteArrayOutputStream bos = new java.io.ByteArrayOutputStream();

        // 6. 调用编组方法
        marshallingService.encodeValue(abcObject, bos);

        // 7. 打印结果
        System.out.println("Generated XML:\n" + bos.toString());

        // 示例：另一个可能由 createDEF(DEF value) 处理的对象
        // DEF defObject = new DEF();
        // defObject.setSomeProperty("Another Object");
        // java.io.ByteArrayOutputStream bos2 = new java.io.ByteArrayOutputStream();
        // marshallingService.encodeValue(defObject, bos2);
        // System.out.println("Generated XML for DEF:\n" + bos2.toString());
    }
}

package com.example.generated; // 与 ObjectFactory 在同一个包

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlType;

@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "ProtectedABC", propOrder = {
    "aBC"
})
public class ABC {

    @XmlElement(required = true)
    protected String aBC;

    public String getABC() {
        return aBC;
    }

    public void setABC(String value) {
        this.aBC = value;
    }
}

package com.example.generated; // 与 ABC 在同一个包

import javax.xml.bind.JAXBElement;
import javax.xml.bind.annotation.XmlElementDecl;
import javax.xml.bind.annotation.XmlRegistry;
import javax.xml.namespace.QName;

@XmlRegistry
public class ObjectFactory {

    // 注意：这里的 QName 名称需要与 ObjectFactory 中 create 方法关联的 XML 元素名称匹配
    // 例如，如果 createRequest1 方法对应的是 "request1" 元素，那么 QName 字段也应是 _REQUEST1_QNAME
    // 为了与示例POJO的类名ABC对应，这里假设有一个元素名为 "request1"
    private final static QName _ABC_QNAME = new QName("http://www", "request1");
    private final static QName _DEF_QNAME = new QName("http://www", "response1");
    private final static QName _XYZ_QNAME = new QName("http://www", "result1");

    /**
     * Create a new ObjectFactory that can be used to create new instances of schema derived classes for package: com.example.generated
     *
     */
    public ObjectFactory() {}

    /**
     * Create an instance of {@link ABC }
     *
     */
    public ABC createABC() {
        return new ABC();
    }

    /**
     * Create an instance of {@link JAXBElement }{@code <}{@link ABC }{@code >}
     * for the "request1" XML element.
     *