数据库信息缓存

浏览数：67 / 时间：2015年06月12日

　　提前将经常用到的数据库信息加载到缓存中，能极大的提升数据访问的效率。但这也带来数据同步的问题，所以很自然的就想设定一个时间间隔，数据过期后清空缓存，将数据库的信息重新加载到缓存中，但这个时间间隔很难把握。

　　下面可以看看可设定一个固定时间来更新缓存的例子，勉强可以使用，但是高并发时很容易出问题。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class LocalCache
{
    // 声明带时间标志的对象
    static class TimedValue
    {
        public long cacheTime;

        public Object value;

        public TimedValue(long cacheTime, Object value)
        {
            this.cacheTime = cacheTime;
            this.value = value;
        }

        public long getCacheTime()
        {
            return cacheTime;
        }

        public Object getValue()
        {
            return value;
        }
    }

    // 用Map进行缓存
    private static Map<String, TimedValue> cache = new HashMap<String, TimedValue>();
    private static final long VALID_TIME = 24 * 60 * 60 * 1000;
    // 类第一次使用时自动加载到缓存中
    static
    {
        loadData();
    }

    public Object get(String id)
    {
        TimedValue timedValue = cache.get(id);
        if (timedValue == null)
        {
            return null;
        }
        if (System.currentTimeMillis() - timedValue.getCacheTime() < VALID_TIME)
        {
            return timedValue.getValue();
        }
        else
        {
            loadData();
            return get(id);
        }
    }

    public static void loadData()
    {
        List<Product> products = getHotProductFromDB();
　　　　 cache.clear();
        for (Product product : products)
        {
            cache.put(product.getId(), new TimedValue(System.currentTimeMillis(), product));
        }
    }

    // 此处示意，表示从数据库中取出常用信息
    private static List<Product> getHotProductFromDB()
    {
        return new ArrayList<Product>();
    }
}

public class Product
{
    public String id;
    public String name;
    public double price;

    public String getId()
    {
        return id;
    }

    public String getName()
    {
        return name;
    }

    public double getPrice()
    {
        return price;
    }
}

　　比较好的实现是Google Guava 工具包中的缓存类com.google.common.cache.LocalCache，不仅可以设定失效时间，同时在数据失效后还可以实现异步进行缓存的刷新。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class LocalCache
{
   // 声明带时间标志的对象
   class TimedValue
   {
       public long cacheTime;

       public Object value;

       public TimedValue(long cacheTime, Object value)
       {
           this.cacheTime = cacheTime;
           this.value = value;
       }

       public long getCacheTime()
       {
           return cacheTime;
       }

       public Object getValue()
       {
           return value;
       }
   }

   private Map<String, TimedValue> cache = new HashMap<String, LocalCache.TimedValue>();
   private static final long VALID_TIME = 24 * 60 * 60 * 1000;

   public Object get(String id)
   {
       TimedValue timedValue = cache.get(id);
       if (timedValue != null && System.currentTimeMillis() - timedValue.getCacheTime() < VALID_TIME)
       {
           return timedValue.getValue();
       }
       else
       {
           loadData();
           return get(id);
       }
   }

   public void loadData()
   {
       List<Product> products = getHotProductFromDB();
       for (Product product : products)
       {
           cache.put(product.getId(), new TimedValue(System.currentTimeMillis(), product));
       }
   }

   // 此处示意，表示从数据库中取出常用信息
   private List<Product> getHotProductFromDB()
   {
       return new ArrayList<Product>();
   }
}