Shrio认证详解+自定义Realm

2023-07-31 19:15:22

Authentication(身份认证)是Shiro权限控制的第一步，用来告诉系统你就是你。

在提交认证的时候，我们需要给系统提交两个信息：

Principals：是一个表示用户的唯一属性，可以是用户名，邮箱之类的。

Credentials：是证明用户身份的证书，可以是密码或者指纹之类的。

认证主要分为三步：

1、收集认证信息

2、提交认证信息

3、如果认证成功，则允许访问，否则就拒绝访问或者重试。

收集认证信息：

在入门的例子中,使用了一个UsernamePasswordToken来收集用户的用户名和密码，用来登陆。

这个类支持最简单的用户名和密码登陆。实现了org.apache.shiro.authc.AuthenticationToken接口。

AuthenticationToken接口是认证系统的基础，只有getCredentials()，getPrincipal()两个方法用来获取基本的认证信息。

HostAuthenticationToken和RememberMeAuthenticationToken是它的两个子接口。

HostAuthenticationToken只有一个getHost()方法用来获取请求的地址信息。

RememberMeAuthenticationToken只有一个isRememberMe()方法用来标记用户是否需要记住我。

然后还有两个子类UsernamePasswordToken和CasToken提供了基本的实现。其中CasToken已经被废弃了。

例:

//Example using most common scenario of username/password pair:

UsernamePasswordToken token = new UsernamePasswordToken(username, password);

//"Remember Me" built-in:

token.setRememberMe(true);

提交认证信息：

收集好认证信息之后，保存为AuthenticationToken的一个实例，我们需要提交这个认证信息来进行认证。

进行认证前，我们首先需要获取当前用户（Subject）。然后调用login方法来进行登陆。

例：

Subject currentUser = SecurityUtils.getSubject();

currentUser.login(token);

处理结果：

如果登陆成功的话，则不会有什么异常，此时如果调用isAuthenticated()方法，则会返回true。

如果登陆失败的话，则被抛出异常，在SHiro中，提供了很多异常类，可以用来捕捉具体的异常。

例子：

try {

    currentUser.login(token);

} catch ( UnknownAccountException uae ) { ...

} catch ( IncorrectCredentialsException ice ) { ...

} catch ( LockedAccountException lae ) { ...

} catch ( ExcessiveAttemptsException eae ) { ...

} ... catch your own ...

} catch ( AuthenticationException ae ) {

    //unexpected error?

}

//No problems, continue on as expected...

可以看到，前面出现了Remembered和Authenticated。那这两种有什么区别呢？

需要注意的是，这是两种互斥的情况，当我们在登陆的时候，登陆成功之后，我们Authenticated返回的是true。

选择Remeber me的时候，我们下次可以不登陆直接访问，而我们下次登陆之后，Remembered返回的是true，但是Authenticated返回的是false。

在登陆之后，我们可以可以用logout()方法来注销。这时候用户的信息都会被清空，包括保存在Cookie中的RemeberMe信息还有session也会被无效。

上面我们就简单的讲述了一下在代码中实现登陆验证的流程。具体实例可以参考入门的例子。

那么，在Shrio内部是怎么样的一个认证流程呢？大概可以用下图来概括：

第一步：在代码中调用login方法，传递构造好的AuthenticationToken实例。

第二步：通过一个DelegatingSubject来分发认证请求给SecurityManager

第三步：SecurityManager容器会把接收到的token简单的转发给它内部的认证器实例通过调用认证器的authenticate(token)方法。

这通常是一个ModularRealmAuthenticator实例，用来支持多个Realm。

第四步：如果有定义多个Realm则ModularRealmAuthenticator会初始化一个支持多个Realm的认证器，通过配置的AuthenticationStrategy。

第五步：每一个配置的Realm都会被检测是否支持提交的AuthenticationToken，如果支持的话就会调用getAuthenticationInfo方法，从Realm中获取数据来跟提交的token进行验证。

验证器

在SecurityManager中，默认使用ModularRealmAuthenticator实例，它不仅仅支持单Realm还支持多个Realm。

