SSM+Redis整合

今天药忘吃喽~ 2022-02-03 13:59 199阅读 0赞

记着:Spring与Redis整合其实是缓存的整合，不在spring部分，而在mybatis部分！！！

在网上找了很多博客，最后找到这篇博文才算整合完成：https://blog.csdn.net/zhanglf02/article/details/74999231\#commentBox 十分感谢博主！

项目结构:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhZHkxMzI_size_16_color_FFFFFF_t_70]  
1、添加pom依赖

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    	<groupId>com.gm</groupId>
    	<artifactId>SSM-Redis</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<packaging>war</packaging>
    	
    	<properties>
    		
    		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    		<junit.version>4.9</junit.version>
    		<spring.version>4.3.1.RELEASE</spring.version>
    		<mybatis.version>3.4.4</mybatis.version>
    		<mybatis.spring.version>1.3.1</mybatis.spring.version>
    		<commons-dbcp.version>1.4</commons-dbcp.version>
    		<jstl.version>1.2</jstl.version>
    		<log4j.version>1.2.17</log4j.version>
    		<fastjson.version>1.2.35</fastjson.version>
    		<slf4j.version>1.7.25</slf4j.version>
    		<jackson.version>1.9.13</jackson.version>
    		<commons-fileupload.version>1.3.3</commons-fileupload.version>
    		<commons-io.version>2.5</commons-io.version>
    		<commons-codec.version>1.10</commons-codec.version>
    		<aspectjweaver.version>1.8.11</aspectjweaver.version>
    	</properties>
    	<dependencies>
    		
    		
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-core</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-web</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-oxm</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-tx</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-jdbc</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-webmvc</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-aop</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-context-support</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-test</artifactId>
    			<version>${spring.version}</version>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>org.mybatis</groupId>
    			<artifactId>mybatis</artifactId>
    			<version>${mybatis.version}</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>org.mybatis</groupId>
    			<artifactId>mybatis-spring</artifactId>
    			<version>${mybatis.spring.version}</version>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>mysql</groupId>
    			<artifactId>mysql-connector-java</artifactId>
    			<version>5.1.6</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>commons-dbcp</groupId>
    			<artifactId>commons-dbcp</artifactId>
    			<version>${commons-dbcp.version}</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>jstl</groupId>
    			<artifactId>jstl</artifactId>
    			<version>${jstl.version}</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>log4j</groupId>
    			<artifactId>log4j</artifactId>
    			<version>${log4j.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.slf4j</groupId>
    			<artifactId>slf4j-api</artifactId>
    			<version>${slf4j.version}</version>
    		</dependency>
    		<dependency>
    			<groupId>org.slf4j</groupId>
    			<artifactId>slf4j-log4j12</artifactId>
    			<version>${slf4j.version}</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>com.alibaba</groupId>
    			<artifactId>fastjson</artifactId>
    			<version>${fastjson.version}</version>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>org.apache.commons</groupId>
    			<artifactId>commons-lang3</artifactId>
    			<version>3.8.1</version>
    		</dependency>
    		
    		<dependency>
    			<groupId>commons-codec</groupId>
    			<artifactId>commons-codec</artifactId>
    			<version>${commons-codec.version}</version>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>org.aspectj</groupId>
    			<artifactId>aspectjweaver</artifactId>
    			<version>${aspectjweaver.version}</version>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>javax.servlet</groupId>
    			<artifactId>javax.servlet-api</artifactId>
    			<version>4.0.0-b07</version>
    			<scope>provided</scope>
    		</dependency>
    
    		
    		<dependency>
    			<groupId>junit</groupId>
    			<artifactId>junit</artifactId>
    			<version>4.10</version>
    		</dependency>
    		
    		 
            <dependency>
                <groupId>org.springframework.data</groupId>
                <artifactId>spring-data-redis</artifactId>
                <version>1.0.2.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
                <version>2.1.0</version>
            </dependency>
     
            <dependency>
                <groupId>org.mybatis.caches</groupId>
                <artifactId>mybatis-redis</artifactId>
                <version>1.0.0-beta2</version>
            </dependency>
            
    	</dependencies>
    	<build>
    		<plugins>
    			
    			<plugin>
    				<groupId>org.apache.maven.plugins</groupId>
    				<artifactId>maven-compiler-plugin</artifactId>
    				<version>2.3.2</version>
    				<configuration>
    					<source>1.8</source>
    					<target>1.8</target>
    				</configuration>
    			</plugin>
    		</plugins>
    		<finalName>redis</finalName>
    	</build>
    </project>

2、配置资源文件:

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop"
    	xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
    	xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/aop
            http://www.springframework.org/schema/aop/spring-aop.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd
            http://www.springframework.org/schema/mvc
            http://www.springframework.org/schema/mvc/spring-mvc.xsd
            http://www.springframework.org/schema/tx
            http://www.springframework.org/schema/tx/spring-tx.xsd">
    
    	
    	<context:component-scan base-package="com.gm.*"
    		use-default-filters="true">
    		<context:exclude-filter type="annotation"
    			expression="org.springframework.stereotype.Controller" />
    	</context:component-scan>
    
    	
    	<context:annotation-config />
    
    	
    	<bean
    		class="org.springframework.beans.factory.config.PreferencesPlaceholderConfigurer">
    		<property name="locations">
    			<list>
    				<value>classpath:db.properties</value>
    			</list>
    		</property>
    
    	</bean>
    
    
    	
    	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
    		<property name="driverClassName" value="${driver}"></property>
    		<property name="url" value="${url}"></property>
    		<property name="username" value="${username}"></property>
    		<property name="password" value="${password}"></property>
    	</bean>
    
    
    	
    	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    		
    		<property name="dataSource" ref="dataSource" />
    
    		
    		
    
    		
    		<property name="mapperLocations" value="classpath:com/gm/dao/*Dao.xml"></property>
    
    		
    		
    
    		
    		<property name="typeAliasesPackage" value="com.gm.entity"></property>
    
    
    		
    		<property name="configurationProperties">
    			<props>
    				
    				<prop key="cacheEnabled">true</prop>
    				
    				<prop key="lazyLoadingEnabled">false</prop>
    				
    				<prop key="aggressiveLazyLoading">true</prop>
    			</props>
    		</property>
    		
    	</bean>
    
    	
    	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    
    		
    		<property name="basePackage" value="com.gm.dao" />
    	</bean>
    
    	
    	<bean id="transactionManager"
    		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    		
    		<property name="dataSource" ref="dataSource"></property>
    	</bean>
    
    	
    	<tx:advice id="txAdvice" transaction-manager="transactionManager">
    		<tx:attributes>
    			<tx:method name="add*" propagation="REQUIRED" />
    			<tx:method name="save*" propagation="REQUIRED" />
    			<tx:method name="insert*" propagation="REQUIRED" />
    			<tx:method name="regist*" propagation="REQUIRED" />
    			<tx:method name="update*" propagation="REQUIRED" />
    			<tx:method name="modify*" propagation="REQUIRED" />
    			<tx:method name="del*" propagation="REQUIRED" />
    			<tx:method name="remove**" propagation="REQUIRED" />
    			<tx:method name="*" propagation="SUPPORTS" read-only="true" />
    		</tx:attributes>
    	</tx:advice>
    
    	
    	<aop:config>
    		
    		<aop:pointcut expression="execution(* com.gm.service.impl.*.*(..))"
    			id="txPoint" />
    		
    		<aop:advisor advice-ref="txAdvice" pointcut-ref="txPoint" />
    	</aop:config>
    
    </beans>

db.properties

driver = com.mysql.jdbc.Driver
    #在xml配置文件中配置数据库utl时，要使用&的转义字符也就是&
    #useUnicode=true&characterEncoding=utf8
    #1. 存数据时：
    #数据库在存放项目数据的时候会先用UTF-8格式将数据解码成字节码，然后再将解码后的字节码重新使用GBK编码存放到数据库中。
    #2.取数据时：
    #在从数据库中取数据的时候，数据库会先将数据库中的数据按GBK格式解码成字节码，然后再将解码后的字节码重新按UTF-8格式编码数据，最后再将数据返回给客户端。
    #serverTimezone=UTC
    #覆盖时区的检测/映射。当服务器的时区为映射到Java时区时使用
    #设置时区UTC代表的是全球标准时间 ，但是我们使用的时间是北京时区也就是东八区，领先UTC八个小时
    #如果出现在java代码和数据插入的时间不匹配 那么serverTimezone=Asia/Shanghai
    url = jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC useSSL=false&
    username = root
    password = root

log4j.xml

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE log4j:configuration PUBLIC "-//log4j/log4j Configuration//EN" "log4j.dtd">
    <log4j:configuration>
        
        <appender name="consoleAppender" class="org.apache.log4j.ConsoleAppender">
            <param name="Threshold" value="info"/>
            日志输出格式
            <layout class="org.apache.log4j.PatternLayout">
                <param name="ConversionPattern" value="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>
            </layout>
        </appender>
    
        
        
        <appender name="fileAppenderInfo" class="org.apache.log4j.DailyRollingFileAppender">
        	
            <param name="File" value="${reids.root}/WEB-INF/logs/info.log" />
            <param name="DatePattern" value=".yyyy-MM-dd" />
            
            <layout class="org.apache.log4j.PatternLayout">
                <param name="ConversionPattern" value="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>
            </layout>
            <filter class="org.apache.log4j.varia.LevelRangeFilter">
                <param name="LevelMin" value="INFO" />
                <param name="LevelMax" value="INFO" />
            </filter>
        </appender>
    
        
        <appender name="fileAppenderWarn" class="org.apache.log4j.DailyRollingFileAppender">
            <param name="File" value="${reids.root}/WEB-INF/logs/warn.log" />
            <param name="DatePattern" value=".yyyy-MM-dd" />
            <layout class="org.apache.log4j.PatternLayout">
                <param name="ConversionPattern" value="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>
            </layout>
    
            <filter class="org.apache.log4j.varia.LevelRangeFilter">
                <param name="LevelMin" value="WARN" />
                <param name="LevelMax" value="WARN" />
            </filter>
        </appender>
    
        
        <appender name="fileAppenderError" class="org.apache.log4j.DailyRollingFileAppender">
            <param name="File" value="${reids.root}/WEB-INF/logs/error.log" />
            <param name="DatePattern" value=".yyyy-MM-dd" />
            <layout class="org.apache.log4j.PatternLayout">
                <param name="ConversionPattern" value="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n"/>
            </layout>
            <filter class="org.apache.log4j.varia.LevelRangeFilter">
                <param name="LevelMin" value="ERROR" />
                <param name="LevelMax" value="ERROR" />
            </filter>
        </appender>
    
        
        <logger name="org.springframework">
            <level value="INFO"></level>
        </logger>
    
        <root>
            <level value="ALL"/>
            <appender-ref ref="consoleAppender" />
            <appender-ref ref="fileAppenderInfo" />
            <appender-ref ref="fileAppenderWarn" />
            <appender-ref ref="fileAppenderError" />
        </root>
    </log4j:configuration>

redis.properties

#要链接的redis地址 ip
    redis.ip=127.0.0.1
    #redis端口 默认为6379
    redis.port=6379
    redis.key=SOA
    #默认没有密码可致为空
    redis.password=admin
    #是否启用redis？true启用，false不启用。
    redis.switch=true
     
    jedis.pool.maxActive=3000
    jedis.pool.maxIdle=1000
    jedis.pool.maxWait=1500
    jedis.pool.testOnBorrow=true
    jedis.pool.testOnReturn=true
    jedis.pool.timeout=5000

springmvc.xml

web.xml

<?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xmlns="http://xmlns.jcp.org/xml/ns/javaee"
    	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
    	id="WebApp_ID" version="3.1">
    	<display-name>Archetype Created Web Application</display-name>
    	<welcome-file-list>
    		<welcome-file>main.jsp</welcome-file>
    	</welcome-file-list>
    
    	
    	<context-param>
    		<param-name>webAppRootKey</param-name>
    		
    		<param-value>redis.root</param-value>
    	</context-param>
    	<listener>
    		<listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
    	</listener>
    
    	<context-param>
    		<param-name>contextConfigLocation</param-name>
    		<param-value>classpath:applicationContext.xml</param-value>
    	</context-param>
    
    	<filter>
    		<filter-name>encodingFilter</filter-name>
    		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    		<init-param>
    			<param-name>encoding</param-name>
    			<param-value>UTF-8</param-value>
    		</init-param>
    	</filter>
    	<filter-mapping>
    		<filter-name>encodingFilter</filter-name>
    		<url-pattern>/*</url-pattern>
    	</filter-mapping>
    
    	
    	<listener>
    		<listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
    	</listener>
    	
    	<listener>
    		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    	</listener>
    
    	<servlet>
    		<servlet-name>SpringMVC</servlet-name>
    		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    		<init-param>
    			<param-name>contextConfigLocation</param-name>
    			<param-value>classpath:springmvc.xml</param-value>
    		</init-param>
    		<load-on-startup>1</load-on-startup>
    	</servlet>
    	<servlet-mapping>
    		<servlet-name>SpringMVC</servlet-name>
    		<url-pattern>/</url-pattern>
    	</servlet-mapping>
    
    </web-app>

首先是引入三个工具类ConfigUtils、JedisUtils、RedisCache  
ConfigUtils(主要链接redis)

package com.gm.util;
     
    import java.io.IOException;
    import java.util.Properties;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
     
    public class ConfigUtils {
            private static Logger logger=LoggerFactory.getLogger(ConfigUtils.class);
     
            public static boolean redisSwitch;
            public static int maxIdle;
            public static boolean testOnBorrow;
            public static boolean testOnReturn;
            public static String ip;
            public static int port;
            public static String key;
            public static String password;
            public static int timeout;
            public static int fail_count=0;
     
            static{
                Properties props=new Properties();
                try {
                    props.load(JedisUtils.class.getResourceAsStream("/redis.properties"));
     
                    redisSwitch=Boolean.valueOf(props.getProperty("redis.switch"));
                    maxIdle=Integer.valueOf(props.getProperty("jedis.pool.maxIdle"));
                    testOnBorrow=Boolean.valueOf(props.getProperty("jedis.pool.testOnBorrow"));
                    testOnReturn=Boolean.valueOf(props.getProperty("jedis.pool.testOnReturn"));
                    ip=String.valueOf(props.getProperty("redis.ip"));
                    port=Integer.valueOf(props.getProperty("redis.port"));
                    password=String.valueOf(props.getProperty("redis.password"));
                    key=String.valueOf(props.getProperty("redis.key"));
                    timeout=Integer.valueOf(props.getProperty("jedis.pool.timeout"));
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
     
            }
            //对redis开关进行设置,有三种情况：1.如果现在开关开，则关闭redispool  2.如果开关关闭，则设置redispool为开启状态  3.现在状态和要设置的状态一致，不做操作。
            public static void setSwitch(boolean redisSwitch){
                if(true==ConfigUtils.redisSwitch && false== redisSwitch){
                    logger.info("switch:open-->close");
                    JedisUtils.closeJedisPool();
                }else if(ConfigUtils.redisSwitch==false && true == redisSwitch){
                    logger.info("switch:close-->open");
                    JedisUtils.getInstence();
                }
                ConfigUtils.redisSwitch=redisSwitch;
            }
            //当redis连接异常超过一定数量之后，不再走redis,但是没有一个机制，当reids恢复后重新使用redis
            public static void setFail(){
                if(redisSwitch){
                    fail_count=fail_count+1;
     
                    if(fail_count >10){
                        logger.info("setSwitch(false)");
                        setSwitch(false);
                    }
                }
            }
     
            public static void setSucc(){
                if(fail_count >0){
                    fail_count=0;
                }
                if(!redisSwitch){
                    setSwitch(true);
                }
            }
        }

JedisUtils(主要是添加，查找，删除等redis中的数据)

package com.gm.util;
    
    import org.mybatis.caches.redis.SerializeUtil;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    import redis.clients.jedis.JedisPoolConfig;
    
    public class JedisUtils {
        private static Logger logger=LoggerFactory.getLogger(JedisUtils.class);
     
        private static JedisPool JEDISPOOL;
     
        public static void getInstence(){
            if(JEDISPOOL == null){
                logger.info("JeidsUtils getInstence...");
                try {
                    JedisPoolConfig conf=new JedisPoolConfig();
                    conf.setMaxIdle(ConfigUtils.maxIdle);
                    conf.setTestOnBorrow(ConfigUtils.testOnBorrow);
                    //当配置中配置有password时，则创建带密码的缓存池
                    if(ConfigUtils.password !=null && !"".equals(ConfigUtils.password)){
                        JEDISPOOL=new JedisPool(conf,ConfigUtils.ip,ConfigUtils.port,ConfigUtils.timeout,ConfigUtils.password);
                        logger.info("--------JEDISPOOL:"+JEDISPOOL.getResource());
                    }else{
                        //没有配置则用无密码的缓存池。
                        JEDISPOOL=new JedisPool(conf,ConfigUtils.ip,ConfigUtils.port,ConfigUtils.timeout);
                    }
                } catch (Exception e) {
                    logger.error("加载【jedis.properties】异常,异常信息为："+e.getMessage());
                }
            }
        }
     
        public static Jedis getJedis(){
            try {
                return JEDISPOOL.getResource();
            } catch (Exception e) {
                return null;
            }
        }
     
        public static void closeJedis(Jedis jedis){
            if(jedis !=null){
                jedis.quit();
            }
        }
     
        public static void closeJedisPool(){
            if(JEDISPOOL !=null){
                JEDISPOOL.destroy();
            }
        }
        //redis 序列化存储Object
        public static void put(String id,Object key,Object value){
            Jedis jedis=getJedis();
            logger.info("redis put ... key =["+key+"]");
            try {
                jedis.hset(SerializeUtil.serialize(id), SerializeUtil.serialize(key), SerializeUtil.serialize(value));
                ConfigUtils.setSucc();
            } catch (Exception e) {
                ConfigUtils.setFail();
                logger.error("redis执行异常【"+e.getMessage()+"】");
            }finally{
                closeJedis(jedis);
            }
        }
     
     
        public static Object get(String id,Object key){
            Jedis jedis=getJedis();
            try {
                Object object = SerializeUtil.unserialize(jedis.hget(SerializeUtil.serialize(id), SerializeUtil.serialize(key)));
                logger.info("redis get ... key=["+key+"],value=["+object+"]");
                ConfigUtils.setSucc();
                return object;
            } catch (Exception e) {
                ConfigUtils.setFail();
                logger.error("Redis执行异常【"+e.getMessage()+"】");
            }finally{
                closeJedis(jedis);
            }
     
            return null;
        }
     
     
        public static Long remove(String id,Object key){
            Jedis jedis=getJedis();
            try {
                Long num = jedis.hdel(id.toString(), key.toString());
                ConfigUtils.setSucc();
                return num;
            } catch (Exception e) {
                ConfigUtils.setFail();
                logger.error("Redis执行异常，异常信息："+e.getMessage());
            }finally{
                closeJedis(jedis);
            }
     
            return 0l;
        }
     
        public static void removeAll(String id){
            Jedis jedis=getJedis();
            try {
                jedis.del(id.toString());
                ConfigUtils.setSucc();
            } catch (Exception e) {
                ConfigUtils.setFail();
                logger.error("Redis执行异常【"+e.getMessage()+"】");
            }finally{
                closeJedis(jedis);
            }
        }
     
     
        public static int getSize(String id){
            Jedis jedis=getJedis();
     
            try {
                return  jedis.hgetAll(SerializeUtil.serialize(id)).size();
            } catch (Exception e) {
                ConfigUtils.setFail();
                logger.error("Redis执行异常【"+e.getMessage()+"】");
            }finally{
                closeJedis(jedis);
            }
            return -1;
        }
    }

RedisCache

package com.gm.util;
    
    import java.util.concurrent.locks.Lock;
    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;
     
    public class RedisCache implements Cache {
     
        private static Logger logger = LoggerFactory.getLogger(RedisCache.class);
     
        private String cacheId;
        /**
         * 读写锁：分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，这是由jvm自己控制的，你只要上好相应的锁即可。如果你的代码只读数据，可以很多人
         * 同时读，但不能同时写，那就上读锁；如果你的代码修改数据，只能有一个人在写，且不能同时读取，那就上写锁。总之，读的时候上读锁，写的时候上
         * 写锁！
         */
        private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);
        private final Lock read = readWriteLock.readLock();
        private final Lock write = readWriteLock.writeLock();
     
        public RedisCache(String cacheId) {
            if (cacheId == null) {
                throw new IllegalArgumentException("Cache instances require an ID");
            }
            this.cacheId = ConfigUtils.key + "." + cacheId;
            logger.info("查询结果存入缓存对应的缓存空间生成的名字cacheId: " + this.cacheId);
     
            if (ConfigUtils.redisSwitch) {
                JedisUtils.getInstence();
            }
        }
     
        @Override
        public String getId() {
            return cacheId;
        }
     
        @Override
        public void putObject(Object key, Object value) {
            // TODO 从缓存中写数据，用写锁锁定，不允许读
            logger.info("NTSRedisCache putObject=" + cacheId);
            if (ConfigUtils.redisSwitch) {
                write.lock();
                try {
                    JedisUtils.put(cacheId, key, value);
                } finally {
                    write.unlock();
                }
     
            }
        }
     
        @Override
        public Object getObject(Object key) {
            // TODO 从缓存中读数据，用读锁锁定，不允许写
    //        logger.info("从缓存cacheId="+cacheId+"中拿数据key="+key+"对应的value");
            logger.info("》》》》》》》》》》》》》》》》》在缓存中根据cacheid="+cacheId+"  拿对应的key和value");
            if (ConfigUtils.redisSwitch) {
                read.lock();
                try {
                    return JedisUtils.get(cacheId, key);
                } finally {
                    read.unlock();
                }
            }
            return null;
        }
     
        @Override
        public Object removeObject(Object key) {
            // TODO 从缓存中改动数据，用写锁锁定，不允许读，改动结束后释放写锁。
            logger.info("NTSRedisCache clear =" + cacheId);
            if (ConfigUtils.redisSwitch) {
                write.lock();
                try {
                    return JedisUtils.remove(cacheId, key);
                } finally {
                    write.unlock();
                }
            }
            return null;
        }
     
        @Override
        public void clear() {
            // TODO  从缓存中改动数据，用写锁锁定，不允许读，改动结束后释放写锁。
            logger.info("NTSRedisCache clear =" + cacheId);
            if (ConfigUtils.redisSwitch) {
                write.lock();
                try {
                    JedisUtils.removeAll(cacheId);
                } finally {
                    write.unlock();
                }
            }
        }
     
        @Override
        public int getSize() {
            // TODO Auto-generated method stub
            logger.info("NTSRedisCache clear =" + cacheId);
            if (ConfigUtils.redisSwitch) {
                read.lock();
                try {
                    return JedisUtils.getSize(cacheId);
                } finally {
                    read.unlock();
                }
            }
            return -1;
        }
     
        @Override
        public ReadWriteLock getReadWriteLock() {
            return readWriteLock;
        }
     
    }

