SpringBoot中shiro使用redis作为缓存机制

灰太狼 2022-10-28 13:26 149阅读 0赞

### SpringBoot中shiro使用redis作为缓存机制 ###

*  1.导入依赖
 *  2.修改application.yml配置文件
 *  3.编写单元测试redis能否连接
 *   *  3.1测试结果：
     *  3.2RDM中结果
 *  4.开发RedisCacheManager类
 *  5.开发RedisCache类
 *   *  5.1开发ApplicationContextUtils工具类
 *  6.在shiro配置类中，去打开shiro的缓存机制
 *  7.测试

# 1.导入依赖 #

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
                <version>2.2.4.RELEASE</version>
            </dependency>

# 2.修改application.yml配置文件 #

spring:
      redis:
        port: 6379
        host: 55.165.226.xxx
        database: 0

# 3.编写单元测试redis能否连接 #

@Autowired
        RedisTemplate<String,String> redisTemplate;
    
        @Test
        public void testRedisConnect(){ 
            Map<String,String> map=new HashMap<>();
            map.put("ttttt","15");
            redisTemplate.opsForHash().put("haha","dierge",map.toString());
    
            Object mmap =new Object();
            mmap=redisTemplate.opsForHash().get("haha","dierge");
            System.out.println(mmap);
        }

## 3.1测试结果： ##

![在这里插入图片描述][20210206142156644.png]

## 3.2RDM中结果 ##

![在这里插入图片描述][20210206142516654.png]

# 4.开发RedisCacheManager类 #

import org.apache.shiro.cache.Cache;
    import org.apache.shiro.cache.CacheException;
    import org.apache.shiro.cache.CacheManager;
    import org.springframework.stereotype.Component;
    
    @Component
    public class RedisCacheManager implements CacheManager { 
        @Override
        public <K, V> Cache<K, V> getCache(String cacheName) throws CacheException { 
            System.out.println("缓存名称: "+cacheName);
            return new RedisCache<K,V>(cacheName);
        }
    }

# 5.开发RedisCache类 #

注意在下面的代码中，如果直接注入redisTemplate，我的总会报空指针的错误，然后我上网搜了一下，也没能解决，所以就只能使用自己编写的ApplicationContextUtils工具类来获取redisTemplate。如果读者有能解决空指针的办法或者有实现了的直接注入redisTemplate的例子，可以在评论区中给出，谢谢。

import com.graproject.utils.ApplicationContextUtils;
    import org.apache.shiro.cache.Cache;
    import org.apache.shiro.cache.CacheException;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    import java.util.Collection;
    import java.util.Set;
    
    
    public class RedisCache<K, V> implements Cache<K, V> { 
    
        private String cacheName;
    
        public RedisCache() { 
        }
    
        public RedisCache(String cacheName) { 
            this.cacheName = cacheName;
        }
    
        @Override
        public V get(K k) throws CacheException { 
            System.out.println("获取缓存:" + k);
            return (V) getRedisTemplate().opsForHash().get(this.cacheName, k.toString());
        }
    
        @Override
        public V put(K k, V v) throws CacheException { 
            System.out.println("设置缓存key: " + k + " value:" + v);
            getRedisTemplate().opsForHash().put(this.cacheName, k.toString(), v);
            return null;
        }
    
        @Override
        public V remove(K k) throws CacheException { 
            return (V) getRedisTemplate().opsForHash().delete(this.cacheName, k.toString());
        }
    
        @Override
        public void clear() throws CacheException { 
            getRedisTemplate().delete(this.cacheName);
        }
    
        @Override
        public int size() { 
            return getRedisTemplate().opsForHash().size(this.cacheName).intValue();
        }
    
        @Override
        public Set<K> keys() { 
            return getRedisTemplate().opsForHash().keys(this.cacheName);
        }
    
        @Override
        public Collection<V> values() { 
            return getRedisTemplate().opsForHash().values(this.cacheName);
        }
    
        private RedisTemplate getRedisTemplate() { 
            RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("redisTemplate");
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
            return redisTemplate;
        }
    }

## 5.1开发ApplicationContextUtils工具类 ##

import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.stereotype.Component;
    
    @Component
    public class ApplicationContextUtils implements ApplicationContextAware { 
    
        private static ApplicationContext context;
    
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { 
            this.context = applicationContext;
        }
    
        //根据bean名字获取工厂中指定bean 对象
        public static Object getBean(String beanName){ 
            System.out.println("beanName"+beanName);
            Object object=context.getBean(beanName);
            System.out.println("object"+object);
            return context.getBean(beanName);
        }
    }

# 6.在shiro配置类中，去打开shiro的缓存机制 #

@Bean
        public Realm getRealm(){ 
            UserRealm userRealm = new UserRealm();
    
            userRealm.setCachingEnabled(true);
    
            userRealm.setCacheManager(new RedisCacheManager());//这里代表使用redis缓存。
    
            userRealm.setAuthenticationCachingEnabled(true);
            userRealm.setAuthenticationCacheName("authenticationCache");
    
            userRealm.setAuthorizationCachingEnabled(true);
            userRealm.setAuthorizationCacheName("authorizationCache");
    
            return userRealm;
        }

# 7.测试 #

我这里编写了一个测试登录的接口，然后登录之后就可以去redis中查看数据了，然后当你再次登录的时候，去后端查看日志，看是否再次访问了mysql接口，如果没有进行访问mysql数据库，那么就代表使用redis作为缓存机制成功。  
![在这里插入图片描述][20210206142834325.png]

[20210206142156644.png]: /images/20221024/36a02e4c764f47c98a4e42363f7750ff.png
[20210206142516654.png]: /images/20221024/7e37640950d24de18cd52f9e64a9fca4.png
[20210206142834325.png]: /images/20221024/c5ac98d72f634d76a9e628acf7ddf5ad.png