如果实在单个Realm的情况下，ModualrRealmAuthenticator会直接调用这个Realm来尝试验证。

如果我们需要定义自己的验证器的话，可以通过在配置文件的[main]中如下定义：

[main]

...

authenticator = com.foo.bar.CustomAuthenticator

securityManager.authenticator = $authenticator

验证策略

如果是只有一个Realms的时候，则不需要验证策略。

如果是有两个以上的Realm的时候，ModularRealmAuthenticator依赖于AuthenticationStrategy组件来决定认证成功或者失败的条件，

比如是一个成功就成功还是要都成功才是成功之类的。。。。

在Shiro里面已经有三个认证策略的实现

AtLeastOneSuccessfulStrategy：只要有一个或一个以上的认证成功就表示认证成功

FirstSuccessfulStrategy；只有第一个认证成功的时候才表示认证成功

AllSuccessfulStrategy:只有所有的都认证成功的时候才表示认证成功。

在ModularRealmAuthenticator默认使用AtLeastOneSuccessfulStrategy的验证策略。当然也可以通过下面的方式定义其他的验证策略。

[main]

...

authcStrategy = org.apache.shiro.authc.pam.FirstSuccessfulStrategy

securityManager.authenticator.authenticationStrategy = $authcStrategy

...

Realm认证顺序

在定义了多个Realm的时候，如果有多个Realm支持当前的AuthenticationToken，则会依次调用Realm的getAuthenticationInfo方法。

调用的顺序分为两种：

隐式的：

如果在SecurityManager中定义了如下的几个Realm，则会按照他们定义的顺序去调用。

blahRealm = com.company.blah.Realm

...

fooRealm = com.company.foo.Realm

...

barRealm = com.company.another.Realm

此时的效果就等于下面的语句。

securityManager.realms = $blahRealm, $fooRealm, $barRealm、

显示的：

就如上面的一样，如果在securityManager.realms中配置的时候，改变realm的配置顺序，则会按照这个配置顺序来调用，这就是显示的配置。

blahRealm = com.company.blah.Realm

...

fooRealm = com.company.foo.Realm

...

barRealm = com.company.another.Realm

securityManager.realms = $fooRealm, $barRealm, $blahRealm

...

域认证

前面说了下Realm的认证策略和认证顺序，那么，在Realm认证的时候，究竟发生什么事情了呢？

supporting AuthenticationTokens

在Realm被用来尝试认证登陆的时候首先会调用supports方法，来检测是否能解析这个AuthenticationToken，决定是否进行认证。

Handing supported AuthenticationTokens

如果这个realm支持提交的AuthenticationTokens的话，解析器会调用Realm的getAuthenticationINfo(token)方法，来尝试认证，

这个方法大概做了下面这些事情：

1、检测token中的唯一用户标识

2、基于唯一标识去数据源中查找

3、确保提供的证书跟数据源中保存的一样

4、如果证书一样，就封装一个AuthenticationINfo实例返回

5、如果证书不匹配，则抛出一个AuthenticationException异常

下面，我们来看看Shrio提供的Realm的类结构：

org.apache.shiro.realm.Realm(I)：base
　　org.apache.shiro.realm.CachingRealm(Abstract)：提供缓存支持
　　　　org.apache.shiro.realm.AuthenticatingRealm(Abstract):提供认证支持
　　　　　　org.apache.shiro.realm.AuthorizingRealm(Abstract):提供授权支持
　　　　　　　　org.apache.shiro.realm.SimpleAccountRealm(C):简单的用户名密码支持
　　　　　　　　　　org.apache.shiro.realm.text.TextConfigurationRealm(C)：支持Text文件的简单用户名密码支持
　　　　　　　　　　　　org.apache.shiro.realm.text.IniRealm(C)：通过INI文件的简单用户名密码支持(默认使用这个)
　　　　　　　　　　　　org.apache.shiro.realm.text.PropertiesRealm(C)：支持属性文件的简单用户名密码支持
　　　　　　　　org.apache.shiro.realm.jdbc.JdbcRealm(C):支持通过JDBC认证