定义实体类

User(需要实现序列化，实现 java.io.Serializable 的接口 否则会报java.io.NotSerializableException异常)

package com.gm.entity;
    
    import java.io.Serializable;
    
    /**
     * 用户实体类(tb_user)
     * 
     * @author Administrator
     *
     */
    public class User implements Serializable {
    	private static final long serialVersionUID = 1L;
    	private int user_id;// 用户id
    	private String nickname;// 用户昵称
    	private int phone;// 用户电话
    
    	public int getUser_id() {
    		return user_id;
    	}
    
    	public void setUser_id(int user_id) {
    		this.user_id = user_id;
    	}
    
    	public String getNickname() {
    		return nickname;
    	}
    
    	public void setNickname(String nickname) {
    		this.nickname = nickname;
    	}
    
    	public int getPhone() {
    		return phone;
    	}
    
    	public void setPhone(int phone) {
    		this.phone = phone;
    	}
    
    }

然后定义dao层接口以及接口对应的xml  
UserDao

package com.gm.dao;
    
    import java.util.List;
    
    import com.gm.entity.User;
    
    /**
     * 用户dao层接口
     * @author Administrator
     *
     */
    public interface UserDao {
    
    	/**
    	 * 查询所有用户信息
    	 * @return
    	 */
    	List<User> selectUserAll();
    	
    }

