2020-08-16

zsh1783154183@gmail

于 2020-08-20 21:04:08 发布

阅读量103

点赞数

分类专栏： shiro框架 springboot 文章标签： shiro

本文链接：https://blog.csdn.net/m0_49731762/article/details/108039407

版权

shiro框架同时被 2 个专栏收录

1 篇文章 0 订阅

订阅专栏

springboot

1 篇文章 0 订阅

订阅专栏

shiro 安全框架概述

Shiro是apache旗下一个开源安全框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。使用shiro就可以非常快速的完成认证、授权等功能的开发，降低系统成本。
链接: http://shiro.apache.org/.
在概念层面 shiro主要包括三个主要理念：
在这里插入图片描述

Subject : 用户主体负责提交用户的身份给SecurityManager 进行认证
SecurityManager : 安全器管理 shiro框架最核心对象负责认证授权
Authenticator(认证管理器)：负责用户的认证操作
Authorizer(授权管理器)：负责授权检测
SessionManager(会话管理)：负责创建并管理用户的Session生命周期
CacheManager (缓存管理) ：提供创建缓存实例和管理缓存生命周期的功能
Realm： shiro连接数据的桥梁可以看做是一个业务对象将数据库信息返回给 SecurityManager

shiro 编程认证拦截

添加依赖

<dependency>

   <groupId>org.apache.shiro</groupId>

   <artifactId>shiro-spring</artifactId>

   <version>1.4.1</version>

</dependency>

2.创建shiro的核心配置类 SpringShiroConfig

package com.cy.pj.common.config;

/**@Configuration 注解描述的类为一个配置对象 是一个配置类,
 * 此对象也会交给spring管理
 */
@Configuration
public class SpringShiroConfig {//spring-shiro.xml
	

}

在shiro配置类中添加SecurityManager（接口）配置

// SecurityManager 是一个接口 返回值能用接口尽量用接口 shiro框架的核心
//@Bean 表示 方法的返回值 交给spring管理 如果没有为其指定value值 则bean的名字默认为方法名 其存储的值为返回值 
//
//@Bean（value="aaa"）
@Bean
public SecurityManager securityManager(Realm realm){
//DefaultWebSrcurityManager 是SecurityManager的一个实现类 
	DefaultWebSecurityManager sManager = new DefaultWebSecurityManager();
	 sManager.setRealm(realm);
	return sManager;	
}

在shiro配置类中添加ShiroFilterFactoryBean(shiro过滤器工厂) 对象配置，这个对象主要负责则配置过滤规则，对那些资源进行过滤筛选，过滤规则必须有
spring容器特性所有以FactoryBean结尾的这种类型，spring在创建其对象时，还会创建由这个工厂bean要创建的一个工厂对象
所以：
spring容器在管理ShiroFilterFactoryBean对象时，会基于ShiroFilterFactoryBean对象创建过滤器工厂对象（SpringShiroFilter），，然后通过过滤器工厂创建过滤器（Filter）对象，最后通过filter对请求进行过滤，
例如调用SecurityManager的方法对请求进行验证，假如没有经过验证，则跳转到登录页面进行认证即可


@Bean
public ShiroFilterFactoryBean shiroFilterFactory(SecurityManager securityManager){
		//1.创建过滤器工厂
		ShiroFilterFactoryBean fBean=new ShiroFilterFactoryBean();
		//将SecirityManager 注入给 filter  这样他就能调用SecirityManager 进行认证或者授权 如果验证通过继续 验证不通过 则跳到拦截页面
		fBean.setSecurityManager(securityManager);
		//设置认证不通过 跳转的页面
		fBean.setLoginUrl("/doLoginUI");// /doLoginUI是一个请求路径   需要在过滤规则中放行
		//定义过滤规则 用一个map实现（一定要用LinkedMap  有顺序  允许匿名访问的一定要放在上面）
		LinkedHashMap<String,String> filterMap =new LinkedHashMap<>();
		//	/use/doLogIn/** 表示的是服务器的请求  ** 所有  表示/use/doLogIn/开头的所有请求
		filterMap.put("/use/doLogIn/**","anon");//anon 为shiro框架定义 会对应一个过滤器对象 表示可以匿名访问
		//表示 除了上面的匿名访问 所有的请求都必须认证才能访问
		filterMap.put("/**","authc") //authc 表示需要认证访问
		filterMap.put("/doLogOut","logout");//logout 是登出操作 ，此操作执行会进入登录页面
		fBean.setFilterChainDefinitionMap(filterMap); //设置过滤规则 （map中的）
		return fBean;
}

5.配置拦截后跳转的页面（准备好登录页面 login.html） fBean.setLoginUrl("/doLoginUI");

@RequestMapping("doLoginUI")
public String doLoginUI(){
    return "login";
}

shiro 认证业务的实现

.认证流程

1.系统调用subject的login方法将用户信息提交给 SecurityManager
2. SecurityManager将认证操作交给认证器对象Authenticator
3. Authenticator将用户传入的身份信息传递给Realm
4. Realm访问数据库获取用户信息然后对信息进行封装并返回给Authenticator
5. Authenticator对Realm返回的信息进行身份认证

定义controller

         @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)SecurityManager将token传递给认证管理器

                   //3)认证管理器会将token传递给realm

                   return new JsonResult("login ok");

           }

