shiro 入门

参考文章：

https://www.cnblogs.com/maofa/p/6407102.html

https://www.cnblogs.com/learnhow/p/9747134.html

https://www.cnblogs.com/learnhow/p/5694876.html

https://www.sojson.com/shiro

Shiro 简介

Spring MVC 整合Shiro, Shiro是一个强大的安全框架，提供 认证、授权、加密、会话管理等

Authentication（认证、鉴定）:身份认证、登陆，验证用户是否拥有响应的身份

Authorization（授权、批准）:授权，即权限验证，验证某个认证的用户是否拥有某个权限，某个用户是否拥有操作某个动作的权限，访问某个资源的权限

Session Manager: 会话管理，用户登陆后就是一次会话，在退出之前，所有的信息都保存在会话中。

Cryptography(密码学)：加密，保护数据的安全性，如密码加密后存储

Web Support: Web支持，可以非常容易的集成到Web环境中

Caching: 缓存，将用户的信息存储到缓存，不必每次都去数据库查

Concurrency: shiro 支持多线程应用程序的并发验证，在一个线程中开启另一个线程，可以把权限传播过去

Testing : 支持测试

Run As :允许不同的用户身份进行访问

Remember Me :记住我，第一次登陆后，下次直接进入到系统中

注：Shiro 不会维护用户、权限信息，这些需要程序员设计好后通过接口注入给 Shiro

从宏观的角度观察 Shiro 工作原理

图中，应用代码直接通过Subject 交互，也即是说 Shiro 对外API核心就是 Subject,Api含义：

Subject: 主体，代表了当前 用户，也是当前交互的应用都称为 Subject.所有的Subject 绑定到SecurityManager,与Subject 交互的东西委托SecurityManager,Subject 是表面，真正执行的是SecurityManager

SecurityManager:安全管理器，所有的与安全有关的操作都会与SecurityManager 交互，其也是Shiro 的核心，类似于Spring MVC 的 前端控制器（DispatcherServlet）。

Realm: 域，Shiro 从Realm获取安全数据（如用户、角色、权限），就是说SecurityManager 要验证用户身份，需要从Realm 获取相应的用户比较确认用户是否合法；Realm 类似于Shiro 的数据源

从内部角度观察Shiro

Subject：主体，可以看到主体可以是任何可以与应用交互的“用户”；

SecurityManager：相当于SpringMVC中的DispatcherServlet或者Struts2中的FilterDispatcher；是Shiro的心脏；所有具体的交互都通过SecurityManager进行控制；
　　　　　　　　它管理着所有Subject、且负责进行认证和授权、及会话、缓存的管理。

Authenticator：认证器，负责主体认证的，这是一个扩展点，如果用户觉得Shiro默认的不好，可以自定义实现；其需要认证策略（Authentication Strategy），即什么情况下算用户认证通过了；

Authrizer：授权器，或者访问控制器，用来决定主体是否有权限进行相应的操作；即控制着用户能访问应用中的哪些功能；

Realm：可以有1个或多个Realm，可以认为是安全实体数据源，即用于获取安全实体的；可以是JDBC实现，也可以是LDAP实现，或者内存实现等等；由用户提供；
　　　　　　注意：Shiro不知道你的用户/权限存储在哪及以何种格式存储；所以我们一般在应用中都需要实现自己的Realm；

SessionManager：如果写过Servlet就应该知道Session的概念，Session呢需要有人去管理它的生命周期，这个组件就是SessionManager；而Shiro并不仅仅可以用在Web环境，
　　　　　　　　也可以用在如普通的JavaSE环境、EJB等环境；所有呢，Shiro就抽象了一个自己的Session来管理主体与应用之间交互的数据；这样的话，比如我们在Web环境用，
　　　　　　　　刚开始是一台Web服务器；接着又上了台EJB服务器；这时想把两台服务器的会话数据放到一个地方，这个时候就可以实现自己的分布式会话（如把数据放到Memcached服务器）；

SessionDAO：DAO大家都用过，数据访问对象，用于会话的CRUD，比如我们想把Session保存到数据库，那么可以实现自己的SessionDAO，通过如JDBC写到数据库；
　　　　　　　　比如想把Session放到Memcached中，可以实现自己的Memcached SessionDAO；另外SessionDAO中可以使用Cache进行缓存，以提高性能；

CacheManager：缓存控制器，来管理如用户、角色、权限等的缓存的；因为这些数据基本上很少去改变，放到缓存中后可以提高访问的性能

Cryptography：密码模块，Shiro提高了一些常见的加密组件用于如密码加密/解密的

自定义Realm

public class ShiroRealn extends AuthorizingRealm{
}

1.ShiroRealm 父类 AuthorizingRealm 将获取Subject相关信息分成两步，获取身份验证信息（doGetAuthenticationInfo）以及授权信息（doGetAuthorizationInfo）

2.doGetAuthenticationInfo 获取身份验证相关的信息：

