Shiro(动吧旅游项目) part7

官网：http://shiro.apache.org/

Shiro安全框架简介

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

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

Shiro概要架构
在概念层面，Shiro 架构包含三个主要的理念，如图

其中：
1）Subject :主体对象，负责提交用户认证和授权信息。
2）SecurityManager：安全管理器，负责认证，授权等业务实现。
3）Realm：领域对象，负责从数据层获取业务数据。
Shiro详细架构
Shiro框架进行权限管理时,要涉及到的一些核心对象,主要包括:认证管理对象,授权管理对象,会话管理对象,缓存管理对象,加密管理对象以及Realm管理对象(领域对象:负责处理认证和授权领域的数据访问题)等，其具体架构如图
其中：
1）Subject（主体）:与软件交互的一个特定的实体（用户、第三方服务等）。
2）SecurityManager(安全管理器) :Shiro 的核心，用来协调管理组件工作。
3）Authenticator(认证管理器):负责执行认证操作。
4）Authorizer(授权管理器):负责授权检测。
5）SessionManager(会话管理):负责创建并管理用户 Session 生命周期，提供一个强有力的 Session 体验。
6）SessionDAO:代表 SessionManager 执行 Session 持久（CRUD）动作，它允许任何存储的数据挂接到 session 管理基础上。
7）CacheManager（缓存管理器）:提供创建缓存实例和管理缓存生命周期的功能。
8)Cryptography(加密管理器):提供了加密方式的设计及管理。
9)Realms(领域对象):是shiro和你的应用程序安全数据之间的桥梁。
Shiro框架认证拦截实现（filter）
Shiro基本环境配置
实用spring整合shiro时，需要在pom.xml中添加如下依赖：

<dependency>

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

   <artifactId>shiro-spring</artifactId>

   <version>1.5.3</version>

</dependency>

Shiro核心对象配置
第一步:创建SpringShiroConfig类。关键代码如下：

package com.cy.pj.common.config;

/**@Configuration 注解描述的类为一个配置对象,

 * 此对象也会交给spring管理

 */

@Configuration

public class SpringShiroConfig {//spring-shiro.xml


}

第二步：在Shiro配置类中添加SecurityManager配置，关键代码如下：

@Bean

public SecurityManager securityManager() {

                 DefaultWebSecurityManager sManager=

                 new DefaultWebSecurityManager();

                 return sManager;

}

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

@Bean

public ShiroFilterFactoryBean shiroFilterFactory (

                         SecurityManager securityManager) {

                 ShiroFilterFactoryBean sfBean=

                 new ShiroFilterFactoryBean();

                 sfBean.setSecurityManager(securityManager);

                 //定义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");

                 //除了匿名访问的资源,其它都要认证("authc")后访问

                 map.put("/**","authc");

                 sfBean.setFilterChainDefinitionMap(map);

                 return sfBean;

         }

Shiro登陆页面呈现
业务描述及设计实现
当服务端拦截到用户请求以后,判定此请求是否已经被认证,假如没有认证应该先跳转到登录页面。
第一步：在PageController中添加一个呈现登录页面的方法,关键代码如下：

@RequestMapping("doLoginUI")

public String doLoginUI(){

                return "login";

}

第二步：修改SpringShiroConfig类中shiroFilterFactorybean的配置，添加登陆url的设置。关键代码见sfBean.setLoginUrl("/doLoginUI")部分。

@Bean

public ShiroFilterFactoryBean shiroFilterFactory (

                         @Autowired SecurityManager securityManager) {

                 ShiroFilterFactoryBean sfBean=

                 new ShiroFilterFactoryBean();

                 sfBean.setSecurityManager(securityManager);

 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");

                 //除了匿名访问的资源,其它都要认证("authc")后访问

                 map.put("/**","authc");

                 sfBean.setFilterChainDefinitionMap(map);

                 return sfBean;

}

客户端页面实现
在/templates/pages/添加一个login.html页面,然后将项目部署到web服务器,并启动测试运行。
Shiro框架认证业务实现
身份认证即判定用户是否是系统的合法用户，用户访问系统资源时的认证（对用户身份信息的认证）流程图

其中认证流程分析如下:

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

在SysUserDao接口中，添加根据用户名获取用户对象的方法，关键代码如下：

SysUser findUserByUserName(String username)

根据SysUserDao中定义的方法，在SysUserMapper文件中添加元素定义。
关键代码分析及实现。
基于用户名获取用户对象的方法，关键代码如下：

<select id="findUserByUserName"

           resultType="com.cy.pj.sys.entity.SysUser">

      select *

      from sys_users  

      where username=#{username}

   </select>

业务描述及设计实现。
本模块的业务在Realm类型的对象中进行实现，我们编写realm时，要继承

AuthorizingRealm并重写相关方法，完成认证及授权业务数据的获取及封装。

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

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.AuthorizationInfo;
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 com.cy.pj.sys.dao.SysUserDao;
import com.cy.pj.sys.pojo.SysUser;
@Service
public class ShiroUserRealm  extends AuthorizingRealm{
	 @Autowired

     private SysUserDao sysUserDao;
	 
	 /**
	  * 负责完成授权信息的获取和封装
	  * 
	  * */
	 @Override
	protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
		// AuthenticationInfo doGetAuthenticationInfo
		return null;
	}

     /**

      * 设置凭证匹配器(与用户添加操作使用相同的加密算法)

      */
	 //用set方法设置加密对象
     @Override

     public void setCredentialsMatcher( CredentialsMatcher credentialsMatcher) {

             //构建加密匹配器对象

             HashedCredentialsMatcher cMatcher= new HashedCredentialsMatcher();

             //设置加密算法

             cMatcher.setHashAlgorithmName("MD5");

             //设置加密次数

             cMatcher.setHashIterations(1);

             super.setCredentialsMatcher(cMatcher);

     }
     
     //用get方法设置加密对象
     @Override
    public CredentialsMatcher getCredentialsMatcher() {
    	// TODO Auto-generated method stub
    	 
    	 //构建加密匹配器对象

         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

                             this.getName());//realName

             //6.返回封装结果

             return info;//返回值会传递给认证管理器(后续

             //认证管理器会通过此信息完成认证操作)

     }

}

第二步：对此realm，需要在SpringShiroConfig配置类中，注入给SecurityManager对象,修改securityManager方法，见黄色背景部分

Controller 类实现
第一步：在SysUserController中添加处理登陆的方法。关键代码如下：

     @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");

           }

第二步：修改shiroFilterFactory的配置，对/user/doLogin这个路径进行匿名访问的配置，查看如下黄色标记部分的代码:

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

 @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;

        }

认证客户端实现
异步登陆操作实现

$(function () {

    $(".login-box-body").on("click",".btn",doLogin);

  });

  function doLogin(){

          var params={

                 username:$("#usernameId").val(),

                 password:$("#passwordId").val()

          }

          var url="user/doLogin";

          $.post(url,params,function(result){

                  if(result.state==1){

                        //跳转到indexUI对应的页面

                        location.href="doIndexUI?t="+Math.random();

                  }else{

                        $(".login-box-msg").html(result.message);

                  }

          });

  }

退出操作配置实现
在SpringShiroConfig配置类中，修改过滤规则，添加黄色标记部分代码的配置,请看如下代码:

最终代码：

package com.cy.pj.common.config;


import java.util.LinkedHashMap;

import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.realm.Realm;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/** 
@Configuration 注解描述的类为一个配置对象,
 * 此对象也会交给spring管理
*/
@Configuration
public class SpringShiroConfig {
	/**
	 * SecurityManager对象为shiro框架的核心
	 * @Bean 通常会配置@Configuration注解进行使用，其它特点：
	 * 1)此注解描述方法会交给spring管理
     * 2)@Bean注解没有指定其value属性的值，则bean的名字默认为方法名
	 * */
	//@Bean(value="sManager")
	@Bean
	public SecurityManager securityManager(Realm realm) {

        DefaultWebSecurityManager sManager=new DefaultWebSecurityManager();
        sManager.setRealm(realm);
        return sManager;
	}
	
	/**
	 * Spring容器在管理ShiroFilterFactoryBean对象，
	 *    会基于ShiroFilterFactoryBean对象, 创建过滤器工厂对象（SpringShiroFilter），
	 *    然后通过过滤器工厂创建过滤器(filter)对象,最后通过Filter对请求数据进行过滤，
	 *    例如调用securityManager的方法判定此请求是否已经过认证，假如没有经过认证
	 *    则跳转到登陆页面进行认证即可。
	 * @param securityManager
	 * @return
	 */
	@Bean

	public ShiroFilterFactoryBean shiroFilterFactory (SecurityManager securityManager) {

	                 ShiroFilterFactoryBean sfBean=new ShiroFilterFactoryBean();

	                 sfBean.setSecurityManager(securityManager);
	                 //设置认证需要认证得页面
	                 sfBean.setLoginUrl("/doLoginUI");
	                 //定义map指定请求过滤规则(哪些资源允许匿名访问,哪些必须认证访问)
                     //设置过滤规则(有顺序，允许匿名访问的放在上面)
	                 LinkedHashMap<String,String> map= new LinkedHashMap<>();

	                 //静态资源允许匿名访问:"anon"

	                 map.put("/bower_components/**","anon");//anno为shiro框架定义，会对应一个过滤器对象，这里表示允许匿名访问

	                 map.put("/build/**","anon");

	                 map.put("/dist/**","anon");

	                 map.put("/plugins/**","anon");
	                 map.put("/user/doLogin", "anon");//登陆操作允许匿名访问
	                 map.put("/doLogout","logout"); //logout为登出操作，此方法执行时会进入登陆页面
						 // map.put("/doIndexUI", "anon");
						//  map.put("/log/**", "anon");
						 
	                 //除了匿名访问的资源,其它都要认证("authc")后访问

	                 map.put("/**","authc");

	                 sfBean.setFilterChainDefinitionMap(map);

	                 return sfBean;

	         }
	
	

}

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

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.AuthorizationInfo;
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 com.cy.pj.sys.dao.SysUserDao;
import com.cy.pj.sys.pojo.SysUser;
@Service
public class ShiroUserRealm  extends AuthorizingRealm{
	 @Autowired

     private SysUserDao sysUserDao;
	 
	 /**
	  * 负责完成授权信息的获取和封装
	  * 
	  * */
	 @Override
	protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
		// AuthenticationInfo doGetAuthenticationInfo
		return null;
	}

     /**

      * 设置凭证匹配器(与用户添加操作使用相同的加密算法)

      */
	 //用set方法设置加密对象
     @Override

     public void setCredentialsMatcher( CredentialsMatcher credentialsMatcher) {

             //构建加密匹配器对象

             HashedCredentialsMatcher cMatcher= new HashedCredentialsMatcher();

             //设置加密算法

             cMatcher.setHashAlgorithmName("MD5");

             //设置加密次数

             cMatcher.setHashIterations(1);

             super.setCredentialsMatcher(cMatcher);

     }
     
     //用get方法设置加密对象
     @Override
    public CredentialsMatcher getCredentialsMatcher() {
    	// TODO Auto-generated method stub
    	 
    	 //构建加密匹配器对象

         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

                             this.getName());//realName

             //6.返回封装结果

             return info;//返回值会传递给SecurityManager，此对象基于认证信息进行认证。


     }

}

Shiro框架授权过程实现

授权流程分析

其中授权流程分析如下：
1)系统调用subject相关方法将用户信息(例如isPermitted)递交给SecurityManager。
2)SecurityManager将权限检测操作委托给Authorizer对象。
3)Authorizer将用户信息委托给realm。
4)Realm访问数据库获取用户权限信息并封装。
5)Authorizer对用户授权信息进行判定。思考：思考不使用shiro如何完成授权操作？intercetor，aop。
添加授权配置
在SpringShiroConfig配置类中，添加授权时的相关配置：
第一步:配置bean对象的生命周期管理(SpringBoot可以不配置)。

