<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-core</artifactId>
<version>1.2.3</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-web</artifactId>
<version>1.2.3</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>1.2.3</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-ehcache</artifactId>
<version>1.2.3</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-quartz</artifactId>
<version>1.2.3</version>
</dependency><dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-all</artifactId>
<version>1.2.3</version>
</dependency>
log4j.rootLogger=debug, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m %n
#对用户信息进行配置
[users]
#用户账号和密码
zhangsan=123456
lisi=654321// 用户登录和退出
@Test
public void testLoginAndLogout() {
// 创建SecurityManager工厂。通过ini配置文件创建securityManager
Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-first.ini");
// 创建SecurityManager
SecurityManager securityManager = factory.getInstance();
// 将securityManager设置到当前的运行环境中
SecurityUtils.setSecurityManager(securityManager);
// 从SecurityUtils中创建一个subject
Subject subject = SecurityUtils.getSubject();
// 在认证提交前准备token(令牌)
// 这里的账号和密码 将来是由用户输入进去的
UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123456");
//执行认证提交
try {
//执行认证提交
subject.login(token);
} catch (AuthenticationException e) {
e.printStackTrace();
}
// 是否认证通过
boolean isAuthenticated = subject.isAuthenticated();
System.out.println("是否认证通过："+isAuthenticated);
//退出操作
subject.logout();
// 是否认证通过
isAuthenticated = subject.isAuthenticated();
System.out.println("是否认证通过："+isAuthenticated);
}
public class CustomRealm extends AuthorizingRealm {
// 设置Realm的名称
@Override
public String getName() {
return super.getName();
}
// 支持UsernamePasswordToken
@Override
public boolean supports(AuthenticationToken token) {
return token instanceof UsernamePasswordToken;
}
// 用于认证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
// token是用户输入的
// 第一步从token中取出身份信息
String usercode = (String) token.getPrincipal();
// 第二步：根据用户输入的usercode从数据库查询
// ......
// 如果查询不到返回null
// 数据库中用户账号是zhangsan
if (!usercode.equals("zhangsan")) {
return null;
}
// 模拟从数据库中查询到密码
String password = "123456";
// 如果查询到返回认证信息AuthenticationInfo
SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(usercode, password,
this.getName());
return simpleAuthenticationInfo;
}
// 用于授权
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
return null;
}
}[main]
#自定义realm
customRealm=liuxun.test.shiro.realm.CustomRealm
#将realm设置到SecurityManager，相当于Spring中的注入
securityManager.realms=$customRealmpackage liuxun.test.shiro.authentication;
import org.apache.shiro.crypto.hash.Md5Hash;
import org.apache.shiro.crypto.hash.SimpleHash;
public class MD5Test {
public static void main(String[] args) {
//原始密码
String source = "123456";
//盐
String salt = "qwerty";
//散列次数
int hashIterations = 2;
//上边散列1次：48474f975022f960bc2afbe49be581e8
//上边散列2次：13f79dafcbbedc313273e2b891ac84d3
//构造方法中：
//第一个参数：明文，原始密码
//第二个参数：盐，通过使用随机字符串
//第三个参数：散列的次数，比如散列两次，相当于md5(md5(''))
Md5Hash md5Hash = new Md5Hash(source, salt, hashIterations);
String password_md5 = md5Hash.toString();
System.out.println(password_md5);
//使用后SimpleHash
//第一个参数：散列算法
SimpleHash simpleHash = new SimpleHash("md5", source, salt, hashIterations);
System.out.println(simpleHash.toString());
}
}// 用于认证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
// token保存了用户输入的身份信息userName和password
// 第一步：从token中取出身份信息
String userCode = (String) token.getPrincipal();
// 第二步：根据用户输入的userCode从数据库查询
// ....
// 如果查询不到返回null 假设用户输入的账号是zhansgan
// 模拟从数据库中查询账号是zhangsan的用户
if (!userCode.equals("zhangsan")) {
return null;
}
// 模拟从数据库中查询到密码(散列值)
// 按照固定规则加密的结果，此密码是在数据库中存储的，原始密码是123456 盐是qwerty
String password = "48474f975022f960bc2afbe49be581e8";
// 盐，随机字符串，此随机字符串也是在数据库中存储的,模拟从数据库中获取
String salt = "qwerty";
// 如果查询到则返回认证信息AuthenticationInfo
SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(userCode, password,
ByteSource.Util.bytes(salt), this.getName());
return simpleAuthenticationInfo;
}[main]
#定义凭证匹配器
credentialsMatcher=org.apache.shiro.authc.credential.HashedCredentialsMatcher
#散列算法
credentialsMatcher.hashAlgorithmName=md5
#散列次数
credentialsMatcher.hashIterations=1
#将凭证匹配器设置到Realm
customRealm=liuxun.test.shiro.realm.CustomRealmMd5
customRealm.credentialsMatcher=$credentialsMatcher
#将Realm设置到securityManager
securityManager.realms=$customRealm#用户
[users]
#用户zhang的密码是123，此用户具有role1和role2两个角色
zhang=123,role1,role2
wang=123,role2
#权限
[roles]
#角色role1对资源user拥有create、update权限
role1=user:create,user:update
#角色role2对资源user拥有create、delete权限
role2=user:create,user:delete
#role3对资源user拥有create权限
role3=user:create在ini文件中用户、角色、权限的配置规则是：
// 角色授权、资源授权测试
@Test
public void testAuthorization() {
// 创建SecurityManager工厂
Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-permission.ini");
// 创建SecurityManager
SecurityManager securityManager = factory.getInstance();
// 将SecurityManager设置到系统运行环境，和Spring整合后将SecurityManager配置在Spring容器中，一般单例管理
SecurityUtils.setSecurityManager(securityManager);
// 创建subject
Subject subject = SecurityUtils.getSubject();
// 创建token令牌
UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123");
// 执行认证
try {
subject.login(token);
} catch (AuthenticationException e) {
e.printStackTrace();
}
System.out.println("认证状态：" + subject.isAuthenticated());
// 认证通过后执行授权
// 基于角色的授权
// hasRole传入角色标识
boolean ishasRole = subject.hasRole("role1");
System.out.println("单个角色判断 " + ishasRole);
// hasAllRoles 是否拥有多个角色
boolean hasAllRoles = subject.hasAllRoles(Arrays.asList("role1", "role2", "role3"));
System.out.println("多个角色判断 " + hasAllRoles);
//使用check方法进行授权，如果授权不通过会抛出异常,用于断言
subject.checkRole("role2");
//基于资源的权限
//isPermitted传入权限标识符
boolean isPermitted = subject.isPermitted("user:create:1");
System.out.println("单个权限判断 "+isPermitted);
boolean isPermittedAll = subject.isPermittedAll("user:create:1","user:delete");
System.out.println("多个权限判断 "+isPermittedAll);
//使用check方法进行授权测试，如果授权不通过会抛出异常
subject.checkPermission("item:delete");
}// 用于授权
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
//从principals获取身份信息
//将getPrimaryPrincipal方法返回值转为真实类型
//(在上边的doGetAuthenticationInfo认证通过后填充到SimpleAuthenticationInfo中身份类型)
String userCode = (String) principals.getPrimaryPrincipal();
//根据身份信息从数据库中获取权限信息
//模拟从数据库中取到的数据
List<String> permissions = new ArrayList<String>();
permissions.add("user:create");//用户创建
permissions.add("items:add");//商品添加权限
//....
//查询到权限数据，返回授权信息(要包括上边的permissions)
SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
//将上边查询到的授权信息填充到simpleAuthorizationInfo对象中
simpleAuthorizationInfo.addStringPermissions(permissions);
return simpleAuthorizationInfo;
}[main]
#自定义realm
customRealm=liuxun.test.shiro.realm.CustomRealm
#将realm设置到SecurityManager，相当于Spring中的注入
securityManager.realms=$customRealmpackage liuxun.test.shiro.authentication;
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.apache.shiro.util.Factory;
import org.junit.Test;
/**
* 认证测试
*
* @author liuxun
*
*/
public class AuthenticationTest {
// 用户登录和退出
@Test
public void testLoginAndLogout() {
// 创建SecurityManager工厂。通过ini配置文件创建securityManager
Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-first.ini");
// 创建SecurityManager
SecurityManager securityManager = factory.getInstance();
// 将securityManager设置到当前的运行环境中
SecurityUtils.setSecurityManager(securityManager);
// 从SecurityUtils中创建一个subject
Subject subject = SecurityUtils.getSubject();
// 在认证提交前准备token(令牌)
// 这里的账号和密码 将来是由用户输入进去的
UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123456");
//执行认证提交
try {
//执行认证提交
subject.login(token);
} catch (AuthenticationException e) {
e.printStackTrace();
}
// 是否认证通过
boolean isAuthenticated = subject.isAuthenticated();
System.out.println("是否认证通过："+isAuthenticated);
//退出操作
subject.logout();
// 是否认证通过
isAuthenticated = subject.isAuthenticated();
System.out.println("是否认证通过："+isAuthenticated);
}
//自定义Realm
@Test
public void testCustomRealm() {
// 创建SecurityManager工厂。通过ini配置文件创建securityManager
Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-realm.ini");
// 创建SecurityManager
SecurityManager securityManager = factory.getInstance();
// 将securityManager设置到当前的运行环境中
SecurityUtils.setSecurityManager(securityManager);
// 从SecurityUtils中创建一个subject
Subject subject = SecurityUtils.getSubject();
// 在认证提交前准备token(令牌)
// 这里的账号和密码 将来是由用户输入进去的
UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123456");
//执行认证提交
try {
//执行认证提交
subject.login(token);
} catch (AuthenticationException e) {
e.printStackTrace();
}
// 是否认证通过
boolean isAuthenticated = subject.isAuthenticated();
System.out.println("是否认证通过："+isAuthenticated);
}
//自定义Realm实现散列值匹配
@Test
public void testCustomRealmMd5() {
// 创建SecurityManager工厂。通过ini配置文件创建securityManager
Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-realm-md5.ini");
// 创建SecurityManager
SecurityManager securityManager = factory.getInstance();
// 将securityManager设置到当前的运行环境中
SecurityUtils.setSecurityManager(securityManager);
// 从SecurityUtils中创建一个subject
Subject subject = SecurityUtils.getSubject();
// 在认证提交前准备token(令牌)
// 这里的账号和密码 将来是由用户输入进去的
UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123456");
//执行认证提交
try {
//执行认证提交
subject.login(token);
} catch (AuthenticationException e) {
e.printStackTrace();
}
// 是否认证通过
boolean isAuthenticated = subject.isAuthenticated();
System.out.println("是否认证通过："+isAuthenticated);
}
}package liuxun.test.shiro.authentication;
import org.apache.shiro.crypto.hash.Md5Hash;
import org.apache.shiro.crypto.hash.SimpleHash;
public class MD5Test {
public static void main(String[] args) {
//原始密码
String source = "123456";
//盐
String salt = "qwerty";
//散列次数
int hashIterations = 2;
//上边散列1次：48474f975022f960bc2afbe49be581e8
//上边散列2次：13f79dafcbbedc313273e2b891ac84d3
//构造方法中：
//第一个参数：明文，原始密码
//第二个参数：盐，通过使用随机字符串
//第三个参数：散列的次数，比如散列两次，相当于md5(md5(''))
Md5Hash md5Hash = new Md5Hash(source, salt, hashIterations);
String password_md5 = md5Hash.toString();
System.out.println(password_md5);
//使用后SimpleHash
//第一个参数：散列算法
SimpleHash simpleHash = new SimpleHash("md5", source, salt, hashIterations);
System.out.println(simpleHash.toString());
}
}
package liuxun.test.shiro.authorization;
import java.util.Arrays;
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.apache.shiro.util.Factory;
import org.junit.Test;
/**
* 授权测试
*
* @author liuxun
*
*/
public class AuthorizationTest {
// 角色授权、资源授权测试
@Test
public void testAuthorization() {
// 创建SecurityManager工厂
Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-permission.ini");
// 创建SecurityManager
SecurityManager securityManager = factory.getInstance();
// 将SecurityManager设置到系统运行环境，和Spring整合后将SecurityManager配置在Spring容器中，一般单例管理
SecurityUtils.setSecurityManager(securityManager);
// 创建subject
Subject subject = SecurityUtils.getSubject();
// 创建token令牌
UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123");
// 执行认证
try {
subject.login(token);
} catch (AuthenticationException e) {
e.printStackTrace();
}
System.out.println("认证状态：" + subject.isAuthenticated());
// 认证通过后执行授权
// 基于角色的授权
// hasRole传入角色标识
boolean ishasRole = subject.hasRole("role1");
System.out.println("单个角色判断 " + ishasRole);
// hasAllRoles 是否拥有多个角色
boolean hasAllRoles = subject.hasAllRoles(Arrays.asList("role1", "role2", "role3"));
System.out.println("多个角色判断 " + hasAllRoles);
// 使用check方法进行授权，如果授权不通过会抛出异常,用于断言
subject.checkRole("role2");
// 基于资源的权限
// isPermitted传入权限标识符
boolean isPermitted = subject.isPermitted("user:create:1");
System.out.println("单个权限判断 " + isPermitted);
boolean isPermittedAll = subject.isPermittedAll("user:create:1", "user:delete");
System.out.println("多个权限判断 " + isPermittedAll);
// 使用check方法进行授权测试，如果授权不通过会抛出异常
subject.checkPermission("item:delete");
}
// 自定义Realm进行资源授权测试
@Test
public void testAuthorizationCustomRealm() {
// 创建SecurityManager工厂
Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-realm.ini");
// 创建SecurityManager
SecurityManager securityManager = factory.getInstance();
// 将SecurityManager设置到系统运行环境，和Spring整合后将SecurityManager配置在Spring容器中，一般单例管理
SecurityUtils.setSecurityManager(securityManager);
// 创建subject
Subject subject = SecurityUtils.getSubject();
// 创建token令牌
UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123");
// 执行认证
try {
subject.login(token);
} catch (AuthenticationException e) {
e.printStackTrace();
}
System.out.println("认证状态：" + subject.isAuthenticated());
// 认证通过后执行授权
// 基于资源的授权，调用isPermitted方法会调用CustomRealm从数据库中查询正确权限数据
// isPermitted传入权限标识符，判断user:create:1是否在CustomRealm查询到的权限数据之内
boolean isPermitted = subject.isPermitted("user:create:1");
System.out.println("单个权限判断 " + isPermitted);
boolean isPermittedAll = subject.isPermittedAll("user:create:1", "user:delete");
System.out.println("多个权限判断 " + isPermittedAll);
// 使用check方法进行授权测试，如果授权不通过会抛出异常
subject.checkPermission("item:add:1");
}
}package liuxun.test.shiro.realm;
import java.util.ArrayList;
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.authc.UsernamePasswordToken;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
public class CustomRealm extends AuthorizingRealm {
// 设置Realm的名称
@Override
public String getName() {
return "CustomRealm";
}
// 支持UsernamePasswordToken
@Override
public boolean supports(AuthenticationToken token) {
return token instanceof UsernamePasswordToken;
}
// 用于认证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
// token是用户输入的
// 第一步从token中取出身份信息
String usercode = (String) token.getPrincipal();
// 第二步：根据用户输入的usercode从数据库查询
// ......
// 如果查询不到返回null
// 数据库中用户账号是zhangsan
if (!usercode.equals("zhangsan")) {
return null;
}
// 模拟从数据库中查询到密码
String password = "123456";
// 如果查询到返回认证信息AuthenticationInfo
SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(usercode, password,
this.getName());
return simpleAuthenticationInfo;
}
// 用于授权
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
//从principals获取身份信息
//将getPrimaryPrincipal方法返回值转为真实类型
//(在上边的doGetAuthenticationInfo认证通过后填充到SimpleAuthenticationInfo中身份类型)
String userCode = (String) principals.getPrimaryPrincipal();
//根据身份信息从数据库中获取权限信息
//模拟从数据库中取到的数据
List<String> permissions = new ArrayList<String>();
permissions.add("user:create");//用户创建
permissions.add("items:add");//商品添加权限
//....
//查询到权限数据，返回授权信息(要包括上边的permissions)
SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
//将上边查询到的授权信息填充到simpleAuthorizationInfo对象中
simpleAuthorizationInfo.addStringPermissions(permissions);
return simpleAuthorizationInfo;
}
}
package liuxun.test.shiro.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.authc.UsernamePasswordToken;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;
public class CustomRealmMd5 extends AuthorizingRealm {
// 设置Realm名称
@Override
public void setName(String name) {
super.setName("CustomRealmMd5");
}
// 支持UsernamePasswordToken
@Override
public boolean supports(AuthenticationToken token) {
return token instanceof UsernamePasswordToken;
}
// 用于认证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
// token保存了用户输入的身份信息userName和password
// 第一步：从token中取出身份信息
String userCode = (String) token.getPrincipal();
// 第二步：根据用户输入的userCode从数据库查询
// ....
// 如果查询不到返回null 假设用户输入的账号是zhansgan
// 模拟从数据库中查询账号是zhangsan的用户
if (!userCode.equals("zhangsan")) {
return null;
}
// 模拟从数据库中查询到密码(散列值)
// 按照固定规则加密的结果，此密码是在数据库中存储的，原始密码是123456 盐是qwerty
String password = "48474f975022f960bc2afbe49be581e8";
// 盐，随机字符串，此随机字符串也是在数据库中存储的,模拟从数据库中获取
String salt = "qwerty";
// 如果查询到则返回认证信息AuthenticationInfo
SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(userCode, password,
ByteSource.Util.bytes(salt), this.getName());
return simpleAuthenticationInfo;
}
// 用于授权
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
return null;
}
}log4j.properties
log4j.rootLogger=debug, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m %n
#对用户信息进行配置
[users]
#用户账号和密码
zhangsan=123456
lisi=654321#用户
[users]
#用户zhang的密码是123，此用户具有role1和role2两个角色
zhangsan=123,role1,role2
wang=123,role2
#权限
[roles]
#角色role1对资源user拥有create、update权限
role1=user:create,user:update
#角色role2对资源user拥有create、delete权限
role2=user:create,user:delete
#role3对资源user拥有create权限
role3=user:create[main]
#自定义realm
customRealm=liuxun.test.shiro.realm.CustomRealm
#将realm设置到SecurityManager，相当于Spring中的注入
securityManager.realms=$customRealm[main]
#定义凭证匹配器
credentialsMatcher=org.apache.shiro.authc.credential.HashedCredentialsMatcher
#散列算法
credentialsMatcher.hashAlgorithmName=md5
#散列次数
credentialsMatcher.hashIterations=1
#将凭证匹配器设置到Realm
customRealm=liuxun.test.shiro.realm.CustomRealmMd5
customRealm.credentialsMatcher=$credentialsMatcher
#将Realm设置到securityManager
securityManager.realms=$customRealm