shiro基础配置操作 shiro整合SpringBoot登录 放行 加密密码

Shiro基础笔记

一、Shiro简介

shiro是一个专门用来进行权限管理的框架。 权限管理包括用户身份认证鉴权（授权）两部分，简称认证授权

• 认证：进行登录功能，我们只需要写一个登录的sql语句即可

• 鉴权：判断某个用户登录后有哪些权限

1、shiro认证相当的术语

• Subject :主体

  主体就是当前要登录的人（对象），认证后获得的那个对象就是主体

• Principal :身份信息

  主体（subject）进行身份认证的标识，标识必须具有唯一性，如用户名、手机号、邮箱地址等，一个主体可以有多个身份，但是必须有一个主身份（Primary Principal）。

• credential :凭证信息

  是只有主体自己知道的安全信息，如密码、证书等。

2、shiro鉴权

​ 认证成功后才调用鉴权。

• 权限模型

  - 主体（账号、密码）
  - 资源（资源名称、访问地址） 
  - 权限（权限名称、资源id）
  - 角色（角色名称）  
  - 角色和权限关系（角色id、权限id）
  - 主体和角色关系（主体id、角色id）
  ​
  通常数据库和权限相当的表有三张:
     用户表
     角色表
     资源权限表

3、权限相关表设计

a、方式一

​ 用户表->角色->资源权限

b 、方式二

​ 用户->资源权限

 

4、权限控制

a、权限控制有两种方式

• 通过角色授权

  登录后获得用户所有的角色，当访问controller资源时判断用户是否拥有某个指定的角色。

• 通过资源授权

  RBAC基于资源的访问控制（Resource-Based Access Control）是以资源为中心进行访问控制

  登录后获得用户所有的资源，当访问controller资源时判断访问的controller方法的url是否在资源中存在

b、粗颗粒度和细颗粒度控制

• 粗颗粒度控制

  对资源类型的管理称为粗颗粒度权限管理，即只控制到菜单、按钮、方法，控制的是Controller层

• 细颗粒度控制

  细颗粒度控制的是业务逻辑，控制的是service层

二、shiro入门案例

1、什么是shiro

Shiro是apache旗下一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架

2、shiro架构

• Subject 主体

• SecurityManager 安全管理器

  SecurityManager即安全管理器，对全部的subject进行安全管理，它是shiro的核心，负责对所有的subject进行安全管理。通过SecurityManager可以完成subject的认证、授权等，实质上SecurityManager是通过Authenticator进行认证，通过Authorizer进行授权，通过SessionManager进行会话管理等。

• Authenticator 认证器

  Authenticator即认证器，对用户身份进行认证，Authenticator是一个接口，shiro提供ModularRealmAuthenticator实现类，通过ModularRealmAuthenticator基本上可以满足大多数需求，也可以自定义认证器。

• Authorizer 授权器

  Authorizer即授权器，用户通过认证器认证通过，在访问功能时需要通过授权器判断用户是否有此功能的操作权限

• realm

  相当于datasource数据源，realm是调用dao持久化层获得用户认证和授权所需的数据

• Cryptography

  Cryptography即密码管理，shiro提供了一套加密/解密的组件，方便开发。比如提供常用的散列、加/解密等功能。

3、shiro认证

• 坐标配置

  
  <dependencies>
          <!--shiro坐标-->
          <dependency>
              <groupId>org.apache.shiro</groupId>
              <artifactId>shiro-all</artifactId>
              <version>1.8.0</version>
          </dependency>
  ​
          <!--单元测试-->
          <dependency>
              <groupId>junit</groupId>
              <artifactId>junit</artifactId>
              <version>4.12</version>
          </dependency>
  ​
          <!--log4j日志-->
          <dependency>
              <groupId>commons-logging</groupId>
              <artifactId>commons-logging</artifactId>
              <version>1.2</version>
          </dependency>
      </dependencies>

• 创建shiro配置文件

  创建安全管理器所需的数据源

  在resource中创建shiro.ini文件,内容配置如下：

  
  [users]   //表示下面的数据是用户数据
  tom=123   //等号左边的是帐号    等号右边的是密码
  jack=123