首先根据传入的用户名获取User信息，如果user为空，抛出 UnknownAccountException; 如果用户被锁定，抛出LockedAccountException;
最后生成AuthenticationInfo信息，交给父类AuthenticatingRealm 使用 CredentialsMatcher 进行判断密码是否正确。如果不正确，抛出 IncorrectCredentialsException;
在组装SimpleAuthenticationInfo 信息时，需要传入：身份信息（用户名）、凭据（密文密码）、盐（username+salt）、CredentialsMatcher使用盐加密传入的明文和此处的密文进行匹配

3.doGetAuthorizationInfo 获取授权信息： PrincipalCollection 是一个身份集合，直接调用getPrimaryPrincipal 得到之前传入的用户名，然后根据用户名调用 UserService 接口获取角色及授权信息。

AuthenticationTaken

AuthenticationToken 用于收集用户提交的身份及凭据

public interface AuthenticationToken extends Serializable {
    Object getPrincipal(); //身份
    Object getCredentials(); //凭据
}  

Shiro 提供了一个直接拿来用的UsernamePasswordToken,用于实现用户名/密码Token组，另外还有

RememberMeAuthenticationToken 和 HostAuthenticationToken,记住我与主机验证的支持

AuthenticationInfo

AuthenticationInfo有两个作用：

、如果Realm是AuthenticatingRealm子类，则提供给AuthenticatingRealm内部使用的CredentialsMatcher进行凭据验证；（如果没有继承它需要在自己的Realm中自己实现验证）；

、提供给SecurityManager来创建Subject（提供身份信息）；

PrincipalCollection

可以在Shiro 配置多个 Realm

public interface PrincipalCollection extends Iterable, Serializable {
    Object getPrimaryPrincipal(); //得到主要的身份
    <T> T oneByType(Class<T> type); //根据身份类型获取第一个
    <T> Collection<T> byType(Class<T> type); //根据身份类型获取一组
    List asList(); //转换为List
    Set asSet(); //转换为Set
    Collection fromRealm(String realmName); //根据Realm名字获取
    Set<String> getRealmNames(); //获取所有身份验证通过的Realm名字
    boolean isEmpty(); //判断是否为空
}

因为PrincipalCollection聚合了多个，此处最需要注意的是getPrimaryPrincipal，如果只有一个Principal那么直接返回即可，如果有多个Principal，

则返回第一个（因为内部使用Map存储，所以可以认为是返回任意一个）；

oneByType / byType根据凭据的类型返回相应的Principal；fromRealm根据Realm名字（每个Principal都与一个Realm关联）获取相应的Principal。

目前Shiro只提供了一个实现SimplePrincipalCollection，还记得之前的AuthenticationStrategy实现嘛，用于在多Realm时判断是否满足条件的，

在大多数实现中（继承了AbstractAuthenticationStrategy）afterAttempt方法会进行AuthenticationInfo（实现了MergableAuthenticationInfo）的merge，

比如SimpleAuthenticationInfo会合并多个Principal为一个PrincipalCollection。

AuthorizationInfo

AuthorizationInfo用于聚合授权信息的：

public interface AuthorizationInfo extends Serializable {
    Collection<String> getRoles(); //获取角色字符串信息
    Collection<String> getStringPermissions(); //获取权限字符串信息
    Collection<Permission> getObjectPermissions(); //获取Permission对象信息
}   

我的Shiro 实战

application.yml

server:
  context-path: /web
  port: 

