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

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

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

1.2Shiro核心对象配置
第一步:创建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("/modules/**","anon");
		 map.put("/dist/**","anon");
		 map.put("/plugins/**","anon");
		 //除了匿名访问的资源,其它都要认证("authc")后访问
		 map.put("/**","authc");
		 sfBean.setFilterChainDefinitionMap(map);
		 return sfBean;
	 }

2具体业务
当服务端拦截到用户请求以后,判定此请求是否已经被认证,假如没有认证应该先跳转到登录页面。
2.1前端
在/templates/pages/添加一个login.html页面,然后将项目部署到web服务器,并启动测试运行
2.2后台
第一步：在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("/modules/**","anon");
		 map.put("/dist/**","anon");
		 map.put("/plugins/**","anon");
		 //除了匿名访问的资源,其它都要认证("authc")后访问
		 map.put("/**","authc");
		 sfBean.setFilterChainDefinitionMap(map);
		 return sfBean;
}

三Shiro框架认证业务实现
3.1认证流程分析

1. 系统调用subject的login方法将用户信息提交给SecurityManager
2. SecurityManager将认证操作委托给认证器对象Authenticator
3. Authenticator将用户输入的身份信息传递给Realm。
4. Realm访问数据库获取用户信息然后对信息进行封装并返回。
5. Authenticator 对realm返回的信息进行身份认证。
   3.2具体业务
   前端
   点击登录操作时,将输入的用户名,密码异步提交到服务端。

$(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);
		  }
	  });
  }

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

SysUser findUserByUserName(String username)

3.2.3 Mapper元素定义

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

service层
第一步：定义ShiroUserRealm类，关键代码如下：

package com.cy.pj.sys.service.realm;
@Service
public class ShiroUserRealm extends AuthorizingRealm {

	@Autowired
	private SysUserDao sysUserDao;
		
	/**
	 * 设置凭证匹配器(与用户添加操作使用相同的加密算法)
	 */
	@Override
	public void setCredentialsMatcher(
	      CredentialsMatcher credentialsMatcher) {
		//构建凭证匹配对象
		HashedCredentialsMatcher cMatcher=
		new HashedCredentialsMatcher();
		//设置加密算法
		cMatcher.setHashAlgorithmName("MD5");
		//设置加密次数
		cMatcher.setHashIterations(1);
		super.setCredentialsMatcher(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
		//6.返回封装结果
		return info;//返回值会传递给认证管理器(后续
		//认证管理器会通过此信息完成认证操作)
	}
    ....
}

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

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

control层
第一步：在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这个路径进行匿名访问的配置，查看如下黄色标记部分的代码:

@Bean
public ShiroFilterFactoryBean shiroFilterFactory (
			 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");                       //authc表示，除了匿名访问的资源,其它都要认证("authc")后才能访问访问
		 map.put("/**","authc");
		 sfBean.setFilterChainDefinitionMap(map);
		 return sfBean;
	 }

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

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

第四步：退出操作配置实现
在SpringShiroConfig配置类中，修改过滤规则

@Bean
public ShiroFilterFactoryBean shiroFilterFactory(
			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")后访问
		 map.put("/**","authc");
		 sfBean.setFilterChainDefinitionMap(map);
		 return sfBean;
	 }

四Shiro框架授权过程实现
其中授权流程分析如下：

1. 系统调用subject相关方法将用户信息(例如isPermitted)递交给SecurityManager。
2. SecurityManager将权限检测操作委托给Authorizer对象。
3. Authorizer将用户信息委托给realm。
4. Realm访问数据库获取用户权限信息并封装。
5. Authorizer对用户授权信息进行判定。
   添加授权配置：
   配置advisor对象,shiro框架底层会通过此对象的matchs方法返回值(类似切入点)决定是否创建代理对象,进行权限控制。

@Bean
public AuthorizationAttributeSourceAdvisor
authorizationAttributeSourceAdvisor (
	    		    SecurityManager securityManager) {
		        AuthorizationAttributeSourceAdvisor advisor=
				new AuthorizationAttributeSourceAdvisor();
advisor.setSecurityManager(securityManager);
	return advisor;
}说明:使用框架最重要的尊重规则,框架规则指定了什么方式就使用什么方式。

service层：修改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”)
说明：此要注解一定要添加到业务层方法上。
dao层
第一步：在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>

