Redis 整合Spring AOP 测试分布式缓存实现时间戳

青旅半醒 2022-03-15 12:40 226阅读 0赞

# 1.Maven依赖 #

<project xmlns="http://maven.apache.org/POM/4.0.0"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    
    	<groupId>com.weichai</groupId>
    	<artifactId>JedisSpring</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<packaging>jar</packaging>
    
    	<name>JedisSpring</name>
    	<url>http://maven.apache.org</url>
    
    	<properties>
    		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    		
    		<spring.version>5.0.0.RELEASE</spring.version>
    	</properties>
    
    	<dependencies>
    		
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-core</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-webmvc</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-context</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-context-support</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-aop</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-aspects</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-tx</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-jdbc</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-web</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-test</artifactId>
    			<version>4.2.4.RELEASE</version>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>org.springframework.data</groupId>
    			<artifactId>spring-data-redis</artifactId>
    			<version>2.0.0.RELEASE</version>
    		</dependency>
    
    		<dependency>
    			<groupId>redis.clients</groupId>
    			<artifactId>jedis</artifactId>
    			<version>2.9.0</version>
    		</dependency>
    
    		<dependency>
    			<groupId>junit</groupId>
    			<artifactId>junit</artifactId>
    			<version>3.8.1</version>
    			<scope>test</scope>
    		</dependency>
    	</dependencies>
    </project>

# 2.Redis属性配置文件redis.properties #

redis.host=127.0.0.1 
    redis.port=6380
    redis.password=123456
    redis.maxIdle=100
    redis.maxActive=300
    redis.maxWait=1000
    redis.testOnBorrow=true
    redis.timeout=10000

# 3.Spring配置文件spring-context.xml #

<?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:content="http://www.springframework.org/schema/context"
    	xmlns:aop="http://www.springframework.org/schema/aop"
    	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/aop  
                            http://www.springframework.org/schema/aop/spring-aop.xsd">
           
        
        <content:component-scan base-package="com.weichai.service"></content:component-scan>
                         
        
    	<content:property-placeholder
    		ignore-resource-not-found="true" location="classpath:redis.properties" />
    
    	<bean id="poolConfig"
    		class="redis.clients.jedis.JedisPoolConfig">
    		<property name="maxIdle" value="${redis.maxIdle}" />  
    		<property name="maxTotal" value="${redis.maxWait}" />   
    		<property name="testOnBorrow" value="${redis.testOnBorrow}" /> 
    	</bean>
    
        
    	<bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
    		<property name="poolConfig" ref="poolConfig" />
    		<property name="port" value="${redis.port}" />
    		<property name="hostName" value="${redis.host}" />
    	    <property name="password" value="${redis.password}" /> 
    		<property name="timeout" value="${redis.timeout}" />
    	</bean>
    
    	<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
    		<property name="connectionFactory" ref="connectionFactory"></property>
    		
    		<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.weichai.interceptor.MethodCacheInterceptor">
    		   <property name="redisTemplate" ref="redisTemplate" />
    	 </bean>
    	 
    	
    	<bean id="methodCachePointCut" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
    		<property name="advice" ref="methodCacheInterceptor" />
    		<property name="pattern" value=".*ServiceImpl.*getTimestamp" />
    	</bean>
    	<bean id="redisService" class="com.weichai.service.RedisService" />
    	<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" />
    </beans>

# 4.Spring AOP监控缓存方法 #

package com.weichai.interceptor;
    
    import java.util.concurrent.TimeUnit;
    
    import org.aopalliance.intercept.MethodInterceptor;
    import org.aopalliance.intercept.MethodInvocation;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.ValueOperations;
    
    public class MethodCacheInterceptor implements MethodInterceptor {
    
    //	@Autowired 
     //   @Qualifier("redisTemplate")
        public RedisTemplate<String, Object> redisTemplate;
    	
    	private Long defaultCacheExpireTime =  1024L; // 缓存默认的过期时间,这里设置了10秒 
    	
    	public Object invoke(MethodInvocation invocation) throws Throwable {
    		// TODO Auto-generated method stub
    		Object value = null;
    		String targetName = invocation.getThis().getClass().getName();
    		String methodName = invocation.getMethod().getName();
    		Object[] arguments = invocation.getArguments();
    		String key = getCacheKey(targetName, methodName, arguments);
    		try {
    			if(exists(key)) {
    				return getCache(key);
    			}
    			// 写入缓存
    			value = invocation.proceed();
    			if(value !=null) {
    				final String tkey = key;
    				final Object tvalue = value;
    				new Thread(new Runnable() {
    					
    					public void run() {
    						// TODO Auto-generated method stub
    						setCache(tkey, tvalue, defaultCacheExpireTime);
    						System.out.println(tkey + " " + tvalue);
    					}
    				}).start();
    			}
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			if (value == null) {
    				return invocation.proceed();
    			}
    		}
    		return value;
    	}
    
    	/**
    	 * 创建缓存key
    	 * @param targetName
    	 * @param methodName
    	 * @param arguments
    	 * @return
    	 */
    	private String getCacheKey(String targetName, String methodName, Object[] arguments) {
    		StringBuffer buffer = new StringBuffer();
    		buffer.append(targetName).append("_").append(methodName);
    		if ((arguments != null) && (arguments.length != 0)) {
    			for (int i = 0; i < arguments.length; i++) {
    				buffer.append("_").append(arguments[i]);
    			}
    		}
    		return buffer.toString();
    	}
    	
    	/**
    	 * 判断缓存中是否有对应的value
    	 * @param key
    	 * @return
    	 */
    	public boolean exists(final String key) {
    		return redisTemplate.hasKey(key);
    	}
    	
    	/**
    	 * 读取缓存
    	 * @param key
    	 * @return
    	 */
    	public Object getCache(final String key) {
    		Object result = null;
    		ValueOperations<String, Object> operations = redisTemplate.opsForValue();
    		result = operations.get(key);
    		return result;
    	}
    	
    	/**
    	 * 写入缓存
    	 * @param key
    	 * @param value
    	 * @param expireTime
    	 * @return
    	 */
    	public boolean setCache(final String key, Object value, Long expireTime) {
    		boolean result = false;
    		try {
    			ValueOperations<String, Object> operations = redisTemplate.opsForValue();
    			operations.set(key, value);
    			redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
    			result = true;
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return result;
    	}
    
    	public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
    		this.redisTemplate = redisTemplate;
    	}
    	
    	
    }

# 5.需要Spring AOP监控的方法（服务） #

package com.weichai.service;
    
    import org.springframework.stereotype.Service;
    
    @Service("redisService")
    public class RedisService {
    
    	/**
         * 返回时间戳
         */
    	public String getTimestamp(String param) {
    		// TODO Auto-generated method stub
    		Long timestamp = System.currentTimeMillis();
    		return timestamp.toString();
    	}
    }

# 6.测试类 #

package com.weichai.JedisSpring;
    
    import org.junit.runner.RunWith;
    import org.springframework.test.context.ContextConfiguration;
    import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    
    @ContextConfiguration(locations = { "classpath:spring-context.xml" })
    @RunWith(SpringJUnit4ClassRunner.class)  
    public class SpringTestCase extends AbstractJUnit4SpringContextTests {
    
    }

package com.weichai.JedisSpring;
    
    import org.junit.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    
    import com.weichai.service.RedisService;
    
    public class RedisTest extends SpringTestCase {
    
    	@Autowired
    	private RedisService redisService;
    
    	@Test
    	public void getTimestampTest() throws InterruptedException {
    		System.out.println("第一次调用：" + redisService.getTimestamp("param"));
    		Thread.sleep(2000);
    		System.out.println("2秒之后调用：" + redisService.getTimestamp("param"));
    		Thread.sleep(11000);
    		System.out.println("再过11秒之后调用：" + redisService.getTimestamp("param"));
    	}
    }