Springboot学习 shiro

1. Shiro

什么是shiro?官网

是一款主流的java安全框架，不依赖任何容器，可以运行在Java SE和Java EE项目里面，主要作用是对访问系统的用户进行身份认证、授权、会话管理、加密等操作

Shiro就是用来解决安全管理的系统化框架

2. Shiro核心组件

用户、角色、权限的关系

会给角色赋予权限，然后给用户赋予角色

2.1 UsernamePasswordToken

用来封装用户登录信息，使用用户的登录信息来创建令牌Token.(封装了用户名和密码的token)

2.2 SecurityManager

Shiro的核心部分，赋值安全认证和授权

2.3 Subject

Shiro的一个抽象概念，包含了用户信息

2.4 Realm

开发者自定义的模块，根据项目的需求，验证和授权的逻辑全部写在Realm中

2.5 AuthenticationInfo

用户的角色信息集合，认证时使用

2.6 AuthorzationInfo

角色的权限集合，授权时使用

2.7 DefaultWebSecurityManager

安全管理器，开发者自定义的Realm，需要注入到DefaultWebSecurityManager进行管理才能生效

2.8 ShiroFilterFactoryBean

过滤器工厂，shiro基本运行机制是开发者定制规则，Shiro去执行，具体的执行操作就是由ShiroFilterFactoryBean创建的一个个Filter对象来完成

3. Springboot整合Shiro

3.1 maven

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

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.3.1.tmp</version>
</dependency>

3.2 自定义shiro过滤器

Realm

package com.hong.realm;

import com.hong.entity.Account;
import com.hong.service.AccountService;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.HashSet;
import java.util.Set;

/**
 * @Author : KongJHong
 * @Date : 2020-08-02 17:39
 * @Version : 1.0
 * Description     :
 */
public class AccountRealm extends AuthorizingRealm {

    @Autowired
    private AccountService accountService;
    /**
     * 配置角色信息（授权）
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        // 获取当前登录的用户信息
        Subject subject = SecurityUtils.getSubject();
        Account account = (Account) subject.getPrincipal();

        //设置角色
        Set<String> roles = new HashSet<>();
        roles.add(account.getRoles());
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo(roles);

        //设置权限
        info.addStringPermission(account.getPerms());
        return info;
    }

    /**
     * 配置用户信息（登录，认证）
     * @param authenticationToken 传入的username和password,封装而成的token
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
        Account account = accountService.findByUsername(token.getUsername());
        if (account == null)return null;

        // 把查到的password和token中的密码进行认证
        return new SimpleAuthenticationInfo(account, account.getPassword(), getName());
    }
}

Config

import com.hong.realm.AccountRealm;
import com.hong.realm.TestRealm;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

/**
 * @Author : KongJHong
 * @Date : 2020-08-02 17:49
 * @Version : 1.0
 * Description     :
 */
@Configuration
public class ShiroConfig {

    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(@Qualifier("securityManager")DefaultWebSecurityManager securityManager){
        ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();
        factoryBean.setSecurityManager(securityManager);

        // 授权设置
        Map<String,String> map = new HashMap<>();
        map.put("/main","authc"); // 请求main.html 必须是 登录状态
        map.put("/manager","perms[manager]"); // 访问/manager.html 必须有用manager授权
        map.put("/administrator","roles[administrator]"); // 访问/administrator.html 必须有用administrator角色
        factoryBean.setFilterChainDefinitionMap(map); //设置过滤器


        // 修改登录页面
        factoryBean.setLoginUrl("/login");

        // 设置未授权页面
        factoryBean.setUnauthorizedUrl("/unauth");

        return factoryBean;
    }

    /*
    * 为什么要写@Qualifier("accountRealm")?
    * 因为要指定spring 从ioc中先把accountRealm捞出来，避免重复创建，同时要求bean创建的先后顺序
    * */
    @Bean
    public DefaultWebSecurityManager securityManager(@Qualifier("accountRealm") AccountRealm accountRealm
                                                     ){
        DefaultWebSecurityManager manager = new DefaultWebSecurityManager();
        manager.setRealm(accountRealm);
//        manager.setRealm(testRealm);
        return manager;
    }

    @Bean
    public AccountRealm accountRealm(){
        return new AccountRealm();
    }

    @Bean
    public TestRealm testRealm(){
        return new TestRealm();
    }
}

3.3 编写认证和授权规则

3.3.1 认证过滤器

anno: 无需认证

authc: 必须认证

authcBasic: 需要通过HTTPBasic认证

user: 不一定通过认证，只要曾经被shiro记录即可，比如：记住我

3.3.2 授权过滤器

perms: 必须拥有某个权限才能访问

role: 必须拥有某个角色才能访问

port: 请求的端口必须是指定值才可以

rest: 请求必须基于Restful

ssl: 必须是安全的URL请求，协议HTTPS

3.3.3 操作逻辑

创建3个页面，main.html、 manager.html、 administrator.html

访问权限如下:

1. 必须登录才能访问main.html
2. 当前用户必须拥有manager授权才能访问manager.html
3. 当前用户必须拥有administrator角色才能访问administrator.html