SpringMVC+Shiro的基本使用及功能介紹

更新時間：2022年04月27日 17:22:55 作者：Resourceful!

本文給大家介紹SpringMVC+Shiro的基本使用，Apache?Shiro是Java的一個安全框架，Shiro本身無法知道所持有令牌的用戶是否合法，因為除了項目的設(shè)計人員恐怕誰都無法得知，本文只介紹最常見也最重要的一種實現(xiàn)方式數(shù)據(jù)庫查詢

一.介紹

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

二.基本功能

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

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

 UsernamePasswordToken token = new UsernamePasswordToken(username, password);

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

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

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

（3）判斷用戶

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

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 = "登錄失敗次數(shù)過多";
            model.addAttribute("errorMsg", "登錄失敗次數(shù)過多");
            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 = "您沒有得到相應(yīng)的授權(quán)！" + e.getMessage();
            model.addAttribute("errorMsg", "您沒有得到相應(yīng)的授權(quán)");
            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方法）
驗證是否有訪問指定資源的權(quán)限，并返回所擁有的所有權(quán)限（getAuthorizationInfo方法）
判斷是否支持token（例如：HostAuthenticationToken，UsernamePasswordToken等）（supports方法）

2.Realm接口的內(nèi)容，這個接口里有3個方法，內(nèi)容如下：

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

3.實現(xiàn)自定義Realm

在權(quán)限控制中比較重要的驗證（登錄或權(quán)限）邏輯，都是在Realm中做的。Realm的類繼承如下：
繼承了AuthorizingRealm的類，都要實現(xiàn)上面說的getAuthenticationInfo和getAuthorizationInfo方法，來完成登錄和權(quán)限的驗證。但如果自定義的Realm類只實現(xiàn)Realm接口的話，只需要getAuthenticationInfo方法就可以。下面看一個只實現(xiàn)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";
    }
    /**
     * 權(quán)限認證
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        String currentUsername = (String)super.getAvailablePrincipal(principalCollection);
        System.out.print("AuthorizationInfo====："+currentUsername);
        SimpleAuthorizationInfo info =  new SimpleAuthorizationInfo();
        //根據(jù)用戶ID查詢角色（role），放入到Authorization里。
        Set<String> roles = roleServerInter.FindRoleByName(currentUsername);
        info.setRoles(roles);
        //根據(jù)用戶ID查詢權(quán)限（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("當(dāng)前無此用戶！");
        }
        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();
    }
}

六.登錄失敗次數(shù)限制

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

<bean id="credentialsMatcher" class="com.sxkj.Common.RetryLimitHashedCredentialsMatcher">
        <constructor-arg ref="cacheManager" />
        <!--加密算法為md5-->
        <property name="hashAlgorithmName" value="md5" />
        <!--3次md5迭代  配置加密的次數(shù)-->
        <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";
}

八.創(chuàng)建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();
    /**
     * 創(chuàng)建ehcache緩存，創(chuàng)建之后的有效期是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;
    }
}

到此這篇關(guān)于SpringMVC+Shiro的基本使用的文章就介紹到這了,更多相關(guān)SpringMVC Shiro使用內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: