基于SpringBoot2.x+Vue2的SaaS-HRM项目(六)
文章目录
- 三、项目设计
-
- 4.10 认证授权
-
- 步骤1 设置SessionManager
- 步骤2 登录认证
- 步骤3 认证授权
- 步骤4 配置ShiroConfiguration
- 步骤5 获取到Redis内的安全数据
- 步骤6 测试
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 + "
/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即可