spring:
  datasource:
    druid:
      type: com.alibaba.druid.pool.DruidDataSource
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://localhost:3306/spring?useSSL=false&characterEncoding=UTF-8
      username: root
      password:
      initial-size: 

      min-idle:
      max-active:
      max-wait:
      time-between-eviction-runs-millis:
      min-evictable-idle-time-millis:
      validation-query:  select '' from dual
      test-while-idle: true
      test-on-borrow: false
      test-on-return: false
      pool-prepared-statements: true
      max-open-prepared-statements:
      max-pool-prepared-statement-per-connection-size:
      filters: stat
      aop-patterns:  com.apusic.servie.*

      web-stat-filter:
        enabled: true
        url-pattern: /*
        exclusions: '*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*'

      stat-view-servlet:
        enabled: true
        url-pattern: /druid/*
        reset-enable: false
        login-username: druid
        login-password: druid123

      filter:
        stat:
          log-slow-sql: true

  thymeleaf:
    cache: false

mybatis:
  type-aliases-package: com.apusic.pojo
  mapper-locations: classpath:mapper/*.xml
  propperty:
    order: BEFORE

Shiro 配置文件

@Configuration
public class ShiroConfig {

    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        shiroFilterFactoryBean.setLoginUrl("/login");
        shiroFilterFactoryBean.setSuccessUrl("/index");
        shiroFilterFactoryBean.setUnauthorizedUrl("/403");

        LinkedHashMap<String,String> filterChainDefinitionMap = new LinkedHashMap<>();

        filterChainDefinitionMap.put("/css/**","anon");
        filterChainDefinitionMap.put("/js/**","anon");
        filterChainDefinitionMap.put("/fonts/**","anon");
        filterChainDefinitionMap.put("/img/**","anon");
        filterChainDefinitionMap.put("/druid/**","anon");
        filterChainDefinitionMap.put("/logout","logout");
        filterChainDefinitionMap.put("/","anon");
        filterChainDefinitionMap.put("/**","authc");

        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return  shiroFilterFactoryBean;
    }

    @Bean
    public SecurityManager securityManager(){
        DefaultWebSecurityManager securityManager  = new DefaultWebSecurityManager();
        securityManager.setRealm(shiroRealm());
        securityManager.setRememberMeManager(rememberMeManager());
        return securityManager;
    }

    @Bean(name = "lifecycleBeanPostProcessor")
    public LifecycleBeanPostProcessor lifecycleBeanPostProcessor(){
        return new LifecycleBeanPostProcessor();
    }

    @Bean
    public ShiroRealm shiroRealm(){
        ShiroRealm shiroRealm = new ShiroRealm();
        return  shiroRealm;
    }

    /**
     * 记住我 cookie 对象
     */

    public SimpleCookie rememberMeCookie(){
        SimpleCookie cookie = new SimpleCookie("rememberMe");
        cookie.setMaxAge();
        return cookie;
    }

    /**
     * cookie 管理
     */
    public CookieRememberMeManager rememberMeManager(){
        CookieRememberMeManager cookieRememberMeManager = new CookieRememberMeManager();
        cookieRememberMeManager.setCookie(rememberMeCookie());
        //
        cookieRememberMeManager.setCipherKey(Base64.decode("3AvVhmFLUs0KTA3Kprsdag=="));
        return cookieRememberMeManager;
    }

    @Bean
    public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator(){
        DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        advisorAutoProxyCreator.setProxyTargetClass(true);
        return advisorAutoProxyCreator;
    }

    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager){
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }

}

ShiroRealm

public class ShiroRealm extends AuthorizingRealm{

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private UserRoleMapper userRoleMapper;

    @Autowired
    private UserPermissionMapper userPermissionMapper;

    /**
     * 获取用户角色和权限
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principal) {
        User user = (User) SecurityUtils.getSubject().getPrincipal();
        String userName = user.getUsername();

        System.out.println("用户" + userName + "获取权限-----ShiroRealm.doGetAuthorizationInfo");
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();

        //获取用户角色
        List<Role> roleList = userRoleMapper.findByUserName(userName);
        Set<String> rolegSet = new HashSet<>();
        for(Role r : roleList){
            rolegSet.add(r.getName());
        }
        simpleAuthorizationInfo.setRoles(rolegSet);

        //获取用户权限集
        List<Permission> permissionList = userPermissionMapper.findByUserName(userName);
        Set<String> permissionSet = new HashSet<>();
        for(Permission p : permissionList){
            permissionSet.add(p.getName());
        }
        simpleAuthorizationInfo.setStringPermissions(permissionSet);
        return simpleAuthorizationInfo;

    }

    /**
     * 登录认证
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        String userName = (String) token.getPrincipal();
        String password = new String((char[]) token.getCredentials());

        System.out.println("用户" + userName + "认证-----ShiroRealm.doGetAuthenticationInfo");
        User user = userMapper.findByUserName(userName);

        if (user == null) {
            throw new UnknownAccountException("用户名或密码错误！");
        }
        if (!password.equals(user.getPassword())) {
            throw new IncorrectCredentialsException("用户名或密码错误！");
        }
        if (user.getStatus().equals("")) {
            throw new LockedAccountException("账号已被锁定,请联系管理员！");
        }
        SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user, password, getName());
        return info;
    }

}

用户密码加密：MD5

public class MD5Utils {
    private static final String SALT = "ABC";

    private static final String ALGORITH_NAME = "md5";

    private static final int HASH_ITERATIONS = ;

    public static String encrypt(String username,String password){
        String newPassword =new SimpleHash(ALGORITH_NAME,password, ByteSource.Util.bytes(username+SALT),HASH_ITERATIONS).toHex();
        return newPassword;
    }

    public static void main(String[] args){
        System.out.println(MD5Utils.encrypt("bai",""));
    }

}

异常处理：

@ControllerAdvice
@Order(value = Ordered.HIGHEST_PRECEDENCE)
public class GlobalExceptionHandler {

    @ExceptionHandler(value = AuthorizationException.class)
    public  String handleAuthorizationException(){
        return "";
    }
}

控制层：

@Controller
@RequestMapping("/user")
public class UserController {

    @RequiresPermissions("user:user")
    @RequestMapping("list")
    public String userList(Model model){
        model.addAttribute("value","获取用户信息");
        return "user";
    }

    @RequiresPermissions("user:add")
    @RequestMapping("add")
    public String userAdd(Model model){
        model.addAttribute("value","新增用户");
        return "user";
    }

    @RequiresPermissions("user:delete")
    @RequestMapping("delete")
    public String userDelete(Model model){
        model.addAttribute("value","删除用户");
        return "user";
    }
}