ssm+redis 如何更简洁的利用自定义注解+AOP实现redis缓存

基于 ssm + maven + redis 使用自定义注解利用aop基于AspectJ方式实现redis缓存

　　如何能更简洁的利用aop实现redis缓存，话不多说，上demo

　　需求：
　　　　数据查询时每次都需要从数据库查询数据，数据库压力很大，查询速度慢，
　　　　因此设置缓存层，查询数据时先从redis中查询，如果查询不到，则到数据库中查询
　　　　然后将数据库中查询的数据放到redis中一份，下次查询时就能直接从redis中查到，不需要查询数据库了

　　实现过程：

　　　　　　先搭建ssm的架子，引入redis，编写redis 缓存方法 RedisCache.java以及序列化用到的工具类

　　　　　　自定义注解 getCache 目的：
　　　　　　　　　　　　被这个注解标记的方法实现aop
　　　　　　　　　　　　防止redis key重复

　　　　　编写切面
　　　　　　@Aspect

　　　　　　　　@Pointcut("@annotation(com.spring_redis.cache.GetCache)")
　　　　　　　　切入点为自定义注解即每个被该注解标记的方法实现通知

　　　　　　　　@Around("getCache()")
　　　　　　　　利用环绕通知
　　　　　　　　　　过程：查询时，先查询redis 如果存在key-value，则返回不查询
　　　　　　　　　　如果不存在，则查询数据库，之后将查询到的数据存入到redis缓存中
　　　　　　　　　　redis key格式：为了防止key冲突，创建的key格式为：
　　　　　　　　　　包名.类名.方法名.参数类型.参数值"，类似 "your.package.SomeService.getById(integer).123"

　　目录结构

　　maven依赖：

  1 <properties>
  2             <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  3              <!-- spring版本号 -->
  4             <spring.version>4.0.6.RELEASE</spring.version>
  5             <!-- mybatis版本号 -->
  6             <mybatis.version>3.2.7</mybatis.version>
  7         </properties>
  8   <dependencies>
  9
 10           <!-- spring核心包 -->
 11         <!-- springframe start -->
 12         <dependency>
 13             <groupId>org.springframework</groupId>
 14             <artifactId>spring-core</artifactId>
 15             <version>${spring.version}</version>
 16         </dependency>
 17
 18         <dependency>
 19             <groupId>org.springframework</groupId>
 20             <artifactId>spring-web</artifactId>
 21             <version>${spring.version}</version>
 22         </dependency>
 23
 24         <dependency>
 25             <groupId>org.springframework</groupId>
 26             <artifactId>spring-oxm</artifactId>
 27             <version>${spring.version}</version>
 28         </dependency>
 29
 30         <dependency>
 31             <groupId>org.springframework</groupId>
 32             <artifactId>spring-tx</artifactId>
 33             <version>${spring.version}</version>
 34         </dependency>
 35
 36         <dependency>
 37             <groupId>org.springframework</groupId>
 38             <artifactId>spring-aop</artifactId>
 39             <version>${spring.version}</version>
 40         </dependency>
 41
 42         <dependency>
 43             <groupId>org.springframework</groupId>
 44             <artifactId>spring-jdbc</artifactId>
 45             <version>${spring.version}</version>
 46         </dependency>
 47
 48         <dependency>
 49             <groupId>org.springframework</groupId>
 50             <artifactId>spring-webmvc</artifactId>
 51             <version>${spring.version}</version>
 52         </dependency>
 53
 54         <!-- https://mvnrepository.com/artifact/org.springframework/spring-context-support -->
 55         <dependency>
 56             <groupId>org.springframework</groupId>
 57             <artifactId>spring-context-support</artifactId>
 58             <version>4.0.6.RELEASE</version>
 59         </dependency>
 60
 61         <dependency>
 62             <groupId>org.springframework</groupId>
 63             <artifactId>spring-context</artifactId>
 64             <exclusions>
 65                 <exclusion>
 66                     <groupId>commons-logging</groupId>
 67                     <artifactId>commons-logging</artifactId>
 68                 </exclusion>
 69             </exclusions>
 70             <version>${spring.version}</version>
 71         </dependency>
 72         <dependency>
 73             <groupId>org.springframework</groupId>
 74             <artifactId>spring-test</artifactId>
 75             <version>${spring.version}</version>
 76         </dependency>
 77         <!-- springframe end -->
 78
 79           <!-- aop注解  -->
 80
 81         <dependency>
 82             <groupId>org.aspectj</groupId>
 83             <artifactId>aspectjrt</artifactId>
 84             <version>1.6.12</version>
 85         </dependency>
 86         <dependency>
 87             <groupId>org.aspectj</groupId>
 88             <artifactId>aspectjweaver</artifactId>
 89             <version>1.6.12</version>
 90         </dependency>
 91         <dependency>
 92             <groupId>cglib</groupId>
 93             <artifactId>cglib</artifactId>
 94             <version>2.2</version>
 95         </dependency>
 96
 97           <!-- mysql驱动包 -->
 98         <dependency>
 99             <groupId>mysql</groupId>
