redis在java中的使用

介绍：redis在开发中我们长用到，有单机模式，有集群模式，根据自己项目的规格去正确使用redis可以事半功倍，下面我会把我开发中积累到我认为好用的工具类和redis的使用方法分享给大家，看后不会找我

// 这是redis的枚举类，redis key和liveTime配置

/*
 * Copyright (C) 2020 Baidu, Inc. All Rights Reserved.
 */
package com.pactera.utlis;

import org.apache.commons.lang3.StringUtils;

/**
 * 公共Redis key和liveTime配置
 *
 * @author gyl
 */
public enum RedisConfEnum {

    /**
     * 检验缓存是否是初始化的，有这个值说明是初始化的，否则不是
     */
    INIT_CACHE_DEFAULT_KEY(-1),

    // 一个月
    KEY_0(10 * 60 * 24 * 30),

    // 一天
    KEY_1(60 * 60 * 24),

    // 缓存1小时
    KEY_2(60 * 60),

    // 30分钟缓存
    KEY_3(30 * 60),

    // 1分钟
    KEY_4(60),

    // 5分钟
    KEY_5(5 * 60),

    // 10分钟
    ORDER_SHARE_DONATION_COUNT(10 * 60);

    RedisConfEnum(
            long liveTime) {
        this.liveTime = liveTime;
    }

    /**
     * 有效时间,单位秒
     */
    private long liveTime;

    /**
     * 需要被反序列化的类型
     */
    private Class type;

    /**
     * redis key
     *
     * @param suffix
     * @return
     */
    public String getKey(String... suffix) {
        String tmpSuffix = "";
        if (suffix != null && suffix.length > 0) {
            for (String str : suffix) {
                if (StringUtils.isNotBlank(str)) {
                    tmpSuffix += "_" + str;
                }
            }
        }
        return REDIS_KEY_PREFIX_COMMON + this.name() + tmpSuffix;
    }

    private static final String REDIS_KEY_PREFIX_COMMON = "GONGYI_COMMON_";

    public long getLiveTime() {
        return liveTime;
    }
}

// redis工具类，仔细阅读里面的每个方法

package com.pactera.utlis;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.map.LinkedMap;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;

/**
 * redis 工具类
 */
@Component
public class RedisUtil {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    /**
     * 读取缓存
     *
     * @param key
     * @return
     */
    public String get(final String key) {
        String result = null;
        try {
            ValueOperations<String, String> operations = redisTemplate.opsForValue();
            result = operations.get(key);
        } catch (Exception e) {
            LoggerHelper.err(getClass(), "redis get error! key:{}, e:{}", key, e);
            e.printStackTrace();
        }

        return result;
    }

    /**
     * 写入缓存
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, String value) {
        boolean result = false;
        try {
            ValueOperations<String, String> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            LoggerHelper.err(getClass(), "redis set error! key:{}, value:{}, e:{}", key, value, e);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 写入缓存
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, String value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<String, String> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            // 负数过期时间则永不过期
            if (expireTime != null && expireTime > 0L) {
                redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            }
            result = true;
        } catch (Exception e) {
            LoggerHelper.err(getClass(), "redis set error! key:{}, value:{}, e:{}", key, value, e);
            e.printStackTrace();
        }
        return result;
    }

    /**
     * hset
     *
     * @param key
     * @param field
     * @param value
     * @return
     */
    public boolean hset(String key, String field, String value, long... expire) {
        boolean result = false;
        try {
            final byte[] rawKey = redisTemplate.getStringSerializer().serialize(key);
            final byte[] rawField = redisTemplate.getStringSerializer().serialize(field);
            final byte[] rawValue = redisTemplate.getStringSerializer().serialize(value);
            result = redisTemplate.execute(new RedisCallback<Boolean>() {
                public Boolean doInRedis(RedisConnection connection) {
                    boolean ret = connection.hSet(rawKey, rawField, rawValue);
                    if (expire.length > 0 && expire[0] > 0) {
                        connection.expire(rawKey, expire[0]);
                    }
                    return ret;
                }
            }, true);
        } catch (Exception ex) {
            LoggerHelper.err(getClass(), "hset error", ex);
        }
        return result;
    }

