redis与spring的完全集成

下载spring-data-redis，gav如下：

                <dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>1.0.1.RELEASE</version>
    <exclusions>
        <exclusion>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </exclusion>
        <exclusion>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
        </exclusion>
    </exclusions>

</dependency>

其中exclusion了两个包，原因是与项目里其它包冲突。

bean配置如下，可在web.xml里配置加载bean文件：

<bean id="redisCacheManager" class="com.cr.common.cache.base.RedisCacheManger">
    <property name="pool" ref="shardedJedisPool"/>
</bean>
<!-- jedis 连接池配置-->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
    <property name="maxActive"     value="${redis.pool.maxActive}" />
    <property name="maxIdle"       value="${redis.pool.maxIdle}" />
    <property name="maxWait"       value="${redis.pool.maxWait}" />
    <property name="testOnBorrow"  value="${redis.pool.testOnBorrow}" />
</bean>
<!-- jedis 多个服务器配置-->
<bean id="jedisShardInfo1" class="redis.clients.jedis.JedisShardInfo">
    <constructor-arg index="0" value="${redis2.ip}" />
    <constructor-arg index="1" value="${redis.port}" type="int" />
</bean>

<bean id="jedisShardInfo2" class="redis.clients.jedis.JedisShardInfo">
    <constructor-arg index="0" value="${redis.ip}" />
    <constructor-arg index="1" value="${redis.port}" type="int" />
</bean>

<bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool">
    <constructor-arg index="0" ref="jedisPoolConfig" />
    <constructor-arg index="1">
        <list>
            <ref bean="jedisShardInfo1" />
            <ref bean="jedisShardInfo2"/>
        </list>
    </constructor-arg>
</bean>

<bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
    >
    <property name="hostName"   value="${redis.ip}" />
    <property name="port"       value="${redis.port}" />
    <property name="poolConfig" ref="jedisPoolConfig" />

    <!--<property name="shardInfo"  ref="shardedJedisPool"></property>-->
</bean>

<context:property-placeholder  location="/WEB-INF/spring/SystemContext.properties"/>
<context:component-scan base-package="org.springframework.data.redis.samples"/>

 

属性文件内容如下：

redis.ip=192.168.1.110
redis2.ip=192.168.1.112
#Port
redis.port=6379

#最大分配的对象数
redis.pool.maxActive=1024
#最大能够保持idel状态的对象数
redis.pool.maxIdle=200
#当池内没有返回对象时，最大等待时间
redis.pool.maxWait=1000
#当调用borrow Object方法时，是否进行有效性检查
redis.pool.testOnBorrow=true
#当调用return Object方法时，是否进行有效性检查
redis.pool.testOnReturn=true

缓存管理接口：

public interface RedisCache {

    public <T> T getRedisCacheInfo(String key);

    public <T> boolean setRedisCacheInfo(String key, T value);

}

缓存管理实现：

public class RedisCacheManger implements RedisCache {

    private ShardedJedisPool pool ;

    private Logger log = Logger.getLogger(RedisCacheManger.class);
    public ShardedJedisPool getPool() {
        return pool;
    }

    public void setPool(ShardedJedisPool pool) {
        this.pool = pool;
    }

    public <T> T getRedisCacheInfo(String key) {

        try {
            log.info("get from redisCache :"+key);
            System.out.println("get from rediscache");
            ShardedJedis jedis = pool.getResource();
            pool.returnResource(jedis);
            return (T)jedis.get(key);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


    public <T> boolean setRedisCacheInfo(String key, T value) {

        try {
            log.info("add to redisCache :"+key);
            System.out.println("add to rediscache");
            ShardedJedis jedis = pool.getResource();
            jedis.set(key, (String)value);
            pool.returnResource(jedis);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }
    public static void main(String[] args) {
        new RedisCacheManger().setRedisCacheInfo("12345", "asdfg");
    }
}

缓存切面注解：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface NeedRedisCached {}

缓存切面处理类：

@Aspect
public class RedisCacheAspect implements Ordered {

    private static Logger log = Logger.getLogger(RedisCacheAspect.class);
    private RedisCache redisCacheManager;
    private int orderValue = 3;
    public RedisCache getRedisCacheManager() {
        return redisCacheManager;
    }

    public void setRedisCacheManager(RedisCache redisCacheManager) {
        this.redisCacheManager = redisCacheManager;
    }

    @Pointcut("@annotation(com.jd.bi.odp.common.cache.core.NeedRedisCached)")
    public void needRedisCached() {

    }

    @Around("needRedisCached() && args(filter,..)")
    public Object aroundInvoke(ProceedingJoinPoint pjp, QueryFilter filter) throws Throwable {
        log.info("enter aroundInvoke!!!");
        if (filter.getValue() == null) {
            return null;
        }

        boolean cacheEnabled = CommonUtil.parseBoolean(HBaseConfig.getProperty("redisCache.enabled"), false);

        if (cacheEnabled) {

            String md5key = MD5Util.getMD5(filter.getValue().toString());
            Object value = redisCacheManager.getRedisCacheInfo(md5key);
            boolean flag = false;
            if (null != value) {

                JSONObject json = new JSONObject(value.toString());
                return json;
            } else if ("null".equals(value)) {
                return null;
            } else { //执行hbase查询
                value = pjp.proceed();
                if(null!=value){//此处根据业务逻辑判断不缓存的条件
                    }
                    else{
                        flag = redisCacheManager.setRedisCacheInfo(md5key, value.toString());

                        if(flag)
                            log.info("add a cache success by key: "+md5key);
                        else
                            log.warn("add a cache failure by key: "+md5key);
                    }
                }
                return value;
            }
        } else {// 执行hbase查询
            return pjp.proceed();
        }
    }
    @Override
    public int getOrder() {
        return orderValue;
    }
    public int getOrderValue() {
        return orderValue;
    }

    public void setOrderValue(int orderValue) {
        this.orderValue = orderValue;
    }
}

缓存存在直接返回，不存在的话执行数据源查询，此处是hbase查询，并设置缓存。

 

切面配置：

<!-- redis缓存运行切面 -->
<bean id="RedisCacheAspect"
    class="com.cr.common.cache.core.RedisCacheAspect">
    <property name="orderValue" value="3" />
    <property name="redisCacheManager" ref="redisCacheManager"/>
</bean>
<!-- 切面申明配置-->
<aop:aspectj-autoproxy>
    <aop:include name="RedisCacheAspect" />
</aop:aspectj-autoproxy>

此时，前端web页面用户的访问触发的action如果满足条件，则会进入切面方法处理，完成redis缓存的使用。

http://blog.csdn.net/cuirong1986/article/details/8213159?utm_source=tuicool&utm_medium=referral