org.apache.shiro.cache.CacheManager Java Examples

/**
 * session管理器(单机环境)
 */
@Bean
@ConditionalOnProperty(prefix = "guns", name = "spring-session-open", havingValue = "false")
public DefaultWebSessionManager defaultWebSessionManager(CacheManager cacheShiroManager, GunsProperties gunsProperties) {
    DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
    sessionManager.setCacheManager(cacheShiroManager);
    sessionManager.setSessionValidationInterval(gunsProperties.getSessionValidationInterval() * 1000);
    sessionManager.setGlobalSessionTimeout(gunsProperties.getSessionInvalidateTime() * 1000);
    sessionManager.setDeleteInvalidSessions(true);
    sessionManager.setSessionValidationSchedulerEnabled(true);
    Cookie cookie = new SimpleCookie(ShiroHttpSession.DEFAULT_SESSION_ID_NAME);
    cookie.setName("shiroCookie");
    cookie.setHttpOnly(true);
    sessionManager.setSessionIdCookie(cookie);
    return sessionManager;
}
 

/**
 * 定义Shiro安全管理配置
 */
@Bean
public WebSecurityManager securityManager(AuthorizingRealm authorizingRealm,
		CasAuthorizingRealm casAuthorizingRealm, SessionManager sessionManager,
		CacheManager shiroCacheManager) {
	WebSecurityManager bean = new WebSecurityManager();
	Collection<Realm> realms = ListUtils.newArrayList();
	realms.add(authorizingRealm); // 第一个为权限授权控制类
	realms.add(casAuthorizingRealm);
	bean.setRealms(realms);
	bean.setSessionManager(sessionManager);
	bean.setCacheManager(shiroCacheManager);
	// 设置支持CAS的subjectFactory
	bean.setSubjectFactory(new CasSubjectFactory());
	return bean;
}
 

/**
 * session管理器(单机环境)
 */
@Bean
@ConditionalOnProperty(prefix = "guns", name = "spring-session-open", havingValue = "false")
public DefaultWebSessionManager defaultWebSessionManager(CacheManager cacheShiroManager, GunsProperties gunsProperties) {
    DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
    sessionManager.setCacheManager(cacheShiroManager);
    sessionManager.setSessionValidationInterval(gunsProperties.getSessionValidationInterval() * 1000);
    sessionManager.setGlobalSessionTimeout(gunsProperties.getSessionInvalidateTime() * 1000);
    sessionManager.setDeleteInvalidSessions(true);
    sessionManager.setSessionValidationSchedulerEnabled(true);
    Cookie cookie = new SimpleCookie(ShiroHttpSession.DEFAULT_SESSION_ID_NAME);
    cookie.setName("shiroCookie");
    cookie.setHttpOnly(true);
    sessionManager.setSessionIdCookie(cookie);
    return sessionManager;
}
 

public ApiKeyRealm(String name, CacheManager cacheManager, AuthIdentityReader<ApiKey> authIdentityReader,
                   PermissionReader permissionReader, @Nullable String anonymousId) {
    super(null, AnonymousCredentialsMatcher.anonymousOrMatchUsing(new SimpleCredentialsMatcher()));


    _authIdentityReader = checkNotNull(authIdentityReader, "authIdentityReader");
    _permissionReader = checkNotNull(permissionReader, "permissionReader");
    _anonymousId = anonymousId;

    setName(checkNotNull(name, "name"));
    setAuthenticationTokenClass(ApiKeyAuthenticationToken.class);
    setPermissionResolver(permissionReader.getPermissionResolver());
    setRolePermissionResolver(createRolePermissionResolver());
    setCacheManager(prepareCacheManager(cacheManager));
    setAuthenticationCachingEnabled(true);
    setAuthorizationCachingEnabled(true);

    // By default Shiro calls clearCache() for each user when they are logged out in order to prevent stale
    // credentials from being cached.  However, if the cache manager implements InvalidatingCacheManager then it has
    // its own internal listeners that will invalidate the cache on any updates, making this behavior unnecessarily
    // expensive.
    _clearCaches = cacheManager != null && !(cacheManager instanceof InvalidatableCacheManager);
    _log.debug("Clearing of caches for realm {} is {}", name, _clearCaches ? "enabled" : "disabled");
}
 

