SpringMVC Shiro怎么使用

今天小編給大家分享一下SpringMVC Shiro怎么使用的相關知識點，內容詳細，邏輯清晰，相信大部分人都還太了解這方面的知識，所以分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后有所收獲，下面我們一起來了解一下吧。

一.介紹

Apache Shiro是Java的一個安全框架。目前，使用Apache Shiro的人越來越多，因為它相當簡單，對比Spring Security，可能沒有Spring Security做的功能強大，但是在實際工作時可能并不需要那么復雜的東西，所以使用小而簡單的Shiro就足夠了。對于它倆到底哪個好，這個不必糾結，能更簡單的解決項目問題就好了。
Shiro可以非常容易的開發出足夠好的應用，其不僅可以用在JavaSE環境，也可以用在JavaEE環境。Shiro可以幫助我們完成：認證、授權、加密、會話管理、與Web集成、緩存等。這不就是我們想要的嘛，而且Shiro的API也是非常簡單

二.基本功能

Authentication：身份認證/登錄，驗證用戶是不是擁有相應的身份；
Authorization：授權，即權限驗證，驗證某個已認證的用戶是否擁有某個權限；即判斷用戶是否能做事情，常見的如：驗證某個用戶是否擁有某個角色。或者細粒度的驗證某個用戶對某個資源是否具有某個權限；
Session Manager：會話管理，即用戶登錄后就是一次會話，在沒有退出之前，它的所有信息都在會話中；會話可以是普通JavaSE環境的，也可以是如Web環境的；
Cryptography：加密，保護數據的安全性，如密碼加密存儲到數據庫，而不是明文存儲；
Web Support：Web支持，可以非常容易的集成到Web環境；
Caching：緩存，比如用戶登錄后，其用戶信息、擁有的角色/權限不必每次去查，這樣可以提高效率；
Concurrency：shiro支持多線程應用的并發驗證，即如在一個線程中開啟另一個線程，能把權限自動傳播過去；
Testing：提供測試支持；
Run As：允許一個用戶假裝為另一個用戶（如果他們允許）的身份進行訪問；
Remember Me：記住我，這個是非常常見的功能，即一次登錄后，下次再來的話不用登錄了。
記住一點，Shiro不會去維護用戶、維護權限；這些需要我們自己去設計/提供；然后通過相應的接口注入給Shiro即可。
可以看到：應用代碼直接交互的對象是Subject，也就是說Shiro的對外API核心就是Subject；其每個API的含義：
Subject：主體，代表了當前“用戶”，這個用戶不一定是一個具體的人，與當前應用交互的任何東西都是Subject，如網絡爬蟲，機器人等；即一個抽象概念；所有Subject都綁定到SecurityManager，與Subject的所有交互都會委托給SecurityManager；可以把Subject認為是一個門面；SecurityManager才是實際的執行者；
SecurityManager：安全管理器；即所有與安全有關的操作都會與SecurityManager交互；且它管理著所有Subject；可以看出它是Shiro的核心，它負責與后邊介紹的其他組件進行交互，如果學習過SpringMVC，你可以把它看成DispatcherServlet前端控制器；
Realm：域，Shiro從從Realm獲取安全數據（如用戶、角色、權限），就是說SecurityManager要驗證用戶身份，那么它需要從Realm獲取相應的用戶進行比較以確定用戶身份是否合法；也需要從Realm得到用戶相應的角色/權限進行驗證用戶是否能進行操作；可以把Realm看成DataSource，即安全數據源。

