Java中的Redis应用

1、配置redis集群

 



<?xml version="1.0" encoding="UTF-8"?>  
<redisCluster>  
    <!--userRoute -->  
    <clusterGroup name="userRoute" selectdb="1">  
        <server host="10.177.129.16" port="6379"></server>  
        <server host="10.177.129.15" port="6379"></server>  
    </clusterGroup>  
    <!--sessionRoute -->  
    <clusterGroup name="sessionRoute" selectdb="2">  
        <server host="10.177.129.16" port="6379"></server>  
        <server host="10.177.129.15" port="6379"></server>  
    </clusterGroup>  
    <!--publicData -->  
    <clusterGroup name="publicData">  
        <server host="10.177.129.16" port="6379"></server>  
        <server host="10.177.129.15" port="6379"></server>  
    </clusterGroup>  
</redisCluster>

2、创建redis连接属性实体类

 



package net.itxm.cms.syscore.pojo;  
/**
 * redis连接属性
 *
 */ 
public class RedisCluster   
{  
    private String selectdb;  
    private String hostIp;  
    private String  port;  
    public String getSelectdb() {  
        return selectdb;  
    }  
    public void setSelectdb(String selectdb) {  
        this.selectdb = selectdb;  
    }  
    public String getHostIp() {  
        return hostIp;  
    }  
    public void setHostIp(String hostIp) {  
        this.hostIp = hostIp;  
    }  
    public String getPort() {  
        return port;  
    }  
    public void setPort(String port) {  
        this.port = port;  
    }  
}

3、解析redis集群配置

 



package net.itxm.itreasury.test.jedis;  
import java.io.IOException;  
import java.util.ArrayList;  
import java.util.HashMap;  
import java.util.Iterator;  
import java.util.List;  
import java.util.Map;  
import java.util.Set;  
import org.dom4j.Document;  
import org.dom4j.DocumentException;  
import org.dom4j.Element;  
import org.dom4j.io.SAXReader;  
import org.springframework.core.io.ClassPathResource;   
import org.springframework.core.io.Resource;   
import org.springframework.core.io.support.EncodedResource;  
/**
 * 解析redis集群配置
 *
 */ 
public class RedisConfig {  
public static Map<String,List<RedisCluster>> redisGroupMap = null;  
//有参构造函数  
public RedisConfig()  
{  
}  
//获取所有clusterGroup组的键值对  
public static Map<String,List<RedisCluster>> getRedisGroupMap(){  
    //读取xml文件  
    Document document=readXmlFile();  
    //获得clusterGroup节点的key 和 list  
    if(redisGroupMap == null)  
    {  
        redisGroupMap=getMapByItemsGroup(document);  
    }  
    return redisGroupMap;  
}  
//读取redisConfig配置文件  
private static Document readXmlFile(){  
    //创建读入对象  
    SAXReader reader = new SAXReader();  
    //创建document实例  
    Document doc=null;  
    try {  
    //从类路径下加载文件redisConfig.xml    
    Resource resource = new ClassPathResource("redisClusterConfig.xml");   
    //指定文件资源对应的编码格式（UTF-8),这样才能正确读取文件的内容，而不会出现乱码  
    EncodedResource encodeResource = new EncodedResource(resource,"UTF-8");   
    doc = reader.read(encodeResource.getReader());  
    }   
    catch (IOException e) {  
        System.out.println("无法读取系统配置文件redisConfig.xml,可能该文件不存在");  
    } catch (DocumentException e) {  
        System.out.println("解析redisConfig.xml文件出现异常");  
    }  
    return doc;  
}  
//读取xml节点,返回节点为redisGroup的Map  
private  static Map<String,List<RedisCluster>> getMapByItemsGroup(Document document){  
    Map<String,List<RedisCluster>> itemmap=new HashMap<String,List<RedisCluster>>();  
    try{  
        //获得根节点  
        Element root=document.getRootElement();  
        //获得根节点下所有子节点clusterGroup的list  
        List itemsList=root.selectNodes("./clusterGroup");  
        for(int i=0;i<itemsList.size();i++){  
        //获得节点Items  
        Element items=(Element)itemsList.get(i);  
        String groupName=items.attribute("name").getText();  
        String selectdb = items.attribute("selectdb")==null?"":items.attribute("selectdb").getText();  
//      if(groupName!=null&&groupName.equals(this.getGroupName())){  
             //获得clusterGroup下所有子节点service的list  
             List itemList=items.elements();  
             //获得service节点的值  
             List<RedisCluster> redisClusterList = getItemList(itemList,selectdb);  
             itemmap.put(groupName, redisClusterList);  
//      }  
        }  
    }  
    catch(Exception e){  
    }  
    return itemmap;  
}  
//获得所有Item下节点的redis服务节点  
private static List<RedisCluster> getItemList(List itemList,String selectdb){  
    List<RedisCluster> redisClusterList = new ArrayList<RedisCluster>();  
    for(int i=0;i<itemList.size();i++){  
        //获得节点server  
        Element item=(Element)itemList.get(i);  
        String hostIp =  item.attribute("host").getText();  
        String port = item.attribute("port").getText();  
        RedisCluster redisCluster =new RedisCluster();  
        redisCluster.setHostIp(hostIp);  
        redisCluster.setPort(port);  
        redisCluster.setSelectdb(selectdb);  
        redisClusterList.add(redisCluster);  
   }  
    return redisClusterList;  
}  
public static void main(String[] args) {  
    getRedisGroupMap();  
    //JedisUtil.insertPublicDataObject("user1", "张三", JedisUtil.ONLINE_USER);  
    //JedisUtil.insertPublicDataObject("user2", "李四", JedisUtil.ONLINE_USER);  
    //JedisUtil.insertPublicDataObject("user3", "王五", JedisUtil.ONLINE_USER);  
      Set s = JedisUtil.getAllSet(JedisUtil.ONLINE_USER);  
      Iterator it = s.iterator();      
      while (it.hasNext()) {  
       String key = (String) it.next();  
       String value = JedisUtil.getString(key,JedisUtil.ONLINE_USER);  
       System.out.println(key + value);  
      }  
    String test = JedisUtil.getString("user1",JedisUtil.ONLINE_USER);  
    System.out.println(test);  
}  
}