在系统默认的情况下，系统使用的是IniRealm这个实现，可以从INI配置文件的[users]和[roles]两个节中读取用户信息和权限信息。

如果我们需要定义自己的Realm实现的话，一般都是继承AuthorizingRealm。

稍候，我们将简单介绍下如果从db中来实现认证。

证书匹配：

前面我们说过，Realm需要去匹配用户提交的证书跟数据源中存储的证书是否匹配，如果匹配的话就认为是认证成功。

在获得用户唯一标识后，系统回去Realm会去检索用户的证书，然后通过CredentialsMatcher来检测证书是否匹配。

Shrio中也提供了一些证书的匹配器可以直接拿来使用，使用下面的方法变更默认的匹配器：

[main]

...

customMatcher = com.company.shiro.realm.CustomCredentialsMatcher

myRealm = com.company.shiro.realm.MyRealm

myRealm.credentialsMatcher = $customMatcher

...

Simple Equality Check

默认情况下所有提供的Realm实现都是使用SimpleCredentialsMatcher来检测证书是否匹配。

不过一般情况下都不需要变更，因为默认的就足够了。

Hashing Credentials

相比使用原始的数据存储起来，拿来匹配，我们更愿意将证书加密进行存储来进行匹配。那么如何使用呢？

在Shiro中提供了几个HashedCredentialsMatcher的子类，用来实现这个功能。包括MD5、SHA-256等等的加密方式。

我们可以通过下面的配置方式：

[main]

...

credentialsMatcher = org.apache.shiro.authc.credential.Sha256CredentialsMatcher

# base64 encoding, not hex in this example:

credentialsMatcher.storedCredentialsHexEncoded = false

credentialsMatcher.hashIterations = 1024

# This next property is only needed in Shiro 1.0\.  Remove it in 1.1 and later:

credentialsMatcher.hashSalted = true

...

myRealm = com.company.....

myRealm.credentialsMatcher = $credentialsMatcher

...

需要注意的是，这种情况下在Realm的实现中需要返回一个SaltedAuthenticationInfo，而不是普通的AuthenticationInfo，因为在用户提交认证的时候，需要获取相同的salt来进行加密，进行匹配认证。

那这个salt（盐）是用来干嘛的呢？

这是因为在进行MD5之类加密的时候，还是可以进行破解的，但是如果加入一个变量来进行加密之后，就基本上是无法破解了(不知道这个SALT的情况下)。

下面我们就做一个通过JDBC来认证的登陆认证程序。点此看源码

首先我们需要一个用户表，脚本如下：

CREATE DATABASE `db_shiro` 

USE `db_shiro`;

DROP TABLE IF EXISTS `users`;

CREATE TABLE `users` (

  `id` int(4) NOT NULL AUTO_INCREMENT,

  `username` varchar(20) DEFAULT NULL,

  `password` varchar(100) DEFAULT NULL,

  UNIQUE KEY `id` (`id`)

) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

insert  into `users`(`id`,`username`,`password`) values (1,'fuwh','');

我们需要定义一个shiro_jdbc.ini文件如下

[main]

dataSource=com.mchange.v2.c3p0.ComboPooledDataSource

dataSource.driverClass=com.mysql.jdbc.Driver

dataSource.jdbcUrl=jdbc:mysql://localhost:3306/db_shiro

dataSource.user=root

dataSource.password=rootadmin

;this is comment read from mysql

jdbcRealm=org.apache.shiro.realm.jdbc.JdbcRealm

jdbcRealm.dataSource=$dataSource

securityManager.realms=$jdbcRealm

编写登陆认证代码：

