基於spring的cache基本配置與使用

spring的配置檔案：

<!-- redis配置 -->
<bean id="sysConfigJedisConnFactory"
        class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
        p:use-pool="true">
        <property name="poolConfig" ref="jedisPoolConfig" />
        <property
 
 name="hostName" value="${redis.machine.ip}" />
        <property name="port" value="${redis.machine.port}" />
    </bean>
    <bean id="sysConfigRedisTemplate" class="org.springframework.data.redis.core.RedisTemplate" p:connection-factory-ref="sysConfigJedisConnFactory" />

<!-- 配置使用快取 -->
 

    <bean
        class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean"
        id="com.leo.util.Constants.SYSCONFIG_CACHE_IN_REDIS" />
    <bean id="sysConfigCacheManager" class="org.springframework.cache.support.SimpleCacheManager">
        <property name="caches"
 
>
            <set>
            <!-- 自定義類(實現cache介面) -->
                <bean class="com.leo.system.cache.SysConfigSimpleRedisCache"
                    p:name-ref="com.leo.util.Constants.SYSCONFIG_CACHE_IN_REDIS" />
            </set>
        </property>
    </bean>

自定義一個類實現spring包下的cache介面，cache註解主要是根據相應的實現方法去執行相應的操作
比如@CacheEvict註解式會執行evict方法重新整理對應hashkey中的資料儲存

/*
 * Filename SimpleRedisCache.java
 * Company  上海韻達快運總部。
 * @author  zhangFeng
 * @version 1.0.0
 */
package com.leo.manage.system.cache;

import javax.annotation.Resource;

import org.apache.log4j.Logger;
import org.springframework.cache.Cache;
import org.springframework.cache.support.SimpleValueWrapper;
import org.springframework.data.redis.core.RedisTemplate;

import com.leo.util.Constants;

/**
 * 註解快取REDIS簡單實現。<br>
 * K-V方式快取
 *
 * @author leo
 * @since 1.0.0_2017年1月20日
 */
public class SysConfigSimpleRedisCache implements Cache {

    Logger logger = Logger.getLogger(getClass());

    @Resource(name="sysConfigRedisTemplate")
    private RedisTemplate<Object, Object> sysConfigRedisTemplate;
    private String name;
    private int expire = -1;
    private static final String CACHE_KEY = Constants.SYSCONFIG_CACHE_IN_REDIS;

    public SysConfigSimpleRedisCache() {}

    public SysConfigSimpleRedisCache(String name, int expire) {
        super();
        this.name = name;
        this.expire = expire;
    }

    public SysConfigSimpleRedisCache(String name) {
        super();
        this.name = name;
    }

    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public Object getNativeCache() {
        return null;
    }

    @Override
    public ValueWrapper get(final Object key) {
        long s = System.currentTimeMillis();
        Object object = null;
        if (key == null) {
            return null;
        }
        if(logger.isDebugEnabled()){
            logger.debug("get key: " + key);
        }
        try {
            object = sysConfigRedisTemplate.opsForHash().get(CACHE_KEY, key);
        } catch (Exception e) {
            // 此處異常無丟擲的途徑
            logger.warn("[SysConfigSimpleRedisCache.get ValueWrapper]操作異常", e);
        }
        if (logger.isInfoEnabled()) {
            logger.info(key + ">redis-get ValueWrapper 處理時間" + (System.currentTimeMillis() - s));
        }
        return object == null ? null : new SimpleValueWrapper(object);
    }

    @Override
    public void put(final Object key, final Object value) {
        try {
            if (value == null) {
                return;
            }
            if (expire > 0) {
                logger.warn("SysConfigSimpleRedisCache.put未實現[expire]！");
            } else {
                sysConfigRedisTemplate.opsForHash().put(CACHE_KEY, key, value);
            }
        } catch (Exception e) {
            // 此處異常無丟擲的途徑
            logger.warn("[put]操作異常", e);
        }
    }

    @Override
    public void evict(final Object key) {
        try {
            if (key == null) {
                return;
            }
            sysConfigRedisTemplate.opsForHash().delete(CACHE_KEY, key);
            if(logger.isDebugEnabled()) {
                logger.debug("SysConfigSimpleRedisCache evict successfully: " + key);
            }
        } catch (Exception e) {
            // 此處異常無丟擲的途徑
            logger.warn("[evict]操作異常", e);
        }

    }

