SpringBoot整合Shiro 安全框架

最新推荐文章于 2022-01-04 15:38:14 发布
最新推荐文章于 2022-01-04 15:38:14 发布
阅读量169 收藏 1
点赞数 1
分类专栏： SpringBoot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16183731/article/details/86533292
版权

Apache Shiro

Apache Shiro是一个功能强大且易于使用的Java安全框架，提供了认证，授权，加密，和会话管理.

简介： 在这里插入图片描述

  • Authentication:身份认证/登录，验证用户是不是拥有相应的身份
  • Authorization：授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情，常见的如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限。
  • Session Manager：会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有信息都在会话中；会话可以是普通 JavaSE 环境的，也可以是如 Web 环境的。
  • Cryptography：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储。
  • Caching：缓存，比如用户登录后，其用户信息、拥有的角色/权限不必每次去查。
  • Concurrency：shiro 支持多线程应用的并发验证，即如在一个线程中开启另一个线程，能把权限自动传播过去。
  • Remember Me：记住我，这个是非常常见的功能，即一次登录后，下次再来的话不用登录了。
  • Run As：允许一个用户假装为另一个用户（如果他们允许）的身份进行访问。
  • Testing：提供测试支持。
  • Web Support：Web支持，可以非常容易的集成到 web 环境。

在这里插入图片描述

  • Subject：主体，可以看到主体可以是任何与应用交互的“用户”。
  • SecurityManager：相当于 SpringMVC 中的 DispatcherServlet 或者 Struts2 中的 FilterDispatcher。它是 Shiro 的核心，所有具体的交互都通过 SecurityManager 进行控制。它管理着所有 Subject、且负责进行认证和授权、及会话、缓存的管理。
  • Authenticator：认证器，负责主体认证的，这是一个扩展点，如果用户觉得 Shiro 默认的不好，我们可以自定义实现。其需要认证策略（Authentication Strategy），即什么情况下算用户认证通过了。
  • Authrizer：授权器，或者访问控制器。它用来决定主体是否有权限进行相应的操作，即控制着用户能访问应用中的哪些功能。
  • Realm：可以有1个或多个 Realm，可以认为是安全实体数据源，即用于获取安全实体的。它可以是 JDBC 实现，也可以是 LDAP 实现，或者内存实现等。
  • SessionManager：如果写过 Servlet 就应该知道 Session 的概念，Session 需要有人去管理它的生命周期，这个组件就是 SessionManager。而 Shiro 并不仅仅可以用在 Web 环境，也可以用在如普通的 JavaSE 环境。
  • SessionDAO：DAO 大家都用过，数据访问对象，用于会话的 CRUD。我们可以自定义 SessionDAO 的实现，控制 session 存储的位置。如通过 JDBC 写到数据库或通过 jedis 写入 redis 中。另外 SessionDAO 中可以使用 Cache 进行缓存，以提高性能。
  • CacheManager：缓存管理器。它来管理如用户、角色、权限等的缓存的。因为这些数据基本上很少去改变，放到缓存中后可以提高访问的性能。
  • Cryptography：密码模块，Shiro 提高了一些常见的加密组件用于如密码加密/解密的。

运行流程：

在这里插入图片描述

  • Subject：主体，代表了当前“用户”。这个用户不一定是一个具体的人，与当前应用交互的任何东西都是 Subject，如网络爬虫，机器人等。所有 Subject 都绑定到 SecurityManager，与 Subject 的所有交互都会委托给 SecurityManager。我们可以把 Subject 认为是一个门面，SecurityManager 才是实际的执行者。
  • SecurityManager：安全管理器。即所有与安全有关的操作都会与 SecurityManager 交互，且它管理着所有 Subject。可以看出它是 Shiro 的核心，它负责与后边介绍的其他组件进行交互，如果学习过 SpringMVC，我们可以把它看成 DispatcherServlet 前端控制器。
  • Realm：域。Shiro 从 Realm 获取安全数据（如用户、角色、权限），就是说 SecurityManager 要验证用户身份，那么它需要从 Realm 获取相应的用户进行比较以确定用户身份是否合法，也需要从 Realm 得到用户相应的角色/权限进行验证用户是否能进行操作。我们可以把 Realm 看成 DataSource，即安全数据源。

