缓存——redis和本地

OSCache:http://www.cnblogs.com/Irving/archive/2013/04/05/3000722.html

服务器缓存

使用redis
以下是个测试类，包含基本方法的使用，通过反射将对象与map的转化。

import org.junit.Test;
import redis.clients.jedis.Jedis;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.*;

public class TestRedis {

  private  static String address = "XXXX" ;
  private  static int port = XXXX;
  private Jedis j  = new Jedis(address) ;

  /**
     * 登录连接
     */
    public static Jedis getRedis(){
        Jedis jedis = new Jedis(address,port) ;
       // jedis.auth("XXXX");//认证密码
        return jedis ;
    }

    /**
     * 操作key的命令
     * del 删除；rename 重命名
     * dump 序列化；exits 是否存在;EXPIRE(key,seconds) 过期时间
     *
     */
    @Test
    public void testkey(){
        //添加和获取
         j.set("野草烧不尽","春风吹又生");
         j.rename("野草烧不尽","烧不尽");
         String value = j.get("烧不尽");
         System.out.println(value);
         j.dump("野草烧不尽");
    }

    /**
     * 操作值-字符串
     * set 添加（覆盖）键-值；get获取；strlen 获取长度
     * append 追加
     */
    @Test
    public void teststring(){
//        j.append("烧不尽","...");
//        System.out.println(j.strlen("烧不尽")+":"+j.get("烧不尽"));
        System.out.println(j.get("2"));
    }

    /**
     * 操作列表
     * rpush/lpush 从右/左添加
     * lrange 从列表中提取一个范围内的元素-1表示最后一个
     * llen 列表长度；
     */
    @Test
    public void testlist(){
        j.del("mlist");
        j.rpush("mlist","a","b","c");
        j.lpush("mlist","1","2");

      //  String s=  j.lindex("mlist",4);
        System.out.println(j.lrange("mlist",0,-1));
    }

    /**
     * 操作hash
     * hdel 删除；hexists 是否存在；
     * hget 获取某key下的field;hetAll 获取key下所有
     * hset 设置字段值
     */
    @Test
    public void testhash(){
        Map m = new HashMap();
        m.put("id","1");
        m.put("age","14");
        m.put("name","jack");
        j.hmset("user",m);

        System.out.println(j.hget("user","id"));
        System.out.println(j.hgetAll("user"));
    }

    /**
     * 操作集合 -无序set  -有序 zadd
     * sadd 添加；交并补；
     * 获取集合 smembers
     */
    @Test
    public void testset(){
        j.sadd("num","1","2","3","4","5");
        Set s = j.smembers("num");
        System.out.println(s);

    }

    /**
     * map转对象
     */
    public static Object mapToObject(Map<String, String> map, Class<?> beanClass) throws Exception {
        if (map == null || map.size()<=0)
            return null;

        Object obj = beanClass.newInstance();
        //获取关联的所有类，本类以及所有父类
        boolean ret = true;
        Class oo = obj.getClass();
        List<Class> clazzs = new ArrayList<Class>();
        while(ret){
            clazzs.add(oo);
            oo = oo.getSuperclass();
            if(oo == null || oo == Object.class)break;
        }

        for(int i=0;i<clazzs.size();i++){
            Field[] fields = clazzs.get(i).getDeclaredFields();
            for (Field field : fields) {
                int mod = field.getModifiers();
                if(Modifier.isStatic(mod) || Modifier.isFinal(mod)){
                    continue;
                }
                //由字符串转换回对象对应的类型
                if (field != null) {
                    field.setAccessible(true);
                    field.set(obj, map.get(field.getName()));
                }
            }
        }
        return obj;
    }

    /**
     * 对象转map
     */
    public static Map<String, Object> objectToMap(Object obj) throws Exception {
        if(obj == null){
            return null;
        }
        //获取关联的所有类，本类以及所有父类
        boolean ret = true;
        Class oo = obj.getClass();
        List<Class> clazzs = new ArrayList<Class>();
        while(ret){
            clazzs.add(oo);
            oo = oo.getSuperclass();
            if(oo == null || oo == Object.class)break;
        }

        Map<String, Object> map = new HashMap<String, Object>();

        for(int i=0;i<clazzs.size();i++){
            Field[] declaredFields = clazzs.get(i).getDeclaredFields();
            for (Field field : declaredFields) {
                int mod = field.getModifiers();
                //过滤 static 和 final 类型
                if(Modifier.isStatic(mod) || Modifier.isFinal(mod)){
                    continue;
                }
                field.setAccessible(true);
                map.put(field.getName(), field.get(obj));
            }
        }

        return map;
    }
}

本地缓存

public class CacheManager {

//一个本地的缓存Map

private Map localCacheStore =new HashMap();

//一个私有的对象，非懒汉模式

private static CacheManager cacheManager =new CacheManager();

//私有构造方法，外部不可以new一个对象

private CacheManager(){

}

//静态方法，外部获得实例对象

public static CacheManager getInstance(){

return cacheManager;

}

//获得缓存中的数据

public Object getValueByKey(String key){

return localCacheStore.get(key);

}

//向缓存中添加数据

public void putValue(String key ,Object value){

localCacheStore.put(key, value);

}

}