认证和授权的概念
认证：系统提供的用于识别用户身份的功能，通常登录功能就是认证功能-----让系统知道你是谁？？
授权：系统授予用户可以访问哪些功能的许可（证书）----让系统知道你能做什么？？
shiro框架的简单介绍
shiro框架的核心功能有四大部分：认证、授权、会话管理和加密。
认证流程如下：


其中，Application Code:应用程序代码，开发人员负责
Subject：框架提供的接口，代表当前用户对象。
SecurityManager：框架提供的接口，代表安全管理器对象。
Realm：可以开发人员编写，框架也可以提供，类似dao。


Maven项目中shiro框架的应用：
1，首先引入shiro框架的相关jar:
<dependency>
    <gruopId>org.apache.shiro</groupId>

    <artifactId>shiro-all</artifactId>

    <version>1.2.2</version>

<dependcy>
2，在web.xml中配置spring框架提供的用于整合shiro框架的过滤器
<!-- 配置spring框架提供的用于整合shiro框架的过滤器 -->    --------------必须在struts2过滤器之前
  <filter>
   <filter-name>shiroFilter</filter-name>
   <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
  </filter>
  <filter-mapping>
   <filter-name>shiroFilter</filter-name>
   <url-pattern>/*</url-pattern>

  </filter-mapping>
3，在spring配置文件中配置bean，id为shiroFilter
<!-- 配置shiro框架的过滤器工厂对象 -->
 <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
 <!-- 注入安全管理器对象 -->
 <property name="securityManager" ref="securityManager"/>
 <!-- 注入相关页面访问URL -->
 <property name="loginUrl" value="/login.jsp"/>                 登录页面
 <property name="successUrl" value="/index.jsp"/>                认证成功页面
 <property name="unauthorizedUrl" value="/unauthorized.jsp"/>    权限不足的页面
 <!--注入URL拦截规则 -->
 <property name="filterChainDefinitions">
 <value>
 /css/** = anon                            （anon:匿名访问，不登录也能访问，authc是拦截所有请求）              
 /js/** = anon
 /easyUI/** = anon
 /images/** = anon
 /validatecode.jsp* = anon                  （验证码生成的jsp）
 /login.jsp = anon
 /userAction_login = anon
 /page_base_staff.action = perms["staff-list"]    (perms:检查权限的过滤器，没有跳转权限不足页面)
 /* = authc
 </value>
 </property>

 </bean>
        <!-- 注册安全管理器对象 -->
 <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
 <property name="realm" ref="bosRealm"/>
 <property name="cacheManager" ref="cacheManager"></property>
 </bean> 
 <!-- 注册缓存器对象 -->
 <bean id="cacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">
 <!-- 注册ehcache配置文件 --> 
 <property name="cacheManagerConfigFile" value="classpath:ehcache.xml"></property>
 </bean> 
 <!-- 注册自定义的realm -->
 <bean id="bosRealm" class="xxx.BOSRealm">

 </bean>
4，在登陆的servlet/action/controller中修改登录方法：
/ 用户登录功能
 public String login() throws Exception {
// 1,接受页面参数
// 从域中获得验证码
 String key = (String) ActionContext.getContext().getSession().get("key");
// 判断验证码是否正确
 if(key.equals(checkcode) && StringUtils.isNotBlank(checkcode)){
// 验证码正确，获得当前登录用户对象
 Subject subject = SecurityUtils.getSubject();
// 用户密码令牌
 AuthenticationToken token = new UsernamePasswordToken(model.getUsername(),   MD5Utils.md5(model.getPassword()));               ------------用传进来的username和password生成token
 try {
 subject.login(token);
 User user = (User) subject.getPrincipal();
 ServletActionContext.getRequest().getSession().setAttribute("user", user);
 return "toIndex";
 } catch (Exception e) { 
 this.addActionError("您输入的账号或密码有误");
 return "login";
 }
 }else{
 this.addActionError("您输入的验证码有误");
 return "login";
 }

 }


5，realm代码的编写：

public class BOSRealm extends AuthorizingRealm{
 @Autowired
 private IUserDao userDao;
 //认证方法
 protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
 UsernamePasswordToken mytoken = (UsernamePasswordToken)token;             --------------上文生成的token
 String username = mytoken.getUsername();
 //根据用户名查询数据库中的密码
 User user = userDao.findUserByUserName(username);
 if(user == null){
 //用户名不存在
 return null;
 }
 //如果能查询到，再由框架比对数据库中查询到的密码和页面提交的密码是否一致
 AuthenticationInfo info = new SimpleAuthenticationInfo(user, user.getPassword(), this.getName());
 return info;                                            -----------第一个传的是user，上文就可以取出user放到session
 }
 //授权方法
 protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
 // TODO Auto-generated method stub
 return null;
 }

最近在做SSM（SpringMVC+Shiro+MyBatis）整合的一个项目，对于shiro的配置不是特别熟练，于是想要写下来，加深一下印象。在有SpringMVC+MyBatis配置的基础上整合shiro：
 首先进入shiro的官方网站（http://shiro.apache.org/），如下图所示（图中有提示下一步怎么操作）：
 点击Download进入到下面这个页面：
 
 向下拖动，可以看到shiro的相关依赖，添加四个依赖到（pom.xml）中：分别是shiro-core、shiro-spring、shiro-web、shiro-ehcache，
 
 
 这里我把我的依赖给弄下来（pom.xml）：
 
			<!-- Shiro -->
			<dependency>
				<groupId>org.apache.shiro</groupId>
				<artifactId>shiro-core</artifactId>
				<version>1.3.2</version>
			</dependency>
 
			<dependency>
				<groupId>org.apache.shiro</groupId>
				<artifactId>shiro-web</artifactId>
				<version>1.3.2</version>
			</dependency>
 
			<dependency>
				<groupId>org.apache.shiro</groupId>
				<artifactId>shiro-spring</artifactId>
				<version>1.3.2</version>
			</dependency>
 
			<dependency>
				<groupId>org.apache.shiro</groupId>
				<artifactId>shiro-ehcache</artifactId>
				<version>1.3.2</version>
			</dependency>

 
添加完依赖之后，开始配置：
 
 
依次如图所示，找到有配置信息的页面:
 
 
进入到配置文件（Web-configuration）：
 
 点击上图指示的地方，进入到下一个页面：
 
 进入到这里，可以开始配置了：
 
 
如图中所示，配置文件：
 
 
 
 我现在我把我配置的信息给复制过来，方便大家直接复制：
 
这是applicationContext.xml里的配置，但是我是将有关shiro的配置单独放在一个xml文件中（application_shiro.xml），我个人觉得这样更容易区分：
 
<code class="language-java"><?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
	<!--第一步：直接配置一个 securityManager -->

	<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
		

<!--刚配置时，先把这条注释掉，等后面写了MyRealm.java时，再把它的注释去掉，因为如果没有去掉就会在
tomcat开启时报一个错误 -->

<!--<property name="realm" ref="myRealm" /> -->

</bean>
<bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor" />
<!-- 第三步：把请求路径拦截之后的处理 -->
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
<!--shiro整个的处理，都由securityManger指定和决定 -->
<property name="securityManager" ref="securityManager" />
<!-- loginUrl==>如果登录成功，跳转到哪个页面，或者执行哪个请求 -->
<property name="loginUrl" value="/login.jsp" />
<!-- 验证通过执行的请求或者跳转 -->
<property name="successUrl" value="/home.jsp" />
<!-- 验证不通过执行的请求或者跳转 -->
<property name="unauthorizedUrl" value="/unauthorized.jsp" />
<!-- 具体的拦截路径和拦截的方式和角色和权限的范围 -->
<property name="filterChainDefinitions">
<value>
</value>
</property>
</bean>
</beans>

接着配置web.xml:

</code>
 
<!-- 第二步：服务器启动时，加载shiro的配置文件  --> 
 <filter> 
    <filter-name>shiroFilter</filter-name> 
       <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class> 
          <init-param>       
                 <param-name>targetFilterLifecycle</param-name>   
                <param-value>true</param-value>  
           </init-param></filter><!-- 拦截所有的请求路径 --><filter-mapping>
         <filter-name>shiroFilter</filter-name>  
         <url-pattern>/*</url-pattern>
     </filter-mapping><!-- 还有一个地方要注意，因为我是单独把shiro写在一个xml文件中，新加了一个文件，所以要添加路径 -->
     <context-param>  
     	<param-name>contextConfigLocation</param-name>  
     		<param-value>  		classpath:applicationContext.xml  		classpath:application_shiro.xml  	</param-value>
     		  </context-param>
 
然后再是spring_mvc.xml(添加注解功能):
 
<code class="language-java"><!-- 配置启用Shiro的注解功能 -->
	<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" 
		depends-on="lifecycleBeanPostProcessor">
		<property name="proxyTargetClass" value="true"></property>
	</bean>
		
    <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
	    <property name="securityManager" ref="securityManager"/>
	</bean></code>
 
配置文件完成，开启tomcat，成功开启（出现如图所示的红线部分，说明配置shiro成功）：
 
 
配置成功后，可以开始写代码了。

登录认证
 
一、添加pom依赖
 
 
 
<!-- Shiro -->
<dependency>
  <groupId>commons-logging</groupId>
  <artifactId>commons-logging</artifactId>
  <version>1.2</version>
</dependency>
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-nop</artifactId>
  <version>1.7.24</version>
</dependency>
<dependency>
  <groupId>commons-collections</groupId>
  <artifactId>commons-collections</artifactId>
  <version>3.2.1</version>
</dependency>
<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-core</artifactId>
  <version>1.4.0</version>
</dependency>
<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-web</artifactId>
  <version>1.4.0</version>
</dependency>
<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-ehcache</artifactId>
  <version>1.4.0</version>
</dependency>
<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-spring</artifactId>
  <version>1.4.0</version>
</dependency>
 
二、登录拦截,如果没有登录,跳转到登录页面
 
1.在web.xml当中配置过滤器拦截所有请求，进行处理
 
 
 
<!-- 拦截到所有请求,使用spring一个bean来进行处理 -->
<filter>
  <filter-name>shiroFilter</filter-name>
  <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
  <!-- 是否filter中的init和 destroy-->
  <init-param>
    <param-name>targetFilterLifecycle</param-name>
    <param-value>true</param-value>
  </init-param>
</filter>

<filter-mapping>
  <filter-name>shiroFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>
 
2.在Spring当中配置shiro过滤器和安全管理器
 
 
 
<!-- 配置shiro过滤器 -->
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
    <property name="securityManager" ref="securityManager"></property>

    <!-- 配置shiro过滤器pattern -->
    <property name="filterChainDefinitions">
        <value>
            /static/** = anon   <!-- 不需要登录验证 -->
            /login.jsp = anon   <!-- 不需要登录验证 -->
           /**=authc     <!-- 除指定请求外,其它所有的请求都需要身份验证 -->
        </value>
    </property>
</bean>

<!-- 配置shiro安全管理器 -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager"></bean>
 
三、登录认证
 
1.在Shiro过滤器中配置登录认证的路径
 
<!--
    其他请求会判断当前有没有认证过
    默认情况下没有认证,会跳转到login.jsp
    配置了loginUrl，如果没有认证的话，就会执行对应的login请求
    loginUrl：如果发现请求是loginUrl的值，会去做认证
    配置登录认证的路径
 -->
<property name="loginUrl" value="/login" />
 
2.创建登录Realm，创建一个类继承AuthorizingRealm
 
public class EmployeeRealm extends AuthorizingRealm {

    @Autowired
    private EmployeeService employeeService;
    // 认证
    @Override   // 会自动把username和password封装到token里
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        // 获取身份信息
        String username = (String) token.getPrincipal();
        // 到数据库中查询有没有当前用户
        Employee employee = employeeService.getEmployeeWithUsername(username);
        if(employee == null){
            return null;
        }
        // 认证
        // 参数：主体、正确的密码、盐、当前realm名称
        SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(
                employee,
                employee.getPassword(),
                ByteSource.Util.bytes(employee.getUsername()),
                this.getName()
        );
        return info;
    }

    // 授权
    // 1.发现访问路径的方法上面有授权的注解，就会调用这个方法
    // 2.页面当中有授权的标签，也会调用这个方法
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
    
    }
}
 
 3.配置Realm数据源 
 
<!-- 自定义Realm -->
<bean id="employeeRealm" class="pers.liuchengyin.web.realm.EmployeeRealm">
    <property name="credentialsMatcher" ref="credentialsMatcher"></property>
</bean>

<!-- 配置shiro安全管理器 -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
    <!-- 注入realm -->
    <property name="realm" ref="employeeRealm"></property>
    <!-- 注入缓存器 -->
    <property name="cacheManager" ref="ehCache"/>
</bean>
 
4.表单发送登录请求
 
<script>
    $(function () {
       $("#loginBtn").click(function () {
            // Ajax发送的请求，没有办法跳转服务当中的请求，只能通过浏览器当中来跳转
            // 发送请求，做登录认证
           $.post("/login",$("form").serialize(),function (data) {
               // 把data,json格式的字符串转成json 数据
               data = $.parseJSON(data);
               if (data.success){
                   // 跳转到首页
                   window.location.href = "/index.jsp"
               } else {
                   alert(data.msg);
               }
           });
       });
    });
</script>
 
5. 创建表单认证过滤器
 
 
 
public class MyFormFilter extends FormAuthenticationFilter {

    // 认证成功调用
    @Override
    protected boolean onLoginSuccess(AuthenticationToken token, Subject subject, ServletRequest request, ServletResponse response) throws Exception {
        // 响应给浏览器
        response.setCharacterEncoding("utf-8");
        AjaxRes ajaxRes = new AjaxRes();
        ajaxRes.setMsg("登陆成功");
        ajaxRes.setSuccess(true);
        // 把对象转成Json格式的字符串
        String jsonString = new ObjectMapper().writeValueAsString(ajaxRes);
        response.getWriter().print(jsonString);
        return false;
    }

    // 认证失败调用
    @Override
    protected boolean onLoginFailure(AuthenticationToken token, AuthenticationException e, ServletRequest request, ServletResponse response) {
        // 响应给浏览器
        AjaxRes ajaxRes = new AjaxRes();
        ajaxRes.setSuccess(false);
        if(e != null){
            // 获取异常的名称
            String name = e.getClass().getName();
            if(name.equals(UnknownAccountException.class.getName())){
                // 没有这个账号
                ajaxRes.setMsg("账号不正确");
            }else if(name.equals(IncorrectCredentialsException.class.getName())){
                // 密码错误
                ajaxRes.setMsg("密码不正确");
            }else{
                // 未知异常
                ajaxRes.setMsg("未知错误");
            }
        }
        try {
            String jsonString = new ObjectMapper().writeValueAsString(ajaxRes);
            response.setCharacterEncoding("utf-8");
            response.getWriter().print(jsonString);
        } catch (IOException e1) {
            e1.printStackTrace();
        }
        return false;
    }
}
 
6.重新配置过滤器
 
<!-- 自定义的过滤器 -->
<bean id="myFormFilter" class="pers.liuchengyin.web.filter.MyFormFilter"/>
 
 
 
<!-- 配置shiro过滤器 -->
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
    <!-- 配置表单监听的过滤器 -->
    <property name="filters">
        <map>
            <entry key="authc" value-ref="myFormFilter"></entry>
        </map>
    </property>
 
 
 
 
 
需要注意的是，Ajax发送的请求没有办法跳转服务当中的请求，只能通过浏览器自己来跳转。
 
 
 
 
 
 
 
 
 
 

一、认识Shiro
 
 
二、代码结构
 
1、代码目录：
 
 
2、pom.xml所有的依赖：
 
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.lyd.shiro</groupId>
  <artifactId>Shiro01</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>Shiro01</name>
  <description>Shiro01</description>
  <build>
    <defaultGoal>compile</defaultGoal>
  </build>
  <dependencies>
	<!-- Shiro核心包 -->
	<dependency>
		<groupId>org.apache.shiro</groupId>
		<artifactId>shiro-core</artifactId>
		<version>1.3.2</version>
	</dependency>
	<!-- slf4j的接口实现 -->
	 <dependency>
		<groupId>org.slf4j</groupId>
		<artifactId>slf4j-log4j12</artifactId>
		<version>1.7.12</version>
	</dependency>
    
  </dependencies>
</project>
 
3、定义shiro.ini文件，主要是存放账户号码以及对应的密码，用于测试：
 
[users]
lyd=123456
jack=666666
 
4、配置日志信息的打印，使用slf4j：
 
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
#
log4j.rootLogger=INFO, stdout

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m %n

# General Apache libraries
log4j.logger.org.apache=WARN

# Spring
log4j.logger.org.springframework=WARN

# Default Shiro logging
log4j.logger.org.apache.shiro=TRACE

# Disable verbose logging
log4j.logger.org.apache.shiro.util.ThreadContext=WARN
log4j.logger.org.apache.shiro.cache.ehcache.EhCache=WARN
 
5、定义测试方法：
 
package com.lyd.shiro;

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.util.Factory;

public class ShiroDemo {

	public static void main(String[] args) {
		//读取配置文件，初始化shiroManger工厂
		Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro.ini");
		//工厂模式,获得securityManager实例对象
		SecurityManager securityManager = factory.getInstance();
		//将securityManger实例绑定到SecurityUtils
		SecurityUtils.setSecurityManager(securityManager);
		//获取当前执行的用户
		Subject currentUser = SecurityUtils.getSubject();
		//创建token令牌，用户名/密码
		UsernamePasswordToken token = new UsernamePasswordToken("lyd","12322");
		try {
			//当前用户登录
			currentUser.login(token);
			System.out.println("身份验证成功！");
		}catch(org.apache.shiro.authc.AuthenticationException e){
			e.printStackTrace();
			System.out.println("身份认证失败！");
		}
		//退出
		currentUser.logout();
	}
}
 
6、测试结果 ：
 
（1）错误的验证信息：
 
2018-06-03 19:05:45,207 DEBUG [org.apache.shiro.authc.credential.SimpleCredentialsMatcher] - Both credentials arguments can be easily converted to byte arrays.  Performing array equals comparison 
org.apache.shiro.authc.IncorrectCredentialsException: Submitted credentials for token [org.apache.shiro.authc.UsernamePasswordToken - lyd, rememberMe=false] did not match the expected credentials.
	at org.apache.shiro.realm.AuthenticatingRealm.assertCredentialsMatch(AuthenticatingRealm.java:600)
	at org.apache.shiro.realm.AuthenticatingRealm.getAuthenticationInfo(AuthenticatingRealm.java:578)
	at org.apache.shiro.authc.pam.ModularRealmAuthenticator.doSingleRealmAuthentication(ModularRealmAuthenticator.java:180)
	at org.apache.shiro.authc.pam.ModularRealmAuthenticator.doAuthenticate(ModularRealmAuthenticator.java:267)
	at org.apache.shiro.authc.AbstractAuthenticator.authenticate(AbstractAuthenticator.java:198)
	at org.apache.shiro.mgt.AuthenticatingSecurityManager.authenticate(AuthenticatingSecurityManager.java:106)
	at org.apache.shiro.mgt.DefaultSecurityManager.login(DefaultSecurityManager.java:270)
	at org.apache.shiro.subject.support.DelegatingSubject.login(DelegatingSubject.java:256)
	at com.lyd.shiro.ShiroDemo.main(ShiroDemo.java:25)
身份认证失败！
2018-06-03 19:05:45,209 TRACE [org.apache.shiro.subject.support.DelegatingSubject] - attempting to get session; create = false; session is null = true; session has id = false 
 
（2）正确的验证信息：
 
2018-06-03 19:19:29,347 TRACE [org.apache.shiro.subject.support.DelegatingSubject] - attempting to get session; create = false; session is null = false; session has id = true 
身份验证成功！
2018-06-03 19:19:29,347 TRACE [org.apache.shiro.subject.support.DelegatingSubject] - attempting to get session; create = false; session is null = false; session has id = true 
 
三、问题
 
首次运行编译的时候遇到slf4j的版本不兼容问题，报错信息如下：
 
 
原因是版本不兼容，解决方式是降低版本。