shiro 过滤器：

anon，authcBasic，auchc，user 是认证过滤器。
perms，roles，ssl，rest，port 是授权过滤器。

anon: 表示可以匿名使用。
java类：【org.apache.shiro.web.filter.authc.AnonymousFilter】

authc:表示需要认证(登录)才能使用，没有参数
java类：【org.apache.shiro.web.filter.authc.FormAuthenticationFilter】

roles：参数可以写多个，多个时必须加上引号，并且参数之间用逗号分割，当有多个参数时，如admins/user/**=roles[“admin,guest”],每个参数通过才算通过，相当于hasAllRoles()方法。
【org.apache.shiro.web.filter.authz.RolesAuthorizationFilter】

perms：参数可以写多个，多个时必须加上引号，并且参数之间用逗号分割，例如/admins/user/**=perms[“user:add:,user:modify:”]，当有多个参数时必须每个参数都通过才通过，想当于isPermitedAll()方法。
【org.apache.shiro.web.filter.authz.PermissionsAuthorizationFilter】

rest：根据请求的方法，相当于/admins/user/**=perms[user:method] ,其中method为post，get，delete等。
【org.apache.shiro.web.filter.authz.HttpMethodPermissionFilter】

port：当请求的url的端口不是8081是跳转到schemal://serverName:8081?queryString,其中schmal是协议http或https等，serverName是你访问的host,8081是url配置里port的端口，queryString是你访问的url里的？后面的参数。
【org.apache.shiro.web.filter.authz.PortFilter】

authcBasic：没有参数表示httpBasic认证
【org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter】

ssl: 表示安全的url请求，协议为https
【org.apache.shiro.web.filter.authc.LogoutFilter】

user: 当登入操作时不做检查
【org.apache.shiro.web.filter.authc.UserFilter】

logout：【org.apache.shiro.web.filter.authc.LogoutFilter】

noSessionCreation：【org.apache.shiro.web.filter.session.NoSessionCreationFilter】
在这里插入图片描述
在这里插入图片描述

/service/ ** =anon <!-- 该uri可以匿名访问--> 
/service/ ** =auth <!-- 该uri需认证访问--> 
/service/ ** =authcBasic <!-- 该uri需要 httpBasic  认证--> 
/service/ ** =perms[user:sys:use]<!-- 该uri需要 用户拥有user:sys:use 权限才能访问--> 
/service/ ** =port[8081] <!-- 该uri需要使用8081端口--> 
/service/ ** =rest[user] <!-- /admins/ **=perms[user:method]，其中，method 表示  get、post、delete 等--> 
/service/ ** =roles[admin] <!-- uri 需要认证用户拥有 admin 角色才能访问--> 
/logout=logou # 表示注销,可以当作固定配置
/service/ **=user # 表示该 uri 需要认证或通过记住我认证才能访问

POM依赖

<!-- shiro-spring -->
		<dependency>
			<groupId>org.apache.shiro</groupId>
			<artifactId>shiro-spring</artifactId>
			<version>1.3.2</version>
		</dependency>

		<!-- shiro-ehcache -->
		<dependency>
			<groupId>org.apache.shiro</groupId>
			<artifactId>shiro-ehcache</artifactId>
			<version>1.3.2</version>
		</dependency>
  • == Relam 实现 ==
public class UserRelam extends AuthorizingRealm {

    private static final Logger Logger = LoggerFactory.getLogger(UserRelam.class);

    @Autowired
    private UserMapper userMapper;

    /*执行授权（为当前登录的Subject授予角色和权限）
     * 如果连续访问同一个URL（比如刷新），该方法不会被重复调用，Shiro有一个时间间隔（也就是cache时间，在ehcache-shiro.xml中配置  
     * 超过这个时间间隔再刷新页面，该方法会被执行  
     * 当访问到页面的时候，使用了相应的注解或者shiro标签才会执行此方法否则不会执行
     * 所以如果只是简单的身份认证没有权限的控制的话，那么这个方法可以不进行实现，直接返回null即可
     * (non-Javadoc)
     * @see org.apache.shiro.realm.AuthorizingRealm#doGetAuthorizationInfo(org.apache.shiro.subject.PrincipalCollection)
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        Logger.info("用户登陆成功开始执行授权操作");
        // 获取当前用户
        String username = (String)principals.getPrimaryPrincipal();
        // TODO 授权
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        // 获取权限
        Set<String> perms = userMapper.findPermsByUsername(username);
        // 获取角色
        Set<String> roles = userMapper.findRolesByUsername(username);
        info.setStringPermissions(perms);
        info.setRoles(roles);
        Logger.info("{} 的权限和角色是：{}{}", username, perms, roles);
        return info;
    }

    /*执行认证 查询数据库用户信息，
     * (non-Javadoc)
     * @see org.apache.shiro.realm.AuthenticatingRealm#doGetAuthenticationInfo(org.apache.shiro.authc.AuthenticationToken)
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        Logger.info("用户开始执行shiro 认证操作");
        // 获取用户的信息
        UsernamePasswordToken userToken = (UsernamePasswordToken)token;
        // 用户名
        String username = userToken.getUsername();

        // 查询数据库 返回信息
        UserTo userTo = userMapper.findUserByUsername(username);
        if (userTo == null) {
            throw new AuthenticationException("用户名信息错误");
        }
        // SimpleHash sHash = new SimpleHash("MD5", passWord, ByteSource.Util.bytes("password"), 1024); 不访问数据库自己操作

        Logger.info("usertO 基本信息是：{}", userTo);

        // 传入:用户名,加密后的密码,盐值,该realm的名字，加密算法和加密次数在已经在配置文件中指定
        SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(username, userTo.getPassword(),
            ByteSource.Util.bytes(userTo.getSalt()), getName());
        return info;
    }

    // 权限修改生效后，立即刷新清空缓存，则可以实现用户不退出生效新的权限
    // 在权限修改后调用realm中的方法，realm已经由spring管理，所以从spring中获取realm实例，调用clearCached方法
    public void clearCache() {
        PrincipalCollection principals = SecurityUtils.getSubject().getPrincipals();
        super.clearCache(principals);
    }

}
  • Shiro 核心配置类
@Configuration
public class ShiroConfig {

    private static final Logger LOGGER = LoggerFactory.getLogger(ShiroConfig.class);

    /**
     * 内置过滤器
     * 
     * @param securityManager
     * @return
     */
    @Bean
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultWebSecurityManager securityManager) {
        LOGGER.info("shiro 过滤器开始执行");
        ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();
        factoryBean.setSecurityManager(securityManager);
        // 配置shiro n内置过滤器
        Map<String, String> filterMap = new HashMap<>();
        /*
         *  anon:表示可以匿名使用。 
            authc:表示需要认证(登录)才能使用，没有参数 
            roles：参数可以写多个，多个时必须加上引号，并且参数之间用逗号分割，当有多个参数时，例如admins/user/**=roles["admin,guest"],每个参数通过才算通过，相当于hasAllRoles()方法。 
            perms：参数可以写多个，多个时必须加上引号，并且参数之间用逗号分割，例如/admins/user/**=perms["user:add:*,user:modify:*"]，当有多个参数时必须每个参数都通过才通过，想当于isPermitedAll()方法。 
            rest：根据请求的方法，相当于/admins/user/**=perms[user:method] ,其中method为post，get，delete等。 
            port：当请求的url的端口不是8081是跳转到schemal://serverName:8081?queryString,其中schmal是协议http或https等，serverName是你访问的host,8081是url配置里port的端口，queryString是你访问的url里的？后面的参数。 
            authcBasic：没有参数表示httpBasic认证 
            ssl:表示安全的url请求，协议为https 
            user:当登入操作时不做检查
         */
        // 设置login url
        factoryBean.setLoginUrl("/service/page/login");
        // 设置成功后的跳转的连接
        factoryBean.setSuccessUrl("/service/page/index");
        factoryBean.setUnauthorizedUrl("/service/error-400");
        filterMap.put("/web/**", "anon");
        // 静态资源处理
        filterMap.put("/js/**", "anon");
        filterMap.put("/css/**", "anon");
        filterMap.put("/images/**", "anon");
        filterMap.put("/font/**", "anon");
        // 当请求/shiro/logout时登
        filterMap.put("/service/logout", "logout");
        filterMap.put("/service/login", "anon");

        /*
         *  注意:这里的user是过滤器的一种,而下面roles[user]中的user是自定义的一种角色。
         *  注意:user拦截器既允许通过Subject.login()认证进入的用户访问;又允许通过rememberMe缓存进入的用户访问
         *  注意:authc拦截器既只允许通过Subject.login()认证进入的用户访问;不允许rememberMe缓存通过进入的用户访问
         */
        filterMap.put("/introduce.html", "user");
        filterMap.put("/rememberMe.html", "user");
        // 注意roles[user]这里的话,角色不要再用引号引起来了,直接写即可
        filterMap.put("/user.html", "authc,roles[user]");
        filterMap.put("/admin.html", "authc,roles[admin]");
        filterMap.put("/superadmin.html", "authc,roles[host,admin]");

        // 由于权限由上而下“就近”选择,所以一般将"/**"配置在最下面
        filterMap.put("/**", "anon");// 必须授权才能访问
        factoryBean.setFilterChainDefinitionMap(filterMap);
        LOGGER.info("shiro 过滤器结束执行");
        return factoryBean;
    }

    @Bean
    public DefaultWebSecurityManager getSecurityManager(UserRelam userRelam, SessionManager sessionManager,
        EhCacheManager cacheManager) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        // 设置Relam
        securityManager.setRealm(userRelam);
        // 自定义缓存实现，
        securityManager.setCacheManager(cacheManager);
        securityManager.setSessionManager(sessionManager);
        return securityManager;
    }

    @Bean
    public HashedCredentialsMatcher getHashedCredentialsMatcher() {
        HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
        hashedCredentialsMatcher.setHashAlgorithmName("MD5");// MD5加密
        hashedCredentialsMatcher.setHashIterations(1024);// 迭代1024次
        return hashedCredentialsMatcher;
    }

    /**
     * 配置relam 以及凭证匹配器，也可以在里面重写CredentialsMatcher 方法
     * 
     * @param hashedCredentialsMatcher
     * @return
     */
    @Bean
    public UserRelam getUserRelam(HashedCredentialsMatcher hashedCredentialsMatcher) {
        UserRelam userRelam = new UserRelam();
        userRelam.setCredentialsMatcher(hashedCredentialsMatcher);
        return userRelam;
    }

    /** 配置shiro框架组件的生命周期管理对象 */
    @Bean
    public LifecycleBeanPostProcessor getLifecycleBeanPostProcessor() {
        return new LifecycleBeanPostProcessor();
    }

    /**
     * 配置授权属性应用对象(在执行授权操作时需要用到此对象) 开启shiro aop注解支持. 使用代理方式;所以需要开启代码支持;
     * 
     * @param securityManager
     * @return
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor getAuthorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
        advisor.setSecurityManager(securityManager);
        return advisor;
    }

    /** 配置负责为Bean对象(需要授权访问的方法所在的对象) 创建代理对象的Bean组件 */
    @Bean
    public DefaultAdvisorAutoProxyCreator getDefaultAdvisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator proxyCreator = new DefaultAdvisorAutoProxyCreator();
        proxyCreator.setProxyTargetClass(true);
        return proxyCreator;
    }

    /** 使用缓存ehcachae */
    @Bean
    public EhCacheManager getEhCacheManager() {
        EhCacheManager ehCacheManager = new EhCacheManager();
        // 将ehcacheManager转换成shiro包装后的ehcacheManager对象
        // ehCacheManager.setCacheManager(cacheManager);
        // eheache 配置文件目录
        ehCacheManager.setCacheManagerConfigFile("classpath:ehcache.xml");
        return ehCacheManager;
    }

    /**
     * shiro session的管理
     * 
     * @return
     */
    @Bean
    public SessionManager sessionManager(SimpleCookie simpleCookie, SessionDAO sessionDAO) {
        DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
        sessionManager.setGlobalSessionTimeout(100000);// ms
        // 设置sessionDao对session查询，在查询在线用户service中用到了
        // sessionManager.setSessionDAO(sessionDAO);
        // 配置session 的监听
        // Collection<SessionListener> listeners = new ArrayList<SessionListener>();
        // listeners.add(new BDsess)
        sessionManager.setSessionValidationSchedulerEnabled(true);
        sessionManager.setSessionIdCookieEnabled(true);
        // 设置cookie 中sessionid 的名称
        sessionManager.setSessionIdCookie(simpleCookie);
        return sessionManager;
    }

    @Bean
    public SessionDAO getSessionDAO() {
        return new MemorySessionDAO();
    }

    @Bean
    public SimpleCookie getSimpleCookie() {
        SimpleCookie simpleCookie = new SimpleCookie();
        simpleCookie.setName("jeesite.session.id");
        return simpleCookie;
    }

}

