基于SpringBoot2.x+Vue2的SaaS-HRM项目(六)

最新推荐文章于 2024-05-07 15:47:17 发布

2NaCl

最新推荐文章于 2024-05-07 15:47:17 发布

阅读量838

点赞数 1

分类专栏： javaWeb

本文链接：https://blog.csdn.net/qq_41936805/article/details/94737618

版权

javaWeb 专栏收录该内容

34 篇文章 3 订阅

订阅专栏

文章目录

三、项目设计
- 4.10 认证授权

github地址前端：https://github.com/2NaCl/gongdaVue
github地址后端：https://github.com/2NaCl/gongda

三、项目设计

4.10 认证授权

认证：身份认证/登录，验证用户是不是拥有响应的身份，基于shiro的认证shiro需要采集到用户登录数据使用subject的login方法进入realm完成认证工作。

Realm域：shiro从Realm获取安全数据(如用户、角色、权限)，就是说SecurityManager要验证用户身份，那么就需要用Realm中获取响应的用户及其角色和权限进行比较以确定身份是否合法。

介绍一下shiro的组成部分：
在这里插入图片描述
Subject:主体，可以看作主体可以是任何可以与应用交互的用户

首先我们用shiro来实现最简单的登录授权认证操作。

首先将登录方式改为shiro格式，不管以哪种令牌登录，都要使用subject.login()

//用户登录
	@PostMapping(value="/login")
    public String login(String username,String password) {

        try {

            /**
             * 密码加密，不能用明文去加密，所以前端传过来密码要先加密
             * shiro 提供的md5加密
             *
             * 参数1：加密的内容
             * 参数2：盐(混淆字符串)
             * 参数3：加密次数
             */

//            password =  new Md5Hash(password, username, 3).toString();


            //构造登录令牌
            UsernamePasswordToken upToken = new UsernamePasswordToken(username, password);
            //1. 获取subject
            Subject subject = SecurityUtils.getSubject();
            //2.调用subject进行登录
            subject.login(upToken);
            return "登录成功";
        } catch (Exception e) {
            return "用户名或者密码错误";
        }

    }

用户登录操作的时候需要使用到自身角色，权限信息，就需要从Realm中提取信息，验证操作的可行性。

public class CustomRealm extends AuthorizingRealm {

    public void setName(String name) {
        super.setName("customRealm");
    }


    @Autowired
    private UserService userService;

    /**
     * 授权
     *      操作的时候，判断用户是否具有响应的权限
     *      先认证 -- 安全数据
     *      再授权 -- 根据安全数据获取用户具有的所有操作权限
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        // 1. 获取已认证的用户数据
        User user = (User) principalCollection.getPrimaryPrincipal();//得到唯一的安全数据
        // 2. 根据用户数据获取用户的权限信息(所有角色，所有权限)
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        Set<String> roles = new HashSet<>();//所有角色
        Set<String> perms = new HashSet<>();//所有权限
        for (Role role : user.getRoles()) {
            roles.add(role.getName());
            for (Permission permission : role.getPermissions()) {
                perms.add(permission.getCode());
            }
        }
        info.setStringPermissions(perms);
        info.setRoles(roles);
        return info;
    }

    /**
     * 认证
     * 参数：传递的用户名密码
     * @param authenticationToken
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {

        // 1. 获取登录的用户名密码(token)
        UsernamePasswordToken upToken = (UsernamePasswordToken) authenticationToken;
        String username = upToken.getUsername();
        String password = new String(upToken.getPassword());
        // 2.根据用户名查询数据库
        User user = userService.findByName(username);
        // 3.判断用户是否存在或者密码是否一致
        if (user != null && user.getPassword().equals(password)) {
            // 4.如果一致返回安全数据
            // 构造方法：用户数据，密码，realm域名
            SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user, password, this.getName());
            return info;
        }
        // 5.不一致，就返回null(抛出异常)
        return null;
    }
}

由于用户往往在各个模块都会牵扯到权限认证，角色认证，那么就需要shiro内部进行模块之前配合的判断组件，使用SpringBoot的配置方式来完成SecurityManager，Realm的装配，完成配合。
而判断用户权限，shiro使用的是过滤器的方式，存入map，然后进行判断。

@Configuration
public class ShiroConfiguration {
    // 1. 创建realm
    @Bean
    public CustomRealm getRealm() {
        return new CustomRealm();
    }

    // 2. 创建安全管理器
    @Bean
    public SecurityManager getSecurityManager(CustomRealm realm) {
        DefaultWebSecurityManager defaultSecurityManager = new DefaultWebSecurityManager(realm);
        defaultSecurityManager.setRealm(realm);
        return defaultSecurityManager;
    }

    // 3. 配置shiro的过滤器工厂
    // 在web程序中，都是通过一组过滤来实现
    @Bean
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
        // 1.创建过滤器工厂
        ShiroFilterFactoryBean filterFactoryBean = new ShiroFilterFactoryBean();
        // 2.设置安全管理器
        filterFactoryBean.setSecurityManager(securityManager);
        // 3.通用配置
        filterFactoryBean.setLoginUrl("autherror?code=1");//跳转url地址
        filterFactoryBean.setUnauthorizedUrl("/autherror?code=2");//未授权的url
        // 4.设置过滤器

        /**
         * 设置所有的过滤器，同Map进行控制
         * key = 拦截的url地址
         * value = 过滤器类型
         */
        Map<String, String> map = new LinkedHashMap<>();
        map.put("/user/home", "anon");//当前请求地址匿名访问
        map.put("/user/**", "authc");//当前请求地址必须认证之后访问