@Bean

public LifecycleBeanPostProcessor   lifecycleBeanPostProcessor() {

                 return new LifecycleBeanPostProcessor();

}

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

@DependsOn("lifecycleBeanPostProcessor")

@Bean

public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {

                 return new DefaultAdvisorAutoProxyCreator();

}

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

 @Bean

public AuthorizationAttributeSourceAdvisor

authorizationAttributeSourceAdvisor (

                                SecurityManager securityManager) {

                        AuthorizationAttributeSourceAdvisor advisor=

                                new AuthorizationAttributeSourceAdvisor();

advisor.setSecurityManager(securityManager);

        return advisor;

}

授权服务端实现

基于登陆用户ID，认证信息获取登陆用户的权限信息，并进行封装。
第一步：在SysUserRoleDao中定义基于用户id查找角色id的方法(假如方法已经存在则无需再写)，关键代码如下：

 List<Integer> findRoleIdsByUserId(Integer id);

第二步：在SysRoleMenuDao中定义基于角色id查找菜单id的方法，关键代码如下：

  List<Integer> findMenuIdsByRoleIds(

                        @Param("roleIds")Integer[] roleIds);

第三步：在SysMenuDao中基于菜单id查找权限标识的方法，关键代码如下：

  List<String> findPermissions(

                        @Param("menuIds")

                        Integer[] menuIds);

Mapper实现
第一步：在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="int">

         select menu_id

         from sys_role_menus

         where role_id in

         <foreach collection="roleIds"

                  open="("

                  close=")"

                  separator=","

                  item="item">

               #{item}

         </foreach>

</select>

第三步:在SysMenuMapper中定义findPermissions元素，关键代码如下：

 <select id="findPermissions"

           resultType="string">

       select permission <!-- sys:user:update -->

       from sys_menus

       where id in

       <foreach collection="menuIds"

                open="("

                close=")"

                separator=","

                item="item">

            #{item}

       </foreach>

   </select>

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

@Service

public class ShiroUserRealm extends AuthorizingRealm {

        @Autowired

        private SysUserDao sysUserDao;

        @Autowired

        private SysUserRoleDao sysUserRoleDao;

        @Autowired

        private SysRoleMenuDao sysRoleMenuDao;

        @Autowired

        private SysMenuDao sysMenuDao;

        /**通过此方法完成授权信息的获取及封装*/

        @Override

        protected AuthorizationInfo doGetAuthorizationInfo(

                PrincipalCollection principals) {

                //1.获取登录用户信息，例如用户id

                SysUser user=(SysUser)principals.getPrimaryPrincipal();

                Integer userId=user.getId();

                //2.基于用户id获取用户拥有的角色(sys_user_roles)

                List<Integer> roleIds=

                sysUserRoleDao.findRoleIdsByUserId(userId);

                if(roleIds==null||roleIds.size()==0)

                throw new AuthorizationException();

                //3.基于角色id获取菜单id(sys_role_menus)

                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.对权限标识信息进行封装并返回

            Set<String> set=new HashSet<>();

            for(String per:permissions){

                    if(!StringUtils.isEmpty(per)){

                            set.add(per);

                    }

            }

            SimpleAuthorizationInfo info=

            new SimpleAuthorizationInfo();

            info.setStringPermissions(set);

                return info;//返回给授权管理器

        }

   。。。。


}

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

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

Shiro扩展功能应用

Shiro缓存配置

当我们进行授权操作时,每次都会从数据库查询用户权限信息,为了提高授权性能,可以将用户权限信息查询出来以后进行缓存,下次授权时从缓存取数据即可。

Shiro中内置缓存应用实现,其步骤如下:

第一步:在SpringShiroConfig中配置缓存Bean对象(Shiro框架提供)。

@Bean

