习课的redis配置记录

<!-- redis begin -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
        </dependency>
        <!-- rabbitmq end -->

spring

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       ">

    <!-- 注入redis依赖服务器信息 -->
    <context:property-placeholder location="classpath:jedis.properties,classpath:system-db.properties,classpath:dev.properties" />

    <!-- spring 自动扫描组件 -->
    <context:component-scan base-package="com.xk.ses" />
    <bean class="com.xk.lang.redis.RedisOperate">
        <constructor-arg ref="shardedJedisPoolService"></constructor-arg>
    </bean>

    <import resource="spring-mvc.xml" />
    <import resource="spring-aop.xml" />
    <import resource="spring-mybatis.xml" />
    <import resource="spring-context-redis.xml" />
    <import resource="email.xml"/>
</beans>

spring-context-redis.xml

<?xml version="1.0" encoding= "UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:p="http://www.springframework.org/schema/p" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd ">

    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="${redis.maxIdle}" />
        <!-- <property name="maxActive" value="${redis.maxActive}" /> <property
            name="maxWait" value="${redis.maxWait}" /> -->
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />
        <property name="testOnReturn" value="${redis.testOnReturn}" />
    </bean>

    <bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool">
        <constructor-arg index="0" ref="poolConfig"></constructor-arg>
        <constructor-arg index="1">
            <list>
                <bean class="redis.clients.jedis.JedisShardInfo">
                    <constructor-arg index="0" value="${redis.host}"></constructor-arg>
                    <property name="password" value="${redis.pass}"></property>
                    <!-- <constructor-arg index="1" value="${redis.port}" type="int"></constructor-arg> -->
                </bean>

                <!-- 多台服务器时使用 <bean class="redis.clients.jedis.JedisShardInfo"> <constructor-arg
                    index="0" value="${redis.host}"></constructor-arg> <constructor-arg index="1"
                    value="${redis.port}" type="int"></constructor-arg> </bean> -->
            </list>
        </constructor-arg>
    </bean>

    <bean id="shardedJedisPoolService" class="com.xk.lang.redis.ShardedJedisPoolServiceImpl">
        <property name="shardedJedisPool" ref="shardedJedisPool"></property>
    </bean>

</beans>

读取的配置文件

#redis server
redis.host=http://192.168.2.88:6379/1
redis.port=6379
redis.pass=qqq111
redis.timeout=3000

redis.maxIdle=300
redis.maxActive=600
redis.maxWait=1000
redis.testOnBorrow=true
redis.testOnReturn=true

java类

package com.xk.lang.redis;

public final class RedisKeyConstant {

    public static final String LOGIN_USER_PERFIX = "XKY_";

    public static final String PROVINCE_KEY = "province";  //城市

    public static final String AMS_WHETHER_KEY = "ams_whether";// 学校类型

    public static final String NATION_KEY = "nation";// 国家/地区

    public static final String NATIONALITY_KEY = "nationality";// 民族

    public static final String UMS_SCHOOLTYPE_KEY = "ums_schoolType";// 学校类型

    public static final String UMS_RUNSCHOOLTYPE_KEY = "ums_runSchoolType";// 办学类型

    public static final String UMS_USERTYPE_KEY = "ums_userType";// 用户类型

    public static final String UMS_ROLETYPE_KEY = "ums_roleType";// 角色类型

    public static final String UMS_ORGTYPE_KEY = "ums_orgType";// 组织类型

    public static final String UMS_GROUPTYPE_KEY = "ums_groupType";// 用户组类型

    public static final String OAS_INFOMESSAGE_KEY = "oas_infoMessage";// 信息类型

    public static final String OAS_SCHEDULEMESSAGE_KEY = "oas_scheduleMessage";// 日程类型

    public static final String OAS_LEAVEMESSAGE_KEY = "oas_leaveMessage";// 请假类型

    public static final String SMS_STATE_KEY = "sms_state";// 状态

    public static final String SMS_VOUCHERTYPE_KEY = "sms_voucherType";// 学生档案管理-基础信息,证件类型

    public static final String SMS_SEX_KEY = "sms_sex";// 性别

    public static final String SMS_NATIVEPLACE_KEY = "sms_nativePlace";// 籍贯

    public static final String SMS_CHINESEOUTSIDE_KEY = "sms_chineseOutside";// 港澳台侨外

    public static final String SMS_POLITICSSTATUS_KEY = "sms_politicsStatus";// 政治面貌

    public static final String SMS_HEALTHSTATUS_KEY = "sms_healthStatus";// 健康状况

    public static final String SMS_CATEGORY_KEY = "sms_category";// 户口性质