100             <artifactId>mysql-connector-java</artifactId>
101             <version>5.1.31</version>
102         </dependency>
103
104           <!-- dbcp2连接池 -->
105         <dependency>
106             <groupId>org.apache.commons</groupId>
107             <artifactId>commons-dbcp2</artifactId>
108             <version>2.0.1</version>
109         </dependency>
110
111         <!-- json数据 -->
112         <dependency>
113             <groupId>org.codehaus.jackson</groupId>
114             <artifactId>jackson-mapper-asl</artifactId>
115             <version>1.9.13</version>
116         </dependency>
117
118           <!-- mybatis核心包 -->
119         <dependency>
120             <groupId>org.mybatis</groupId>
121             <artifactId>mybatis</artifactId>
122             <version>${mybatis.version}</version>
123         </dependency>
124         <!-- mybatis/spring包 -->
125         <dependency>
126             <groupId>org.mybatis</groupId>
127             <artifactId>mybatis-spring</artifactId>
128             <version>1.2.2</version>
129         </dependency>
130
131           <dependency>
132             <groupId>org.springframework.data</groupId>
133             <artifactId>spring-data-redis</artifactId>
134             <version>1.6.1.RELEASE</version>
135         </dependency>
136          <dependency>
137             <groupId>redis.clients</groupId>
138             <artifactId>jedis</artifactId>
139             <version>2.7.3</version>
140         </dependency>
141
142           <!-- servlet-api -->
143         <dependency>
144             <groupId>javax.servlet</groupId>
145             <artifactId>javax.servlet-api</artifactId>
146             <version>3.0.1</version>
147             <scope>provided</scope>
148         </dependency>
149         <dependency>
150             <groupId>javax.servlet.jsp</groupId>
151             <artifactId>jsp-api</artifactId>
152             <version>2.2</version>
153             <scope>provided</scope>
154         </dependency>
155         <!-- servlet-api end -->
156
157           <dependency>
158             <groupId>log4j</groupId>
159             <artifactId>log4j</artifactId>
160             <version>1.2.17</version>
161         </dependency>
162   </dependencies>
163

　　这里只给出redis 的相关配置

　　　　在applicationContext-dao.xml　里添加

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
 4     xmlns:context="http://www.springframework.org/schema/context"
 5     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
 6     xmlns:util="http://www.springframework.org/schema/util"
 7     xsi:schemaLocation="http://www.springframework.org/schema/beans
 8     http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
 9     http://www.springframework.org/schema/context
