Shiro权限管理框架

阅读数:0次 2021-11-22

1.权限的管理

1.1 什么是权限管理

基本上涉及用户参与的系统都需要进行权限管理，权限管理是系统安全的范畴，权限管理可以按照安全规则或者安全策略控制用户访问及其被允许的资源。

权限管理包括身份认证 和授权两部分，对用户需要访问的资源先进行身份认证，认证后确认用户是否有访问权限。

1.2 什么是身份认证

身份认证，就是判断一个用户是否为合法用户的处理过程。

1.3 什么是授权

授权，即访问控制，控制用户能访问哪些资源。

2.什么是Shiro

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

特点：

简单易用，学习成本低
提供易于理解的API

3.Shiro的核心架构

3.1 Subject(主体)

Subject即主体，外部应用与Subject交互，将当前用户作为操作主体，外部程序通过Subject进行认证授权，Subject通过SecurityManager安全管理器进行认证授权。

3.2 SecurityManager(安全管理器)

SecurityManager即安全管理器，对全部的Subject进行安全管理，是Shiro的核心。实质上SecurityManager 通过Realm 的Authenticator 进行认证，通过Authorizer 进行授权，通过SessionManager 进行会话管理 。

3.3 Authenticator(认证器)

Authenticator即认证器，对用户身份进行认证，Authenticator是一个接口，Shiro提供ModularRealmAuthenticator实现类，或者自定义认证器。

3.4 Authorizer(授权器)

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

3.5 Realm(领域)

Realm即领域，相当于DataSource数据源，SecurityManager进行安全认证需要通过Realm获取用户权限数据。

注意: 不要把Realm理解成从数据源取数据，在Realm中还有认证授权校验的相关的代码。

3.6 SessionManager(会话管理)

SessionManager即会话管理，不依赖于Web Session，可以使它实现单点登录。

3.7 SessionDAO(会话DAO)

SessionDAO即会话DAO，Session会话操作的一套接口，比如将Session存储到数据库。

3.8 CacheManager(缓存管理)

CacheManager即缓存管理，将用户权限数据存在缓存，可以提高性能。

3.9 Cryptogrphy(密码管理)

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

4.Shiro中的认证

4.1 认证

身份认证，就是判断一个用户是否为合法用户的处理过程。最常用的简单身份认证方式是系统通过核对用户输入的用户名和口令，查看是否与系统中存储的用户名和口令一致，判断用户身份是否正确。

4.2 Shiro中认证的关键对象

Subject 主体
- 访问系统的用户，进行认证的都称为主体
Principal 身份信息
- 是主体进行身份认证的标识，标识具有唯一性，一个主体可以有多个身份，但是必须有一个主身份
Credential 凭证信息
- 只有主体知道的自己的安全信息

4.3 认证流程

4.4 认证的开发

项目源代码: https://github.com/xing-yu-chen/shiro-try

1.创建项目并引入依赖

<!--引入Shiro的相关依赖-->
<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-core</artifactId>
  <version>1.7.1</version>
</dependency>

2.引入Shiro配置文件并加入如下配置

# shiro.ini 假数据
[users]
# 身份信息=凭证信息
xiaochen=123
zhangsan=1234
lisi=12345

3.开发认证代码

public static void main(String[] args) {
        /* 1.创建安全管理器对象 */
        DefaultSecurityManager securityManager=new DefaultSecurityManager();

        /* 2.给安全管理器设置Realm,SecurityManager认证时从resources中读取ini数据配置文件 */
        securityManager.setRealm(new IniRealm("classpath:shiro.ini"));

        /* 3.SecurityUtils Shiro提供全局安全工具类 提供了认证、退出等相关方法,
        认证的时候借助安全工具类实现认证*/
        SecurityUtils.setSecurityManager(securityManager);//告诉工具类要用哪个安全管理器去进行认证

        /* 4. 当前登录的Subject主体对象 */
        Subject subject = SecurityUtils.getSubject();

        /* 5. 创建令牌:用户名-令牌，用身份信息和凭证信息数据库中比对*/
        UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken("xiaochen","123");

        /* 6. 用户认证,失败会有异常 */
        try{
	          System.out.println("认证前状态: "+subject.isAuthenticated());//认证状态: false
            subject.login(usernamePasswordToken);
            System.out.println("认证后状态: "+subject.isAuthenticated());//认证状态: true
        }catch (Exception e){
            e.printStackTrace();
        }
    }

