第十篇 Spring 集成Redis

左手的ㄟ右手 2023-09-26 20:43 92阅读 0赞

《Spring》篇章整体栏目  
—————————————————————————————  
[【第一章】spring 概念与体系结构][spring]  
[【第二章】spring IoC 的工作原理][spring IoC]  
[【第三章】spring IOC与Bean环境搭建与应用][spring IOC_Bean]  
[【第四章】spring bean定义][spring bean]  
[【第五章】Spring 集合注入、作用域][Spring]  
[【第六章】Spring 自动装配][Spring 1]  
[【第七章】spring AOP][spring AOP]  
[【第八章】Spring 集成JdbcTemplate][Spring _JdbcTemplate]  
[【第九章】Spring数据库事务管理][Spring 2]  
[【第十章】Spring 集成Redis][Spring _Redis]  
【第十一章】Spring实战之打造新闻系统后端接口  
—————————————————————————————

#### 目录 ####

*  1.spring集成redis
 *   *  1.1、引入spring-data-redis.jar包：
     *  1.2、redis.properties 配置文件
     *  1.3、spring-redis配置文件(此处包含了数据库和mybatis的配置)
     *  1.4、redis工具类(此处try catch为防止redis宕机等问题时 方法可以继续执行)
     *  1.5、将spring-redis.xml包含到web.xml中
     *  1.6、在需要redis的业务类中注入redisUtil

—————————————————————————————

## 1.spring集成redis ##

### 1.1、引入spring-data-redis.jar包： ###

<dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>1.3.4.RELEASE</version>
        </dependency>

### 1.2、redis.properties 配置文件 ###

#访问地址
    host=127.0.0.1
    #访问端口
    port=6379
    #注意，如果没有password，此处不设置值，但这一项要保留
    password=
     #数据库下标
     dbIndex=0
    #最大空闲数，数据库连接的最大空闲时间。超过空闲时间，数据库连接将被标记为不可用，然后被释放。设为0表示无限制。
    maxIdle=300
    #连接池的最大数据库连接数。设为0表示无限制
    maxActive=600
    #最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
    maxWait=1000
    #在borrow一个jedis实例时，是否提前进行alidate操作；如果为true，则得到的jedis实例均是可用的；
    testOnBorrow=true

### 1.3、spring-redis配置文件(此处包含了数据库和mybatis的配置) ###

<?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:jdbc="http://www.springframework.org/schema/jdbc"  
    	xmlns:jee="http://www.springframework.org/schema/jee" 
    	xmlns:tx="http://www.springframework.org/schema/tx"
    	xmlns:aop="http://www.springframework.org/schema/aop" 
    	xmlns:mvc="http://www.springframework.org/schema/mvc"
    	xmlns:util="http://www.springframework.org/schema/util"
    	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    	xsi:schemaLocation="
    		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
    		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
    		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.1.xsd
    		http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.1.xsd
    		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
    		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
    		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
    		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
    		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.1.xsd">
    	
    	
    	
     	<util:properties id="redis"
    		location="classpath:conf/redis.properties"/> 	 
    	<util:properties id="jdbc"
    		location="classpath:conf/jdbc.properties"/> 
     
    	
    	<bean id="dataSource"
    		class="org.apache.commons.dbcp.BasicDataSource"
    		destroy-method="close"> 
    		<property name="driverClassName"
    			value="#{jdbc.driver}"/>
    		<property name="url"
    			value="#{jdbc.url}"/>
    		<property name="username"
    			value="#{jdbc.user}"/>
    		<property name="password"
    			value="#{jdbc.password}"/>
    		<property name="maxIdle"
    			value="#{jdbc.maxIdle}"/>
    		<property name="maxWait"
    			value="#{jdbc.maxWait}"/>						
    		<property name="maxActive"
    			value="#{jdbc.maxActive}"/>
    		<property name="defaultAutoCommit"
    			value="#{jdbc.defaultAutoCommit}"/>
    		<property name="defaultReadOnly"
    			value="#{jdbc.defaultReadOnly}"/>
    		<property name="testOnBorrow"
    			value="#{jdbc.testOnBorrow}"/>			
    		<property name="validationQuery"
    			value="#{jdbc.validationQuery}"/>	
    	</bean>
    	
    	
    	<bean id="sqlSessionFactory"
    		class="org.mybatis.spring.SqlSessionFactoryBean">
    		<property name="dataSource"
    			 ref="dataSource"/>
    		
    		<property name="mapperLocations"
    			value="classpath:mapper/*.xml"/>
     
    	</bean>
    	
    	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    		<property name="basePackage" 
    			value="com.zzipsun.dao"/>
    	</bean>
    	
    		
    	<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    		<property name="dataSource"
    			ref="dataSource"/>
    	</bean>
    	
    	<tx:annotation-driven 
    		transaction-manager="txManager"/>
    		
    		
        
        
         <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="database" value="#{redis.dbIndex}" />
            <property name="poolConfig" ref="poolConfig" />
        </bean>
        
         <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
            <property name="connectionFactory" ref="jedisConnectionFactory" />
                    
            <property name="keySerializer">
                <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
            </property>
            <property name="valueSerializer">
                <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
            </property>
        </bean> 
     
        
        <bean id="redisUtil" class="com.zzipsun.util.RedisUtil">
        	<property name="redisTemplate" ref="redisTemplate" />
        </bean>
    	
    </beans>