@Bean(name = "securityManager")
	@ConditionalOnMissingBean
	public DefaultSecurityManager securityManager(CacheManager shiroCacheManager) {
        DefaultWebSecurityManager dwsm = new DefaultWebSecurityManager();

        // 用自己的Factory实现替换默认
        // 用于关闭session功能
        dwsm.setSubjectFactory(new StatelessSubjectFactory());
        dwsm.setSessionManager(defaultSessionManager());
        // 关闭session存储
        ((DefaultSessionStorageEvaluator) ((DefaultSubjectDAO)dwsm.getSubjectDAO()).getSessionStorageEvaluator()).setSessionStorageEnabled(false);

//      <!-- 用户授权/认证信息Cache, 采用EhCache 缓存 -->
        dwsm.setCacheManager(shiroCacheManager);

        SecurityUtils.setSecurityManager(dwsm);
        return dwsm;
	}
 

private CacheManager decision(org.springframework.cache.CacheManager springCacheManager) {
	if (springCacheManager instanceof EhCacheCacheManager) {
		EhCacheManager ehCacheManager = new EhCacheManager();
		ehCacheManager.setCacheManager(((EhCacheCacheManager) springCacheManager).getCacheManager());
		return ehCacheManager;
	}
	
	if (springCacheManager instanceof org.springframework.data.redis.cache.RedisCacheManager) {
		GenericJackson2JsonRedisSerializer jsonSerializer = new GenericJackson2JsonRedisSerializer();
		RedisTemplate rt = new RedisTemplate<Object, Object>();
		rt.setConnectionFactory(SpringContextUtils.getBean(RedisConnectionFactory.class));
		rt.setKeySerializer(jsonSerializer);
		rt.setHashKeySerializer(jsonSerializer);
		rt.setBeanClassLoader(this.getClass().getClassLoader());
		rt.afterPropertiesSet();
		RedisCacheManager redisCacheManager = new RedisCacheManager();
		redisCacheManager.setRedisTemplate(rt);
		return redisCacheManager;
	}
	return new SpringCacheManager(springCacheManager);
}
 

/**
 * (基于内存的)用户授权信息Cache
 */
@Bean(name = "cacheManager")
@ConditionalOnMissingBean(name = "cacheManager")
@ConditionalOnMissingClass(value = {"org.apache.shiro.cache.ehcache.EhCacheManager"})
public CacheManager cacheManager() {
    return new MemoryConstrainedCacheManager();
}
 

public CacheManager build() {
	CacheManager cacheManager = null;
	org.springframework.cache.CacheManager springCacheManager = springCachePvd.getIfAvailable();
	if(Objects.isNull(springCacheManager)) {
		cacheManager = new MapCacheManager();
	}else {
		cacheManager = this.decision(springCacheManager);
	}
	return cacheManager;
}
 

@Bean(name = "cacheManager")
@ConditionalOnClass(name = {"org.apache.shiro.cache.ehcache.EhCacheManager"})
@ConditionalOnMissingBean(name = "cacheManager")
public CacheManager ehcacheManager() {
    EhCacheManager ehCacheManager = new EhCacheManager();

    ShiroProperties.Ehcache ehcache = shiroProperties.getEhcache();
    if (ehcache.getConfigFile() != null) {
        ehCacheManager.setCacheManagerConfigFile(ehcache.getConfigFile());
    }

    return ehCacheManager;
}
 

@Override
protected void configureShiro() {
   bindSessionDAO(bind(SessionDAO.class));
   bindCacheManager(bind(CacheManager.class));
   bindAuthenticationDAO(bind(AuthenticationDAO.class));
   bindAuthorizationDAO(bind(AuthorizationDAO.class));
   bindPrincipalResolver(bind(PrincipalResolver.class));
   bindCredentialsHashingStrategy(bind(CredentialsHashingStrategy.class));
   expose(CredentialsHashingStrategy.class);
   bindRealm().to(GuicedIrisRealm.class);
}
 

