SSM框架集成Redis缓存

Redis缓存是一种根据根据key-map方式生成的缓存形式，一般数据会缓存到内存中，如果数据量比较大，可能需要进行相关设置，首先我们先尽心SSM框架集成Redis的一些配置。

1.首先在maven中加入jar包

     <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-ehcache</artifactId>
            <version>1.0.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.6.6.RELEASE</version>
        </dependency>
        <!-- redis客户端jar -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.8.0</version>
        </dependency>

2.在resources资源文件夹下加入redis.properties文件：

redis.host=192.168.1.103
redis.pass=
redis.hostName=127.0.0.1
redis.port=6379
redis.timeout=15000
redis.usePool=true

redis.maxIdle=6
redis.maxActive=100
redis.maxWait=3000
redis.minEvictableIdleTimeMillis=300000
redis.numTestsPerEvictionRun=3
redis.timeBetweenEvictionRunsMillis=60000
redis.testOnBorrow=true

3.在mybatis-config.xml文件中加入延时加载等属性

 <!-- 配置mybatis的缓存，延迟加载等等一系列属性 -->
    <settings>

        <!-- 全局映射器启用缓存 *主要将此属性设置完成即可 -->
        <setting name="cacheEnabled" value="true" />

        <!-- 查询时，关闭关联对象即时加载以提高性能 -->
        <setting name="lazyLoadingEnabled" value="false" />

        <!-- 对于未知的SQL查询，允许返回不同的结果集以达到通用的效果 -->
        <setting name="multipleResultSetsEnabled" value="true" />

        <!-- 设置关联对象加载的形态，此处为按需加载字段(加载字段由SQL指 定)，不会加载关联表的所有字段，以提高性能 -->
        <setting name="aggressiveLazyLoading" value="true" />

    </settings>

4.新建Redis配置文件RedisCache

package com.wuwei.console.config;

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;

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @auther XuXin
 * @date 2019/3/18 14:59
 */
public class RedisCache implements Cache {

    private static final Logger logger = LoggerFactory.getLogger(RedisCache.class);
    private static JedisConnectionFactory jedisConnectionFactory;
    private final String id;
    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 String getId() {
        return this.id;
    }

    @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 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 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;

    }

    @Override
    public void clear() {
        JedisConnection connection = null;
        try {
            connection = jedisConnectionFactory.getConnection(); //连接清除数据
            connection.flushAll();
        } catch (JedisConnectionException e) {
            e.printStackTrace();
        } finally {
            if (connection != null) {
                connection.close();
            }
        }

    }

    @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 ReadWriteLock getReadWriteLock() {
        return this.readWriteLock;
    }
    public static void setJedisConnectionFactory(JedisConnectionFactory jedisConnectionFactory){
        RedisCache.jedisConnectionFactory=jedisConnectionFactory;
    }
}

5.建立RedsiCacheTransfer.java

package com.wuwei.console.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;

/**
 * @auther XuXin
 * @date 2019/3/18 15:34
 */
public class RedisCacheTransfer {
    @Autowired
    public void setJedisConnectionFactory(JedisConnectionFactory jedisConnectionFactory) {
        RedisCache.setJedisConnectionFactory(jedisConnectionFactory);
    }
}

6.配置applicationcontext.xml，加入redis相关配置

    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="systemPropertiesModeName" value="SYSTEM_PROPERTIES_MODE_OVERRIDE" />
        <property name="ignoreResourceNotFound" value="true" />
        <property name="locations">
            <list>
                <value>classpath*:redis.properties</value>
            </list>
        </property>
    </bean>

    <!-- redis数据源 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="300" />
        <property name="maxTotal" value="100" />
        <property name="maxWaitMillis" value="10000" />
        <property name="testOnBorrow" value="true" />
    </bean>

    <!-- Spring-redis连接池管理工厂 -->
    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
          p:host-name="localhost" p:port="6379" p:password=""  p:pool-config-ref="poolConfig"/>
    <!-- 使用中间类解决RedisCache.jedisConnectionFactory的静态注入，从而使MyBatis实现第三方缓存 -->
    <bean id="redisCacheTransfer" class="com.wuwei.console.config.RedisCacheTransfer">
        <property name="jedisConnectionFactory" ref="jedisConnectionFactory"/>

    </bean>

