60--Shiro安全框架

目录

• Shiro安全框架
  • Shiro概述
  • Shiro概要架构
  • Shiro详细架构
• Shiro框架认证拦截实现（filter）
  • Shiro基本环境配置
    • 添加shiro依赖
    • Shiro核心对象配置
  • Shiro登陆页面呈现
    • 服务端Controller实现
    • 客户端页面实现
• Shiro框架认证业务实现
  • 认证流程分析
  • 认证服务端实现
    • 认证核心业务分析
    • DAO接口定义
    • Mapper元素定义
    • Service接口及实现
    • Controller 类实现
  • 认证客户端实现
    • 异步登陆操作实现
    • 退出操作配置实现
• Shiro框架授权过程实现
  • 授权流程分析
  • 添加授权配置
  • 授权服务端实现
    • 核心业务分析
    • Dao实现
    • Mapper实现
    • Service实现
  • 授权访问实描述现

Shiro安全框架

Shiro概述

​ Shiro是apache旗下一个开源安全框架(http://shiro.apache.org/)，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。使用shiro就可以非常快速的完成认证、授权等功能的开发，降低系统成本。

​ 用户在进行资源访问时，要求系统要对用户进行权限控制,其具体流程如图

Shiro概要架构

说明:

Subject :主体对象，负责提交用户认证和授权信息。
SecurityManager：安全管理器，负责认证，授权等业务实现。
Realm：领域对象，负责从数据层获取业务数据。

Shiro详细架构

​ Shiro框架进行权限管理时,要涉及到的一些核心对象,主要包括:认证管理对象,授权管理对象,会话管理对象,缓存管理对象,加密管理对象以及Realm管理对象(领域对象:负责处理认证和授权领域的数据访问题)等

• 主题（org.apache.shiro.subject.Subject）
  当前与软件进行交互的实体（用户，第三方服务，计划任务等）的特定于安全性的“视图”。
• SecurityManager（org.apache.shiro.mgt.SecurityManager）
  如上所述，这SecurityManager是Shiro体系结构的核心。它主要是一个“伞”对象，用于协调其托管组件以确保它们能够顺利协同工作。它还管理Shiro对每个应用程序用户的视图，因此它知道如何对每个用户执行安全性操作。
• Authenticator（org.apache.shiro.authc.Authenticator）
  Authenticator，负责执行和用户反应，以验证（登录）的尝试的组件。当用户尝试登录时，该逻辑由执行Authenticator。该Authenticator知道如何与一个或多个协调Realms该商店相关的用户/帐户信息。从这些数据中获得的数据Realms用于验证用户的身份，以确保用户确实是他们所说的真实身份。
  • 身份验证策略（org.apache.shiro.authc.pam.AuthenticationStrategy）
    如果Realm配置了多个身份验证策略，则AuthenticationStrategy它将协调领域以确定确定尝试成功或失败的条件（例如，一个领域成功但其他领域失败） ，尝试是否成功？所有领域都必须成功吗？只有第一个？）。
• Authorizer（org.apache.shiro.authz.Authorizer）
  Authorizer是部件负责确定用户在该应用程序的访问控制。它是最终表明是否允许用户做某事的机制。像Authenticator一样，Authorizer还知道如何与多个后端数据源进行协调以访问角色和权限信息。在Authorizer使用该信息来准确确定是否允许用户执行特定的操作。
• SessionManager（org.apache.shiro.session.mgt.SessionManager）
  将SessionManager知道如何创建和管理用户Session生命周期，提供在所有环境中的用户强大的会话体验。这是安全框架领域中的一项独特功能-Shiro可以在任何环境中本地管理用户会话，即使没有Web / Servlet或EJB容器也可以。默认情况下，Shiro将使用现有的会话机制（例如Servlet容器）（如果可用），但是如果没有，例如在独立应用程序或非Web环境中，它将使用其内置的企业会话管理来提供相同的编程经验。SessionDAO存在允许任何数据源被用来坚持的会议。
  • SessionDAO（org.apache.shiro.session.mgt.eis.SessionDAO）
    的SessionDAO执行Session持久代（CRUD）操作SessionManager。这允许将任何数据存储插入会话管理基础结构。
• CacheManager（org.apache.shiro.cache.CacheManager）
  CacheManager创建和管理Cache其他四郎组件使用实例的生命周期。因为Shiro可以访问许多后端数据源以进行身份​​验证，授权和会话管理，所以缓存一直是框架中的一流架构功能，可以在使用这些数据源时提高性能。可以将任何现代的开源和/或企业缓存产品插入Shiro，以提供快速有效的用户体验。
• Cryptography（org.apache.shiro.crypto。*）
  密码是企业安全框架的自然补充。Shiro的crypto软件包包含易于使用和理解的加密密码，哈希（又名摘要）和不同编解码器实现的表示形式。该软件包中的所有类都经过精心设计，以使其易于使用和易于理解。使用Java的本机加密技术支持的任何人都知道，驯服它可能是具有挑战性的动物。Shiro的加密API简化了复杂的Java机制，并使加密技术易于为普通凡人使用。
• Realms（org.apache.shiro.realm.Realm）
  如上所述，领域充当Shiro与应用程序的安全数据之间的“桥梁”或“连接器”。当真正需要与安全性相关的数据（例如用户帐户）进行交互以执行身份验证（登录）和授权（访问控制）时，Shiro会从一个或多个为应用程序配置的领域中查找许多此类内容。您可以根据Realms需要配置任意数量（通常每个数据源一个），并且Shiro会根据需要与它们进行协调，以进行身份认证和授权。

Shiro框架认证拦截实现（filter）

Shiro基本环境配置

添加shiro依赖

实用spring整合shiro时，需要在pom.xml中添加如下依赖

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

Shiro核心对象配置

​ 基于SpringBoot 实现的项目中，没有提供shiro的自动化配置，需要我们自己配置。

第一步:创建SpringShiroConfig类。

第二步：在Shiro配置类中添加SecurityManager配置(这里一定要使用org.apache.shiro.mgt.SecurityManager这个接口对象)

第三步: 在Shiro配置类中添加ShiroFilterFactoryBean对象的配置。通过此对象设置资源匿名访问、认证访问。

package com.cy.pj.common.config;

/** @Configuration 注解描述的类为spring框架中的一个配置类  */
@Configuration
public class SpringShiroConfig {
    /**
     * SecurityManager 对象shiro框架的核心。
     * @Bean 通常会配置@Configuration注解进行使用，其它特点：
     * 1)此注解描述方法会交给spring管理
     * 2)@Bean注解没有指定其value属性的值，则bean的名字默认为方法名
     * @return
     */
	//@Bean(value="sManager")
	@Bean
	public SecurityManager securityManager(Realm realm,
			CacheManager cacheManager,
			RememberMeManager rememberManager,
			SessionManager sessionManager) {
		DefaultWebSecurityManager sManager=new DefaultWebSecurityManager();
		sManager.setRealm(realm);
		sManager.setCacheManager(cacheManager);
		sManager.setRememberMeManager(rememberManager);
		sManager.setSessionManager(sessionManager);
		return sManager;
	}
	/**
	 * Spring容器在管理ShiroFilterFactoryBean对象，
	 *    会基于ShiroFilterFactoryBean对象, 创建过滤器工厂对象（SpringShiroFilter），
	 *    然后通过过滤器工厂创建过滤器(filter)对象,最后通过Filter对请求数据进行过滤，
	 *    例如调用securityManager的方法判定此请求是否已经过认证，假如没有经过认证
	 *    则跳转到登陆页面进行认证即可。
	 * @param securityManager
	 * @return
	 */
	@Bean
	public ShiroFilterFactoryBean shiroFilterFactory(SecurityManager securityManager) {
		ShiroFilterFactoryBean fBean=new ShiroFilterFactoryBean();
		fBean.setSecurityManager(securityManager);
		//设置需要进行认证的登陆页面
		fBean.setLoginUrl("/doLoginUI");
		//设置过滤规则(有顺序，允许匿名访问的放在上面)
		LinkedHashMap<String,String> filterMap=new LinkedHashMap<>();
		filterMap.put("/bower_components/**","anon");//anno为shiro框架定义，会对应一个过滤器对象，这里表示允许匿名访问
		filterMap.put("/build/**","anon");
		filterMap.put("/dist/**","anon");
		filterMap.put("/plugins/**","anon");
		filterMap.put("/user/doLogin", "anon");//登陆操作允许匿名访问
		filterMap.put("/doLogout", "logout");//logout为登出操作，此操作执行时会进入登陆页面
		//filterMap.put("/**", "authc");//authc为设置需要认证访问的资源
		filterMap.put("/**", "user");//user表示可以通过用户端提交的cookie信息进行认证
		fBean.setFilterChainDefinitionMap(filterMap);
		return fBean;
	}

过滤器名称

对象关系如下图

Shiro登陆页面呈现

服务端Controller实现

• 业务描述及设计实现
  当服务端拦截到用户请求以后,判定此请求是否已经被认证,假如没有认证应该先跳转到登录页面。

• 关键代码分析及实现.

  ​ 第一步：在PageController中添加一个呈现登录页面的方法

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

  ​ 第二步：修改SpringShiroConfig类中shiroFilterFactorybean的配置，添加登陆url的设置。

  //设置需要进行认证的登陆页面 
  sfBean.setLoginUrl("/doLoginUI");
  

客户端页面实现

• 业务描述及设计实现。
  在/templates/pages/添加一个login.html页面,然后将项目部署到web服务器,并启动测试运行.

Shiro框架认证业务实现

认证流程分析

​ 身份认证即判定用户是否是系统的合法用户，用户访问系统资源时的认证（对用户身份信息的认证）

其中认证流程分析如下:

• 系统调用subject的login方法将用户信息提交给SecurityManager
• SecurityManager将认证操作委托给认证器对象Authenticator
• Authenticator将用户输入的身份信息传递给Realm。
• Realm访问数据库获取用户信息然后对信息进行封装并返回。
• Authenticator 对realm返回的信息进行身份认证。

思考：不使用shiro框架如何完成认证操作？filter，intercetor。

认证服务端实现

认证核心业务分析

DAO接口定义

• 业务描述及设计实现。
  在用户数据层对象SysUserDao中，按特定条件查询用户信息，并对其进行封装。

• 关键代码分析及实现。

  在SysUserDao接口中，添加根据用户名获取用户对象的方法

  //	基于用户名查询
  SysUser findUserByUserName(String username);
  

Mapper元素定义

• 业务描述及设计实现。
  根据SysUserDao中定义的方法，在SysUserMapper文件中添加元素定义。

• 关键代码分析及实现。

  ​ 基于用户名获取用户对象的方法

  <select id="findUserByUserName"
          resultType="com.cy.pj.sys.pojo.SysUser">
      select *
      from sys_users  
      where username=#{username}
  </select>
  

  也可以直接使用注解

  @Select("select * from sys_users where username =#{username}")
  

Service接口及实现

• 业务描述及设计实现。
  本模块的业务在Realm类型的对象中进行实现，编写realm时，要继承AuthorizingRealm并重写相关方法，完成认证及授权业务数据的获取及封装。

• 关键代码分析及实现。

  ​ 第一步：定义ShiroUserRealm类.继承AuthorizingRealm,将其交给spring管理

  package com.cy.pj.sys.service.realm;
  
  @Service
  public class ShiroUserRealm  extends AuthorizingRealm{
  	@Autowired
  	private SysUserDao sysUserDao;
  	@Autowired
  	private SysUserRoleDao sysUserRoleDao;
  	@Autowired
  	private SysRoleMenuDao sysRoleMenuDao;
  	@Autowired
  	private SysMenuDao sysMenuDao;
  	/**
  	 * 	设置加密算法
  	 */
  	@Override
  	public void setCredentialsMatcher(CredentialsMatcher credentialsMatcher) {
  		//构建加密对象
  		HashedCredentialsMatcher cMatcher = new HashedCredentialsMatcher();
  		cMatcher.setHashAlgorithmName("MD5");
  		//设置加密次数
  		cMatcher.setHashIterations(1);
  		//set方法必须要调用cMatcher
  		super.setCredentialsMatcher(cMatcher);
  	}
  	//设置加密算法也可以通过get
  //	@Override
  //	public CredentialsMatcher getCredentialsMatcher() {
  //		//构建加密对象
  //		HashedCredentialsMatcher cMatcher = new HashedCredentialsMatcher();
  //		cMatcher.setHashAlgorithmName("MD5");
  //		//设置加密次数
  //		cMatcher.setHashIterations(1);
  //		return cMatcher;
  //	}
  	/**
  	 * 	负责完成认证信息的获取和封装
  	 */
  	@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,//principal (用户身份)(传什么将来就可以取什么)
  						user.getPassword(),//hashedCredentials 已加密的密码
  						credentialsSalt, //credentialsSalt
  						getName());//realName
  		//System.out.println("this.getName"+getName());//ShiroUserRealm
  		//6.返回封装结果
  		return info;//返回值会传递给认证管理器(SecurityManager)(后续认证管理器会通过此信息完成认证操作)
  
  	}
  	//	完成授权信息的获取和封装 
  	@Override
  	protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
  		return null;
  	}
  }
  
  

  ​ 第二步：对此Realm，需要在SpringShiroConfig配置类中，注入给SecurityManager对象,修改securityManager方法

  @Bean
  public SecurityManager securityManager(Realm realm) {
      DefaultWebSecurityManager sManager=
          new DefaultWebSecurityManager();
      sManager.setRealm(realm);
      return sManager;
  }
  

