如何为单例JAXB实例适配两个不同类的编组与解组？

嘿，我明白你的问题了——你现在的单例JAXBContext只绑定了单个类，导致编组用一个类、解组用另一个类时就卡壳了对吧？其实JAXBContext本身是支持处理多个类的，而且它是线程安全的，我们只需要调整单例的实现方式，就能轻松解决这个问题。下面给你两种实用的方案：

方案一：一次性初始化所有需要的类 #

如果已经明确知道要处理的所有类（比如编组用的ClassX和解组用的ClassY），可以直接在静态初始化块里把这些类都传给JAXBContext.newInstance()，这样全局就一个Context实例，能处理所有指定的类：

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import java.io.InputStream;
import java.io.OutputStream;

public class JAXBInitialisedSingleton {
    // 全局唯一的JAXBContext实例，包含所有需要处理的类
    private static final JAXBContext contextObj;

    // 静态初始化块，保证只初始化一次
    static {
        try {
            // 把你需要的所有类都列在这里，用逗号分隔
            contextObj = JAXBContext.newInstance(ClassX.class, ClassY.class);
        } catch (JAXBException e) {
            // 初始化失败时抛出运行时异常，避免后续空指针
            throw new RuntimeException("Failed to initialize JAXBContext", e);
        }
    }

    // 私有构造方法，防止实例化
    private JAXBInitialisedSingleton() {}

    // 获取全局Context实例
    public static JAXBContext getInstance() {
        return contextObj;
    }

    // 封装编组方法，方便直接调用
    public static <T> void marshal(T obj, OutputStream os) throws JAXBException {
        Marshaller marshaller = contextObj.createMarshaller();
        // 可以在这里设置编组的配置，比如格式化输出
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
        marshaller.marshal(obj, os);
    }

    // 封装解组方法，指定目标类
    public static <T> T unmarshal(InputStream is, Class<T> clazz) throws JAXBException {
        Unmarshaller unmarshaller = contextObj.createUnmarshaller();
        return clazz.cast(unmarshaller.unmarshal(is));
    }
}

这个方案的优点是简单直接，全局只维护一个Context实例，性能最优，适合你能提前确定所有需要处理的类的场景。

方案二：按需缓存单个类的Context #

如果不确定要处理的类有哪些，或者类的数量比较多，可以用一个线程安全的缓存来存储每个类对应的JAXBContext，确保每个类只创建一次Context：

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class JAXBInitialisedSingleton {
    // 用ConcurrentHashMap做线程安全的缓存，key是Class，value是对应的JAXBContext
    private static final Map<Class<?>, JAXBContext> contextCache = new ConcurrentHashMap<>();

    private JAXBInitialisedSingleton() {}

    // 根据传入的类获取对应的Context，不存在则创建
    public static JAXBContext getInstance(Class<?> clazz) throws JAXBException {
        // computeIfAbsent是线程安全的，确保每个Class只创建一次Context
        return contextCache.computeIfAbsent(clazz, targetClass -> JAXBContext.newInstance(targetClass));
    }

    // 封装编组方法，自动获取对象所属类的Context
    public static <T> void marshal(T obj, OutputStream os) throws JAXBException {
        Marshaller marshaller = getInstance(obj.getClass()).createMarshaller();
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
        marshaller.marshal(obj, os);
    }

    // 封装解组方法，传入目标类获取对应的Context
    public static <T> T unmarshal(InputStream is, Class<T> clazz) throws JAXBException {
        Unmarshaller unmarshaller = getInstance(clazz).createUnmarshaller();
        return clazz.cast(unmarshaller.unmarshal(is));
    }
}

这个方案更灵活，不管后续新增多少个需要处理的类，都能自动适配，而且ConcurrentHashMap的线程安全特性也能保证多线程环境下的正确性。

额外小提示 #

• 如果你的类都属于同一个包，可以直接用JAXBContext.newInstance("com.your.package.name")来初始化整个包下的所有JAXB类，更省事。
• JAXBContext是重量级对象，所以一定要避免频繁创建，这两个方案都是为了复用实例，提升性能。
• 处理JAXBException时，你可以根据业务需求选择抛出或者封装成自定义异常，不用硬套运行时异常。

内容的提问来源于stack exchange，提问作者jack