[Java知识库] shiro架构图及执行流程详解

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> shiro架构图及执行流程详解 -> 正文阅读

[Java知识库]shiro架构图及执行流程详解

1、shiro架构图

shiro基本架构图：

在这里插入图片描述

Subject： 主体，可以是任何可以与应用交互的“用户”；
SecurityManager： 相当于SpringMVC中的DispatcherServlet，是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提高了一些常见的加密组件用于如密码加密/解密的。

以上部分参考https://www.cnblogs.com/flyuphigh/p/8058454.html

2、shiro基本流程

一个简单的Shiro应用：
在这里插入图片描述

1、应用代码通过Subject来进行认证和授权，而Subject又委托给SecurityManager；
2、我们需要给Shiro的SecurityManager注入Realm，从而让SecurityManager能得到合法的用户及其权限进行判断。
Shiro不提供维护用户/权限，而是通过Realm让开发人员自己注入

实际开发中，使用shiro来控制权限,一般有三个基本对象:
1、权限对象Persimmsion

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Permission{
    private String id;
    private String name;
    private String url;
}

2、角色对象Role

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Role{
    private String id;
    private String name;
    //权限集合
    private List<Permission> permissions;
}

3、用户对象User

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User{
    private String id;
    private String username;
    private String password;
    //定义角色
    List<Role> roleList;
}

用户拥有哪些角色，角色中包含哪些权限操作，从而来管理用户是否有权限来执行一些操作。

接下来便是配置shiro：
1、自定义Realm

public class CustomerRealm extends AuthorizingRealm {
    @Autowired
    private UserService userService;
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {

        //获取身份信息
        String primaryPrincipal = (String) principalCollection.getPrimaryPrincipal();
        System.out.println("调用授权验证："+primaryPrincipal);
        User user = userService.findRolesByUserName(primaryPrincipal);
        if (!CollectionUtils.isEmpty(user.getRoleList())) {
            SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
            for (Role role : user.getRoleList()) {
                simpleAuthorizationInfo.addRole(role.getName());

                //权限信息
                List<Permission> permissions = userService.findPermissionsByRoleId(role.getId());
                if(!CollectionUtils.isEmpty(permissions)){
                    for (Permission p : permissions) {
                        simpleAuthorizationInfo.addStringPermission(p.getName());
                    }
                }
            }
            return simpleAuthorizationInfo;
        }

        return null;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        String principal = (String) authenticationToken.getPrincipal();
        User user = userService.findByUserName(principal);

        if (!ObjectUtils.isEmpty(user)) {
            return new SimpleAuthenticationInfo(user.getUsername(),
                    user.getPassword(),
                    new MyByteSource(user.getSalt()),
                    //ByteSource.Util.bytes(user.getSalt().getBytes()),
                    this.getName());
        }

        return null;
    }
}

本文所附代码不细看具体细节，这里只总结大致流程，自定义CustomerRealm 继承抽象类 AuthorizingRealm，并实现其两个抽象方法doGetAuthorizationInfo与doGetAuthenticationInfo，两者分别获取数据库中当前Subject（即用户User）的权限信息和认证信息（即密码验证），一般数据库表中权限和角色关系都是多对多，我们可以联表查询到当前用户所有角色中所有权限值。总的来看，自定义CustomerRealm会分别把权限信息与认证密码信息分别封装，以便调用这两个方法时返回数据库中数据。

2、定义配置类shiroConfig

@Configuration
public class ShiroConfig {

    //1.创建shiroFilter  //负责拦截所有请求
    @Bean
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultWebSecurityManager defaultWebSecurityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();

        //给filter设置安全管理器
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);
        //配置系统受限资源  公共资源
        Map<String, String> stringStringMap = new HashMap<String, String>();
        stringStringMap.put("/index.jsp","authc"); //请求该页面需要认证和授权

       //默认认证界面路径
        shiroFilterFactoryBean.setLoginUrl("/login.jsp");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(stringStringMap);
        return shiroFilterFactoryBean;
    }

    //2.创建SecurityManager
    @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();
        //修改凭证校验匹配器
        HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
        //设置加密算法
        hashedCredentialsMatcher.setHashAlgorithmName("MD5");
        //设置散列次数
        hashedCredentialsMatcher.setHashIterations(1024);
        customerRealm.setCredentialsMatcher(hashedCredentialsMatcher);

        //开启缓存管理
        customerRealm.setCacheManager(new RedisCacheManager());
        //开启全局缓存
        customerRealm.setCachingEnabled(true);
        //开启认证缓存
        customerRealm.setAuthenticationCachingEnabled(true);
        customerRealm.setAuthenticationCacheName("AuthenticationCache");
        //开启授权缓存
        customerRealm.setAuthorizationCachingEnabled(true);
        customerRealm.setAuthorizationCacheName("AuthorizationCache");

        return customerRealm;
    }
}

这里配置了三个Bean，顺序是

获取ShiroFilterFactoryBean，作用是类似于AOP，执行相关操作前，先进行功能过滤，拦截所有请求，进入到shiro中进行认证与授权
创建SecurityManager，它是shiro的心脏，来管理shiro
对自定义的CustomerRealm进行一些配置，比如配置凭证校验匹配器了、设置reids缓存了

从三个方法传入参数来看，是呈链式调用的，getShiroFilterFactoryBean()方法需要传入DefaultWebSecurityManager对象，getDefaultWebSecurityManager()方法需要传入Realm（Realm是个接口）实际传入的是getRealm()方法返回的CustomerRealm对象。

事实上，每个Bean对应的方法名可以改变，比如getRealm()可以改为getMyRealm()，然后对应的defaultWebSecurityManager.setRealm(realm);改为defaultWebSecurityManager.setRealm(getMyRealm());即可

配置完后，看实际执行流程（以认证为例）：
1、切入点在subject.login()

@PostMapping("/login/{username}/{password}")
public String login(@PathVariable("username") String username,
                    @PathVariable("password") String password){
    Subject subject = SecurityUtils.getSubject();
    try{
        subject.login(new UsernamePasswordToken(username,password));
        return "success!!!";
    }catch (UnknownAccountException e){
        e.printStackTrace();
        return "用户名错误！！！";
    }catch (IncorrectCredentialsException e){
        e.printStackTrace();
        return "密码错误！！！";
    }
}

2、Subject是个接口，这里的login方法由DelegatingSubject实现

public class DelegatingSubject implements Subject {

可以看到，DelegatingSubject中的login()方法又调用了SecurityManager的login()方法
注意调试的时候，要下载shiro框架的源码来查看对应的java文件，不要去看class文件里的东西，java文件里更清晰

public void login(AuthenticationToken token) throws AuthenticationException {
    clearRunAsIdentitiesInternal();
    Subject subject = securityManager.login(this, token);

3、进入securityManager.login()方法，发现执行的是DefaultSecurityManager的login()方法，并调用了authenticate()方法，其中DefaultSecurityManager继承的父类实现了SecurityManager接口

public Subject login(Subject subject, AuthenticationToken token) throws AuthenticationException {
    AuthenticationInfo info;
    try {
        info = authenticate(token);

4、这个authenticate()方法属于抽象类AuthenticatingSecurityManager，转而调用了this.authenticator的authenticate()方法，

public AuthenticationInfo authenticate(AuthenticationToken token) throws AuthenticationException {
    return this.authenticator.authenticate(token);
}

5、这个this.authenticator是该抽象类中定义的private Authenticator authenticator; Authenticator 是个接口，实际执行的是其实现类AbstractAuthenticator的authenticate()方法

public final AuthenticationInfo authenticate(AuthenticationToken token) throws AuthenticationException {
    if (token == null) {
        throw new IllegalArgumentException("Method argument (authentication token) cannot be null.");
    }
    log.trace("Authentication attempt received for token [{}]", token);

    AuthenticationInfo info;
    try {
        info = doAuthenticate(token);

6、AbstractAuthenticator是个抽象类，并执行了其doAuthenticate()方法，该方法是个抽象方法，实际执行的是其实现类ModularRealmAuthenticator中的方法

protected AuthenticationInfo doAuthenticate(AuthenticationToken authenticationToken) throws AuthenticationException {
    assertRealmsConfigured();
    Collection<Realm> realms = getRealms();
    if (realms.size() == 1) {
        return doSingleRealmAuthentication(realms.iterator().next(), authenticationToken);
    } else {
        return doMultiRealmAuthentication(realms, authenticationToken);
    }
}

这里有个疑问：getRealms()如何获取到realm的，查看了对应方法，只看见传参，没看见从哪来的…不过最开始的确配置了defaultWebSecurityManager.setRealm(realm);不然这里会报错

回去补习了一下@Bean作用，，，猜测这个realm是直接从Spring容器中得到的，这是我们前边@Bean配置的getRealm()返回的自定义CustomerRealm对象

7、进入当前类下的doSingleRealmAuthentication()方法，然后去执行realm.getAuthenticationInfo()方法。

protected AuthenticationInfo doSingleRealmAuthentication(Realm realm, AuthenticationToken token) {
    if (!realm.supports(token)) {
        String msg = "Realm [" + realm + "] does not support authentication token [" +
                token + "].  Please ensure that the appropriate Realm implementation is " +
                "configured correctly or that the realm accepts AuthenticationTokens of this type.";
        throw new UnsupportedTokenException(msg);
    }
    AuthenticationInfo info = realm.getAuthenticationInfo(token);

8、Realm是个接口，实际调用的是抽象类AuthenticatingRealm的方法

public final AuthenticationInfo getAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

    AuthenticationInfo info = getCachedAuthenticationInfo(token);
    if (info == null) {
        //otherwise not cached, perform the lookup:
        info = doGetAuthenticationInfo(token);

9、先从缓存中取，若取不到，则执行doGetAuthenticationInfo()方法，绕了这么久终于来了！！！还记得自定义的CustomerRealm 继承抽象类AuthorizingRealm，并实现了其两个抽象方法，其中一个就是认证的doGetAuthenticationInfo()，这里从数据库读取用户名密码，来完成认证过程。

授权的话现在使用一般都是在controller里的每个请求方法前加注解如：

@RequiresPermissions("/user/login")
或
@RequiresRoles("admin")

在config配置类中加入以下配置，使注解生效

@Bean //配置使@RequiresPermissions起作用
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor
            = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }