shiro框架注解配置

最新推荐文章于 2024-01-20 19:24:38 发布

qq_44801336

最新推荐文章于 2024-01-20 19:24:38 发布

阅读量384

点赞数 1

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/qq_44801336/article/details/105198346

版权

java 专栏收录该内容

54 篇文章 0 订阅

订阅专栏

配置SecurityManager
SecurityManager即安全管理器,它是shiro的核心,通过SecurityManager可以完成subject的认证、授权等

/**
     * 描述的方法其返回值会交给spring管理
     * @Bean 一般应用在整合第三bean资源时
     * @return
     */
    @Bean
    public SecurityManager newSecurityManager( Realm realm, CacheManager cacheManager){
        DefaultWebSecurityManager sManager = new DefaultWebSecurityManager();
        sManager.setRealm(realm);
        //将shiro中的cache管理器注入给SecurityManager
        sManager.setCacheManager(cacheManager);
        return sManager;
    }

注入进入的Realm和CacheManager分别是
这个realm使用比较繁琐

realm作用:Shiro从Realm获取安全数据
默认自带的realm：idae查看realm继承关系，有默认实现和自定义继承的realm
这次用继承的realm
需要重写方法doGetAuthenticationInfo(认证)和doGetAuthorizationInfo(授权)
认证的思路
1 . 通过登录页面输入的用户名和密码传入后台，再进行封装到Subject

@RequestMapping("doLogin")
	public JsonResult doLogin(String username,String password){
		//1.获取Subject对象
		Subject subject = SecurityUtils.getSubject();
		//2.通过Subject提交用户信息，交给shiro框架进行认证操作
		//2.1 对用户进行封装
		UsernamePasswordToken token = new UsernamePasswordToken(username, password);
		//2.2对用户信息进行身份认证
		subject.login(token);
		//分析
		//1.token会传给shiro的SecurityManager
		//2.SercurityManager将token传递给认证管理器
		//3.认证管理器会将token传递给realm
		return new JsonResult("login ok");
	}

2 . 这样再下面的方法中就可以进行调用当前用户的信息
3 . 根据id或者用户名等唯一信息查询用户的状态值是0或1，即禁用、启用，否则报异常，异常由全局异常处理类接收，并且有相应的值
4 . 将数据封装返回到SecurityManager
5 . 接下来是授权方法，需要的加密方式和用户保存时，保存密码，hash次数，salt(盐值)一致—盐值在创建认证对象时以传入，这样才可以将当前用户的密码进行相同方法的加密(当然这一套方法在凭证匹配器方法中填写)，shiro底层进行判断

@Service
public class ShiroUserRealm extends AuthorizingRealm  {

    @Resource
    private SysUserDao sysUserDao;

    @Resource
    private SysUserRoleDao sysUserRoleDao;

    @Resource
    private SysRoleMenuDao sysRoleMenuDao;

    @Resource
    private SysMenuDao sysMenuDao;

    /**
     *  通过此方法完成认证数据的获取及封装,系统
     *  底层会将认证数据传递认证管理器,由认证
     *  管理器完成认证操作
     * @param token
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        //1.获取用户名(用户页面输入)
        UsernamePasswordToken upToken = (UsernamePasswordToken) token;
        String username = upToken.getUsername();
        //2.基于用户名查询用户信息
        SysUser user = sysUserDao.findUserByUserName(username);
        //3.判定用户是否存在
        if(user == null){
            throw new UnknownAccountException();
        }
        //4.判定用户是否已被禁用
        if (user.getValid()==0){
            throw new LockedAccountException();
        }
        //5.封装用户信息
        ByteSource credentialsSalt = ByteSource.Util.bytes(user.getSalt());
        SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user, user.getPassword(), credentialsSalt, getName());
        //6.返回封装结果
        return info;
    }

    /**
     * 设置凭证匹配器(与用户添加操作使用相同的加密算法)
     * @param credentialsMatcher
     */
    @Override
    public void setCredentialsMatcher(CredentialsMatcher credentialsMatcher) {
        //构建凭证匹配对象
        HashedCredentialsMatcher cMatcher = new HashedCredentialsMatcher();
        //设置加密算法
        cMatcher.setHashAlgorithmName("MD5");
        //设置加密次数
        cMatcher.setHashIterations(1);
        super.setCredentialsMatcher(cMatcher);

    }