7.在daoMapper中一定要加入这一句：加入引入RedisCache.class文件

<cache eviction="LRU" type="com.wuwei.console.config.RedisCache" />

<?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="com.wuwei.core.dao.FluxOutsideDao" >
    <cache eviction="LRU" type="com.wuwei.console.config.RedisCache" />---这句很重要

    <resultMap id="flux_outside_min_10" type="FluxOutsideMin10" >
        <id column="TmStamp" property="tmStamp" />
        <result column="RecNum" property="recNum" />
        <result column="albedo_Avg" property="albedoAvg" />
        <result column="R_SW_in_Avg" property="rSwInAvg" />
        <result column="R_SW_out_Avg" property="rSwOutAvg" />
    </resultMap>
    <select id="getFlux" parameterType="Map"  resultMap="flux_outside_min_10">
        SELECT  *  FROM flux_outside_min_10
        limit #{pageStart} ,#{pageSize}
    </select>

    <select id="totalCount" resultType="Long">
        SELECT  count(*)  FROM flux_outside_min_10
    </select>


    <cache type="org.mybatis.caches.ehcache.EncacheCache"/>

</mapper>

8.最重要的是entity层实体类一定要序列化   implements Serializable(相当重要)

package com.wuwei.core.entity;

import java.io.Serializable;
import java.util.Date;

public class FluxOutsideMin10 implements Serializable {
    //时间标签
    private Date tmStamp;
    private long recNum;
    private float albedoAvg;
    private float rSwInAvg;
    private float rSwOutAvg;

    public Date getTmStamp() {
        return tmStamp;
    }

    public void setTmStamp(Date tmStamp) {
        this.tmStamp = tmStamp;
    }

    public long getRecNum() {
        return recNum;
    }

    public void setRecNum(long recNum) {
        this.recNum = recNum;
    }

    public float getAlbedoAvg() {
        return albedoAvg;
    }

    public void setAlbedoAvg(float albedoAvg) {
        this.albedoAvg = albedoAvg;
    }

    public float getrSwInAvg() {
        return rSwInAvg;
    }

    public void setrSwInAvg(float rSwInAvg) {
        this.rSwInAvg = rSwInAvg;
    }

    public float getrSwOutAvg() {
        return rSwOutAvg;
    }

    public void setrSwOutAvg(float rSwOutAvg) {
        this.rSwOutAvg = rSwOutAvg;
    }
}

9、配置Mybatis缓存

Mybatis-config.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>

    <!--配置Mybatis缓存，延迟加载等一系列属性-->
    <settings>
        <!--全局映射启用缓存 * 表示将此属性设置完成即可-->
        <setting name="cacheEnabled" value="true"/>

        <!--查询时，关闭关联对象即时加载提高性能-->
        <setting name="lazyLoadingEnables" value="false"/>

        <!--对于未知SQl查询，允许返回不同的结果集以达到通用效果-->
        <setting name="multipleResultSetsEnabled" value="true"/>

        <!--设置关联对象加载状态，此处为按需加载字段（加载字段由SQL指定），不会加载关联标的所有字段，以提高性能-->
        <setting name="aggressiveLazyLoading" value="true"/>

    </settings>
    <!-- entity aliases -->
    <typeAliases>
        <package name="com.wuwei.core.entity"/>
    </typeAliases>

    <!-- mapper xml -->
    <mappers>
        <package name="com.wuwei.core.dao"/>
    </mappers>

</configuration>

 

跑一些，做个对比，发现是真的快了不少！！！！