@Bean
@ConditionalOnMissingBean
public SessionDAO sessionDAO(CacheManager cacheManager) {
    EnterpriseCacheSessionDAO dao = new EnterpriseCacheSessionDAO();
    dao.setActiveSessionsCacheName(shiroSessionProperties.getActiveSessionsCacheName());
    Class<? extends SessionIdGenerator> idGenerator = shiroSessionProperties.getIdGenerator();
    if (idGenerator != null) {
        SessionIdGenerator sessionIdGenerator = BeanUtils.instantiate(idGenerator);
        dao.setSessionIdGenerator(sessionIdGenerator);
    }
    dao.setCacheManager(cacheManager);

    return dao;
}
 

/**
 * 缓存管理器 使用Ehcache实现
 */
@Bean
public CacheManager getCacheShiroManager(EhCacheManagerFactoryBean ehcache) {
    EhCacheManager ehCacheManager = new EhCacheManager();
    ehCacheManager.setCacheManager(ehcache.getObject());
    return ehCacheManager;
}
 

@Override
public void setCacheManager(CacheManager authzInfoCacheManager)
{
	if (created && getCacheManager() != null)
	{
		return;
	}
	super.setCacheManager(authzInfoCacheManager);
}
 

public SimpleAuthorizingRealm(CacheManager cacheManager, CredentialsMatcher matcher) {
	super(cacheManager, matcher);
	HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
	hashedCredentialsMatcher.setHashAlgorithmName("SHA-256");
	hashedCredentialsMatcher.setHashIterations(1024);
	// 这一行决定hex还是base64
	hashedCredentialsMatcher.setStoredCredentialsHexEncoded(false);
	// 设置token类型是关键!!!
	setCredentialsMatcher(hashedCredentialsMatcher);
	setAuthenticationTokenClass(UsernamePasswordToken.class);
}
 

public void configure(Binder binder) {
    // Subject
    SecurityConfig.SubjectConfig subjectConfig = securityConfig.subject();
    Optional.ofNullable(subjectConfig.getContext()).ifPresent(c -> binder.bind(SubjectContext.class).to(c));
    Optional.ofNullable(subjectConfig.getFactory()).ifPresent(f -> binder.bind(SubjectFactory.class).to(f));
    Class<? extends SubjectDAO> subjectDao = subjectConfig.getDao();
    binder.bind(SubjectDAO.class).to(subjectDao != null ? subjectDao : DefaultSubjectDAO.class);

    // Authentication
    SecurityConfig.AuthenticationConfig authenticationConfig = securityConfig.authentication();
    binder.bind(Authenticator.class).to(authenticationConfig.getAuthenticator());
    binder.bind(AuthenticationStrategy.class).to(authenticationConfig.getStrategy());
    binder.bind(CredentialsMatcher.class).to(authenticationConfig.getCredentialsMatcher());

    // Cache configuration
    SecurityConfig.CacheConfig cacheConfig = securityConfig.cache();
    binder.bind(CacheManager.class).to(cacheConfig.getManager());

    // Sessions
    SecurityConfig.SessionConfig sessionConfig = securityConfig.sessions();
    binder.bind(SessionStorageEvaluator.class).to(sessionConfig.getStorageEvaluator());
    Optional.ofNullable(sessionConfig.getValidationScheduler())
            .ifPresent(s -> binder.bind(SessionValidationScheduler.class).to(s));
    binder.bindConstant()
            .annotatedWith(Names.named("shiro.sessionValidationInterval"))
            .to(sessionConfig.getValidationInterval() * 1000);
    binder.bindConstant()
            .annotatedWith(Names.named("shiro.globalSessionTimeout"))
            .to(sessionConfig.getTimeout() * 1000);
}
 

/**
 * 缓存管理器
 * @return
 */
@Bean
public CacheManager shiroRedisCacheManager(){
    ShiroRedisCacheManager redisCacheManager=new ShiroRedisCacheManager(cacheLive*1000,cacheKeyPrefix+"-shiro-cache-",redisTemplate);
    return redisCacheManager;

}
 

private org.ehcache.CacheManager ensureCacheManager() throws MalformedURLException {
  if (manager == null) {
    manager = CacheManagerBuilder.newCacheManager(getConfiguration());
    manager.init();

    cacheManagerImplicitlyCreated = true;
  }

  return manager;
}
 

