创建一个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) {
            }
        }
    }

这个例子是天真的,因为它只使用一个Class来创建JAXBContext并使用相同的Class实例作为Keyed Pool的Key.这可以通过将类数组作为参数而不是仅传递一个类来改进.

希望这可以提供帮助.

Answer 1

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