五Shiro扩展功能应用
1Shiro缓存配置
当我们进行授权操作时,每次都会从数据库查询用户权限信息,为了提高授权性能,可以将用户权限信息查询出来以后进行缓存,下次授权时从缓存取数据即可。
Shiro中内置缓存应用实现,其步骤如下:
第一步:在SpringShiroConfig中配置缓存Bean对象(Shiro框架提供)。

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

说明:这个CacheManager对象的名字不能写cacheManager,因为spring容器中已经存在一个名字为cacheManager的对象了.
第二步:修改securityManager的配置，将缓存对象注入给SecurityManager对象。

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

说明:对于shiro框架而言,还可以借助第三方的缓存产品(例如redis)对用户的权限信息进行cache操作.
2Shiro记住我
前端js：修改login.html中的代码

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;//防止刷新时重复提交
	  });
  }

后台
第一步:在SysUserController中的doLogin方法中基于是否选中记住我，设置token的setRememberMe方法。

@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对象。

 @Bean
	 public SecurityManager securityManager(
			Realm realm,CacheManager cacheManager
RememberMeManager rememberManager) {
		 DefaultWebSecurityManager sManager=
		 new DefaultWebSecurityManager();
		 sManager.setRealm(realm);
		 sManager.setCacheManager(cacheManager);
		 sManager.setRememberMeManager(rememberManager);
		 return sManager;
	 }

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

@Bean
	 public ShiroFilterFactoryBean shiroFilterFactory(
			 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");//自动查LoginUrl
		 //除了匿名访问的资源,其它都要认证("authc")后访问
		 map.put("/**","user");//authc
		 sfBean.setFilterChainDefinitionMap(map);
		 return sfBean;
	 }

3Shiro会话时长配置
使用shiro框架实现认证操作,用户登录成功会将用户信息写入到会话对象中,其默认时长为30分钟,假如需要对此进行配置,可参考如下配置:
第一步：在SpringShiroConfig类中，添加会话管理器配置。关键代码如下：

@Bean   
public SessionManager sessionManager() {
		 DefaultWebSessionManager sManager=
				 new DefaultWebSessionManager();
		 sManager.setGlobalSessionTimeout(60*60*1000);
		 return sManager;
}

第二步：在SpringShiroConfig配置类中，对安全管理器 securityManager 增加 sessionManager值的注入，关键代码如下：

@Bean
public SecurityManager securityManager(
			Realm realm,CacheManager cacheManager,
RememberMeManager rememberManager,
SessionManager sessionManager) {
		 DefaultWebSecurityManager sManager=
		 new DefaultWebSecurityManager();
		 sManager.setRealm(realm);
		 sManager.setCacheManager(cacheManager);
		 sManager.setRememberMeManager(rememberMeManager);
		 sManager.setSessionManager(sessionManager);
		 return sManager;
}

4相关业务实现
4.1用户名动态化呈现
第一步：定义一个工具类(ShiroUtils)，获取用户登陆信息

package com.cy.pj.common.util;
import org.apache.shiro.SecurityUtils;
import com.cy.pj.sys.entity.SysUser;
public class ShiroUtils {
	  public static String getUsername() {
		  return getUser().getUsername();
	  }
	  public static SysUser getUser() {
		  return  (SysUser)
           SecurityUtils.getSubject().getPrincipal();
	  }
}

第二步：修改PageController中的doIndexUI方法，代码如下：

@RequestMapping("doIndexUI")
	public String doIndexUI(Model model) {
		SysUser user=ShiroUtils.getUser();
		model.addAttribute("user",user);
		return "starter";
	}

第三步：借助thymeleaf中的表达式直接在页面上(starter.html)获取登陆用户信息

<span class="hidden-xs" id="loginUserId">[[${user.username}]]</span>