也就是說對于我們而言，最簡單的一個Shiro應用：
1、應用代碼通過Subject來進行認證和授權，而Subject又委托給SecurityManager；
2、我們需要給Shiro的SecurityManager注入Realm，從而讓SecurityManager能得到合法的用戶及其權限進行判斷。
從以上也可以看出，Shiro不提供維護用戶/權限，而是通過Realm讓開發人員自己注入
Subject：主體，可以看到主體可以是任何可以與應用交互的“用戶”；
SecurityManager：相當于SpringMVC中的DispatcherServlet或者Struts2中的FilterDispatcher；是Shiro的心臟；所有具體的交互都通過SecurityManager進行控制；它管理著所有Subject、且負責進行認證和授權、及會話、緩存的管理。
Authenticator：認證器，負責主體認證的，這是一個擴展點，如果用戶覺得Shiro默認的不好，可以自定義實現；其需要認證策略（Authentication Strategy），即什么情況下算用戶認證通過了；
Authrizer：授權器，或者訪問控制器，用來決定主體是否有權限進行相應的操作；即控制著用戶能訪問應用中的哪些功能；
Realm：可以有1個或多個Realm，可以認為是安全實體數據源，即用于獲取安全實體的；可以是JDBC實現，也可以是LDAP實現，或者內存實現等等；由用戶提供；注意：Shiro不知道你的用戶/權限存儲在哪及以何種格式存儲；所以我們一般在應用中都需要實現自己的Realm；
SessionManager：如果寫過Servlet就應該知道Session的概念，Session呢需要有人去管理它的生命周期，這個組件就是SessionManager；而Shiro并不僅僅可以用在Web環境，也可以用在如普通的JavaSE環境、EJB等環境；所有呢，Shiro就抽象了一個自己的Session來管理主體與應用之間交互的數據；這樣的話，比如我們在Web環境用，剛開始是一臺Web服務器；接著又上了臺EJB服務器；這時想把兩臺服務器的會話數據放到一個地方，這個時候就可以實現自己的分布式會話（如把數據放到Memcached服務器）；
SessionDAO：DAO大家都用過，數據訪問對象，用于會話的CRUD，比如我們想把Session保存到數據庫，那么可以實現自己的SessionDAO，通過如JDBC寫到數據庫；比如想把Session放到Memcached中，可以實現自己的Memcached SessionDAO；另外SessionDAO中可以使用Cache進行緩存，以提高性能；
CacheManager：緩存控制器，來管理如用戶、角色、權限等的緩存的；因為這些數據基本上很少去改變，放到緩存中后可以提高訪問的性能
Cryptography：密碼模塊，Shiro提高了一些常見的加密組件用于如密碼加密/解密的。

三.使用Maven包

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

四.用戶登錄

（1）使用用戶的登錄信息創建令牌

 UsernamePasswordToken token = new UsernamePasswordToken(username, password);

token可以理解為用戶令牌，登錄的過程被抽象為Shiro驗證令牌是否具有合法身份以及相關權限。
（2）執行登陸

    SecurityUtils.setSecurityManager(securityManager); // 注入SecurityManager安全管理器
    Subject subject = SecurityUtils.getSubject(); // 獲取Subject單例對象
    subject.login(token); // 登陸

Shiro的核心部分是SecurityManager，它負責安全認證與授權。Shiro本身已經實現了所有的細節，用戶可以完全把它當做一個黑盒來使用。SecurityUtils對象，本質上就是一個工廠類似Spring中的ApplicationContext。Subject是初學者比較難于理解的對象，很多人以為它可以等同于User，其實不然。Subject中文翻譯：項目，而正確的理解也恰恰如此。它是你目前所設計的需要通過Shiro保護的項目的一個抽象概念。通過令牌（token）與項目（subject）的登陸（login）關系，Shiro保證了項目整體的安全。

（3）判斷用戶

Shiro本身無法知道所持有令牌的用戶是否合法，因為除了項目的設計人員恐怕誰都無法得知。因此Realm是整個框架中為數不多的必須由設計者自行實現的模塊，當然Shiro提供了多種實現的途徑，本文只介紹最常見也最重要的一種實現方式——數據庫查詢。

2.基本代碼

 /**
 * 用戶登錄
 * @param user
 * @param model
 * @param remember
 * @return
 */