        filterFactoryBean.setFilterChainDefinitionMap(map);
        return filterFactoryBean;
    }

    // 开启对shiro注解的支持
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }

}

注意：anon, authc, authcBasic, user 是第一组认证过滤器，perms, port, rest, roles, ssl 是第二组授权过滤器，要通过授权过滤器，就先要完成登陆认证操作（即先要完成认证才能前去寻找授权) 才能走第二组授权器（例如访问需要 roles 权限的 url，如果还没有登陆的话，会直接跳转到 shiroFilterFactoryBean.setLoginUrl(); 设置的 url ）

shiro中的会话管理
shiro的会话管理是独立的，支持SE与EE环境，管理subject的session建立，删除，维护等等的相关信息，我们可以用SessionManager相关的组件实现session的信息打印到控制台。

//登录成功之后打印所有session内容
    @RequestMapping(value = "/show")
    public String show(HttpSession httpSession) {
	    //获取session中的键值
        Enumeration enumeration = httpSession.getAttributeNames();
        //遍历enumeration
        while (enumeration.hasMoreElements()) {
            //获取session
            String name = enumeration.nextElement().toString();
            //根据键值取session
            Object value = httpSession.getAttribute(name);
            //打印结果
            System.out.println(name + ":" + value + "<br/>/n");
        }
        return "查看session成功";
    }

最后将shiro结合redis进行统一会话管理，用redis存储session信息，维护会话操作即可，只需要(1)配置RedisManager，对redis进行操作(2)实现shiro-redis的缓存管理(3)配置SessionDao与redis的依赖关系(4)最终交给SecurityManager管理

然后具体的代码实现来到项目中。

步骤1 设置SessionManager

设置会话管理SessionManager，构建SessionId的获取方式，思路是提取请求头，替换Bearer

public class CustomSessionManager extends DefaultWebSessionManager {

    /**
     * 指定SessionID的获取方法
     */
    @Override
    protected Serializable getSessionId(ServletRequest request, ServletResponse response) {
        //获取请求头Authorization中的数据
        String id = WebUtils.toHttp(request).getHeader("Authorization");
        if (StringUtils.isEmpty(id)) {
            return super.getSessionId(request, response);
        } else {
            //请求头信息：bearer token
            id = id.replaceAll("bearer ", "");

            //返回sessionId
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE, "header");
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, id);
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID, Boolean.TRUE);
            return id;
        }
    }
}

步骤2 登录认证

登录修改，将原本jwt修改的模式，修改为shiro的认证登录，方法步骤如下

