java-classic-code/java-commons-cache/CacheFactory.java

package com.yiidata.intergration.web.modules.sys.cache;

import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.util.Optional;
import java.util.Properties;

/**
 * <pre>
 *
 * Created by zhaopx.
 * User: zhaopx
 * Date: 2019/11/14
 * Time: 14:22
 *
 * </pre>
 *
 * @author zhaopx
 */
@Component("cache")
public class CacheFactory implements FactoryBean, InitializingBean, DisposableBean {

    /**
     * logger
     */
    private static Logger logger = LoggerFactory.getLogger(CacheFactory.class);


    @Value("${cache.type: mem}")
    String type;


    @Value("${cache.redis.database: 0}")
    int redisDb;


    @Value("${cache.redis.host: localhost}")
    String redisHost;


    @Value("${cache.redis.port: 6379}")
    int redisPort;

    /**
     * 配置
     */
    private Properties config;


    /**
     * Cache
     */
    private ICache cache;


    public CacheFactory() {
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        config = new Properties();
        config.setProperty("type", Optional.ofNullable(StringUtils.trimToNull(type)).orElse("mem"));
        config.setProperty("host", redisHost);
        config.setProperty("port", ""+redisPort);
        config.setProperty("db", ""+redisDb);

        String cacheType = config.getProperty("type", "ehcache");
        if(StringUtils.isBlank(cacheType) || "mem".equalsIgnoreCase(cacheType) ||
                "ehcache".equalsIgnoreCase(cacheType)) {
            logger.info("use ehcache.");
            this.cache = initEhcache();
        } else if("redis".equalsIgnoreCase(cacheType)) {
            String host = this.config.getProperty("host");
            if(StringUtils.isBlank(host)) {
                throw new IllegalArgumentException("redis cache host must not be blank.");
            }
            int port = Integer.parseInt(this.config.getProperty("port", "3306"));
            int db = Integer.parseInt(this.config.getProperty("db", "0"));
            logger.info("use redis cache {}:{}/{}", host, port, db);
            this.cache = initRedisCache(host, port, db);
        } else {
            throw new IllegalArgumentException("unknown cache type " + cacheType);
        }
    }


    /**
     * 初始化 Redis 客户端
     * @param host
     * @param port
     * @param db
     * @return
     */
    private ICache initRedisCache(String host, int port, int db) {
        return new Redised(host, port, db);
    }

    /**
     * 初始化 EHCache 客户端
     * @return
     */
    private ICache initEhcache() {
        return new Ehcache();
    }

    @Override
    public Object getObject() throws Exception {
        return cache;
    }

    @Override
    public Class getObjectType() {
        return ICache.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }

    @Override
    public void destroy() throws Exception {
        cache.shutdown();
    }
}