Controller 类实现

• 业务描述及设计实现。

  ​ 在此对象中定义相关方法，处理客户端的登陆请求，例如获取用户名，密码等然后提交该shiro框架进行认证。

• 关键代码分析及实现。

  ​ 第一步：在SysUserController中添加处理登陆的方法。

  //登录login
  @RequestMapping("doLogin")
  public JsonResult doLogin(String username,String password) {
      //将用户提交的信息交给securityManager进行认证
      Subject subject = SecurityUtils.getSubject();
      //封装用户名和密码的令牌,通过构造方法 ,也可以通过set方法
      UsernamePasswordToken token = new UsernamePasswordToken(username, password);
     //对用户信息进行身份认证
      subject.login(token);//提交给securityManager
      return new JsonResult("login ok");
  }
  

  ​ 第二步：修改shiroFilterFactory的配置，对/user/doLogin这个路径进行匿名访问的配置

  filterMap.put("/user/doLogin", "anon");//登陆操作允许匿名访问
  

  ​ 第三步：当我们在执行登录操作时,为了提高用户体验,可对系统中的异常信息进行处理,可以在统一异常处理类中添加以下方法:

  @ExceptionHandler(ShiroException.class)
  @ResponseBody
  public JsonResult doHandleShiroException(ShiroException e) {
      JsonResult jr = new JsonResult();
  
      jr.setState(0);
      if(e instanceof UnknownAccountException) {
          jr.setMessage("账户不存在");
      }else if(e instanceof LockedAccountException) {
          jr.setMessage("账户已被禁用");
      }else if(e instanceof IncorrectCredentialsException) {
          jr.setMessage("密码不正确");
      }else if(e instanceof AuthorizationException) {
          jr.setMessage("没有此操作权限");
      }else {
          jr.setMessage("系统维护中");
      }
      e.printStackTrace();
      return jr;
  }
  