• 编写认证代码

  
  /**
   * shiro测试类
   */
  public class MyShiroTest {
  ​
      /**
       * 测试shiro认证
       */
      @Test
      public void shiroTest(){
          //创建安全管理器对象
          DefaultSecurityManager securityManager=new DefaultSecurityManager();
          //读取shiro配置
          IniRealm realm=new IniRealm("classpath:shiro.ini");
          //将realm添加到securityManager中
          securityManager.setRealm(realm);
  ​
          //将安全管理器添加到Suject上下文对象中
          SecurityUtils.setSecurityManager(securityManager);
          //获得Subject主体对象
          Subject subject=SecurityUtils.getSubject();
  ​
          /**
           * 创建认证令牌对象
           *    参数一：用户输入的帐号
           *    参数二：用户输入的密码
           */
          UsernamePasswordToken token=new UsernamePasswordToken("tom2","123");
          try {
              //执行登录认证
              subject.login(token);
          }catch (Exception e){
              e.printStackTrace();
          }
  ​
          //获得认证的状态
          //获得用户状态
          boolean isAuthenticated=subject.isAuthenticated();
          System.out.println("用户认证状态："+isAuthenticated);
  ​
          //注销
          subject.logout();
      }
  }

• shiro常见异常

  
  org.apache.shiro.authc.UnknownAccountException   //帐号不存在
  org.apache.shiro.authc.IncorrectCredentialsException  //密码错误

 

4、使用自定义Realm 获得据库中的用户信息

• 创建一个自定义Realm类，该类要继承一个授权的父类AuthorizingRealm

  
  /**
   * 自定义Realm，用来获得数据查出来的用户数据
   */
  public class MyRealm extends AuthorizingRealm {
  ​
      /**
       * 授权，认证成功后，会自动执行该方法
       * @param principalCollection
       * @return
       */
      @Override
      protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
  ​
          return null;
      }
  ​
      /**
       * 认证
       * @param authenticationToken
       * @return
       * @throws AuthenticationException
       */
      @Override
      protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken)
              throws AuthenticationException {
          //获得用户令牌
          UsernamePasswordToken token= (UsernamePasswordToken) authenticationToken;
         //从token取出用户的帐号和密码
          //这个帐号是用户输入的
          String account=token.getUsername();//获得令牌中的用户名
  ​
          //获得从数据根据用户名查出来的密码
            //调用UserDao中的根据帐号查询方法即可
          String password=getPwd(account);
          if(password==null){
              //帐号不存在
              return null;
          }
  ​
          //帐号是对的，判断输入的密码和查出来的密码是不是相同,这个工作是由shiro的认证信息对象完成的
          /**
           * 参数一：用户输入的帐号
           * 参数二：是从数据库查出来的密码
           * 参数三：是当前自定认Realm的名称
           */
          SimpleAuthenticationInfo authenticationInfo=
                  new SimpleAuthenticationInfo(account,password,this.getName());
          return authenticationInfo;
      }
  ​
      /**
       * 模拟从数据库中获得的密码
       * @param account
       * @return
       */
      public String getPwd(String account){
          if("tom".equals(account)){
              return "123";
          }
          if("jack".equals(account)){
              return "456";
          }
          return null;
      }
  }

• 在shiro的配置类中编写认证代码

  
   /**
       * 测试shiro认证
       */
      @Test
      public void shiroTest(){
          //创建安全管理器对象
          DefaultSecurityManager securityManager=new DefaultSecurityManager();
          //将realm添加到securityManager中
          securityManager.setRealm(realm);
          //将realm添加到securityManager中
          securityManager.setRealm(realm);
  ​
          //将安全管理器添加到Suject上下文对象中
          SecurityUtils.setSecurityManager(securityManager);
          //获得Subject主体对象
          Subject subject=SecurityUtils.getSubject();
  ​
          //判断用户是否登录过
          if(!subject.isAuthenticated()){
              //没有登录过，创建用户令牌
              /**
               * 创建认证令牌对象
               *    参数一：用户输入的帐号
               *    参数二：用户输入的密码
               */
              UsernamePasswordToken token=new UsernamePasswordToken("tom","1243");
              try {
                  //执行登录认证
                  subject.login(token);  ////调用自定义Realm的认证方法
              }catch (UnknownAccountException e){
                  System.out.println("帐号不存在");
              }catch (IncorrectCredentialsException e){
                  System.out.println("密码错误");
              }
          }
      }

5、shiro密码加密

shiro 中提供两种加密方式:MD5和SHA

• 单独对密码加密

  
        String pwd="456";
          //sha
          /**
           * 参数一：加密方式  SHA  MD5
           * 参数二：要加密的密码
           * 参数三：盐值  (在做用户添加的时候一般会为每个用户产生一个随机的盐值，将这个盐值一起保存到数据库)
           * 参数四：加密次数
           */
          SimpleHash sh=new SimpleHash("SHA",pwd,"woniu",100);
          System.out.println(sh);
  ​
          //md5
          SimpleHash sh3=new  SimpleHash("MD5",pwd,"woniu",100);
          System.out.println(sh3);