@RequestMapping(value="/login",method = RequestMethod.POST)
    public Result login(@RequestBody Map<String,String> loginMap) {
        String mobile = loginMap.get("mobile");
        String password = loginMap.get("password");

        /**
         * shiro登录验证方式
         */
        //1.构造登录令牌 UserNameAndPasswordToken
        //加密密码
        try {
            password = new Md5Hash(password, mobile, 3).toString();//1.密码，盐，加密次数
            UsernamePasswordToken usernamePasswordToken = new UsernamePasswordToken(mobile, password);
            //2.获取subject
            Subject subject = SecurityUtils.getSubject();
            //3.调用login方法，进入realm完成认证
            subject.login(usernamePasswordToken);
            //4.获取sessionId
            String sessionId = (String) subject.getSession().getId();
            //5.构造返回结果
            return new Result(ResultCode.SUCCESS, sessionId);
        } catch (Exception e) {
            e.printStackTrace();
            return new Result(ResultCode.MOBILEORPASSWORDERROR);  
        }

然后再把保存密码的方式进行修改，由于没有token令牌了，所以，要手动去存密码，而因为管理员是有默认的密码的，所以这里保存的都是普通员工，顺便再赋予一下最下等的角色权限。

/**
     * 1.保存用户
     */
		public void save(User user) {
        //设置主键的值
        String id = idWorker.nextId()+"";
        String password = new Md5Hash(user.getPassword(),user.getStudentId(),3).toString();
        user.setLevel("user");
        user.setPassword(password);//设置初始密码
        user.setEnableState(1);
        user.setId(id);
        //调用dao保存部门
        userDao.save(user);
    }

步骤3 认证授权

设置公共Realm域

在授权的重写方法中获取安全信息源，构造权限信息，完成登录的授权
在认证的重写方法中构造安全数据，获取到用户的信息，进行比较，构建出安全信息源
二者分别写在两个模块，因为系统本身是多个微服务，分公共和私有，要用私有的继承公共的，完成整个Realm域的建设。

公共realm，并且起名为ihrmRealm

public class IhrmRealm extends AuthorizingRealm {

    public void setName(String name) {
        super.setName("ihrmRealm");
    }
    //授权
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        //1.获取安全数据
        ProfileResult result = (ProfileResult) principalCollection.getPrimaryPrincipal();
        //2.获取权限信息
        Set<String> apiPerm = (Set<String>)result.getRoles().get("apis");
        //3.构造权限数据，返回值
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        info.setStringPermissions(apiPerm);
        return info;
    }

    // 认证
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        return null;
    }
}

由于realm域的数据，最终还是要被存储到redis中的，而存储的数据内容就是用户信息，角色，权限，手机，密码，所以我们要来到实体类，实现两个接口，返回null即可。
在这里插入图片描述
认证模块：
UserRealm

public class UserRealm extends IhrmRealm {

    @Autowired
    private UserService userService;

    @Autowired
    private PermissionService permissionService;

    //认证
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        //1.获取用户的手机号和密码
        UsernamePasswordToken upToken = (UsernamePasswordToken) authenticationToken;
        String mobile = upToken.getUsername();
        String password = new String(upToken.getPassword());
        //2.根据手机号查询用户
        User user = userService.findByMobile(mobile);
        //3.判断用户是否存在
        if (user != null && user.getPassword().equals(password)) {
            //4.构造安全数据并且返回(安全数据：用户基本数据，权限信息 )
            ProfileResult result = null;
            if ("user".equals(user.getLevel())) {
                result = new ProfileResult(user);
            } else {
                Map map = new HashMap();
                if ("coAdmin".equals(user.getLevel())) {
                    map.put("enVisible", 1);
                }
                List<Permission> list = permissionService.findAll(map);
                result = new ProfileResult(user, list);
            }
            //构造方法：安全数据，密码，realm域名
            SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(result, user.getPassword(), this.getName());
            return info;
        }
        return null;
    }
}

步骤4 配置ShiroConfiguration

在配置过滤条件的时候，可以设置一个Base的控制类，对未授权和未登录分开处理。

这里主要要注意的还是过滤器，anon authc perms的辨析很重要


@Configuration
public class ShiroConfiguration {
    // 1. 创建realm
    @Bean
    public IhrmRealm getRealm() {
        return new UserRealm();
    }