1.LifecycleBeanPostProcessor，这是个DestructionAwareBeanPostProcessor的子类，负责org.apache.shiro.util.Initializable类型bean的生命周期的，初始化和销毁。主要是AuthorizingRealm类的子类，以及EhCacheManager类。
2.HashedCredentialsMatcher，这个类是为了对密码进行编码的，防止密码在数据库里明码保存，当然在登陆认证的生活，这个类也负责对form里输入的密码进行编码。
3.ShiroRealm，这是个自定义的认证类，继承自AuthorizingRealm，负责用户的认证和权限的处理，可以参考JdbcRealm的实现。
4.EhCacheManager，缓存管理，用户登陆成功后，把用户信息和权限信息缓存起来，然后每次用户请求时，放入用户的session中，如果不设置这个bean，每个请求都会查询一次数据库。
5.SecurityManager，权限管理，这个类组合了登陆，登出，权限，session的处理，是个比较重要的类。
6.ShiroFilterFactoryBean，是个factorybean，为了生成ShiroFilter。它主要保持了三项数据，securityManager，filters，filterChainDefinitionManager。
7.DefaultAdvisorAutoProxyCreator，Spring的一个bean，由Advisor决定对哪些类的方法进行AOP代理。
8.AuthorizationAttributeSourceAdvisor，shiro里实现的Advisor类，内部使用AopAllianceAnnotationsAuthorizingMethodInterceptor来拦截用以下注解的方法。

  • 测试类
