Shiro缓存使用Redis、Ehcache、自带的MpCache实现的三种方式实例

已于 2022-03-13 15:03:25 修改
阅读量911 收藏
点赞数 1
分类专栏： # Shiro授权认证 文章标签： shiro
于 2021-01-14 23:17:27 首次发布
原文链接：https://www.cnblogs.com/zfding/p/8536480.html
版权

第一种：使用Redis做缓存，将数据存储到redis数据库中

第一步：在项目里面引入redis，配置文件如下：

配置文件:spring_shiro_redis.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:c="http://www.springframework.org/schema/c"
       xmlns:cache="http://www.springframework.org/schema/cache"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/cache
       http://www.springframework.org/schema/cache/spring-cache.xsd">
      <description>spring-redis-cache配置文件</description>
<!-- ###############################-Redis-########################################### -->
    <!-- 配置redis和spring 的整合 -->
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxTotal" value="${redis.maxTotal}" />
        <property name="maxIdle" value="${redis.maxIdle}" />
        <property name="maxWaitMillis" value="${redis.maxWaitMills}" />
        <!-- <property name="testOnBorrow" value="${redis.pool.testOnBorrow}" /> -->
    </bean>
    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="hostName" value="${redis.masterHost}" />
        <property name="port" value="${redis.masterPort}" />
        <property name="timeout" value="${redis.timeout}" />
        <property name="password" value="${redis.masterPassword}" />
        <property name="poolConfig" ref="jedisPoolConfig" />
    </bean>
    <bean id="template" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="jedisConnectionFactory" />
        <!-- 开启事务 -->
        <property name="enableTransactionSupport" value="true" />
        <!-- 序列化策略 推荐使用StringRedisSerializer -->
        <!--  <property name="keySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property> -->
        <!-- <property name="valueSerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property> -->
        <!--<property name="hashKeySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="hashValueSerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property> -->
        <property name="keySerializer">
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"></bean>
        </property>
        <property name="valueSerializer">
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
        </property>
        <property name="hashKeySerializer">
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
        </property>
        <property name="hashValueSerializer">
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
        </property>
    </bean>
    <!--spring cache-->
    <bean id="cacheManager" class="org.springframework.data.redis.cache.RedisCacheManager"
          c:redisOperations-ref="template">
        <!-- 默认缓存10分钟 -->
        <property name="defaultExpiration" value="600"/>
        <property name="usePrefix" value="true"/>
        <!-- cacheName 缓存超时配置，半小时，一小时，一天 -->
        <property name="expires">
            <map key-type="java.lang.String" value-type="java.lang.Long">
                <entry key="halfHour" value="1800"/>
                <entry key="hour" value="3600"/>
                <entry key="oneDay" value="86400"/>
                <!-- shiro cache keys 对缓存的配置 -->
                <entry key="authorizationCache" value="1800"/>
                <entry key="authenticationCache" value="1800"/>
                <entry key="activeSessionCache" value="1800"/>
            </map>
        </property>
    </bean>
    <!-- cache注解，和spring-ehcache.xml中的只能使用一个 -->
    <cache:annotation-driven cache-manager="cacheManager" proxy-target-class="true"/>
</beans>

redis的配置文件redis.properties:

#Reids config
#最大能够保持活动的对象数
redis.maxIdle=10
redis.maxTotal=100
#当池内没有返回对象时最大等待时间
redis.maxWaitMills=1000
#超时时间
redis.timeout=1000
#当调用borrow Object方法时，是否进行有效性检查
redis.pool.testOnBorrow=true
#redis-master
redis.masterHost=192.168.206.128
redis.masterPort=6379
redis.masterPassword=1234

下面是spring-shiro.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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd"
    default-lazy-init="true">
    <description>Spring-shiro配置文件</description>
     <!--配置安全管理器-->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <!--设置自定义Realm-->
        <property name="realm" ref="myRealm"/>
        <!--将缓存管理器，交给安全管理器-->
        <property name="cacheManager" ref="shiroSpringCacheManager"/>
        <!-- 记住密码管理 -->
        <property name="rememberMeManager" ref="rememberMeManager"/>
        <property name="sessionManager" ref="sessionManager"/>
    </bean>
    <!-- 自定义realm -->
    <bean id = "myRealm" class="com.dzf.shiro.MyRealm">
        <property name="cacheManager" ref="shiroSpringCacheManager"/>
        <property name="credentialsMatcher" ref="myCredentialsMatcher"/>
        <!-- 打开缓存 -->
        <property name="cachingEnabled" value="true"/>
        <!-- 打开身份认证缓存 -->
        <property name="authenticationCachingEnabled" value="true"/>
        <!-- 打开授权缓存 -->
        <property name="authorizationCachingEnabled" value="true"/>
        <!-- 缓存AuthenticationInfo信息的缓存名称 --> 
        <property name="authenticationCacheName" value="authenticationCache"/>
        <!-- 缓存AuthorizationInfo信息的缓存名称 -->
        <property name="authorizationCacheName" value="authorizationCache"/>
    </bean>
    <!-- 配置自定义缓存管理器，中引入redis缓存管理器 -->
    <bean id = "shiroSpringCacheManager" class="com.dzf.shiro.ShiroSpringCacheManager">
        <property name="cacheManager" ref="cacheManager"/>
    </bean>
     <!-- 密码错误5次锁定半小时 -->
    <bean id="myCredentialsMatcher" class="com.dzf.shiro.MyCredentialsMatcher">
        <property name="cacheManager" ref="shiroSpringCacheManager"/>
        <property name="limitCacheName" value="halfHour"/>
        <property name="passwordHash" ref="passwordHash"/>
    </bean>
    <bean id = "passwordHash"  class="com.dzf.shiro.PasswordHash">
        <!-- 使用MD5 -->
        <property name="hashAlgorithm" value="md5" />
        <!-- 加密5次 -->
        <property name="hashIterations" value="2"/>
    </bean>
     <!-- 记住密码Cookie -->
    <bean id="rememberMeCookie" class="org.apache.shiro.web.servlet.SimpleCookie">  
            <!-- cookie的名字 -->
        <constructor-arg value="rememberMe"/>
        <property name="httpOnly" value="true"/>
        <!-- 7天,-->
        <property name="maxAge" value="604800"/>
    </bean>
    <!-- sesisonCookie 设置  -->
    <bean id="sessionIdCookie" class="org.apache.shiro.web.servlet.SimpleCookie">  
            <!-- cookie的名字 -->
        <constructor-arg value="sessionIdCookie"/>
        <property name="httpOnly" value="true"/>
        <!-- 30分钟  单位是秒-->
        <property name="maxAge" value="1800"/>
    </bean>   
    <!-- rememberMe管理器,cipherKey生成见{@code Base64Test.java} -->
    <bean id="rememberMeManager" class="org.apache.shiro.web.mgt.CookieRememberMeManager">
        <property name="cipherKey" value="#{T(org.apache.shiro.codec.Base64).decode('5aaC5qKm5oqA5pyvAAAAAA==')}"/>
        <property name="cookie" ref="rememberMeCookie"/>  
    </bean>
     <!-- 会话管理器 -->
    <bean id="sessionManager" class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">
        <!-- 设置全局会话超时时间 半小时  单位是毫秒-->
        <property name="globalSessionTimeout" value="1800000"/>
        <!-- url上带sessionId 默认为true -->
        <property name="sessionIdUrlRewritingEnabled" value="false"/>
        <property name="sessionIdCookie" ref="sessionIdCookie"/>
        <property name="sessionDAO" ref="sessionDAO"/>
    </bean>
    
    <!-- 会话DAO 用于会话的CRUD -->
    <bean id="sessionDAO" class="org.apache.shiro.session.mgt.eis.EnterpriseCacheSessionDAO">
        <!-- Session缓存名字，配置30分钟过期 -->
        <property name="activeSessionsCacheName" value="activeSessionCache"/>
        <property name="cacheManager" ref="shiroSpringCacheManager"/>
    </bean>
    <!-- Shiro Filter -->
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <!-- 安全管理器 -->
        <property name="securityManager" ref="securityManager"/>
        <!-- 默认的登陆访问url -->
        <property name="loginUrl" value="/login.jsp"/>
        <!-- 登陆成功后跳转的url -->
        <!-- <property name="successUrl" value="/index.jsp"/> -->
        <!-- 没有权限跳转的url -->
        <property name="unauthorizedUrl" value="/unauth.jsp"/>
        <property name="filterChainDefinitions">
            <value>
                <!-- 
                    anon  不需要认证
                    authc 需要认证
                    user  验证通过或RememberMe登录的都可以
                -->
                /commons/** = anon
                /static/** = anon
                /user/login = anon
                /user/toLogin= anon
                /user/register = anon
                /register.jsp = anon
                /** = authc
            </value>
        </property>
    </bean>
    
    <!-- 静态注入，相当于调用SecurityUtils.setSecurityManager(securityManager) -->
    <bean class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
        <property name="staticMethod" value="org.apache.shiro.SecurityUtils.setSecurityManager"/>
        <property name="arguments" ref="securityManager"/>
    </bean>
    <!-- 保证实现了Shiro内部lifecycle函数的bean执行 -->
    <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>
</beans>

第二步：定义自己的CacheManager

package com.dzf.shiro;

import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheManager;
import org.apache.shiro.util.Destroyable;
/**
 * <p> 自定义cacheManage 扩张shiro里面的缓存 使用reids作缓存 </p>
 * <description>
 *  引入自己定义的CacheManager
 *  关于CacheManager的配置文件在spring-redis-cache.xml中
 * </description>
 * @author xxxx
 * @date 2018年2月3日
 * @time 14:01:53
 */

