shiro讲解之 SpringMVC 集成Shiro

不念不忘少年蓝@ 2022-06-06 01:26 390阅读 0赞

## **shiro讲解之 SpringMVC 集成Shiro** ##

本章节将通过实例来学习下SpringMVC+Spring+Shiro如何集成并用一个精简的例子说明。

--------------------

## **整合** ##

*  新建一个完整的Spring+SpringMVC 框架
    
     *  关于Spring整个SpringMVC的例子已在SpingMVC模块有分享，可移步至SpringMVC。
 *  项目目录
    
     *  ![这里写图片描述][SouthEast]
 *  整合 Shiro 步骤
    
     *  下载 Shiro 及相关jar包
        
         *  pom.xml新增以下依赖
            
                
                        
                        <dependency>
                            <groupId>org.apache.shiro</groupId>
                            <artifactId>shiro-all</artifactId>
                            <version>1.3.2</version>
                        </dependency>
                        
                
                        
                        
                        <dependency>
                            <groupId>org.apache.shiro</groupId>
                            <artifactId>shiro-ehcache</artifactId>
                            <version>1.2.4</version>
                        </dependency>
                
                        
     *  配置web.xml
        
         *  Shiro web.xml配置信息参考 [Shiro Web App][]。这里我们的整合将直接参考Spring Example中的web.xml的配置信息。
            
                
                    
                    <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>
            
            web.xml文件中配置Shiro 的DelegatingFilterProxy,该Filter的核心作用点就是用户拦截和过滤请求的URL,之于如何处理URL将在Shiro配置文件的 shiroFilter中有具体的说明。
     *  新建ehcache.xml缓存  
        在整合Shiro的过程中我们在使用shiro的缓存机制时会使用到缓存，这一点在pom.xml的依赖有提现，另外在后续的篇章中我们也将详细说明Shiro的缓存机制，这里做初步了解。  
        在classpath(一般建议，也可以自定义)下新建一个ehcache.xml,配置信息如下，**如有必要可全部复制**
        
            <?xml version="1.0" encoding="UTF-8"?>
            <ehcache>
            
                <diskStore path="java.io.tmpdir" /> 
            
            
                
                <cache name="passwordRetryCache" maxEntriesLocalHeap="2000" eternal="false" timeToIdleSeconds="3600" timeToLiveSeconds="0" overflowToDisk="false" statistics="true">
                </cache>
            
                <cache name="authorizationCache" maxEntriesLocalHeap="2000" eternal="false" timeToIdleSeconds="3600" timeToLiveSeconds="0" overflowToDisk="false" statistics="true">
                </cache>
            
                <cache name="authenticationCache" maxEntriesLocalHeap="2000" eternal="false" timeToIdleSeconds="3600" timeToLiveSeconds="0" overflowToDisk="false" statistics="true">
                </cache>
            
                <cache name="shiro-activeSessionCache" maxEntriesLocalHeap="2000" eternal="false" timeToIdleSeconds="3600" timeToLiveSeconds="0" overflowToDisk="false" statistics="true">
                </cache>
            
                <defaultCache maxElementsInMemory="10000" eternal="false" timeToIdleSeconds="120" timeToLiveSeconds="120" overflowToDisk="true" maxElementsOnDisk="10000000" diskPersistent="false" diskExpiryThreadIntervalSeconds="120" memoryStoreEvictionPolicy="LRU" />
            
                
            </ehcache>
     *  在ApplicationContext.xml中配置Shiro相关信息  
        在ApplicationContext.xml文件中配置Shiro的必要信息，这里我们的整合将直接参考Spring Example中的applicationContext.xml的配置信息。基本配置如下(在讲解后续功能时会不断完善该配置)
        
            
                <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
                    <property name="cacheManager" ref="cacheManager" />
                    
                    
                    <property name="realms">
                        <list>
                            <ref bean="shiroRealm"></ref>
                        </list>
                    </property>
                </bean>
            
                
                
                <bean id="cacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">
                    <property name="cacheManagerConfigFile" value="classpath:ehcache.xml"></property>
                </bean>
            
                
                <bean id="shiroRealm" class="com.shiro.example.interceptor.realm.ShiroRealm">
                    
                </bean>
            
                
            
                
                <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor" />
            
                
                <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" depends-on="lifecycleBeanPostProcessor" />
            
                <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
                    <property name="securityManager" ref="securityManager" />
                </bean>
            
            
                
                <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
                    <property name="securityManager" ref="securityManager" />
                    <property name="loginUrl" value="/login/toLogin" />
                    <property name="successUrl" value="/example/index" />
                    <property name="unauthorizedUrl" value="/example/unauthorized" />
                    <property name="filterChainDefinitions">
                        <value>
                            /login/toLogin = anon
                            /login/loginVal = anon
                            /login/logout = logout
                            /** = authc
                        </value>
                    </property>
                </bean>

--------------------

## **一个Shiro例子** ##

以上配置好以后我们将做一个Shiro 认证的登录例子。

*  新建Form表单,本例子中的login.jsp
    
        <%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%>
        <% String path = request.getContextPath(); String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path; %>
        
        <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
        <html>
        
        <head>
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
        <title>Insert title here</title>
        </head>
        <body>
        
        
        
            <form action="<%=basePath %>/login/loginVal" method="POST">
                username: <input type="text" name="username" /> <br> <br>
                password: <input type="password" name="password" /> <br> <br>
                <input type="submit" value="Submit" />
        
            </form>
        
        </body>
        </html>
 *  实现Controller方法
    
        package com.shiro.example.controller;
        
        import org.apache.shiro.SecurityUtils;
        import org.apache.shiro.authc.UsernamePasswordToken;
        import org.apache.shiro.subject.Subject;
        import org.springframework.stereotype.Controller;
        import org.springframework.web.bind.annotation.RequestMapping;
        import org.springframework.web.bind.annotation.RequestParam;
        
        @Controller
        @RequestMapping(value = "/login")
        public class LoginProcess {
        
            @RequestMapping("/loginVal")
            public String login(@RequestParam("username") String username, @RequestParam("password") String password)
                    throws Exception {
                System.out.println("username: " + username + "+ password: " + password);
                Subject subject = SecurityUtils.getSubject();
                // 如果当前用户并未经过认证登录的
                /*if (!subject.isAuthenticated()) {*/
                    UsernamePasswordToken token = new UsernamePasswordToken(username, password);
                     token.setRememberMe(true);
                    try {
        
                        subject.login(token);
        
                    } catch (Exception e) {
                        System.out.println("登录失败: " + e.getMessage());
                        return "erro";
                    }
                /*} System.out.println("用户尚未被认证");*/
                return "index";
            }
        
            @RequestMapping("/toLogin")
            public String toLogin() throws Exception {
                return "login";
            }
        
        }
 *  实现自定义Realm方法
    
        package com.shiro.example.interceptor.realm;
        
        import java.util.HashSet;
        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.authz.AuthorizationInfo;
        import org.apache.shiro.authz.SimpleAuthorizationInfo;
        import org.apache.shiro.crypto.hash.SimpleHash;
        import org.apache.shiro.realm.AuthorizingRealm;
        import org.apache.shiro.subject.PrincipalCollection;
        import org.apache.shiro.util.ByteSource;
        
        import com.shiro.example.entity.SubjectEntity;
        
        public class ShiroRealm extends AuthorizingRealm {
        
            @Override
            protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
                System.out.println("[FirstRealm] doGetAuthenticationInfo");
        
                // 1. 把 AuthenticationToken 转换为 UsernamePasswordToken
                UsernamePasswordToken upToken = (UsernamePasswordToken) token;
        
                // 2. 从 UsernamePasswordToken 中来获取 username
                String username = upToken.getUsername();
        
                // 3. 调用数据库的方法, 从数据库中查询 username 对应的用户记录
                SubjectEntity principals = new SubjectEntity("123456", "Dustyone");
        
                // 4. 若用户不存在, 则可以抛出 UnknownAccountException 异常
                if ("unknown".equals(username)) {
                    throw new UnknownAccountException("用户不存在!");
                }
        
                // 5. 根据用户信息的情况, 决定是否需要抛出其他的 AuthenticationException 异常.
                if ("monster".equals(username)) {
                    throw new LockedAccountException("用户被锁定");
                }
        
                // 6. 根据用户的情况, 来构建 AuthenticationInfo 对象并返回. 通常使用的实现类为:
                // SimpleAuthenticationInfo
                // 以下信息是从数据库中获取的.
                // 1). principal: 认证的实体信息. 可以是 username, 也可以是数据表对应的用户的实体类对象.
                Object principal = principals.getUsername();
                // 2). credentials: 密码.
                Object credentials = principals.getPassword(); // "fc1709d0a95a6be30bc5926fdb7f22f4";
        
        
                // 3). realmName: 当前 realm 对象的 name. 调用父类的 getName() 方法即可
                String realmName = getName();
                SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(principal, credentials, realmName);
        
        
                /* * //3). realmName: 当前 realm 对象的 name. 调用父类的 getName() 方法即可 String * realmName = getName(); //4). 盐值. ByteSource credentialsSalt = * ByteSource.Util.bytes(username); * * SimpleAuthenticationInfo info = null; //new * SimpleAuthenticationInfo(principal, credentials, realmName); info = * new SimpleAuthenticationInfo(principal, credentials, credentialsSalt, * realmName); */
                return info;
            }
 *  新建Subject Entity
    
        package com.shiro.example.entity;
        
        import java.io.Serializable;
        
        public class SubjectEntity implements Serializable{ 
        
            /** * Subject Entity */
            private static final long serialVersionUID = 1L;
            public SubjectEntity() {
                super();
            }
            @Override
            public String toString() {
                return "SubjectEntity [username=" + username + ", password=" + password + "]";
            }
            public SubjectEntity(String password, String username) {
                super();
                this.username = username;
                this.password = password;
            }
            public String getUsername() {
                return username;
            }
            public void setUsername(String username) {
                this.username = username;
            }
            public String getPassword() {
                return password;
            }
            public void setPassword(String password) {
                this.password = password;
            }
            private String username;
            private String password;
        }
 *  Example 文件
    
        ```
        package com.shiro.example.controller;
        
        import org.springframework.stereotype.Controller;
        import org.springframework.web.bind.annotation.RequestMapping;
        
        @Controller
        @RequestMapping("/example")
        public class Example {
        
            @RequestMapping(value = "/index")
            public String example() throws Exception {
                return "example";
            }
        
            @RequestMapping(value="/unauthorized") 
            public String unauthorized(){
                return "unauthorized";
            }
        }
        
        ```

--------------------

## **本例子涉及的核心功能点** ##

*  Shiro 认证(登录验证)
    
     *  由我们自定义的Realm代码中可知我们指定登录的Subject的usernam=Dustyone password=123456。唯有此principal(实体)组合才能通过Shiro认证(暂时不涉及加密)。
     *  正确登录  
        ![这里写图片描述][SouthEast 1]
        
        ![这里写图片描述][SouthEast 2]
     *  错误principal登录
        
        ![这里写图片描述][SouthEast 3]
        
        ![这里写图片描述][SouthEast 4]
 *  Shiro 授权
    
     *  在shiroFilter的 filterChainDefinitions我们做了访问权限声明即除了 **/login/toLogin** 和 **/login/loginVal** 可以被匿名访问意外其他的任何url请都将被 shiro filetr收集并进行Subject 授权(即用户是否有权限访问\*\*, 此处的两个星号标识资源。)。以 /example/index请求为例，在用户未登录的情况下访问该路径将直接跳转至登录页面。只有在登录成功的情况下才能访问 /example/index
     *  未登录的情况下访问 /example/index 将直接跳至登录页面  
        ![这里写图片描述][SouthEast 5]
     *  已登录的情况下访问 /example/index 直接可以访问该资源  
        ![这里写图片描述][SouthEast 6]
        
        ![这里写图片描述][SouthEast 7]
 *  Shiro 缓存  
    用户登录成功之后(特质在启用了shiro的缓存机制之后),shiro 缓存将对最近一个Subject的认证或授权信息写入缓存。当该Subject 再次访问需要认证或授权的资源时，shiro将从缓存中(本例子中特指ehcache.xml)读取Subject的相关信息而不再此对该Subject进行认证或授权处理(这里的认证或授权特指我们自定义的Reaml中的 doGetAuthenticationInfo 和 doGetAuthorizationInfo 两个方法)。
 *  Shiro 登出  
    在访问logout 之后shiro将清除所有缓存信息并跳至登录页面。

[SouthEast]: /images/20220606/f7ebc91c3ee64c98b1b4f41faab13f59.png
[Shiro Web App]: https://github.com/apache/shiro/tree/master/samples/spring
[SouthEast 1]: /images/20220606/e4e3a943e7e14995b1838c2a470d3719.png
[SouthEast 2]: /images/20220606/f5ac8ad7b47141f9bb5c20ac3d0e3013.png
[SouthEast 3]: /images/20220606/fe0c47727ca54f25a48a73d86599d459.png
[SouthEast 4]: /images/20220606/5f483b80ac3f41bab4f26d5c3793c849.png
[SouthEast 5]: /images/20220606/6d893bc22c29423a8d68ed51c180ef2a.png
[SouthEast 6]: /images/20220606/8b9b512a9e0442648880465254a91202.png
[SouthEast 7]: /images/20220606/903621d9a6ba44f3a584766eebd24868.png