java aop redis缓存

最新推荐文章于 2024-03-04 18:00:00 发布
最新推荐文章于 2024-03-04 18:00:00 发布
阅读量2.3k 收藏 3
点赞数 2
分类专栏： redis 

<!-- Redis客户端 -->
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.8.0</version>
		</dependency>

        <!-- Jackson Json处理工具包 -->
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
			<version>2.7.3</version>
		</dependency>



spring 配置文件添加

  <!-- 开启切面代理 使得spring认识 @Aspect -->
     <aop:aspectj-autoproxy/>

然后定义两个标注在Service实现方法上的注解，用于传递类型参数： 

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
public @interface RedisCache {
	
    Class type();
    public int expire() default 0;      //缓存多少秒,默认无限期  
}


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RedisEvict {
    Class type();
}

注解的使用方式如下： 

	@RedisCache(type = User.class, expire = 200000000)
	public List<User> findUsersByGroupId(Integer group_id) {
		return groupDao.findUsersByGroupId(group_id);
	}
	@RedisEvict(type = User.class)// 表示该方法需要执行清除缓存逻辑
	public void updateUserByPhone(String nickName,String phone) {
		UserDao.updateUserByPhone(nickName, phone);
	}


JsonUtils

import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.log4j.Logger;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;



public class JsonUtils {

	private static Logger logger = Logger.getLogger(JsonUtils.class);

	// 定义jackson对象
	private static final ObjectMapper MAPPER = new ObjectMapper();

