SpringBoot中Shiro缓存使用Redis、Ehcache

心已赠人 2023-06-04 02:41 79阅读 0赞

在SpringBoot中Shiro缓存使用Redis、Ehcache实现的两种方式实例

SpringBoot 中配置redis作为session 缓存器。 让shiro引用

  • 本文是建立在你是使用这shiro基础之上的补充内容

第一种：Redis缓存，将数据存储到redis 并且开启session存入redis中。

引入pom

  1. <dependency>
  2.             <groupId>org.springframework.boot</groupId>
  3.             <artifactId>spring-boot-starter-data-redis</artifactId>
  4.         </dependency>
  5.         <dependency>
  6.             <groupId>org.springframework.session</groupId>
  7.             <artifactId>spring-session-data-redis</artifactId>
  8.      </dependency>

配置redisConfig

  1. @Configuration
  2. @EnableCaching
  3. public class RedisConfig extends CachingConfigurerSupport {
  4.     @Bean
  5.     public KeyGenerator keyGenerator() {
  6.         return new KeyGenerator() {
  7.             @Override
  8.             public Object generate(Object target, Method method, Object... params) {
  9.                 StringBuilder sb = new StringBuilder();
  10.                 sb.append(target.getClass().getName());
  11.                 sb.append(method.getName());
  12.                 for (Object obj : params) {
  13.                     sb.append(obj.toString());
  14.                 }
  15.                 return sb.toString();
  16.             }
  17.         };
  18.     }
  21.     @Bean
  22.     //在这里配置缓存reids配置
  23.     public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
  24.         RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
  25.                 .entryTtl(Duration.ofHours(1)); // 设置缓存有效期一小时
  26.         System.out.println("《========【开启redis】 ======== 》 ");
  27.         return RedisCacheManager
  28.                 .builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
  29.                 .cacheDefaults(redisCacheConfiguration).build();
  30.     }
  32.     @Bean
  33.     public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
  34.         StringRedisTemplate template = new StringRedisTemplate(factory);
  35.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  36.         ObjectMapper om = new ObjectMapper();
  37.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  38.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  39.         jackson2JsonRedisSerializer.setObjectMapper(om);
  40.         template.setValueSerializer(jackson2JsonRedisSerializer);
  41.         template.afterPropertiesSet();
  42.         return template;
  43.     }
  45. }

