www.2527.com_澳门新葡8455手机版_新京葡娱乐场网址_
做最好的网站

合并申明,spring配置redis注脚缓存

2019-05-24 23:04 来源:未知

   伍比方因为连串化计谋不相同,可以区显式的设置  具体可参谋:

 

 

  • 四. RedisCacheConfig redis自定义的工具类,自定义redis的key生成规则

 

 
表 三. @CacheEvict 成效和布署方式

@CachEvict 的魔法 主要针对方法配置,能够根据早晚的规范对缓存举办清空

@CacheEvict 主要的参数
value 缓存的名称,在 spring 配置文件中定义,必须指定至少一个 例如:
@CachEvict(value=”mycache”) 或者 
@CachEvict(value={”cache1”,”cache2”}
key 缓存的 key,可以为空,如果指定要按照 SpEL 表达式编写,如果不指定,则缺省按照方法的所有参数进行组合 例如:
@CachEvict(value=”testcache”,key=”#userName”)
condition 缓存的条件,可以为空,使用 SpEL 编写,返回 true 或者 false,只有为 true 才清空缓存 例如:
@CachEvict(value=”testcache”,
condition=”#userName.length()>2”)
allEntries 是否清空所有缓存内容,缺省为 false,如果指定为 true,则方法调用后将立即清空所有缓存 例如:
@CachEvict(value=”testcache”,allEntries=true)
beforeInvocation 是否在方法执行前就清空,缺省为 false,如果指定为 true,则在方法还没有执行的时候就清空缓存,缺省情况下,如果方法执行抛出异常,则不会清空缓存 例如:
@CachEvict(value=”testcache”,beforeInvocation=true)

 

*************************************************************************************************************************************************************************************

*************************************************************************************************************************************************************************************

spEL表明式的利用方法:

关于申明完成Redis缓存的方法,唯有将key设计的合理且庞大,整个的缓存在项目中技术通用且快速。否则,就像是本人上边的简易的例子同样,真的是好笑了。

 

最直观的表现:第一回登入,会有一条数据库的查询语句在调控台。

表 1. @Cacheable 效率和计划格局

@Cacheable 的功能 首要针对方法配置,能够依照办法的伸手参数对其结果开始展览缓存

@Cacheable 主要的参数
value 缓存的名称,缓存中具体哪个数据库,在 spring 配置文件中定义,必须指定至少一个 例如:
@Cacheable(value=”mycache”) 或者 
@Cacheable(value={”cache1”,”cache2”}
key 缓存的 key,可以为空,如果指定要按照 SpEL 表达式编写,如果不指定,则缺省按照方法的所有参数进行组合,或者方法参数列表中的任意一个参数,或者字符串 参数组合

例如:
@Cacheable(value=”testcache”,key=”#userName”)

@Cacheable(value=”testcache”,key=” '字符串' #userName”)

condition 缓存的条件,可以为空,使用 SpEL 编写,返回 true 或者 false,只有为 true 才进行缓存 例如:
@Cacheable(value=”testcache”,condition=”#userName.length()>2”)

 

配置redis承继到spring管理项目,使用注明达成redis缓存功效。

 

*************************************************************************************************************************************************************************************

例如:

myUser是地点申明中的value,也正是缓存数据库名字叫myUser

  

所以我们可以对上面的自定义规则进行改造,将方法名和参数名进行隔开之后进行区分:(修改过的key的生成规则)

    public Object generate(Object o, Method method, Object... params) {
        //规定  本类名 方法名 参数名 为key
        StringBuilder sb = new StringBuilder();
        sb.append(o.getClass().getName());
        sb.append("-");
        sb.append(method.getName());
        sb.append("-");
        for (Object param : params) {
            sb.append(param.toString());
        }
        return sb.toString();
    }

RedisCacheManager        做为 redis 统壹的调整和老董

 

<!-- redis架包 -->
          <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.6.2.RELEASE</version>
          </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>

  一施用了@Cacheable(value="myUser"),即表示缓存中有,直接从缓存抽出,未有的话先从数据库中查出,然后再插入

说明:

 

参考:

  三》@CachePut   类似于革新操作,即每趟不管缓存中有未有结果,都从数据库查找结果,并将结果更新到缓存,并赶回结果

 

 

   贰 RedisTemplate默许采取的是JDK的连串化战略,保存的key和value都是运用此政策种类化保存的。JdkSerializationRedisSerializer

表 三. @CacheEvict 功用和陈设方式

@CachEvict 的职能 重要针对方法配置,能够基于早晚的准绳对缓存进行清空

@CacheEvict 主要的参数
value 缓存的名称,在 spring 配置文件中定义,必须指定至少一个 例如:
@CachEvict(value=”mycache”) 或者 
@CachEvict(value={”cache1”,”cache2”}
key 缓存的 key,可以为空,如果指定要按照 SpEL 表达式编写,如果不指定,则缺省按照方法的所有参数进行组合 例如:
@CachEvict(value=”testcache”,key=”#userName”)
condition 缓存的条件,可以为空,使用 SpEL 编写,返回 true 或者 false,只有为 true 才清空缓存 例如:
@CachEvict(value=”testcache”,
condition=”#userName.length()>2”)
allEntries 是否清空所有缓存内容,缺省为 false,如果指定为 true,则方法调用后将立即清空所有缓存 例如:
@CachEvict(value=”testcache”,allEntries=true)
beforeInvocation 是否在方法执行前就清空,缺省为 false,如果指定为 true,则在方法还没有执行的时候就清空缓存,缺省情况下,如果方法执行抛出异常,则不会清空缓存 例如:
@CachEvict(value=”testcache”,beforeInvocation=true)

 

*************************************************************************************************************************************************************************************

*************************************************************************************************************************************************************************************

spEL表明式的使用方法:

关于证明实现Redis缓存的格局,唯有将key设计的客体且壮大,整个的缓存在项目中技术通用且相当的慢。否则,就好像自身上边的回顾的例子同样,真的是滑稽了。

 

 

键名key为:xACxEDx00x05tx00Jcom.sxd.controller.WelcomeController_welcome_com.sxd.entity.User@36e69d03,

  引进jackson是为起先动增添缓存

键值对value值:xACxEDx00x05tx00x07success

 

*******************************************************************************************************************************************************************

 

spring-data-redis  项目,协作 spring 天性并集成 Jedis 的一对限令和章程。

 

   四在地点配置文件中,没有显式的付出序列化攻略,会有默许的连串化攻略。

上边的自定义的key规则是类      本类名 方法名 参数名(中间未有逗号区分),比方:

*******************************************************************************************************************************************************************

 

 

 

步骤:一.maven的pom.xml文件导入架包

 

1.maven的pom.xml文件导入架包【本来spring-data-redis架包版本选取最新的二.0.0 ,乃至选取到1.八.肆版本,只要保存,运营项目,spring管理的bean都会创制失利,架包争辨的来由大概别的标题,所以退而求其次,使用一.陆.二本子】

    图片 1

   四. RedisCacheConfig redis自定义的工具类,自定义redis的key生成规则

  2》@Cacheable  配置在艺术或类上,成效:本办法实行后,先去缓存看有未有数量,假使未有,从数据库中搜寻出来,给缓存中存壹份,重返结果,下次本办法实行,在缓存未过期境况下,先在缓存中找找,有的话一向再次回到,未有的话从数据库查找

 

 

5.在你想要做缓存的地点,使用申明实行缓存

 

图片 2

说明:

先介绍多少个注脚

  2假设未在类上应用@CacheConfig评释规定数额要缓存到哪些库中,就亟须给value三个值,规定数量最后缓存到哪个redis库中

   壹redis以键值对的款型储存缓存数据,而且会对目的开展体系化,如上海体育场面能够见到,键和值后边都有1串类别化的字符

    0.spring的主配置中证明注明缓存:<cache:annotation-driven cache-manager="redisCacheManager"/>

  2倘使未在类上选择@CacheConfig注脚规定数量要缓存到哪些库中,就必须给value四个值,规定数额最后缓存到哪个redis库中

  • 一.maven的pom.xml文件导入架包
 

 

   正是因为系列化攻略的不如,尽管是同三个key用不一样的Template去连串化,结果是例外的。所以依照key去删除数据的时候就出现了删除失利的标题。

RedisTemplate          RedisTemplate 对 RedisConnection 进行了打包。提供连接管理,种类化等功用,它对 Redis 的交互举行了越来越高等级次序的望梅止渴,非常大的有益和简化了 Redis 的操作

参考自:

解释:

  肆key-value的value正是本办法的再次来到值,假若要缓存登陆用户消息,本办法供给开始展览改造,再次来到user对象就能够缓存到key-value的value中

 

最直观的显现:第三遍登6,会有一条数据库的查询语句在调整台。

 

JedisPoolConfig           jedis连接池配置对象

JedisPoolConfig           jedis连接池配置对象

   3.spring管制bean的生成,xml文件配置

JedisConnectionFactory         jedis连接工厂,生成连接对象

<!-- redis 序列化策略 ,通常情况下key值采用String序列化策略, -->  
<!-- 如果不指定序列化策略,StringRedisTemplate的key和value都将采用String序列化策略; -->  
<!-- 但是RedisTemplate的key和value都将采用JDK序列化 这样就会出现采用不同template保存的数据不能用同一个template删除的问题 -->  
<bean id="stringRedisSerializer"   
    class="org.springframework.data.redis.serializer.StringRedisSerializer" />  

<bean id='redisWriteTemplate' class="org.springframework.data.redis.core.RedisTemplate">  
    <property name="connectionFactory" ref="jedisWriteConnectionFactory" />  
    <property name="keySerializer" ref="stringRedisSerializer" />  
    <property name="hashKeySerializer" ref="stringRedisSerializer" />  
</bean>

 

        StringRedisTemplate默许采取的是String的种类化攻略,保存的key和value都以选用此政策种类化保存的。StringRedisSerializer

Array2List.TestClassAndMethodAndParamfun1{2=ssssssssssssssssss, 1=ssssssssssssssssss}

四. RedisCacheConfig redis自定义的工具类,自定义redis的key生成规则

  • 0.spring的主配置中宣示证明缓存:<cache:annotation-driven cache-manager="redisCacheManager"/>

  肆》@CacheEvict 用来祛除用在本办法依旧类上的缓存数据(用在哪个地方清除哪个地方)

@CachePut 的效应 主要针对方法配置,能够依照办法的乞请参数对其结果开始展览缓存,和 @Cacheable 差异的是,它每一回都会接触真实方法的调用
@CachePut 主要的参数
value 缓存的名称,在 spring 配置文件中定义,必须指定至少一个 例如:
@Cacheable(value=”mycache”) 或者 
@Cacheable(value={”cache1”,”cache2”}
key 缓存的 key,可以为空,如果指定要按照 SpEL 表达式编写,如果不指定,则缺省按照方法的所有参数进行组合 例如:
@Cacheable(value=”testcache”,key=”#userName”)
condition 缓存的条件,可以为空,使用 SpEL 编写,返回 true 或者 false,只有为 true 才进行缓存 例如:
@Cacheable(value=”testcache”,condition=”#userName.length()>2”)
 

 

 

  继续访问       

   2.陈设文件添加配置

     删除缓存的时候删除钦赐的键,然后从内定的value加上~keys的zset中删去相应的值,达成删除1个缓存。

  三》@CachePut   类似于革新操作,即每一趟不管缓存中有未有结果,都从数据库查找结果,并将结果更新到缓存,并再次回到结果

  四》@CacheEvict 用来扫除用在本办法或然类上的缓存数据(用在哪里清除哪里)

  一》@CacheConfig  配置在类上,cacheNames即定义了本类中存有应用缓存的地点,都去找这一个库。只要接纳了那个注解,在措施上@Cacheable    @CachePut   @CacheEvict就足以不用写value去找具体库名了。【一般不怎么用】

 

       退出再登六,不会举行数据库的询问,直接从数据库中收取缓存,登入成功。

 

   3SD奥迪Q伍暗中认可接纳的类别化计策有二种,1种是String的种类化战术,一种是JDK的体系化战略。

 

package com.sxd.util;

import java.lang.reflect.Method;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;

@Configuration
@EnableCaching
public class RedisCacheConfig extends CachingConfigurerSupport {
     protected final static Logger log = LoggerFactory.getLogger(RedisCacheConfig.class);

        private volatile JedisConnectionFactory mJedisConnectionFactory;
        private volatile RedisTemplate<String, String> mRedisTemplate;
        private volatile RedisCacheManager mRedisCacheManager;

        public RedisCacheConfig() {
            super();
        }

        public RedisCacheConfig(JedisConnectionFactory mJedisConnectionFactory, RedisTemplate<String, String> mRedisTemplate, RedisCacheManager mRedisCacheManager) {
            super();
            this.mJedisConnectionFactory = mJedisConnectionFactory;
            this.mRedisTemplate = mRedisTemplate;
            this.mRedisCacheManager = mRedisCacheManager;
        }

        public JedisConnectionFactory redisConnectionFactory() {
            return mJedisConnectionFactory;
        }

        public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory cf) {
            return mRedisTemplate;
        }

        public CacheManager cacheManager(RedisTemplate<?, ?> redisTemplate) {
            return mRedisCacheManager;
        }



        @Bean
        public KeyGenerator keyGenerator() {
            return new KeyGenerator() {
                @Override
                public Object generate(Object target, Method method,
                        Object... params) {
                    //规定  本类名 方法名 参数名 为key
                    StringBuilder sb = new StringBuilder();
                    sb.append(target.getClass().getName() "_");
                    sb.append(method.getName() "_");
                    for (Object obj : params) {
                        sb.append(obj.toString() ",");
                    }
                    return sb.toString();
                }
            };
        }

}

  注意:此步骤必须做,必须注解采用的缓存处理器是协调配置的redisCacheManager,否则会报错。

表 贰. @CachePut 功效和布局格局

RedisCacheManager        做为 redis 统1的调节和主任

    <!-- **************************************************redis********************************************************** -->
    <!-- 配置 JedisPoolConfig 实例 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="${redis.maxIdle}"/>
        <property name="maxTotal" value="${redis.maxActive}"/>
        <property name="maxWaitMillis" value="${redis.maxWait}"/>
        <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
    </bean>

    <!-- 配置JedisConnectionFactory -->
    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="hostName" value="${redis.host}"/>
        <property name="port" value="${redis.port}"/>
        <property name="password" value="${redis.pass}"/>
        <property name="database" value="${redis.dbIndex}"/>
        <property name="poolConfig" ref="poolConfig"/>
    </bean>

    <!-- 配置RedisTemplate -->
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="jedisConnectionFactory"/>
    </bean>

    <!-- 配置RedisCacheManager -->
    <bean id="redisCacheManager" class="org.springframework.data.redis.cache.RedisCacheManager">
        <constructor-arg name="redisOperations" ref="redisTemplate"/>
        <property name="defaultExpiration" value="${redis.expiration}"/>
    </bean>

    <!-- 配置RedisCacheConfig -->
    <bean id="redisCacheConfig" class="com.sxd.util.RedisCacheConfig">
        <constructor-arg ref="jedisConnectionFactory"/>
        <constructor-arg ref="redisTemplate"/>
        <constructor-arg ref="redisCacheManager"/>
    </bean>

 

 

注意:

        RedisTemplate暗中认可选取的是JDK的种类化攻略,保存的key和value都以行使此政策种类化保存的。JdkSerializationRedisSerializer

  • 二.布署文件加多配置redis.properties

    #访问地址
    redis.host=127.0.0.1
    #访问端口
    redis.port=6379
    #注意,假使未有password,此处不设置值,但这一项要保存
    redis.password=

    #最大空闲数,数据库连接的最大空闲时间。当先空闲时间,数据库连接将被标志为不可用,然后被放飞。设为0意味着无界定。
    redis.maxIdle=300
    #连接池的最大数据库连接数。设为0象征无界定
    redis.maxActive=600
    #最大确立连接等待时间。即便超越此时间将接受非凡。设为-一象征无界定。
    redis.maxWait=1000
    #在borrow多少个jedis实例时,是或不是提前实行alidate操作;假若为true,则得到的jedis实例均是可用的;
    redis.testOnBorrow=true

  • 3.spring管制bean的浮动,xml文件配置   applicationContext-redis.xml

    xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd ">
    
    <!-- 连接池基本参数配置,类似数据库连接池 -->
    <context:property-placeholder location="classpath:redis.properties"
        ignore-unresolvable="true" />
    
    <!-- redis连接池 -->  
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxTotal" value="${redis.maxActive}" />
        <property name="maxIdle" value="${redis.maxIdle}" />
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />
    </bean>
    
    <!-- 连接池配置,类似数据库连接池 -->
    <bean id="jedisConnectionFactory"
        class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="hostName" value="${redis.host}"></property>
        <property name="port" value="${redis.port}"></property>
        <!-- <property name="password" value="${redis.pass}"></property> -->
        <property name="poolConfig" ref="poolConfig"></property>
    </bean>
    
    <!--redis操作模版,使用该对象可以操作redis  -->  
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" >    
        <property name="connectionFactory" ref="jedisConnectionFactory" />    
        <!--如果不配置Serializer,那么存储的时候缺省使用String,如果用User类型存储,那么会提示错误User can't cast to String!!  -->    
        <property name="keySerializer" >    
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />    
        </property>    
        <property name="valueSerializer" >    
            <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer" />    
        </property>    
        <property name="hashKeySerializer">    
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>    
        </property>    
        <property name="hashValueSerializer">    
            <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>    
        </property>    
        <!--开启事务  -->  
        <property name="enableTransactionSupport" value="true"></property>  
    </bean >   
    
#============================#
#==== Redis settings ====#
#============================#
#redis 服务器 IP
redis.host=127.0.0.1

#redis 服务器端口
redis.port=6379

#redis 密码
redis.pass=398023

#redis 支持16个数据库(相当于不同用户)可以使不同的应用程序数据彼此分开同时又存储在相同的实例上
redis.dbIndex=0

#redis 缓存数据过期时间单位秒
redis.expiration=3000

#控制一个 pool 最多有多少个状态为 idle 的jedis实例
redis.maxIdle=300

#控制一个 pool 可分配多少个jedis实例
redis.maxActive=600

#当borrow一个jedis实例时,最大的等待时间,如果超过等待时间,则直接抛出JedisConnectionException;
redis.maxWait=1000

#在borrow一个jedis实例时,是否提前进行alidate操作;如果为true,则得到的jedis实例均是可用的;
redis.testOnBorrow=true

  在redis做缓存的时候最棒是各样缓存的生命周期不固定,也正是散落的使缓存失效。能够安装限制期限为三-玖时辰。具体的做法正是在Java中生出2个三-玖钟头的随机数。

 

 

注意:

  在IDEA中结成的时候开选取注明配置Bean报错,因此将地点的KeyGenerator单独分红类,注入到Spring中并在cache标签中指明key生成器:

KeyGenerator.java

package cn.xm.jwxt.utils;

import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * @Author: qlq
 * @Description
 * @Date: 22:49 2018/3/25
 */
public class KeyGenerator implements org.springframework.cache.interceptor.KeyGenerator {
    @Override
    public Object generate(Object o, Method method, Object... params) {
        //规定  本类名 方法名 参数名 为key
        StringBuilder sb = new StringBuilder();
        sb.append(o.getClass().getName());
        sb.append(method.getName());
        for (Object param : params) {
            sb.append(param.toString());
        }
        return sb.toString();
    }
}

 

key的变迁规则也能够修改为:

    public Object generate(Object o, Method method, Object... params) {
        //规定  本类名 方法名 参数名 为key
        StringBuilder sb = new StringBuilder();
        sb.append(o.getClass().getName());
        sb.append("-");
        sb.append(method.getName());
        sb.append("-");
        for (Object param : params) {
            sb.append(param.toString());
        }
        return sb.toString();
    }

 

 

 

 

RedisCacheConfig.java

package cn.xm.jwxt.utils;

import java.lang.reflect.Method;

import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
/**
 * 注解redis缓存集成spring需要使用的配置类  java配置的方式注入bean到spring
 * @author liqiang
 *
 */
public class RedisCacheConfig extends CachingConfigurerSupport {
    private volatile JedisConnectionFactory jedisConnectionFactory;
    private volatile RedisTemplate<String, String> redisTemplate;
    private volatile RedisCacheManager redisCacheManager;

    public RedisCacheConfig() {
        super();
    }

    /**
     * 带参数的构造方法 初始化所有的成员变量
     * 
     * @param jedisConnectionFactory
     * @param redisTemplate
     * @param redisCacheManager
     */
    public RedisCacheConfig(JedisConnectionFactory jedisConnectionFactory, RedisTemplate<String, String> redisTemplate,
            RedisCacheManager redisCacheManager) {
        this.jedisConnectionFactory = jedisConnectionFactory;
        this.redisTemplate = redisTemplate;
        this.redisCacheManager = redisCacheManager;
    }

    public JedisConnectionFactory getJedisConnecionFactory() {
        return jedisConnectionFactory;
    }

    public RedisTemplate<String, String> getRedisTemplate() {
        return redisTemplate;
    }

    public RedisCacheManager getRedisCacheManager() {
        return redisCacheManager;
    }
}

 

applicationContext-redis.xml

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

    <cache:annotation-driven cache-manager="redisCacheManager" key-generator="keyGenerator"/>

    <!-- 连接池基本参数配置,类似数据库连接池 -->
    <context:property-placeholder location="classpath:redis.properties"
        ignore-unresolvable="true" />

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

    <!-- 连接池配置,类似数据库连接池 -->
    <bean id="jedisConnectionFactory"
        class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="hostName" value="${redis.host}"></property>
        <property name="port" value="${redis.port}"></property>
        <!-- <property name="password" value="${redis.pass}"></property> -->
        <property name="poolConfig" ref="poolConfig"></property>
    </bean>

    <!--redis操作模版,使用该对象可以操作redis  -->  
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" >    
        <property name="connectionFactory" ref="jedisConnectionFactory" />    
        <!--如果不配置Serializer,那么存储的时候缺省使用String,如果用User类型存储,那么会提示错误User can't cast to String!!  -->    
        <property name="keySerializer" >    
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />    
        </property>    
        <property name="valueSerializer" >    
            <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer" />    
        </property>    
        <property name="hashKeySerializer">    
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>    
        </property>    
        <property name="hashValueSerializer">    
            <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>    
        </property>    
        <!--开启事务  -->  
        <property name="enableTransactionSupport" value="true"></property>  
    </bean >


    <!-- 配置RedisCacheManager -->
    <bean id="redisCacheManager" class="org.springframework.data.redis.cache.RedisCacheManager">
        <constructor-arg name="redisOperations" ref="redisTemplate" />
        <property name="defaultExpiration" value="${redis.expiration}" />
    </bean>

    <!-- 配置RedisCacheConfig -->
    <bean id="redisCacheConfig" class="cn.xm.jwxt.utils.RedisCacheConfig">
        <constructor-arg ref="jedisConnectionFactory"/>
        <constructor-arg ref="redisTemplate"/>
        <constructor-arg ref="redisCacheManager"/>
    </bean>

    <!---->
    <bean id="keyGenerator" class="cn.xm.jwxt.utils.KeyGenerator"></bean>

    <!-- 下面这个是整合Mybatis的二级缓存使用的 -->
<!--    <bean id="redisCacheTransfer" class="cn.qlq.jedis.RedisCacheTransfer">
        <property name="jedisConnectionFactory" ref="jedisConnectionFactory" />
    </bean>-->

</beans>

 

 

 

 

 参考:

手动redis表明集成spring:

有关缓存注脚的更详尽的利用形式仿效:http://www.cnblogs.com/qlqwjy/p/8559119.html 

 

RedisCacheConfig         RedisCacheConfig extends org.springframework.cache.annotation.CachingConfigurerSupport,自定义redis的key生成规则,假如不在表明参数中证明key=“”的话,就应用这么些类中的key生成规则生成key

    函数表明下面的user加上~value作为二个zset存入缓存,值为现实的缓存的键:

JedisConnectionFactory         jedis连接工厂,生成连接对象

  壹》@CacheConfig  配置在类上,cacheNames即定义了本类中具有应用缓存的地方,都去找这一个库。只要利用了那一个注解,在艺术上@Cacheable    @CachePut   @CacheEvict就足以不用写value去找具体库名了。【一般不怎么用】

  二》@Cacheable  配置在章程或类上,功效:本办法推行后,先去缓存看有没有数据,借使未有,从数据库中探寻出来,给缓存中存1份,再次回到结果,后一次本办法试行,在缓存未过期情状下,先在缓存中搜寻,有的话一贯重临,未有的话从数据库查找

  明日在spring整合Redis的时候利用了手动的法子,也正是能够手动的向redis增添缓存与消除缓存,参照他事他说加以侦查:

终极交给那多少个阐明的切切实实参数以及接纳有关配图参谋。

  findUserById()函数将单个用户存入缓存中,比方访问:  后查看redis:

图片 3

Array2List.TestClassAndMethodAndParam-fun1-{2=ssssssssssssssssss, 1=ssssssssssssssssss}

二.配备文件增加配置

      一.maven的pom.xml文件导入架包

  一使用了@Cacheable(value="myUser"),即表示缓存中有,间接从缓存抽出,没有的话先从数据库中搜查捕获,然后再插入

例子:

 

  四key-value的value便是本办法的重返值,假诺要缓存登录用户消息,本办法须要张开改换,重回user对象就足以缓存到key-value的value中

   伍.在你想要做缓存的地点,使用注脚进行缓存

 

*************************************************************************************************************************************************************************************

 

 

表 一. @Cacheable 功用和铺排情势

@Cacheable 的功能 主要针对方法配置,能够基于章程的请求参数对其结果进行缓存

@Cacheable 主要的参数
value 缓存的名称,缓存中具体哪个数据库,在 spring 配置文件中定义,必须指定至少一个 例如:
@Cacheable(value=”mycache”) 或者 
@Cacheable(value={”cache1”,”cache2”}
key 缓存的 key,可以为空,如果指定要按照 SpEL 表达式编写,如果不指定,则缺省按照方法的所有参数进行组合,或者方法参数列表中的任意一个参数,或者字符串 参数组合

例如:
@Cacheable(value=”testcache”,key=”#userName”)

@Cacheable(value=”testcache”,key=” '字符串' #userName”)

condition 缓存的条件,可以为空,使用 SpEL 编写,返回 true 或者 false,只有为 true 才进行缓存 例如:
@Cacheable(value=”testcache”,condition=”#userName.length()>2”)

例子:

最后交给这多少个申明的具体参数以及选取相关配图参照他事他说加以考察。

三.spring管理bean的变动,xml文件配置

      选取Java配置的法子注入到spring

 

<cache:annotation-driven cache-manager="redisCacheManager"/>

  叁因为redis缓存数据实际上就是键值对的款型积攒,因而必须给定key-value的key,这里未有给key参数赋值,所以key的变型规则依据地方工具类中规定的key生成的

总结:

RedisTemplate          RedisTemplate 对 RedisConnection 举办了包装。提供连接管理,类别化等成效,它对 Redis 的交互实行了越来越高档期的顺序的悬空,十分大的便利和简化了 Redis 的操作

 Service加多缓存与删除缓存:

   

 

翻看一下这次缓存的数量,在redis可视化学工业具中

先介绍多少个表明

 

   二.计划文件加多配置

@CachePut 的功力 首要针对方法配置,能够依据办法的央浼参数对其结果开始展览缓存,和 @Cacheable 差异的是,它每一趟都会接触真实方法的调用
@CachePut 主要的参数
value 缓存的名称,在 spring 配置文件中定义,必须指定至少一个 例如:
@Cacheable(value=”mycache”) 或者 
@Cacheable(value={”cache1”,”cache2”}
key 缓存的 key,可以为空,如果指定要按照 SpEL 表达式编写,如果不指定,则缺省按照方法的所有参数进行组合 例如:
@Cacheable(value=”testcache”,key=”#userName”)
condition 缓存的条件,可以为空,使用 SpEL 编写,返回 true 或者 false,只有为 true 才进行缓存 例如:
@Cacheable(value=”testcache”,condition=”#userName.length()>2”)

 

@Cacheable(value="user",key="'user' #id.toString()")

 

图片 4

package cn.qlq.Action;

import java.sql.SQLException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.lang3.Validate;
import org.apache.struts2.ServletActionContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;

import com.github.pagehelper.PageHelper;
import com.opensymphony.xwork2.ActionSupport;

import cn.qlq.bean.User;
import cn.qlq.service.UserService;

@Controller
@Scope("prototype")
@SuppressWarnings("all")
public class UserAction extends ActionSupport {
    private Map<String, Object> response;
    @Autowired
    private UserService userService;
    private int id;
    private String name;

    /**
     * 测试清除注解保存的缓存的同时手动添加单个缓存
     * 
     * @return
     */
    public String add() {
        try {
            userService.addUser(id, name);
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return "add";
    }

    /**
     * 测试查询单个的时候注解添加单个缓存
     * 
     * @return
     * @throws Exception
     */
    public String find() throws Exception {
        User user = userService.findUserById(id);
        HttpServletRequest request = ServletActionContext.getRequest();
        request.setAttribute("user", user);
        return "find";
    }


    /**
     * 测试删除单个的时候注解删除单个缓存
     * @return
     */
    public String delete() {
        try {
            userService.deleteById(id);
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return "delete";
    }

    /**
     * 测试注解缓存,将查出来的集合结果加入缓存
     * 
     * @return
     * @throws Exception
     */
    public String findPage() throws Exception {
        response = new HashMap();
        if (name == null)
            name = "111";
        // 第三个参数代表排序方式
        PageHelper.startPage(2, 2, "id desc");
        List<User> users = userService.findUsersByPage(name);
        response.put("users", users);
        return "success";
    }

    public Map getResponse() {
        return response;
    }

    public void setResponse(Map response) {
        this.response = response;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

  三因为redis缓存数据实际上正是键值对的款型储存,由此必须给定key-value的key,这里未有给key参数赋值,所以key的转变规则依照地点工具类中显著的key生成的

 

  • 五.在你想要做缓存的地点,使用注解举办缓存

   

 

 

 

      <!-- 配置RedisCacheManager -->
    <bean id="redisCacheManager" class="org.springframework.data.redis.cache.RedisCacheManager">
        <constructor-arg name="redisOperations" ref="redisTemplate" />
        <property name="defaultExpiration" value="${redis.expiration}" />
    </bean>

    <!-- 配置RedisCacheConfig -->
    <bean id="redisCacheConfig" class="cn.qlq.util.RedisCacheConfig">
        <constructor-arg ref="jedisConnectionFactory"/>
        <constructor-arg ref="redisTemplate"/>
        <constructor-arg ref="redisCacheManager"/>
    </bean>

    <!-- 下面这个是整合Mybatis的二级缓存使用的 -->
    <bean id="redisCacheTransfer" class="cn.qlq.jedis.RedisCacheTransfer">
        <property name="jedisConnectionFactory" ref="jedisConnectionFactory" />
    </bean>

</beans>

 

   五.在您想要做缓存的地点,使用注明举办缓存

       退出再登6,不会试行数据库的询问,直接从数据库中收取缓存,登6成功。

总结:

   肆. RedisCacheConfig redis自定义的工具类,自定义redis的key生成规则

结果:

             假如去除的时候只钦点了其value,而未有一些名key值,则跟据value值加上~keys作为key找到相应的zset,依据zset值获取具备的key后删除,然后删除此zset即成功删除。

  继续走访  删除叁个user四缓存:

 

图片 5

 

      图片 6

 

    此版本的redisspring-data-redis在装置缓存的时候是将value的值加上~keys存为四个zset,值正是各类具体的缓存的key。比如地方

        <!-- jedis依赖 -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.8.4.RELEASE</version>
        </dependency>
        <!-- jackson -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.1.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.1.0</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.1.0</version>
        </dependency>

  明日想的将spring注明整合Redis缓存弄理解,于是通过查阅资料,先做记录如下:

大约步骤如下:

    就是将user~keys作为贰个zset,然后其值为user一.......(缓存的键)

表 贰. @CachePut 效率和铺排格局
package cn.qlq.service.impl;

import java.sql.SQLException;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import cn.qlq.bean.User;
import cn.qlq.mapper.UserMapper;
import cn.qlq.service.UserService;
import cn.qlq.util.RedisUtil;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private UserMapper userMapper;


    //查询出来的时候添加单个缓存
    @Cacheable(value="user",key="'user' #id.toString()")
    @Override
    public User findUserById(int id) throws Exception {
        System.out.println("打印语句则没有走缓存");
        return userMapper.findUserById(id);
    }

    //删除数据库的时候删除redis的缓存
    @Override
    @CacheEvict(value="user",key="'user' #id.toString()")
    public boolean deleteById(int id){
        return true;
    }


    //添加缓存
    @Cacheable(value="Alluser")
    @Override
    public List<User> findUsersByPage(String name) throws SQLException {
        System.out.println("打印语句则没有走缓存");
        return userMapper.findUsersByPage();
    }

    //清除上面的缓存,同时手动的添加一个缓存看能否实现
    @CacheEvict(value="Alluser")
    @Override
    public int addUser(int id, String name) throws SQLException {
        redisUtil.set("mykey", "myvalue");
        return userMapper.addUser(id, name);
    }

}

图片 7

package cn.qlq.util;

import java.lang.reflect.Method;

import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
@EnableCaching
@Configuration
public class RedisCacheConfig extends CachingConfigurerSupport {
    private volatile JedisConnectionFactory jedisConnectionFactory;
    private volatile RedisTemplate<String, String> redisTemplate;
    private volatile RedisCacheManager redisCacheManager;

    public RedisCacheConfig() {
        super();
    }

    /**
     * 带参数的构造方法 初始化所有的成员变量
     * 
     * @param jedisConnectionFactory
     * @param redisTemplate
     * @param redisCacheManager
     */
    public RedisCacheConfig(JedisConnectionFactory jedisConnectionFactory, RedisTemplate<String, String> redisTemplate,
            RedisCacheManager redisCacheManager) {
        this.jedisConnectionFactory = jedisConnectionFactory;
        this.redisTemplate = redisTemplate;
        this.redisCacheManager = redisCacheManager;
    }

    public JedisConnectionFactory getJedisConnecionFactory() {
        return jedisConnectionFactory;
    }

    public RedisTemplate<String, String> getRedisTemplate() {
        return redisTemplate;
    }

    public RedisCacheManager getRedisCacheManager() {
        return redisCacheManager;
    }

    @Bean
    public KeyGenerator keyGenerator() {
      return new KeyGenerator() {
        @Override
        public Object generate(Object o, Method method, Object... params) {
          StringBuilder sb = new StringBuilder();
          sb.append(o.getClass().getName());
          sb.append(method.getName());
          for (Object param : params) {
            sb.append(param.toString());
          }
          return sb.toString();
        }
      };
    }
}

 

Action:

   三.spring管理bean的成形,xml文件配置

RedisCacheConfig         RedisCacheConfig extends org.springframework.cache.annotation.CachingConfigurerSupport,自定义redis的key生成规则,若是不在注解参数中注脚key=“”的话,就应用那几个类中的key生成规则生成key

TAG标签:
版权声明:本文由澳门新葡8455手机版发布于www.2527.com,转载请注明出处:合并申明,spring配置redis注脚缓存