    public static final String SMS_BLOOD_KEY = "sms_blood";// 血型

    public static final String SMS_RELIGION_KEY = "sms_religion";// 宗教信仰

    public static final String SMS_STUDENTTYPE_KEY = "sms_studentType";// 学生类别

    public static final String SMS_WAYSOFENROLL_KEY = "sms_waysOfEnroll";// 入学方式

    public static final String SMS_STUDENTSOURCE_KEY = "sms_studentSource";// 学生来源

    public static final String SMS_READMODE_KEY = "sms_readMode";// 就读方式

    public static final String SMS_DISABLEDTYPE_KEY = "sms_disabledType";// 残疾人类型

    public static final String SMS_CHILDSCHOOLTYPE_KEY = "sms_childSchoolType";// 上下学方式

    // public static final String SMS_VOUCHERTYPE_KEY =
    // "sms_voucherType";//学生档案管理-家庭成员,证件类型

    public static final String SMS_BUSINESSTYPE_KEY = "sms_businessType";// 从业状况

    public static final String SMS_EDUCATION_KEY = "sms_education";// 学历

    public static final String SMS_FAMILYTYPE_KEY = "sms_familyType";// 家庭类别

    public static final String SMS_DIFFICULTYREASON_KEY = "sms_difficultyReason";// 困难原因

    public static final String SMS_DIFFICULTYDEGREE_KEY = "sms_difficultyDegree";// 困难程度

    public static final String SMS_UNUSUALCODE_KEY = "sms_unusualCode";// 异常类别码

    public static final String SMS_EXAMINEWAY_KEY = "sms_examineWay";// 考试方式码

    public static final String SMS_AWARDLEVECODE_KEY = "sms_awardLeveCode";// 奖励级别码

    public static final String SMS_AWARDGRADECODE_KEY = "sms_awardGradeCode";// 奖励等级码

    public static final String SMS_AWARDCODE_KEY = "sms_awardCode";// 获奖类别码

    public static final String SMS_BONUSCODE_KEY = "sms_bonusCode";// 奖励类型码

    public static final String SMS_BONUSMETHODS_KEY = "sms_bonusMethods";// 奖励方式码

    public static final String SMS_DISPOSALNAME_KEY = "sms_disposalName";// 处分名称码

    public static final String SMS_TRANSACTIONLEVE_KEY = "sms_transactionLeve";// 异动类别

    public static final String SMS_TRANSACTIONREASON_KEY = "sms_transactionReason";// 异动原因

    public static final String SMS_GRADUATETO_KEY = "sms_graduateTo";// 毕业去向

    public static final String TMS_COURSEMANAGE_KEY = "tms_courseManage";// 教育部基础课程

    public static final String TMS_SCHOOLYEAR_KEY = "tms_schoolYear";// 学年

    public static final String TMS_TRIMESTER_KEY = "tms_trimester";// 学期

    public static final String TMS_CLASSQUALITY_KEY = "tms_classQuality";// 班级性质

    public static final String TMS_WISH_KEY = "tms_wish";// 志愿

    public static final String TMS_FEATURES_KEY = "tms_features";// 特长

    public static final String AMS_JOBTITLE_KEY = "ams_jobTitle";// 职称

    public static final String AMS_COMPILETYPE_KEY = "ams_compileType";// 编制类型

    public static final String AMS_MARIAGESTATE_KEY = "ams_mariageState";// 婚姻状况

    public static final String AMS_LEAMINGSTYLES_KEY = "ams_leamingStyles";// 学习方式

    public static final String AMS_USESTATE_KEY = "ams_useState";// 使用状况

    public static final String AMS_STRUCTURESORT_KEY = "ams_structureSort";// 建筑物分类

    public static final String AMS_STRUCTUREFLAT_KEY = "ams_structureFlat";// 建筑物结构

    public static final String AMS_FFUNDSOURCE_KEY = "ams_fFundSource";// 经费来源

    public static final String AMS_SEISMICSTRENGTH_KEY = "ams_seismicStrength";// 抗震设防烈度

    public static final String AMS_SEISMICNORM_KEY = "ams_seismicNorm";// 抗震设防标准

    public static final String AMS_STRUCTURESTATE_KEY = "ams_structureState";// 建筑物状况

    public static final String AMS_STRUCTUREUSE_KEY = "ams_structureUse";// 建筑物用途

    public static final String AMS_STRUCTUREUSE_TEACH_KEY = "ams_structureUse_teach";// 建筑物用途

    public static final String AMS_STRUCTUREUSE_LIVE_KEY = "ams_structureUse_live";// 生活用房

