使用Redis做MyBatis的二级缓存

àì夳堔傛蜴生んèń 2022-01-31 03:39 225阅读 0赞

1. 介绍

使用mybatis时可以使用二级缓存提高查询速度，进而改善用户体验。

使用redis做mybatis的二级缓存可是内存可控<如将单独的服务器部署出来用于二级缓存>，管理方便。

2. 使用思路

2.1 配置redis.xml 设置redis服务连接各参数

2.1 在配置文件中使用 <setting> 标签，设置开启二级缓存；

2.2 在mapper.xml 中使用<cache type="com.demo.RedisCacheClass" /> 将cache映射到指定的RedisCacheClass类中；

2.3 映射类RedisCacheClass 实现 MyBatis包中的Cache类，并重写其中各方法；

在重写各方法体中，使用redisFactory和redis服务建立连接，将缓存的数据加载到指定的redis内存中(putObject方法)或将redis服务中的数据从缓存中读取出来(getObject方法)；

在redis服务中写入和加载数据时需要借用spring-data-redis.jar中JdkSerializationRedisSerializer.class中的序列化(serialize)和反序列化方法(deserialize),此为包中封装的redis默认的序列化方法；

2.4 映射类中的各方法重写完成后即可实现mybatis数据二级缓存到redis服务中；

3. 代码实践

3.1 配置redis.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:p="http://www.springframework.org/schema/p"
        xmlns:mvc="http://www.springframework.org/schema/mvc"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:tx="http://www.springframework.org/schema/tx"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:task="http://www.springframework.org/schema/task"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc-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.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-3.0.xsd
        http://www.springframework.org/schema/task
        http://www.springframework.org/schema/task/spring-task-3.0.xsd" >
        
        <context:annotation-config /> 
           
        <task:annotation-driven/>
        
        <context:component-scan base-package="demo.util,demo.salesorder,demo.person" />
        
        <mvc:annotation-driven />
        
        <bean id="propertyConfigurer"    class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
            <property name="locations">
                <list>
                    <value>classpath:sysconfig/jdbc.properties</value>
                    <value>classpath:sysconfig/redis.properties</value>
                </list>
            </property>
        </bean>
        
        <bean id="defaultDataSource"   class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"
            p:driverClassName="${jdbc.driverClassName}"
            p:url="${jdbc.databaseurl}"
            p:username="${jdbc.username}"
            p:password="${jdbc.password}" >
            <property name="maxActive">
                <value>${jdbc.maxActive}</value>
            </property>  
            <property name="initialSize">
                <value>${jdbc.initialSize}</value>
            </property>  
            <property name="maxWait">
                <value>${jdbc.maxWait}</value>
            </property>  
            <property name="maxIdle">
                <value>${jdbc.maxIdle}</value>
            </property>
            <property name="minIdle">
                <value>${jdbc.minIdle}</value>
            </property>
            
            <property name="timeBetweenEvictionRunsMillis">
                <value>18000000</value>
            </property>
            <property name="minEvictableIdleTimeMillis">
                <value>10800000</value>
            </property>
            <property name="validationQuery">
                <value>SELECT 1</value>
            </property>
            <property name="testOnBorrow">
                <value>true</value>
            </property>
        </bean>
        
        
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="defaultDataSource" />
            <property name="typeAliasesPackage" value="demo.salesorder,demo.person" />
             
            <property name="configLocation" value="classpath:sysconfig/mybatis-config.xml" />
        </bean>
        
        
        
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <property name="basePackage" value="demo.*.data" />
            <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
        </bean>
        
        
        
        
        <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">  
            <property name="maxIdle" value="${redis.maxIdle}" />  
            <property name="maxTotal" value="${redis.maxActive}" />  
            <property name="maxWaitMillis" value="${redis.maxWait}" />  
            <property name="testOnBorrow" value="${redis.testOnBorrow}" />  
        </bean>
        
        
        <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
            <property name="hostName" value="${redis.host}" />
            <property name="port" value="${redis.port}" />
            <property name="password" value="${redis.pass}" />
            <property name="timeout" value="${redis.timeout}" />
            <property name="poolConfig" ref="poolConfig" />
        </bean>      
        
        <bean id="redisCacheTransfer" class="demo.redis.RedisCacheTransfer">
            <property name="jedisConnectionFactory" ref="jedisConnectionFactory"/>
        </bean>      
        
        <bean class="demo.util.UTF8StringBeanPostProcessor"></bean>          
    </beans>

3.2 mybatis.xml 配置开启二级缓存

<?xml version="1.0" encoding="UTF-8" ?>  
    <!DOCTYPE configuration 
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
        
        <settings>
    
            
            <setting name="cacheEnabled" value="true"/>
    
            
            <setting name="lazyLoadingEnabled" value="false"/>
    
            
            <setting name="multipleResultSetsEnabled" value="true"/>
    
            
            <setting name="aggressiveLazyLoading" value="true"/>
    
        </settings>
    </configuration>