UserDao.xml

<?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.gm.dao.UserDao">
    	
    	
    	
    	<cache type="com.gm.util.RedisCache"/>
    	<select id="selectUserAll" resultType="User">
    		select user_id,nickname,phone from tb_user
    	</select>
    
    </mapper>

业务层的接口 以及实现  
UserService

package com.gm.service;
    
    import java.util.List;
    
    import com.gm.entity.User;
    
    /**
     * 用户业务层接口
     * @author Administrator
     *
     */
    public interface UserService {
    
    	/**
    	 * 查询所有用户信息
    	 * @return
    	 */
    	List<User> selectUserAll();
    }

UserServiceImpl

package com.gm.service.impl;
    
    import java.util.List;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import com.gm.dao.UserDao;
    import com.gm.entity.User;
    import com.gm.service.UserService;
    
    /**
     * 用户业务层实现类
     * 
     * @author Administrator
     *
     */
    @Service("userService")
    public class UserServiceImpl implements UserService {
    
    	@Autowired
    	UserDao userDao;
    
    	@Override
    	public List<User> selectUserAll() {
    
    		List<User> list = userDao.selectUserAll();
    		if (list != null && list.size() > 0) {
    			for (User user : list) {
    				System.out.println("查询得到的用户的姓名：" + user.getNickname() + ",学生的电话：" + user.getPhone());
    			}
    		}
    		return list;
    	}
    }