@Controller
@RequestMapping
public class UserController {

    private static final Logger LOGGER = LoggerFactory.getLogger(GloableExecption.class);

    @Autowired
    private UserService userService;

    @Autowired
    private UserMapper userMapper;

    @RequestMapping("/login")
    public String login(UserTo userTo) {
        LOGGER.info("开始执行登陆操作 username：{}，password:{}", userTo.getUsername(), userTo.getPassword());
        Subject subject = SecurityUtils.getSubject();// 创建用户实体
        System.err.println(subject.isRemembered() + "" + subject.isAuthenticated());
        // if (!subject.isAuthenticated()) {
        UsernamePasswordToken token = new UsernamePasswordToken(userTo.getUsername(), userTo.getPassword());
        try {
            // 执行登陆验证
            subject.login(token);
            LOGGER.info("恭喜登陆成功");
        } catch (UnknownAccountException e) {
            throw new ServiceException("用户名不存在");
        } catch (IncorrectCredentialsException e) {
            throw new ServiceException("用户名或者密码错误");
        }
        // }
        return "index";
    }

    @RequestMapping("/logout")
    public String logout() {
        Subject subject = SecurityUtils.getSubject();
        subject.logout();
        LOGGER.info("用户登出成功");
        return "index";
    }

    @RequestMapping("/select")
    @ResponseBody
    @RequiresPermissions(value = {"system:user:delete"})
    public Object selectUser() {
        // userService.insertUserList(new ArrayList<>());
        return userMapper.findUserByUsername("wang3");
    }