• 在shiro中认证时对输入的密码加密

  在自定realm的认证方法中添加盐

  
  /**
       * 认证
       * @param authenticationToken
       * @return
       * @throws AuthenticationException
       */
      @Override
      protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken)
              throws AuthenticationException {
          //获得用户令牌
          UsernamePasswordToken token= (UsernamePasswordToken) authenticationToken;
         //从token取出用户的帐号和密码
          //这个帐号是用户输入的
          String account=token.getUsername();//获得令牌中的用户名
  ​
          //获得从数据根据用户名查出来的密码
            //调用UserDao中的根据帐号查询方法即可
          String password=getPwd(account);
          if(password==null){
              //帐号不存在
              return null;
          }
  ​
          //帐号是对的，判断输入的密码和查出来的密码是不是相同,这个工作是由shiro的认证信息对象完成的
          //获得加密盐对象
          ByteSource salt=ByteSource.Util.bytes("woniu");   //看我啊  看我啊  看我啊
          /**
           * 参数一：用户输入的帐号
           * 参数二：是从数据库查出来的密码
           * 参数三：密码的盐值
           * 参数四：是当前自定认Realm的名称
           */
          SimpleAuthenticationInfo authenticationInfo=
                  new SimpleAuthenticationInfo(account,password,salt,this.getName());
          return authenticationInfo;
      }

  在shrio的配置类中创建密码管理器(用来配置密码的加密信息)

  
   //设置密码匹配器
  HashedCredentialsMatcher matcher=new HashedCredentialsMatcher();
  //设置加密算法
  matcher.setHashAlgorithmName("MD5");
  //设置加密次数
  matcher.setHashIterations(10);
  //将密码匹配器加入到自定义Realm中
  loginRealm.setCredentialsMatcher(matcher);

三、shiro授权

验证是否有权限访问controller中的方法

1、在shiro.ini中为用户配置权限

角色1 用户的查询 用户的删除

角色2 订单的添加 订单的修改

角色3 用户的添加 订单的删除

[users]
tom=123,res1,res2 #配置用户拥有的角色
jack=456,res3
​
#配置的角色
[roles]
res1=user:list,user:del  #角色拥有的资源权限
res2=order:add,order:update
res3=user:add,order:del

2、shiro判断权限的API

• Subject 用于判断角色的方法

  方法	作用
  hasRole(String roleName)	判断是否有该角色访问权， 返回 boolen
  hasRoles(List<String> roleNames)	判断是否有这些这些角色访问权， 返回 boolean[]
  hasAllRoles(Collection<String> roleNames)	判断是否有这些这些角色访问权， 返回 boolean
  checkRole(String roleName)	如果判断失败抛出 AuthorizationException 异常
  checkRoles(String... roleNames)	如果判断失败抛出 AuthorizationException 异常
  checkRoles(Collection<String> roleNames)	如果判断失败抛出 AuthorizationException 异常

• Subject 用于判断权限的方法有

  方法	作用
  isPermitted(String perm)	判断是否有该权限，返回 boolen
  isPermitted(List<String> perms)	判断是否有这些这些权限，返回 boolean[]
  isPermittedAll(Collection<String> perms)	判断是否有这些这些权限，返回 boolean
  checkPermission(String perm)	如果判断失败抛出 AuthorizationException 异常
  checkPermissions(String... perms)	如果判断失败抛出 AuthorizationException 异常
  checkPermissionsAll(Collection<String> perms)	如果判断失败抛出 AuthorizationException 异常

3、判断主体是否有权限

• 基于角色

  
  System.out.println("用户是否拥有一个角色：" + subject.hasRole("role1"));
  //是否有多个角色
  System.out.println("用户是否拥有多个角色：" + subject.hasAllRoles(Arrays.asList("role1", "role2")));
  subject.checkRole("role1");
  // 授权检测，失败则抛出异常
  //subject.checkRoles(Arrays.asList("role1", "role3"));

• ​ 基于资源

  
  // 基于资源授权
  System.out.println("是否拥有某一个权限：" + subject.isPermitted("user:delete"));
  System.out.println("是否拥有多个权限：" + subject.isPermittedAll("user:create:1",  "user:delete"));
  ​
  //对应的check方法：
  subject.checkPermission("sys:user:delete");
  subject.checkPermissions("user:create:1","user:delete");

  <font color=red>提示：在web项目中，一般不会进行手动编码授权，而是在controller的方法上添加shiro授权注解</font>

4、自定义realm授权