    /**
     * hget
     *
     * @param key
     * @param field
     * @return
     */
    public String hget(String key, String field) {
        final byte[] rawKey = redisTemplate.getStringSerializer().serialize(key);
        final byte[] rawField = redisTemplate.getStringSerializer().serialize(field);
        final byte[] rawValue = redisTemplate.execute(new RedisCallback<byte[]>() {
            public byte[] doInRedis(RedisConnection connection) {
                return connection.hGet(rawKey, rawField);
            }
        }, true);
        return redisTemplate.getStringSerializer().deserialize(rawValue);
    }

    /**
     * hgetAll
     *
     * @param key
     * @return
     */
    public Map<String, String> hgetAll(String key) {
        final byte[] rawKey = redisTemplate.getStringSerializer().serialize(key);
        final Map<byte[], byte[]> rawFieldValueMap = redisTemplate.execute(new RedisCallback<Map<byte[], byte[]>>() {
            public Map<byte[], byte[]> doInRedis(RedisConnection connection) {
                return connection.hGetAll(rawKey);
            }
        }, true);
        if (rawFieldValueMap == null) {
            return null;
        }
        Map<String, String> fieldValueMap = new LinkedMap<>();
        for (Entry<byte[], byte[]> entry : rawFieldValueMap.entrySet()) {
            fieldValueMap.put(redisTemplate.getStringSerializer().deserialize(entry.getKey()),
                    redisTemplate.getStringSerializer().deserialize(entry.getValue()));
        }
        return fieldValueMap;
    }

    /**
     * hIncr 原子自增
     *
     * @param key
     * @param field
     * @return
     */
    public Long hIncr(String key, String field, long... expire) {
        return hIncr(1L, key, field, expire);
    }

    /**
     * hIncr 原子自增
     *
     * @param key
     * @param field
     * @param delta 自增的量
     * @return
     */
    public Long hIncr(long delta, String key, String field, long... expire) {
        final byte[] rawKey = redisTemplate.getStringSerializer().serialize(key);
        final byte[] rawField = redisTemplate.getStringSerializer().serialize(field);
        return redisTemplate.execute(new RedisCallback<Long>() {
            public Long doInRedis(RedisConnection connection) {
                Long ret = connection.hIncrBy(rawKey, rawField, delta);
                if (expire.length > 0 && expire[0] > 0) {
                    connection.expire(rawKey, expire[0]);
                }
                return ret;
            }
        }, true);
    }