public CacheManager shiroCacheManager(){

         return new MemoryConstrainedCacheManager();

}

说明:这个CacheManager对象的名字不能写cacheManager,因为spring容器中已经存在一个名字为cacheManager的对象了.

第二步:修改securityManager的配置，将缓存对象注入给SecurityManager对象。

Shiro记住我
记住我功能是要在用户登录成功以后,假如关闭浏览器,下次再访问系统资源(例如首页doIndexUI)时,无需再执行登录操作
客户端业务实现

其客户端login.html中关键JS实现:

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){

                  if(result.state==1){

                        //跳转到indexUI对应的页面

                        location.href="doIndexUI?t="+Math.random();

                  }else{

                        $(".login-box-msg").html(result.message);

                  }

                  return false;//防止刷新时重复提交

          });

  }

服务端业务实现

@RequestMapping("doLogin")

         @ResponseBody

         public JsonResult doLogin(

                         boolean isRememberMe,

                         String username,

                         String password) {

                 //1.封装用户信息

                 UsernamePasswordToken token=

                 new UsernamePasswordToken(username, password);

                 if(isRememberMe) {

                        token.setRememberMe(true);

                 }

                 //2.提交用户信息

                 Subject subject=SecurityUtils.getSubject();

                 subject.login(token);//token会提交给securityManager

                 return new JsonResult("login ok");

         }

第二步:在SpringShiroConfig配置类中添加记住我配置，关键代码如下：

@Bean

         public RememberMeManager rememberMeManager() {

                 CookieRememberMeManager cManager=

                 new CookieRememberMeManager();

  SimpleCookie cookie=new SimpleCookie("rememberMe");

                 cookie.setMaxAge(7*24*60*60);

                 cManager.setCookie(cookie);

                 return cManager;

         }

第三步:在SpringShiroConfig中修改securityManager的配置，为

securityManager注入rememberManager对象。参考黄色部分代码。

第四步:修改shiro的过滤认证级别，将/=author修改为/=users,查看黄色背景部分。

Shiro会话时长配置
使用shiro框架实现认证操作,用户登录成功会将用户信息写入到会话对象中,其默认时长为30分钟,假如需要对此进行配置,可参考如下配置:

第一步：在SpringShiroConfig类中，添加会话管理器配置。关键代码如下：

@Bean  

public SessionManager sessionManager() {

                 DefaultWebSessionManager sManager=

                                 new DefaultWebSessionManager();

                 sManager.setGlobalSessionTimeout(60*60*1000);

                 return sManager;

}

第二步：在SpringShiroConfig配置类中，对安全管理器 securityManager

增加 sessionManager值的注入，关键代码如下：

知识点：
1.Base64生成密钥


2.session会话
1.添加bean

2.改文件

提取共性代码：
1.提取

package com.cy.pj.common.util;

import org.apache.shiro.SecurityUtils;

import com.cy.pj.sys.pojo.SysUser;

public class ShiroUtil {

	  public static String getUsername() {
		  return getUser().getUsername();
	  }
	  public static SysUser getUser() {
		  //从session中获取登陆用户
		  return (SysUser)SecurityUtils.getSubject().getPrincipal();
	  }
}

2.修改：

3赋值：

页面上获取username:

修改密码

2.

3.

4.实现类

@Override
	public int updatePassword(String sourcePassword, String newPassword, String cfgPassword) {
		//1.参数校验
		AssertUtil.isArgumentValid(StringUtils.isEmpty(sourcePassword), "原密码不能为空");
		AssertUtil.isArgumentValid(StringUtils.isEmpty(newPassword), "新密码不能为空");
		AssertUtil.isArgumentValid(!newPassword.equals(cfgPassword), "两次密码输入不一致");
		//2.判断原密码是否正确。
		SysUser user=ShiroUtil.getUser();
		String sourceSalt=user.getSalt();//获取数据库中登陆用户的密码盐值
		SimpleHash sh=new SimpleHash("MD5", sourcePassword, sourceSalt, 1);
		AssertUtil.isArgumentValid(!user.getPassword().equals(sh.toHex()), "原密码不正确");
		//3.修改密码
		String newSalt=UUID.randomUUID().toString();
		sh=new SimpleHash("MD5", newPassword, newSalt, 1);
		int rows=sysUserDao.updatePassword(sh.toHex(), newSalt, user.getId());
		return rows;
	}

