shiro 框架基本讲解

关注公众号 资源自由分享 回复 shiro 领取视频教程

什么是权限管理：

• • • 基本上涉及到用户参与的系统都要进行权限管理，权限管理属于系统安全的范畴，权限管理实现对用户访问系统的控制，按照安全规则或者安全策略控制用户可以访问而且只能访问自己被授权的资源。
    • 权限管理包括用户身份认证和授权两部分，简称认证授权。对于需要访问控制的资源用户首先经过身份认证，认证通过后用户具有该资源的访问权限访问

 用户身份认证：

• • • 身份认证，就是判断一个用户是否为合法用户的处理过程。最常用的简单身份认证方式是系统通过核对用户输入的用户名和口令，看其是否与系统中存储的该用户的用户名和口令一致，来判断用户身份是否正确。对于采用指纹等系统，则出示指纹；对于硬件Key等刷卡系统，则需要刷卡

      用户名密码身份认证流程：

 关键对象：

       上边的流程图中需要理解以下关键对象：

        Subject：主体：访问系统的用户，主体可以是用户、程序等，进行认证的都称为主体；

        Principal：身份信息：是主体（subject）进行身份认证的标识，标识必须具有唯一性，如用户名、手机号、邮箱地址等，一个主体可以有多个身份，但是必须有一个主身份（Primary Principal）。

        credential：凭证信息：是只有主体自己知道的安全信息，如密码、证书等。

       授权：

       授权，即访问控制，控制谁能访问哪些资源。主体进行身份认证后需要分配权限方可访问系统的资源，对于某些资源没有权限是无法访问的

       授权流程：

        关键对象：

               授权可简单理解为who对what(which)进行How操作

ho：即主体（Subject），主体需要访问系统中的资源。

What：即资源（Resource），如系统菜单、页面、按钮、类方法、系统商品信息等。资源包括资源类型和资源实例，比如商品信息为资源类型，类型为t01的商品为资源实例，编号为001的商品信息也属于资源实例。

How：权限/许可（Permission），规定了主体对资源的操作许可，权限离开资源没有意义，如用户查询权限、用户添加权限、某个类方法的调用权限、编号为001用户的修改权限等，通过权限可知主体对哪些资源都有哪些操作许可。权限分为粗颗粒和细颗粒，粗颗粒权限是指对资源类型的权限，细颗粒权限是对资源实例的权限。

主体、资源、权限关系如下图：

权限模型：

         对上节中的主体、资源、权限通过数据模型表示：

主体（账号、密码）、资源（资源名称、访问地址）、权限（权限名称、资源id）、角色（角色名称）、角色和权限关系（角色id、权限id）、主体和角色关系（主体id、角色id）

如下图：

 

         权限分配：

                   对主体分配权限，主体只允许在权限范围内对资源进行操作，比如：对u01用户分配商品修改权限，u01用户只能对商品进行修改。

                  通常需要持久化，根据上边的数据模型创建表并将用户的权限信息存储在数据库中

         权限控制：

                 用户拥有了权限即可操作权限范围内的资源，系统不知道主体是否具有访问权限需要对用户的访问进行控制

以上是对权限的基本讲解。下面开始真正的学习shiro

shiro介绍

 什么是shiro 

Shiro是apache旗下一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。

 为什么要学shiro 

既然shiro将安全认证相关的功能抽取出来组成一个框架，使用shiro就可以非常快速的完成认证、授权等功能的开发，降低系统成本。
shiro使用广泛，shiro可以运行在web应用，非web应用，集群分布式应用中越来越多的用户开始使用shiro。
java领域中spring security(原名Acegi)也是一个开源的权限管理框架，但是spring security依赖spring运行，而shiro就相对独立，最主要是因为shiro使用简单、灵活，所以现在越来越多的用户选择shiro。

shiro 的架构：

subject :

Subject即主体，外部应用与subject进行交互，subject记录了当前操作用户，将用户的概念理解为当前操作的主体，可能是一个通过浏览器请求的用户，也可能是一个运行的程序。        
Subject在shiro中是一个接口，接口中定义了很多认证授相关的方法，外部程序通过subject进行认证授，而subject是通过SecurityManager安全管理器进行认证授权

SecurityManager :

