访问数据库使用redis作为mysql的缓存（redis和mysql结合）

￡神魔★判官ぃ 2022-04-04 03:26 358阅读 0赞

首先声明一下，我是在一个SSM项目的基础上进行优化的，所以就不进行基础的介绍了。

下面我也补充一些知识点：

redis：

内存型数据库，有持久化功能，具备分布式特性，可靠性高，适用于对**读写效率要求都很高**，数据处理**业务复杂和对安全性要求较高**的系统（如新浪微博的计数和微博发布部分系统，对数据安全性、读写要求都很高）。

缓存机制说明：

所有的查询结果都放进了缓存，也就是把MySQL查询的结果放到了redis中去， 然后第二次发起该条查询时就可以从redis中去读取查询的结果，从而不与MySQL交互，从而达到优化的效果，redis的查询速度之于MySQL的查询速度相当于 内存读写速度 /硬盘读写速度。

reids的安装很简单，我会在文末附上文件地址，只需要解压缩，然后点击打开redis-server.exe即可

下面正式开始：

1.pom.xml文件添加如下：

<dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-redis</artifactId>
        <version>1.5.2.RELEASE</version>
    </dependency>

2.redis.properties

# Redis settings
    redis.host=127.0.0.1
    redis.port=6379  
    #redis.pass=password
    redis.dbIndex=0  
    redis.expiration=3000  
    redis.maxIdle=300  
    redis.maxActive=600  
    redis.maxWait=1000  
    redis.testOnBorrow=true

3.database.properties

driver=com.mysql.jdbc.Driver
    url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8
    username=###
    password=###
    #\u5b9a\u4e49\u521d\u59cb\u8fde\u63a5\u6570
    initialSize=10
    #\u5b9a\u4e49\u6700\u5927\u8fde\u63a5\u6570
    maxActive=20
    #\u5b9a\u4e49\u6700\u5927\u7a7a\u95f2
    maxIdle=20
    #\u5b9a\u4e49\u6700\u5c0f\u7a7a\u95f2
    minIdle=1
    #\u5b9a\u4e49\u6700\u957f\u7b49\u5f85\u65f6\u95f4
    maxWait=60000
    timeBetweenEvictionRunsMillis=300000

4..spring-mybatis.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:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc" 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/mvc  
      http://www.springframework.org/schema/mvc/spring-mvc.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">
    
        
       <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
          <property name="locations">
             <list>
                <value>classpath:database.properties</value>
                <value>classpath:redis.properties</value>
             </list>
          </property>
       </bean>
       
       <context:component-scan base-package="com.hanpeng" use-default-filters="false">
          <context:include-filter type="annotation" expression="org.springframework.stereotype.Repository"/> 
          <context:include-filter type="annotation" expression="org.springframework.stereotype.Service"/> 
        </context:component-scan>
    
    
       <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
          destroy-method="close">
          <property name="driverClassName" value="${driver}" />
          <property name="url" value="${url}" />
          <property name="username" value="${username}" />
          <property name="password" value="${password}" />
          
          <property name="initialSize" value="${initialSize}"></property>
          
          <property name="maxActive" value="${maxActive}"></property>
          
          <property name="maxIdle" value="${maxIdle}"></property>
          
          <property name="minIdle" value="${minIdle}"></property>
          
          <property name="maxWait" value="${maxWait}"></property>
          
           <property name="timeBetweenEvictionRunsMillis" value="${timeBetweenEvictionRunsMillis}"/>
           
           <property name="testOnBorrow" value="false"/>
           
          <property name="validationQuery" value="SELECT 1" />
          
           <property name="testWhileIdle" value="true"/>
       </bean>
    
          
        <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
            <property name="dataSource" ref="dataSource" />  
              
            <property name="mapperLocations" value="classpath*:mapping/**/*.xml"></property>
          <property name="configLocation" value="mybatis-config.xml"></property>
          
          <property name="plugins">
             <array>
                <bean class="com.github.pagehelper.PageInterceptor">
                   <property name="properties">
                      
                      <value>
                         helperDialect=postgresql
                         reasonable=true
                         supportMethodsArguments=true
                         params=count=countSql
                         autoRuntimeDialect=true
                      </value>
                   </property>
                </bean>
             </array>
          </property>
    
       </bean>
    
    
      
          
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">  
            <property name="basePackage" value="com.hanpeng" />  
            <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
       </bean>
       
       
       <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate"
          scope="prototype">
          <constructor-arg index="0" ref="sqlSessionFactory" />
       </bean>
    
       
       <bean id="transactionManager"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
          <property name="dataSource" ref="dataSource" />
       </bean>
    
       
       <tx:advice id="txAdvice" transaction-manager="transactionManager">
          <tx:attributes>
             
             <tx:method name="get*" read-only="true" />
             <tx:method name="list*" read-only="true" />
             <tx:method name="query*" read-only="true" />
             <tx:method name="search*" read-only="true" />
             <tx:method name="find*" read-only="true" />
             <tx:method name="check*" read-only="true" />
             <tx:method name="newLog*" propagation="NOT_SUPPORTED" />
             
             <tx:method name="*" rollback-for="Exception" />    
          </tx:attributes>
       </tx:advice>
    
       
    
       
       
       <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" />
       </bean>
    
       
       <bean id="redisCacheManager" class="org.springframework.data.redis.cache.RedisCacheManager">
          <constructor-arg ref="redisTemplate" />
          <property name="defaultExpiration" value="${redis.expiration}" />
       </bean>
    
       
       <bean id="redisCacheConfig" class="com.jd.service.RedisCacheConfig">
          <constructor-arg ref="jedisConnectionFactory" />
          <constructor-arg ref="redisTemplate" />
          <constructor-arg ref="redisCacheManager" />
       </bean>
        
    </beans>