public class ShiroSpringCacheManager implements CacheManager ,Destroyable{

    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 <K, V> Cache<K, V> getCache(String name)  {
        if (name == null ){
            return null;
        }
        return new ShiroSpringCache<K,V>(name,getCacheManager());
    }


}

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

package com.dzf.shiro;
 
 import org.apache.shiro.cache.CacheException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.cache.Cache;
 import org.springframework.cache.Cache.ValueWrapper;
 import org.springframework.cache.CacheManager;
 
 import java.util.Collection;
 import java.util.Set;
 
 /**
  * <p> 自定义缓存 将数据存入到redis中 </p>
  * @author xxx
  * @date 2018年2月1日
  * @time 22:32:11
  * @param <K>
  * @param <V>
  */
 @SuppressWarnings("unchecked")
 public class ShiroSpringCache<K,V> implements org.apache.shiro.cache.Cache<K, V>{
     private static final Logger log = LoggerFactory.getLogger(ShiroSpringCache.class);
     private CacheManager cacheManager;
     private Cache cache;
 //    private RedisCache cache2;
     public ShiroSpringCache(String name, CacheManager cacheManager) {
         if(name==null || cacheManager==null){
             throw new IllegalArgumentException("cacheManager or CacheName cannot be null.");
         }
         this.cacheManager = cacheManager;
         //这里首先是从父类中获取这个cache,如果没有会创建一个redisCache,初始化这个redisCache的时候
         //会设置它的过期时间如果没有配置过这个缓存的，那么默认的缓存时间是为0的，如果配置了，就会把配置的时间赋予给这个RedisCache
         //如果从缓存的过期时间为0，就表示这个RedisCache不存在了，这个redisCache实现了spring中的cache
         this.cache= cacheManager.getCache(name);
     }
     @Override
     public V get(K key) throws CacheException {
         log.info("从缓存中获取key为{}的缓存信息",key);
         if(key == null){
             return null;
         }
         ValueWrapper valueWrapper = cache.get(key);
         if(valueWrapper==null){
             return null;
         }
         return (V) valueWrapper.get();
     }
 
     @Override
     public V put(K key, V value) throws CacheException {
         log.info("创建新的缓存，信息为：{}={}",key,value);
         cache.put(key, value);
         return get(key);
     }
 
     @Override
     public V remove(K key) throws CacheException {
         log.info("干掉key为{}的缓存",key);
         V v = get(key);
         cache.evict(key);//干掉这个名字为key的缓存
         return v;
     }
 
     @Override
     public void clear() throws CacheException {
         log.info("清空所有的缓存");
         cache.clear();
     }
 
     @Override
     public int size() {
         return cacheManager.getCacheNames().size();
     }
 
     /**
      * 获取缓存中所的key值
      */
     @Override
     public Set<K> keys() {
         return (Set<K>) cacheManager.getCacheNames();
     }
 
     /**
      * 获取缓存中所有的values值
      */
     @Override
     public Collection<V> values() {
         return (Collection<V>) cache.get(cacheManager.getCacheNames()).get();
     }
 
     @Override
     public String toString() {
         return "ShiroSpringCache [cache=" + cache + "]";
     }
 }