SecurityManager即安全管理器，对全部的subject进行安全管理，它是shiro的核心，负责对所有的subject进行安全管理。通过SecurityManager可以完成subject的认证、授权等，
实SecurityManager是通过Authenticator进行认证，通过Authorizer进行授权，通过SessionManager进行会话管理等。SecurityManager是一个接口，继承了Authenticator, Authorizer, 
SessionManager这三个接口。

Authenticator：

Authenticator即认证器，对用户身份进行认证，Authenticator是一个接口，shiro提供 ModularRealmAuthenticator实现类，通过ModularRealmAuthenticator基本上可以满足大多数需求，也可以自定义认证器。

Authorizer ：

Authorizer即授权器，用户通过认证器认证通过，在访问功能时需要通过授权器判断用户是否有此功能的操作权限。

realm ： 

Realm即领域，相当于datasource数据源，securityManager进行安全认证需要通过Realm获取用户权限数据，比如：如果用户身份数据在数据库那么realm就需要从数据库获取用户身份信息。
注意：不要把realm理解成只是从数据源取数据，在realm中还有认证授权校验的相关的代码。　

sessionManager ：

sessionManager即会话管理，shiro框架定义了一套会话管理，它不依赖web容器的session，所以shiro可以使用在非web应用上，也可以将分布式应用的会话集中在一点管理，此特性可使它实现单点登录。

SessionDAO ：

SessionDAO即会话dao，是对session会话操作的一套接口，比如要将session存储到数据库，可以通过jdbc将会话存储到数据库。

CacheManager ：

CacheManager即缓存管理，将用户权限数据存储在缓存，这样可以提高性能。

Cryptography ：

Cryptography即密码管理，shiro提供了一套加密/解密的组件，方便开发。比如提供常用的散列、加/解密等功能。

　　shiro的jar包 ：

<dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version>1.2.3</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-web</artifactId>
            <version>1.2.3</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.2.3</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-ehcache</artifactId>
            <version>1.2.3</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-quartz</artifactId>
            <version>1.2.3</version>
        </dependency>

也可以通过引入shiro-all包括shiro所有的包：

<dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-all</artifactId>
            <version>1.2.3</version>
        </dependency>

shiro认证

认证流程：

       入门程序：

1、创建普通的java 工程项目

2、导入jar 包

3、使用log4j.properties日志配置文件输出日志

log4j.rootLogger=debug, 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

4、使用shiro.ini 文件 【通过Shiro.ini配置文件初始化SecurityManager环境】

      配置 eclipse支持ini文件编辑：

     在eclipse配置后，在classpath创建shiro.ini配置文件，为了方便测试将用户名和密码配置的shiro.ini配置文件中：

[users]
zhang=123
lisi=123

认证代码：

     // 用户登陆、用户退出
    @Test
    public void testLoginLogout() {
        // 构建SecurityManager工厂，IniSecurityManagerFactory可以从ini文件中初始化SecurityManager环境
        Factory<SecurityManager> factory = new IniSecurityManagerFactory(
                "classpath:shiro.ini");
        // 通过工厂创建SecurityManager
        SecurityManager securityManager = factory.getInstance();     
        // 将securityManager设置到运行环境中
        SecurityUtils.setSecurityManager(securityManager);
        // 创建一个Subject实例，该实例认证要使用上边创建的securityManager进行
        Subject subject = SecurityUtils.getSubject();
        // 创建token令牌，记录用户认证的身份和凭证即账号和密码 
        UsernamePasswordToken token = new UsernamePasswordToken("zhang", "123");
        try {
            // 用户登陆
            subject.login(token);
        } catch (AuthenticationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        // 用户认证状态
        Boolean isAuthenticated = subject.isAuthenticated();
        System.out.println("用户认证状态：" + isAuthenticated);

        // 用户退出
        subject.logout();
        isAuthenticated = subject.isAuthenticated();
        System.out.println("用户认证状态：" + isAuthenticated);
    }

 

认证执行流程 ：

1、  创建token令牌，token中有用户提交的认证信息即账号和密码

2、  执行subject.login(token)，最终由securityManager通过Authenticator进行认证

3、  Authenticator的实现ModularRealmAuthenticator调用realm从ini配置文件取用户真实的账号和密码，这里使用的是IniRealm（shiro自带）

4、  IniRealm先根据token中的账号去ini中找该账号，如果找不到则给ModularRealmAuthenticator返回null，如果找到则匹配密码，匹配密码成功则认证通过。

以上程序使用的是Shiro自带的IniRealm，IniRealm从ini配置文件中读取用户的信息，大部分情况下需要从系统的数据库中读取用户信息，所以需要自定义realm

shiro提供的realm 如下图：

 

最基础的是Realm接口，CachingRealm负责缓存处理，AuthenticationRealm负责认证，AuthorizingRealm负责授权，通常自定义的realm继承AuthorizingRealm

 自定义Realm 代码如下：

public class CustomRealm1 extends AuthorizingRealm {

    @Override
    public String getName() {
        return "customRealm1";
    }

    //支持UsernamePasswordToken
    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof UsernamePasswordToken;
    }

    //认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(
            AuthenticationToken token) throws AuthenticationException {
        
        //从token中 获取用户身份信息
        String username = (String) token.getPrincipal();
        //拿username从数据库中查询
        //....
        //如果查询不到则返回null
        if(!username.equals("zhang")){//这里模拟查询不到
            return null;
        }
        
        //获取从数据库查询出来的用户密码 
        String password = "123";//这里使用静态数据模拟。。
        
        //返回认证信息由父类AuthenticatingRealm进行认证
        SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(
                username, password, getName());

        return simpleAuthenticationInfo;
    }

    //授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(
            PrincipalCollection principals) {
        // TODO Auto-generated method stub
        return null;
    }
}

同时需要创建shiro-realm.ini 文件：

[main]
#自定义 realm
customRealm=cn.itcast.shiro.authentication.realm.CustomRealm1
#将realm设置到securityManager
securityManager.realms=$customRealm

测试代码同入门程序，将ini的地址修改为shiro-realm.ini

 一般来说密码需要  加密 可以选择MD5加密方式这里就不详细说明。

shiro授权

授权流程 图：

授权方式 ：

Shiro 支持三种方式的授权：
    编程式：通过写if/else 授权代码块完成：
Subject subject = SecurityUtils.getSubject();
if(subject.hasRole(“admin”)) {
//有权限
} else {
//无权限
}
    注解式：通过在执行的Java方法上放置相应的注解完成：
@RequiresRoles("admin")
public void hello() {
//有权限
}
    JSP/GSP 标签：在JSP/GSP 页面通过相应的标签完成：
<shiro:hasRole name="admin">
<!— 有权限—>
</shiro:hasRole>

授权测试 ：

1、创建存放权限的配置文件shiro-permission.ini，如下：

[users]
#用户zhang的密码是123，此用户具有role1和role2两个角色
zhang=123,role1,role2
wang=123,role2

[roles]
#角色role1对资源user拥有create、update权限
role1=user:create,user:update
#角色role2对资源user拥有create、delete权限
role2=user:create,user:delete
#角色role3对资源user拥有create权限
role3=user:create

 注意：在ini文件中用户、角色、权限的配置规则是：“用户名=密码，角色1，角色2...” “角色=权限1，权限2...”，首先根据用户名找角色，再根据角色找权限，角色是权限集合

权限字符串规则：

权限字符串的规则是：“资源标识符：操作：资源实例标识符”，意思是对哪个资源的哪个实例具有什么操作，“:”是资源/操作/实例的分割符，权限字符串也可以使用*通配符。

例子：
用户创建权限：user:create，或user:create:*
用户修改实例001的权限：user:update:001
用户实例001的所有权限：user：*：001

测试代码如下：

@Test
    public void testPermission() {

        // 从ini文件中创建SecurityManager工厂
        Factory<SecurityManager> factory = new IniSecurityManagerFactory(
                "classpath:shiro-permission.ini");

        // 创建SecurityManager
        SecurityManager securityManager = factory.getInstance();

        // 将securityManager设置到运行环境
        SecurityUtils.setSecurityManager(securityManager);

        // 创建主体对象
        Subject subject = SecurityUtils.getSubject();

        // 对主体对象进行认证
        // 用户登陆
        // 设置用户认证的身份(principals)和凭证(credentials)
        UsernamePasswordToken token = new UsernamePasswordToken("zhang", "123");
        try {
            subject.login(token);
        } catch (AuthenticationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        // 用户认证状态
        Boolean isAuthenticated = subject.isAuthenticated();

        System.out.println("用户认证状态：" + isAuthenticated);

        // 用户授权检测 基于角色授权
        // 是否有某一个角色
        System.out.println("用户是否拥有一个角色：" + subject.hasRole("role1"));
        // 是否有多个角色
        System.out.println("用户是否拥有多个角色：" + subject.hasAllRoles(Arrays.asList("role1", "role2")));
        
//        subject.checkRole("role1");
//        subject.checkRoles(Arrays.asList("role1", "role2"));

        // 授权检测，失败则抛出异常
        // subject.checkRole("role22");

        // 基于资源授权
        System.out.println("是否拥有某一个权限：" + subject.isPermitted("user:delete"));
        System.out.println("是否拥有多个权限：" + subject.isPermittedAll("user:create:1",    "user:delete"));
        
        //检查权限
        subject.checkPermission("sys:user:delete");
        subject.checkPermissions("user:create:1","user:delete");
        

    }

注意：测试代码同认证代码，注意ini地址改为shiro-permission.ini，主要学习下边授权的方法；在用户认证通过后执行下边的授权代码

 基于角色的授权：

     // 用户授权检测 基于角色授权
     // 是否有某一个角色
     System.out.println("用户是否拥有一个角色：" + subject.hasRole("role1"));
     // 是否有多个角色
     System.out.println("用户是否拥有多个角色：" + subject.hasAllRoles(Arrays.asList("role1", "role2")));

      //对应的check方法：
      subject.checkRole("role1");
      subject.checkRoles(Arrays.asList("role1", "role2"));

上边check方法如果授权失败则抛出异常：

org.apache.shiro.authz.UnauthorizedException: Subject does not have role [.....]

基于资源授权：

// 基于资源授权
        System.out.println("是否拥有某一个权限：" + subject.isPermitted("user:delete"));
        System.out.println("是否拥有多个权限：" + subject.isPermittedAll("user:create:1",    "user:delete"));
对应的check方法：
subject.checkPermission("sys:user:delete");
subject.checkPermissions("user:create:1","user:delete");

与上边认证自定义realm一样，大部分情况是要从数据库获取权限数据，这里直接实现基于资源的授权

授权自定义 realm 代码  如下：

  直接在认证写的自定义realm类中完善doGetAuthorizationInfo方法，此方法需要完成：根据用户身份信息从数据库查询权限字符串，由shiro进行授权：

// 授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(
            PrincipalCollection principals) {
        // 获取身份信息
        String username = (String) principals.getPrimaryPrincipal();
        // 根据身份信息从数据库中查询权限数据
        //....这里使用静态数据模拟
        List<String> permissions = new ArrayList<String>();
        permissions.add("user:create");
        permissions.add("user.delete");
        
        //将权限信息封闭为AuthorizationInfo
        
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        for(String permission:permissions){
            simpleAuthorizationInfo.addStringPermission(permission);
        }
        
        return simpleAuthorizationInfo;
    }

授权执行流程：

1、  执行subject.isPermitted("user:create")

2、  securityManager通过ModularRealmAuthorizer进行授权

3、  ModularRealmAuthorizer调用realm获取权限信息

4、  ModularRealmAuthorizer再通过permissionResolver解析权限字符串，校验是否匹配

shiro与spring web项目的整合

1、web.xml添加shiro Filter

<!-- shiro过虑器，DelegatingFilterProx会从spring容器中找shiroFilter -->
    <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>

2、applicationContext-shiro.xml

<!-- Shiro 的Web过滤器 -->
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <property name="securityManager" ref="securityManager" />
        <!-- 如果没有认证将要跳转的登陆地址，http可访问的url，如果不在表单认证过虑器FormAuthenticationFilter中指定此地址就为身份认证地址 -->
        <property name="loginUrl" value="/login.action" />
<!-- 没有权限跳转的地址 -->
        <property name="unauthorizedUrl" value="/refuse.jsp" />
<!-- shiro拦截器配置 -->
        <property name="filters">
            <map>
                <entry key="authc" value-ref="formAuthenticationFilter" />
            </map>
        </property>
        <property name="filterChainDefinitions">
            <value>
                <!-- 必须通过身份认证方可访问，身份认 证的url必须和过虑器中指定的loginUrl一致 -->
                /loginsubmit.action = authc
                <!-- 退出拦截，请求logout.action执行退出操作 -->
                /logout.action = logout
                <!-- 无权访问页面 -->
                /refuse.jsp = anon
                <!-- roles[XX]表示有XX角色才可访问 -->
                /item/list.action = roles[item],authc
                /js/** anon
                /images/** anon
                /styles/** anon
                <!-- user表示身份认证通过或通过记住我认证通过的可以访问 -->
                /** = user
                <!-- /**放在最下边，如果一个url有多个过虑器则多个过虑器中间用逗号分隔，如：/** = user,roles[admin] -->

            </value>
        </property>
    </bean>


    <!-- 安全管理器 -->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="realm" ref="userRealm" />
        
    </bean>

    <!-- 自定义 realm -->
    <bean id="userRealm" class="cn.itcast.ssm.realm.CustomRealm1">
    </bean>
    <!-- 基于Form表单的身份验证过滤器，不配置将也会注册此过虑器，表单中的用户账号、密码及loginurl将采用默认值，建议配置 -->
    <bean id="formAuthenticationFilter"
        class="org.apache.shiro.web.filter.authc.FormAuthenticationFilter">
        <!-- 表单中账号的input名称 -->
        <property name="usernameParam" value="usercode" />
        <!-- 表单中密码的input名称 -->
        <property name="passwordParam" value="password" />
        <!-- <property name="rememberMeParam" value="rememberMe"/> -->
        <!-- loginurl：用户登陆地址，此地址是可以http访问的url地址 -->
        <property name="loginUrl" value="/loginsubmit.action" />
    </bean>

注意：

securityManager：这个属性是必须的。
loginUrl：没有登录认证的用户请求将跳转到此地址，不是必须的属性，不输入地址的话会自动寻找项目web项目的根目录下的”/login.jsp”页面。
unauthorizedUrl：没有权限默认跳转的页面。

3、使用shiro注解授权：

在springmvc.xml中配置shiro注解支持，可在controller方法中使用shiro注解配置权限：

<!-- 开启aop，对类代理 -->
    <aop:config proxy-target-class="true"></aop:config>
    <!-- 开启shiro注解支持 -->
    <bean
        class="
org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
        <property name="securityManager" ref="securityManager" />
    </bean>

修改Controller代码，在方法上添加授权注解，如下：

// 查询商品列表
    @RequestMapping("/queryItem")
    @RequiresPermissions("item:query")
    public ModelAndView queryItem() throws Exception {
           。。。。。。。
    }

上边代码@RequiresPermissions("item:query")表示必须拥有“item:query”权限方可执行

4、重新 自定义realm ：

            此realm先不从数据库查询权限数据，当前需要先将shiro整合完成，在上定义的realm基础上修改：

public class CustomRealm1 extends AuthorizingRealm {

    @Autowired
    private SysService sysService;

    @Override
    public String getName() {
        return "customRealm";
    }

    // 支持什么类型的token
    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof UsernamePasswordToken;
    }

    // 认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(
            AuthenticationToken token) throws AuthenticationException {

        // 从token中 获取用户身份信息
        String username = (String) token.getPrincipal();
        // 拿username从数据库中查询
        // ....
        // 如果查询不到则返回null
        if (!username.equals("zhang")) {// 这里模拟查询不到
            return null;
        }

        // 获取从数据库查询出来的用户密码
        String password = "123";// 这里使用静态数据模拟。。
        
        // 根据用户id从数据库取出菜单
        //...先用静态数据
        List<SysPermission> menus = new ArrayList<SysPermission>();;
        
        SysPermission sysPermission_1 = new SysPermission();
        sysPermission_1.setName("商品管理");
        sysPermission_1.setUrl("/item/queryItem.action");
        SysPermission sysPermission_2 = new SysPermission();
        sysPermission_2.setName("用户管理");
        sysPermission_2.setUrl("/user/query.action");
        
        menus.add(sysPermission_1);
        menus.add(sysPermission_2);
        
        // 构建用户身体份信息
        ActiveUser activeUser = new ActiveUser();
        activeUser.setUserid(username);
        activeUser.setUsername(username);
        activeUser.setUsercode(username);
        activeUser.setMenus(menus);

        // 返回认证信息由父类AuthenticatingRealm进行认证
        SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(
                activeUser, password, getName());

        return simpleAuthenticationInfo;
    }

    // 授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(
            PrincipalCollection principals) {
        // 获取身份信息
        ActiveUser activeUser = (ActiveUser) principals.getPrimaryPrincipal();
        //用户id
        String userid = activeUser.getUserid();
        // 根据用户id从数据库中查询权限数据
        // ....这里使用静态数据模拟
        List<String> permissions = new ArrayList<String>();
        permissions.add("item:query");
        permissions.add("item:update");

        // 将权限信息封闭为AuthorizationInfo

        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        for (String permission : permissions) {
            simpleAuthorizationInfo.addStringPermission(permission);
        }

        return simpleAuthorizationInfo;
    }

}

  5、登录controller :

//用户登陆页面
    @RequestMapping("/login")
    public String login()throws Exception{
        return "login";
    }
    // 用户登陆提交
    @RequestMapping("/loginsubmit")
    public String loginsubmit(Model model, HttpServletRequest request)
            throws Exception {

        // shiro在认证过程中出现错误后将异常类路径通过request返回
        String exceptionClassName = (String) request
                .getAttribute("shiroLoginFailure");
        if (UnknownAccountException.class.getName().equals(exceptionClassName)) {
            throw new CustomException("账号不存在");
        } else if (IncorrectCredentialsException.class.getName().equals(
                exceptionClassName)) {
            throw new CustomException("用户名/密码错误");
        } else{
            throw new Exception();//最终在异常处理器生成未知错误
        }
    }

      6、退出

由于使用shiro的sessionManager，不用开发退出功能，使用shiro的logout拦截器即可

<!-- 退出拦截，请求logout.action执行退出操作 -->
/logout.action = logout

注意：如需添加MD5校验需要修改applicationContext-shiro.xml：

<!-- 凭证匹配器 -->
    <bean id="credentialsMatcher"
        class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
        <property name="hashAlgorithmName" value="md5" />
        <property name="hashIterations" value="1" />
    </bean>

<!-- 自定义 realm -->
    <bean id="userRealm" class="cn.itcast.ssm.realm.CustomRealm1">
        <property name="credentialsMatcher" ref="credentialsMatcher" />
    </bean>

shiro缓存 配置：

在applicationContext-shiro.xml中配置缓存管理器：

<!-- 安全管理器 -->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="realm" ref="userRealm" />
        <property name="sessionManager" ref="sessionManager" />
        <property name="cacheManager" ref="cacheManager"/>
    </bean>

<!-- 缓存管理器 -->
    <bean id="cacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">
    </bean>

session管理 ：

在applicationContext-shiro.xml中配置sessionManager

<!-- 安全管理器 -->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="realm" ref="userRealm" />
        <property name="sessionManager" ref="sessionManager" />
    </bean>
<!-- 会话管理器 -->
    <bean id="sessionManager" class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">
        <!-- session的失效时长，单位毫秒 -->
        <property name="globalSessionTimeout" value="600000"/>
        <!-- 删除失效的session -->
        <property name="deleteInvalidSessions" value="true"/>
    </bean>

配置记住我【下次免登陆】

       1、用户身份实现java.io.Serializable接口【即用户实体类】

2、修改applicationContext-shiro.xml中对FormAuthenticationFilter的配置：

       <bean id="formAuthenticationFilter" class="org.apache.shiro.web.filter.authc.FormAuthenticationFilter"> 改为  如下：

<bean id="formAuthenticationFilter"

       class="cn.itcast.ssm.shiro.MyFormAuthenticationFilter">

       <!-- 表单中账号的input名称 -->

       <property name="usernameParam" value="usercode" />

       <!-- 表单中密码的input名称 -->

       <property name="passwordParam" value="password" />

       <property name="rememberMeParam" value="rememberMe"/>

       <!-- loginurl：用户登陆地址，此地址是可以http访问的url地址 -->

       <property name="loginUrl" value="/loginsubmit.action" />

    </bean>

              3、修改applicationContext-shiro.xml

<!-- 安全管理器 -->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="realm" ref="userRealm" />
        <property name="sessionManager" ref="sessionManager" />
        <property name="cacheManager" ref="cacheManager"/>
        <!-- 记住我 -->
        <property name="rememberMeManager" ref="rememberMeManager"/>
    </bean>

<!-- rememberMeManager管理器 -->
    <bean id="rememberMeManager" class="org.apache.shiro.web.mgt.CookieRememberMeManager">
        <property name="cookie" ref="rememberMeCookie" />
    </bean>
    <!-- 记住我cookie -->
    <bean id="rememberMeCookie" class="org.apache.shiro.web.servlet.SimpleCookie">
        <constructor-arg value="rememberMe" />
        <!-- 记住我cookie生效时间30天 -->
        <property name="maxAge" value="2592000" />
    </bean>

登录页面 添加如下：

<input type="checkbox" name="rememberMe" />自动登陆

附 :

shiro过虑器
过滤器简称    对应的java类
anon    org.apache.shiro.web.filter.authc.AnonymousFilter
authc    org.apache.shiro.web.filter.authc.FormAuthenticationFilter
authcBasic    org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter
perms    org.apache.shiro.web.filter.authz.PermissionsAuthorizationFilter
port    org.apache.shiro.web.filter.authz.PortFilter
rest    org.apache.shiro.web.filter.authz.HttpMethodPermissionFilter
roles    org.apache.shiro.web.filter.authz.RolesAuthorizationFilter
ssl    org.apache.shiro.web.filter.authz.SslFilter
user    org.apache.shiro.web.filter.authc.UserFilter
logout    org.apache.shiro.web.filter.authc.LogoutFilter


anon:例子/admins/**=anon 没有参数，表示可以匿名使用。
authc:例如/admins/user/**=authc表示需要认证(登录)才能使用，没有参数
roles：例子/admins/user/**=roles[admin],参数可以写多个，多个时必须加上引号，并且参数之间用逗号分割，当有多个参数时，例如admins/user/**=roles["admin,guest"],每个参数通过才算通过，相当于hasAllRoles()方法。
perms：例子/admins/user/**=perms[user:add:*],参数可以写多个，多个时必须加上引号，并且参数之间用逗号分割，例如/admins/user/**=perms["user:add:*,user:modify:*"]，当有多个参数时必须每个参数都通过才通过，想当于isPermitedAll()方法。
rest：例子/admins/user/**=rest[user],根据请求的方法，相当于/admins/user/**=perms[user:method] ,其中method为post，get，delete等。
port：例子/admins/user/**=port[8081],当请求的url的端口不是8081是跳转到schemal://serverName:8081?queryString,其中schmal是协议http或https等，serverName是你访问的host,8081是url配置里port的端口，queryString
是你访问的url里的？后面的参数。
authcBasic：例如/admins/user/**=authcBasic没有参数表示httpBasic认证

ssl:例子/admins/user/**=ssl没有参数，表示安全的url请求，协议为https
user:例如/admins/user/**=user没有参数表示必须存在用户，当登入操作时不做检查
注：
anon，authcBasic，auchc，user是认证过滤器，
perms，roles，ssl，rest，port是授权过滤器

shiro的jsp标签

Jsp页面添加：
<%@ tagliburi="http://shiro.apache.org/tags" prefix="shiro" %>

标签名称    标签条件（均是显示标签内容）
<shiro:authenticated>    登录之后
<shiro:notAuthenticated>    不在登录状态时
<shiro:guest>    用户在没有RememberMe时
<shiro:user>    用户在RememberMe时
<shiro:hasAnyRoles name="abc,123" >    在有abc或者123角色时
<shiro:hasRole name="abc">    拥有角色abc
<shiro:lacksRole name="abc">    没有角色abc
<shiro:hasPermission name="abc">    拥有权限资源abc
<shiro:lacksPermission name="abc">    没有abc权限资源
<shiro:principal>    显示用户身份名称
 <shiro:principal property="username"/>     显示用户身份中的属性值