4、操作redis数据库的工具类

 



package net.itxm.cms.syscore.utils;  
import java.lang.reflect.Type;  
import java.util.List;  
import java.util.Set;  
import java.util.zip.CRC32;  
import redis.clients.jedis.Jedis;  
import redis.clients.jedis.exceptions.JedisConnectionException;  
import com.google.gson.Gson;  
import com.isoftstone.cms.syscore.pojo.RedisCluster;  
public class JedisUtil {  
    // 数据库  
    public static final String STORE_LOGINUSER = "4";// 商户登陆用户  
    public static final String STORE_INFO = "5";// 商户状态 商户购买服务有效期  
    public static final String CHECK_CODE = "6";// 验证码  
    public static final String MENU = "7";// 全部菜单  
    public static final String SERVICE = "8";// 服务收费信息  
    public static final String STORE_LOGINKEY = "9";// 初始化登录公钥 私钥对  
    // 固定key  
    public static final String ALL_MENU_KEY = "ALL_MENU_KEY";  
    public static final String BUY_SERVICE_KEY = "BUY_SERVICE_KEY";// 服务收费购买key  
    public static final String ALL_SERVICE_KEY = "ALL_SERVICE_KEY";//所有服务  
    public static final String MENU_AUTHORITY = "MENU_AUTHORITY";// 菜单权限  
    public static final String STORE_MENU_KEY = "STORE_MENU_KEY";// 需要商户分配的业务菜单  
    public static final String STORE_SERVICE_KEY = "STORE_SERVICE_KEY";// 商户收费key  
    public static final String SYSTE_MENU_KEY = "SYSTE_MENU_KEY";// 系统管理菜单key  
    // jedis服务组业务类型  
    public static final String CONT_CLUSTERNAME_PUBLICDATA = "publicData";  
    public static final String CONT_CLUSTERNAME_SESSIONROUTE = "sessionRoute";  
    public static final String CONT_CLUSTERNAME_USERROUTE = "userRoute";  
    // 操作方式 0 插入 1获取 2 删除  
    public static final long INSERT_OPERATION = 0;  
    public static final long GET_OPERATION = 1;  
    public static final long DELETE_OPERATION = 2;  
    // 验证码过期秒数  
    public static final int CHECKCODE_EXPIRESECONDS = 5*60;  
    // session过期秒数  
    public static final int EXPIRESECONDS = 30 * 60;  
    private static void closeJedis(Jedis jedis) {  
        try {  
            jedis.quit();  
        } catch (JedisConnectionException e) {  
            e.printStackTrace();  
        }  
        jedis.disconnect();  
    }  
    /**
     * 根据Key获取字符串
     *
     * @param key
     * @param jedisGroup
     */ 
    public static String getString(String key, String selectdb) {  
        Jedis jedis = getPublicDataJedis(key, GET_OPERATION, selectdb);  
        return jedis.get(key);  
    }  
    /**
     * 获取所有数据set
     * @param selectdb
     * @return
     */ 
    public static Set getAllSet(String selectdb) {  
        Jedis jedis = getDataJedis(GET_OPERATION, selectdb);  
        return jedis.keys("*");  
    }  
    /**
     * 默认取配置文件的第一个数据库
     * @param operation
     * @param selectdb
     * @return
     */ 
    private static Jedis getDataJedis(long operation, String selectdb) {  
        if (RedisConfig.redisGroupMap == null) {  
            RedisConfig.redisGroupMap = RedisConfig.getRedisGroupMap();  
        }  
        List<RedisCluster> clustersList = RedisConfig.redisGroupMap.get(CONT_CLUSTERNAME_PUBLICDATA);  
        int clusterNo = 0;//默认存到第一个  
        RedisCluster cluster = clustersList.get(clusterNo);  
        Jedis jedis = new Jedis(cluster.getHostIp(), Integer.valueOf(cluster.getPort()));  
        jedis.select(Integer.valueOf(selectdb));  
        return jedis;  
    }  
    /**
     * 删除数据
     *
     * @param key
     * @param jedisGroup
     */ 
    public static void deleteObject(String key, String jedisGroup) {  
        Jedis jedis = getJedis(key, jedisGroup, DELETE_OPERATION);  
        jedis.del(key);  
        closeJedis(jedis);  
    }  
    /**
     * 删除公共数据
     *
     * @param key
     * @param objClass
     * @param selectdb
     */ 
    public static void deletePublicDataObject(String key, String selectdb) {  
        Jedis jedis = getPublicDataJedis(key, DELETE_OPERATION, selectdb);  
        jedis.del(key);  
        closeJedis(jedis);  
    }  
    /**
     * 获取jedis的库实例
     *
     * @param key
     * @param jedisGroup
     * @param operation
     * @return
     */ 
    private static Jedis getJedis(String key, String jedisGroup, long operation) {  
        if (RedisConfig.redisGroupMap == null) {  
            RedisConfig.redisGroupMap = RedisConfig.getRedisGroupMap();  
        }  
        List<RedisCluster> clustersList = RedisConfig.redisGroupMap.get(jedisGroup);  
        int arrayLength = clustersList.size();  
        // 根据key值算出该信息应该存入到那个  
        int clusterNo = getRedisNo(key, arrayLength);  
        RedisCluster cluster = clustersList.get(clusterNo);  
        Jedis jedis = new Jedis(cluster.getHostIp(), Integer.valueOf(cluster.getPort()));  
        jedis.select(Integer.valueOf(cluster.getSelectdb()));  
        return jedis;  
    }  
    /**
     * redis key值获取对象
     *
     * @param key
     * @param objClass
     * @param jedisGroup
     * @return
     */ 
    public static Object getObject(String key, Class objClass, String jedisGroup) {  
        Jedis jedis = getJedis(key, jedisGroup, GET_OPERATION);  
        String sObj = jedis.get(key);  
        closeJedis(jedis);  
        Gson gson = new Gson();  
        return gson.fromJson(sObj, objClass);  
    }  
    /**
     * 获取公共数据jedis的库实例
     *
     * @param key
     * @param jedisGroup
     * @param operation
     * @return
     */ 
    private static Jedis getPublicDataJedis(String key, long operation, String selectdb) {  
        if (RedisConfig.redisGroupMap == null) {  
            RedisConfig.redisGroupMap = RedisConfig.getRedisGroupMap();  
        }  
        List<RedisCluster> clustersList = RedisConfig.redisGroupMap.get(CONT_CLUSTERNAME_PUBLICDATA);  
        int arrayLength = clustersList.size();  
        // 根据key值算出该信息应该存入到那个  
        int clusterNo = getRedisNo(key, arrayLength);  
        <a href="http://www.itxm.net/" target="_blank">RedisCluster </a>cluster = clustersList.get(clusterNo);  
        Jedis jedis = new Jedis(cluster.getHostIp(), Integer.valueOf(cluster.getPort()));  
        jedis.select(Integer.valueOf(selectdb));  
        return jedis;  
    }  
    /**
     * publicdata redis key值获取对象
     *
     * @param key
     * @param objClass
     * @param jedisGroup
     * @return
     */ 
    public static Object getPublicDataObject(String key, Class objClass, String selectdb) {  
        Jedis jedis = getPublicDataJedis(key, GET_OPERATION, selectdb);  
        String sObj = jedis.get(key);  
        closeJedis(jedis);  
        Gson gson = new Gson();  
        return gson.fromJson(sObj, objClass);  
    }  
    /**
     * publicdata redis key值获取对象 List<Entity>
     *
     * @param key
     * @param objClass
     * @param jedisGroup
     * @return
     */ 
    public static Object getPublicDataObjectByType(String key, Type type, String selectdb) {  
        Jedis jedis = getPublicDataJedis(key, GET_OPERATION, selectdb);  
        String sObj = jedis.get(key);  
        closeJedis(jedis);  
        Gson gson = new Gson();  
        return gson.fromJson(sObj, type);  
    }  
    /**
     * 获取redis服务器库编号
     *
     * @param hashKey
     * @return
     */ 
    public static int getRedisNo(String key, int arraySize) {  
        long hashKey = hash(key);  
        int redisNo = (int) (hashKey % arraySize);  
        return redisNo;  
    }  
    /**
     * 根据key值算出hash值
     *
     * @param k
     * @return
     */ 
    public static long hash(String k) {  
        CRC32 crc32 = new CRC32();  
        crc32.update(k.getBytes());  
        return crc32.getValue();  
    }  
    /**
     * redis 根据key值将对象插入到不同的库中
     *
     * @param key
     * @param insertObj
     * @param jedisGroup
     */ 
    public static void insertObject(String key, Object insertObj, String jedisGroup) {  
        Jedis jedis = getJedis(key, jedisGroup, INSERT_OPERATION);  
        Gson gson = new Gson();  
        jedis.set(key, gson.toJson(insertObj));  
        closeJedis(jedis);  
    }  
    /**
     * redis 根据key值将对象插入到不同的库中
     *
     * @param key
     * @param insertObj
     * @param jedisGroup
     * @param expire
     */ 
    public static void insertObject(String key, Object insertObj, String jedisGroup, int expireSeconds) {  
        Jedis jedis = getJedis(key, jedisGroup, INSERT_OPERATION);  
        Gson gson = new Gson();  
        jedis.setex(key, expireSeconds, gson.toJson(insertObj));  
        closeJedis(jedis);  
    }  
    /**
     * publicdata redis 根据key值将对象插入到不同的库中
     *
     * @param key
     * @param insertObj
     * @param jedisGroup
     */ 
    public static void insertPublicDataObject(<a href="http://www.itxm.net/" target="_blank">String </a>key, Object insertObj, String selectdb) {  
        Jedis jedis = getPublicDataJedis(key, INSERT_OPERATION, selectdb);  
        Gson gson = new Gson();  
        jedis.set(key, gson.toJson(insertObj));  
        closeJedis(jedis);  
    }  
    /**
     * publicdata redis 根据key值将对象插入到不同的库中,
     *
     * @param key
     * @param insertObj
     * @param jedisGroup
     * @param expireSeconds
     */ 
    public static void insertPublicDataObject(String key, Object insertObj, String selectdb, int expireSeconds) {  
        Jedis jedis = getPublicDataJedis(key, INSERT_OPERATION, selectdb);  
        Gson gson = new Gson();  
        jedis.setex(key, expireSeconds, gson.toJson(insertObj));  
        closeJedis(jedis);  
    }  
    /**
     * 更新redis中key的超时时间
     *
     * @param key
     * @param jedisGroup
     * @param expireSeconds
     */ 
    public static void resetExpireSeconds(String key, String jedisGroup, int expireSeconds) {  
        Jedis jedis = getJedis(key, jedisGroup, GET_OPERATION);  
        jedis.expire(key, expireSeconds);  
        closeJedis(jedis);  
    }  
}

5、所需jar包

相关阅读:
Wannafly挑战赛14 F.细胞
 D 勤奋的杨老师（二）（最小割）
三分算法求最值
 初识最大流
 初识数据结构
 决策型DP
哈希表
 【BZOJ】1878: [SDOI2009]HH的项链（主席树）
【HDU】1520 Anniversary party（树形dp）
【UVa】1606 Amphiphilic Carbon Molecules（计算几何）
原文地址：https://www.cnblogs.com/Jansens520/p/7825636.html