创建 JAXB Unmarshaller 池

Question

我四处寻找一种方法来提高 JAXB Unmarshalling 处理大量文件的性能，并发现了以下建议：

“如果您真的关心性能，和/或您的应用程序将读取大量小文档，那么创建 Unmarshaller 可能是一个相对昂贵的操作，在这种情况下，请考虑池化 Unmarshaller 对象”

谷歌搜索网络以找到这样的示例没有返回任何内容，所以我认为将我的内容放在一起可能会感兴趣。这里使用 Spring 3.0 和 Apache Commons Pool 实现。

UnmarshallerFactory.java

import java.util.HashMap;
import java.util.Map;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import org.apache.commons.pool.KeyedPoolableObjectFactory;
import org.springframework.stereotype.Component;

/**
 * Pool of JAXB Unmarshallers.
 * 
 */
@Component
public class UnmarshallerFactory implements KeyedPoolableObjectFactory {
    // Map of JAXB Contexts
    @SuppressWarnings("rawtypes")
    private final static Map<Object, JAXBContext> JAXB_CONTEXT_MAP = new HashMap<Object, JAXBContext>();

    @Override
    public void activateObject(final Object arg0, final Object arg1) throws Exception {
    }

    @Override
    public void passivateObject(final Object arg0, final Object arg1) throws Exception {
    }

    @Override
    public final void destroyObject(final Object key, final Object object) throws Exception {
    }

    /**
     * Create a new instance of Unmarshaller if none exists for the specified
     * key.
     * 
     * @param unmarshallerKey
     *            : Class used to create an instance of Unmarshaller
     */
    @SuppressWarnings("rawtypes")
    @Override
    public final Object makeObject(final Object unmarshallerKey) {
        if (unmarshallerKey instanceof Class) {
            Class clazz = (Class) unmarshallerKey;
            // Retrieve or create a JACBContext for this key
            JAXBContext jc = JAXB_CONTEXT_MAP.get(unmarshallerKey);
            if (jc == null) {
                try {
                    jc = JAXBContext.newInstance(clazz);
                    // JAXB Context is threadsafe, it can be reused, so let's store it for later
                    JAXB_CONTEXT_MAP.put(unmarshallerKey, jc);
                } catch (JAXBException e) {
                    // Deal with that error here
                    return null;
                }
            }
            try {
                return jc.createUnmarshaller();
            } catch (JAXBException e) {
                // Deal with that error here
            }
        }
        return null;
    }

    @Override
    public final boolean validateObject(final Object key, final Object object) {
        return true;
    }
}

UnmarshallerPool.java

import org.apache.commons.pool.impl.GenericKeyedObjectPool;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class UnmarshallerPool extends GenericKeyedObjectPool {
    @Autowired
    public UnmarshallerPool(final UnmarshallerFactory unmarshallerFactory) {
    // Make usage of the factory created above
    super(unmarshallerFactory);
            // You'd better set the properties from a file here
    this.setMaxIdle(4);
    this.setMaxActive(5);
    this.setMinEvictableIdleTimeMillis(30000);
    this.setTestOnBorrow(false);
    this.setMaxWait(1000);
    }

    public UnmarshallerPool(UnmarshallerFactory objFactory,
        GenericKeyedObjectPool.Config config) {
        super(objFactory, config);
    }

    @Override
    public Object borrowObject(Object key) throws Exception {
        return super.borrowObject(key);
    }

    @Override
    public void returnObject(Object key, Object obj) throws Exception {
        super.returnObject(key, obj);
    }
}

在需要 JAXB Unmarshaller 的类中：

    // Autowiring of the Pool
    @Resource(name = "unmarshallerPool")
    private UnmarshallerPool unmarshallerPool;

    public void myMethod() {
        Unmarshaller u = null;
        try {
            // Borrow an Unmarshaller from the pool
            u = (Unmarshaller) this.unmarshallerPool.borrowObject(MyJAXBClass.class);
            MyJAXBClass myJAXBObject = (MyJAXBClass) u.unmarshal(url);
            // Do whatever
        } catch (Exception e) {
            // Deal with that error
        } finally {
            try {
                // Return the Unmarshaller to the pool
                this.unmarshallerPool.returnObject(MyJAXBClass.class, u);
            } catch (Exception ignore) {
            }
        }
    }

此示例很幼稚，因为它仅使用一个类来创建 JAXBContext 并使用相同的类实例作为键控池的键。这可以通过传递一组类作为参数而不是仅传递一个类来改进。

希望这能有所帮助。

Answer 1

解组器的创建是为了轻量级。我建议在制定池化策略之前进行一些分析。