guava cache使用例子。。。注意在查询数据库时没有记录的情况，暂时获取CacheLoader.InvalidCacheLoadException异常，或者存放默认数据并标示NoDATA！@value注入static属性时注意要加到其非静态setter方法上即可！

GuavaCache及@Value使用例子.java

package com.uxin.starclock.manage.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.uxin.starclock.common.Constant;
import com.uxin.starclock.common.exception.BaseException;
import com.uxin.starclock.dto.IncallringDto;
import com.uxin.starclock.dto.IncallringWithAdsDto;
import com.uxin.starclock.entity.IncallringSetting;
import com.uxin.starclock.manage.IncallringService;
import com.uxin.starclock.manage.NoticeGoodsCenterService;
import com.uxin.starclock.persistence.mapper.IncallringMapper;
import com.uxin.starclock.persistence.mapper.IncallringSettingMapper;
import org.apache.commons.lang3.StringUtils;
import org.joda.time.DateTime;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

/**
 * @author: YANGLiiN
 * @time: 2015-11-29 11:20
 */
@Service
public class IncallringServiceImpl implements IncallringService {

    private static final Logger log = LoggerFactory.getLogger(IncallringServiceImpl.class);

    @Resource
    private IncallringMapper incallringMapper;
    @Resource
    private IncallringSettingMapper incallringSettingMapper;
    @Resource
    private NoticeGoodsCenterService noticeGoodsCenterService;

    // 广告列表
    @Value("#{'${custom.incallring.ads}'.split(',')}")
    private List<String> ads;

    @Value("${custom.incallring.defaultid}")
    private Long defaultid;

    // 静态属性只能用非静态set方法注入
    private static long listCacheTime = 10;
    private static long myCacheTime = 3;

    // 来电铃声缓存
    private static final Cache<String, Object> incallringCache = CacheBuilder.newBuilder()
                                                                             .expireAfterWrite(listCacheTime,
                                                                                               TimeUnit.MINUTES)
                                                                             .maximumSize(100)
                                                                             .build();

    // 我的来电铃声设置缓存
    private static final Cache<String, Object> myIncallringCache = CacheBuilder.newBuilder()
                                                                               .expireAfterWrite(myCacheTime,
                                                                                                 TimeUnit.HOURS)
                                                                               .maximumSize(10000)
                                                                               .build();

    @Override
    public IncallringWithAdsDto list(final Long uid) {

        List<IncallringDto> rings = null;
        IncallringSetting s = null;

        try {
            rings = (List<IncallringDto>) incallringCache.get("rings",
                                                              new Callable<List<IncallringDto>>() {
                                                                  @Override
                                                                  public List<IncallringDto> call()
                                                                          throws Exception {
                                                                      return incallringMapper.queryRings();
                                                                  }
                                                              });
        }
        catch (ExecutionException e) {
            log.error("**** 从guava cache查询来电铃声列表失败 ****", e);
            rings = incallringMapper.queryRings();
        }
        catch (CacheLoader.InvalidCacheLoadException e) {
            // 没有数据 Callable.call 返回null，忽略。。。
        }

        try {
            s = (IncallringSetting) myIncallringCache.get("myring:" + uid,
                                                          new Callable<IncallringSetting>() {
                                                              @Override
                                                              public IncallringSetting call()
                                                                      throws Exception {
                                                                  return incallringSettingMapper.getMySetting(uid);
                                                              }
                                                          });
        }
        catch (ExecutionException e) {
            log.error("**** 从guava cache查询我的来电铃声失败 ****", e);
            s = incallringSettingMapper.getMySetting(uid);
        }
        catch (CacheLoader.InvalidCacheLoadException e1) {
            // 没有数据 Callable.call 返回null，忽略。。。
        }

        Long usedRingid = defaultid;
        if (s != null) {
            usedRingid = s.getIncallringid();
        }

        for (IncallringDto i : rings) {
            if (usedRingid.compareTo(i.getId()) == 0) {
                i.setUsestatus(Constant.CUSTOM_RESOURCE_IN_USE);
            } else {
                i.setUsestatus(Constant.CUSTOM_RESOURCE_NOT_USE);
            }
        }

        IncallringWithAdsDto rs = new IncallringWithAdsDto();
        rs.setRings(rings);
        rs.setAds(ads);

        return rs;
    }

    @Override
    @Transactional
    public String save(Long uid, Long ringid) {

        // 查询用户是否能用该资源
        IncallringDto ring = incallringMapper.getById(ringid);
        if (ring == null || ring.getStatus() != 1) {
            throw new BaseException(Constant.ERROR_RESOURCE_NOT_EXIST, "该资源不存在或已下架");
        }

        boolean isVip = false;
        // 查询用户是否是会员
        String uc = noticeGoodsCenterService.buildQueryGoodsParams(uid);
        if (StringUtils.isNotBlank(uc)) {
            JSONObject o = JSON.parseObject(uc);
            if (o != null && o.getIntValue("result") == 0) {
                isVip = true;
            }
        }

        if (ring.getLevel() == Constant.CUSTOM_VIP && !isVip) {
            throw new BaseException(Constant.ERROR_RESOURCE_ONLY_CAN_USE_BY_VIP, "该资源只有会员才能使用");
        }

        incallringSettingMapper.deleteSetting(uid);

        DateTime dt = DateTime.now();
        String version = String.valueOf(dt.getMillis());

        IncallringSetting setting = new IncallringSetting();
        setting.setUid(uid);
        setting.setIncallringid(ringid);
        setting.setVersion(version);
        setting.setCreatetime(dt.toDate());
        incallringSettingMapper.insert(setting);

        // 删除该用户的缓存
        myIncallringCache.invalidate("myring:" + uid);

        return version;
    }

    @Override
    public IncallringDto getMySetting(Long uid) {
        IncallringDto ring = null;
        IncallringSetting s = incallringSettingMapper.getMySetting(uid);
        if (s != null) {
            ring = incallringMapper.getById(s.getIncallringid());
            if (ring != null) {
                ring.setUsestatus(Constant.CUSTOM_RESOURCE_IN_USE);
                ring.setVersion(s.getVersion());
            }

        } else {
            ring = incallringMapper.getById(defaultid);
            if (ring != null) {
                ring.setUsestatus(Constant.CUSTOM_RESOURCE_IN_USE);
                ring.setVersion(Constant.CUSTOM_DEFAULT_VERSION);
            }
        }

        return ring;

    }

    @Value("${custom.incallring.list.cache.minutes}")
    public void setListCacheTime(long listCacheTime) {
        IncallringServiceImpl.listCacheTime = listCacheTime;
    }

    @Value("${custom.incallring.my.cache.minutes}")
    public void setMyCacheTime(long myCacheTime) {
        IncallringServiceImpl.myCacheTime = myCacheTime;
    }

}