10     http://www.springframework.org/schema/context/spring-context-3.2.xsd
11     http://www.springframework.org/schema/tx
12     http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
13     http://www.springframework.org/schema/aop
14     http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
15     http://www.springframework.org/schema/util
16     http://www.springframework.org/schema/util/spring-util-3.2.xsd">
17
18
19         <!-- 加载db.properties文件中的内容，db.properties文件中key命名要有一定的特殊规则 -->
20         <context:property-placeholder location="classpath:properties/db.properties" />
21
22
23
24         <!-- 配置数据源 ，dbcp -->
25
26         <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
27         <property name="driverClassName" value="${jdbc.driver}" />
28         <property name="url" value="${jdbc.url}" />
29         <property name="username" value="${jdbc.username}" />
30         <property name="password" value="${jdbc.password}" />
31         </bean>
32
33
34         <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"
35         p:dataSource-ref="dataSource" p:configLocation="classpath:mybatis/sqlMapConfig.xml"
36         ></bean>
37               <!-- Redis和缓存配置开始 -->
38             <!-- jedis 配置 -->
39             <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig" >
40                   <property name="maxIdle" value="100" />
41                   <property name="maxWaitMillis" value="1000" />
42                   <property name="testOnBorrow" value="true" />
43             </bean >
44
45             <!-- redis连接池 -->
46                 <bean id="jedisPool" class="redis.clients.jedis.JedisPool" destroy-method="close">
47                     <constructor-arg name="poolConfig" ref="poolConfig"/>
48                     <constructor-arg name="host" value="127.0.0.1"/>
49                     <constructor-arg name="port" value="6379"/>
50                 </bean>
51
52               <!-- redis服务器中心 -->
53             <bean id="connectionFactory"  class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" >
54                   <property name="poolConfig" ref="poolConfig" />
55                   <property name="port" value="6379" />
56                   <property name="hostName" value="127.0.0.1" />
57                   <!-- <property name="password" value="${redis.password}" /> -->
58                   <property name="timeout" value="10000" ></property>
59             </bean >
60             <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" >
61                   <property name="connectionFactory" ref="connectionFactory" />
62                   <property name="keySerializer" >
63                       <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
64                   </property>
65                   <property name="valueSerializer" >
66                       <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
67                   </property>
68             </bean >
69
70
71
72
73
74             <!-- cache配置 -->
75             <bean id="putCache" class="com.spring_redis.cache.PutCacheAOP" >
76                   <property name="redisTemplate" ref="redisTemplate" />
77             </bean>
78
79             <!-- cache配置 -->
80              <bean id="getCache" class="com.spring_redis.cache.GetCacheAOP" >
81                    <property name="redisTemplate" ref="redisTemplate" />
82              </bean>
83
84              <!-- Redis和缓存配置结束 -->
85
86             <!-- mapper扫描器 -->
87             <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
88                 <!-- 扫描包路径，如果需要扫描多个包，中间使用半角逗号隔开 -->
89                 <property name="basePackage" value="com.spring_redis.mapper"></property>
90                 <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
91             </bean>
92
93             <bean id="roomservice" class="com.spring_redis.service.impl.RoomServiceImpl" >
94
95              </bean>
96
97 </beans>

　　springmvc.xml

 1 <beans xmlns="http://www.springframework.org/schema/beans"
 2     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
 3     xmlns:context="http://www.springframework.org/schema/context"
 4     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
 5     xsi:schemaLocation="http://www.springframework.org/schema/beans
 6         http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
 7         http://www.springframework.org/schema/mvc
 8         http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
 9         http://www.springframework.org/schema/context
10         http://www.springframework.org/schema/context/spring-context-3.2.xsd
11         http://www.springframework.org/schema/aop
12         http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
13         http://www.springframework.org/schema/tx
14         http://www.springframework.org/schema/tx/spring-tx-3.2.xsd ">
15
16     <aop:aspectj-autoproxy proxy-target-class="true"/>
17
18     <!-- 可以扫描controller、service、... 这里让扫描controller，指定controller的包 com.ssm.controlle -->
19     <context:component-scan base-package="com.spring_redis">
20     </context:component-scan>
21     <!-- 使用 mvc:annotation-driven代替上边注解映射器和注解适配器配置 mvc:annotation-driven默认加载很多的参数绑定方法 -->
22     <mvc:annotation-driven />
23     <!-- 视图解析器 解析jsp解析，默认使用jstl标签，classpath下的得有jstl的包 -->
24     <bean
25         class="org.springframework.web.servlet.view.InternalResourceViewResolver">
26         <!-- 配置jsp路径的前缀 <property name="prefix" value="/jsp/"/> -->
27         <!-- 配置jsp路径的后缀 -->
28         <property name="suffix" value=".jsp" />
29     </bean>
30
31
32 </beans>

<aop:aspectj-autoproxy proxy-target-class="true"/> 开启注解这个一定要写到springmvc.xml里，否则注解会不起作用

　　那重点开始了

　　创建自定义注解

 1 /**
 2  * 自定义注解,对于查询使用缓存的方法加入该注解
 3  * @author Chenth
 4  */
 5 @Retention(RetentionPolicy.RUNTIME)
 6 @Target({ElementType.METHOD})
 7 public @interface GetCache {
 8     String name() default "";
 9     String value() default "";
10 }

　　被这个自定义注解所标记的方法将实现下面的切面

　　配置切面

  1 package com.spring_redis.cache;
  2
  3 import java.io.Serializable;
  4 import java.lang.reflect.Method;
  5
  6
  7 import org.aspectj.lang.JoinPoint;
  8 import org.aspectj.lang.ProceedingJoinPoint;
  9 import org.aspectj.lang.annotation.Around;
 10 import org.aspectj.lang.annotation.Aspect;
 11 import org.aspectj.lang.annotation.Pointcut;
 12 import org.aspectj.lang.reflect.MethodSignature;
 13 import org.springframework.beans.factory.annotation.Autowired;
 14 import org.springframework.data.redis.core.RedisTemplate;
 15 import org.springframework.stereotype.Component;
 16
 17 import com.spring_redis.util.RedisCache;
 18
 19 @Component
 20 @Aspect
 21 public class GetCacheAOP  {
 22
 23     @Autowired
 24     private RedisTemplate<Serializable, Object> redisTemplate;
 25
 26     private RedisCache redisCache = new RedisCache();
 27
 28
 29     @Pointcut("@annotation(com.spring_redis.cache.GetCache)")
 30     public void getCache(){
 31         System.out.println("我是一个切入点");
 32     }
 33
 34     /**
 35      * 在所有标注@getCache的地方切入
 36      * @param joinPoint
 37      */
 38     @Around("getCache()")
 39     public Object beforeExec(ProceedingJoinPoint joinPoint){
 40
 41
 42         //前置：到redis中查询缓存
 43         System.out.println("调用从redis中查询的方法...");
 44
 45         //redis中key格式：    id
 46         String redisKey = getCacheKey(joinPoint);
 47
 48         //获取从redis中查询到的对象
 49         Object objectFromRedis = redisCache.getDataFromRedis(redisKey);
 50
 51         //如果查询到了
 52         if(null != objectFromRedis){
 53             System.out.println("从redis中查询到了数据...不需要查询数据库");
 54             return objectFromRedis;
 55         }
 56
 57         System.out.println("没有从redis中查到数据...");
 58
 59         //没有查到，那么查询数据库
 60         Object object = null;
 61         try {
 62             object = joinPoint.proceed();
 63         } catch (Throwable e) {
 64
 65             e.printStackTrace();
 66         }
 67
 68         System.out.println("从数据库中查询的数据...");
 69
 70         //后置：将数据库中查询的数据放到redis中
 71         System.out.println("调用把数据库查询的数据存储到redis中的方法...");
 72
 73         redisCache.setDataToRedis(redisKey, object);
 74         System.out.println("redis中的数据..."+object.toString());
 75         //将查询到的数据返回
 76         return object;
 77     }
 78
 79     /**
 80      * 根据类名、方法名和参数值获取唯一的缓存键
 81      * @return 格式为 "包名.类名.方法名.参数类型.参数值"，类似 "your.package.SomeService.getById(int).123"
 82      */
 83
 84     @SuppressWarnings("unused")
 85     private String getCacheKey(ProceedingJoinPoint joinPoint) {
 86
 87
 88         MethodSignature ms=(MethodSignature) joinPoint.getSignature();
 89         Method method=ms.getMethod();
 90         String ActionName = method.getAnnotation(GetCache.class).name();
 91         String fieldList = method.getAnnotation(GetCache.class).value();
 92         //System.out.println("签名是"+ms.toString());
 93         for (String field:fieldList.split(","))
 94              ActionName +="."+field;
 95
 96         //先获取目标方法参数
 97         String id = null;
 98         Object[] args = joinPoint.getArgs();
 99         if (args != null && args.length > 0) {
100             id = String.valueOf(args[0]);
101         }
102
103         ActionName += "="+id;
104         String redisKey = ms+"."+ActionName;
105         return redisKey;
106     }
107
108
109     public void setRedisTemplate(
110             RedisTemplate<Serializable, Object> redisTemplate) {
111         this.redisTemplate = redisTemplate;
112     }
113 }

 @Pointcut("@annotation(com.spring_redis.cache.GetCache)") 这个切入点的作用是

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　在所有标注@getCache的地方切入

 @Around("getCache()")这里用的是后置通知，即查询之前先查询redis，如果有数据就返回数据，没有就穿透的数据库查询数据，之后再缓存到redis中

　　这里并没有太多的讲解配置ssm框架，可能后续会写关于spring+springmvc+mybatis的框架整合

　　编写mapper层,service层,controller层

　　mapper

