欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页

Spring Boot中集成 Shiro做简单的认证及授权.

程序员文章站 2022-07-12 23:14:44
...

Spring Boot中集成 Shiro做简单的认证及授权.

一. Shiro 三大核心组件

Spring Boot中集成 Shiro做简单的认证及授权.
1.Subject：主体，代表了当前 “用户”，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是 Subject，如网络爬虫，机器人等；即一个抽象概念；所有 Subject 都绑定到 SecurityManager，与 Subject 的所有交互都会委托给 SecurityManager；可以把 Subject 认为是一个门面；SecurityManager 才是实际的执行者；
2.SecurityManager:安全管理器；即所有与安全有关的操作都会与 SecurityManager 交互；且它管理着所有 Subject；可以看出它是 Shiro 的核心，它负责与后边介绍的其他组件进行交互，如果学习过 SpringMVC，你可以把它看成 DispatcherServlet 前端控制器；
3.Realms:域，Shiro 从 Realm 获取安全数据（如用户、角色、权限），就是说 SecurityManager 要验证用户身份，那么它需要从 Realm 获取相应的用户进行比较以确定用户身份是否合法；也需要从 Realm 得到用户相应的角色 / 权限进行验证用户是否能进行操作；可以把 Realm 看成 DataSource，即安全数据源。

也就是说对于我们而言，最简单的一个 Shiro 应用：

  • 应用代码通过 Subject 来进行认证和授权，而 Subject 又委托给 SecurityManager；
  • 我们需要给 Shiro 的 SecurityManager 注入 Realm，从而让 SecurityManager 能得到合法的用户及其权限进行判断。
    Spring Boot中集成 Shiro做简单的认证及授权.

从以上也可以看出，Shiro 不提供维护用户 / 权限，而是通过 Realm 让开发人员自己注入。

二.Spring Boot 集成 Shiro 过程

1.依赖导入

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

2.数据库表数据初始化