    /**
     * 批量删除对应的value
     *
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }

    /**
     * 批量删除key
     *
     * @param pattern
     */
    public void removePattern(final String pattern) {
        Set<String> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0) {
            redisTemplate.delete(keys);
        }
    }

    /**
     * 删除对应的value
     *
     * @param key
     */
    public void remove(final String key) {
        //TODO 需要判断这个key是否存在么?
        //        if (exists(key)) {
        redisTemplate.delete(key);
        //        }
    }

    /**
     * 判断缓存中是否有对应的value
     *
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 获取redis数据
     *
     * @param conf
     * @param clazz
     * @param getData
     * @param noCache
     * @return
     */
    public <T> T doRedisGet(RedisConfEnum conf, Class<T> clazz, GetData<T> getData, boolean... noCache) {
        return doRedisGet(conf, null, clazz, getData, noCache);
    }

    /**
     * 刷新redis数据
     *
     * @param conf
     * @param params
     * @param clazz
     * @param getData
     * @return
     */
    public <T> T doRefreshRedis(RedisConfEnum conf, String[] params, Class<T> clazz, GetData<T> getData) {
        T entity = getData.get();
        setObject2Cache(conf.getKey(params), conf.getLiveTime(), entity);
        return entity;
    }

    /**
     * 获取redis数据
     *
     * @param conf
     * @param params
     * @param clazz
     * @param getData
     * @param noCache
     * @return
     */
    public <T> T doRedisGet(RedisConfEnum conf, String[] params, Class<T> clazz, GetData<T> getData,
                            boolean... noCache) {
        if (noCache.length > 0 && noCache[0]) {
            return getData.get();
        }
        T entity = getObjectFromCache(conf.getKey(params), clazz);
        if (entity != null) {
            return entity;
        }
        entity = getData.get();
        setObject2Cache(conf.getKey(params), conf.getLiveTime(), entity);
        return entity;
    }

    /**
     * 获取redis数据
     *
     * @param conf
     * @param clazz
     * @param getListData
     * @return
     */
    public <T> List<T> doRedisGetList(RedisConfEnum conf, Class<T> clazz, GetListData<T> getListData) {
        return doRedisGetList(conf, null, clazz, getListData);
    }

    /**
     * 获取redis数据
     *
     * @param conf
     * @param params
     * @param clazz
     * @param getListData
     * @return
     */
    public <T> List<T> doRedisGetList(RedisConfEnum conf, String[] params, Class<T> clazz, GetListData<T> getListData) {
        List<T> list = getListFromCache(conf.getKey(params), clazz);
        if (CollectionUtils.isNotEmpty(list)) {
            return list;
        }
        list = getListData.get();
        setList2Cache(conf.getKey(params), conf.getLiveTime(), list);
        return list;
    }

    /**
     * 刷新redis数据
     *
     * @param conf
     * @param clazz
     * @param getListData
     * @return
     */
    public <T> List<T> doRefreshRedisList(RedisConfEnum conf, Class<T> clazz, GetListData<T> getListData) {
        return doRefreshRedisList(conf, null, clazz, getListData);
    }

    /**
     * 刷新redis数据
     *
     * @param conf
     * @param params
     * @param clazz
     * @param getListData
     * @return
     */
    public <T> List<T> doRefreshRedisList(RedisConfEnum conf, String[] params, Class<T> clazz,
                                          GetListData<T> getListData) {
        List<T> list = getListData.get();
        String key = conf.getKey(params);
        redisTemplate.delete(key);
        setList2Cache(key, conf.getLiveTime(), list);
        return list;
    }

    /**
     * 将列表保存到缓存
     *
     * @param key    缓存key
     * @param expire 缓存时间
     * @param data   列表数据
     */
    public <T> void setList2Cache(String key, long expire, List<T> data) {
        this.set(key, JSON.toJSONString(data), expire);
    }

    /**
     * 从缓存中获取列表
     *
     * @param key   缓存key
     * @param clazz
     * @return
     */
    public <T> List<T> getListFromCache(String key, Class<T> clazz) {
        List<T> data = new ArrayList<T>();
        String result = this.get(key);
        if (StringUtils.isBlank(result)) {
            return data;
        }
        data = getListByJsonStr(result, clazz);
        return data;
    }

    /**
     * 从缓存中获取列表
     *
     * @param jsonStr
     * @param clazz
     * @return
     */
    public <T> List<T> getListByJsonStr(String jsonStr, Class<T> clazz) {
        List<T> data = new ArrayList<T>();
        if (StringUtils.isBlank(jsonStr)) {
            return data;
        }
        try {
            JSONArray jsonArray = JSONArray.parseArray(jsonStr);
            if (jsonArray != null && jsonArray.size() > 0) {
                for (int i = 0; i < jsonArray.size(); i++) {
                    T elem = JSON.parseObject(jsonArray.get(i).toString(), clazz);
                    data.add(elem);
                }
            }
        } catch (Exception ex) {
            LoggerHelper.info(getClass(), "反序列化失败", ex);
        }

        return data;
    }

    /**
     * 将对象保存到缓存
     *
     * @param key    缓存key
     * @param expire 缓存时间
     * @param object 对象
     */
    public <T> void setObject2Cache(String key, long expire, T object) {
        this.set(key, JSON.toJSONString(object), expire);
    }

    /**
     * 从缓存中获取对象
     *
     * @param key   缓存key
     * @param clazz
     * @return
     */
    public <T> T getObjectFromCache(String key, Class<T> clazz) {
        String result = get(key);
        if (StringUtils.isBlank(result)) {
            return null;
        }
        T elem = null;
        try {
            elem = JSON.parseObject(result, clazz);
        } catch (Exception ex) {
            LoggerHelper.info(getClass(), "反序列化失败", ex);
        }
        return elem;
    }

    public interface GetData<T> {
        T get();
    }

    public interface GetListData<T> {
        List<T> get();
    }

    /**
     * 把一个对象缓存到hash中
     *
     * @param key
     * @param obj
     * @param expire
     * @return
     */
    public Boolean hsetObj(String key, Object obj, long expire) {
        HashMap parseObject = JSON.parseObject(JSON.toJSONString(obj), HashMap.class);
        Map<byte[], byte[]> byteMap = new HashMap<byte[], byte[]>();
        Set<Entry> entrySet = parseObject.entrySet();
        for (Entry entry : entrySet) {
            byte[] keyBytes = redisTemplate.getStringSerializer().serialize(entry.getKey().toString());
            byte[] valueBytes = redisTemplate.getStringSerializer().serialize(entry.getValue().toString());
            byteMap.put(keyBytes, valueBytes);
        }
        final byte[] rawKey = redisTemplate.getStringSerializer().serialize(key);
        return redisTemplate.execute(new RedisCallback<Boolean>() {
            public Boolean doInRedis(RedisConnection connection) {
                connection.hMSet(rawKey, byteMap);
                if (expire > 0) {
                    connection.expire(rawKey, expire);
                }
                return true;
            }
        }, true);
    }

    /**
     * 在一个hash中获得一个对象
     *
     * @param key
     * @param clazzType
     * @return
     */
    public <T> T hgetObj(String key, Class<T> clazzType) {
        final byte[] rawKey = redisTemplate.getStringSerializer().serialize(key);
        final Map<byte[], byte[]> byteMap = redisTemplate.execute(new RedisCallback<Map<byte[], byte[]>>() {
            public Map<byte[], byte[]> doInRedis(RedisConnection connection) {
                return connection.hGetAll(rawKey);
            }
        }, true);
        if (byteMap == null) {
            return null;
        }
        if (byteMap.isEmpty()) {
            return null;
        }
        Set<Entry<byte[], byte[]>> entrySet = byteMap.entrySet();
        Map<String, String> resMap = new HashMap<String, String>();
        for (Entry<byte[], byte[]> entry : entrySet) {
            String fKey = redisTemplate.getStringSerializer().deserialize(entry.getKey());
            String fValue = redisTemplate.getStringSerializer().deserialize(entry.getValue());
            resMap.put(fKey, fValue);
        }
        T t = null;
        try {
            t = JSON.parseObject(JSON.toJSONString(resMap), clazzType);
        } catch (Exception ex) {
            LoggerHelper.info(getClass(), "凡序列化失败", ex);
        }
        return t;
    }

    /**
     * hash原子递减
     *
     * @param key
     * @param field
     * @param expire
     */
    public void hDec(String key, String field, long expire) {
        hIncr(-1L, key, field, expire);
    }

    public <T> void rpush(String key, long expore, List<T> collection) {
        Collection<String> collect =
                collection.stream().map(item -> JsonUtils.ObjectToJson(item)).collect(Collectors.toList());
        redisTemplate.opsForList().rightPushAll(key, collect);
        if (expore > 0) {
            redisTemplate.expire(key, expore, TimeUnit.SECONDS);
        }
    }

    public void lpush(String key, long livetime, Object obj) {
        redisTemplate.opsForList().rightPush(key, JsonUtils.ObjectToJson(obj));
        expireKey(key, livetime);
    }

    public <T> List<T> lrange(String key, int start, int size, Class<T> clazz) {
        List<T> resultList = new ArrayList<>();
        //底层默认用的lrange,这一点需要注意
        try {
            List<String> rangeList = redisTemplate.opsForList().range(key, start, start + size);
            if (rangeList == null) {
                return resultList;
            }
            return rangeList.stream().map(jsonStr -> JsonUtils.fromJson(jsonStr, clazz))
                    .filter(temObj -> temObj != null)
                    .collect(Collectors.toList());
        } catch (Exception ex) {
            LoggerHelper.err(getClass(), "redis range error", ex);
            return resultList;
        }
    }

    public <T> List<T> rangeAll(String key, Class<T> clazz) {
        List<T> resultList = new ArrayList<>();
        //底层默认用的lrange,这一点需要注意
        try {
            List<String> rangeList = redisTemplate.opsForList().range(key, 0, -1);
            if (rangeList == null) {
                return resultList;
            }
            return rangeList.stream().map(jsonStr -> JsonUtils.fromJson(jsonStr, clazz))
                    .filter(temObj -> temObj != null)
                    .collect(Collectors.toList());
        } catch (Exception ex) {
            LoggerHelper.err(getClass(), "redis range error", ex);
            return resultList;
        }
    }

    public void zadd(String key, Object value, double score, long liveTime) {
        redisTemplate.opsForZSet().add(key, JsonUtils.ObjectToJson(value), score);
        expireKey(key, liveTime);
    }

    public <T> List<T> zrange(String key, int start, int size, Class<T> clazz) {
        Set<String> range = redisTemplate.opsForZSet().range(key, start, start + size - 1);
        return range.stream().map(item -> JsonUtils.fromJson(item, clazz)).collect(Collectors.toList());
    }

    public <T> List<T> zreverseRange(String key, int start, int size, Class<T> clazz) {
        Set<String> range = redisTemplate.opsForZSet().reverseRange(key, start, start + size - 1);
        return range.stream().map(item -> JsonUtils.fromJson(item, clazz)).collect(Collectors.toList());
    }

    public void expireKey(String key, long livetime) {
        redisTemplate.expire(key, livetime, TimeUnit.SECONDS.SECONDS);
    }

    public long incr(String key) {
        return incr(key, 1);
    }

    public long incr(String key, long delta) {
        Long increment = redisTemplate.opsForValue().increment(key, delta);
        return increment;
    }

    public long incr(String key, long delta, long liveTime) {
        long incr = incr(key, delta);
        if (incr == 1) {
            expireKey(key, liveTime);
        }
        return incr;
    }

    public Set<String> keys(String pattern) {
        return redisTemplate.keys(pattern);
    }

    public void removeKes(Set<String> keys) {
        redisTemplate.delete(keys);
    }

}

