import java.util.concurrent.ExecutionException;

import org.apache.http.client.utils.CloneUtils;
import org.springframework.beans.factory.InitializingBean;

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;


/**
 * 〈一句话功能简述〉<br>
 * guava内存缓存基类
 *
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public abstract class AbstractMemoryCache<PK, T> implements InitializingBean {

    private LoadingCache<PK, T> cache;

    protected abstract CacheBuilder<Object, Object> getCacheBuilder(CacheBuilder<Object, Object> cacheBuilder);

    protected abstract CacheLoader<PK, T> getCacheLoader();

    protected LoadingCache<PK, T> getCache() {
        return cache;
    }

    public T getValue(PK pk) throws Exception {
        try {
            return CloneUtils.cloneObject(this.cache.get(pk));
        } catch (CloneNotSupportedException | ExecutionException e) {
            throw new Exception(e);
        }
    }

    public void setValue(PK pk, T t) {
        this.cache.put(pk, t);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        CacheLoader<PK, T> cacheLoader = this.getCacheLoader();
        CacheBuilder<Object, Object> cacheBuilder = this.getCacheBuilder(CacheBuilder.newBuilder());
        this.cache = cacheBuilder.build(cacheLoader);
    }

}

package org.springframework.beans.factory;

/**
 * Interface to be implemented by beans that need to react once all their
 * properties have been set by a BeanFactory: for example, to perform custom
 * initialization, or merely to check that all mandatory properties have been set.
 *
 * <p>An alternative to implementing InitializingBean is specifying a custom
 * init-method, for example in an XML bean definition.
 * For a list of all bean lifecycle methods, see the BeanFactory javadocs.
 *
 * @author Rod Johnson
 * @see BeanNameAware
 * @see BeanFactoryAware
 * @see BeanFactory
 * @see org.springframework.beans.factory.support.RootBeanDefinition#getInitMethodName
 * @see org.springframework.context.ApplicationContextAware
 */
public interface InitializingBean {

    /**
     * Invoked by a BeanFactory after it has set all bean properties supplied
     * (and satisfied BeanFactoryAware and ApplicationContextAware).
     * <p>This method allows the bean instance to perform initialization only
     * possible when all bean properties have been set and to throw an
     * exception in the event of misconfiguration.
     * @throws Exception in the event of misconfiguration (such
     * as failure to set an essential property) or if initialization fails.
     */
    void afterPropertiesSet() throws Exception;

}

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;


import org.springframework.stereotype.Component;

/**
 * 〈一句话功能简述〉<br>
 * 〈缓存〉
 *
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 * @date 20190807
 */
@Component("tokenCache")
public class TokenCache extends AbstractMemoryCache<String, Map<String, Object>> {

    // 过期时间: 3小时
    private static final int EXPIRE_SEC_TIME = 3;

    // 最多保存的key的数量
    private static final int MAX_KEY_SIZE = 500;
·　　

　　·// 设置存储数量和过期时间
    @Override
    protected CacheBuilder<Object, Object> getCacheBuilder(CacheBuilder<Object, Object> cacheBuilder) {
        return cacheBuilder.maximumSize(MAX_KEY_SIZE).expireAfterWrite(EXPIRE_SEC_TIME, TimeUnit.HOURS);
    }

    @Override
    protected CacheLoader<String, Map<String, Object>> getCacheLoader() {
        return new CacheLoader<String, Map<String, Object>>() {

            @Override
            public Map<String, Object> load(String key) throws Exception {
                return new HashMap<>();
            }
        };
    }
    // 根据key获取token值
    public Object genToken(String key) throws Exception {
        
        return super.getValue(key).get(key);
    }

　　// 在guava中根据key缓存值
    public void setCache(String key,Object token) {
        Map<String, Object> tokenMap = new HashMap<>();
        tokenMap.put(key, token);
        super.setValue(key, tokenMap);
    }
}