/*** * @author     cmy* @date     2016-10-22* @description 持久化*/public interface RoomMapper {@Insert("insert into room(roomName,address) values(#{roomName},#{addRess})")int insert(Room room);@Select("select * from room where id=#{id}")public Room selectByPrimaryKey(@Param("id")Integer id);}

　　service

 1 /**
 2  *
 3  * @author     cmy
 4  * @date     2016-10-22
 5  * @description test
 6  */
 7 public interface RoomService {
 8
 9
10     int insert(Room room)throws Exception;
11
12
13     Room selectByPrimaryKey(Integer id)throws Exception;
14
15 }
16
17 // 实现
18 /**
19  * @author         cmy
20  * @date         2016-10-22
21  * @description  test 实现
22  */
23 public class RoomServiceImpl implements RoomService{
24
25     @Autowired
26     private RoomMapper mapper;
27
28     @Override
29     public int insert(Room room) throws Exception {
30
31         return mapper.insert(room);
32     }
33
34     @Override
35     public Room selectByPrimaryKey(Integer id) throws Exception {
36
37         return mapper.selectByPrimaryKey(id);
38     }
39
40
41 }

　　　controller

/*** * @author     cmy* @date     2016-10-22* @description test controller*/@Controller
@RequestMapping("room")
public class RoomController {@Autowiredprivate RoomService  roomService;@GetCache(name="room",value="id")@RequestMapping("selectByPrimaryKey")public @ResponseBody Object roomList(Integer id) throws Exception{  System.out.println("已查询到数据，准备缓存到redis...  "+roomService.selectByPrimaryKey(id).getRoomName());return roomService.selectByPrimaryKey(id);}}

　　缓存要用到的工具类 RedisCache

 1 public class RedisCache {
 2
 3     @Autowired
 4     private JedisPool jedisPool = new JedisPool();
 5
 6
 7     //从redis缓存中查询，反序列化
 8     public Object getDataFromRedis(String redisKey){
 9         //查询
10         Jedis jedis = jedisPool.getResource();
11         byte[] result = jedis.get(redisKey.getBytes());
12
13         //如果查询没有为空
14         if(null == result){
15             return null;
16         }
17
18         //查询到了，反序列化
19         return SerializeUtil.unSerialize(result);
20     }
21
22     //将数据库中查询到的数据放入redis
23     public void setDataToRedis(String redisKey, Object obj){
24
25         //序列化
26         byte[] bytes = SerializeUtil.serialize(obj);
27
28         //存入redis
29         Jedis jedis = jedisPool.getResource();
30         String success = jedis.set(redisKey.getBytes(), bytes);
31
32         if("OK".equals(success)){
33             System.out.println("数据成功保存到redis...");
34         }
35     }
36 }

　　缓存要用到的序列化和反序列化工具

 1 /**
 2  *
 3  * @Description: 序列化反序列化工具
 4  */
 5 public class SerializeUtil {
 6     /**
 7      *
 8      * 序列化
 9      */
10     public static byte[] serialize(Object obj){
11
12         ObjectOutputStream oos = null;
13         ByteArrayOutputStream baos = null;
14
15         try {
16             //序列化
17             baos = new ByteArrayOutputStream();
18             oos = new ObjectOutputStream(baos);
19
20             oos.writeObject(obj);
21             byte[] byteArray = baos.toByteArray();
22             return byteArray;
23
24         } catch (IOException e) {
25             e.printStackTrace();
26         }
27         return null;
28     }
29
30     /**
31      *
32      * 反序列化
33      * @param bytes
34      * @return
35      */
36     public static Object unSerialize(byte[] bytes){
37
38         ByteArrayInputStream bais = null;
39
40         try {
41             //反序列化为对象
42             bais = new ByteArrayInputStream(bytes);
43             ObjectInputStream ois = new ObjectInputStream(bais);
44             return ois.readObject();
45
46         } catch (Exception e) {
47             e.printStackTrace();
48         }
49         return null;
50     }
51 }

　以上就是利用aop+自定义注解实现 redis缓存的过程了

　　　　　　有不对之处，还望指出　欢迎留言

有参考到的文章：http://www.cnblogs.com/mrlinfeng/p/5857775.html

　　　　　　　　http://blog.csdn.net/chentian610/article/details/51012789

转载于:https://www.cnblogs.com/cmyxn/p/5990974.html