4.自定义认证和授权的Realm

认证:

最终执行用户名比较 SimpleAccountRealm
- doGetAuthenticationInfo 在这个方法中完成用户名校验
最终密码校验是在AuthenticatingRealm 中
- assertCredentialsMatch

总结：

对象	功能	方法
AuthenticatingRealm	认证Realm	doGetAuthenticationInfo
AuthorizingRealm	授权Realm	doGetAuthorizationInfo

自定义Realm实现，将认证/授权数据的来源转为数据库

仅实现认证

/**
* 自定义Realm,数据来源于数据库
*/
public class CustomerRealm extends AuthorizingRealm {
    //授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }

    //认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //在token中获取用户名身份信息
        String principal = (String) authenticationToken.getPrincipal();
        System.out.println("获取到身份信息:"+principal);
        //根据身份信息使用JDBC或者Mybatis查询数据库
        if("xiaochen".equals(principal)){
            //如果用户名相等就返回一个SimpleAuthenticationInfo对象，不相等就报用户名错误
            SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo("xiaochen","123",this.getName());
            return simpleAuthenticationInfo;
        }
        return null;
    }
}

/**
* 测试的main函数
*/
public static void main(String[] args) {
    //创建securityManager
    DefaultSecurityManager securityManager=new DefaultSecurityManager();

    //设置自定义Realm
    securityManager.setRealm(new CustomerRealm());

    //将安全工具类设置安全管理器
    SecurityUtils.setSecurityManager(securityManager);
    
    //通过安全工具类获取Subject
    Subject subject = SecurityUtils.getSubject();
    
    //创建token
    UsernamePasswordToken token = new UsernamePasswordToken("xiaochen","123");

    try {
        //用户认证
        subject.login(token);
    } catch (AuthenticationException e) {
        e.printStackTrace();
    }
    System.out.println("认证状态:"+subject.isAuthenticated());
}
//结果
//获取到身份信息:xiaochen
//认证状态:true

MD5加密逻辑

注意: MD5不能调用setBytes() 方法去获取加密内容，必须使用构造器

// MD5
Md5Hash md5Hash = new Md5Hash("123");
System.out.println("MD5加密结果: "+md5Hash.toHex());

// MD5+Salt
Md5Hash md5Hash1 = new Md5Hash("123", "Ha*qw12");
System.out.println("MD5+Salt加密结果: "+md5Hash1.toHex());

//MD5+Salt+hash散列
//hash越大安全性越高，常用1024/2048
Md5Hash md5Hash2 = new Md5Hash("123", "Ha*qw12", 1024);
System.out.println("MD5+Salt+Hash加密结果: "+md5Hash2.toHex());

// 结果
// MD5加密结果: 202cb962ac59075b964b07152d234b70
// MD5+Salt加密结果: 53697a2e5a515f980518459bf19502d8
// MD5+Salt+Hash加密结果: b8865ac0a7ac17a09a65f861429b08e6

MD5认证流程实现

将自定义Realm中的CredentialsMatcher凭证匹配器设置Hash凭证匹配器

1	HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();

HashCredentialsMatcher凭证器支持的算法很多，写上支持的算法名字即可
1
hashedCredentialsMatcher.setHashAlgorithmName("md5");
认证时加上ByteSource.Util类的bytes()方法 ( 随机盐的使用方法 )
- 参数1:数据库用户名
- 参数2:md5密码密文
- 参数3:随机盐
- 参数4:Realm的名字
1
return new SimpleAuthenticationInfo("xiaochen","e5152ece30ac7ac598905ca5ea161acc", ByteSource.Util.bytes("sakdj*12"),this.getName());