5.控制层
客户端：

bug分析：
1.
2.验证时密码不正确：

package com.cy.pj.common.config;
import java.util.LinkedHashMap;
import org.apache.shiro.cache.CacheManager;
import org.apache.shiro.cache.MemoryConstrainedCacheManager;
import org.apache.shiro.mgt.RememberMeManager;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.realm.Realm;
import org.apache.shiro.session.mgt.SessionManager;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.CookieRememberMeManager;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.servlet.SimpleCookie;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/** @Configuration 注解描述的类为spring框架中的一个配置类  */
@Configuration
public class SpringShiroConfig {
	/**
	    *  配置会话管理对象(Session管理器)，在Shiro框架的应用中，用户登陆成功以后
	       默认会将用户信息存储到session(服务端的一个对象)。
	 */
	@Bean
	public SessionManager sessionManager() {
		DefaultWebSessionManager sessionManager=new DefaultWebSessionManager();
		//设置session生命周期(默认为30分钟)
		sessionManager.setGlobalSessionTimeout(60*60*1000);//设置为60分钟
		return sessionManager;
	}
	/**
	 * 配置记住我管理器对象，此对象可以通过cookie对象存储账户信息，并将此信息
	 * 写到客户端，下次客户端可以访问服务端时，可以携带cookie中的信息进行自动
	 * 认证。
	 */
	@Bean
	public RememberMeManager rememberMeManager() {
		CookieRememberMeManager cManager=new CookieRememberMeManager();
		SimpleCookie cookie=new SimpleCookie("rememberMe");
		cookie.setMaxAge(7*24*60*60);
		cManager.setCookie(cookie);
		
		//设置加密解密密钥(假如服务器重启以后，还是需要重新登陆，将下面的语句注释掉)
		//注意:
		//1)密钥的选择16位的一个字符串
		//2)密钥的复杂度越高，加密以后的内容就越安全。
		//cManager.setCipherKey("abcd12345678qwer".getBytes());
		return cManager;
	}
	/**
	 * 配置shiro框架的缓存管理器对象(这个对象不是缓存对象，是管理缓存的一个对象)
	   基于此配置可以在Shiro框架内部初始化一个Cache对象，此Cache对象可以存储用户的权限
	   信息，当用户访问一个授权才可以访问的方法时，我们需要从数据库获取用户权限信息，
	   然后还可以将用户的这个权限信息缓存起来，下次需要时从缓存获取即可。
	 * @return
	 */
	@Bean
	public CacheManager shiroCacheManager() {
		return new MemoryConstrainedCacheManager();
	}
    /**
     * 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;
	}
	/**
	   *  配置Advisor对象，此对象内容会关联切入点和相关通知
	 * @param securityManager
	 * @return
	 */
	@Bean
	public AuthorizationAttributeSourceAdvisor 
	authorizationAttributeSourceAdvisor (
		    		    SecurityManager securityManager) {
	AuthorizationAttributeSourceAdvisor advisor=//顾问对象
					new AuthorizationAttributeSourceAdvisor();
	advisor.setSecurityManager(securityManager);
		return advisor;
	}

}

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 {
	@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.findRoleIdByUserId(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 {
	    //1.获取用户提交的认证信息
		UsernamePasswordToken upToken=(UsernamePasswordToken)token;
		//2.基于用户名查找用户信息
		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 info=
		new SimpleAuthenticationInfo(
				user,//principal 用户身份(传什么，将来取出来就是什么)
				user.getPassword(),//hashedCredentials (已加密的密码)
				credentialsSalt,//credentialsSalt
				this.getName());//realmName
		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;
	}

}

允许匿名访问：


shiro的xml配置：

认证授权：

shiro的另一种配置

官网：http://shiro.apache.org/spring-boot.html
1.换依赖

2.更改配置
2.1不需要service

2.2配置reaml

2.3配置过滤规则

3.修改application文件配置

4.使用缓存：

5.配置cookie

6.增加session

底层使用的事HttpSession，所以配置的session对象没有作用

密码的修改：

检查PageController中是否有返回UI页面的方法，有则无需添加。例如：

@RequestMapping("{module}/{moduleUI}")

public String doModuleUI(@PathVariable String moduleUI) {

                return "sys/"+moduleUI;

}

1.准备密码编辑页面
准备密码编辑页面(/templates/pages/sys/pwd_edit.html)
2.密码编辑页面呈现
在starter.html页面尾部的页面加载完成的事件处理函数中添加事件处理，关键代码如下：

$(function(){

     …

     doLoadUI("load-pwd-id","user/pwd_edit")

})

function doLoadUI(id,url){

         $("#"+id).click(function(){

                    $("#mainContentId").load(url);

    });

}

SysUserDao

   int updatePassword(

                        @Param("password")String password,

                        @Param("salt")String salt,

                        @Param("id")Integer id);

SysUserMapper.xml

 <update id="updatePassword">

         update sys_users

         set password=#{password},

             salt=#{salt},

             modifiedTime=now()

         where id=#{id}

</update>

SysUserService接口

 int updatePassword(String password,

                                   String newPassword,

                                   String cfgPassword);

SysUserServiceImpl

@Override

        public int updatePassword(String password, String newPassword,

 String cfgPassword) {

                //1.判定新密码与密码确认是否相同

                if(StringUtils.isEmpty(newPassword))

                throw new IllegalArgumentException("新密码不能为空");

                if(StringUtils.isEmpty(cfgPassword))

                throw new IllegalArgumentException("确认密码不能为空");

                if(!newPassword.equals(cfgPassword))

                throw new IllegalArgumentException("两次输入的密码不相等");

                //2.判定原密码是否正确

                if(StringUtils.isEmpty(password))

                throw new IllegalArgumentException("原密码不能为空");

                //获取登陆用户

                SysUser user=(SysUser)SecurityUtils.getSubject().getPrincipal();

                SimpleHash sh=new SimpleHash("MD5",

                password, user.getSalt(), 1);

                if(!user.getPassword().equals(sh.toHex()))

                throw new IllegalArgumentException("原密码不正确");

                //3.对新密码进行加密

                String salt=UUID.randomUUID().toString();

                sh=new SimpleHash("MD5",newPassword,salt, 1);

                //4.将新密码加密以后的结果更新到数据库

                int rows=sysUserDao.updatePassword(sh.toHex(), salt,user.getId());

                if(rows==0)

                throw new ServiceException("修改失败");

                return rows;

        }

SysUserController

@RequestMapping("doUpdatePassword")

public JsonResult doUpdatePassword(

                         String pwd,

                         String newPwd,

                         String cfgPwd) {

                 sysUserService.updatePassword(pwd, newPwd, cfgPwd);

                 return new JsonResult("update ok");

}

修改密码客户端：

第一步：对保存和取消按钮进行事件注册，关键代码如下：

  $(function(){

           $(".box-footer")

           .on("click",".btn-cancel",doCancel)

           .on("click",".btn-save",doUpdateObject)

   });

第二步：定义保存和取消事件处理函数，关键代码如下：

function doCancel(){

           $("#mainContentId").html("");

   }

 function doUpdateObject(){

           //1.获取用户提交数据

           var params={pwd:$("#pwdId").val(),

                      newPwd:$("d").val(),

                      cfgPwd:$("#cfgPwdId")#newPwdI.val()

           }

           //2.定义请求的url

           var url="user/doUpdatePassword"

           //3.异步提交请求,执行更新操作

           $.post(url,params,function(result){

                        alert(result.message);

           })

   }