Apache Commons Configuration 缓存

Question

我想知道如何在apache-commons-configuration框架中缓存我的属性。从我的config.xml中不同的位置获取属性需要很长时间。所以，是否有一个带有缓存功能（例如按时间）的Configuration接口实现？

- Alexey Kutuzov

Answer 1

• 您可以将 Apache 对象保存在某个类的静态变量中，并在完成后将其设置为 null。使用静态 getter 读取它。

• 不确定 Apache 配置 API，但我们使用静态 HashMap 并在其中存储属性。

如果全是字符串：

private static Map data = new HashMap();

可以公开作为属性，以便您可以在任何地方使用它。

public class Props{

private static Map<String, String> data = new HashMap<String, String> ();

public static void put(String name, String val){
    data.put(name,val);
}

public static String  get(String name){
    return data.get(name)
}

public static  void load(){//todo }


public static  void save(){//todo if needed if few change and need persistence}

}

除了基本数据类型之外，针对任何数据类型。

public class Props{

private static Map<String, Object> data = new HashMap<String, Object> ();

public static void put(String name, Object val){
    data.put(name,val);
}

public static String  get(String name){
    return data.get(name)
}

public static void load(){//todo }


public static void save(){//todo if needed if few change and need persistence}

}

如果您希望在一段时间后丢弃对象，可以使用WhirlyCache而不是HashMap。我看不出有什么问题？

- tgkprog

Answer 2

我扩展了DatabaseConfiguration，这样就不会一直访问我的数据库。 至于重新加载，我在需要时实例化配置，并在完成后将其丢弃。

public class MyConfig extends DatabaseConfiguration {

    private WeakHashMap<String,Object> cache = new WeakHashMap<String,Object>();

    public MyConfig(String datasourceString,String section) throws NamingException {
        this((DataSource) new InitialContext().lookup(datasourceString),section);
    }

    protected MyConfig(DataSource datasource,String section) {
        super(datasource, "COMMON_CONFIG","PROP_SECTION", "PROP_KEY", "PROP_VALUE",section);
    }

    @Override
    public Object getProperty(String key){
        Object cachedValue = cache.get(key);
        if (cachedValue != null){
            return cachedValue;
        }
        Object databaseValue = super.getProperty(key);
        cache.put(key, databaseValue);
        return databaseValue;

    }
}

- rjdkolb

Answer 3

最终，我编写了自己的缓存，使用了Guava：

public class Cfg {
    private static Logger log = LoggerFactory.getLogger(Cfg.class);
    private Configuration cfg;
    private LoadingCache<String, Boolean> boolCache;
    private LoadingCache<String, String> stringCache;
    private LoadingCache<String, Float> floatCache;
    private LoadingCache<String, Integer> integerCache;
    private LoadingCache<String, List> listCache;

    @PostConstruct
    public void init() {
        boolCache = CacheBuilder.newBuilder().expireAfterAccess(cfg.getInt("configuration.cache"), TimeUnit.MINUTES).build(new CacheLoader<String, Boolean>() {
            @Override
            public Boolean load(String key) throws Exception {
                return check(cfg.getBoolean(key), key);
            }
        });
        stringCache = CacheBuilder.newBuilder().expireAfterAccess(cfg.getInt("configuration.cache"), TimeUnit.MINUTES).build(new CacheLoader<String, String>() {
            @Override
            public String load(String key) throws Exception {
                return check(cfg.getString(key), key);
            }
        });
        floatCache = CacheBuilder.newBuilder().expireAfterAccess(cfg.getInt("configuration.cache"), TimeUnit.MINUTES).build(new CacheLoader<String, Float>() {
            @Override
            public Float load(String key) throws Exception {
                return check(cfg.getFloat(key), key);
            }
        });
        integerCache = CacheBuilder.newBuilder().expireAfterAccess(cfg.getInt("configuration.cache"), TimeUnit.MINUTES).build(new CacheLoader<String, Integer>() {
            @Override
            public Integer load(String key) throws Exception {
                return check(cfg.getInt(key), key);
            }
        });
        listCache = CacheBuilder.newBuilder().expireAfterAccess(cfg.getInt("configuration.cache"), TimeUnit.MINUTES).build(new CacheLoader<String, List>() {
            @Override
            public List load(String key) throws Exception {
                return check(cfg.getList(key), key);
            }
        });
    }

    public boolean _bool(String key) {
        try {
            return boolCache.get(key);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }
    }

    public float _float(String key) {
        try {
            return floatCache.get(key);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }
    }

    public int _int(String key) {
        try {
            return integerCache.get(key);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }
    }

    public String _string(String key) {
        try {
            return stringCache.get(key);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }
    }

    public List<String> _list(String key) {
        try {
            //noinspection unchecked
            return listCache.get(key);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }
    }

    public void setCfg(Configuration cfg) {
        this.cfg = cfg;
    }

    private <T> T check(T el, String key) {
        if (el != null) {
            return el;
        }
        throw new KeyNotFound(key);
    }
}

- Alexey Kutuzov