/**
* 使用MD5Hash凭证匹配器的Shiro认证实现
*/
public static void main(String[] args) {
        //创建securityManager
        DefaultSecurityManager securityManager = new DefaultSecurityManager();

        //设置自定义Realm
        CustomerMd5Realm customerMd5Realm = new CustomerMd5Realm();
        //设置Realm的hash的凭证匹配器，修改默认的匹配器
        HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
        //hash凭证器支持的算法非常多，此处写上支持的算法名字(使用算法)
        hashedCredentialsMatcher.setHashAlgorithmName("md5");
  			//散列次数
  			hashedCredentialsMatcher.setHashIterations(1024);
        customerMd5Realm.setCredentialsMatcher(hashedCredentialsMatcher);

        securityManager.setRealm(customerMd5Realm);


        //将安全管理器注入安全工具类
        SecurityUtils.setSecurityManager(securityManager);

        //通过安全工具获取一个Subject主体
        Subject subject = SecurityUtils.getSubject();

        //认证
        UsernamePasswordToken token = new UsernamePasswordToken("xiaochen","123");

        try {
            subject.login(token);
            System.out.println("登录成功");
        } catch (UnknownAccountException e) {
            e.printStackTrace();
            System.out.println("用户名错误");
        }catch (IncorrectCredentialsException e){
            e.printStackTrace();
            System.out.println("密码错误");
        }
    }

/**
* 使用自定义Realm Md5+Salt+Hash
*/
public class CustomerMd5Realm extends AuthorizingRealm {

    // 授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }

    //认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        // 获取身份信息
        String principal = (String)authenticationToken.getPrincipal();

        //根据用户名查询数据库
        if("xiaochen".equals(principal)){
            //随机盐的使用方法
            return new SimpleAuthenticationInfo("xiaochen",
                                                "b8865ac0a7ac17a09a65f861429b08e6", 				
                                                ByteSource.Util.bytes("Ha*qw12"),
                                                this.getName());
        }
        return null;
    }

    //public static void main(String[] args) {
    //    Md5Hash md5Hash = new Md5Hash("123","sakdj*12");
    //    System.out.println(md5Hash.toHex());
    //}
}

5.Shiro中的授权

5.1 授权

授权，即访问控制，控制哪些主体可以访问哪些资源。

5.2 关键对象

授权可以理解为who对what进行how操作

Who，即主体(Subject)
What，即资源(Resource)
How，即权限/许可(Permisssion)

5.3 授权流程

5.4 授权方式

基于角色的访问控制
- RBAC基于角色的访问控制(Role-Based Access Control)是以角色为中心进行访问控制
  1
  2
  3
  if(subject.hasRole("admin")){
  //操作什么角色
  }

基于资源的访问控制

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

if(subject.isPermission("user:create:*")){
  //谁 ，拥有 什么样的权限，对 哪些资源
  //对所有的用户具有创建权限
}

5.5 权限字符串

资源标识符:操作:资源实例标识符

用户创建权限: (user:create 或 user:create)
用户修改实例001的权限: (user:update:001)
用户实例001的所有权限: (user:*:001)

5.6 Shiro中授权编程的实现

编程式

Subject subject=SecurityUtils.getSubject();
if(subject.hasRole("admin")){
  //有权限
}else{
  //没有权限
}

注解式

@RequiresRoles("admin")
public void hello(){
  //有权限
}

标签式

<!--JSP-->
<shiro:hasRole name="admin">
	<!--有权限-->
</shiro:hasRole>
<!--Themeleaf中需要额外集成-->

5.7 开发授权代码