我来稍微解释下这个自定义ShiroSpringCache类中的CacheManager,这个是CacheManager其实就是RedisCacheManager,我们通过getter和setter注入过,RedisCacheManager是CacheManager的实现类.自己跟着源码看下去，一看就可以看的懂。到此为止，使用redis做缓存，和spring的集成就完成了。注意：需要使用的缓存只需要在spring_shiro_redis.xml中配置就行了，放入缓存中的对象需要实现序列号接口

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

同样需要配置文件：ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache updateCheck="false" dynamicConfig="false">
    <diskStore path="java.io.tmpdir"/>
    <!--授权信息缓存-->
    <cache name="authorizationCache"
           maxEntriesLocalHeap="2000"
           eternal="false"
           timeToIdleSeconds="1800"
           timeToLiveSeconds="1800"
           overflowToDisk="false"
           statistics="true">
    </cache>
<!--身份信息缓存-->
    <cache name="authenticationCache"
           maxEntriesLocalHeap="2000"
           eternal="false"
           timeToIdleSeconds="1800"
           timeToLiveSeconds="1800"
           overflowToDisk="false"
           statistics="true">
    </cache>
<!--session缓存-->
    <cache name="activeSessionCache"
           maxEntriesLocalHeap="2000"
           eternal="false"
           timeToIdleSeconds="1800"
           timeToLiveSeconds="1800"
           overflowToDisk="false"
           statistics="true">
    </cache>

    <!-- 缓存半小时 -->
    <cache name="halfHour"
           maxElementsInMemory="10000"
           maxElementsOnDisk="100000"
           eternal="false"
           timeToIdleSeconds="1800"
           timeToLiveSeconds="1800"
           overflowToDisk="false"
           diskPersistent="false" />

    <!-- 缓存一小时 -->
    <cache name="hour"
           maxElementsInMemory="10000"
           maxElementsOnDisk="100000"
           eternal="false"
           timeToIdleSeconds="3600"
           timeToLiveSeconds="3600"
           overflowToDisk="false"
           diskPersistent="false" />

    <!-- 缓存一天 -->
    <cache name="oneDay"
           maxElementsInMemory="10000"
           maxElementsOnDisk="100000"
           eternal="false"
           timeToIdleSeconds="86400"
           timeToLiveSeconds="86400"
           overflowToDisk="false"
           diskPersistent="false" />

    <!--
        name:缓存名称。
        maxElementsInMemory：缓存最大个数。
        eternal:对象是否永久有效，一但设置了，timeout将不起作用。
        timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
        timeToLiveSeconds：设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
        overflowToDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。
        diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
        maxElementsOnDisk：硬盘最大缓存个数。
        diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
        diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
        memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
        clearOnFlush：内存数量最大时是否清除。
    -->
    <defaultCache name="defaultCache"
                  maxElementsInMemory="10000"
                  eternal="false"
                  timeToIdleSeconds="600"
                  timeToLiveSeconds="600"
                  overflowToDisk="false"
                  maxElementsOnDisk="100000"
                  diskPersistent="false"
                  diskExpiryThreadIntervalSeconds="120"
                  memoryStoreEvictionPolicy="LRU"/>

</ehcache>

spring和ehcache集成的配置文件：spring_ehcache.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:cache="http://www.springframework.org/schema/cache"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/cache
       http://www.springframework.org/schema/cache/spring-cache.xsd">
    <!-- Spring提供的基于的Ehcache实现的缓存管理器 -->
    <!-- 如果有多个ehcacheManager要在bean加上p:shared="true" -->
    <bean id="ehcacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean" >
        <property name="configLocation" value="classpath:ehcache.xml"/>
    </bean>
    <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager">
        <property name="cacheManager" ref="ehcacheManager"/>
        <property name="transactionAware" value="true"/>
    </bean>
    <!-- cache注解，和spring-redis.xml中的只能使用一个 -->
    <cache:annotation-driven cache-manager="cacheManager" proxy-target-class="true"/>
</beans>

第三种：使用MemoryConstrainedCacheManager这个缓存管理器，将数据缓存到内存中去

解释：Shiro已经为我们编写了一套缓存的实现，那就是MpCache，是使用Map实现的，有兴趣的可以去看源码

怎么使用这个shiro已经为我们实现好的缓存，是非常容易的。

在上面的spring-shiro.xml中， <!-- 配置自定义缓存管理器，中引入redis缓存管理器 -->：

<bean id = "shiroSpringCacheManager" class="com.dzf.shiro.ShiroSpringCacheManager">
        <property name="cacheManager" ref="cacheManager"/>

只需要把这个改为下面这句：