接下来就可以尝试调用  
UserController

package com.gm.controller;
    
    import java.util.List;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    import com.gm.entity.User;
    import com.gm.service.UserService;
    
    /**
     * 用户控制类
     * @author Administrator
     *
     */
    @Controller
    @RequestMapping("user")
    public class UserController {
    
    	@Autowired
    	UserService userService;
    	
    	@ResponseBody
    	@RequestMapping("getUserAll")
    	public void getUserAll() {
    		//查询所有用户
    		List<User> list=userService.selectUserAll();
    		
    	}
    }

调用结果（由于我调用过 所以直接从redis缓存中取出数据）

[16:32:00:112] [INFO] - com.gm.util.RedisCache.getObject(RedisCache.java:61) - 》》》》》》》》》》》》》》》》》在缓存中根据cacheid=SOA.com.gm.dao.UserDao  拿对应的key和value
    [16:32:00:125] [INFO] - com.gm.util.JedisUtils.get(JedisUtils.java:76) - redis get ... key=[-273895532:3612635778:com.gm.dao.UserDao.selectUserAll:0:2147483647:select user_id,nickname,phone from tb_user:SqlSessionFactoryBean],value=[[com.gm.entity.User@68e109de, com.gm.entity.User@4ce5c8da, com.gm.entity.User@50430872]]
    查询得到的用户的姓名：张三,学生的电话：1235436
    查询得到的用户的姓名：李四,学生的电话：1231243
    查询得到的用户的姓名：王五,学生的电话：31421

搞定！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhZHkxMzI_size_16_color_FFFFFF_t_70]: /images/20220203/79b845e76a754e9498de9315b3856f85.png