/**
* 实现授权
*/
public static void main(String[] args) {
    //首选实现认证功能
    //创建安全管理器
    DefaultSecurityManager securityManager = new DefaultSecurityManager();

    //自定义Realm，实现自定义认证授权校验数据库功能,并且实现Md5+Salt+Hash加密功能
    HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
    hashedCredentialsMatcher.setHashAlgorithmName("md5");
    hashedCredentialsMatcher.setHashIterations(1024);
    CustomerRealm customerRealm = new CustomerRealm();
    customerRealm.setCredentialsMatcher(hashedCredentialsMatcher);

    //设置安全管理器的Realm,校验数据库
    securityManager.setRealm(customerRealm);

    //将安全管理器设置给安全工具
    SecurityUtils.setSecurityManager(securityManager);

    //从工具中获取主体对象
    Subject subject = SecurityUtils.getSubject();

    //token
    UsernamePasswordToken token = new UsernamePasswordToken("zhangsan","123");

    //认证
    try {
        subject.login(token);
    } catch (UnknownAccountException e) {
        e.printStackTrace();
        System.out.println("用户名错误");
    }catch (IncorrectCredentialsException e){
        e.printStackTrace();
        System.out.println("密码错误");
    }
    System.out.println("登录状态: "+subject.isAuthenticated());

    //授权
    if(subject.isAuthenticated()){
        //基于角色的访问控制
        //单角色
        System.out.println("该用户是否有该权限:"+subject.hasRole("admin"));

        //多角色
        System.out.println("该用户是否具有该权限"+subject.hasAllRoles(Arrays.asList("admin","user")));

        //具有某一角色
        boolean[] booleans = subject.hasRoles(Arrays.asList("admin", "user"));
        for (boolean boolean1:booleans) {
            System.out.println("该用户是否具有该权限:"+boolean1);
        }

        System.out.println("===========");
        //基于权限的访问控制
        System.out.println("权限:"+subject.isPermitted("user:create:001"));
        //分别具有哪些权限
        boolean[] permitted = subject.isPermitted("user:create:01", "order:*:01");
        for (boolean booleanPermitted:permitted) {
            System.out.println("权限: "+booleanPermitted);
        }
        //同时具有哪些权限
        System.out.println("权限:"+subject.isPermittedAll("user:create:01", "order:*:01"));
    }
}

/**
* 完整的认证授权Realm
*/
public class CustomerRealm extends AuthorizingRealm {
    //授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        //拿到当前登录的主体身份信息
        String primaryPrincipal = (String)principalCollection.getPrimaryPrincipal();
        System.out.println("身份信息:"+primaryPrincipal);

        //根据身份信息 用户名 获取当前用户的角色信息,以及权限信息
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        simpleAuthorizationInfo.addRole("admin");
        simpleAuthorizationInfo.addRole("user");
        simpleAuthorizationInfo.addStringPermission("user:create:*");

        return simpleAuthorizationInfo;
    }

    //认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //获取身份信息
        String principal = (String)authenticationToken.getPrincipal();

        //根据用户名查询数据库
        if("zhangsan".equals(principal)){
            return new SimpleAuthenticationInfo("zhangsan","b8865ac0a7ac17a09a65f861429b08e6", ByteSource.Util.bytes("Ha*qw12"),this.getName());
        }
        return null;
    }
}

6.SpringBoot整合实战

6.1 运行逻辑

6.2 导入依赖

<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring-boot-starter</artifactId>
    <version>1.7.1</version>
</dependency>
<dependency>
  <groupId>com.github.theborakompanioni</groupId>
  <artifactId>thymeleaf-extras-shiro</artifactId>
  <version>2.0.0</version>
</dependency>
<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-ehcache</artifactId>
  <version>1.7.1</version>
</dependency>

6.3 常见过滤器

注意：shiro提供多个默认的过滤器，我们可以用这些过滤器来配置控制指定url的权限

配置缩写	对应的过滤器	功能
anon	AnonymousFilter	指定url可以匿名访问
authc	FormAuthenticationFilter	指定url需要form表单登录，默认会从请求中获取username、password、rememberMe等参数并尝试登录，如果登录不了就会跳转到loginUrl配置的路径。我们也可以用这个过滤器做默认的登录逻辑，但是一般都是我们自己在控制器写登录逻辑的，自己写的话出错返回得到信息都可以定制。
authcBasic	BasicHttpAuthenticationFilter	指定url需要basic
logout	LogoutFilter	登出过滤器，配置指定url就可以实现退出功能，非常方便
noSessionCreation	NoSessionCreationFilter	禁止创建会话
perms	PermissionsAuthorizationFilter	需要指定权限才能访问
port	PortFilter	需要指定端口才能访问
rest	HttpMethodPermissionFilter	将http请求方法转化成相应的动词来构造一个权限字符串，这个感觉意义不大
roles	RolesAuthorizationFilter	需要指定角色才能访问
ssl	SslFilter	需要https请求才能访问
user	UserFilter	需要已登录或”记住我”的用户才能访问