<!-- 配置shiro自带的缓存管理器 -->
     <bean id = "shiroSpringCacheManager" class="org.apache.shiro.cache.MemoryConstrainedCacheManager"/>

参考链接：Shiro缓存使用Redis、Ehcache、自带的MpCache实现的三种方式实例

tomorrow.hello
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
shiro使用redis作为缓存
cui_xf_的博客
11-25 6839
应用场景：Shiro的为每个用户的角色和权限信息提供缓存支持，通过Shiro自己定义的CacheManager实现，默认实现有Ehcache和内存（就是一个Map结构），在应用中通常使用redis作为缓存服务器，因此使用redis来作为shiro的缓存。 优缺点：一般来说缓存放在本地，通过本地内存进行缓存速度更快，但是在分布式环境下，修改了用户权限需要经行协同。将缓存和Session放在统一的数据...
Shiro(3) 缓存机制
u010478214的博客
06-19 973
Shiro提供了缓存功能，以确保安全操作保持尽可能的快。 但是Shiro作为一个安全框架，不可能实现一个完整的缓存机制，因此，Shiro提供了一个抽象的缓存API,我们可以通过此套API来继承任何的缓存产品。 首先我们来看看Shiro的缓存API的接口：public interface Cache { public V get(K key) throws CacheExcepti
Spring Boot集成shiro之使用redis缓存demo
最新发布
HBLOG
05-23 564
登录用户，第一次会从数据库中查询，并通过RedisTemplate的put方法将用户信息装入缓存，下次再刷新首页就会从redis中查询权限，授权等信息。启动项目，访问http://127.0.0.1:8088/userInfo/userAdd，会跳转到登录页，输入admin 123456，查看redis是否缓存了。由于自定义realm中认证所需要的盐值内部并没有实现序列化接口，所以我们需要自己定一个。注意实体类（角色类，用户类，权限类）要记得实现Serializable接口 最后在。
springboot + shiro 整合 redis 缓存用户并发登录限制和用户登录错误次数
快乐的小三菊的博客
06-08 2856
springboot + shiro + redis
细说shiro之七：缓存
骏马逸动，心随你动的博客
06-03 563
官网：https://shiro.apache.org/ 一. 概述 Shiro作为一个开源的权限框架，其组件化的设计思想使得开发者可以根据具体业务场景灵活地实现权限管理方案，权限粒度的控制非常方便。 首先，我们来看看Shiro框架的架构图： 从上图我们可以很清晰地看到，CacheManager也是Shiro架构中的主要组件之一，Shiro正是通过CacheManager组件实现权限数据缓存。 当权限信息存放在数据库中时，对于每次前端的访问请求都需要进行一次数据库查询。特别是在大量使用shiro的jsp
Shiro使用Redis作为缓存(解决Shiro频繁访问Redis)(十一)
Doge的技术小屋
11-10 1687
原文：https://blog.csdn.net/qq_34021712/article/details/80791219 之前写过一篇博客,使用的一个开源项目,实现了redis作为缓存 缓存用户的权限 和 session信息,还有两个功能没有修改,一个是用户并发登录限制,一个是用户密码错误次数.本篇中几个类 也是使用的开源项目中的类,只不过是拿出来了,redis单独做的配置,方便进行优化。 整合过程 1.首先是整合Redis Redis客户端使用的是RedisTemplate,自己写了一个序列化工具继承R
shiro缓存机实例代码
09-15
总的来说，Shiro 的缓存机制提供了一种灵活的方式，允许开发者根据项目需求选择合适的缓存实现，并通过简单的配置启用和管理缓存，从而提升应用的性能和响应速度。这使得 Shiro 成为了 Java 安全领域一个极具吸引力...
java shiro实现退出登陆清空缓存
08-31
这里没有给出具体的缓存清理代码，因为实际应用中可能涉及不同的缓存实现（如 Redis、Memcached 或 Ehcache），清理缓存的方法会因缓存技术而异。 总之，通过扩展 Shiro 的 `LogoutFilter`，我们可以在用户登出时...
Shiro集成 Redis 方案
01-07
如果你需要使用 Redis 存储权限和角色相关的缓存，需要创建 `RedisCacheManager` 实例，并在 Shiro 配置中指定。 6. **连接池配置** 对于高并发场景，推荐使用 Redis 连接池，如 JedisPool 或 lettuce 的 ...
shiro-redis-master.zip
12-10
"shiro-redis-master.zip" 是一个针对Shiro框架的扩展，它将默认的Ehcache缓存替换为Redis，以实现更高效的集中式缓存解决方案。在分布式系统中，使用Redis作为缓存可以提高数据的一致性和可访问性，特别是对于那些...
Shiro应用实例2
02-03
这可以通过配置 Realm 使用缓存 provider 来实现，例如 Ehcache 或 Redis。 7. **安全管理配置**：在 Shiro 的配置文件（如 shiro.ini 或者 XML 配置）中，开发者可以定义安全相关的设置，如 Realm 的配置、过滤器...
MP_Cache用户指南(中英文对译版)
03-10
MP_Cache用户指南(中英文对译版) MP_Cache 类是为CodeIgniter提供更多灵活性的缓存解决方案。 你能使用它来缓存从数据库查询获得的单一数据变量或者缓存整个页面。 MP_Cache 把序列化后的数据保存进文件,同时提供函数方法去回收重建和删除该缓存文件。
shiro授权 shiro和企业项目整合开发
10-14
可以使用 EhCache、Redis 或其他缓存系统。配置缓存管理器，如 `EhCacheManager` 或 `RedisCacheManager`，并将其注入 SecurityManager。 ### 五、验证码和“记住我”功能 1. **验证码**：Shiro 并不直接提供...
shiro权限代码
04-08
你可以配置缓存管理器，例如使用 EhCache 或 Redis 实现分布式缓存。 8. **安全逻辑**：在业务逻辑中，你可以通过Subject的`isPermitted()`、`hasRole()`等方法判断用户是否有执行某项操作的权限。 9. **退出登录*...
shiro-jwt-springboot：shiro合并jwt前进行分离权限认证示例
01-29
Shiro支持多种缓存实现，如EhCache或Redis。 总结来说，"shiro-jwt-springboot"项目为我们提供了一个示例，演示了如何在Spring Boot应用中利用Apache Shiro进行权限认证，并结合JWT进行安全的身份验证。通过这个...
Shiro整合Sping的源码
03-23
- Shiro 还支持缓存管理，可以通过集成 Redis 或 Ehcache 提高性能。 - Spring Security 是另一个强大的安全框架，虽然比 Shiro 复杂，但功能更全面，可以考虑根据项目需求选择合适的框架。 了解这些知识点后，你...
shiro 刷新认证以及权限缓存（略坑）
热门推荐
qq_37959142的博客
04-20 1万+
这里提供两种清除用户缓存的方法1、通过ehcache清除缓存（已验证）这种方法简单明了，适合对cache比较了解的人思路：从shiroCacheManager获取用户的认证缓存，以及权限缓存，然后根据principal（username等可以确定用户信息的key，在配置shiro的时候由用户指定）对cache进行remove操作。代码：@Resource(name = "shiroCacheMan...
ssm+shiro
mengyong1108的博客
08-16 364
shiro原理 框架解释：  subject：主体，可以是用户也可以是程序，主体要访问系统，系统需要对主体进行认证、授权。 securityManager：安全管理器，主体进行认证和授权都 是通过securityManager进行。它包含下面的认证器和授权器。 authenticator：认证器，主体进行认证最终通过authenticator进行的。  authorizer：授权器，主体
spring boot 集成shiro，redis，EhCache缓存的主要配置
╃緣分天空╃
11-14 1489
简介：redis用户缓存用户的session,EhCache用于缓存用户的权限。 问题：即使有EhCache缓存了用户的权限,但是每次访问需要权限的方法时,依然会调用授权方法进行授权。 ShiroConfig.java import at.pollux.thymeleaf.shiro.dialect.ShiroDialect; import com.nongqitong.web.red...
shiro redis缓存
05-27
Shiro提供了一个可扩展的缓存机制，可以将缓存存储到各种数据源中，其中Redis是一种常用的缓存数据源之一。使用Redis作为Shiro缓存数据源可以提高缓存访问速度和效率。 要使用Redis作为Shiro的缓存数据源，需要在Shiro配置文件中配置Redis缓存管理器和Redis缓存数据源。具体配置方法可以参考Shiro的官方文档或者其他相关资料。 配置完成后，Shiro会自动将需要缓存的数据存储到Redis中，可以大大提高系统的性能和稳定性。同时，使用Redis作为缓存数据源还可以支持分布式部署，可以实现多个服务器之间的数据共享和同步。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值