认证异常交给统一异常处理类

        @ExceptionHandler(ShiroException.class)

   @ResponseBody

        public JsonResult doHandleShiroException(

                        ShiroException e) {

                JsonResult r=new JsonResult();

                r.setState(0);

                if(e instanceof UnknownAccountException) {

                        r.setMessage("账户不存在");

                }else if(e instanceof LockedAccountException) {

                        r.setMessage("账户已被禁用");

                }else if(e instanceof IncorrectCredentialsException) {

                        r.setMessage("密码不正确");

                }else if(e instanceof AuthorizationException) {

                        r.setMessage("没有此操作权限");

                }else {

                        r.setMessage("系统维护中");

                }

                e.printStackTrace();

                return r;

        }

配置Realm

package com.cy.pj.sys.service.realm;

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

import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.LockedAccountException;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authc.credential.CredentialsMatcher;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.apache.shiro.authz.AuthorizationException;
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.apache.shiro.util.ByteSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import com.cy.pj.sys.dao.SysMenuDao;
import com.cy.pj.sys.dao.SysRoleMenuDao;
import com.cy.pj.sys.dao.SysUserDao;
import com.cy.pj.sys.dao.SysUserRoleDao;
import com.cy.pj.sys.pojo.SysUser;

@Service
public class ShiroUserRealm extends AuthorizingRealm {//需要继承AuthorizingRealm 授权
	@Autowired
    private SysUserDao sysUserDao;
	
	@Autowired
	private SysUserRoleDao sysUserRoleDao;
	
	@Autowired
	private SysRoleMenuDao sysRoleMenuDao;
	
	@Autowired
	private SysMenuDao sysMenuDao;
	/**负责完成授权信息的获取和封装*/
	@Override
	protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
		System.out.println("===doGetAuthorizationInfo===");
		//1.获取登陆用户id
		SysUser user=(SysUser)principals.getPrimaryPrincipal();
		//2.基于用户id查找用户拥有的角色id
		List<Integer> roleIds=sysUserRoleDao.findRoleIdsByUserId(user.getId());
		if(roleIds==null||roleIds.size()==0)
			throw new AuthorizationException();
		//3.基于角色id查找对应的菜单id
		List<Integer> menuIds=sysRoleMenuDao.findMenuIdsByRoleIds(roleIds);
		if(menuIds==null||menuIds.size()==0)
			throw new AuthorizationException();
		//4.基于菜单id查找其授权标识
		List<String> permissions=sysMenuDao.findPermissions(menuIds);
		if(permissions==null||permissions.size()==0)
			throw new AuthorizationException();
		//5.封装信息并返回
		Set<String> stringPermissions=new HashSet<>();
		for(String per:permissions) {
			if(!StringUtils.isEmpty(per)) {
			   stringPermissions.add(per);
			}
		}
		System.out.println("stringPermissions="+stringPermissions);
		SimpleAuthorizationInfo info=new SimpleAuthorizationInfo();
		info.setStringPermissions(stringPermissions);
		return info;
	}
	/**负责完成认证信息的获取和封装*/
	@Override
	protected AuthenticationInfo doGetAuthenticationInfo(
			AuthenticationToken token) throws AuthenticationException { //AuthenticationToken 里封装了用户的信息
	    //1.获取用户提交的认证信息 UsernamePasswordToken 为AuthenticationToken 的一个子类（我们现在做的是荣户名和密码的认证 所以 转换成这个类）
		UsernamePasswordToken upToken=(UsernamePasswordToken)token;
		//2.基于用户名查找用户信息 基于UsernamePasswordToken 里面的方法getUsername 获取用户名
		SysUser user=sysUserDao.findUserByUserName(upToken.getUsername());
		//3.判定用户是否存在
		if(user==null)
			throw new UnknownAccountException();
		//4.判定用户是否已被禁用(被禁用则不允许登陆)
		if(user.getValid()==0)
			throw new LockedAccountException();
		//5.封装认证信息并返回
		ByteSource credentialsSalt=ByteSource.Util.bytes(user.getSalt());
		//SimpleAuthenticationInfo为AuthenticationInfo（接口） 的一个子类
		SimpleAuthenticationInfo info=
		new SimpleAuthenticationInfo(
				user,//principal 用户身份(传什么，将来取出来就是什么) 将来这个信息会存到登录成功后的Session中
				user.getPassword(),//hashedCredentials (已加密的密码)
				credentialsSalt,//credentialsSalt 盐值 ByteSource类型
				this.getName());//realmName 创建Realm的名称
		return info;//返回值会传递给SecurityManager，此对象基于认证信息进行认证。
	}
	/**
	  * 设置加密算法
	 */
//	@Override
//	public void setCredentialsMatcher(CredentialsMatcher credentialsMatcher) {
//		//构建加密匹配器对象
//		HashedCredentialsMatcher cMatcher=
//		new HashedCredentialsMatcher("MD5");
//		//设置加密次数
//		cMatcher.setHashIterations(1);
//		super.setCredentialsMatcher(cMatcher);
//	}
	//设置加密对象也可以使用getCredentialsMatcher方法进行封装
	@Override
	public CredentialsMatcher getCredentialsMatcher() {
		//构建加密匹配器对象
		HashedCredentialsMatcher cMatcher=
				new HashedCredentialsMatcher("MD5");
		//设置加密次数
		cMatcher.setHashIterations(1);
		return cMatcher;
	}

}
    ....

}

zsh1783154183@gmail

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2020-08-16

shiro 安全框架概述Shiro是apache旗下一个开源安全框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。使用shiro就可以非常快速的完成认证、授权等功能的开发，降低系统成本。链接: http://shiro.apache.org/.在概念层面 shiro主要包括三个主要理念：Subject : 用户主体负责提交用户的身份给SecurityManager 进行认证SecurityManager : 安
复制链接

扫一扫