6.4 配置文件

spring:
  application:
    name: shiro
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/shiro-test?characterEncoding=UTF-8
    username: root
    password: 123456
  redis:
    port: 6379
    host: localhost
    database: 0
  thymeleaf:
    suffix: .html
  mvc:
    view:
      prefix: classpath:/templates/
mybatis:
  type-aliases-package: com.example.demo.entity
  mapper-locations: classpath:mappers/*Mapper.xml

6.5 编辑代码

6.5.1 Shiro配置类

ShiroFilter

功能:负责拦截所有请求，将SecurityManger自动注入到ShiroFilter中
SecurityManager
功能:需要将Realm数据来源自动注入到SecurityManger中
Realm

功能:创建自定义的Realm，配置密码凭证校验器、缓存、操作数据等

/**
* Shiro配置类:ShiroConfig.java
*/
@Configuration
public class ShiroConfig {

    // 1. 创建ShiroFilter
    // 功能:负责拦截所有请求
    // 需要将DefaultWebSecurityManager自动注入进ShiroFilter中
    @Bean
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultWebSecurityManager defaultWebSecurityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean=new ShiroFilterFactoryBean();

        //给filter设置安全管理器
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);
        //经过shiro的所有请求都会经过当前的filter
        System.out.println("拦截了数据");
        //需要告诉filter哪些资源是公共资源，哪些资源是受限资源
        //配置系统受限资源
        Map<String,String> map=new HashMap<>();
        //配置系统的公共资源,不受限的资源放在上面,要用到的认证资源路径不能拦截
        //比如登录、注册
        map.put("/index","anon");

        //autoc受限资源拦截，表示请求这个资源需要认证和授权
        //anon是不需要认证和授权的匿名访问
        map.put("/**","authc");

        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);

        //默认认证界面路径
        shiroFilterFactoryBean.setLoginUrl("/index");


        return shiroFilterFactoryBean;
    }

    // 2. 创建SecurityManager
    // 需要Realm数据来源自动注入到SecurityManager里
    // 功能:设置Realm
    @Bean
    public DefaultWebSecurityManager getDefaultWebSecurityManager(Realm realm){
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();

        //给安全管理器设置Realm
        defaultWebSecurityManager.setRealm(realm);
        return defaultWebSecurityManager;
    }

    // 3. 创建自定义Realm
    @Bean
    public Realm getRealm(){
        CustomerRealm customerRealm = new CustomerRealm();
        //修改realm中默认的密码凭证校验匹配器
        HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
        hashedCredentialsMatcher.setHashAlgorithmName("Md5");
        hashedCredentialsMatcher.setHashIterations(1024);
        customerRealm.setCredentialsMatcher(hashedCredentialsMatcher);
        //开启缓存管理
        //customerRealm.setCacheManager(new EhCacheManager());
        //使用redis缓存
        customerRealm.setCacheManager(new RedisCacheManger());
        //开启全局缓存
        customerRealm.setCachingEnabled(true);
        //开启认证缓存,本地缓存/应用内部
        customerRealm.setAuthenticationCachingEnabled(true);
        //设置在缓存中的名字，有默认，一般自定义
        customerRealm.setAuthenticationCacheName("authenticationCache");
        //开启授权缓存
        customerRealm.setAuthorizationCachingEnabled(true);
        customerRealm.setAuthorizationCacheName("authorizationCache");
        return customerRealm;
    }
}

6.5.2 自定义Realm

public class CustomerRealm extends AuthorizingRealm {
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        // 获取身份信息
        String primaryPrincipal = (String) principalCollection.getPrimaryPrincipal();
        // 根据主身份信息获取角色信息以及权限信息
        if("zhangsan".equals(primaryPrincipal)){
            SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
            simpleAuthorizationInfo.addRole("admin");
            simpleAuthorizationInfo.addStringPermission("admin:*:*");
            return  simpleAuthorizationInfo;
        }