    public static final String AMS_STRUCTUREUSE_AMS_KEY = "ams_structureUse_ams";// 行政办公用房

    public static final String AMS_STRUCTUREUSE_OTHER_KEY = "ams_structureUse_other";// 其他

    public static final String AMS_HEATINGWAY_KEY = "ams_heatingWay";// 供暖方式

    public static final String AMS_STRUCTUREBASETYPE_KEY = "ams_structureBaseType";// 建筑物基础形式

    public static final String AMS_STRUCTUREFLATTYPE_KEY = "ams_structureFlatType";// 建筑物平面形式

    public static final String AMS_STRUCTUREFLOORTYPE_KEY = "ams_structureFloorType";// 建筑物楼板形式

    public static final String AMS_NATIONALNAME_KEY = "ams_nationalName";// *专项投资补助名称

    public static final String AMS_STRUCTURELEVE_KEY = "ams_structureLeve";// 文物建筑等级

    public static final String AMS_CLASSTYPE_KEY = "ams_classType";// 教室类型

    public static final String AMS_CLASSUSESTATUS_KEY = "ams_classUseStatus";// 教室占用情况（用途）

    public static final String OAS_LEAVETYPE_KEY = "oas_leaveMessage";// 请假类型

    //public static final String OAS_APPROVAL_KEY = "oas_approval";// 审批状态, 这个没有了

}

package com.xk.lang.redis;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;

import org.apache.commons.lang3.StringUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import com.alibaba.fastjson.JSON;
import com.xk.cbs.ums.user.po.UserInfo;

/**
 *
 * @author lsm
 *
 */

public class RedisOperate {

    private ShardedJedisPoolService shardedJedisPoolService;

    private UserInfo user;

    private final static String name = "userToken";

    public UserInfo getUser() {
        ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = servletRequestAttributes.getRequest();
        String userToken = null;
        if (request != null) {
            // System.out.println(request.getSession().getId());
            Cookie[] cookies = request.getCookies();
            if (null != cookies && cookies.length > 0) {
                for (Cookie cookie : cookies) {
                    // System.out.println(cookie.getValue()+"---"+cookie.getName());
                    if (cookie.getName().equals(name))
                        userToken = cookie.getValue();
                }
            }
        }
        setUser(userToken);
        return user;
    }

    private void setUser(String userToken) {
        if (StringUtils.isNotBlank(userToken) && shardedJedisPoolService != null) {
            String value = shardedJedisPoolService.get(RedisKeyConstant.LOGIN_USER_PERFIX + userToken);
            this.user = JSON.parseObject(value,UserInfo.class);
            /*ShardedJedis shardedJedis = null;
            try {
                shardedJedis = shardedJedisPoolService.getResource();
                String value = shardedJedis.get(RedisKeyConstant.LOGIN_USER_PERFIX + userToken);
                this.user = JSON.parseObject(value,UserInfo.class);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (shardedJedis != null){
                    shardedJedis.close();
                }
            }*/
        }
    }

    public RedisOperate(ShardedJedisPoolService shardedJedisPoolService) {
        this.shardedJedisPoolService = shardedJedisPoolService;
    }
    /**
     * public UserInfo getUserInfo() { String userToken =
     * request.getParameter("userToken") + ""; ShardedJedis shardedJedis =
     * shardedJedisPoolService.getResource(); String userInfoString =
     * shardedJedis.get(userToken); UserInfo userInfo =
     * JSON.parseObject(userInfoString, UserInfo.class); shardedJedis.close();
     * return userInfo; }
     **/
}

package com.xk.lang.redis;

import java.util.Collection;
import java.util.Map;

import redis.clients.jedis.Jedis;

public interface ShardedJedisPoolService {

    //ShardedJedis getResource();

    boolean ping();

    boolean isConnect();

    /**
     * 根据key获取map类型值
     * @param key
     * @return
     */
    Map<String, String> hgetAll(String key);

    /**
     * 根据key获取String类型值
     * @param key
     * @return
     */
    String get(String key);

    /**
     * 判断key是否存在
     * @param key
     * @return
     */
    Boolean exists(String key);

    /**
     * 设置String类型值
     * @param key
     * @param value
     * @return
     */
    String set(String key, String value);

    /**
     * 获取所有的分片
     * @return
     */
    Collection<Jedis> getAllShards();

    /**
     * 根据key与field获取String类型
     * @param key
     * @param field
     * @return
     */
    String hget(String key, String field);

    /**
     * 设置String听类型值
     * @param key
     * @param field
     * @param value
     * @return
     */
    Long hset(String key, String field, String value);