    @RequestMapping("/insert")
    @ResponseBody
    @RequiresPermissions(value = {"system:user:insert"})
    public Object insertUser(UserTo userTo) {
        Subject subject = SecurityUtils.getSubject();
        System.err.println("进来了");
        return userMapper.findUserByUsername("wang3");
    }

    /**
     * 尝试通过异常让事务回滚
     * 
     * @return
     */
    @RequestMapping("trans")
    @ResponseBody
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class) // 开启事务,异常事务回滚
    public Object transTest() {
        UserTo user = new UserTo();
        user.setAge(18);
        user.setBrithday(new Date());
        user.setCreteTime(new Date());
        user.setModifyTime(new Date());
        user.setLastLoginTime(new Date());
        String salt = String.valueOf(System.currentTimeMillis());
        SimpleHash sHash = new SimpleHash("MD5", "password", ByteSource.Util.bytes(salt), 1024);
        user.setSalt(salt);
        user.setPassword(sHash.toString());
        user.setUsername("wang");
        user.setGender("women");
        // 获取自增的主键
        userMapper.insertUser(user);
        LOGGER.info("新增后主键是：{}", user.getId());
        // int i = 0 / 0;// 制造异常 看事务回滚
        return null;
    }

    // 配置错误界面
    @RequestMapping("error-400")
    public String toPage400() {
        return "err";
    }

    @Autowired
    private UserRelam userRelam;

    // 登陆界面
    @RequestMapping("page/login")
    public String log() {
        userRelam.clearCache();// 刷新权限不许要重新登录
        return "login";
    }

    // 主界面
    @RequestMapping("page/index")
    public String index() {
        return "index";
    }

}