认证客户端实现

异步登陆操作实现

点击登录操作时,将输入的用户名,密码异步提交到服务端。在login.html页面中

<script>
    $(function () {
    $('input').iCheck({
        checkboxClass: 'icheckbox_square-blue',
        radioClass: 'iradio_square-blue',
        increaseArea: '20%' // optional
    });
    $(".btn").click(doLogin);
});
function doLogin(){
    var params={
        username:$("#usernameId").val(),
        password:$("#passwordId").val(),
        isRememberMe:$("#rememberId").prop("checked")
    }
    var url="user/doLogin";
    console.log("params",params);
    $.post(url,params,function(result){
        console.log("login.result",result);
        if(result.state==1){
            //跳转到indexUI对应的页面
            location.href="doIndexUI?t="+Math.random();
        }else{
            $(".login-box-msg").html(result.message); 
        }
        return false;//防止刷新时重复提交
    });
}
</script>

退出操作配置实现

在SpringShiroConfig配置类中，修改过滤规则,添加以下过滤即可

filterMap.put("/doLogout", "logout");

Shiro框架授权过程实现

授权流程分析

授权即对用户资源访问的授权（是否允许用户访问此资源）

其中授权流程分析如下：

• 系统调用subject相关方法将用户信息(例如isPermitted)递交给SecurityManager。
• SecurityManager将权限检测操作委托给Authorizer对象。
• Authorizer将用户信息委托给realm。
• Realm访问数据库获取用户权限信息并封装。
• Authorizer对用户授权信息进行判定。

不使用shiro如何完成授权操作？intercetor，aop。

添加授权配置

在SpringShiroConfig配置类中，添加授权时的相关配置：

第一步:配置bean对象的生命周期管理(SpringBoot可以不配置)

//配置bean对象的生命周期管理
@Bean
public LifecycleBeanPostProcessor lifecycleBeanPostProcessor () {
    return new LifecycleBeanPostProcessor();
}

第二步: 通过如下配置要为目标业务对象创建代理对象（SpringBoot中可省略）

@DependsOn("lifecycleBeanPostProcessor")
@Bean
public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
		 return new DefaultAdvisorAutoProxyCreator();
}

第三步:配置advisor对象,shiro框架底层会通过此对象的matchs方法返回值(类似切入点)决定是否创建代理对象,进行权限控制。

//配置Advisor对象，此对象内容会关联切入点和相关通知
@Bean
public AuthorizationAttributeSourceAdvisor 
authorizationAttributeSourceAdvisor (
	    		    SecurityManager securityManager) {
		        AuthorizationAttributeSourceAdvisor advisor=
				new AuthorizationAttributeSourceAdvisor();
advisor.setSecurityManager(securityManager);
	return advisor;
}

授权服务端实现

核心业务分析

Dao实现

• 业务描述及设计实现。
  登陆用户ID，认证信息获取登陆用户的权限信息，并进行封装,首先根据用户的id查询用户对应的角色id,然后基于角色id查询角色对应的菜单id,最后根据菜单id查询权限的标识。

• 关键代码分析及实现。
  第一步：在SysUserRoleDao中定义基于用户id查找角色id的方法(假如方法已经存在则无需再写)

  List<Integer> findRoleIdsByUserId(Integer id);
  

  ​ 第二步：在SysRoleMenuDao中定义基于角色id查找菜单id的方法

  List<Integer> findMenuIdsByRoleIds(
  			@Param("roleIds")List<Integer> roleIds);
  

  ​ 第三步：在SysMenuDao中基于菜单id查找权限标识的方法

  List<String> findPermissions(
  			@Param("menuIds")
  			List<Integer> menuIds);	
  

Mapper实现

• 业务描述及设计实现。
  基于Dao中方法，定义映射元素。

• 关键代码分析及实现。

  第一步：在SysUserRoleMapper中定义findRoleIdsByUserId元素。

  <select id="findRoleIdsByUserId"
              resultType="int">
             select role_id
             from sys_user_roles
             where user_id=#{userId}        
  </select>
  

  第二步:在SysRoleMenuMapper中定义findMenuIdsByRoleIds元素。

  <select id="findMenuIdsByRoleIds" resultType="integer">
      select menu_id from sys_role_menus
      where role_id in
      <foreach collection="roleIds" item="roleId" open="(" close=")" separator=",">
          #{roleId}
      </foreach>
  

  第三步:在SysMenuMapper中定义findPermissions元素.

  <select id="findPermissions" resultType="string">
      select permission <!-- sys:user:update -->
      from sys_menus
      where id in
      <foreach collection="menuIds" item="menuId" open="(" close=")" separator=",">
          #{menuId}
      </foreach>
  </select> 
  