5.缓存主要在service层进行，查询的结果会缓存，把对象序列号存到redis中去，key就是注解中的参数，例如@Cacheable("findUsers"): 存在redis中的key就是findUsers。缓存了这个结果之后再次请求这个方法就不会去数据库中查，而是从redis缓存中读取数据，这样就减少了跟数据库之间的交互。然后修改、删除、增加操作就会清除缓存，保持数据的一致性。

RedisCacheConfig: 需要增加这个配置类，会在applicationContex配置文件中注册这个bean。

package com.jd.service;
    
    import java.lang.reflect.Method;
    
    import org.springframework.cache.annotation.CachingConfigurerSupport;
    import org.springframework.cache.annotation.EnableCaching;
    import org.springframework.cache.interceptor.KeyGenerator;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.cache.RedisCacheManager;
    import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    
    /**
     * @program: cloudConnectWMS
     * @description: redis配置类(通过spring管理redis缓存配置)
     * @author: by hanpeng
     * @create: 2018-12-14 11:27
     **/
    @Configuration
    @EnableCaching
    public class RedisCacheConfig extends CachingConfigurerSupport {
        private volatile JedisConnectionFactory jedisConnectionFactory;
        private volatile RedisTemplate<String, String> redisTemplate;
        private volatile RedisCacheManager redisCacheManager;
    
        public RedisCacheConfig() {
            super();
        }
    
        /**
         * 带参数的构造方法 初始化所有的成员变量
         *
         * @param jedisConnectionFactory
         * @param redisTemplate
         * @param redisCacheManager
         */
        public RedisCacheConfig(JedisConnectionFactory jedisConnectionFactory, RedisTemplate<String, String> redisTemplate,
                                RedisCacheManager redisCacheManager) {
            this.jedisConnectionFactory = jedisConnectionFactory;
            this.redisTemplate = redisTemplate;
            this.redisCacheManager = redisCacheManager;
        }
    
        public JedisConnectionFactory getJedisConnecionFactory() {
            return jedisConnectionFactory;
        }
    
        public RedisTemplate<String, String> getRedisTemplate() {
            return redisTemplate;
        }
    
        public RedisCacheManager getRedisCacheManager() {
            return redisCacheManager;
        }
    
        @Bean
        public KeyGenerator customKeyGenerator() {
            return new KeyGenerator() {
                @Override
                public Object generate(Object target, Method method, Object... objects) {
                    StringBuilder sb = new StringBuilder();
                    sb.append(target.getClass().getName());
                    sb.append(method.getName());
                    for (Object obj : objects) {
                        sb.append(obj.toString());
                    }
                    return sb.toString();
                }
            };
        }
    }

6.UserServiceImpl

import java.util.List;  
import javax.annotation.Resource;  
import org.springframework.cache.annotation.CacheEvict;  
import org.springframework.cache.annotation.Cacheable;  
import org.springframework.stereotype.Service;  
import org.springframework.transaction.annotation.Propagation;  
import org.springframework.transaction.annotation.Transactional;

/\*\*  
\* userService  
\*  
\* @Cacheable("a")注解的意义就是把该方法的查询结果放到redis中去，下一次再发起查询就去redis中去取，存在redis中的数据的key就是a；  
\* @CacheEvict(value=\{"a","b"\},allEntries=true) 的意思就是执行该方法后要清除redis中key名称为a,b的数据；  
\*/  
@Service("userService")  
@Transactional(propagation=Propagation.REQUIRED, rollbackFor=Exception.class)  
public class UserServiceImpl implements IUserService \{

@Resource  
private UserMapper iUserDao;

@Cacheable("getUserById") //标注该方法查询的结果进入缓存，再次访问时直接读取缓存中的数据  
@Override  
public User getUserById(int userId) \{  
return this.iUserDao.selectByPrimaryKey(userId);  
\}

@Cacheable("getAllUser")  
@Override  
public List<User> getAllUser() \{  
return this.iUserDao.selectAllUser();  
\}

@CacheEvict(value= \{"getAllUser","getUserById","findUsers"\},allEntries=true)//清空缓存，allEntries变量表示所有对象的缓存都清除  
@Override  
public void insertUser(User user) \{  
this.iUserDao.insertUser(user);  
\}

@CacheEvict(value= \{"getAllUser","getUserById","findUsers"\},allEntries=true)  
@Override  
public void deleteUser(int id) \{  
this.iUserDao.deleteUser(id);  
\}

@Cacheable("findUsers")  
@Override  
public List<User> findUsers(String keyWords) \{  
return iUserDao.findUsers(keyWords);  
\}

@CacheEvict(value= \{"getAllUser","getUserById","findUsers"\},allEntries=true)  
@Override  
public void editUser(User user) \{  
this.iUserDao.editUser(user);  
\}  
\}

### **redis安装包获取地址** [https://download.csdn.net/download/qq\_33609401/10851061][https_download.csdn.net_download_qq_33609401_10851061] ###

[https_download.csdn.net_download_qq_33609401_10851061]: https://download.csdn.net/download/qq_33609401/10851061