    /**
     * 通过此方法完成授权信息的获取及封装
     * @param principals
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        //1.获取登录用户信息,例如用户id
        SysUser user = (SysUser) principals.getPrimaryPrincipal();
        Integer userId = user.getId();
        //2.基于用户id获取用户拥有的角色(sys_user_role)
        List<Integer> roleIds = sysUserRoleDao.findRoleIdsByUserId(userId);
        if(roleIds == null || roleIds.size() == 0){
            throw new AuthorizationException();
        }
        //3.基于角色id获取菜单id(sys_role_menus)
        //List转int数组
        Integer[] array = {};
        List<Integer> menuIds = sysRoleMenuDao.findMenuIdsByRoleIds(roleIds.toArray(array));
        if (menuIds == null || menuIds.size() == 0){
            throw new AuthorizationException();
        }
        //4.基于菜单id获取权限标识(sys_menus)
        List<String> permissions = sysMenuDao.findPermissions(menuIds.toArray(array));
        //5.对权限标识信息进行封装并返回
        HashSet<String> set = new HashSet<>();
        for (String per:permissions){
            //有数据才返回false，那么将放入set集合中
            if(!StringUtils.isEmpty(per)){
                set.add(per);
            }
        }
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        info.setStringPermissions(set);
        return info;
    }

}

6 .接下来是授权方法使用，首先需要在添加授权方法上添加注解@RequiresPermissions(“sys:user:update”),其中这个注解的value值将是授权的关键，因为在授权的一系列业务代码只为了查询到当前用户的菜单中的permission字段，并用set集合去重封装，返回到SecurityManager
7 .到此relam方法结束

    @RequiredLog(operation = "禁用启用")
	@RequiresPermissions("sys:user:update")
	@Override
	public int validById(Integer id, Integer valid, String modifiedUser) {
		//1.参数校验
		Assert.isValid(id!=null&&id>0, "id值无效");
		Assert.isValid(valid!=null&&(valid==1||valid==0), "状态无效");
		//2.修改状态
		int rows=sysUserDao.validById(id, valid, modifiedUser);
		if(rows==0) {
			throw new ServiceException("记录可能已经不存在");
		}
		log.info("哈哈");
		//3.返回结果
		return rows;
	}

CacheManager

创建CacheManager
添加到SecurityManager ( 可见这个对象真是shiro的核心,全部要存入这里面)

 @Bean
    public CacheManager shiroCacheManager(){
        return new MemoryConstrainedCacheManager();
    }

/**
     * 描述的方法其返回值会交给spring管理
     * @Bean 一般应用在整合第三bean资源时
     * @return
     */
    @Bean
    public SecurityManager newSecurityManager( Realm realm, CacheManager cacheManager){
        DefaultWebSecurityManager sManager = new DefaultWebSecurityManager();
        sManager.setRealm(realm);
        //将shiro中的cache管理器注入给SecurityManager
        sManager.setCacheManager(cacheManager);
        return sManager;
    }

配置过滤规则和代理

/**
     * 配置过滤器工厂
     * @param securityManager
     * @return
     */
    @Bean
    public ShiroFilterFactoryBean newShiroFilterFactoryBean(@Autowired SecurityManager securityManager){
        ShiroFilterFactoryBean sfBean = new ShiroFilterFactoryBean();
        sfBean.setSecurityManager(securityManager);
        //假如没有认证请求先访问此认证的url
        sfBean.setLoginUrl("/doLoginUI");
        //定义map指定请求过滤规则(哪些资源允许匿名访问,哪些必须认证访问)
        LinkedHashMap<String, String> map = new LinkedHashMap<>();
        //静态资源允许匿名访问":anon"
        map.put("/bower_components/**","anon");
        map.put("/build/**","anon");
        map.put("/dist/**","anon");
        map.put("/plugins/**","anon");
        map.put("/user/doLogin","anon");
        map.put("/doLogout","logout");
        //除了匿名访问的资源,其它都要认证("authc")后访问authc
        map.put("/**","authc");
        sfBean.setFilterChainDefinitionMap(map);
        return sfBean;
    }

    /**
     * 配置授权的Advisor,通过此Advisor告诉框架底层要为指定的对象创建代理对象然后
     * 对指定业务方法进行授权检查
     * @param securityManager
     * @return
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor newAuthorizationAttributeSourceAdvisor(SecurityManager securityManager){
        AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
        advisor.setSecurityManager(securityManager);
        return advisor;
    }

有个知识点也挺有意思,就是Cache这个对象用什么存储的
当配置缓存，即不用每次都去查询用户是否授权
软引用的HashMap，即内存不足时清空
源码如何查找

找到CacheManager的返回new的对象MemoryConstrainedCacheManager
protected Cache createCache(String name) {
return new MapCache(name, new SoftHashMap());
}中有SoftHashMap
再找到一下方法，断点即可查看
缓存的思路是先去到缓存找，没有查询，再存一份到缓存，下次查找就是去缓存

public class SoftHashMap<K, V> implements Map<K, V> {

public V get(Object key) {
        this.processQueue();
        V result = null;
        SoftHashMap.SoftValue<V, K> value = (SoftHashMap.SoftValue)this.map.get(key);
        if (value != null) {
            result = value.get();
            if (result == null) {
                this.map.remove(key);
            } else {
                this.addToStrongReferences(result);
            }
        }

        return result;
    }