缓存 文件

<ehcache>
    <!-- Sets the path to the directory where cache .data files are created.

         If the path is a Java System Property it is replaced by
         its value in the running VM.

         The following properties are translated:
         user.home - User's home directory
         user.dir - User's current working directory
         java.io.tmpdir - Default temp file path -->
    <diskStore path="java.io.tmpdir"/>
    
    <cache name="authorizationCache"
           maxEntriesLocalHeap="2000"
           eternal="false"
           timeToIdleSeconds="3600"
           timeToLiveSeconds="0"
           overflowToDisk="false"
           statistics="true">
    </cache>
    

    <cache name="authenticationCache"
           maxEntriesLocalHeap="2000"
           eternal="false"
           timeToIdleSeconds="3600"
           timeToLiveSeconds="0"
           overflowToDisk="false"
           statistics="true">
    </cache>

    <cache name="shiro-activeSessionCache"
           maxEntriesLocalHeap="2000"
           eternal="false"
           timeToIdleSeconds="3600"
           timeToLiveSeconds="0"
           overflowToDisk="false"
           statistics="true">
    </cache>

    <!--Default Cache configuration. These will applied to caches programmatically created through
        the CacheManager.

        The following attributes are required for defaultCache:

        maxInMemory       - Sets the maximum number of objects that will be created in memory
        eternal           - Sets whether elements are eternal. If eternal,  timeouts are ignored and the element
                            is never expired.
        timeToIdleSeconds - Sets the time to idle for an element before it expires. Is only used
                            if the element is not eternal. Idle time is now - last accessed time
        timeToLiveSeconds - Sets the time to live for an element before it expires. Is only used
                            if the element is not eternal. TTL is now - creation time
        overflowToDisk    - Sets whether elements can overflow to disk when the in-memory cache
                            has reached the maxInMemory limit.

        -->
    <defaultCache
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        overflowToDisk="true"/>

    <!--Predefined caches.  Add your cache configuration settings here.
        If you do not have a configuration for your cache a WARNING will be issued when the
        CacheManager starts
        The following attributes are required for defaultCache:
        name              - Sets the name of the cache. This is used to identify the cache. It must be unique.
        maxInMemory       - Sets the maximum number of objects that will be created in memory
        eternal           - Sets whether elements are eternal. If eternal,  timeouts are ignored and the element
                            is never expired.
        timeToIdleSeconds - Sets the time to idle for an element before it expires. Is only used
                            if the element is not eternal. Idle time is now - last accessed time
        timeToLiveSeconds - Sets the time to live for an element before it expires. Is only used
                            if the element is not eternal. TTL is now - creation time
        overflowToDisk    - Sets whether elements can overflow to disk when the in-memory cache
                            has reached the maxInMemory limit.-->
    <!-- Place configuration for your caches following -->

	 <cache name="sampleCache1"
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="300"
        timeToLiveSeconds="600"
        overflowToDisk="true"
        />
 
    <cache name="sampleCache2"
        maxElementsInMemory="1000"
        eternal="true"
        timeToIdleSeconds="0"
        timeToLiveSeconds="0"
        overflowToDisk="false"
        /> 