    /**
     * 删除值
     * @param key
     * @param fields
     * @return
     */
    Long hdel(String key, String... fields);

    /**
     * 设置String类型值，设置超时时间
     * @param key
     * @param seconds
     * @param value
     * @return
     */
    String setex(String key, int seconds, String value);
}

package com.xk.lang.redis;

import java.util.Collection;
import java.util.Map;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;

public class ShardedJedisPoolServiceImpl implements ShardedJedisPoolService {

    private ShardedJedisPool shardedJedisPool;

    private ShardedJedis getResource() {
        return getShardedJedisPool().getResource();
    }

    @Override
    public boolean ping() {
        ShardedJedis shardedJedis = this.getResource();
        for (Jedis jedis : shardedJedis.getAllShards()) {
            if (!"PONG".equals(jedis.ping())) {
                return false;
            }
        }
        return true;
    }

    public void setShardedJedisPool(ShardedJedisPool shardedJedisPool) {
        this.shardedJedisPool = shardedJedisPool;
    }

    public ShardedJedisPool getShardedJedisPool() {
        if (shardedJedisPool == null) {
            throw new NullPointerException("shardedJedisPool must not be null.");
        }
        return shardedJedisPool;
    }

    public boolean isConnect() {
        boolean isExists = false;
        if (shardedJedisPool != null) {
            ShardedJedis shardedJedis = null;
            try {
                shardedJedis = this.getResource();
                boolean isPong = true;
                for (Jedis jedis : shardedJedis.getAllShards()) {
                    if (!"PONG".equals(jedis.ping())) {
                        isPong = false;
                        break;
                    }
                }
                if (isPong)
                    isExists = true;
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (shardedJedis != null)
                    shardedJedis.close();
            }
        }
        return isExists;
    }

    @Override
    public Map<String, String> hgetAll(String key) {
        ShardedJedis shardedJedis = null;
        try {
            shardedJedis = this.getResource();
            Map<String, String> map = shardedJedis.hgetAll(key);
            return map;
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(null != shardedJedis){
                shardedJedis.close();
            }
        }
        return null;
    }

    @Override
    public String get(String key) {
        ShardedJedis shardedJedis = null;
        try {
            shardedJedis = this.getResource();
            String returnValue = shardedJedis.get(key);
            return returnValue;
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(null != shardedJedis){
                shardedJedis.close();
            }
        }
        return null;
    }

    @Override
    public Boolean exists(String key) {
        ShardedJedis shardedJedis = null;
        try {
            shardedJedis = this.getResource();
            Boolean returnValue = shardedJedis.exists(key);
            return returnValue;
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(null != shardedJedis){
                shardedJedis.close();
            }
        }
        return Boolean.FALSE;
    }

    @Override
    public String set(String key, String value) {
        ShardedJedis shardedJedis = null;
        try {
            shardedJedis = this.getResource();
            String returnValue = shardedJedis.set(key, value);
            return returnValue;
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(null != shardedJedis){
                shardedJedis.close();
            }
        }
        return null;
    }

    @Override
    public Collection<Jedis> getAllShards() {
        ShardedJedis shardedJedis = null;
        try{
            shardedJedis = this.getResource();
            Collection<Jedis> allShards = shardedJedis.getAllShards();
            return allShards;
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(null != shardedJedis){
                shardedJedis.close();
            }
        }
        return null;
    }

    @Override
    public String hget(String key, String field) {
        ShardedJedis shardedJedis = null;
        try {
            shardedJedis = this.getResource();
            String returnValue = shardedJedis.hget(key, field);
            return returnValue;
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(null != shardedJedis){
                shardedJedis.close();
            }
        }
        return null;
    }

    @Override
    public Long hset(String key, String field, String value) {
        ShardedJedis shardedJedis = null;
        try {
            shardedJedis = this.getResource();
            Long returnValue = shardedJedis.hset(key, field,value);
            return returnValue;
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(null != shardedJedis){
                shardedJedis.close();
            }
        }
        return null;
    }

    @Override
    public Long hdel(String key, String... fields) {
        ShardedJedis shardedJedis = null;
        try {
            shardedJedis = this.getResource();
            Long returnValue = shardedJedis.hdel(key, fields);
            return returnValue;
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(null != shardedJedis){
                shardedJedis.close();
            }
        }
        return null;
    }

    @Override
    public String setex(String key, int seconds, String value) {
        ShardedJedis shardedJedis = null;
        try {
            shardedJedis = this.getResource();
            String returnValue = shardedJedis.setex(key, seconds, value);
            return returnValue;
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(null != shardedJedis){
                shardedJedis.close();
            }
        }
        return null;
    }

}