href=”#what-is-apache-shiro-” What is Apache Shiro?

Apache Shiro is a powerful and flexible open-source security framework that cleanly handles authentication, authorization, enterprise session management and cryptography.

包名

Maven 坐标

说明

shiro-all

Not Recommended

Includes all binary functionality for Shiro

shiro-core

<dependency> 
  <groupId>org.apache.shiro</groupId>    
  <artifactId>shiro-core</artifactId>  
  <version>1.3.2</version> 
</dependency> 

Required in all environments. Slf4j’s slf4j-api jar and one

of its binding jars is required. commons-beanutils is required only if using INI config.

只要使用shiro必须的核心包，它依赖slf4j 和 commons-beanutils 以及还需要一个INI配置文件

shiro-web

<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-web</artifactId>
  <version>1.3.2</version>
</dependency>

Enables support for web-based applications.

支持基于Web的应用

shiro-aspectj

<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-aspectj</artifactId>
  <version>1.3.2</version>
</dependency>

Enables AspectJ support for Shiro AOP and Annotations.

shiro-cas

<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-cas</artifactId>
  <version>1.3.2</version>
</dependency>

Enables Jasig CAS support.
 NOTE:
Shiro-CAS support is deprecated, support has been moved to

the Apache Shiro based buji-pac4j project.

对cas单点登录框架的支持

shiro-ehcache

<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-ehcache</artifactId>
  <version>1.3.2</version>
</dependency>

Enables Ehcache-based famework caching.

对echche缓存框架的支持

shiro-hazelcast

<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-hazelcast</artifactId>
  <version>1.3.2</version>
</dependency>

Enables Hazelcast-based famework caching.

shiro-features

<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-features</artifactId>
  <version>1.3.2</version>
</dependency>

OSGi / Apache Karaf integration.

shiro-guice

<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-guice</artifactId>
  <version>1.3.2</version>
</dependency>

Enables Google Guice integration.

guice 类似spring的ioc框架。

shiro-quartz

<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-quartz</artifactId>
  <version>1.3.2</version>
</dependency>

Enables Quartz-based scheduling for Shiro native session validation.

quartz定时器框架

shiro-spring

<dependency>
  <groupId>org.apache.shiro</groupId>
  <artifactId>shiro-spring</artifactId>
  <version>1.3.2</version>
</dependency>

Enables Spring Framework integration.

[main]   #用于配置SecurityManager里面的对象 

  对象名=类全限制名

  对象名.属性[.属性…] = 值

[users]   #用于配置用户名信息

   用户名= 密码, 角色1, 角色2, …, 角色N

[roles]   #用于配置角色信息

   角色名= 权限1, 权限2, …, 权限N   #全部权限使用 * （星号）

[urls]    #用于配置路径拦截规则

[users]

 jim = jim,admin

[roles]

 admin = *

package cn.gzsxt.shiro;

import org.apache.shiro.SecurityUtils;

import org.apache.shiro.authc.AuthenticationException;

import org.apache.shiro.authc.AuthenticationToken;

import org.apache.shiro.authc.UsernamePasswordToken;

import org.apache.shiro.config.IniSecurityManagerFactory;

import org.apache.shiro.mgt.SecurityManager;

import org.apache.shiro.subject.Subject;

public class ShiroDemo {

public static void main(String[] args) {

// 1.获得SecurityManager对象

IniSecurityManagerFactory factory = new IniSecurityManagerFactory(“classpath:shiro.ini”);

SecurityManager securityManager = factory.createInstance();

//2.设置SecurityUtils使用的安全管理器是securityManager

SecurityUtils.setSecurityManager(securityManager);

//2.获得subject

Subject subject = SecurityUtils.getSubject();

AuthenticationToken token=new UsernamePasswordToken(“jim”, “jim”);

//3.校验用户名密码是否正确

try {

Subject resultSubject = securityManager.login(subject, token);

//获得用户名

System.out.println(resultSubject.getPrincipal());

//判断是否拥有admin角色

boolean hasRole = resultSubject.hasRole(“admin”);

System.out.println(hasRole);

} catch (AuthenticationException e) {

System.out.println(“校验失败，用户名或者密码不正确”);

e.printStackTrace();

}

}

}

[main]

#声明realm对象

myRealm=cn.gzsxt.realm.MyRealm

#指定securityManager的realm对象

securityManager.realms=$myRealm

package cn.gzsxt.test;

import org.apache.shiro.SecurityUtils;

import org.apache.shiro.authc.AuthenticationException;

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.junit.Test;

public class PermissionTest {

@Test

public void authc(){

try {

//第一步：获得SecurityManager对象

IniSecurityManagerFactory ismf=new IniSecurityManagerFactory(“classpath:shiro.ini”);

SecurityManager securityManager = ismf.createInstance();

//第二步：构造一个subject

SecurityUtils.setSecurityManager(securityManager);

Subject subject = SecurityUtils.getSubject();

//第三步：封装用户名密码（身份信息）

UsernamePasswordToken token=new UsernamePasswordToken(“zhangsan”, “123456”);

//第四步：校验（登录）

Subject resultSubject = securityManager.login(subject, token);

//第五步：验证是否通过

System.out.println(resultSubject.isAuthenticated());

} catch (AuthenticationException e) {

e.printStackTrace();

}

}

}

package cn.gzsxt.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;

/**

 * 自动一个MyRealm类，用于权限验证以及权限授予

 *

 * @author ranger

 *

 */

public class MyRealm extends AuthorizingRealm {

/**

 * 权限验证 所谓的权限验证，就是验证访问者（subject）.是否使用有使用权限的身份。 说白了，就验证用户名密码是否正确

 *

 * 如果校验成功，我们就返回AuthenticationInfo对象 如果校验失败，我们需要返回一个异常

 * UnknownAccountException

 *

 */

@Override

protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

System.out.println(“用户名：” + token.getPrincipal());

if (token.getPrincipal().equals(“zhangsan”)) {

return new SimpleAuthenticationInfo(token.getPrincipal(), “123456”,

this.getName());

} else {

return null;

}

}

/**

 * 授权 根据通过校验的身份（subject）,说白了就是登录成功的访问者，我们给予什么权限。

 * 将查询到的权限信息封装在AuthorizationInfo里面返回！！

 */