@RequestMapping("/login")
public String login(Student user,Model model,String remember) {
    ModelAndView view = new ModelAndView("loginerro");
    String msg = "";
    Subject subject = SecurityUtils.getSubject();
        UsernamePasswordToken token = new UsernamePasswordToken(user.getUsername(), user.getPassword(),user.getUsername());
        if(remember!=null){
            if(remember.equals("記住我")){//記住我
                token.setRememberMe(true);
            }
        }
        try {
            subject.login(token);
            return "main";
        } catch (IncorrectCredentialsException e) {
            model.addAttribute("errorMsg", "抱歉，您的密碼有誤");
        } catch (ExcessiveAttemptsException e) {
            msg = "登錄失敗次數過多";
            model.addAttribute("errorMsg", "登錄失敗次數過多");
            System.out.println(msg);
        } catch (LockedAccountException e) {
            msg = "帳號已被鎖定. The account for username " + token.getPrincipal() + " was locked.";
            model.addAttribute("errorMsg", "帳號已被鎖定");
            System.out.println(msg);
        } catch (DisabledAccountException e) {
            msg = "帳號已被禁用. The account for username " + token.getPrincipal() + " was disabled.";
            model.addAttribute("errorMsg", "帳號已被禁用");
            System.out.println(msg);
        } catch (ExpiredCredentialsException e) {
            msg = "帳號已過期. the account for username " + token.getPrincipal() + "  was expired.";
            model.addAttribute("errorMsg", "帳號已過期");
            System.out.println(msg);
        } catch (UnknownAccountException e) {
            model.addAttribute("errorMsg", e.getMessage());
        } catch (UnauthorizedException e) {
            msg = "您沒有得到相應的授權！" + e.getMessage();
            model.addAttribute("errorMsg", "您沒有得到相應的授權");
            System.out.println(msg);
        } catch (AccountException e) {
            msg = e.getMessage();
            model.addAttribute("errorMsg", e.getMessage());
            System.out.println(msg);
        }
        return "home";
}

五.Reaml

1.Realm能做的工作主要有以下幾個方面：

驗證是否能登錄，并返回驗證信息（getAuthenticationInfo方法）
驗證是否有訪問指定資源的權限，并返回所擁有的所有權限（getAuthorizationInfo方法）
判斷是否支持token（例如：HostAuthenticationToken，UsernamePasswordToken等）（supports方法）

2.Realm接口的內容，這個接口里有3個方法，內容如下：

 AuthenticationInfo getAuthenticationInfo(AuthenticationToken token)
boolean supports(AuthenticationToken token)
String getName()

3.實現自定義Realm

在權限控制中比較重要的驗證（登錄或權限）邏輯，都是在Realm中做的。Realm的類繼承如下：
繼承了AuthorizingRealm的類，都要實現上面說的getAuthenticationInfo和getAuthorizationInfo方法，來完成登錄和權限的驗證。但如果自定義的Realm類只實現Realm接口的話，只需要getAuthenticationInfo方法就可以。下面看一個只實現Realm接口的自定義Realm。

自定義realm代碼

public class LoginShiro extends AuthorizingRealm {
    private static final Logger logger = LogManager.getLogger(LoginShiro.class);
    @Autowired
    private UserServerInter userServerInter;
    @Autowired
    private RoleServerInter roleServerInter;
    @Autowired
    private PermissionServerInter permissionServerInter;
    @Autowired
    private UserDao userDao;
    @Override
    public String getName() {
        return "realm";
    }
    /**
     * 權限認證
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        String currentUsername = (String)super.getAvailablePrincipal(principalCollection);
        System.out.print("AuthorizationInfo====："+currentUsername);
        SimpleAuthorizationInfo info =  new SimpleAuthorizationInfo();
        //根據用戶ID查詢角色（role），放入到Authorization里。
        Set<String> roles = roleServerInter.FindRoleByName(currentUsername);
        info.setRoles(roles);
        //根據用戶ID查詢權限（permission），放入到Authorization里。
        Set<String> permissions = permissionServerInter.findPermissionByName(currentUsername);
        info.setStringPermissions(permissions);
        return info;
    }
    /**
     * 身份認證
     * @param authenticationToken
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
         SimpleAuthenticationInfo authenticationInfo = null;
        UsernamePasswordToken token=(UsernamePasswordToken) authenticationToken;
        String username = String.valueOf(token.getUsername());
        String password = new String(token.getPassword());
        Student user= userDao.FindUserByUserName(username);
        if (null != user) {
                authenticationInfo = new SimpleAuthenticationInfo(user.getUsername(), user.getPassword(), getName());
//                //鹽值：取用戶信息中唯一的字段來生成鹽值，避免由于兩個用戶原始密碼相同，加密后的密碼也相同
                authenticationInfo.setCredentialsSalt(ByteSource.Util.bytes(username+user.getSalt()));
        }else {
            throw new AccountException("當前無此用戶！");
        }
        return authenticationInfo;
    }
    @Override
     public void clearCachedAuthorizationInfo(PrincipalCollection principals) {
                super.clearCachedAuthorizationInfo(principals);
    }
    @Override
     public void clearCachedAuthenticationInfo(PrincipalCollection principals) {
        super.clearCachedAuthenticationInfo(principals);
    }
    @Override
     public void clearCache(PrincipalCollection principals) {
        super.clearCache(principals);
    }
    public void clearAllCachedAuthorizationInfo() {
        getAuthorizationCache().clear();
    }
    public void clearAllCachedAuthenticationInfo() {
        getAuthenticationCache().clear();
    }
    /**
     * 清空緩存
     */
    public void clearAllCache() {
        clearAllCachedAuthenticationInfo();
        clearAllCachedAuthorizationInfo();
    }
}