package com.fuwh.demo;

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;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class ShiroDemo02 {

    private static Logger log=LoggerFactory.getLogger(ShiroDemo02.class);

    public static void main(String[] args) {

        //取得SecurityManager工厂

        Factory<SecurityManager> factory=new IniSecurityManagerFactory("classpath:shiro_jdbc.ini");

        //取得SecurityManager实例

        SecurityManager securityManager=factory.getInstance();

        //将securityManager绑定到SecurityUtil

        SecurityUtils.setSecurityManager(securityManager);

        /*    至此为止，简单的从mysql数据库读取realm信息的shiro环境就配置好了    */

        //取得当前用户

        Subject currentUser=SecurityUtils.getSubject();

        //使用shiro来进行登陆验证

        if(!currentUser.isAuthenticated()) {

            UsernamePasswordToken token=new UsernamePasswordToken("fuwh","123456");

            try {

                currentUser.login(token);

                log.info("登陆成功！！！");

            } catch (Exception e) {

                e.printStackTrace();

                log.error("认证失败...");

            }

        }

        currentUser.logout();

    }

}

执行结果：

2017-08-26 15:16:03,357 [main] INFO  [com.mchange.v2.log.MLog] - MLog clients using log4j logging.

2017-08-26 15:16:04,107 [main] INFO  [com.mchange.v2.c3p0.C3P0Registry] - Initializing c3p0-0.9.1.2 [built 21-May-2007 15:04:56; debug? true; trace: 10]

2017-08-26 15:16:04,436 [main] INFO  [org.apache.shiro.config.IniSecurityManagerFactory] - Realms have been explicitly set on the SecurityManager instance - auto-setting of realms will not occur.