    // 2. 创建安全管理器
    @Bean
    public SecurityManager getSecurityManager(IhrmRealm realm) {
        DefaultWebSecurityManager defaultSecurityManager = new DefaultWebSecurityManager(realm);
        defaultSecurityManager.setRealm(realm);

        //将自定义的会话管理器注册到安全管理器中
        defaultSecurityManager.setSessionManager(sessionManager());
        //将自定义的redis管理器注册到安全管理器中
        defaultSecurityManager.setCacheManager(cacheManager());

        return defaultSecurityManager;
    }

    // 3. 配置shiro的过滤器工厂
    // 在web程序中，都是通过一组过滤来实现
    @Bean
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
        // 1.创建过滤器工厂
        ShiroFilterFactoryBean filterFactoryBean = new ShiroFilterFactoryBean();
        // 2.设置安全管理器
        filterFactoryBean.setSecurityManager(securityManager);
        // 3.通用配置
        filterFactoryBean.setLoginUrl("autherror?code=1");//跳转url地址
        filterFactoryBean.setUnauthorizedUrl("/autherror?code=2");//未授权的url
        // 4.设置过滤器
        Map<String, String> map = new LinkedHashMap<>();
        /**
         * 设置所有的过滤器，同Map进行控制
         * key = 拦截的url地址
         * value = 过滤器类型
         *
         * anon --可匿名访问
         * authc -- 必须认证访问 注册
         * perms -- 具有某种权限
         */

        map.put("/sys/login", "anon");//当前请求地址匿名访问
        map.put("/autherror", "anon");//未授权未登录，无须登录访问
        map.put("/**", "authc");//当前请求地址必须认证之后访问

        filterFactoryBean.setFilterChainDefinitionMap(map);
        return filterFactoryBean;
    }

    // 开启对shiro注解的支持
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
        return authorizationAttributeSourceAdvisor;
    }

    //Redis控制器
    //SpringData Redis , Jedis都可以使用Redis
    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private String port;
    /**
     * 1.配置Redis
     */
    public RedisManager redisManager() {
        RedisManager redisManager = new RedisManager();
        redisManager.setHost(host);
        redisManager.setPort(Integer.valueOf(port));
        return redisManager;
    }

    /**
     * 2.配置SessionDao
     */
    public RedisSessionDAO redisSessionDAO() {
        RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
        redisSessionDAO.setRedisManager(redisManager());
        return redisSessionDAO;
    }

    /**
     * 3.配置会话管理器
     */
    public DefaultWebSessionManager sessionManager() {
        CustomSessionManager sessionManager = new CustomSessionManager();
        sessionManager.setSessionDAO(redisSessionDAO());
        //不想用cookie，可以禁用
        sessionManager.setSessionIdCookieEnabled(false);
        //禁用url重写 url：jsessionId = id
        sessionManager.setSessionIdUrlRewritingEnabled(false);
        return sessionManager;
    }

    /**
     * 4.配置缓存管理器
     */
    public RedisCacheManager cacheManager() {
        RedisCacheManager redisCacheManager = new RedisCacheManager();
        redisCacheManager.setRedisManager(redisManager());
        return redisCacheManager;
    }


}

步骤5 获取到Redis内的安全数据

@RequestMapping(value="/profile",method = RequestMethod.POST)
    public Result profile(HttpServletRequest request) throws Exception {
        //获取session中的安全数据
        Subject subject = SecurityUtils.getSubject();
        //1.subject获取所有的安全数据集合
        PrincipalCollection principals = subject.getPrincipals();
        //2.获取安全数据
        ProfileResult result = (ProfileResult)principals.getPrimaryPrincipal();
        return new Result(ResultCode.SUCCESS,result);

步骤6 测试

来到postman，以现在的sessionID当做之前的token即可
在这里插入图片描述

2NaCl

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
基于SpringBoot2.x+Vue2的SaaS-HRM项目(六)

文章目录三、项目设计4.10 认证授权三、项目设计4.10 认证授权认证：身份认证/登录，验证用户是不是拥有响应的身份，基于shiro的认证shiro需要采集到用户登录数据使用subject的login方法进入realm完成认证工作。Realm域：shiro从Realm获取安全数据(如用户、角色、权限)，就是说SecurityManager要验证用户身份，那么就需要用Realm中获取响应的...
复制链接

扫一扫