六.登錄失敗次數限制

1.在spring-shiro配置文件里面配置安全管理器

<bean id="credentialsMatcher" class="com.sxkj.Common.RetryLimitHashedCredentialsMatcher">
        <constructor-arg ref="cacheManager" />
        <!--加密算法為md5-->
        <property name="hashAlgorithmName" value="md5" />
        <!--3次md5迭代  配置加密的次數-->
        <property name="hashIterations" value="2" />
        <!--是否存儲散列后的密碼為16進制，需要和生成密碼時的一樣，默認是base64-->
        <property name="storedCredentialsHexEncoded" value="true" />
    </bean>

2.RetryLimitHashedCredentialsMatcher文件

 public class RetryLimitHashedCredentialsMatcher extends HashedCredentialsMatcher {
    private Cache  <    String, AtomicInteger> passwordRetryCache;
    public RetryLimitHashedCredentialsMatcher(CacheManager cacheManager) {
//        passwordRetryCache = cacheManager.getCache("passwordRetryCache");
    }
    @Override
    public boolean doCredentialsMatch(AuthenticationToken token,
                                      AuthenticationInfo info) {
//        Strin matches;
        String username = (String) token.getPrincipal();
//retrycount + 1
        Object element = EhcacheUtil.getItem(username);
        if (element == null) {
            EhcacheUtil.putItem(username, 1);
            element=0;
        }else{
            int count=Integer.parseInt(element.toString())+1;
            element=count;
            EhcacheUtil.putItem(username,element);
        }
        AtomicInteger retryCount = new AtomicInteger(Integer.parseInt(element.toString()));
        if (retryCount.incrementAndGet() > 5) {
//if retrycount >5 throw
            throw new ExcessiveAttemptsException();
        }
        boolean matches = super.doCredentialsMatch(token, info);
        if (matches) {
//clear retrycount
            EhcacheUtil.removeItem(username);
        }
        return matches;
    }
}

七.退出登錄

 /**
 * 退出登錄
 * @return
 */
@RequestMapping("/logout")
public String logout(){
    Subject subject = SecurityUtils.getSubject();
    Session session = subject.getSession();
    if (subject.isAuthenticated()) {
        System.out.println(session.getLastAccessTime());
        subject.logout();
    } else if(subject.isRemembered()) {
        subject.logout();
    }
    return "home";
}

八.創建Ecache緩存以及時效

1.spring-shir配置ecache

 <!--Ehcache緩存管理器 -->
    <bean id="cacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">
        <property name="cacheManagerConfigFile" value="classpath:ehcache.xml"></property>
    </bean>

2.Ecache工具類

public class EhcacheUtil {
    private static final CacheManager cacheManager = CacheManager.getInstance();
    /**
     * 創建ehcache緩存，創建之后的有效期是1小時
     */
    private static Cache cache = new Cache(new CacheConfiguration("systemCache", 5000).memoryStoreEvictionPolicy(MemoryStoreEvictionPolicy.FIFO).timeoutMillis(300).timeToLiveSeconds( 60 * 60));
    static {
        cacheManager.addCache(cache);
    }
    public static void putItem(String key, Object item) {
        if (cache.get(key) != null) {
            cache.remove(key);
        }
        Element element = new Element(key, item);
        cache.put(element);
    }
    public static void removeItem(String key) {
        cache.remove(key);
    }
    public static void updateItem(String key, Object value) {
        putItem(key, value);
    }
    public static Object getItem(String key) {
        Element element=  cache.get(key);
        if(null!=element)
        {
            return element.getObjectValue();
        }
        return null;
    }
}

以上就是“SpringMVC Shiro怎么使用”這篇文章的所有內容，感謝各位的閱讀！相信大家閱讀完這篇文章都有很大的收獲，小編每天都會為大家更新不同的知識，如果還想學習更多的知識，請關注億速云行業資訊頻道。