    @Override
    public void clear() {
        try {
            sysConfigRedisTemplate.delete(getName());
            if(logger.isDebugEnabled()) {
                logger.debug("SysConfigSimpleRedisCache clear successfully");
            }
        } catch (Exception e) {
            // 此處異常無丟擲的途徑
            logger.warn("[clear]操作異常", e);
        }
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getExpire() {
        return expire;
    }

    public void setExpire(int expire) {
        this.expire = expire;
    }

    @SuppressWarnings("unchecked")
    @Override
    public <T> T get(final Object key, Class<T> type) {
        long s = System.currentTimeMillis();
        if (key == null) {
            return null;
        }
        Object object = null;
        try {
            object = sysConfigRedisTemplate.opsForHash().get(CACHE_KEY, key);
        } catch (Exception e) {
            // 此處異常無丟擲的途徑
            logger.warn("[SysConfigSimpleRedisCache.get <T>]操作異常", e);
        }
        if (logger.isInfoEnabled()) {
            logger.info(key + ">redis-get <T> 處理時間" + (System.currentTimeMillis() - s));
        }
        return object == null ? null : ((T) object);
    }

}

對應方法上通過註解操作：

package com.leo.system.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.leo.member.manage.system.dao.MBMNG_system_configDao;
import com.leo.member.manage.system.service.MBMNG_system_configCacheService;
import com.leo.util.Constants;

/**
 * 系統快取配置
 * @author leo
 * @since 3.5.6_2017年1月22日
 */
@Service(value = "configCacheService")
public class configCacheServiceImpl implements
        configCacheService {

    @Autowired
    private configDao dataDao;

    /**
     *  Cacheable註解，先從redis獲取資料，取不到在從資料庫獲取
     *  資料庫獲取之後把值放入redis中，對應的hashkey中的key通過key引數設定
     * 
     * 通過key獲取系統配置
     */
    @Cacheable(value = {Constants.SYSCONFIG_CACHE_IN_REDIS}, key = "'[email protected]'.concat(#sysCodeTxt != null? #sysCodeTxt : '')")
    @Override
    public String getSysValTxt(String sysCodeTxt) throws Exception {

        return dataDao.getSysValTxt(sysCodeTxt);
    }

    /**
     *  Cacheable註解，先從redis獲取資料，取不到在從資料庫獲取
     *  資料庫獲取之後把值放入redis中，對應的hashkey中的key通過key引數設定
     * 
     *  通過key獲取系統配置中json資料裡面jsonkey的值
     *  sysCodeTxt 系統配置key
     *  jsonKey 系統配置key對應的json資料裡面的jsonkey
     */
    @Cacheable(value = {Constants.SYSCONFIG_CACHE_IN_REDIS},key = "'[email protected]'.concat(#sysCodeTxt != null? #sysCodeTxt : '').concat('@').concat(#jsonKey != null? #jsonKey : '')")
    @Override
    public String getSysValTxtJsonkey(String sysCodeTxt, String jsonKey) throws Exception {
        String sysValTxt = dataDao.getSysValTxt(sysCodeTxt);
        JSONObject parseObject = JSON.parseObject(sysValTxt);
        return parseObject.getString(jsonKey);
    }

    /**
     * 修改資料 
     * 修改資料時，先執行程式碼體的操作，然後會根據hashkey(Constants.SYSCONFIG_CACHE_IN_REDIS)清除redis的值
     * allEntries 表示清除所有實體
     */
    @CacheEvict(value = { Constants.SYSCONFIG_CACHE_IN_REDIS }, allEntries = true)
    @Override
    public void updateData(configVO vo,
            RuntimeOperator operateInf) {
        // TODO
        configPO po = vo.toPO();
        Object[] keys = po.getKeys();
        configPO po0 = dataDao.getSingle(keys);
        if (po0 == null) {
            throw new ServiceException(ErrorCode.ERROR_RECORD_NOT_EXISTS);
        }

        po.setUpdate_time(Timestamp.valueOf(operateInf.getOperate_tm()));

        dataDao.update(po);

    }
}