redis整合spring实现对数据的缓存

清疚 2022-06-12 08:26 260阅读 0赞

1编写redis类，主要是对数据的读写操作

public class RedisUtil {
        private Logger logger = Logger.getLogger(RedisUtil.class);
        private RedisTemplate<Serializable, Object> redisTemplate;
    
        /** * 批量删除对应的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<Serializable> keys = redisTemplate.keys(pattern);
            if (keys.size() > 0)
                redisTemplate.delete(keys);
        }
    
        /** * 删除对应的value * * @param key */ public void remove(final String key) {
            if (exists(key)) {
                redisTemplate.delete(key);
            }
        }
    
        /** * 判断缓存中是否有对应的value * * @param key * @return */ public boolean exists(final String key) {
            return redisTemplate.hasKey(key);
        }
    
        /** * 读取缓存 * * @param key * @return */ public Object get(final String key) {
            Object result = null;
            ValueOperations<Serializable, Object> operations = redisTemplate
                    .opsForValue();
            result = operations.get(key);
            return result;
        }
    
        /** * 写入缓存 * * @param key * @param value * @return */ public boolean set(final String key, Object value) {
            boolean result = false;
            try {
                ValueOperations<Serializable, Object> operations = redisTemplate
                        .opsForValue();
                operations.set(key, value);
                result = true;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return result;
        }
    
        /** * 写入缓存 * * @param key * @param value * @return */ public boolean set(final String key, Object value, Long expireTime) {
            boolean result = false;
            try {
                ValueOperations<Serializable, Object> operations = redisTemplate
                        .opsForValue();
                operations.set(key, value);
                redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
                result = true;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return result;
        }
    
        public void setRedisTemplate(
                RedisTemplate<Serializable, Object> redisTemplate) {
            this.redisTemplate = redisTemplate;
        }
    }

2拦截器，用于在读取数据前访问，如果有结果，则不继续下去

public class MethodCacheInterceptor implements MethodInterceptor {
        private Logger logger = Logger.getLogger(MethodCacheInterceptor.class);
        private RedisUtil redisUtil;
    
        public Object invoke(MethodInvocation invocation) throws Throwable {
            Object value = null;
    
            String targetName = invocation.getThis().getClass().getName();//类名
            String methodName = invocation.getMethod().getName();//方法名
            Object[] arguments = invocation.getArguments();//参数
            String key = getCacheKey(targetName, methodName, arguments);
            System.out.println(key);
            try {
                // 判断是否有缓存
                if (redisUtil.exists(key)) {
                    return redisUtil.get(key);
                }
                // 写入缓存
                value = invocation.proceed();
                if (value != null) {
                    final String tkey = key;
                    final Object tvalue = value;
                    new Thread(new Runnable() {
                        public void run() {
                            redisUtil.set(tkey, tvalue, 1000000000L);
                        }
                    }).start();
                }
            } catch (Exception e) {
                e.printStackTrace();
                if (value == null) {
                    return invocation.proceed();
                }
            }
            return value;
        }
    
    
        /** * 创建缓存key * * @param targetName * @param methodName * @param arguments */ private String getCacheKey(String targetName, String methodName,
                                   Object[] arguments) {
            StringBuffer sbu = new StringBuffer();
            sbu.append(targetName).append("_").append(methodName);
            if ((arguments != null) && (arguments.length != 0)) {
                for (int i = 0; i < arguments.length; i++) {
                    sbu.append("_").append(arguments[i]);
                }
            }
            return sbu.toString();
        }
    
        public void setRedisUtil(RedisUtil redisUtil) {
            this.redisUtil = redisUtil;
        }
    }

3spring配置：

<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig" >
        <property name="maxIdle" value="100" />
        <property name="maxWaitMillis" value="1000" />
        <property name="testOnBorrow" value="true" />
    </bean >
    <bean id="testDao" class="com.smart.domain.TestDao"/>
    <bean id="testService" class="com.smart.domain.TestService"
          p:testDao-ref="testDao"/>
    
    <bean id="connectionFactory"  class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" >
        <property name="poolConfig" ref="poolConfig" />
        <property name="port" value="6379" />
        <property name="hostName" value="127.0.0.1" />
        <property name="timeout" value="100000" ></property>
    </bean >
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" >
        <property name="connectionFactory" ref="connectionFactory" />
        <property name="keySerializer" >
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
        </property>
        <property name="valueSerializer" >
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
        </property>
    </bean >
    
    
    <bean id="methodCacheInterceptor" class="com.smart.domain.MethodCacheInterceptor" >
        <property name="redisUtil" ref="redisUtil" />
    </bean >
    <bean id="redisUtil" class="com.smart.domain.RedisUtil" >
        <property name="redisTemplate" ref="redisTemplate" />
    </bean >
    <aop:config>
    
        
        <aop:pointcut id="loginPoint"
                      expression="execution(* getService(..))"/>
        
        <aop:advisor pointcut-ref="loginPoint" advice-ref="methodCacheInterceptor"/>
    
    
    </aop:config>

4配置的几个测试

public class TestDao {
        public String getDao(){
            //注意，如果是调用缓存数据，那么这句话就不会打印。
            System.out.println("正在执行sql语句。。。。");
            return "Result success";
        }
    }

public class TestService {
        private TestDao testDao;
    
        public void setTestDao(TestDao testDao) {
            this.testDao = testDao;
        }
        public String getService(){
            return testDao.getDao();
        }
    }

5测试：

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration({
      "classpath:applicationContext.xml"})
    public class RedisTest {
        @Autowired
        private TestService testService;
        @Test
        public void redis(){
            String s=testService.getService();
            String s1=testService.getService();
            System.out.println(s+","+s1);
        }
    }

运行结果：

com.smart.domain.TestService\_getService  
com.smart.domain.TestService\_getService  
Result success,Result success

因为缓存时间比较长，我这个例子不是第一次跑了，所以dao中的sql依据也没有运行