@Override

protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection collection) {

return null;

}

}

package cn.gzsxt.test;

import org.apache.shiro.crypto.hash.SimpleHash;

import org.apache.shiro.util.ByteSource;

//注意事项：设置的创建密码的参数必须与校验器的参数保持一致

public class CreatePasswordUtils {

public static void main(String[] args) {

   //加密方式

        String hashAlgorithmName = “MD5”;

        //明文密码

        Object credentials = “123456”;

        //盐值

        Object salt = ByteSource.Util.bytes(“nchu234we”);

        //迭代加密的次数，

        int hashIterations = 1;

        //返回加密的结果

        Object result = new SimpleHash(hashAlgorithmName, credentials, salt, hashIterations);

        //加密后的密码

        System.out.println(result);

}

}

[main]

# 对象名 =类全限制名 ，就是创建一个对象

myRealm = cn.gzsxt.realm.MyRealm

#加密的对象

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

#设置加密的算法为md5 ，属性对应的是set方法

credentialsMatcher.hashAlgorithmName=md5

#设置md5加密次数为1次

credentialsMatcher.hashIterations=1

#设置md5算法是加盐

credentialsMatcher.hashSalted=true

#将加密对象指定给对应给myRealm对象

myRealm.credentialsMatcher=$credentialsMatcher

#将realm对象加入到securityManager容器里面

#引用 securityManager.realms = $对象名

#securityManager对象名是shiro固定的。用于指定securityManager容器

#对象的引用格式为： 对象名.属性名 = $对象名；

securityManager.realms = $myRealm

package cn.gzsxt.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;

import org.apache.shiro.util.ByteSource;

/**

 * Realm :所有Realm的父接口

 * AuthenticatingRealm ：只有权限校验，没有权限授权的Realm

 * AuthorizingRealm ： 既有权限校验，权限授权的Realm （主要就是使用它）

 * JdbcRealm：使用实现的对数据库 操作的代码的Realm。它已经写死了表名，必要要按它定义的表名定义数据库表。（灵活性差）

 *

 * 注意事项：使用Realm，将验证认证信息与获得授权信息，都放在一起！！！！！

 * @author ranger

 *

 *

 */

public class MyRealm extends AuthorizingRealm {

/**

 * 用于权限校验

 */

@Override

protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

try {

System.out.println(“=权限校验=”);

//第一步：获得请求过来的用户名

Object principal = token.getPrincipal();

//第二步：根据用户查询数据库，返回用户信息 （模拟数据，查询到了“admin“）

if(“admin”.equals(principal)){

//第三步：如果用户名相同，校验密码,如果密码正确，不会报异常，如果校验不通过就报异常

//参数1：用户名

//参数2：校验的密码,从数据库查询出来的

//参数3：realm的名字 。随便设置一个唯一字符串

//4). md5加密盐值

        ByteSource salt = ByteSource.Util.bytes(“nchu234we”);

SimpleAuthenticationInfo authenticationInfo=new SimpleAuthenticationInfo(principal,“8763d15228c560fed665e1fe73b2f601”,salt,this.getName());

return authenticationInfo;

}

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

/**

 * 权限授权

 */

@Override

protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection token) {

return null;

}

}

package cn.gzsxt.javabean;

import java.io.Serializable;

/**

 * 注意：因为Shiro是一个支持缓存的框架，所以实体类需要实现序列化接口

 * @author ranger

 *

 */

public class ActiveUser implements Serializable{

private static final long serialVersionUID = -1354674546192347496L;

private Integer userId;

public Integer getUserId() {

return userId;

}

public void setUserId(Integer userId) {

this.userId = userId;

}

private String username;

private String password;

private Integer age;

private Integer status;

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;

}

public Integer getAge() {

return age;

}

public void setAge(Integer age) {

this.age = age;

}

public Integer getStatus() {

return status;

}

public void setStatus(Integer status) {

this.status = status;

}

public static long getSerialversionuid() {

return serialVersionUID;

}

}

package cn.gzsxt.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;

import org.apache.shiro.util.ByteSource;

import cn.gzsxt.javabean.ActiveUser;

/**

 * Realm :所有Realm的父接口

 * AuthenticatingRealm ：只有权限校验，没有权限授权的Realm

 * AuthorizingRealm ： 既有权限校验，权限授权的Realm （主要就是使用它）

 * JdbcRealm：使用实现的对数据库 操作的代码的Realm。它已经写死了表名，必要要按它定义的表名定义数据库表。（灵活性差）

 *

 * 注意事项：使用Realm，将验证认证信息与获得授权信息，都放在一起！！！！！

 * @author ranger

 *

 *

 */

public class MyRealm extends AuthorizingRealm {

/**

 * 用于权限校验

 */

@Override

protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

try {

System.out.println(“=权限校验=”);

//第一步：获得请求过来的用户名

Object principal = token.getPrincipal();

//第二步：根据用户查询数据库，返回用户信息 （模拟数据，查询到了“admin“）

if(“admin”.equals(principal)){

//第三步：如果用户名相同，校验密码,如果密码正确，不会报异常，如果校验不通过就报异常

//参数1：用户名

//参数2：校验的密码,从数据库查询出来的

//参数3：realm的名字 。随便设置一个唯一字符串

ActiveUser user=new ActiveUser();

user.setUserId(1);

user.setAge(20);

user.setPassword(“8763d15228c560fed665e1fe73b2f601”);

user.setUsername(“admin”);

user.setStatus(0);

//4). md5加密盐值

        ByteSource credentialsSalt = ByteSource.Util.bytes(“nchu234we”);

        //参数1：用于设置认证信息，返回给调用对象的

        //参数2：校验的密码

        //参数3：如果配置了Md5加密，而且设置了需要加盐，该参数就是密码的盐

        //参数4：指定realm的名字，随便写个唯一的字符串就可以。建议直接使用this.getName();

SimpleAuthenticationInfo authenticationInfo=new SimpleAuthenticationInfo(user,”8763d15228c560fed665e1fe73b2f601″,credentialsSalt,this.getName());

return authenticationInfo;

}

} catch (Exception e) {

e.printStackTrace();

}

         //如果校验成功，返回null

return null;

}

/**

 * 权限授权

 */

@Override

protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection token) {

return null;

}

}

package cn.gzsxt.test;

import java.util.ArrayList;

import java.util.List;

import org.apache.shiro.SecurityUtils;

import org.apache.shiro.authc.AuthenticationException;

import org.apache.shiro.authc.UsernamePasswordToken;

import org.apache.shiro.config.IniSecurityManagerFactory;

import org.apache.shiro.mgt.SecurityManager;

import org.apache.shiro.subject.Subject;

/**

 * 注意：根据示例

 * 1.身份信息是放在Subject这个身份对象里面的

 * 2.Shiro的所有对象是通过securityManager来管理

 * 3.可以在配置文件配置，认证的信息（数据库里面的表数据）

 * @author ranger

 *

 */

public class ShiroTest {

public static void main(String[] args) {

//第一步：读取配置文件

IniSecurityManagerFactory factory= new IniSecurityManagerFactory(“classpath:shiro.ini”);

//第二步：获得安全管理器

SecurityManager securityManager = factory.createInstance();

//第三步：通过安全管理器帮助类构建一个Subject（身份）

SecurityUtils.setSecurityManager(securityManager);

Subject subject = SecurityUtils.getSubject();

//第四步：构建身份信息（用户名/密码）

UsernamePasswordToken token = new  UsernamePasswordToken(“admin”,”123456″);

//第五步：校验是否成功,将一个空的身份，以及身份信息通过登录方法，如果成功返回带身份信息的Subject对象。如果不成功就报异常

try {

Subject result = securityManager.login(subject, token);

System.out.println(“认证成功，用户名“+result.getPrincipals());

boolean flag = result.isAuthenticated();

//使用校验方法，校验用户对应的角色

boolean hasRole = result.hasRole(“roleAdmin”);

System.out.println(“是否有指定的角色：“+hasRole);

List<String> hasRoles=new ArrayList<>();

hasRoles.add(“roleAdmin”);

hasRoles.add(“roleEdu”);

boolean allRoles = result.hasAllRoles(hasRoles);

System.out.println(“是否都包括集合的所有角色:”+allRoles);

//校验用户是否有对应的权限

boolean permitted = result.isPermitted(“user:add”);

System.out.println(“是否有user:add权限：“+permitted);

boolean permitted2 = result.isPermitted(“modular:add”);

System.out.println(“是否有modular:add权限：“+permitted2);

System.out.println(flag);

} catch (AuthenticationException e) {

System.out.println(“用户名或者密码出错“);

e.printStackTrace();

}

}

}

#users标签：用于指定用户信息，以及用户的角色

#注意：shiro的支持一个用于有多个角色的

#用户名= 密码, 角色1, 角色2, …, 角色N

#如果出现多个角色，用于取的是角色的并集

[users]

   admin = 123456,roleAdmin,roleEdu

#roles标签：用于设置角色的信息，包括的角色以及权限

#权限字符串的格式为：模块名:操作:操作…  类似我们的子权限的设置  

[roles]

   roleAdmin = user:query,user:add,user:delete,modular:*

   roleEdu = edu:query,edu:add

package cn.gzsxt.javabean;

import java.io.Serializable;

/**

 * 注意：因为Shiro是一个支持缓存的框架，所以实体类需要实现序列化接口

 * @author ranger

 *

 */

public class ActiveUser implements Serializable{

private static final long serialVersionUID = -1354674546192347496L;

private Integer userId;

public Integer getUserId() {

return userId;

}

public void setUserId(Integer userId) {

this.userId = userId;

}

private String username;

private String password;

private Integer age;

private Integer status;

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;

}

public Integer getAge() {

return age;

}

public void setAge(Integer age) {

this.age = age;

}

public Integer getStatus() {

return status;

}

public void setStatus(Integer status) {

this.status = status;

}

public static long getSerialversionuid() {

return serialVersionUID;

}

}

package cn.gzsxt.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.authz.SimpleAuthorizationInfo;

import org.apache.shiro.realm.AuthorizingRealm;

import org.apache.shiro.subject.PrincipalCollection;

import org.apache.shiro.util.ByteSource;

import cn.gzsxt.javabean.ActiveUser;

import cn.gzsxt.javabean.Role;

/**

 * Realm :所有Realm的父接口

 * AuthenticatingRealm ：只有权限校验，没有权限授权的Realm

 * AuthorizingRealm ： 既有权限校验，权限授权的Realm （主要就是使用它）

 * JdbcRealm：使用实现的对数据库 操作的代码的Realm。它已经写死了表名，必要要按它定义的表名定义数据库表。（灵活性差）

 *

 * 注意事项：使用Realm，将验证认证信息与获得授权信息，都放在一起！！！！！

 * @author ranger

 *

 *

 */

public class MyRealm extends AuthorizingRealm {

/**

 * 用于权限校验

 */

@Override

protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

try {

System.out.println(“=权限校验=”);

//第一步：获得请求过来的用户名

Object principal = token.getPrincipal();

//第二步：根据用户查询数据库，返回用户信息 （模拟数据，查询到了“admin“）

if(“admin”.equals(principal)){

//第三步：如果用户名相同，校验密码,如果密码正确，不会报异常，如果校验不通过就报异常

//参数1：用户名

//参数2：校验的密码,从数据库查询出来的

//参数3：realm的名字 。随便设置一个唯一字符串

ActiveUser user=new ActiveUser();

user.setUserId(1);

user.setAge(20);

user.setPassword(“8763d15228c560fed665e1fe73b2f601”);

user.setUsername(“admin”);

user.setStatus(0);

//4). md5加密盐值

        ByteSource credentialsSalt = ByteSource.Util.bytes(“nchu234we”);

        //参数1：用于设置认证信息，返回给调用对象的

        //参数2：校验的密码

        //参数3：如果配置了Md5加密，而且设置了需要加盐，该参数就是密码的盐

        //参数4：指定realm的名字，随便写个唯一的字符串就可以。建议直接使用this.getName();

SimpleAuthenticationInfo authenticationInfo=new SimpleAuthenticationInfo(user,”8763d15228c560fed665e1fe73b2f601″,credentialsSalt,this.getName());

return authenticationInfo;

}

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

/**

 * 权限授权，必须在通过验证后才执行的方法

 */

@Override

protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection token) {

System.out.println(“===权限授予====”);

//获得当前通过验证的用户，为什么可以获得校验后的用户信息呢？

//答：因为就是如果通不过校验，肯定就会有有授权，进入了授权肯定就有校验的认证用户了

ActiveUser user=(ActiveUser) token.getPrimaryPrincipal();

SimpleAuthorizationInfo authorizationInfo=new SimpleAuthorizationInfo();

authorizationInfo.addStringPermission(“user:query”);

authorizationInfo.addStringPermission(“user:add”);

authorizationInfo.addStringPermission(“user:delete”);

authorizationInfo.addStringPermission(“user:edit”);

authorizationInfo.addStringPermission(“modular:*”);

authorizationInfo.addRole(“roleAdmin”);

//将权限设置角色里面

         Role role=new Role();

role.setPermisssion(authorizationInfo.getStringPermissions());

         user.setRole(role);

return authorizationInfo;

}

}

[main]

# 对象名 =类全限制名 ，就是创建一个对象

myRealm = cn.gzsxt.realm.MyRealm

#加密的对象

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

#设置加密的算法为md5

credentialsMatcher.hashAlgorithmName=md5

#设置md5加密次数为1次

credentialsMatcher.hashIterations=1

#设置md5算法是加盐

credentialsMatcher.hashSalted=true

#将加密对象指定给对应给myRealm对象

myRealm.credentialsMatcher=$credentialsMatcher

#将realm对象加入到securityManager容器里面

#引用 securityManager.realms = $对象名

#securityManager对象名是shiro固定的。用于指定securityManager容器

#对象的引用格式为： 对象名.属性名 = $对象名；

securityManager.realms = $myRealm

package cn.gzsxt.test;

import java.util.ArrayList;

import java.util.List;

import org.apache.shiro.SecurityUtils;

import org.apache.shiro.authc.AuthenticationException;

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 cn.gzsxt.javabean.ActiveUser;

import cn.gzsxt.javabean.Role;

/**

 * 注意：根据示例

 * 1.身份信息是放在Subject这个身份对象里面的

 * 2.Shiro的所有对象是通过securityManager来管理

 * 3.可以在配置文件配置，认证的信息（数据库里面的表数据）

 * @author ranger

 *

 */

public class ShiroTest {

public static void main(String[] args) {

//第一步：读取配置文件

IniSecurityManagerFactory factory= new IniSecurityManagerFactory(“classpath:shiro.ini”);

//第二步：获得安全管理器

SecurityManager securityManager = factory.createInstance();

//第三步：通过安全管理器帮助类构建一个Subject（身份）

SecurityUtils.setSecurityManager(securityManager);

Subject subject = SecurityUtils.getSubject();

//第四步：构建身份信息（用户名/密码）

UsernamePasswordToken token = new  UsernamePasswordToken(“admin”,”123456″);

//第五步：校验是否成功,将一个空的身份，以及身份信息通过登录方法，如果成功返回带身份信息的Subject对象。如果不成功就报异常

try {

Subject result = securityManager.login(subject, token);

System.out.println(“认证成功，用户名“+result.getPrincipals());

boolean flag = result.isAuthenticated();

//使用校验方法，校验用户对应的角色

boolean hasRole = result.hasRole(“roleAdmin”);

System.out.println(“是否有指定的角色：“+hasRole);

List<String> hasRoles=new ArrayList<>();

hasRoles.add(“roleAdmin”);

hasRoles.add(“roleEdu”);

boolean allRoles = result.hasAllRoles(hasRoles);

System.out.println(“是否都包括集合的所有角色:”+allRoles);

//校验用户是否有对应的权限

boolean permitted = result.isPermitted(“user:add”);

System.out.println(“是否有user:add权限：“+permitted);

boolean permitted2 = result.isPermitted(“modular:add”);

System.out.println(“是否有modular:add权限：“+permitted2);

System.out.println(flag);

} catch (AuthenticationException e) {

System.out.println(“用户名或者密码出错“);

e.printStackTrace();

}

}

}

— 导出 shiro-1115 的数据库结构

DROP DATABASE IF EXISTS `shiro-1115`;

CREATE DATABASE IF NOT EXISTS `shiro-1115` /*!40100 DEFAULT CHARACTER SET utf8 */;

USE `shiro-1115`;

— 导出  表 shiro-1115.tb_admin 结构

DROP TABLE IF EXISTS `tb_admin`;

CREATE TABLE IF NOT EXISTS `tb_admin` (

  `admin_id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT ‘管理员编号‘,

  `admin_name` varchar(50) DEFAULT NULL COMMENT ‘管理员名‘,

  `admin_account` varchar(50) DEFAULT NULL COMMENT ‘登录账号‘,

  `admin_pwd` varchar(50) DEFAULT NULL COMMENT ‘登录密码‘,

  `create_date` datetime DEFAULT NULL COMMENT ‘创建日期‘,

  `admin_status` int(11) DEFAULT NULL COMMENT ‘管理员状态 0可用，1禁用‘,

  `role_id` bigint(20) DEFAULT NULL COMMENT ‘角色编号‘,

  PRIMARY KEY (`admin_id`)

) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COMMENT=’管理员‘;

— 正在导出表  shiro-1115.tb_admin 的数据：~1 rows (大约)

DELETE FROM `tb_admin`;

/*!40000 ALTER TABLE `tb_admin` DISABLE KEYS */;

INSERT INTO `tb_admin` (`admin_id`, `admin_name`, `admin_account`, `admin_pwd`, `create_date`, `admin_status`, `role_id`) VALUES

(1, ‘配置管理员‘, ‘admin’, ‘123456’, ‘2019-04-02 16:33:39’, 0, 1);

/*!40000 ALTER TABLE `tb_admin` ENABLE KEYS */;

— 导出  表 shiro-1115.tb_dictionary 结构

DROP TABLE IF EXISTS `tb_dictionary`;

CREATE TABLE IF NOT EXISTS `tb_dictionary` (

  `dictionary_id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT ‘字典编号‘,

  `dictionary_name` varchar(200) DEFAULT NULL COMMENT ‘字典名‘,

  `dictionary_value` varchar(500) DEFAULT NULL COMMENT ‘字典值‘,

  `dictionary_type_code` bigint(20) DEFAULT NULL COMMENT ‘字段类型编码‘,

  `dictionary_type_name` varchar(200) DEFAULT NULL COMMENT ‘字段类型名称‘,

  PRIMARY KEY (`dictionary_id`)

) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT=’tb_dictionary’;

— 正在导出表  shiro-1115.tb_dictionary 的数据：~0 rows (大约)

DELETE FROM `tb_dictionary`;

/*!40000 ALTER TABLE `tb_dictionary` DISABLE KEYS */;

/*!40000 ALTER TABLE `tb_dictionary` ENABLE KEYS */;

— 导出  表 shiro-1115.tb_modular 结构

DROP TABLE IF EXISTS `tb_modular`;

CREATE TABLE IF NOT EXISTS `tb_modular` (

  `modular_id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT ‘模块编号‘,

  `modular_name` varchar(200) DEFAULT NULL COMMENT ‘模块名‘,

  `modular_sort` bigint(20) DEFAULT NULL COMMENT ‘排序顺序‘,

  PRIMARY KEY (`modular_id`)

) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COMMENT=’模块表‘;

— 正在导出表  shiro-1115.tb_modular 的数据：~0 rows (大约)

DELETE FROM `tb_modular`;

/*!40000 ALTER TABLE `tb_modular` DISABLE KEYS */;

INSERT INTO `tb_modular` (`modular_id`, `modular_name`, `modular_sort`) VALUES

(1, ‘系统管理模块‘, 0);

/*!40000 ALTER TABLE `tb_modular` ENABLE KEYS */;

— 导出  表 shiro-1115.tb_permission 结构

DROP TABLE IF EXISTS `tb_permission`;

CREATE TABLE IF NOT EXISTS `tb_permission` (

  `permission_id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT ‘权限编号‘,

  `permission_name` varchar(200) DEFAULT NULL COMMENT ‘权限名‘,

  `permission_action` varchar(500) DEFAULT NULL COMMENT ‘权限路径，匹配路径是否有权限‘,

  `permission_is_show` int(11) DEFAULT NULL COMMENT ‘是否显示‘,

  `permission_key` varchar(500) DEFAULT NULL COMMENT ‘父菜单编号，0表示顶级菜单‘,

  `modular_id` bigint(20) DEFAULT NULL COMMENT ‘模块编号‘,

  PRIMARY KEY (`permission_id`)

) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8 COMMENT=’权限表‘;

— 正在导出表  shiro-1115.tb_permission 的数据：~2 rows (大约)

DELETE FROM `tb_permission`;

/*!40000 ALTER TABLE `tb_permission` DISABLE KEYS */;

INSERT INTO `tb_permission` (`permission_id`, `permission_name`, `permission_action`, `permission_is_show`, `permission_key`, `modular_id`) VALUES

(1, ‘管理员管理‘, ‘/admin/toAdminList’, 0, ‘admin:list’, 1),

(2, ‘管理员管理-To增加‘, ‘/admin/toAdminAdd’, 0, ‘admin:list:to_add’, 1),

(3, ‘管理员管理–增加‘, ‘/admin/addAdmin’, 0, ‘admin:list:add’, 1);

/*!40000 ALTER TABLE `tb_permission` ENABLE KEYS */;

— 导出  表 shiro-1115.tb_role 结构

DROP TABLE IF EXISTS `tb_role`;

CREATE TABLE IF NOT EXISTS `tb_role` (

  `role_id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT ‘角色编号‘,

  `role_name` varchar(50) DEFAULT NULL COMMENT ‘角色名‘,

  `role_permissions` varchar(1000) DEFAULT NULL COMMENT ‘权限集，权限编号使用逗号分隔‘,

  PRIMARY KEY (`role_id`)

) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COMMENT=’角色‘;

— 正在导出表  shiro-1115.tb_role 的数据：~1 rows (大约)

DELETE FROM `tb_role`;

/*!40000 ALTER TABLE `tb_role` DISABLE KEYS */;

INSERT INTO `tb_role` (`role_id`, `role_name`, `role_permissions`) VALUES

(1, ‘超级管理员‘, ‘1,2,3’);

/*!40000 ALTER TABLE `tb_role` ENABLE KEYS */;

[users]

   admin = 123456,roleAdmin

[roles]

   roleAdmin = user:list,user:list:add,user:list:to_add

package cn.gzsxt.test;

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;

public class ShiroTest {

public static void main(String[] args) {

//第一步：读取配置文件,创建SecurityManager容器

IniSecurityManagerFactory factory=new IniSecurityManagerFactory(“classpath:shiro.ini”);

SecurityManager securityManager = factory.createInstance();

//第二步：通过SecurityUtil获得一个身份对象

SecurityUtils.setSecurityManager(securityManager);

Subject subject = SecurityUtils.getSubject();

//第三步：构建一个身份信息（Token）

UsernamePasswordToken token=new UsernamePasswordToken(“admin”,”123456″);

//验证信息，获得配置文件的身份信息以及权限

Subject resultSubject = securityManager.login(subject, token);

System.out.println(“用户信息：“+resultSubject.getPrincipal());

}

}

package cn.gzsxt.pojo;

import java.io.Serializable;

public class Admin implements Serializable {

private static final long serialVersionUID = -4165903044029644075L;

private Long adminId;//BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT ‘管理员编号‘,

private String adminName;//VARCHAR(50) NULL DEFAULT NULL COMMENT ‘管理员名‘,

private String adminAccount;//VARCHAR(50) NULL DEFAULT NULL COMMENT ‘登录账号‘,

private String adminPwd;//VARCHAR(50) NULL DEFAULT NULL COMMENT ‘登录密码‘,

private String createDate;//DATETIME NULL DEFAULT NULL COMMENT ‘创建日期‘,

private Integer adminStatus;//INT(11) NULL DEFAULT NULL COMMENT ‘管理员状态 0可用，1禁用‘,

private Long roleId;//BIGINT(20) NULL DEFAULT NULL COMMENT ‘角色编号‘,

//一个管理员只能是有一个角色

private Role role;

public Role getRole() {

return role;

}

public void setRole(Role role) {

this.role = role;

}

public Long getAdminId() {

return adminId;

}

public void setAdminId(Long adminId) {

this.adminId = adminId;

}

public String getAdminName() {

return adminName;

}

public void setAdminName(String adminName) {

this.adminName = adminName;

}

public String getAdminAccount() {

return adminAccount;

}

public void setAdminAccount(String adminAccount) {

this.adminAccount = adminAccount;

}

public String getAdminPwd() {

return adminPwd;

}

public void setAdminPwd(String adminPwd) {

this.adminPwd = adminPwd;

}

public String getCreateDate() {

return createDate;

}

public void setCreateDate(String createDate) {

this.createDate = createDate;

}

public Integer getAdminStatus() {

return adminStatus;

}

public void setAdminStatus(Integer adminStatus) {

this.adminStatus = adminStatus;

}

public Long getRoleId() {

return roleId;

}

public void setRoleId(Long roleId) {

this.roleId = roleId;

}

}

package cn.gzsxt.pojo;

import java.io.Serializable;

import java.util.List;

public class Role implements Serializable {

private static final long serialVersionUID = 7439278538619165462L;

private Long roleId;//BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT ‘角色编号‘,

private String roleName;//VARCHAR(50) NULL DEFAULT NULL COMMENT ‘角色名‘,

private String rolePermissions;//VARCHAR(1000) NULL DEFAULT NULL COMMENT ‘权限集，权限编号使用逗号分隔‘,

//一个就是有多个权限

private List<Permission> permissions;

public List<Permission> getPermissions() {

return permissions;

}

public void setPermissions(List<Permission> permissions) {

this.permissions = permissions;

}

public Long getRoleId() {

return roleId;

}

public void setRoleId(Long roleId) {

this.roleId = roleId;

}

public String getRoleName() {

return roleName;

}

public void setRoleName(String roleName) {

this.roleName = roleName;

}

public String getRolePermissions() {

return rolePermissions;

}

public void setRolePermissions(String rolePermissions) {

this.rolePermissions = rolePermissions;

}

}

package cn.gzsxt.pojo;

import java.io.Serializable;

public class Permission implements Serializable {

private static final long serialVersionUID = -8720560773258570437L;

private Long permissionId;//BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT ‘权限编号‘,

private String permissionName;//VARCHAR(200) NULL DEFAULT NULL COMMENT ‘权限名‘,

private String permissionAction;//VARCHAR(500) NULL DEFAULT NULL COMMENT ‘权限路径，匹配路径是否有权限‘,

private Integer permissionIsShow;//INT(11) NULL DEFAULT NULL COMMENT ‘是否显示‘,

private String permissionKey;//VARCHAR(500) NULL DEFAULT NULL COMMENT ‘父菜单编号，0表示顶级菜单‘,

private Long modularId;//BIGINT(20) NULL DEFAULT NULL COMMENT ‘模块编号‘,

public Long getPermissionId() {

return permissionId;

}

public void setPermissionId(Long permissionId) {

this.permissionId = permissionId;

}

public String getPermissionName() {

return permissionName;

}

public void setPermissionName(String permissionName) {

this.permissionName = permissionName;

}

public String getPermissionAction() {

return permissionAction;

}

public void setPermissionAction(String permissionAction) {

this.permissionAction = permissionAction;

}

public Integer getPermissionIsShow() {

return permissionIsShow;

}

public void setPermissionIsShow(Integer permissionIsShow) {

this.permissionIsShow = permissionIsShow;

}

public String getPermissionKey() {

return permissionKey;

}

public void setPermissionKey(String permissionKey) {

this.permissionKey = permissionKey;

}

public Long getModularId() {

return modularId;

}

public void setModularId(Long modularId) {

this.modularId = modularId;

}

}

package cn.gzsxt.utils;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.SQLException;

public class DbUitls {

//1.获得数据库连接

public static Connection getConnection(){

//四要素

String driver=”org.gjt.mm.mysql.Driver”;

String url=”jdbc:mysql://localhost:3306/shiro-1115″;

String user=”root”;

String password=”123456″;

//加载驱动

try {

Class.forName(driver);

return DriverManager.getConnection(url, user, password);

} catch (ClassNotFoundException e) {

e.printStackTrace();

} catch (SQLException e) {

e.printStackTrace();

}

return null;

}

public static void main(String[] args) {

System.out.println(DbUitls.getConnection());

}

}

package cn.gzsxt.realm;

import java.sql.SQLException;

import java.util.List;

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.authz.SimpleAuthorizationInfo;

import org.apache.shiro.realm.AuthorizingRealm;

import org.apache.shiro.subject.PrincipalCollection;

import org.apache.shiro.util.ByteSource;

import cn.gzsxt.dao.AdminDAO;

import cn.gzsxt.dao.PermissionDAO;

import cn.gzsxt.dao.RoleDAO;

import cn.gzsxt.pojo.Admin;

import cn.gzsxt.pojo.Permission;

import cn.gzsxt.pojo.Role;

public class MyRealm extends AuthorizingRealm {

private AdminDAO adminDAO = new AdminDAO();

private RoleDAO roleDAO=new RoleDAO();

private PermissionDAO permissionDAO =new PermissionDAO();

/**

 * 权限验证

 */

@Override

protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

System.out.println(“=权限验证==”);

// 连接数据库，通过用户名查询用户信息

// 1.获得认证信息，账号名

String adminAccount = (String) token.getPrincipal();

// 2.通过账号名查询查询指定的管理员记录

try {

Admin admin = adminDAO.findByAccount(adminAccount);

//密码加盐

ByteSource salt=ByteSource.Util.bytes(“asdfwera”+admin.getAdminSalt());

SimpleAuthenticationInfo authenticationInfo=new SimpleAuthenticationInfo(admin,admin.getAdminPwd(),salt,this.getName());

return authenticationInfo;

} catch (SQLException e) {

e.printStackTrace();

}

return null;

}

/**

 * 权限授权，授予必须依赖权限验证通过

 */

@Override

protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {

}

}

#[users]

#   admin = 123456,roleAdmin

#[roles]

#   roleAdmin = user:list,user:list:add,user:list:to_add

[main]

  #自定义Realm

  myRealm =  cn.gzsxt.realm.MyRealm

  #创建一个Hash算法的对象

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

  #设置hash算法是Md5算法

  credentialsMatcher.hashAlgorithmName=md5

  #设置迭代加密的次数

  credentialsMatcher.hashIterations=2

  #设置是否加盐

  credentialsMatcher.hashSalted=true

  #指定自定义Realm支持hash算法加密的密码

  myRealm.credentialsMatcher=$credentialsMatcher

  securityManager.realms=$myRealm

package cn.gzsxt.realm;

import java.sql.SQLException;

import java.util.List;

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.authz.SimpleAuthorizationInfo;

import org.apache.shiro.realm.AuthorizingRealm;

import org.apache.shiro.subject.PrincipalCollection;

import org.apache.shiro.util.ByteSource;

import cn.gzsxt.dao.AdminDAO;

import cn.gzsxt.dao.PermissionDAO;

import cn.gzsxt.dao.RoleDAO;

import cn.gzsxt.pojo.Admin;

import cn.gzsxt.pojo.Permission;

import cn.gzsxt.pojo.Role;

public class MyRealm extends AuthorizingRealm {

private AdminDAO adminDAO = new AdminDAO();

private RoleDAO roleDAO=new RoleDAO();

private PermissionDAO permissionDAO =new PermissionDAO();

/**

 * 权限验证

 */

@Override

protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

System.out.println(“=权限验证==”);

// 连接数据库，通过用户名查询用户信息

// 1.获得认证信息，账号名

String adminAccount = (String) token.getPrincipal();

// 2.通过账号名查询查询指定的管理员记录

try {

Admin admin = adminDAO.findByAccount(adminAccount);

//密码加盐

ByteSource salt=ByteSource.Util.bytes(“asdfwera”+admin.getAdminSalt());

SimpleAuthenticationInfo authenticationInfo=new SimpleAuthenticationInfo(admin,admin.getAdminPwd(),salt,this.getName());

return authenticationInfo;

} catch (SQLException e) {

e.printStackTrace();

}

return null;

}

/**

 * 权限授权，授予必须依赖权限验证通过

 */

@Override

protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {

    //获得当前验证通过的管理员

Admin admin=(Admin) principalCollection.getPrimaryPrincipal();

//通过当前管理员获得角色编号

Long roleId = admin.getRoleId();

try {

//通过角色编号查询唯一的角色（单角色权限验证）

Role role = roleDAO.findByRoleId(roleId);

//将角色信息放在管理员的实体类里面

admin.setRole(role);

//通过就是的权限ID集，获得角色的权限

String rolePermissions = role.getRolePermissions();

List<Permission> permissions = permissionDAO.findByIds(rolePermissions);

//将角色的权限赋予角色对象

role.setPermissions(permissions);

//创建一个权限授予对象

SimpleAuthorizationInfo authorizationInfo=new SimpleAuthorizationInfo();

//将角色设置给该对象

authorizationInfo.addRole(role.getRoleName());

//将权限设置给Shiro的权限对象

for (Permission permission : permissions) {

authorizationInfo.addStringPermission(permission.getPermissionKey());

}

//返回

return authorizationInfo;

} catch (SQLException e) {

e.printStackTrace();

}

return null;

}

}

<%@ page language=“java” contentType=“text/html; charset=UTF-8”

    pageEncoding=“UTF-8”%>

<!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>

  <a href=“${pageContext.request.contextPath }/admin/addAdmin”>addAdmin</a>

</body>

</html>

package cn.gzsxt.controller;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.context.annotation.SessionScope;

@Controller

@SessionScope

@RequestMapping(value=”admin”)

public class AdminController {

@RequestMapping(value=”/addAdmin”)

public String addAdmin(){

System.out.println(“=增加管理员=”);

return “/index.jsp”;

}

}

<?xml version=“1.0” encoding=“UTF-8”?>

<web-app xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”

xmlns=“http://xmlns.jcp.org/xml/ns/javaee”

xsi:schemaLocation=“http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd”

id=“WebApp_ID” version=“3.1”>

<display-name>shiro-demo-08-springmvc</display-name>

<!– 配置核心控制器。拦截器所有的请求 –>

<servlet>

<servlet-name>dispatcherServlet</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<!– 指定配置文件的路径 –>

<init-param>

  <param-name>contextConfigLocation</param-name>

  <param-value>classpath:spring-*.xml</param-value>

</init-param>

<!– 配置启动的时候就创建对象 –>

<load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>dispatcherServlet</servlet-name>

<url-pattern>/</url-pattern>

</servlet-mapping>

<welcome-file-list>

<welcome-file>index.jsp</welcome-file>

</welcome-file-list>

</web-app>

<?xml version=“1.0” encoding=“UTF-8”?>

<beans xmlns=“http://www.springframework.org/schema/beans”

xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”

xmlns:mvc=“http://www.springframework.org/schema/mvc”

xsi:schemaLocation=“http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd”>

   <!– 启动默认注解支持 –>

   <mvc:annotation-driven />

   <!– 放开静态资源访问 –>

   <mvc:default-servlet-handler/>

</beans>

<?xml version=“1.0” encoding=“UTF-8”?>

<beans xmlns=“http://www.springframework.org/schema/beans”

xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”

xmlns:context=“http://www.springframework.org/schema/context”

xsi:schemaLocation=“http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd”>

  <!– 扫描组件配置 –>

  <context:component-scan base-package=“cn.gzsxt” />

</beans>

[users]

  admin = 123456,adminRole

[roles]

  adminRole = admin:list,admin:add,admin:delete,admin:edit   

package cn.gzsxt.shiro.test;

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;

public class ShiroTest {

public static void main(String[] args) {

//第一步：加载ini配置文件，获得SecurityManagerFactory对象

IniSecurityManagerFactory factory=new IniSecurityManagerFactory(“classpath:shiro.ini”);

//第二步：获得SecurityManager对象

SecurityManager securityManager = factory.createInstance();

//第三步：获得Subject身份对象

SecurityUtils.setSecurityManager(securityManager);

Subject subject = SecurityUtils.getSubject();

//第四步：构建一个身份信息对象（Token）

UsernamePasswordToken token=new UsernamePasswordToken(“admin”,”123456″);

//第五步：login操作。校验权限

Subject resultSubject = securityManager.login(subject, token);

//第六步：校验是否成功

boolean  isAuth= resultSubject.isAuthenticated();

System.out.println(isAuth);

}

}

#[users]

#  admin = 123456,adminRole

#[roles]

#  adminRole = admin:list,admin:add,admin:delete,admin:edit   

[main]

  myRealm = cn.gzsxt.realm.MyRealm

  securityManager.realms=$myRealm

package cn.gzsxt.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 MyRealm extends AuthorizingRealm {

@Override

protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

        System.out.println(“=权限校验=”);

try {

if (token.getPrincipal().equals(“admin”)) {

SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(token.getPrincipal(), “123456”,

this.getName());

return info;

}

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

@Override

protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {

       SimpleAuthorizationInfo info=new SimpleAuthorizationInfo();

info.addRole(“role_admin”);

info.addStringPermission(“user:add”);

info.addStringPermission(“user:list”);

//info.addStringPermission(“user:edit”);

return info;

}

}

<filter>

  <filter-name>securityFilterBean</filter-name>

<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>

  <!– 将生命周期交给Spring代理 –>

  <init-param>

    <param-name>targetFilterLifecycle</param-name>

    <param-value>true</param-value>

  </init-param>

</filter>

<filter-mapping>

   <filter-name>securityFilterBean</filter-name>

  <url-pattern>/*</url-pattern>

</filter-mapping>

<?xml version=“1.0” encoding=“UTF-8”?>

<beans xmlns=“http://www.springframework.org/schema/beans”

xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”

xsi:schemaLocation=“http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd”>

<!– 配置拦截器调用的对象 注意事项：bean的名字必须要和web.xml的DelegatingFilterProxy的过滤的name属性一一对应。 –>

<bean name=“securityFilterBean” class=“org.apache.shiro.spring.web.ShiroFilterFactoryBean”>

<!– 指定跳转到校验不成功的路径 ，不指定会跳转上一次访问菜单页面 –>

<!– <property name=”unauthorizedUrl” value=”/undo”></property> –>

<!– 指定依赖的securityManager对象 –>

<property name=“securityManager” ref=“securityManager”></property>

<!– 指定 登录请求的路径 –>

<property name=“loginUrl” value=“/admin/loginAdmin”></property>

<!– 登录成功跳转的路径 –>

<property name=“successUrl” value=“/index”></property>

<!– 用于指定执行的过滤器链 ，配置多个过滤器连接对的url –>

<property name=“filterChainDefinitions”>

<value>

<!– 指定url与过滤器的关系 –>

<!– 所有的路径都要拦截 –>

/admin/toLogin = anon

/** = authc

</value>

</property>

</bean>

<!– 2.指定securityManager的对象 –>

<bean name=“securityManager” class=“org.apache.shiro.web.mgt.DefaultWebSecurityManager”>

<property name=“realm” ref=“myRealm” />

</bean>

<!– 3.创建一个Realm对象 –>

<bean name=“myRealm” class=“cn.gzsxt.realm.MyRealm”></bean>

<!– 4.Spring容器对shiro生命周期的管理 ,基于注解权限拦截需要配置–>

<bean name=“lifecycleBeanPostProcessor” class=“org.apache.shiro.spring.LifecycleBeanPostProcessor”></bean>

    <bean class=“org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator” depends-on=“lifecycleBeanPostProcessor”/>

</beans>

<%@ page language=“java” contentType=“text/html; charset=UTF-8” pageEncoding=“UTF-8”%>

<%@taglib prefix=“shiro” uri=“http://shiro.apache.org/tags” %>

<!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>

  主页  <a href=“${pageContext.request.contextPath }/logout”>退出</a><br/>

  <shiro:hasPermission name=“user:list”>

  <!– 如果有user:list权限才显示  用户列表 –>

   <a href=“#”> 用户列表</a><br/>

 </shiro:hasPermission>

  <shiro:hasPermission name=“user:add”>

 <!– 如果有user:add权限才显示  用户增加 –>

 <a href=“#”>  用户增加</a><br/>

 </shiro:hasPermission>

 <shiro:hasPermission name=“user:edit”>

   <!– 如果有user:edit权限才显示  用户编辑 –>

  <a href=“#”> 用户编辑</a><br/>

  </shiro:hasPermission>

  <shiro:hasPermission name=“user:delete”>

   <!– 如果有user:delete权限才显示  用户删除 –>

 <a href=“#”>  用户删除</a><br/>

 </shiro:hasPermission>

</body>

</html>

<filter>

<filter-name>securityFilterBean</filter-name>

<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>

  <!– 将生命周期交给Spring代理 –>

  <init-param>

    <param-name>targetFilterLifecycle</param-name>

    <param-value>true</param-value>

  </init-param>

</filter>

<filter-mapping>

   <filter-name>securityFilterBean</filter-name>

  <url-pattern>/*</url-pattern>

</filter-mapping>

package cn.gzsxt.config;

import java.util.LinkedHashMap;

import java.util.Map;

import org.apache.shiro.spring.web.ShiroFilterFactoryBean;

import org.apache.shiro.web.mgt.DefaultWebSecurityManager;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import cn.gzsxt.realm.ShiroRealm;

@Configuration

public class ShiroConfig {

//1.配置securityFilterBean对象

@Bean(name=”securityFilter”)

public Object getShiroFilterFactory() {

ShiroFilterFactoryBean factory=new ShiroFilterFactoryBean();

//设置属性

factory.setLoginUrl(“/login”);

factory.setSuccessUrl(“/index”);

factory.setSecurityManager(this.getSecurityManager());

//基于配置的权限过滤器，顺序执行，所以使用LinkedHashMap

Map<String, String> filterChainDefinition=new LinkedHashMap<>();

filterChainDefinition.put(“/**”, “authc”);

factory.setFilterChainDefinitionMap(filterChainDefinition);

Object securityFilter=null;

try {

securityFilter = factory.getObject();

} catch (Exception e) {

e.printStackTrace();

}

return securityFilter;

}

//2.获得securityManager对象

@Bean(name=”securityManager”)

public DefaultWebSecurityManager getSecurityManager() {

DefaultWebSecurityManager securityManager=new DefaultWebSecurityManager();

//设置需要的realm对象

securityManager.setRealm(this.getRealm());

return securityManager;

}

//3.配置realm对象

@Bean

public ShiroRealm getRealm(){

ShiroRealm realm=new ShiroRealm();

return realm;

}

}