Service实现

• 业务描述及设计实现。
  在ShiroUserReam类中，重写对象realm的doGetAuthorizationInfo方法，并完成用户权限信息的获取以及封装，最后将信息传递给授权管理器完成授权操作。
• 关键代码分析及实现。
  修改ShiroUserRealm类中的doGetAuthorizationInfo方法

/**
 *  	完成授权信息的获取和封装
 */
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {

    //获取登录用户信息 例如id
    SysUser sysUser =(SysUser)principals.getPrimaryPrincipal();//主身份，基于认证传的信息
    Integer userId  = sysUser.getId();
    //基于用户的id获取用户所拥有的角色
    List<Integer> roleIds = sysUserRoleDao.findRoleIdsByUserId(userId);
    if (roleIds==null || roleIds.size()==0) {
        throw new AuthorizationException();
    }
    //基于角色id 获取对应的菜单id
    List<Integer> menuIds =sysRoleMenuDao.findMenuIdsByRoleIds(roleIds);
    if (menuIds==null || menuIds.size()==0) {
        throw new AuthorizationException();
    }
    //基于菜单id 获取权限标识
    List<String> permissions = sysMenuDao.findPermissions(menuIds);
    if (permissions==null || permissions.size()==0) {
        throw new AuthorizationException();
    }
    //对权限标识信息进行封装并返回
    Set<String> set = new HashSet<>();
    for (String per : permissions) {
        if (!StringUtils.isEmpty(per)) {
            set.add(per);
        }
    }
    //System.out.println("set:"+set);
    SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
    //这里不可以使用构造方法赋值，必须要通过set方法
    info.setStringPermissions(set);
    return info;
}

授权访问实描述现

​ 在需要进行授权访问的业务层（Service）方法上，添加执行此方法需要的权限标识，参考代码@RequiresPermissions(“sys:user:update”)

只有在哪个方法上面使用了该注解,那么才会对该方法使用权限的控制

@RequiresPermissions注解的说明

/**
* @RequiresPermissions 这个注解描述的方法为一个切入点方法。此方法在执行之前
*    需要进行权限检测(负责这个过程的方法是一个通知方法)，假如用户权限中包含
 * @RequiresPermissions 注解value属性指定的值，则授权访问，不包含则抛出异常。
*   思考：假如你去设计这个切入点对应的通知方法，你会做什么？
	 *1)目标方法执行之前获取方法上的@RequiresPermissions注解，进而取到注解中内容。
 	 *2)将注解中内容提交(subject.checkPermission(perstr))给SecurityManager对象(此对象负责授权操作)
	  *3)SecurityManager会基于realm去查找用户拥有的权限(这部分我们自己实现)。
	  *4)SecurityManager会判断用户拥有权限中是否包含RequiresPermissions注解中的内容
	  *5)SecurityManager基于用户权限进行授权或抛出异常。
	 */

​ 说明：此要注解一定要添加到业务层方法上。