</ehcache>

参靠考项目地址：

https://github.com/DonaldAndMickey/Boke.git

灬奔跑的蜗牛灬
关注
专栏目录
spring boot整合shiro之shiro过滤器介绍
无名剑
08-07 1万+
过滤器链条配置说明 1、一个URL可以配置多个Filter，使用逗号分隔 2、当设置多个过滤器时，全部验证通过，才视为通过 3、部分过滤器可指定参数，如perms，roles Shiro内置的FilterChain anon(org.apache.shiro.web.filter.authc.AnonymousFilter):例子/admins/**=anon 没有参数，表示可以匿...
Apache Shiro内置拦截器
wunianisme的博客
07-19 712
Shiro内置了很多默认的拦截器，比如身份验证、授权等相关的。默认拦截器可以参考org.apache.shiro.web.filter.mgt.DefaultFilter中的枚举拦截器。 public enum DefaultFilter{ anno(AnonymousFilter.class), authc(FormAuthenticationFilter.class), authc...
Spring项目集成ShiroFilter简单实现权限管理
weixin_33860737的博客
02-13 281
Shiros是我们开发中常用的用来实现权限控制的一种工具包，它主要有认证、授权、加密、会话管理、与Web集成、缓存等功能。我是从事javaweb工作的，我就经常遇到需要实现权限控制的项目，之前我们都是靠查询数据获取列表拼接展示的，还有的是及时的判断权限的问题的，现在有了Shiros了，我们就可以统一的进行设置权限问题，Shrios的实现也是很简单的，下面让我们来看看具体实现步骤 ...
shiro---1
weixin_30497527的博客
12-15 101
The default Filter instances available automatically are defined by theDefaultFilter enumand the enum'snamefield is the name available for configuration. They are: Filter NameClass anon ...
shiro简单配置
热门推荐
都是浮云
04-20 13万+
注：这里只介绍spring配置模式。 因为官方例子虽然中有更加简洁的ini配置形式，但是使用ini配置无法与spring整合。而且两种配置方法一样，只是格式不一样。 涉及的jar包 Jar包名称 版本 核心包shiro-core 1.2.0 Web相关包shiro-web 1.2.0
搭建Springboot整合shiro安全框架+Redis+Swagger+Filter超详细
最新发布
07-08
在本教程中，我们将深入探讨如何利用Spring Boot整合Shiro安全框架，以实现用户认证与授权，同时结合Redis进行会话管理，以及使用Swagger为API提供文档化接口，最后通过Filter实现自定义的请求处理。以下是对这些...
SpringBoot_Shiro_JWT_Redis:SpringBoot整合Shiro、JWT和Redis实现token登录授权验证以及token刷新
05-14
SpringBoot整合Shiro、JWT和Redis实现token登录授权验证以及token刷新 前端代码为一个博客页面，使用了Semantic UI框架结合thymeleaf模板 SpringBoot结合JWT+Shiro+Redis实现token无状态登录授权 [TOC] 一、引言 ​ ...
springboot 与shiro安全框架的整合
08-05
3. **SpringBoot整合Shiro** 整合SpringBoot和Shiro主要涉及以下步骤： - 添加依赖：在SpringBoot的`pom.xml`或`build.gradle`文件中引入Shiro的依赖。 - 配置Shiro：创建一个自定义的Shiro配置类，配置Realm以...
springboot整合shiro
03-30
**SpringBoot整合Shiro**是将流行的Java Web框架Spring Boot与安全管理框架Apache Shiro结合，以构建高效、安全的Web应用程序。Spring Boot以其简洁的配置和快速的开发体验深受开发者喜爱，而Shiro则提供了全面的...
springboot整合shiro安全认证框架
weixin_46164384的博客
01-04 286
首先搭建一个简单的测试环境 搭建一个springboot 项目 引入依赖，主要是web starter shiro（安全认证） 和thymeleaf（简单的页面构建），这里不做数据层的查询，所以不引入数据库相关的。 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId&g
Shiro权限管理的过滤器解释
我的博客
01-05 168
filterCh...
我的shiro之旅: 三 浅谈shiro的filter
Dylan的博文
08-01 9723
博客已移至 http://blog.gogl.top   前段时间比较懒，项目也有些紧，没有写什么东西。现在再对Shiro做一些整理。上一篇主要介绍了一个完整而又简单的shiro集成到项目的例子，主要是spring项目。这篇文章，想谈一下关于shiro的filter，这需要读者对shiro有一定的理解，至少有用过shiro。   &lt;bean id="shiroFilter" cla...
spring boot第八次作业
a2534142998的博客
08-04 186
Shiro进行权限控制 1 . 添加依赖 org.apache.shiro shiro-spring 1.2.5 org.apache.shiro shiro-ehcache 1.2.5 2 . 编写Shiro配置类 package com.xbz.web.system.config; import at.pollux.thymeleaf.shiro.dialect.ShiroDialect; import org.apache.shiro.authc
Shiro学习笔记（2）——身份验证之Realm
君君的专栏
05-27 1万+
环境准备 什么是Realm 为什么要用Realm 自定义Realm 多个Realm 配置Authenticator和AuthenticationStrategy 自定义AuthenticationStrategy验证策略 多个Realm验证顺序环境准备 创建java工程 需要的jar包大家也可以使用maven，参考官网 什么是Realm 在我所看的学习资料中，关于Realm的定义，写了整整一长串，但
shiro实现不同身份使用不同Realm进行验证
Alan_Xiang的博客
02-01 3万+
假设现在有这样一种需求：存在两张表user和admin，分别记录普通用户和管理员的信息。并且现在要实现普通用户和管理员的分开登录，即需要两个Realm——UserRealm和AdminRealm，分别处理普通用户和管理员的验证功能。 　　但是正常情况下，当定义了两个Realm，无论是普通用户登录，还是管理员登录，都会由这两个Realm共同处理。这是因为，当配置了多个Realm时，我们通常使用的认证
死磕Spring AOP系列3：剖析Bean处理器之DefaultAdvisorAutoProxyCreator
weixin_33878457的博客
06-04 225
导航死磕Spring AOP系列1：编程式实现AOP 死磕Spring AOP系列2：剖析Bean处理器之BeanNameAutoProxyCreator这是<死磕Spring AOP系列>的第三篇。经过前面的讲解，已经掌握了以下知识点Spring AOP的底层支持，是基于ProxyFactory+ProxyConfig+Advisor生成的Spring容器的代...
第十一章 缓存机制（二） Realm 缓存
yifanSJ的博客
09-16 2314
Shiro 提供了CachingRealm，其实现了CacheManagerAware接口，提供了缓存的一些基础实现；另外AuthenticatingRealm及AuthorizingRealm分别提供了对AuthenticationInfo 和AuthorizationInfo信息的缓存。 ini配置 userRealm=com.github.zhangkaitao.shiro.ch
第六章 Realm及相关对象——《跟我学Shiro》
jinnianshilongnian的专栏
02-26 1014
  目录贴： 跟我学Shiro目录贴     6.1 Realm 【2.5 Realm】及【3.5 Authorizer】部分都已经详细介绍过Realm了，接下来再来看一下一般真实环境下的Realm如何实现。    1、定义实体及关系 即用户-角色之间是多对多关系，角色-权限之间是多对多关系；且用户和权限之间通过角色建立关系；在系统中验证时通过权限验证，角色只是权限集合，即...
SpringBoot 一些常用的配置
qq_16183731的博客
01-10 3281
设置拦截的url路径 server: context-path: /services/ SpringBoot自动配置原理:
基于Springboot和Thymeleaf整合Shiro安全框架实践
资源摘要信息:"Springboot+shiro+thymeleaf"的知识点梳理 在现代Web开发中，结合后端框架与安全框架以及模板引擎是一种常见的实践，以确保开发的便捷性和应用的安全性。Spring Boot、Shiro以及Thymeleaf的组合就是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值