### 1.4、redis工具类(此处try catch为防止redis宕机等问题时 方法可以继续执行) ###

import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.stereotype.Component;
    import org.springframework.util.CollectionUtils;
     
    /**
     * 
     * @author 
     * 基于spring和redis的redisTemplate工具类
     * 针对所有的hash 都是以h开头的方法
     * 针对所有的Set 都是以s开头的方法                    不含通用方法
     * 针对所有的List 都是以l开头的方法
     */
    @Component("redisUtil")
    public class RedisUtil {
        
     
     
    	private RedisTemplate<String, Object> redisTemplate;
    	
    	public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
        
    		this.redisTemplate = redisTemplate;
    	}
    	//=============================common============================
    	/**
    	 * 指定缓存失效时间
    	 * @param key 键
    	 * @param time 时间(秒)
    	 * @return
    	 */
    	public boolean expire(String key,long time){
        
    		try {
        
    			if(time>0){
        
    				redisTemplate.expire(key, time, TimeUnit.SECONDS);
    			}
    			return true;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
    	}
    	
    	/**
    	 * 根据key 获取过期时间
    	 * @param key 键 不能为null
    	 * @return 时间(秒) 返回0代表为永久有效
    	 */
    	public long getExpire(String key){
        
    		return redisTemplate.getExpire(key,TimeUnit.SECONDS);
    	}
    	
    	/**
    	 * 判断key是否存在
    	 * @param key 键
    	 * @return true 存在 false不存在
    	 */
    	public boolean hasKey(String key){
        
    		try {
        
    			return redisTemplate.hasKey(key);
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
    	}
    	
    	/**
    	 * 删除缓存
    	 * @param key 可以传一个值 或多个
    	 */
    	@SuppressWarnings("unchecked")
    	public void del(String ... key){
        
    		if(key!=null&&key.length>0){
        
    			if(key.length==1){
        
    				redisTemplate.delete(key[0]);
    			}else{
        
    				redisTemplate.delete(CollectionUtils.arrayToList(key));
    			}
    		}
    	}
    	
    	//============================String=============================
    	/**
    	 * 普通缓存获取
    	 * @param key 键
    	 * @return 值
    	 */
    	public Object get(String key){
        
    		return key==null?null:redisTemplate.opsForValue().get(key);
    	}
    	
    	/**
    	 * 普通缓存放入
    	 * @param key 键
    	 * @param value 值
    	 * @return true成功 false失败
    	 */
    	public boolean set(String key,Object value) {
        
    		 try {
        
    			redisTemplate.opsForValue().set(key, value);
    			return true;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
    		
    	}
    	
    	/**
    	 * 普通缓存放入并设置时间
    	 * @param key 键
    	 * @param value 值
    	 * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
    	 * @return true成功 false 失败
    	 */
    	public boolean set(String key,Object value,long time){
        
    		try {
        
    			if(time>0){
        
    				redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
    			}else{
        
    				set(key, value);
    			}
    			return true;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
    	}
    	
    	/**
    	 * 递增
    	 * @param key 键
    	 * @param by 要增加几(大于0)
    	 * @return
    	 */
    	public long incr(String key, long delta){
          
    		if(delta<0){
        
    			throw new RuntimeException("递增因子必须大于0");
    		}
    		return redisTemplate.opsForValue().increment(key, delta);
        }
    	
    	/**
    	 * 递减
    	 * @param key 键
    	 * @param by 要减少几(小于0)
    	 * @return
    	 */
    	public long decr(String key, long delta){
          
    		if(delta<0){
        
    			throw new RuntimeException("递减因子必须大于0");
    		}
            return redisTemplate.opsForValue().increment(key, -delta);  
        }  
    	
    	//================================Map=================================
    	/**
    	 * HashGet
    	 * @param key 键 不能为null
    	 * @param item 项 不能为null
    	 * @return 值
    	 */
    	public Object hget(String key,String item){
        
    		try {
        
    			return redisTemplate.opsForHash().get(key, item);
    		} catch (Exception e) {
        
    			return  null;
    		}
    	}
    	
    	/**
    	 * 获取hashKey对应的所有键值
    	 * @param key 键
    	 * @return 对应的多个键值
    	 */
    	public Map<Object,Object> hmget(String key){
        
    		return redisTemplate.opsForHash().entries(key);
    	}
    	
    	/**
    	 * HashSet
    	 * @param key 键
    	 * @param map 对应多个键值
    	 * @return true 成功 false 失败
    	 */
    	public boolean hmset(String key, Map<String,Object> map){
          
            try {
        
    			redisTemplate.opsForHash().putAll(key, map);
    			return true;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
        }
    	
    	/**
    	 * HashSet 并设置时间
    	 * @param key 键
    	 * @param map 对应多个键值
    	 * @param time 时间(秒)
    	 * @return true成功 false失败
    	 */
        public boolean hmset(String key, Map<String,Object> map, long time){
          
            try {
        
    			redisTemplate.opsForHash().putAll(key, map);
    			if(time>0){
        
    				expire(key, time);
    			}
    			return true;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
        }
    	
    	/**
    	 * 向一张hash表中放入数据,如果不存在将创建
    	 * @param key 键
    	 * @param item 项
    	 * @param value 值
    	 * @return true 成功 false失败
    	 */
    	public boolean hset(String key,String item,Object value) {
        
    		 try {
        
    			redisTemplate.opsForHash().put(key, item, value);
    			return true;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
    	}
    	
    	/**
    	 * 向一张hash表中放入数据,如果不存在将创建
    	 * @param key 键
    	 * @param item 项
    	 * @param value 值
    	 * @param time 时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
    	 * @return true 成功 false失败
    	 */
    	public boolean hset(String key,String item,Object value,long time) {
        
    		 try {
        
    			redisTemplate.opsForHash().put(key, item, value);
    			if(time>0){
        
    				expire(key, time);
    			}
    			return true;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
    	}
    	
    	/**
    	 * 删除hash表中的值
    	 * @param key 键 不能为null
    	 * @param item 项 可以使多个 不能为null
    	 */
        public void hdel(String key, Object... item){
          
    		redisTemplate.opsForHash().delete(key,item);
        } 
        
        /**
         * 判断hash表中是否有该项的值
         * @param key 键 不能为null
         * @param item 项 不能为null
         * @return true 存在 false不存在
         */
        public boolean hHasKey(String key, String item){
        
    		return redisTemplate.opsForHash().hasKey(key, item);
        } 
    	
    	/**
    	 * hash递增 如果不存在,就会创建一个 并把新增后的值返回
    	 * @param key 键
    	 * @param item 项
    	 * @param by 要增加几(大于0)
    	 * @return
    	 */
    	public double hincr(String key, String item,double by){
          
            return redisTemplate.opsForHash().increment(key, item, by);
        }
    	
    	/**
    	 * hash递减
    	 * @param key 键
    	 * @param item 项
    	 * @param by 要减少记(小于0)
    	 * @return
    	 */
    	public double hdecr(String key, String item,double by){
          
            return redisTemplate.opsForHash().increment(key, item,-by);  
        }  
    	
    	//============================set=============================
    	/**
    	 * 根据key获取Set中的所有值
    	 * @param key 键
    	 * @return
    	 */
    	public Set<Object> sGet(String key){
        
    		try {
        
    			return redisTemplate.opsForSet().members(key);
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return null;
    		}
    	}
    	
    	/**
    	 * 根据value从一个set中查询,是否存在
    	 * @param key 键
    	 * @param value 值
    	 * @return true 存在 false不存在
    	 */
    	public boolean sHasKey(String key,Object value){
        
    		try {
        
    			return redisTemplate.opsForSet().isMember(key, value);
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
    	}
    	
    	/**
    	 * 将数据放入set缓存
    	 * @param key 键
    	 * @param values 值 可以是多个
    	 * @return 成功个数
    	 */
    	public long sSet(String key, Object...values) {
        
            try {
        
                return redisTemplate.opsForSet().add(key, values);
            } catch (Exception e) {
        
            	e.printStackTrace();
            	return 0;
            }
        }
    	
    	/**
    	 * 将set数据放入缓存
    	 * @param key 键
    	 * @param time 时间(秒)
    	 * @param values 值 可以是多个
    	 * @return 成功个数
    	 */
    	public long sSetAndTime(String key,long time,Object...values) {
        
            try {
        
            	Long count = redisTemplate.opsForSet().add(key, values);
            	if(time>0) expire(key, time);
                return count;
            } catch (Exception e) {
        
            	e.printStackTrace();
            	return 0;
            }
        }
    	
    	/**
    	 * 获取set缓存的长度
    	 * @param key 键
    	 * @return
    	 */
    	public long sGetSetSize(String key){
        
    		try {
        
    			return redisTemplate.opsForSet().size(key);
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return 0;
    		}
    	}
    	
    	/**
    	 * 移除值为value的
    	 * @param key 键
    	 * @param values 值 可以是多个
    	 * @return 移除的个数
    	 */
    	public long setRemove(String key, Object ...values) {
        
            try {
        
                Long count = redisTemplate.opsForSet().remove(key, values);
                return count;
            } catch (Exception e) {
        
            	e.printStackTrace();
            	return 0;
            }
        }
        //===============================list=================================
        
    	/**
    	 * 获取list缓存的内容
    	 * @param key 键
    	 * @param start 开始
    	 * @param end 结束  0 到 -1代表所有值
    	 * @return
    	 */
    	public List<Object> lGet(String key,long start, long end){
        
    		try {
        
    			return redisTemplate.opsForList().range(key, start, end);
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return null;
    		}
    	}
    	
    	/**
    	 * 获取list缓存的长度
    	 * @param key 键
    	 * @return
    	 */
    	public long lGetListSize(String key){
        
    		try {
        
    			return redisTemplate.opsForList().size(key);
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return 0;
    		}
    	}
    	
    	/**
    	 * 通过索引 获取list中的值
    	 * @param key 键
    	 * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
    	 * @return
    	 */
    	public Object lGetIndex(String key,long index){
        
    		try {
        
    			return redisTemplate.opsForList().index(key, index);
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return null;
    		}
    	}
    	
    	/**
    	 * 将list放入缓存
    	 * @param key 键
    	 * @param value 值
    	 * @param time 时间(秒)
    	 * @return
    	 */
    	public boolean lSet(String key, Object value) {
        
            try {
        
                redisTemplate.opsForList().rightPush(key, value);
                return true;
            } catch (Exception e) {
        
            	e.printStackTrace();
            	return false;
            }
        }
    	
    	/**
    	 * 将list放入缓存
    	 * @param key 键
    	 * @param value 值
    	 * @param time 时间(秒)
    	 * @return
    	 */
    	public boolean lSet(String key, Object value, long time) {
        
            try {
        
                redisTemplate.opsForList().rightPush(key, value);
                if (time > 0) expire(key, time);
                return true;
            } catch (Exception e) {
        
            	e.printStackTrace();
            	return false;
            }
        }
    	
    	/**
    	 * 将list放入缓存
    	 * @param key 键
    	 * @param value 值
    	 * @param time 时间(秒)
    	 * @return
    	 */
    	public boolean lSet(String key, List<Object> value) {
        
    	    try {
        
    			redisTemplate.opsForList().rightPushAll(key, value);
    			return true;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
        }
    	
    	/**
    	 * 将list放入缓存
    	 * @param key 键
    	 * @param value 值
    	 * @param time 时间(秒)
    	 * @return
    	 */
    	public boolean lSet(String key, List<Object> value, long time) {
        
    	    try {
        
    			redisTemplate.opsForList().rightPushAll(key, value);
    			if (time > 0) expire(key, time);
    			return true;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
        }
    	
    	/**
    	 * 根据索引修改list中的某条数据
    	 * @param key 键
    	 * @param index 索引
    	 * @param value 值
    	 * @return
    	 */
    	public boolean lUpdateIndex(String key, long index,Object value) {
        
    	    try {
        
    			redisTemplate.opsForList().set(key, index, value);
    			return true;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return false;
    		}
        } 
    	
    	/**
    	 * 移除N个值为value 
    	 * @param key 键
    	 * @param count 移除多少个
    	 * @param value 值
    	 * @return 移除的个数
    	 */
    	public long lRemove(String key,long count,Object value) {
        
    		try {
        
    			Long remove = redisTemplate.opsForList().remove(key, count, value);
    			return remove;
    		} catch (Exception e) {
        
    			e.printStackTrace();
    			return 0;
    		}
    	}
    }

### 1.5、将spring-redis.xml包含到web.xml中 ###

<servlet>
        <description></description>
        <display-name>DispatcherServlet</display-name>
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
          <description></description>
          <param-name>contextConfigLocation</param-name>
          <param-value>classpath:conf/spring-*.xml</param-value>  --此处包含所有spring配置文件
        </init-param>
        <load-on-startup>1</load-on-startup>
      </servlet>

### 1.6、在需要redis的业务类中注入redisUtil ###

此处用一个方法理解redis的使用：

/**
     * ArticleServiceImp.java
     */
    package com.zzipsun.service.imp;
     
    import java.sql.Array;
    import java.util.Arrays;
    import java.util.List;
    import java.util.Map;
     
    import javax.annotation.Resource;
     
    import org.apache.log4j.Logger;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Service;
     
    import com.zzipsun.dao.ArticleDao;
    import com.zzipsun.entity.Article;
    import com.zzipsun.service.base.ArticleService;
    import com.zzipsun.util.Log4JUtil;
    import com.zzipsun.util.RedisUtil;
     
    /**
     * @author zs
     *
     */
    @Service("articleService")
    public class ArticleServiceImp implements ArticleService {
        
    	Logger log=Logger.getLogger(ArticleServiceImp.class);
    @Resource
    ArticleDao  articleDao;
    @Value("#{jdbc.pagesize}")
    int  pageSize;
    @Resource
    RedisUtil redisUtil;
     
    	/* (non-Javadoc)
    	 * @see com.zzipsun.service.base.ArticleService#findArticleById(java.lang.String)
    	 */
    	//查看一个文章
    	public Article findArticleById(String articleId) {
        
    		if(articleId.trim()==""||articleId==null) {
        
    			throw new RuntimeException("您查看的文章找不到了");
    		}
    		//尝试从redis缓冲中获取map中的article实体对象
    		Article article=(Article)redisUtil.hget("article", articleId);
    		if(article!=null) {
        
    			log.debug("redis中的id为"+articleId+"的article标题为"+article.getTitle());
    		}
    		//如果redis缓存中不存在此文章
    		if(article==null) {
        
    			//数据库查询
    			article=articleDao.findArticleById(articleId);
    			//存入redis中
    			redisUtil.hset("article", articleId, article);
    		}
    		return article;
    	}
    }

[spring]: https://blog.csdn.net/s445320/article/details/130083101
[spring IoC]: https://blog.csdn.net/s445320/article/details/130084533
[spring IOC_Bean]: https://blog.csdn.net/s445320/article/details/130089034
[spring bean]: https://blog.csdn.net/s445320/article/details/130083981
[Spring]: https://blog.csdn.net/s445320/article/details/130215406
[Spring 1]: https://blog.csdn.net/s445320/article/details/130221452
[spring AOP]: https://blog.csdn.net/s445320/article/details/130222493
[Spring _JdbcTemplate]: https://blog.csdn.net/s445320/article/details/130226462
[Spring 2]: https://blog.csdn.net/s445320/article/details/130227115
[Spring _Redis]: https://blog.csdn.net/s445320/article/details/130194622