修改自定义Realm中的授权方法

 /**
     * 模拟根据当前登录人的帐号获得该用户所有的资源权限
     * @param account
     * @return
     */
    public Set<String> getParem(String account){
        Set<String> list=new HashSet<>();
        if(account.equals("tom")){
            list.add("user:list");
            list.add("user:update");
​
        }
        if(account.equals("jack")){
            list.add("order:list");
            list.add("order:add");
        }
        return list;
    }
    
 /**
     * 授权，认证成功后，会自动执行该方法
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        //获得保存在认证消息对象中的第一个参数
        String account= (String) principalCollection.getPrimaryPrincipal();
        //System.out.println("当前登录人的帐号是："+account);
        //读取当前登录用户所有的资源权限
        Set<String> parems=getParem(account);
​
        //创建授权信息对象
        SimpleAuthorizationInfo authorizationInfo=new SimpleAuthorizationInfo();
        //将查询到的资源权限添加到授权对象
        authorizationInfo.setStringPermissions(parems);
        return authorizationInfo;
    }

 

四、SpringBoot整合Shiro

1、配坐标

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
​
    <groupId>cn.woniu</groupId>
    <artifactId>springboot-shiro</artifactId>
    <version>1.0-SNAPSHOT</version>
​
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
​
    <parent>
        <artifactId>spring-boot-starter-parent</artifactId>
        <groupId>org.springframework.boot</groupId>
        <version>2.3.7.RELEASE</version>
    </parent>
​
    <dependencies>
        <!--mvc-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
​
        <!--数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.22</version>
            <scope>runtime</scope>
        </dependency>
        <!--数据源-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!--springboot的mybaits启动器-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.0</version>
        </dependency>
​
        <!--实体类工具-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
​
        <!--devtool热部署-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
​
        <!--测试启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
​
        <!--springboot整合shiro启动器-->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring-boot-web-starter</artifactId>
            <version>1.7.1</version>
        </dependency>
    </dependencies>
​
    <build>
        <plugins>
            <!--springboot编译插件-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.7.RELEASE</version>
                <configuration>
                    <mainClass>cn.woniu.ApplicationApp</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
​
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.7</version> <!-- 不要低于 1.3.7 版本 -->
                <dependencies>
                    <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>8.0.22</version>
                    </dependency>
                    <dependency>
                        <groupId>org.mybatis.generator</groupId>
                        <artifactId>mybatis-generator-core</artifactId>
                        <version>1.3.7</version> <!-- 不要低于 1.3.7 版本 -->
                    </dependency>
                </dependencies>
                <configuration>
                    <verbose>true</verbose> <!-- 允许移动生成的文件 -->
                    <overwrite>true</overwrite> <!-- 是否覆盖 -->
                    <!--配置文件的路径 -->
                    <configurationFile>src/main/resources/generatorConfig.xml</configurationFile>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

2、创建自定义Realm类

/**
 * shiro自定义realm类
 */
public class CustomRelm extends AuthorizingRealm {
​
    /**
     * 授权方法
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }
​
    /**
     * 认证方法
     * @param authenticationToken
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        return null;
    }
}

3、shiro认证授权过滤器

• anon：匿名过滤器，该过滤器表示某个请求不被拦截

• authc：认证过滤器，表示某个请求必须登录后才能访问

• perms：授权过滤器，认证成功后，访问controller时，会判断该用户是否有访问权限，没有则抛异常

4、在shiro配置类中，配置认证授权过滤器

/**
     * shiro的过滤器，不管是认证还是授权都要被这个过滤器将url先拦截过来
     */
    @Bean(name="shiroFilterFactoryBean")
    public ShiroFilterFactoryBean getFilterFactoryBean(DefaultWebSecurityManager securityManager){
        //实例化shiro的过滤器工厂
        ShiroFilterFactoryBean factoryBean=new ShiroFilterFactoryBean();
        //将安全管理器交给shiro过滤器工厂
        factoryBean.setSecurityManager(securityManager);
​
        //配置controller中url的拦截过滤器链
        Map<String, String> maps = factoryBean.getFilterChainDefinitionMap();
​
        //进入登录页面的请求使用匿名过滤器，不被拦截
        maps.put("/login","anon");
        maps.put("/dologin","anon");
​
        /**
         *  配置拦截哪些url   /**  默认拦截所有请求
         *  第一个参数为要拦截的请求地址
         *  第二个参数为要使用哪种过滤器来操作该地址
         */
        maps.put("/**","authc");//使用认证过滤器，拦截所有请求
​
        //没有登录过，默认跳到controller中的login请求
        //配置了默认跳转请求的url，会自动放行
        factoryBean.setLoginUrl("/login");
        return factoryBean;
    }

 

五、springboot整合shiro实现认证

1、编写controller