DROP TABLE IF EXISTS `t_permission`;
CREATE TABLE `t_permission`  (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `permission_name` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '权限名',
  `role_id` int(11) NULL DEFAULT NULL COMMENT '外键关联role',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Records of t_permission
-- ----------------------------
INSERT INTO `t_permission` VALUES (1, 'user:*', 1);
INSERT INTO `t_permission` VALUES (2, 'student:*\n', 2);

-- ----------------------------
-- Table structure for t_role
-- ----------------------------
DROP TABLE IF EXISTS `t_role`;
CREATE TABLE `t_role`  (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `role_name` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '角色名称',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Records of t_role
-- ----------------------------
INSERT INTO `t_role` VALUES (1, 'admin');
INSERT INTO `t_role` VALUES (2, 'teacher');
INSERT INTO `t_role` VALUES (3, 'student');

-- ----------------------------
-- Table structure for t_user
-- ----------------------------
DROP TABLE IF EXISTS `t_user`;
CREATE TABLE `t_user`  (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户主键',
  `username` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '用户名',
  `password` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '密码',
  `login_name` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '登录名',
  `role_id` int(11) NULL DEFAULT NULL COMMENT '外键关联role表',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Records of t_user
-- ----------------------------
INSERT INTO `t_user` VALUES (1, 'zhangsan', '123456', '系统管理员', 1);
INSERT INTO `t_user` VALUES (2, 'lisi', '123456', '老师', 2);
INSERT INTO `t_user` VALUES (3, 'wangwu', '123456', '学生', 3);

t_user
Spring Boot中集成 Shiro做简单的认证及授权.
t_role
Spring Boot中集成 Shiro做简单的认证及授权.
t_permission
Spring Boot中集成 Shiro做简单的认证及授权.
3.自定义 Realm

/*
 * @className: MyRealm
 * @description 自定义Realm
 * @since JDK1.8
 * @author ljh
 * @createdAt  2020/2/23 0023 
 * @version 1.0.0
 **/
public class MyRealm extends AuthorizingRealm {

    @Autowired
    private UserService userService;

	/**
     * 用来为当前登陆成功的用户授予权限和角色
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        //获取用户名
        String username = (String) principalCollection.getPrimaryPrincipal();
        SimpleAuthorizationInfo authorizationInfo=new SimpleAuthorizationInfo();
        //给用户设置角色
        List<Role> roles = userService.findRolesByUserName(username);
        Set<String> roleNames = roles.stream().map(Role::getRoleName).collect(Collectors.toSet());
        authorizationInfo.setRoles(roleNames);
        //给用户设置权限
        List<Permission> permissions = userService.findPermissionsByUserName(username);
        Set<String> permissionNames = permissions.stream().map(Permission::getPermissionName).collect(Collectors.toSet());
        authorizationInfo.setStringPermissions(permissionNames);
        return authorizationInfo;
    }

	/**
     * 用来验证当前登录的用户，获取认证信息
     * @param authenticationToken
     * @return
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {

        //根据token获取用户名
        String username = (String) authenticationToken.getPrincipal();
        //根据用户名查询用户
        User user = userService.findUserByUsername(username);
        if (user!=null){
            //将用户存入session中
            SecurityUtils.getSubject().getSession().setAttribute("user",user);
            //传入用户名和密码进行身份认证,并返回认证信息
            return new SimpleAuthenticationInfo(user.getUsername(),user.getPassword(),MyRealm.class.getName());
        }else {
            return null;
        }


    }
}

从上面两个方法中可以看出：验证身份的时候是根据用户输入的用户名先从数据库中查出该用户名对应的用户，这时候并没有涉及到密码，也就是说到这一步的时候，即使用户输入的密码不对，也是可以查出来该用户的，然后将该用户的正确信息封装到 authcInfo 中返回给 Shiro，接下来就是Shiro的事了，它会根据这里面的真实信息与用户前台输入的用户名和密码进行校验， 这个时候也要校验密码了，如果校验通过就让用户登录，否则跳转到指定页面。同理，权限验证的时候也是先根据用户名从数据库中获取与该用户名有关的角色和权限，然后封装到 authorizationInfo 中返回给 Shiro。

4.Shiro 配置

/*
 * @className: ShiroConfig
 * @description Shiro配置
 * @since JDK1.8
 * @author ljh
 * @createdAt  2020/2/23 0023 
 * @version 1.0.0
 **/
@Configuration
@Slf4j
public class ShiroConfig {

    /**
     * 注入自定义的realm
     * @return MyRealm
     */
    @Bean
    public MyRealm myAuthRealm() {
        log.info("====myRealm注册完成=====");
        return new MyRealm();
    }


    /**
     * 注入安全管理器
     * @return SecurityManager
     */
    @Bean
    public SecurityManager securityManager() {
        // 将自定义realm加进来
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager(myAuthRealm());
        log.info("====securityManager注册完成====");
        return securityManager;
    }

    /**
     * 注入Shiro过滤器
     * @param securityManager 安全管理器
     * @return ShiroFilterFactoryBean
     */
    @Bean
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
        // 定义shiroFactoryBean
        ShiroFilterFactoryBean shiroFilterFactoryBean=new ShiroFilterFactoryBean();

        // 设置自定义的securityManager
        shiroFilterFactoryBean.setSecurityManager(securityManager);

        // 设置默认登录的url，身份认证失败会访问该url
        shiroFilterFactoryBean.setLoginUrl("/login");
        // 设置成功之后要跳转的链接
        shiroFilterFactoryBean.setSuccessUrl("/success");
        // 设置未授权界面，权限认证失败会访问该url
        shiroFilterFactoryBean.setUnauthorizedUrl("/unauthorized");

        // LinkedHashMap是有序的，进行顺序拦截器配置
        Map<String,String> filterChainMap = new LinkedHashMap<>();

        // 配置可以匿名访问的地址，可以根据实际情况自己添加，放行一些静态资源等，anon表示放行
        filterChainMap.put("/css/**", "anon");
        filterChainMap.put("/imgs/**", "anon");
        filterChainMap.put("/js/**", "anon");
        filterChainMap.put("/swagger-*/**", "anon");
        filterChainMap.put("/swagger-ui.html/**", "anon");
        // 登录url 放行
        filterChainMap.put("/login", "anon");

        // “/user/admin” 开头的需要身份认证，authc表示要身份认证
        filterChainMap.put("/user/admin*", "authc");
        // “/user/student” 开头的需要角色认证，是“admin”才允许
        filterChainMap.put("/user/student*/**", "roles[admin]");
        // “/user/teacher” 开头的需要权限认证，是“user:create”才允许
        filterChainMap.put("/user/teacher*/**", "perms[\"user:create\"]");

        // 配置logout过滤器
        filterChainMap.put("/logout", "logout");

        // 设置shiroFilterFactoryBean的FilterChainDefinitionMap
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainMap);
        log.info("====shiroFilterFactoryBean注册完成====");
        return shiroFilterFactoryBean;
    }


}
Filter 说明
anon 开放权限，可以理解为匿名用户或游客，可以直接访问的
authc 需要身份认证的
logout 注销，执行后会直接跳转到 shiroFilterFactoryBean.setLoginUrl(); 设置的 url，即登录页面
roles[admin] 参数可写多个，表示是某个或某些角色才能通过，多个参数时写 roles[“admin，user”]，当有多个参数时必须每个参数都通过才算通过
perms[user] 参数可写多个，表示需要某个或某些权限才能通过，多个参数时写 perms[“user, admin”]，当有多个参数时必须每个参数都通过才算通过

5.使用 Shiro 进行认证

  1. 认证的相关接口

接口一： 使用 http://localhost:8080/user/admin 来验证身份认证
接口二： 使用 http://localhost:8080/user/student 来验证角色认证
接口三： 使用 http://localhost:8080/user/teacher 来验证权限认证
接口四： 使用 http://localhost:8080/user/login 来实现用户登录

2.认证流程

流程一： 直接访问接口一（此时还未登录），认证失败，跳转到 login.html 页面让用户登录，登录会请求接口四，实现用户登录功能，此时 Shiro 已经保存了用户信息了。
流程二： 再次访问接口一（此时用户已经登录），认证成功，跳转到 success.html 页面，展示用户信息。
流程三： 访问接口二，测试角色认证是否成功。
流程四： 访问接口三，测试权限认证是否成功。

6.身份、角色、权限认证接口

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

    /**
     * 身份认证测试接口
     *
     * @param request
     * @return
     */
    @RequestMapping("/admin")
    public String admin(HttpServletRequest request) {
        Object user = request.getSession().getAttribute("user");
        log.info("身份认证通过{}", user);
        return "success";
    }

    /**
     * 角色认证测试接口
     *
     * @param request
     * @return
     */
    @RequestMapping("/student")
    public String student(HttpServletRequest request) {
        log.info("角色认证通过{}");
        return "success";
    }

    /**
     * 权限认证测试接口
     *
     * @param request
     * @return
     */
    @RequestMapping("/teacher")
    public String teacher(HttpServletRequest request) {
        log.info("权限认证通过{}");
        return "success";
    }

    /**
     * 登录接口
     * @description 
     *  首先会根据前端传过来的用户名和密码，创建一个 token，然后使用 SecurityUtils 来创建一个认证主体，
     *  接下来开始调用 subject.login(token) 开始进行身份认证了，注意这里传了刚刚创建的 token，就如注释中所述，
     *  这一步会跳转到我们自定义的 realm 中，进入 doGetAuthenticationInfo 方法，
     *  所以到这里，您就会明白该方法中那个参数 token 了。然后就是上文分析的那样，开始进行身份认证。
     * @param request
     * @param user
     * @return
     */
    @RequestMapping("/login")
    public String login(HttpServletRequest request, User user) {
        //根据用户名和密码创建token
        UsernamePasswordToken token = new UsernamePasswordToken(user.getUsername(), user.getPassword());
        //获取subject主题
        Subject subject = SecurityUtils.getSubject();
       
        try {
            // 开始认证，这一步会跳到我们自定义的realm中
            subject.login(token);
            request.getSession().setAttribute("user", user);
            log.info("登录成功");
            System.out.println("登录成功");
            return "success";
        } catch (AuthenticationException e) {
            request.getSession().setAttribute("user", user);
            request.setAttribute("error", "用户名或密码错误");
            log.info("登录失败,跳转登录页面");
            System.out.println("登录失败,跳转登录页面");
            e.printStackTrace();
            return "login";
        }
    }

    /**
     * 退出接口
     * @return
     */
    @RequestMapping("/logout")
    @UnInterception("UnInterception")
    public String logout() {
        SecurityUtils.getSubject().logout();
        return "login";
    }

}

/*
 * @className: IndexController
 * @description 跳转Controller
 * @since JDK1.8
 * @author ljh
 * @createdAt  2020/2/23 0023
 * @version 1.0.0
 **/
@Controller
public class IndexController {


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

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

Spring Boot中集成 Shiro做简单的认证及授权.
7.测试

浏览器请求 http://localhost:8080/user/admin 会进行身份认证，因为此时未登录，所以会跳转到 IndexController 中的 /login 接口，然后跳转到 login.html 页面让我们登录，使用用户名密码为 zhangsan/123456 登录之后，我们在浏览器中请求 http://localhost:8080/user/student 接口，会进行角色认证，因为数据库中 zhangsan的用户角色是 admin，所以和配置中的吻合，认证通过；我们再请求 http://localhost:8080/user/teacher 接口，会进行权限认证，因为数据库中 zhangsan的用户权限为 user:*，满足配置中的 user:create，所以认证通过。接下来，我们点退出，系统会注销重新让我们登录，我们使用 lisi这个用户来登录，重复上述操作，当在进行角色认证和权限认证这两步时，就认证不通过了，因为数据库中 lisi这个用户存的角色和权限与配置中的不同，所以认证不通过。

相关标签： 认证 授权

上一篇： Adams隐式4阶方法解常微分方程，python实现

下一篇： Spring Boot 集成 Apache Shiro

推荐阅读