ssm+reids缓存整合
在说正文之前我们先介绍一下redis:
redis是当今比较热门的非关系型数据库之一，他使用的是key-value的键值对来进行存储，是一个存在于内存之中的数据库，我们一般用于做数据缓存。当我们需要大量的数据查询时，如果我们都直接访问数据库时，会严重影响数据库性能。所以我们一般的操作就是在db层之上的各级使用多级的no-sql来为db提供缓冲。
因为redis是存在于内存之中，那么问题来了当我们断电时或者宕机时就会产生数据丢失，所以redis为我们提供了rdb和aof的两种持久化保存的方式，这也是为什么同样是缓存数据库我们选择redis而不选择memcache的原因。而且为了在大流量下提供稳定业务，redis还提供了redis-cluster，twemproxy，codis等集群化方案，为我们搭建分布式系统提供了可能。废话说了这么多下面开始正文。
一.添加redis对应的依赖
<!-- reids缓存--> <!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-redis --> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redis</artifactId> <version>${redis.data.version}</version> </dependency> <!-- https://mvnrepository.com/artifact/redis.clients/jedis --> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>${redis.clients.version}</version> </dependency>
依赖版本大家可以下用的最多的比较稳定。
二.添加相应的spring配置
<?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" 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 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> <!--开启aop代理--> <aop:aspectj-autoproxy expose-proxy="true"/> <!--spring添加注解扫描--> <context:annotation-config></context:annotation-config> <!--spring 注解扫描但是要排除spring mvc的控制器--> <context:component-scan base-package="com"> <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"></context:exclude-filter> </context:component-scan> <!--加载资源文件,该标签全文只能有一个--> <context:property-placeholder location="classpath:jdbc.properties,classpath:redisconfig.properties"/> <!--配置数据源，阿里数据连接池--> <bean id="dataSource" class="${jdbc.dataType}" destroy-method="close"> <property name="driverClassName" value="${jdbc.driver}"/> <property name="url" value="${jdbc.url}"/> <property name="username" value="${jdbc.usename}"/> <property name="password" value="${jdbc.password}"/> <!-- 数据库连接池配置 --> <property name="initialSize" value="20"/><!-- 初始化连接数量 --> <property name="minIdle" value="5"/> <!-- 最小空闲连接数量 --> <property name="maxActive" value="1500"/> <!-- 最大连接数量 --> <property name="maxWait" value="60000"/> <!-- 最大建立连接等待时间(毫秒)。如果超过此时间将接到异常。设为－1表示无限制--> <property name="timeBetweenEvictionRunsMillis" value="60000"/> <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 --> <property name="minEvictableIdleTimeMillis" value="300000"/> <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 --> <property name="validationQuery" value="SELECT 'x'"/> <property name="testWhileIdle" value="true"/> <!--空闲时是否进行验证，检查对象是否有效 --> <property name="testOnBorrow" value="false"/> <!--取得对象时是否进行验证，检查对象是否有效 --> <property name="testOnReturn" value="false"/> <!--返回对象时是否进行验证 --> <!-- 打开PSCache，并且指定每个连接上PSCache的大小 --> <property name="poolPreparedStatements" value="true"/> <!-- 表明是否开启statement cache，默认为false，也就是不开启 --> <property name="maxPoolPreparedStatementPerConnectionSize" value="20"/> <!-- statement cache的大小，默认为-1，也就是不限制 --> <!-- 配置监控统计拦截的filters，去掉后监控界面sql无法统计 --> <property name="filters" value="stat"/> </bean> <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="configLocation" value="classpath:mybatis-config.xml"/> <property name="dataSource" ref="dataSource"/> <!-- 扫描entity包 使用别名 --> <property name="typeAliasesPackage" value="com.lwc.pojo"/> <!-- 扫描sql配置文件:mapper需要的xml文件 --> <property name="mapperLocations" value="classpath*:com/lwc/dao/mapper/*.xml"/> </bean> <!--根据接口名生成对应的代理类--> <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"> <property name="basePackage" value="com.lwc.dao"/> <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/> </bean> <!-- 配置事务管理器 --> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <!-- 注入数据库连接池 --> <property name="dataSource" ref="dataSource"/> </bean> <!--配置事务切面--> <aop:config> <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.lwc.service.*.*(..))"></aop:advisor> </aop:config> <!-- 2 事务详情（事务通知） ， 在aop筛选基础上，比如对ABC三个确定使用什么样的事务。例如：AC读写、B只读 等 <tx:attributes> 用于配置事务详情（属性属性） <tx:method name=""/> 详情具体配置 propagation 传播行为 ， REQUIRED：必须；REQUIRES_NEW:必须是新的 isolation 隔离级别 --> <tx:advice id="txAdvice" transaction-manager="transactionManager"> <tx:attributes> <tx:method name="*" propagation="REQUIRED"/> </tx:attributes> </tx:advice> <!--配置redis缓存--> <!--redis配置--> <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig"> <!--控制一个pool最多有多少个状态为空闲的jedis实例--> <property name="maxIdle" value="${redis.maxIdle}"></property> <!--当borrow(引入)一个实例时，最大的等待时间，如果超过则抛出jedisConnectionException--> <property name="maxWaitMillis" value="${redis.maxWaitMillis}"></property> <property name="maxTotal" value="${redis.maxTotal}"></property> <!-- 在在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的--> <property name="testOnBorrow" value="${redis.testOnBorrow}"></property> </bean> <!--redis连接池--> <bean id="jedisPool" class="redis.clients.jedis.JedisPool"> <constructor-arg index="0" ref="jedisPoolConfig"></constructor-arg> <constructor-arg index="1" value="${redis.host}"></constructor-arg> <constructor-arg index="2" value="${redis.port}"></constructor-arg> <constructor-arg index="3" value="${redis.timeout}"></constructor-arg> </bean> <!-- redis连接工厂 --> <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="poolConfig" ref="jedisPoolConfig"></property> </bean> <!-- redis操作模板，这里采用尽量面向对象的模板 --> <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"> <property name="connectionFactory" ref="JedisConnectionFactory"/> <property name="keySerializer" ref="stringReadisSerializer"/> <property name="valueSerializer" ref="stringReadisSerializer"/> <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"/> </bean> <!--使用字符串进行序列化--> <bean id="stringReadisSerializer" class="org.springframework.data.redis.serializer.StringRedisSerializer"/> <!--使用JDK的序列化器进行转化--> <bean id="jdkSerializationRedisSerializer" class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/> <bean id="getCache" class="com.lwc.redis.aspectj.GetCachAop"> <property name="redisTemplate" ref="redisTemplate"/> </bean> </beans>
这里是spring的基本配置，这里我没有分开来，反正都有注释
三.redis的一些基本资源文件
redis.host=localhost redis.port=6379 redis.maxIdle=50 redis.maxTotal=100 redis.maxWaitMillis=3000 redis.testOnBorrow=true redis.timeout=5000
这里我没有配置密码，所以就没有写pass,但是如果有需要的话可以找到redis的配置文件加上如下语句
这样就可以了，如果没有配置密码而配置了<property name="password" value="${redis.password}" />将会报错
四.利用aop和自定义注解来进行实现环绕
下面是自定义注解，并且配上了一些注解的解释，还没有学过自定注解的小伙伴可以看看
package com.lwc.redis.annotation; import java.lang.annotation.*; /**自定义注解 * 2.1.1 Target:表示注解的作用目标 * * @Target(ElementType.TYPE) //接口、类、枚举、注解 * * @Target(ElementType.FIELD) //字段、枚举的常量 * * @Target(ElementType.METHOD) //方法 * * @Target(ElementType.PARAMETER) //方法参数 * * @Target(ElementType.CONSTRUCTOR) //构造函数 * * @Target(ElementType.LOCAL_VARIABLE)//局部变量 * * @Target(ElementType.ANNOTATION_TYPE)//注解 * * @Target(ElementType.PACKAGE) ///包 * * 2.1.2 @Documented：说明该注解将被包含在javadoc中； * * 2.1.3 @Inherited：说明子类可以继承父类中的该注解 ； * * 2.1.4 @Retention：注解的保留位置； * * @Retention(RetentionPolicy.SOURCE) //注解仅存在于源码中，在class字节码文件中不包含 * * @Retention(RetentionPolicy.CLASS) // 默认的保留策略，注解会在class字节码文件中存在，但运行时无法获得， * * @Retention(RetentionPolicy.RUNTIME) // 注解会在class字节码文件中存在，在运行时可以通过反射获取到 */ @Target(ElementType.METHOD)//目标为方法 @Retention(RetentionPolicy.RUNTIME)//注解在类中存在，运行时通过反射获取 @Documented @Inherited public @interface GetCache { String name() default ""; String value() default ""; }
定义这个注解是为了让aop可以直接根据注解来进行切面环绕，而不需要根据传统的方法来进行切点，这样会方便很多，否则的话就需要
定义接口然后对接口需要的方法进行定义切点，在实现该接口，这样也可以做到切面环绕，但是会更麻烦点，有兴趣的小伙伴可以自己试试
通知类：
package com.lwc.redis.aspectj; import com.lwc.redis.annotation.GetCache; import com.lwc.util.RedisCache; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Pointcut; import org.aspectj.lang.reflect.MethodSignature; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.stereotype.Component; import java.io.Serializable; import java.lang.reflect.Method; @Component @Aspect public class GetCachAop { @Autowired private RedisTemplate<Serializable,Object> redisTemplate; private RedisCache redisCache=new RedisCache(); //定义切点 @Pointcut("@annotation(com.lwc.redis.annotation.GetCache)") public void getCache(){ System.out.println("获取内存数据切入点"); } /*在所有标注了GetCache的地方切入*/ @Around("getCache()") public Object beforeExec(ProceedingJoinPoint joinPoint){ //生成redis中的id,根据自己指定的格式 String redisKey=getCacheKey(joinPoint); //获取从redis中查询得到的对象 Object object=redisCache.getDataFromRedis(redisKey); //如果查询到了 if(null!=object){ System.out.println("从redis中获取到了数据"); return object; }else{ System.out.println("从数据库中查询数据"); //如果没有查询到，则在数据库中进行查询 try { object=joinPoint.proceed(); } catch (Throwable throwable) { throwable.printStackTrace(); } } //在目标方法执行完之后：将查到的数据放入到redis中 redisCache.setDataToRedis(redisKey,object); return object; } /** * 根据方法名参数名类名获取唯一的一个键值 * 格式为yourpackage.classname.methodname(int).argsvalue123 * @param joinPoint * @return */ //变量没有用到时不让警告 @SuppressWarnings("unused") private String getCacheKey(ProceedingJoinPoint joinPoint){ //获取切入方法的一些相关的信息 MethodSignature ms=(MethodSignature) joinPoint.getSignature(); Method method=ms.getMethod(); //获取注解中设置的对应参数 String ActionName=method.getAnnotation(GetCache.class).value(); String fieldList=method.getAnnotation(GetCache.class).name(); for(String field:fieldList.split(".")) ActionName+="."+field; //获取切点方法的参数 String id=null; Object[] args=joinPoint.getArgs(); if(args!=null && args.length>0) id=String.valueOf(args[0]); ActionName+="="+id; String redisKey=ms+"."+ActionName; return redisKey; } public void setRedisTemplate( RedisTemplate<Serializable, Object> redisTemplate){ this.redisTemplate = redisTemplate; } }
上面代码都有详细注释这里就不重复了
下面是序列化的工具类：
package com.lwc.util; import java.io.*; public class SerializableUtil { //将字节数组反序列化为对象 public static Object toObject(byte[] bytes){ Object obj=null; try{ ByteArrayInputStream bis=new ByteArrayInputStream(bytes); ObjectInputStream ois=new ObjectInputStream(bis); obj=ois.read(); ois.close(); bis.close(); } catch (IOException e) { e.printStackTrace(); } return obj; } //将对象序列化为字节数组 public static byte[] toByteArray(Object obj){ byte[] bytes =null; ByteArrayOutputStream bos =new ByteArrayOutputStream(); try{ ObjectOutputStream oos=new ObjectOutputStream(bos); oos.writeObject(obj); oos.flush(); bytes=bos.toByteArray(); oos.close(); bos.close(); } catch (IOException e) { e.printStackTrace(); } return bytes; } }
下面是缓存工具类：
package com.lwc.util; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.support.ClassPathXmlApplicationContext; import org.springframework.stereotype.Component; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; /** * redis缓存工具类 */ public class RedisCache { private static JedisPool jedisPool; //静态类进行参数的初始化 static { ClassPathXmlApplicationContext cxac=new ClassPathXmlApplicationContext("applicationContext.xml"); jedisPool=(JedisPool) cxac.getBean("jedisPool"); } //从缓存中读取数据，进行反序列化 public Object getDataFromRedis(String redisKey){ Jedis jedis=jedisPool.getResource(); byte[] result=jedis.get(redisKey.getBytes()); //如果没有查询到，就返回空 if(null==result) return null; return SerializableUtil.toObject(result); } //将数据库中查到的数据放入redis中 public void setDataToRedis(String redisKey,Object obj){ byte[] bytes =SerializableUtil.toByteArray(obj); Jedis jedis=jedisPool.getResource(); String sucess=jedis.set(redisKey.getBytes(),bytes); if("OK".equals(sucess)){ System.out.println("数据保存成功"); } } }
当然我也看到有人继承cach类来使用redis缓存，下面贴出别人的代码并进行解释：
package com.ssm.redis; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; import org.apache.ibatis.cache.Cache; import org.springframework.beans.factory.annotation.Autowired; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; import redis.clients.jedis.JedisPoolConfig; public class RedisCache implements Cache { private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock(); /** * Jedis客户端 */ @Autowired private Jedis redisClient = createClient(); private String id; public RedisCache(final String id) { if (id == null) { throw new IllegalArgumentException("必须传入ID"); } System.out.println("MybatisRedisCache:id=" + id); this.id = id; } @Override public void clear() { redisClient.flushDB(); } @Override public String getId() { return this.id; } @Override public Object getObject(Object key) { byte[] ob = redisClient.get(SerializeUtil.serialize(key.toString())); if (ob == null) { return null; } Object value = SerializeUtil.unSerialize(ob); return value; } @Override public ReadWriteLock getReadWriteLock() { return readWriteLock; } @Override public int getSize() { return Integer.valueOf(redisClient.dbSize().toString()); } @Override public void putObject(Object key, Object value) { redisClient.set(SerializeUtil.serialize(key.toString()), SerializeUtil.serialize(value)); } @Override public Object removeObject(Object key) { return redisClient.expire(SerializeUtil.serialize(key.toString()), 0); } protected static Jedis createClient() { try { @SuppressWarnings("resource") JedisPool pool = new JedisPool(new JedisPoolConfig(), "127.0.0.1", 6379); return pool.getResource(); } catch (Exception e) { e.printStackTrace(); } throw new RuntimeException("初始化连接池错误"); } }
这个其实是使用mybatis自带的二级缓存，从写mybatis中的缓存类来进行实现使用这种方法就不需要额外的添加aop之类的只需要在映射的dao文件中添加<cache type="packagename.RedisCache" />这样便可以直接使用redis而不需要aop配置
言归正传，我们接着使用aop来实现redis整合，下面是service使用注解来进行实现redis存取
package com.lwc.service; import com.lwc.dao.UserDao; import com.lwc.pojo.User; import com.lwc.redis.annotation.GetCache; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; @Service public class UserService { @Autowired private UserDao userDao; @GetCache(name = "user" ,value = "id") public User getUser(Integer id){ return userDao.selectUser(id); } }
这样我们每次调用service的这个方法就可以实现从redis存取数据了。其他的UserDao和对应的映射文件我这里就不贴出来了
值得一说的是这里的实体类要继承Serializable 接口，不然会报错，因为他时间实例化对象进行序列化存入内存之中。
以上就完成了基本的redis的使用，下篇博文将会介绍redis的持久化