/**
 * Sets the wrapped {@link org.ehcache.CacheManager} instance
 *
 * @param cacheManager the {@link org.ehcache.CacheManager} to be used
 */
public void setCacheManager(org.ehcache.CacheManager cacheManager) {
  try {
    destroy();
  } catch (Exception e) {
    log.warn("The Shiro managed CacheManager threw an Exception while closing", e);
  }
  manager = cacheManager;
  cacheManagerImplicitlyCreated = false;
}
 

public Realm( CacheManager cacheManager ) {
    super( cacheManager );
    setCredentialsMatcher( new AllowAllCredentialsMatcher() );
    setPermissionResolver(new CustomPermissionResolver());
    setCachingEnabled(true);
    setAuthenticationCachingEnabled(true);
}
 

public GenericOAuth2ApiBinding(C config, RestTemplate restTemplate, CacheManager cacheManager) {
	notNull(config, "'config' is null, please check the configure");
	notNull(restTemplate, "'restTemplate' is null, please check the configure");
	notNull(cacheManager, "'cacheManager' is null, please check the configure");
	this.config = config;
	this.restTemplate = restTemplate;
	Object cacheObject = cacheManager.getCache(DEFAULT_CACHE_NAME);
	notNull(cacheObject, "'cacheObject' is null, please check the configure");
	isInstanceOf(IamCache.class, cacheObject);
	this.cache = (IamCache) cacheObject;
}
 

@Bean(name = "cacheManager")
@ConditionalOnClass(name = {"org.apache.shiro.cache.ehcache.EhCacheManager"})
@ConditionalOnMissingBean(name = "cacheManager")
public CacheManager ehcacheManager() {
    EhCacheManager ehCacheManager = new EhCacheManager();
    ShiroProperties.Ehcache ehcache = properties.getEhcache();
    if (ehcache.getCacheManagerConfigFile() != null) {
        ehCacheManager.setCacheManagerConfigFile(ehcache.getCacheManagerConfigFile());
    }
    return ehCacheManager;
}
 

@Bean(name = "securityManager")
@DependsOn(value = {"cacheManager", "rememberMeManager", "mainRealm"})
public DefaultSecurityManager securityManager(Realm realm, RememberMeManager rememberMeManager,
                                              CacheManager cacheManager, SessionManager sessionManager) {
    DefaultSecurityManager sm = new DefaultWebSecurityManager();
    sm.setRealm(realm);
    sm.setCacheManager(cacheManager);
    sm.setSessionManager(sessionManager);
    sm.setRememberMeManager(rememberMeManager);
    return sm;
}
 

@Bean(name = "securityManager")
    public DefaultWebSecurityManager getDefaultWebSecurityManager(
            SystemAuthorizingRealm myShiroRealm,
            DefaultWebSessionManager sessionManager,
            CacheManager shiroCacheManager) {
        DefaultWebSecurityManager dwsm = new DefaultWebSecurityManager();
        dwsm.setRealm(myShiroRealm);
        dwsm.setSessionManager(sessionManager);
//      <!-- 用户授权/认证信息Cache, 采用redis 缓存 -->
        dwsm.setCacheManager(shiroCacheManager);
        return dwsm;
    }
 

public CacheManager getCacheManager() {
	return cacheManager;
}
 

public void setCacheManager(CacheManager cacheManager) {
    this.cache = cacheManager.getCache("shiro-kickout-session");
}
 

public Realm( CacheManager cacheManager, CredentialsMatcher matcher ) {
    super(cacheManager, new AllowAllCredentialsMatcher());
    setPermissionResolver( new CustomPermissionResolver() );
    setCachingEnabled(true);
    setAuthenticationCachingEnabled(true);
}
 

public SpringCacheManager(org.springframework.cache.CacheManager cacheManager){
	this.delegator = cacheManager;
}
 

public RetryLimitHashedCredentialsMatcher(CacheManager cacheManager) {
	passwordRetryCache = cacheManager.getCache("passwordRetryCache");
}
 

public CacheManager getCacheManager() {
	return this.cacheManager;
}
 

public CacheManagerBuilder(ObjectProvider<org.springframework.cache.CacheManager> springCachePvd) {
	this.springCachePvd = springCachePvd;
}