3.3 在mapper.xml中映射缓存类RedisCacheClass

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    
    <mapper namespace="demo.person.data.UserMapper">
    <cache type="demo.redis.cache.RedisCache"/> 
    
    <select id="getPersonList" parameterType="map" resultType="Person">
        select *    
         from person
        <where>
            1=1
            <if test="user_name!=null">
                and user_name=#{user_name}
            </if>    
        </where>
    </select>
    <insert id="addPerson" parameterType="Person" keyProperty="id" useGeneratedKeys="true">
        insert into person(
            login_id,
            user_name,
            gender,
            birthday,
            remark
        )values(
            #{login_id},
            #{user_name},
            #{gender},
            #{birthday},
            #{remark}
        )
    </insert>
    
    </mapper>

3.4 实现Mybatis中的Cache接口

/*
     *    Copyright 2009-2012 the original author or authors.
     *    http://www.apache.org/licenses/LICENSE-2.0*/
    package org.apache.ibatis.cache;
    
    import java.util.concurrent.locks.ReadWriteLock;
    
    public interface Cache {
    
      String getId();
    
      int getSize();
    
      void putObject(Object key, Object value);
    
      Object getObject(Object key);
    
      Object removeObject(Object key);
    
      void clear();
    
      ReadWriteLock getReadWriteLock();
    
    }
    
     
    　　　　RedisCache.java
    
    package demo.redis.cache;
    
    import java.util.concurrent.locks.ReadWriteLock;
    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    import org.apache.ibatis.cache.Cache;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.data.redis.connection.jedis.JedisConnection;
    import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
    import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
    import org.springframework.data.redis.serializer.RedisSerializer;
    
    import redis.clients.jedis.exceptions.JedisConnectionException;
    
    
    public class RedisCache implements Cache //实现类
    {
        private static final Logger logger = LoggerFactory.getLogger(RedisCache.class);
    
        private static JedisConnectionFactory jedisConnectionFactory;
    
        private final String id;
    
        /**
         * The {@code ReadWriteLock}.
         */
        private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    
        public RedisCache(final String id) {
            if (id == null) {
                throw new IllegalArgumentException("Cache instances require an ID");
            }
            logger.debug("MybatisRedisCache:id=" + id);
            this.id = id;
        }
    
        @Override
        public void clear()
        {
            JedisConnection connection = null;
            try
            {
                connection = jedisConnectionFactory.getConnection(); //连接清除数据
                connection.flushDb();
                connection.flushAll();
            }
            catch (JedisConnectionException e)
            {
                e.printStackTrace();
            }
            finally
            {
                if (connection != null) {
                    connection.close();
                }
            }
        }
    
        @Override
        public String getId()
        {
            return this.id;
        }
    
        @Override
        public Object getObject(Object key)
        {
            Object result = null;
            JedisConnection connection = null;
            try
            {
                connection = jedisConnectionFactory.getConnection();
                RedisSerializer<Object> serializer = new JdkSerializationRedisSerializer(); //借用spring_data_redis.jar中的JdkSerializationRedisSerializer.class
                result = serializer.deserialize(connection.get(serializer.serialize(key))); //利用其反序列化方法获取值
            }
            catch (JedisConnectionException e)
            {
                e.printStackTrace();
            }
            finally
            {
                if (connection != null) {
                    connection.close();
                }
            }
            return result;
        }
    
        @Override
        public ReadWriteLock getReadWriteLock()
        {
            return this.readWriteLock;
        }
    
        @Override
        public int getSize()
        {
            int result = 0;
            JedisConnection connection = null;
            try
            {
                connection = jedisConnectionFactory.getConnection();
                result = Integer.valueOf(connection.dbSize().toString());
            }
            catch (JedisConnectionException e)
            {
                e.printStackTrace();
            }
            finally
            {
                if (connection != null) {
                    connection.close();
                }
            }
            return result;
        }
    
        @Override
        public void putObject(Object key, Object value)
        {
            JedisConnection connection = null;
            try
            {
                logger.info(">>>>>>>>>>>>>>>>>>>>>>>>putObject:"+key+"="+value);
                connection = jedisConnectionFactory.getConnection();
                RedisSerializer<Object> serializer = new JdkSerializationRedisSerializer(); //借用spring_data_redis.jar中的JdkSerializationRedisSerializer.class
                connection.set(serializer.serialize(key), serializer.serialize(value)); //利用其序列化方法将数据写入redis服务的缓存中
                
            }
            catch (JedisConnectionException e)
            {
                e.printStackTrace();
            }
            finally
            {
                if (connection != null) {
                    connection.close();
                }
            }
        }
    
        @Override
        public Object removeObject(Object key)
        {
            JedisConnection connection = null
            Object result = null;
            try
            {
                connection = jedisConnectionFactory.getConnection();
                RedisSerializer<Object> serializer = new JdkSerializationRedisSerializer();
                result =connection.expire(serializer.serialize(key), 0);
            }
            catch (JedisConnectionException e)
            {
                e.printStackTrace();
            }
            finally
            {
                if (connection != null) {
                    connection.close();
                }
            }
            return result;
        }
    
        public static void setJedisConnectionFactory(JedisConnectionFactory jedisConnectionFactory) {
            RedisCache.jedisConnectionFactory = jedisConnectionFactory;
        }
    
    }