配置自定义缓存管理器，引入redis缓存管理器

  • 定义自己的CacheManager

    /**

    • 自定义cacheManage 扩张shiro里面的缓存 使用reids作缓存

    • 引入自己定义的CacheManager
    • 关于CacheManager的配置文件在spring-redis-cache.xml中


    • /
      @Component
      public class ShiroSpringCacheManager implements CacheManager ,Destroyable{
      /*

      • 将之上的RedisCacheManager的Bean拿出来 注入于此
        */
        @Autowired
        private org.springframework.cache.CacheManager cacheManager;

        public org.springframework.cache.CacheManager getCacheManager() {
        return cacheManager;
        }

        public void setCacheManager(org.springframework.cache.CacheManager cacheManager) {
        this.cacheManager = cacheManager;
        }

        @Override
        public void destroy() throws Exception {
        cacheManager = null;
        }

        @Override
        public Cache getCache(String name) {
        if (name == null ){

        1.  return null;

        }
        // 新建一个ShiroSpringCache 将Bean放入并实例化
        return new ShiroSpringCache(name,getCacheManager());
        }

  1. }

  • 定义自己实现的Shiro的Cache,实现了Shiro包里的Cache

    /**

    • 自定义缓存 将数据存入到redis中


      */
      @SuppressWarnings(“unchecked”)
      public class ShiroSpringCache implements org.apache.shiro.cache.Cache{
      private static final Logger log = LoggerFactory.getLogger(ShiroSpringCache.class);
      private CacheManager cacheManager;
      private Cache cache;

      public ShiroSpringCache(String name, CacheManager cacheManager) {

      1.  if(name==null || cacheManager==null){
      2.      throw new IllegalArgumentException("cacheManager or CacheName cannot be null.");
      3.  }
      4.  this.cacheManager = cacheManager;
      5.  //这里首先是从父类中获取这个cache,如果没有会创建一个redisCache,初始化这个redisCache的时候
      6.  //会设置它的过期时间如果没有配置过这个缓存的，那么默认的缓存时间是为0的，如果配置了，就会把配置的时间赋予给这个RedisCache
      7.  //如果从缓存的过期时间为0，就表示这个RedisCache不存在了，这个redisCache实现了spring中的cache
      8.  this.cache= cacheManager.getCache(name);

      }
      @Override
      public V get(K key) throws CacheException {

      1.  log.info("从缓存中获取key为{}的缓存信息",key);
      2.  if(key == null){
      3.      return null;
      4.  }
      5.  ValueWrapper valueWrapper = cache.get(key);
      6.  if(valueWrapper==null){
      7.      return null;
      8.  }
      9.  return (V) valueWrapper.get();

      }

      @Override
      public V put(K key, V value) throws CacheException {

      1.  log.info("创建新的缓存，信息为：{}={}",key,value);
      2.  cache.put(key, value);
      3.  return get(key);

      }

      @Override
      public V remove(K key) throws CacheException {

      1.  log.info("干掉key为{}的缓存",key);
      2.  V v = get(key);
      3.  cache.evict(key);//干掉这个名字为key的缓存
      4.  return v;

      }

      @Override
      public void clear() throws CacheException {

      1.  log.info("清空所有的缓存");
      2.  cache.clear();

      }

      @Override
      public int size() {

      1.  return cacheManager.getCacheNames().size();

      }

      /**

      • 获取缓存中所的key值
        */
        @Override
        public Set keys() {
        return (Set) cacheManager.getCacheNames();
        }

        /**

      • 获取缓存中所有的values值
        */
        @Override
        public Collection values() {
        return (Collection) cache.get(cacheManager.getCacheNames()).get();
        }

        @Override
        public String toString() {
        return “ShiroSpringCache [cache=” + cache + “]”;
        }
        }

  • 到此为止，使用redis做缓存，和spring的集成就完成了。

  • 可以使用以下注解将缓存放入redis

    @Cacheable(value = Cache.CONSTANT, key = “‘“ + CacheKey.DICTNAME + “‘+#name+’‘+#val”)

配置spring session管理器

  1. @Bean
  2.     @ConditionalOnProperty(prefix = "xpro", name = "spring-session-open", havingValue = "true")
  3.     public ServletContainerSessionManager servletContainerSessionManager() {
  4.         return new ServletContainerSessionManager();
  5.     }

  • 新建类 spring session设置session过期时间

    /**

    • spring session配置
      *
    • @author xingri
    • @date 2017-07-13 21:05
      */
      @EnableRedisHttpSession(maxInactiveIntervalInSeconds = 900) //session过期时间 如果部署多机环境,需要打开注释
      @ConditionalOnProperty(prefix = “xpro”, name = “spring-session-open”, havingValue = “true”)
      public class SpringSessionConfig {

    }

第一种：Ehcache做缓存，可以将数据存储到磁盘中，也可以存到内存中

  • 新建ehcache.xml 文件

    <?xml version=”1.0” encoding=”UTF-8”?>

配置自定义缓存管理器，引入ehcache缓存管理器

  1. /**
  2.  * ehcache配置
  3.  *
  4.  */
  5. @Configuration
  6. @EnableCaching
  7. public class EhCacheConfig {
  9.     /**
  10.      * EhCache的配置
  11.      */
  12.     @Bean
  13.     public EhCacheCacheManager cacheManager(CacheManager cacheManager) {
  14.         MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
  15.         ManagementService.registerMBeans(cacheManager, mBeanServer, true, true, true, true);
  16.         return new EhCacheCacheManager(cacheManager);
  17.     }
  19.     /**
  20.      * EhCache的配置
  21.      */
  22.     @Bean
  23.     public EhCacheManagerFactoryBean ehcache() {
  24.         System.out.println("《========【开启ehcache】 ======== 》 ");
  25.         EhCacheManagerFactoryBean ehCacheManagerFactoryBean = new EhCacheManagerFactoryBean();
  26.         ehCacheManagerFactoryBean.setConfigLocation(new ClassPathResource("ehcache.xml"));
  27.         return ehCacheManagerFactoryBean;
  28.     }
  30.     @Bean
  31.     public org.apache.shiro.cache.CacheManager getCacheShiroManager(EhCacheManagerFactoryBean ehcache) {
  32.         EhCacheManager ehCacheManager = new EhCacheManager();
  33.         ehCacheManager.setCacheManager(ehcache.getObject());
  34.         return ehCacheManager;
  35.     }
  36. }

最后 最重要的是引入shriro 中

  1. /**
  2.  * shiro权限管理的配置
  3.  *
  4.  */
  5. @Configuration
  6. public class ShiroConfig {
  8.     /**
  9.      * 安全管理器
  10.      */
  11.     @Bean
  12.     public DefaultWebSecurityManager securityManager(CookieRememberMeManager rememberMeManager, CacheManager cacheShiroManager, SessionManager sessionManager) {
  13.         DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
  14.         securityManager.setAuthenticator(modularRealmAuthenticator());
  16.         List<Realm> realms=new ArrayList<>();
  17.         securityManager.setRealms(realms);
  19.         securityManager.setCacheManager(cacheShiroManager);
  21.         securityManager.setRememberMeManager(rememberMeManager);
  22.         securityManager.setSessionManager(sessionManager);
  23.         return securityManager;
  24.     }
  27.     /**
  28.      * spring session管理器（多机环境）
  29.      */
  30.     @Bean
  31.     public ServletContainerSessionManager servletContainerSessionManager() {
  32.         return new ServletContainerSessionManager();
  33.     }
  35.     /**
  36.      * session管理器(单机环境) 使用cookie存储缓存。。如果多级请注释
  37.      */
  38.     @Bean
  39.     public DefaultWebSessionManager defaultWebSessionManager(CacheManager cacheShiroManager, XProProperties xProProperties) {
  40.         DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
  41.         sessionManager.setCacheManager(cacheShiroManager);
  42.         sessionManager.setSessionValidationInterval(xProProperties.getSessionValidationInterval() * 1000);
  43.         sessionManager.setGlobalSessionTimeout(xProProperties.getSessionInvalidateTime() * 1000);
  44.         sessionManager.setDeleteInvalidSessions(true);
  45.         sessionManager.setSessionValidationSchedulerEnabled(true);
  46.         Cookie cookie = new SimpleCookie(ShiroHttpSession.DEFAULT_SESSION_ID_NAME);
  47.         cookie.setName("shiroCookie");
  48.         cookie.setHttpOnly(true);
  49.         sessionManager.setSessionIdCookie(cookie);
  50.         return sessionManager;
  51.     }
  55.     /**
  56.      * 缓存管理器 使用Ehcache实现 如果使用redis则注释下面内容！！！！ 
  57.      */
  58.     @Bean
  59.     public CacheManager getCacheShiroManager(EhCacheManagerFactoryBean ehcache) {
  60.         EhCacheManager ehCacheManager = new EhCacheManager();
  61.         ehCacheManager.setCacheManager(ehcache.getObject());
  62.         return ehCacheManager;
  63.     }
  67.     /**
  68.      * 项目自定义的Realm
  69.      */
  70.     @Bean
  71.     public ShiroDbRealm shiroDbRealm() {
  72.         return new ShiroDbRealm();
  73.     }
  75.     @Bean
  76.     public ShiroTockenRealm shiroTockenRealm( ) {
  77.         return new ShiroTockenRealm();
  78.     }
  80.     @Bean
  81.     public ShiroJwtRealm shiroJwtRealm( ) {
  82.         return new ShiroJwtRealm();
  83.     }
  85.     /**
  86.      * 系统自带的Realm管理，主要针对多realm
  87.      * */
  88.     @Bean
  89.     public ModularRealmAuthenticator modularRealmAuthenticator(){
  90.         ModularRealmAuthenticator modularRealmAuthenticator=new ModularRealmAuthenticator();
  91.         modularRealmAuthenticator.setAuthenticationStrategy(new AtLeastOneSuccessfulStrategy());
  92.         return modularRealmAuthenticator;
  93.     }
  94.     /**
  95.      * rememberMe管理器, cipherKey生成见{@code Base64Test.java}
  96.      */
  97.     @Bean
  98.     public CookieRememberMeManager rememberMeManager(SimpleCookie rememberMeCookie) {
  99.         CookieRememberMeManager manager = new CookieRememberMeManager();
  100.         manager.setCipherKey(Base64.decode("Z3VucwAAAAAAAAAAAAAAAA=="));
  101.         manager.setCookie(rememberMeCookie);
  102.         return manager;
  103.     }
  105.     /**
  106.      * 记住密码Cookie
  107.      */
  108.     @Bean
  109.     public SimpleCookie rememberMeCookie() {
  110.         SimpleCookie simpleCookie = new SimpleCookie("rememberMe");
  111.         simpleCookie.setHttpOnly(true);
  112.         simpleCookie.setMaxAge(7 * 24 * 60 * 60);//7天
  113.         return simpleCookie;
  114.     }
  117.     /**
  118.      * 在方法中 注入 securityManager,进行代理控制
  119.      */
  120.     @Bean
  121.     public MethodInvokingFactoryBean methodInvokingFactoryBean(DefaultWebSecurityManager securityManager) {
  122.         MethodInvokingFactoryBean bean = new MethodInvokingFactoryBean();
  123.         bean.setStaticMethod("org.apache.shiro.SecurityUtils.setSecurityManager");
  124.         bean.setArguments(new Object[]{securityManager});
  125.         return bean;
  126.     }
  128.     /**
  129.      * 保证实现了Shiro内部lifecycle函数的bean执行
  130.      */
  131.     @Bean
  132.     public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
  133.         return new LifecycleBeanPostProcessor();
  134.     }
  136.     /**
  137.      * 启用shrio授权注解拦截方式，AOP式方法级权限检查
  138.      */
  139.     @Bean
  140.     @DependsOn(value = "lifecycleBeanPostProcessor") //依赖其他bean的初始化
  141.     public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
  142.         return new DefaultAdvisorAutoProxyCreator();
  143.     }
  145.     @Bean
  146.     public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(DefaultWebSecurityManager securityManager) {
  147.         AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor =
  148.                 new AuthorizationAttributeSourceAdvisor();
  149.         authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
  150.         return authorizationAttributeSourceAdvisor;
  151.     }
  153. }

转载于:https://www.cnblogs.com/rolandlee/p/11359314.html

发表评论

表情：
评论列表 （有 0 条评论，79人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Spring Boot Shiro中使用缓存

    在Shiro中加入缓存可以使权限相关操作尽可能快，避免频繁访问数据库获取权限信息，因为对于一个用户来说，其权限在短时间内基本是不会变化的。Shiro提供了Cache的抽象，其并

    桃扇骨桃扇骨/ 0 赞/ 79 阅读