2017-08-26 15:16:04,560 [main] INFO  [com.mchange.v2.c3p0.impl.AbstractPoolBackedDataSource] - Initializing c3p0 pool... com.mchange.v2.c3p0.ComboPooledDataSource [ acquireIncrement -> 3, acquireRetryAttempts -> 30, acquireRetryDelay -> 1000, autoCommitOnClose -> false, automaticTestTable -> null, breakAfterAcquireFailure -> false, checkoutTimeout -> 0, connectionCustomizerClassName -> null, connectionTesterClassName -> com.mchange.v2.c3p0.impl.DefaultConnectionTester, dataSourceName -> 1hgetj59q83i1dm1es8ork|67f89fa3, debugUnreturnedConnectionStackTraces -> false, description -> null, driverClass -> com.mysql.jdbc.Driver, factoryClassLocation -> null, forceIgnoreUnresolvedTransactions -> false, identityToken -> 1hgetj59q83i1dm1es8ork|67f89fa3, idleConnectionTestPeriod -> 0, initialPoolSize -> 3, jdbcUrl -> jdbc:mysql://localhost:3306/db_shiro, maxAdministrativeTaskTime -> 0, maxConnectionAge -> 0, maxIdleTime -> 0, maxIdleTimeExcessConnections -> 0, maxPoolSize -> 15, maxStatements -> 0, maxStatementsPerConnection -> 0, minPoolSize -> 3, numHelperThreads -> 3, numThreadsAwaitingCheckoutDefaultUser -> 0, preferredTestQuery -> null, properties -> {user=******, password=******}, propertyCycle -> 0, testConnectionOnCheckin -> false, testConnectionOnCheckout -> false, unreturnedConnectionTimeout -> 0, usesTraditionalReflectiveProxies -> false ]

2017-08-26 15:16:05,040 [main] INFO  [org.apache.shiro.session.mgt.AbstractValidatingSessionManager] - Enabling session validation scheduler...

2017-08-26 15:16:05,056 [main] INFO  [com.fuwh.demo.ShiroDemo02] - 登陆成功！！！

此时，已经可以从表中去验证登陆了。那处理流程又是什么样的呢？

首先我们使用shiro_jdbc.ini来初始化了SecurityManager，在配置文件中，我们定义了连接池信息，还有jdbcRealm，同时在SecurityManager中指定了realm为定义的JjdbcRealm，这时候，其实shiro使用的SecurityManager是一个RealmSecurityManager的实例。而当我们登陆的时候，则会通过配置的jdbcRealm来从数据库中取得用户信息来进行认证。那是怎么取得呢？我们明明没有写sql什么的。

其实，看org.apache.shiro.realm.jdbc.JdbcRealm的源码可以看到，在这个类里面定义了很多的静态sql变量，点此查看，点此查看sql内容

其中比较重要的是AuthenticationQuery这个字段，默认情况下它的值是等于Default_Authentication_query。

Default_Authentication_Query="select password from users where username=?";

所以在默认情况下，它会从users这个表中通过username这个key来查找password。从而拿来跟我们提交的密码来进行匹配验证。

如果我们不想使用默认的数据库，默认的表名，默认的列名的话，也可以通过在配置文件中重写AuthenticationQuery的值来个性化sql文。

首先修改新建一个表members：

USE `db_shiro`;

DROP TABLE IF EXISTS `members`;

CREATE TABLE `members` (

  `id` INT(4) NOT NULL AUTO_INCREMENT,

  `userName` VARCHAR(20) DEFAULT NULL,

  `pass` VARCHAR(100) DEFAULT NULL,

  UNIQUE KEY `id` (`id`)

) ENGINE=INNODB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

INSERT  INTO `members`(`id`,`userName`,`pass`) VALUES (1,'fuwh','');

然后修改shiro_jdbc_sql.ini配置文件：

[main]

dataSource=com.mchange.v2.c3p0.ComboPooledDataSource

dataSource.driverClass=com.mysql.jdbc.Driver

dataSource.jdbcUrl=jdbc:mysql://localhost:3306/db_shiro

dataSource.user=root

dataSource.password=rootadmin

;this is comment read from mysql

jdbcRealm=org.apache.shiro.realm.jdbc.JdbcRealm

jdbcRealm.dataSource=$dataSource

jdbcRealm.authenticationQuery=select pass from members where userName=?

securityManager.realms=$jdbcRealm

修改认证程序的配置文件：

package com.fuwh.demo;

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;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class ShiroDemoSql02 {

    private static Logger log=LoggerFactory.getLogger(ShiroDemoSql02.class);

    public static void main(String[] args) {

        //取得SecurityManager工厂

        Factory<SecurityManager> factory=new IniSecurityManagerFactory("classpath:shiro_jdbc_sql.ini");

        //取得SecurityManager实例

        SecurityManager securityManager=factory.getInstance();

        //将securityManager绑定到SecurityUtil

        SecurityUtils.setSecurityManager(securityManager);

        /*    至此为止，简单的从mysql数据库读取realm信息的shiro环境就配置好了    */

        //取得当前用户

        Subject currentUser=SecurityUtils.getSubject();

        //使用shiro来进行登陆验证

        if(!currentUser.isAuthenticated()) {

            UsernamePasswordToken token=new UsernamePasswordToken("fuwh","123");

            try {

                currentUser.login(token);

                log.info("登陆成功！！！");

            } catch (Exception e) {

                e.printStackTrace();

                log.error("认证失败...");

            }

        }

        currentUser.logout();

    }

}

后面我们会讲到角色认证也是同样的道理。

自定义Realm

上面我们使用的是Shiro提供的默认的Realm，下面我们自定义一个从数据库中读取信息的Realm，通过继承AuthorizingRealm。

package com.fuwh.realm;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import org.apache.shiro.authc.AuthenticationException;

import org.apache.shiro.authc.AuthenticationInfo;

import org.apache.shiro.authc.AuthenticationToken;

import org.apache.shiro.authc.SimpleAuthenticationInfo;

import org.apache.shiro.authz.AuthorizationInfo;

import org.apache.shiro.realm.AuthorizingRealm;

import org.apache.shiro.subject.PrincipalCollection;

import com.fuwh.util.DbUtil;

public class MyJdbcRealm extends AuthorizingRealm{

    @Override

    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {

        // TODO Auto-generated method stub

        return null;

    }

    @Override

    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

        // TODO Auto-generated method stub

        Connection conn=DbUtil.getConnection();

        String sql="select * from members2 where username=?";

        try {

            PreparedStatement ps=conn.prepareStatement(sql);

            ps.setString(1, token.getPrincipal().toString());

            ResultSet rs=ps.executeQuery();

            while(rs.next()) {

                AuthenticationInfo info=new SimpleAuthenticationInfo(rs.getString("username"),rs.getString("password"),"salt");

                return info;

            }

        } catch (SQLException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        return null;

    }

}

修改配置文件

[main]

myJdbcRealm=com.fuwh.realm.MyJdbcRealm

securityManager.realms=$myJdbcRealm

编写登陆类：

package com.fuwh.demo;

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;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class ShiroDemoMySql02 {

    private static Logger log=LoggerFactory.getLogger(ShiroDemoMySql02.class);

    public static void main(String[] args) {

        //取得SecurityManager工厂

        Factory<SecurityManager> factory=new IniSecurityManagerFactory("classpath:shiro_jdbc_my_sql.ini");

        //取得SecurityManager实例

        SecurityManager securityManager=factory.getInstance();

        //将securityManager绑定到SecurityUtil

        SecurityUtils.setSecurityManager(securityManager);

        /*    至此为止，简单的从mysql数据库读取realm信息的shiro环境就配置好了    */

        //取得当前用户

        Subject currentUser=SecurityUtils.getSubject();

        //使用shiro来进行登陆验证

        if(!currentUser.isAuthenticated()) {

            UsernamePasswordToken token=new UsernamePasswordToken("fuwh","123");

            try {

                currentUser.login(token);

                log.info("登陆成功！！！");

            } catch (Exception e) {

                e.printStackTrace();

                log.error("认证失败...");

            }

        }

        currentUser.logout();

    }

}

那如果我们定义了多个Realm呢？

在编写一个Realm类：

package com.fuwh.realm;

import org.apache.shiro.authc.AuthenticationException;

import org.apache.shiro.authc.AuthenticationInfo;

import org.apache.shiro.authc.AuthenticationToken;

import org.apache.shiro.authc.SimpleAuthenticationInfo;

import org.apache.shiro.authz.AuthorizationInfo;

import org.apache.shiro.realm.AuthorizingRealm;

import org.apache.shiro.subject.PrincipalCollection;

public class MyJdbcRealm2 extends AuthorizingRealm{

    @Override

    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {

        // TODO Auto-generated method stub

        return null;

    }

    @Override

    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

        // TODO Auto-generated method stub

        return    new SimpleAuthenticationInfo(token.getPrincipal(),"1234","salt");

    }

}