// json格式化工具类，用来解析数据格式

package com.pactera.utlis;

import com.alibaba.fastjson.JSON;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public final class JsonUtils {

    private static ObjectMapper mapper = new ObjectMapper().disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);

    public static Map<?, ?> JsonToMap(String jsonString) {
        Map<?, ?> map = null;
        try {
            map = mapper.readValue(jsonString, Map.class);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return map;
    }

    public static String ObjectToJson(Object object) {
        String writeValueAsString = null;
        try {
            writeValueAsString = mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return writeValueAsString;
    }

    public <T> List<T> jsonToList(String jsonString, Class<T> clazz) {
        JavaType javaType = getCollectionType(ArrayList.class, clazz);
        List<T> readValue = null;
        try {
            readValue = mapper.readValue(jsonString, javaType);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return readValue;
    }

    public static final <T> T fromJson(String result, Class<T> clazz) {
        T elem = null;
        if (result == null) {
            return elem;
        }
        if ("".equals(result)) {
            return elem;
        }
        try {
            elem = JSON.parseObject(result, clazz);
        } catch (Exception ex) {
            LoggerHelper.info(JsonUtils.class, "反序列化失败", ex);
        }
        return elem;
    }

    public static <T> T jsonToClass(String jsonString, Class<T> clazz) {
        T readValue = null;
        try {
            readValue = mapper.readValue(jsonString, clazz);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return readValue;
    }

    public static JavaType getCollectionType(Class<?> collectionClass, Class<?>... elementClasses) {
        return mapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);
    }

}

以上就是组成我们在java开发中使用的所有关于redis相关的代码，下面我们要在实际开发中给大家演示如何使用redis，学会了记住收藏留言一起学习。

// 注入redis工具类
 @Autowired
    private RedisUtil redisUtil;


 /**
     * 缓存一个列表方法 带分页
     * 
     * @param dateType
     * @param pageBean
     * @return
     */
    public PageInfo<Map<String, Object>> getLoveList(Integer dateType, PageBean pageBean) {
        // TODO Auto-generated method stub
        // 得到缓存数据KEY
        String key = RedisConfEnum.GONGYI_LOVE_LIST.getKey(dateType + "" + "pageNo_" + pageBean.getPageNo(),
                "pageSize_" + pageBean.getPageSize());
        // 查询缓存
        PageInfo<Map<String, Object>> pageInfo = redisUtil.getObjectFromCache(key, PageInfo.class);
        if (pageInfo != null && !pageInfo.getList().isEmpty()) {
            return pageInfo;
        }
        PageHelper.startPage(pageBean.getPageNo(), pageBean.getPageSize(), true);
        // 查询出爱心榜数据
        List<Map<String, Object>> list = projectSupportDao.getLoveList(dateType);
        list.forEach(item -> {
            item.put("projectPicUrl", getPic((Long) item.get("proId")));
        });
        pageInfo = new PageInfo<>(list);
        // 放入缓存
        redisUtil.setObject2Cache(key, RedisConfEnum.GONGYI_LOVE_LIST.getLiveTime(), pageInfo);
        return pageInfo;
    }
 /**
     * 删除缓存
     */
    public void invalidIndexProjectCache() {
        // 首页按type查询list
        redisUtil.remove(new String[] { RedisConfEnum.PC_SEARCH_PROJECT.getKey("pageNo_" + 1, "type_" + 1),
                RedisConfEnum.PC_SEARCH_PROJECT.getKey("pageNo_" + 1, "type_" + 2),
                RedisConfEnum.PC_SEARCH_PROJECT.getKey("pageNo_" + 1, "type_" + 3),
                RedisConfEnum.PC_SEARCH_PROJECT.getKey("pageNo_" + 1, "type_" + 4),
                RedisConfEnum.PC_SEARCH_PROJECT.getKey("pageNo_" + 1, "type_" + 5),
                RedisConfEnum.PC_SEARCH_PROJECT.getKey("pageNo_" + 1, "type_" + 6),
                RedisConfEnum.PC_SEARCH_PROJECT.getKey("pageNo_" + 1, "type_" + -1),
                RedisConfEnum.GONGYI_PROJECT_FEIYAN.getKey("pageNo_" + 1, "_pageSize_" + 100),
                RedisConfEnum.GONGYI_DONTION_LIST.getKey(1 + "pageNo_" + 1, "_pageSize_" + 10),
                RedisConfEnum.GONGYI_DONTION_LIST.getKey(1 + "pageNo_" + 1, "_pageSize_" + 3) });
        // 首页index缓存
        redisUtil.remove(new String[] { "GONGYI_SOAINDEX_PROJECT_LSIT_DONATION_DISEASE_3",
                "GONGYI_SOAINDEX_PROJECT_LSIT_DONATION_HELP_THE_POOR_3",
                "GONGYI_SOAINDEX_PROJECT_LSIT_DONATION_STUDENT_3", "GONGYI_SOAINDEX_PROJECT_LSIT_DONATION_ECOLOGY_3",
                "GONGYI_SOAINDEX_PROJECT_LSIT_DONATION_OTHER_3" });

    }
   // 不带分页
 public List<Map<String, Object>> findInnerMenu() {
        // TODO Auto-generated method stub
        String key = RedisConfEnum.DU_GONGYI_MENU.getKey();
        // 从缓存中查询数据
        List<Map<String, Object>> convertPageToMap = redisUtil.getObjectFromCache(key, List.class);
        if (convertPageToMap != null) {
            return convertPageToMap;
        }
        // 查询年份 （相当与父节点 ，最外一层数据）
        List<Map<String, Object>> list = gongyiNewInnerMapper.selectByYear();
        for (Map<String, Object> mapYear : list) {
            String year = mapYear.get("year").toString();
            // 查询月刊 （相当于父节点下的子节点）
            List<Map<String, Object>> listMonth = gongyiNewInnerMapper.selectByMonth(year);
            for (Map<String, Object> mapMonth : listMonth) {
                String month = mapMonth.get("month").toString();
                // 月刊下单分类数据（最内层的对象，一个月刊下可以拥有多个分类数据）
                List<Map<String, Object>> listLabel = gongyiNewInnerMapper.selectByLabel(month, year);
                mapMonth.put("label", listLabel);
            }
            mapYear.put("month", listMonth);

        }
        redisUtil.setObject2Cache(key, RedisConfEnum.DU_GONGYI_MENU.getLiveTime(), list);
        return list;
    }
  private long updateStatistics(long orgId, long delta, CommonField field) {
        String orgKey = getOrgStatisticKey(orgId);
        Long incCount = redisUtil.hIncr(delta, orgKey, field.getRedisField());
        Map<String, Object> params = new HashMap<String, Object>();
        params.put("field", field.getEntityField());
        params.put("fieldValue", delta);
        params.put("orgId", orgId);
        if (incCount == 1) {
            int updateCount = organizationStatisticsDao.updateStatistics(params);
            // 数据库中不存在
            if (updateCount < 1) {
                OrganizationStatistics record = new OrganizationStatistics();
                record.setOrgId(orgId);
                record.setPv(0L);
                record.setSupportTimes(0L);
                record.initTime();
                try {
                    organizationStatisticsDao.insert(record);
                    organizationStatisticsDao.updateStatistics(params);
                } catch (DuplicateKeyException e) {
                    // 并发冲突修改
                    organizationStatisticsDao.updateStatistics(params);
                }
            } else {
                // 数据库中存在-但是缓存已经失效了-要刷新缓存
                OrganizationStatistics findByOrgId = organizationStatisticsDao.findByOrgId(orgId);
                redisUtil.hsetObj(orgKey, findByOrgId, RedisConfEnum.ORGANIZATION_STATISTICS.getLiveTime());
                return Long.parseLong(redisUtil.hget(orgKey, field.getRedisField()));
            }
        } else {
            threadPoolService.execute(new Runnable() {
                @Override
                public void run() {
                    organizationStatisticsDao.updateStatistics(params);
                }
            });
        }
        return incCount;
    }