        return null;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        System.out.println("=============");
        String principal = (String) authenticationToken.getPrincipal();
        //注入service
        //调用根据用户名查询该用户的方法
        if("zhangsan".equals(principal)){
            return new SimpleAuthenticationInfo(principal,"lisi", ByteSource.Util.bytes("vi0T"),this.getName());
        }
        return null;
    }
}

6.5.3 自定义缓存管理器

public class RedisCacheManger implements CacheManager {

    //参数1： 认证/授权缓存的统一名称
    @Override
    public <K, V> Cache<K, V> getCache(String cacheName) throws CacheException {
        return new RedisCache<K,V>(cacheName);
    }
}

6.5.4 配置Redis缓存

public class RedisCache<k,v> implements Cache<k,v> {
    private String cacheName;

    public String getCacheName() {
        return cacheName;
    }

    public void setCacheName(String cacheName) {
        this.cacheName = cacheName;
    }

    public RedisCache(String cacheName) {
        this.cacheName = cacheName;
    }

    @Override
    public v get(k k) throws CacheException {
        System.out.println("get key:"+k);
        //return (v)redisTemplate.opsForHash().get(this.cacheName,k.toString());
        return null;
    }

    @Override
    public v put(k k, v v) throws CacheException {
        System.out.println("put key:"+k);
        //redisTemplate.opsForHash().put(this.cacheName,k.toString(),v);
        System.out.println("put value:"+v);
        return null;
    }

    @Override
    public v remove(k k) throws CacheException {
        //return (v) redisTemplate.opsForHash().delete(this.cacheName,k.toString());
        return null;
    }

    @Override
    public void clear() throws CacheException {
        //redisTemplate.delete(this.cacheName);
    }

    @Override
    public int size() {
        //return redisTemplate.opsForHash().size(this.cacheName).intValue();
        return 0;
    }

    @Override
    public Set<k> keys() {
        //return redisTemplate.opsForHash().keys(this.cacheName);
        return null;
    }

    @Override
    public Collection<v> values() {
        //return redisTemplate.opsForHash().values(this.cacheName);
        return null;
    }
}

6.5.5 调用实现的方法

@Controller
public class HelloController {
    @RequestMapping("/index")
    public String hello(){
        System.out.println("hello springboot");
        return "index";
    }
    @RequestMapping("/login")
    public String index(String username,String password){
        System.out.println("login");

        // 获取主体对象
        Subject subject= SecurityUtils.getSubject();
        try {
            subject.login(new UsernamePasswordToken("zhangsan","lisi"));
            return "login";
        } catch (IncorrectCredentialsException e) {
            e.printStackTrace();
        }catch (UnknownAccountException e){
            e.printStackTrace();
        }
        return "index";
    }

    @RequestMapping("/logout")
    public String logout(){
        SecurityUtils.getSubject().logout();
        return "index";
    }
    @RequestMapping("/register")
    public String register(Object user){
        //在service层处理加密
        //此处只是假写
        //明文密码进行md5+salt+hash散列
        //将随机盐保存到数据库
        //String salt = SaltUtil.getSalt(8);
        //user.setSalt(salt);
        //Md5Hash md5Hash=new Md5Hash("xiaochen",salt,1024);
        //user.setPassword(md5Hash.toHex());
        //userDao.save(user);
        return null;
    }

    //Java代码授权
    @RequestMapping("/save")
    public String shouquan(){
        //校验功能
        //获取主体对象
        Subject subject = SecurityUtils.getSubject();
        //代码方式
        if(subject.hasRole("admin")){
            System.out.println("保存");
        }else{
            System.out.println("无权访问");
        }
        return null;
    }

    //注解方式实现授权
    @RequestMapping("/Update")
    @RequiresRoles(value = {"admin","user"})//判断角色
    //@RequiresPermissions(value="user:*:*")
    public String shouquan1(){
        return null;
    }
}