shiro11:springboot整合shiro在web工程中的应用

末蓝、 2021-12-19 22:23 246阅读 0赞

# 重点：两道防线 #

第一道：在整合了shiro之后就会对我们设置的请求地址进行拦截，如果不具备相应的权限就没有办法访问相应的地址

第二道：我们都知道，在springboot中默认情况下我们的templates文件夹之可以通过程序之间的跳转来访问，而直接访问界面是没有办法访问的，我们的界面却又存放在这个文件夹里，所以这里死记一点：tempaltes的页面只能通过程序访问，或者通过配置mvc来访问，获取放开templates的访问权限，

上面两道防线，我们这样理解：首先验证shiro的拦截器，如果通过，则放行进入第二道拦截，如果有程序进行跳转，则此次访问可以成功，不然失败

下面开始整合步骤：

# 第一步:引入依赖 #

这里是shiro所使用的基本依赖

<dependency>
                <groupId>org.apache.shiro</groupId>
                <artifactId>shiro-config-core</artifactId>
                <version>1.4.0</version>
            </dependency>
            <dependency>
                <groupId>org.apache.shiro</groupId>
                <artifactId>shiro-web</artifactId>
                <version>1.4.0</version>
            </dependency>
            <dependency>
                <groupId>org.apache.shiro</groupId>
                <artifactId>shiro-ehcache</artifactId>
                <version>1.4.0</version>
            </dependency>
            <dependency>
                <groupId>org.apache.shiro</groupId>
                <artifactId>shiro-spring</artifactId>
                <version>1.4.0</version>
            </dependency>
            <dependency>
                <groupId>com.github.theborakompanioni</groupId>
                <artifactId>thymeleaf-extras-shiro</artifactId>
                <version>2.0.0</version>
            </dependency>

# 第二步：自定义realm #

当我们进行认证和授权的时候都会来到这里进行相关的操作

public class AdminRealm extends AuthorizingRealm {
    
        @Autowired
        UserService userService;
    
        /**
         * 认证
         * @param token 令牌
         * @return
         * @throws AuthenticationException
         */
        @Override
        protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
            String userName = (String)token.getPrincipal();
            User user = userService.getUserByName(userName);
            System.out.println(user);
            if (user == null){
                return null;
            }
    
            /*认证*/
            SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user.getUserName(), user.getUserPassword(), this.getName());
            return info;
        }
    
        /**
         * @param principalCollection
         * @return
         */
        @Override
        protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
            System.out.println("指定了授权");
            return null;
        }
    }

# 第三步:shiro配置类 #

在ShiroFilterFactoryBean中进行拦截器的相应设置，以控制哪些地址是可以放行的，哪些地址是必须经过认证才可以访问的，同时可以配置自定义的过滤器，另外，它必须要注入一个安全管理器

关于setLoginUrl("/login");这个设置，他的意思是，如果在没有授权的情况下，访问的地址不是这个loginUrl的值，那么就向这个地址发送一个请求，如果是这个地址的值，那么就会直接进入自定义realm中进行认证操作（这一点很重要）

在DefaultWebSecurityManager中配置安全管理器，他需要一个自定义的realm，也就是下面你创建的那个

@Configuration
    public class ShiroConfig {
    
    
        /**
         * 创建shiroFilterFactoryBean  shiro拦截器
         */
        @Bean
        public ShiroFilterFactoryBean getShiroFilterFactoryBean(@Qualifier("securityManager") DefaultWebSecurityManager securityManager) {
            //设置安全管理器
            ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
            shiroFilterFactoryBean.setSecurityManager(securityManager);
            shiroFilterFactoryBean.setLoginUrl("/login");
    
            Map<String, Filter> filters = shiroFilterFactoryBean.getFilters();
            filters.put("authc", new UserFormFilter());
    
    
            /*配置拦截器*/
            LinkedHashMap<String, String> filterMap = new LinkedHashMap<>();
            filterMap.put("/staticfiles/**", "anon");
            filterMap.put("/backstage/login", "anon");
            filterMap.put("/**", "authc");
            filterMap.put("/logout", "logout");
            //修改访问被拦截过后的跳转页面
            shiroFilterFactoryBean.setFilterChainDefinitionMap(filterMap);
            return shiroFilterFactoryBean;
        }
    
    
        /**
         * 创建defaultWebSecurityManageer(安全管理器）
         */
        @Bean(value = "securityManager")
        public DefaultWebSecurityManager getDefaultWebSecurityManager(@Qualifier("adminRealm") AdminRealm adminRealm) {
            DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
            //关联我们创建的realm
            securityManager.setRealm(adminRealm);
            return securityManager;
        }
    
    
        /**
         * 创建realm
         */
        @Bean(value = "adminRealm")
        public AdminRealm getRealm() {
            return new AdminRealm();
        }
    
    
    
        /**
         * 配置shirodialect，用于thymeleaf和shiro标签配合使用
         */
        @Bean
        public ShiroDialect getShiroDialect(){
            return new ShiroDialect();
        }
    }

# 第四步：formfilter过滤器 #

当进入到自定义realm进行认证后会来到这里，他会返回给我们认证的结果，并通过我们自己处理响应给浏览器，这个类需要配置到shiro配置类中

public class UserFormFilter extends FormAuthenticationFilter {
    
        @Override
        protected boolean onLoginSuccess(AuthenticationToken token,
                                         Subject subject,
                                         ServletRequest request,
                                         ServletResponse response) throws Exception {
            response.setCharacterEncoding("utf-8");
            response.getWriter().print("登录成功");
            return false;
        }
    
        @Override
        protected boolean onLoginFailure(AuthenticationToken token,
                                         AuthenticationException e,
                                         ServletRequest request,
                                         ServletResponse response) {
            String errorInfo = null;
            if (e!=null){
                String name = e.getClass().getName();
                if (name.equals(UnknownAccountException.class.getName())){
                    errorInfo = "用户名错误";
                }else if (name.equals(IncorrectCredentialsException.class.getName())){
                    errorInfo = "密码错误";
                }else {
                    errorInfo = "未知错误";
                }
            }
            response.setCharacterEncoding("utf-8");
            try {
                response.getWriter().print(errorInfo);
            } catch (IOException ex) {
                ex.printStackTrace();
            }
    
    
            return false;
        }
    }