修改shiro_jdbc_my_sql_2.ini配置文件：

[main]

myJdbcRealm=com.fuwh.realm.MyJdbcRealm

myJdbcRealm2=com.fuwh.realm.MyJdbcRealm2

authStrategy=org.apache.shiro.authc.pam.AtLeastOneSuccessfulStrategy

securityManager.realms=$myJdbcRealm,$myJdbcRealm2

securityManager.authenticator.authenticationStrategy=$authStrategy

修改登陆类：

package com.fuwh.demo;

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;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class ShiroDemoMySql02_2 {

    private static Logger log=LoggerFactory.getLogger(ShiroDemoMySql02_2.class);

    public static void main(String[] args) {

        //取得SecurityManager工厂

        Factory<SecurityManager> factory=new IniSecurityManagerFactory("classpath:shiro_jdbc_my_sql_2.ini");

        //取得SecurityManager实例

        SecurityManager securityManager=factory.getInstance();

        //将securityManager绑定到SecurityUtil

        SecurityUtils.setSecurityManager(securityManager);

        /*    至此为止，简单的从mysql数据库读取realm信息的shiro环境就配置好了    */

        //取得当前用户

        Subject currentUser=SecurityUtils.getSubject();

        //使用shiro来进行登陆验证

        if(!currentUser.isAuthenticated()) {

            UsernamePasswordToken token=new UsernamePasswordToken("fuwh","123");

            try {

                currentUser.login(token);

                log.info("登陆成功！！！");

            } catch (Exception e) {

                e.printStackTrace();

                log.error("认证失败...");

            }

        }

        currentUser.logout();

    }

}

上面的例子中使用的认证策略是只有一个成功就认为是成功。

在Shiro中还提供了下面几个策略：

FirstSuccessfulStrategy：只有第一个认证成功的信息会被用

AllSuccessfulStrategy：只有当所有的都成功的时候才认为是认证成功。

源码地址：https://github.com/oukafu/shiro

码农公寓

相关文章