2流高手速成記（之五）：Springboot整合Shiro實作安全管理

廢話不多說，咱們直接接上回

上一篇我們講了如何使用Springboot框架整合Nosql，并于文章最后部分引入了服務端Session的概念

而早在上上一篇中，我們則已經講到了如何使用Springboot框架整合Mybatis/MybatisPlus實作業務資料的持久化（寫入資料庫）

本篇我們把關注點放在一個于這兩部分有共同交集的內容——安全管理，并且引入我們今天的主角——Shiro框架

Apache Shiro是一個強大且易用的Java安全框架,執行身份驗證、授權、密碼和會話管理，使用Shiro的易于理解的API,您可以快速、輕松地獲得任何應用程式,從最小的移動應用程式到最大的網路和企業應用程式，

—— 來自百度百科

Shiro框架包含三個核心組件：

Subject —— 泛指當前與Shiro互動中的物體，可以是用戶或者某后臺行程

SecurityManager —— Shiro的核心組件，對內管理各種組件實體，對外提供各種安全服務

Realm —— Shiro與安全資料之間的橋接器

Shiro框架還包含有其他諸多概念，為降低大家的心智負擔，這些我們暫且不談，文末會給大家推薦延展閱讀的相關文章

還是老規矩直接上干貨，以完整的實體讓大家對【如何基于Shiro實作權限的細粒度控制】有一個整體上的認知

不知道大家會不會覺得專案結構突然變復雜？別擔心，接下來我會給大家逐一拆解

1. 創建資料表

首先是角色表——role

 然后是用戶表——user

 最后是權限表——permission

 2. 創建三個對應的Mapper

package com.example.hellospringboot.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.hellospringboot.model.Role;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

@Mapper
@Repository
public interface RoleMapper extends BaseMapper<Role> {
}

package com.example.hellospringboot.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.hellospringboot.model.User;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

@Mapper
@Repository
public interface UserMapper extends BaseMapper<User> {
}

package com.example.hellospringboot.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.hellospringboot.model.Permission;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

@Mapper
@Repository
public interface PermissionMapper extends BaseMapper<Permission> {
}

這里我們用到了上上一節講到的內容

這里的Mapper會輔助于后續的安全資料讀取

3. 接下來是Service及其實作類

package com.example.hellospringboot.service;

import com.example.hellospringboot.model.Role;

public interface RoleService {
    Role findRoleById(int id);
}

package com.example.hellospringboot.service.impl;

import com.example.hellospringboot.mapper.RoleMapper;
import com.example.hellospringboot.model.Role;
import com.example.hellospringboot.service.RoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class RoleServiceImpl implements RoleService {

    @Autowired
    RoleMapper mapper;

    public Role findRoleById(int id){
        Role role = mapper.selectById(id);
        return role;
    }
}

package com.example.hellospringboot.service;

import com.example.hellospringboot.model.User;

public interface UserService {
    boolean checkUserByUsernameAndPassword(String userName, String passWord);
    User findUserByUserName(String userName);
}

package com.example.hellospringboot.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.example.hellospringboot.mapper.UserMapper;
import com.example.hellospringboot.model.User;
import com.example.hellospringboot.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    UserMapper mapper;

    public boolean checkUserByUsernameAndPassword(String userName, String passWord){
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper = wrapper.eq("user_name", userName).eq("pass_word",passWord);
        List<User> userList = mapper.selectList(wrapper);
        return userList.size() > 0;
    }

    public User findUserByUserName(String userName){
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper = wrapper.eq("user_name", userName);
        User user = mapper.selectOne(wrapper);
        return user;
    }

}

package com.example.hellospringboot.service;

import com.example.hellospringboot.model.Permission;

import java.util.List;

public interface PermissionService {
    List<Permission> findPermissionsByRoleId(int roleId);
}

package com.example.hellospringboot.service.impl;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.example.hellospringboot.mapper.PermissionMapper;
import com.example.hellospringboot.model.Permission;
import com.example.hellospringboot.service.PermissionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class PermissionServiceImpl implements PermissionService {

    @Autowired
    PermissionMapper mapper;

    public List<Permission> findPermissionsByRoleId(int roleId){
        QueryWrapper<Permission> wrapper = new QueryWrapper<>();
        wrapper = wrapper.eq("role_id", roleId);
        List<Permission> list = mapper.selectList(wrapper);
        return list;
    }

}

ok，我們已經準備好了所有的安全資料，及對應的讀取方法

到這里，我們就算是做好了所有的準備作業

接下來看我們如何通過Shiro框架來運用這些已經裝配好的槍炮子彈

4. 引入Shiro框架相關依賴（pom.xml）

        <!-- 引入shiro框架依賴 -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.10.0</version>
        </dependency>

這次pom.xml終于不是第一步了，哈哈哈，，，

5. 創建Realm嫁接Shiro框架及安全資料（realm/MyAuthorizingRealm）

package com.example.hellospringboot.realm;

import com.example.hellospringboot.model.Permission;
import com.example.hellospringboot.model.Role;
import com.example.hellospringboot.model.User;
import com.example.hellospringboot.service.PermissionService;
import com.example.hellospringboot.service.RoleService;
import com.example.hellospringboot.service.UserService;
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.springframework.beans.factory.annotation.Autowired;

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

public class MyAuthorizingRealm extends AuthorizingRealm {

    @Autowired
    UserService userService;

    @Autowired
    RoleService roleService;

    @Autowired
    PermissionService permissionService;

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) {
        UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
        String userName = token.getUsername();
        String passWord = String.valueOf(token.getPassword());
        if (!userService.checkUserByUsernameAndPassword(userName, passWord)) {//判斷用戶賬號是否正確
            throw new UnknownAccountException("用戶名或密碼錯誤!");
        }
        return new SimpleAuthenticationInfo(userName, passWord, getName());
    }

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        String userName = principalCollection.getPrimaryPrincipal().toString();
        User user = userService.findUserByUserName(userName);
        if (user == null) {
            throw new UnknownAccountException("用戶名或密碼錯誤!");
        }
        List<Integer> rolesList = user.rolesList();
        Set<String> roles = new HashSet<>();
        Set<String> permissions = new HashSet<>();
        for (Integer roleId : rolesList) {
            Role role = roleService.findRoleById(roleId);
            roles.add(role.getName());
            List<Permission> permissionList = permissionService.findPermissionsByRoleId(roleId);
            for (Permission permission : permissionList) {
                permissions.add(permission.getName());
            }
        }
        info.setRoles(roles);
        info.setStringPermissions(permissions);
        return info;
    }
}

Realm的創建對于整個Shiro安全驗證體系搭建而言是至關重要的一步！

其中兩個抽象方法

doGetAuthenticationInfo —— 用于校驗用戶名及密碼的合法性

doGetAuthorizationInfo —— 用于賦予物體對應的角色及互動權限

6. 測驗用Controller創建

package com.example.hellospringboot.controller;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

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

    @PostMapping("/login")
    public String login(String user, String pass) {
        UsernamePasswordToken token = new UsernamePasswordToken(user, pass);
        Subject subject = SecurityUtils.getSubject();
        if(!subject.isAuthenticated()) {
            try {
                subject.login(token);
            } catch (AuthenticationException e) {
                return e.getMessage();
            }
        }
        return "ok";
    }

    @PostMapping("/logout")
    public String logout(){
        Subject subject = SecurityUtils.getSubject();
        if(subject.isAuthenticated()) {
            try {
                subject.logout();
            } catch (AuthenticationException e) {
                return e.getMessage();
            }
        }
        return "ok";
    }

    @GetMapping("/admin")
    public String admin() {
        return "admin";
    }

    @GetMapping("/user")
    public String user() {
        return "user";
    }

}

內容很簡單：

login——登錄方法

logout——登出方法

admin、user——兩個測驗方法，用于測驗不同角色對于不同方法可訪問的細粒度控制

7. ShiroConfig配置類創建，實作用戶訪問權限的細粒度控制

package com.example.hellospringboot.configure;

import com.example.hellospringboot.realm.MyAuthorizingRealm;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.realm.Realm;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.LinkedHashMap;
import java.util.Map;

@Configuration
public class ShiroConfig {

    @Bean
    public SecurityManager securityManager(Realm realm) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(realm);
        return securityManager;
    }

    @Bean
    public MyAuthorizingRealm getRealm() {
        MyAuthorizingRealm realm = new MyAuthorizingRealm();
        return realm;
    }

    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilter = new ShiroFilterFactoryBean();
        shiroFilter.setSecurityManager(securityManager);
        Map<String, String> filterChainMap = new LinkedHashMap<String, String>();
        filterChainMap.put("/user/login", "anon");
        filterChainMap.put("/user/logout", "anon");
        filterChainMap.put("/user/admin", "authc,roles[admin],perms[admin:read]");
        filterChainMap.put("/user/user", "authc,roles[user],perms[user:read]");
        shiroFilter.setFilterChainDefinitionMap(filterChainMap);
        return shiroFilter;
    }
}

securityManager 和 getRealm 顯示指定了Shiro兩大組件的實體宣告

shiroFilterFactoryBean 則是實作角色訪問權限控制的重要方法

        filterChainMap.put("/user/login", "anon"); // 代表login方法可以匿名訪問

        filterChainMap.put("/user/logout", "anon"); // 代表logout方法可以匿名訪問

        filterChainMap.put("/user/admin", "authc,roles[admin],perms[admin:read]"); // 代表admin方法需要用戶滿足admin角色，同時具備admin:read權限

        filterChainMap.put("/user/user", "authc,roles[user],perms[user:read]"); // 代表user方法需要用戶滿足user角色，同時具備user:read權限

至此，整個接入流程便結束了

我們再次結合最開始我們配置的資料來對業務邏輯進行分析

用戶 admin，同時具備admin、user兩種角色

用戶 juste，僅具備user一種角色

角色 admin，同時具備admin:write、admin:read兩種權限

角色 user，同時具備user:write、user:read兩種權限

因此

用戶 admin，同時具備admin:write、admin:read、user:write、user:read 四種操作權限

用戶 juste，同時具備user:write、user:read兩種操作權限

大家理清楚這其中的關系了嗎？^ ^

8. 執行Postman驗證結果

 我們在執行login之前，admin方法無權訪問

 登錄admin之后，同時具備admin和user方法的訪問權限

logout登出，然后login登錄普通用戶juste

會發現依然具備user方法的訪問權限，但是失去了admin方法的訪問權限

到此，驗證我們基于Shiro框架的細粒度權限控制已經實作

除了Shiro框架，我們還有另一個選擇，那就是同樣可以通過集成Spring Security框架來達成相同的目的

關于更多Shiro框架的內容，及其和Spring Security之間的異同，大家感興趣可以參考這篇文章：

Shiro最全基礎教程_思月行云的博客-CSDN博客

對于Spring Security框架，我們暫且留個懸念，以后會專門再給大家講解這部分內容

下一節，我們將把關注點投向微服務領域，SpringCloudAlibaba將會是接下來幾個章節的重頭戲，敬請期待~

MyAuthorizingRealm

標籤：其他

上一篇：1. 凱撒加密演算法 (對稱演算法)

下一篇：在def初始化程式中使用require/require_relative方法可以嗎？