	/**
	 * 将对象转换成json字符串。
	 * 
	 * @param data
	 * @return
	 * @throws IOException
	 */
	public static String objectToJson(Object data) {
		try {
			String string = MAPPER.writeValueAsString(data);
			return string;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 将json结果集转化为对象
	 * 
	 * @param jsonData
	 *            json数据
	 * @param clazz
	 *            对象中的object类型
	 * @return
	 */
	public static <T> T jsonToPojo(String jsonData, Class<T> beanType) {
		try {
			T t = MAPPER.readValue(jsonData, beanType);
			return t;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 将json数据转换成pojo对象list
	 * 
	 * @param jsonData
	 * @param beanType
	 * @return
	 */
	public static <T> List<T> jsonToList(String jsonData, Class<T> beanType) {
		JavaType javaType = MAPPER.getTypeFactory().constructParametricType(
				List.class, beanType);
		try {
			List<T> list = MAPPER.readValue(jsonData, javaType);
			return list;
		} catch (Exception e) {
			e.printStackTrace();
		}

		return null;
	}

	/**
	 * json string convert to map with javaBean
	 */
	public static <T> Map<String, T> jsonTomap(String jsonStr, Class<T> clazz)
			throws Exception {
		Map<String, Map<String, Object>> map = MAPPER.readValue(jsonStr,
				new TypeReference<Map<String, T>>() {
				});
		Map<String, T> result = new HashMap<String, T>();
		for (Entry<String, Map<String, Object>> entry : map.entrySet()) {
			result.put(entry.getKey(), mapTopojo(entry.getValue(), clazz));
		}
		return result;
	}

	/**
	 * json string convert to map
	 */
	public static <T> Map<String, Object> jsonTomap(String jsonStr) {
		try {
			return MAPPER.readValue(jsonStr, Map.class);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * map convert to javaBean
	 */
	public static <T> T mapTopojo(Map map, Class<T> clazz) {

		try {
			return MAPPER.convertValue(map, clazz);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;

	}

}



AOP的代码如下: 

import java.util.List;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.core.annotation.RedisCache;
import com.core.annotation.RedisEvict;
import com.jedis.dao.JedisClient;
import com.utils.JsonUtils;

@Aspect
@Component
public class CacheInterceptor {

	@Autowired
	JedisClient jedisClient;
	
	
	//前置由于数据库数据变更  清理redis缓存
	@Before("@annotation(redisEvict)")
	public void <span style="font-family:Consolas, Courier New, Courier, mono, serif;"><span style="line-height: 18px; background-color: rgb(248, 248, 248);">doBefore</span></span>(JoinPoint jp,RedisEvict redisEvict){
		
		  try{
			  
			  String modelName = redisEvict.type().getName();
			  // 清除对应缓存
			  jedisClient.del(modelName);  
			  
		  }catch (Exception e) {
				
				e.printStackTrace();
				System.out.println("缓存服务器出现问题,发邮箱，发信息...");		
		}
	}

	// 配置环绕方法
	@Around("@annotation(redisCache)")
	public Object doAround(ProceedingJoinPoint pjp, RedisCache redisCache)
			throws Throwable {
		// 得到被代理的方法
		// Method me = ((MethodSignature) pjp.getSignature()).getMethod();
		// Class modelType = me.getAnnotation(RedisCache.class).type();

		//得到注解上类型
		Class modelType = redisCache.type();
		//System.out.println(modelType.getName());
		
		// 去Redis中看看有没有我们的数据 包名+ 类名 + 方法名 + 参数(多个)
		String cacheKey = getCacheKey(pjp);
		System.out.println(cacheKey);

		String value = null;
		
		try {//当取redis发生异常时，为了不影响程序正常执行，需要try..catch()...
			
			//检查redis中是否有缓存
	        value = jedisClient.hget(modelType.getName(),cacheKey);
			
		} catch (Exception e) {
			
			e.printStackTrace();
			System.out.println("缓存服务器出现问题,发邮箱，发信息...");
			
		}

		// result是方法的最终返回结果
		Object result = null;
		if (null == value) {
			// 缓存未命中
			System.out.println("缓存未命中");

			// 后端查询数据  
			result = pjp.proceed();
           
			try {//当取redis发生异常时，为了不影响程序正常执行，需要try..catch()...
				
				// 序列化结果放入缓存
				String json = serialize(result);
				jedisClient.hset(modelType.getName(), cacheKey, json);
				
				if(redisCache.expire()>0) { 
					jedisClient.expire(cacheKey, redisCache.expire());//设置缓存时间
				}
				
			} catch (Exception e) {
				
				e.printStackTrace();
				System.out.println("缓存服务器出现问题,发邮箱，发信息...");
			}
			
		} else {
			
			try{//当数据转换失败发生异常时，为了不影响程序正常执行，需要try..catch()...
				
				// int i =1/0;
				
				// 得到被代理方法的返回值类型
				Class returnType = ((MethodSignature) pjp.getSignature()).getReturnType();
				
				//把json反序列化
				result = deserialize(value, returnType, modelType);
				
			    
				// 缓存命中
				System.out.println("缓存命中");
			} catch (Exception e) {
				
				//数据转换失败，到后端查询数据  
				result = pjp.proceed();
				
				e.printStackTrace();
				System.out.println("缓存命中,但数据转换失败...");
			}

		}

		return result;
	}
	

	protected String serialize(Object target) {
		return JsonUtils.objectToJson(target);
	}

	protected Object deserialize(String jsonString, Class clazz, Class modelType) {
		// 序列化结果应该是List对象
		if (clazz.isAssignableFrom(List.class)) {
			return JsonUtils.jsonToList(jsonString, modelType);
		}

		// 序列化结果是普通对象
		return JsonUtils.jsonToPojo(jsonString, clazz);
	}

	
	// 包名+ 类名 + 方法名 + 参数(多个) 生成Key
	public String getCacheKey(ProceedingJoinPoint pjp) {
		StringBuffer key = new StringBuffer();
		// 包名+ 类名 cn.core.serice.product.ProductServiceImpl.productList
		String packageName = pjp.getTarget().getClass().getName();

		key.append(packageName);
		// 方法名
		String methodName = pjp.getSignature().getName();
		key.append(".").append(methodName);

		// 参数(多个)
		Object[] args = pjp.getArgs();

		for (Object arg : args) {
			// 参数
			key.append(".").append(arg.toString());
		}

		return key.toString();
	}
}


jedisClient.java 

public interface JedisClient {
	String get(String key);

	byte[] get(byte[] key);

	String set(String key, String value);

	String set(byte[] key, byte[] value);

	String hget(String hkey, String key);

	long hset(String hkey, String key, String value);

	long incr(String key);

	long expire(String key, int second);

	long ttl(String key);

	long del(String key);

	long hdel(String hkey, String key);
	
}


JedisClientSingle 

import org.springframework.beans.factory.annotation.Autowired;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

import com.edl.jedis.dao.JedisClient;

public class JedisClientSingle implements JedisClient{

	@Autowired
	private JedisPool jedisPool; 
	
	@Override
	public String get(String key) {
		Jedis jedis = jedisPool.getResource();
		String string = jedis.get(key);
		jedis.close();
		return string;
	}

	@Override
	public String set(String key, String value) {
		Jedis jedis = jedisPool.getResource();
		
		String string = jedis.set(key, value);
		jedis.close();
		return string;
	}

	@Override
	public String hget(String hkey, String key) {
		Jedis jedis = jedisPool.getResource();
		String string = jedis.hget(hkey, key);
		jedis.close();
		return string;
	}

	@Override
	public long hset(String hkey, String key, String value) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.hset(hkey, key, value);
		jedis.close();
		return result;
	}

	@Override
	public long incr(String key) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.incr(key);
		jedis.close();
		return result;
	}

	@Override
	public long expire(String key, int second) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.expire(key, second);
		jedis.close();
		return result;
	}

	@Override
	public long ttl(String key) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.ttl(key);
		jedis.close();
		return result;
	}

	@Override
	public long del(String key) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.del(key);
		jedis.close();
		return result;
	}

	@Override
	public long hdel(String hkey, String key) {
		Jedis jedis = jedisPool.getResource();
		Long result = jedis.hdel(hkey, key);
		jedis.close();
		return result;
	}

	@Override
	public byte[] get(byte[] key) {
		Jedis jedis = jedisPool.getResource();
		byte[] result = jedis.get(key);
		jedis.close();
		return result;
	}

	@Override
	public String set(byte[] key, byte[] value) {
		Jedis jedis = jedisPool.getResource();
		String result = jedis.set(key, value);
		jedis.close();
		return result;
	}
}

JedisClientCluster 


public class JedisClientCluster implements JedisClient {

	@Autowired
	private JedisCluster jedisCluster;
	
	@Override
	public String get(String key) {
		return jedisCluster.get(key);
	}

	@Override
	public String set(String key, String value) {
		return jedisCluster.set(key, value);
	}

	@Override
	public String hget(String hkey, String key) {
		return jedisCluster.hget(hkey, key);
	}

	@Override
	public long hset(String hkey, String key, String value) {
		return jedisCluster.hset(hkey, key, value);
	}

	@Override
	public long incr(String key) {
		return jedisCluster.incr(key);
	}

	@Override
	public long expire(String key, int second) {
		return jedisCluster.expire(key, second);
	}

	@Override
	public long ttl(String key) {
		return jedisCluster.ttl(key);
	}

	@Override
	public long del(String key) {
		
		return jedisCluster.del(key);
	}

	@Override
	public long hdel(String hkey, String key) {
		
		return jedisCluster.hdel(hkey, key);
	}

	@Override
	public byte[] get(byte[] key) {
		// TODO Auto-generated method stub
		return jedisCluster.get(key);
	}

	@Override
	public String set(byte[] key, byte[] value) {
		// TODO Auto-generated method stub
		return jedisCluster.set(key, value);
	}

}



spring-jedis.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:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:task="http://www.springframework.org/schema/task"
	xsi:schemaLocation="http://www.springframework.org/schema/mvc 
		http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
		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/task
                    http://www.springframework.org/schema/task/spring-task-3.0.xsd">

	 <context:component-scan base-package="com.core" />


	<!-- jedis客户端单机版 -->
	<bean id="redisClient" class="redis.clients.jedis.JedisPool">
		<constructor-arg name="host" value="192.168.1.87"></constructor-arg>
		<constructor-arg name="port" value="6379"></constructor-arg>
	</bean>
	<bean id="jedisClient" class="com.edl.jedis.dao.impl.JedisClientSingle" />
	
	<!-- jedis集群版配置 -->
<!-- 	<bean id="redisClient" class="redis.clients.jedis.JedisCluster">
		<constructor-arg name="nodes">
			<set>
			    <bean class="redis.clients.jedis.HostAndPort">
					<constructor-arg name="host" value="192.168.1.87"></constructor-arg>
					<constructor-arg name="port" value="7006"></constructor-arg>
				</bean>
				<bean class="redis.clients.jedis.HostAndPort">
					<constructor-arg name="host" value="192.168.1.87"></constructor-arg>
					<constructor-arg name="port" value="7001"></constructor-arg>
				</bean>
				<bean class="redis.clients.jedis.HostAndPort">
					<constructor-arg name="host" value="192.168.1.87"></constructor-arg>
					<constructor-arg name="port" value="7002"></constructor-arg>
				</bean>
				<bean class="redis.clients.jedis.HostAndPort">
					<constructor-arg name="host" value="192.168.1.87"></constructor-arg>
					<constructor-arg name="port" value="7003"></constructor-arg>
				</bean>
				<bean class="redis.clients.jedis.HostAndPort">
					<constructor-arg name="host" value="192.168.1.87"></constructor-arg>
					<constructor-arg name="port" value="7004"></constructor-arg>
				</bean>
				<bean class="redis.clients.jedis.HostAndPort">
					<constructor-arg name="host" value="192.168.1.87"></constructor-arg>
					<constructor-arg name="port" value="7005"></constructor-arg>
				</bean>
			</set>
		</constructor-arg>
		<constructor-arg name="poolConfig" ref="jedisPoolConfig"></constructor-arg>
	</bean>
	<bean id="jedisClientCluster" class="com.edl.jedis.dao.impl.JedisClientCluster"></bean> -->

</beans>




爱笑的T_T
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
spring-redis-aop:基于aop方式添加redis缓存
05-05
此项目是实现以aop的形式，以annotion方式在实现方法上添加redis缓存 注意： 1.如果用maven打成jar包引入，只需修改一下配置问题 2.也可将代码copy到您的项目中。但要修改一些代码和配置文件 3.对象要实现...
java操作redis缓存
weixin_46266624的博客
05-09 3102
Redis是当前比较热门的NOSQL系统之一，它是一个开源的使用ANSI c语言编写的key-value存储系统（区别于MySQL的二维表格的形式存储。和Memcache类似，但很大程度补偿了Memcache的不足。和Memcache一样，Redis数据都是缓存在计算机内存中，不同的是，Memcache只能将数据缓存到内存中，无法自动定期写入硬盘，这就表示，一断电或重启，内存清空，数据丢失。所以Memcache的应用场景适用于缓存无需持久化的数据。
【Java项目中 利用Redis实现数据缓存】
独上高楼，望尽天涯路。
06-25 2282
黑马程序员-瑞吉外卖项目-代码优化，Java项目利用redis技术实现数据缓存，提高系统稳定性，以及Spring Cache 缓存框架的使用技巧
Java实战：Spring Data Redis缓存实战
最新发布
oandy0的博客
03-04 1847
本文将详细介绍Spring Data Redis在Java应用中的缓存实战，包括Spring Data Redis的基本概念、使用场景、配置方法、数据操作、缓存策略、与Spring MVC集成等。
CGB2004-京淘项目Day12
qq_16804847的博客
08-12 9083
Redis学习
【Java 进阶篇】Redis 缓存优化：提升应用性能的不二选择
繁依Fanyi的博客
12-29 1439
通过本文的介绍，相信你已经对 Redis 缓存优化有了更深入的了解。缓存作为提升应用性能的得力工具，但也需要谨慎使用并结合实际业务场景进行合理的优化。通过解决缓存击穿和缓存雪崩等常见问题，我们可以更好地发挥 Redis 缓存的威力，提升应用的响应速度，提高用户体验。在实际应用中，根据业务场景和需求选择合适的缓存策略，将缓存融入系统架构中，助力应用高效运行。希望本文能够帮助你更好地应对实际开发中的缓存优化问题，让你的应用在性能上更上一层楼。
JAVA技术体系之分布式篇（四）——Redis缓存
qsmiley10的博客
06-15 2449
1、Redis概述 1.1 XXX 1.2 XXX 2、Redis数据类型 2.1 XXX 2.2 XXX 2.3 XXX 3、Redis核心原理 3.1 XXX 3.2 XXX 3.3 XXX 4、Redis分布式实现 4.1 XXX 4.2 XXX 4.3 XXX 5、Redis常见问题及解决方案 5.1 XXX 5.2 XXX 5.3 XXX 6、Redis6.0新特性 6.1 XXX 6.2 XXX 6.3 XXX    ...
spring-redis-aop:redis客户端集成spring实现aop方式
06-25
spring-redis-aop redis客户端集成spring实现aop方式,方便在程序中使用spring的时候更加方便的使用redis内存数据库， 采用aop的方式主要是为了不去污染业务代码，达到业务逻辑更加清晰易于阅读，在使用过程中可以...
aspect-cache:An light spring-boot AOP cache with Java, support POJO,Map and List data type. You can use your key generator(default use SpEL) and cache provider.Key generate with SpEL.Aspect Cache是一个针对Spring Boot，基于AOP注解方式的轻量级缓存，目前支持EHCache，Redis缓存方式。数据类型支
05-09
Aspect Cache是一个针对Spring Boot，基于AOP注解方式的轻量级缓存，目前支持EHCache，Redis缓存方式。数据类型支持POJO、Map和List数据类型，同时支持自定义缓存key解析，也支持自定义的缓存处理方式，或者扩展支持...
java springboot快速开发权限框架
04-07
6、支持分布式部署，session集成了redis 7、灵活的权限控制, 整合shiro，可控制到页面或按钮，满足绝大部分的权限需求,优化权限注解方便权限配置 8、日志记录采用aop(LogAop类)方式，可对用户所有操作进行记录 9、...
IT｜Java｜面试｜宝典
02-16
Java基础和核心面试大全｜Redis面试总结 1.JVM 2.集合 3.多线程并发 4.java基础 5.spring原理 6.微服务 7.netty与rpc 及实现 8.网络 9.zookeeper 10.kafka 11.rabbitmq 12.hbase 13.mongodb 14.cassandra 15.设计...
REDIS缓存数据库在JAVA中的使用
01-18
零基础学会REDIS缓存数据库在JAVA中的使用。从REDIS的安装和使用开始，到Java程序与REDIS数据库进行连接互动，简单明了。
springboot实现消息转换、切面AOP和Redis缓存
11-16
springboot实现消息转换、切面AOP和Redis缓存,实现相关技术的实例，以及相关方法的使用说明
my_blog_maven.zip
04-02
完整博客系统功能开发，功能有日志检查，系统检查，安全技术检查，数据库监听，博客发布，文章宣传，广告，后台图像记录 用到redis缓存，springboot框架 shoir 有什么问题直接加我
spring-boot-101:弹簧引导配置指南，例如mybatis，redis，缓存等
04-23
功能清单Web配置和静态页面支持log4j2配置mySql和myBatis配置mongoDB配置Redis集群配置咖啡因缓存配置RESTful API 不同环境的不同配置文件从application.yml检索属性（请参阅：读取属性） 速度模板（不建议使用） ...
夏季：这是一个支持分布式和移植的Java游戏服务器框架，可用于开发棋牌，回合制等游戏。基于netty实现高性能通讯，支持tcp，http，websocket等协议。支持消息加解密，攻击拦截，黑白列表机制。封装了redis缓存，mysql数据库的连接与使用。轻量级，便于上手
02-05
封装了redis缓存，mysql数据库的连接与使用。轻量级，便于上手。 目录 更新说明 2021.01.31 修复在程序关闭时，异步事件中有推进初始化消息的操作导致异常的问题。 优化ServerPush，添加简单的调用接口。 优化...
SpringBoot基于AOP注解方式实现Redis缓存
有问题请发邮箱[email protected]进行讨论
08-24 344
Spring中的AOP（Aspect Oriented Programming）是基于代理的AOP实现，通过使用基于代理的技术，可以在不修改原有代码的情况下，对原有代码进行增强和改进。Spring AOP实现了面向切面编程的功能，将横切关注点（Cross-cutting concern）从业务逻辑中抽离出来，通过将切面应用到目标对象的方法上实现功能增强。
【springboot进阶】使用aop + 注解方式，简单实现spring cache redis 功能
12-03 1238
使用aop + 注解方式，简单实现spring cache功能，整合出多场景的缓存功能。通过el表达式，能够更好的扩展缓存key的使用。
aop实现redis缓存
08-18
AOP（面向切面编程）可以用于实现 Redis 缓存的功能。下面是一种常见的实现方式： 1. 首先，需要配置 Redis 客户端，确保你的应用程序可以与 Redis 进行通信。 2. 创建一个自定义注解，用于标记需要缓存的方法。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值