 /**
     * 默认进入登录页面
     * @return
     */
    @RequestMapping("dologin")
    public ResponseResult<Void> dologin(String account,String password){
        //获得主体对象
        Subject subject= SecurityUtils.getSubject();
        //创建用户令牌对象，将用户输入的帐号密码保存到令牌对象中
        UsernamePasswordToken token=new UsernamePasswordToken(account,password);
        //主体发送登录请求
        subject.login(token);
        return new ResponseResult<Void>(200,"登录成功");
    }

2、修改自定义realm的认证方法

/**
 * shiro自定义realm类
 */
public class CustomRelm extends AuthorizingRealm {
    @Autowired
    private IUsersService usersService;
​
    /**
     * 授权方法
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
​
        return null;
    }
​
    /**
     * 认证方法
     * @param authenticationToken
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        UsernamePasswordToken token= (UsernamePasswordToken) authenticationToken;
        //从用户令牌中获得用户的输入的帐号
        String account=token.getUsername();
        //根据输入的帐号到数据库查询用户信息
        Users users=usersService.getUserByAccount(account);
        if(users==null){
            //帐号错误
            return null;
        }
​
        SimpleAuthenticationInfo authenticationInfo=new SimpleAuthenticationInfo(account,users.getPassword(),this.getName());
        return authenticationInfo;
    }
}

4、在全局异常处理器中添加shiro相关的异常

/**
 * 全局异常处理器
 */
@RestControllerAdvice
public class GlobalException {
    /**
     * 帐号不存在
     * @param e
     * @return
     */
    @ExceptionHandler(value = {UnknownAccountException.class})
    public ResponseResult<Void> handlerUnknownAccountException(UnknownAccountException e) {
        return new ResponseResult<>(1001,"帐号不存在");
    }
    /**
     * 密码错误
     * @param e
     * @return
     */
    @ExceptionHandler(value = {IncorrectCredentialsException.class})
    public ResponseResult<Void> handlerIncorrectCredentialsException(IncorrectCredentialsException e) {
        return new ResponseResult<>(1002,"密码错误");
    }
}

 

六、SpringBoot整合shiro实现授权

1、在自定realm的授权方法中获得用户所有的资源权限

/**
     * 授权方法
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        //获得主体的帐号
        String account= (String) principalCollection.getPrimaryPrincipal();
        //根据帐号获得所有的资源权限
        List<String> parems= paremsService.findParemsByAccount(account);
​
        SimpleAuthorizationInfo authorizationInfo=new SimpleAuthorizationInfo();
        //将查询出的资源权限保存到授权消息对象中
        authorizationInfo.addStringPermissions(parems);
        return authorizationInfo;
    }

2、在shiro的配置类中添加授权过滤器【了解】

 /**
     * shiro的过滤器，不管是认证还是授权都要被这个过滤器将url先拦截过来
     */
    @Bean(name="shiroFilterFactoryBean")
    public ShiroFilterFactoryBean getFilterFactoryBean(DefaultWebSecurityManager securityManager){
        //实例化shiro的过滤器工厂
        ShiroFilterFactoryBean factoryBean=new ShiroFilterFactoryBean();
        //将安全管理器交给shiro过滤器工厂
        factoryBean.setSecurityManager(securityManager);
        //配置controller中url的拦截过滤器链
        Map<String, String> maps = factoryBean.getFilterChainDefinitionMap();
        //进入登录页面的请求使用匿名过滤器，不被拦截
        maps.put("/dologin","anon");
​
        /*配置授权过滤器*/
        maps.put("/user/list","perms[user:list]");
        maps.put("/user/save","perms[user:save]");
        maps.put("/user/update","perms[user:update]");
        maps.put("/user/del","perms[user:del]");
​
        //配置拦截哪些url   /**  默认拦截所有请求
        maps.put("/**","authc");//使用认证过滤器，拦截所有请求
​
        //没有登录过，默认跳到controller中的login请求
        //配置了默认跳转请求的url，会自动放行
        factoryBean.setLoginUrl("/login");
        return factoryBean;
    }

3、使用注解授权

在实际的开发中，一般都是使用注解进行授权@RequiresPermissions("权限")，而不使用配置方式

/**
     * 用户列表
     * @return
     */
    @RequestMapping("list")
    @RequiresPermissions("user:list")  //配置访问该方法所需的权限
    public ResponseResult<Void> list(){
        return new ResponseResult<Void>(200,"我是controller中的user/list请求");
    }