简单的Spring整合Shiro
shiro是流行的权限控制框架，这里参考了官网http://shiro.apache.org/reference.html和springside中的演示https://github.com/springside/springside4/wiki/Shiro-Security，并在此基础上实现自定义shiro输入参数。
最后是一些shiro中的定义，符合权限设计的国际惯例。这些定义可看可不看，有助于理解Shiro。
一. 环境
spring 3.2.6.RELEASE
shiro 1.2.2
ehcache 2.6.6
commons-codec 1.8
shiro和ehcache在maven应该引入的依赖如下
<!-- SECURITY begin -->
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>${shiro.version}</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-ehcache</artifactId>
<version>${shiro.version}</version>
</dependency>
<!-- SECURITY end -->
<!-- CACHE begin -->
<dependency>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache-core</artifactId>
<version>${ehcache.version}</version>
</dependency>
<!-- CACHE end -->
<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
<version>${commons-codec.version}</version>
</dependency>二、加密方式
这里对选择的加密方式为，用户的password使用salt并迭代N次的sha-1式加密
salt是一组随机定长的byte数字，一般用byte数组装载
本文中用salt加密1024次，salt数组长度为8
用到了加密和解密，过程中用到了commons-codec，由于比较麻烦，所以借用springside中的utils，内容如下
Digests
import java.io.IOException;
import java.io.InputStream;
import java.security.GeneralSecurityException;
import java.security.MessageDigest;
import java.security.SecureRandom;
import org.apache.commons.lang3.Validate;
import com.gqshao.common.exception.Exceptions;
public class Digests {
private static final String SHA1 = "SHA-1";
private static final String MD5 = "MD5";
private static SecureRandom random = new SecureRandom();
/**
* 对输入字符串进行sha1散列.
*/
public static byte[] sha1(byte[] input) {
return digest(input, SHA1, null, 1);
}
public static byte[] sha1(byte[] input, byte[] salt) {
return digest(input, SHA1, salt, 1);
}
public static byte[] sha1(byte[] input, byte[] salt, int iterations) {
return digest(input, SHA1, salt, iterations);
}
/**
* 对字符串进行散列, 支持md5与sha1算法.
*/
private static byte[] digest(byte[] input, String algorithm, byte[] salt, int iterations) {
try {
MessageDigest digest = MessageDigest.getInstance(algorithm);
if (salt != null) {
digest.update(salt);
}
byte[] result = digest.digest(input);
for (int i = 1; i < iterations; i++) {
digest.reset();
result = digest.digest(result);
}
return result;
} catch (GeneralSecurityException e) {
throw Exceptions.unchecked(e);
}
}
/**
* 生成随机的Byte[]作为salt.
*
* @param numBytes byte数组的大小
*/
public static byte[] generateSalt(int numBytes) {
Validate.isTrue(numBytes > 0, "numBytes argument must be a positive integer (1 or larger)", numBytes);
byte[] bytes = new byte[numBytes];
random.nextBytes(bytes);
return bytes;
}
/**
* 对文件进行md5散列.
*/
public static byte[] md5(InputStream input) throws IOException {
return digest(input, MD5);
}
/**
* 对文件进行sha1散列.
*/
public static byte[] sha1(InputStream input) throws IOException {
return digest(input, SHA1);
}
private static byte[] digest(InputStream input, String algorithm) throws IOException {
try {
MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
int bufferLength = 8 * 1024;
byte[] buffer = new byte[bufferLength];
int read = input.read(buffer, 0, bufferLength);
while (read > -1) {
messageDigest.update(buffer, 0, read);
read = input.read(buffer, 0, bufferLength);
}
return messageDigest.digest();
} catch (GeneralSecurityException e) {
throw Exceptions.unchecked(e);
}
}
}Encodes
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import org.apache.commons.codec.DecoderException;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.codec.binary.Hex;
import org.apache.commons.lang3.StringEscapeUtils;
import com.gqshao.common.exception.Exceptions;
public class Encodes {
private static final String DEFAULT_URL_ENCODING = "UTF-8";
private static final char[] BASE62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
.toCharArray();
/**
* Hex编码.
*/
public static String encodeHex(byte[] input) {
return Hex.encodeHexString(input);
}
/**
* Hex解码.
*/
public static byte[] decodeHex(String input) {
try {
return Hex.decodeHex(input.toCharArray());
} catch (DecoderException e) {
throw Exceptions.unchecked(e);
}
}
/**
* Base64编码.
*/
public static String encodeBase64(byte[] input) {
return Base64.encodeBase64String(input);
}
/**
* Base64编码, URL安全(将Base64中的URL非法字符'+'和'/'转为'-'和'_', 见RFC3548).
*/
public static String encodeUrlSafeBase64(byte[] input) {
return Base64.encodeBase64URLSafeString(input);
}
/**
* Base64解码.
*/
public static byte[] decodeBase64(String input) {
return Base64.decodeBase64(input);
}
/**
* Base62编码。
*/
public static String encodeBase62(byte[] input) {
char[] chars = new char[input.length];
for (int i = 0; i < input.length; i++) {
chars[i] = BASE62[((input[i] & 0xFF) % BASE62.length)];
}
return new String(chars);
}
/**
* Html 转码.
*/
public static String escapeHtml(String html) {
return StringEscapeUtils.escapeHtml4(html);
}
/**
* Html 解码.
*/
public static String unescapeHtml(String htmlEscaped) {
return StringEscapeUtils.unescapeHtml4(htmlEscaped);
}
/**
* Xml 转码.
*/
public static String escapeXml(String xml) {
return StringEscapeUtils.escapeXml(xml);
}
/**
* Xml 解码.
*/
public static String unescapeXml(String xmlEscaped) {
return StringEscapeUtils.unescapeXml(xmlEscaped);
}
/**
* URL 编码, Encode默认为UTF-8.
*/
public static String urlEncode(String part) {
try {
return URLEncoder.encode(part, DEFAULT_URL_ENCODING);
} catch (UnsupportedEncodingException e) {
throw Exceptions.unchecked(e);
}
}
/**
* URL 解码, Encode默认为UTF-8.
*/
public static String urlDecode(String part) {
try {
return URLDecoder.decode(part, DEFAULT_URL_ENCODING);
} catch (UnsupportedEncodingException e) {
throw Exceptions.unchecked(e);
}
}
}用法如下:
// 得到8位盐 byte[] salts = Digests.generateSalt(SALT_SIZE); // 将8位byte数组装换为spring String salt = Encodes.encodeHex(salts); // 将spring数组转化为8位byte数组 salts = Encodes.decodeHex(salt); // 原密码 String password = "123456"; // 对密码加盐进行1024次SHA1加密 byte[] hashPassword = Digests.sha1(password.getBytes(), salts, 1024); // 将加密后的密码数组转换成字符串 password = Encodes.encodeHex(hashPassword);
简单说一下就是用户输入密码，系统自动生成盐，并对密码加密。然后将盐的字符串跟加密后的密码字符串保存到数据库中。
三、配置
1.web.xml
主要内容如下，其他的如spring和MVC框架等配置自行添加
<context-param>
<param-name>spring.profiles.default</param-name>
<param-value>development</param-value>
</context-param>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
classpath*:/applicationContext.xml
classpath*:/activiti/applicationContext-security.xml
</param-value>
</context-param>
<!-- Shiro Security filter -->
<filter>
<filter-name>shiroFilter</filter-name>
<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
</filter>
<filter-mapping>
<filter-name>shiroFilter</filter-name>
<url-pattern>/*</url-pattern>
<dispatcher>REQUEST</dispatcher>
<dispatcher>FORWARD</dispatcher>
</filter-mapping>可以看到shiro是通过filter进行过滤的，所以如果还有其他filter注意放的位置，比如org.springframework.web.filter.CharacterEncodingFilter要放到前面，com.opensymphony.sitemesh.webapp.SiteMeshFilter这种就要放到它的后面。
2.applicationContext-shiro.xml和ehcache-shiro.xml
这两个配置文件是shiro的主要配置文件
applicationContext-shiro.xml
<?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:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd"
default-lazy-init="true">
<description>Shiro安全配置</description>
<!-- Shiro's main business-tier object for web-enabled applications -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
<property name="realm" ref="shiroDbRealm" />
<property name="cacheManager" ref="shiroEhcacheManager" />
</bean>
<!-- 項目自定义的Realm -->
<bean id="shiroDbRealm" class="com.myapp.rbac.authentication.ShiroDbRealm" />
<!-- Shiro Filter -->
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
<property name="securityManager" ref="securityManager" />
<!-- 用于调用Controller -->
<property name="loginUrl" value="/login" />
<property name="successUrl" value="/" />
<!-- 自己实现的formAuthcFilter，加入key type-->
<property name="filters">
<util:map>
<entry key="authc">
<bean class="com.myapp.rbac.authentication.CustomFormAuthenticationFilter"/>
</entry>
</util:map>
</property>
<property name="filterChainDefinitions">
<value>
/login = authc
/logout = logout
/static/** = anon
/** = user
</value>
</property>
</bean>
<!-- 用户授权信息Cache, 采用EhCache -->
<bean id="shiroEhcacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">
<property name="cacheManagerConfigFile" value="classpath:security/ehcache-shiro.xml" />
</bean>
<!-- 保证实现了Shiro内部lifecycle函数的bean执行 -->
<bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor" />
<!-- AOP式方法级权限检查 -->
<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" depends-on="lifecycleBeanPostProcessor">
<property name="proxyTargetClass" value="true" />
</bean>
<bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
<property name="securityManager" ref="securityManager" />
</bean>
</beans>注意:
1.com.myapp.rbac.authentication.ShiroDbRealm和com.myapp.rbac.authentication.CustomFormAuthenticationFilter是自定义的文件，一会儿有相关说明
2.shiroFilter属性中loginUrl会被ShiroFilter监控起来
3.shiroFilter属性中loginUrl会被successUrl是成功后返回的路径，这里面设置为“ / ”的原因是用的spring mvc
ehcache-shiro.xml
<ehcache updateCheck="false" name="shiroCache">
<defaultCache
maxElementsInMemory="10000"
eternal="false"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
overflowToDisk="false"
diskPersistent="false"
diskExpiryThreadIntervalSeconds="120"
/>
</ehcache>四.实现类
为了演示自定义，所以从login.jsp(自己实现有个POST方法提交的表单即可)开始都有一个叫"custom"的无意义字段，实际项目中可以按需求选择方案，不一定自定义，直接用UsernamePasswordToken也很好。
1.authcToken及其实现类
用于将前端页面传入的参数封装成Token，传给登陆认证的方法。常用的有org.apache.shiro.authc.UsernamePasswordToken。
这里自己实现了一个类
package com.myapp.rbac.authentication.token;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.authc.HostAuthenticationToken;
import org.apache.shiro.authc.RememberMeAuthenticationToken;
public class CustomToken implements HostAuthenticationToken, RememberMeAuthenticationToken {
private String loginName;
private String password;
private String host;
private boolean rememberMe = false;
private String custom;
public CustomToken() {
}
public CustomToken(String loginName, String password) {
this(loginName, password, false, null, null);
}
public CustomToken(String loginName, String password, String host) {
this(loginName, password, false, host, null);
}
public CustomToken(String loginName, String password, boolean rememberMe) {
this(loginName, password, rememberMe, null, null);
}
public CustomToken(String loginName, String password, boolean rememberMe, String host, String custom) {
this.loginName = loginName;
this.password = password;
this.rememberMe = rememberMe;
this.host = host;
this.custom = custom;
}
public Object getPrincipal() {
return getLoginName();
}
public Object getCredentials() {
return getPassword();
}
public String getHost() {
return host;
}
public boolean isRememberMe() {
return rememberMe;
}
public void clear() {
this.loginName = null;
this.host = null;
this.password = null;
this.rememberMe = false;
this.custom = null;
}
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(getClass().getName());
sb.append(" - ");
sb.append(loginName);
sb.append(", rememberMe=").append(rememberMe);
if (StringUtils.isNotBlank(host)) {
sb.append(" (").append(host).append(")");
}
return sb.toString();
}
public String getLoginName() {
return loginName;
}
public void setLoginName(String loginName) {
this.loginName = loginName;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getCustom() {
return custom;
}
public void setCustom(String custom) {
this.custom = custom;
}
public void setHost(String host) {
this.host = host;
}
public void setRememberMe(boolean rememberMe) {
this.rememberMe = rememberMe;
}
}
2.User/Subject
将一些期望保存的属性属性，封装成一个自定义POJO，会被放到session中
package com.myapp.rbac.authentication.domain;
import java.util.List;
import com.google.common.base.Objects;
import com.gqshao.common.util.Identities;
public class ShiroUser implements java.io.Serializable {
private static final long serialVersionUID = -2649983064333269618L;
private String id;
private String loginName;
private List<String> roles;
private List<String> permissions;
private String ip;
// 记录额外的一些信息
private String custom;
public ShiroUser() {
}
public ShiroUser(User user) {
this.id = Identities.uuid();
this.loginName = user.getLoginName();
}
public ShiroUser(String id, String loginName, String ip, String custom) {
this.id = id;
this.loginName = loginName;
this.ip = ip;
this.custom = custom;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public List<String> getRoles() {
return roles;
}
public void setRoles(List<String> roles) {
this.roles = roles;
}
public List<String> getPermissions() {
return permissions;
}
public void setPermissions(List<String> permissions) {
this.permissions = permissions;
}
public String getIp() {
return ip;
}
public void setIp(String ip) {
this.ip = ip;
}
public String getLoginName() {
return loginName;
}
public void setLoginName(String loginName) {
this.loginName = loginName;
}
@Override
public int hashCode() {
return Objects.hashCode(id, loginName, custom);
}
public String toString() {
return id + ":" + loginName + "- " + custom;
}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
} else if (this.hashCode() == obj.hashCode()) {
return true;
} else {
return false;
}
}
}3.AuthenticatingFilter及其实现类
AuthenticatingFilter主要与将前端提交的表单信息封装成Token，与authcToken的实现类要对应起来。比如与org.apache.shiro.authc.UsernamePasswordToken对应的是org.apache.shiro.web.filter.authc.FormAuthenticationFilter。
这里需要自定义一个CustomFormAuthenticationFilter，用于配合CustomToken。
package com.myapp.rbac.authentication.filter;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.web.filter.authc.AuthenticatingFilter;
import org.apache.shiro.web.util.WebUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class CustomFormAuthenticationFilter extends AuthenticatingFilter {
private static final Logger log = LoggerFactory.getLogger(CustomFormAuthenticationFilter.class);
public static final String DEFAULT_ERROR_KEY_ATTRIBUTE_NAME = "shiroLoginFailure";
public static final String DEFAULT_LOGINNAME_PARAM = "loginName";
public static final String DEFAULT_PASSWORD_PARAM = "password";
public static final String DEFAULT_REMEMBER_ME_PARAM = "rememberMe";
// 自定义的输入字段
public static final String DEFAULT_CUSTOM_PARAM = "custom";
private String loginNameParam = DEFAULT_LOGINNAME_PARAM;
private String passwordParam = DEFAULT_PASSWORD_PARAM;
private String rememberMeParam = DEFAULT_REMEMBER_ME_PARAM;
private String customParam = DEFAULT_CUSTOM_PARAM;
private String failureKeyAttribute = DEFAULT_ERROR_KEY_ATTRIBUTE_NAME;
public CustomFormAuthenticationFilter() {
setLoginUrl(DEFAULT_LOGIN_URL);
}
@Override
public void setLoginUrl(String loginUrl) {
String previous = getLoginUrl();
if (previous != null) {
this.appliedPaths.remove(previous);
}
super.setLoginUrl(loginUrl);
if (log.isTraceEnabled()) {
log.trace("Adding login url to applied paths.");
}
this.appliedPaths.put(getLoginUrl(), null);
}
/**
* 在访问被拒绝
*/
@Override
protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
if (isLoginRequest(request, response)) {
if (isLoginSubmission(request, response)) {
if (log.isTraceEnabled()) {
log.trace("Login submission detected. Attempting to execute login.");
}
return executeLogin(request, response);
} else {
if (log.isTraceEnabled()) {
log.trace("Login page view.");
}
return true;
}
} else {
if (log.isTraceEnabled()) {
log.trace("Attempting to access a path which requires authentication. Forwarding to the "
+ "Authentication url [" + getLoginUrl() + "]");
}
saveRequestAndRedirectToLogin(request, response);
return false;
}
}
/**
* 创建自定义的令牌
*/
@Override
protected AuthenticationToken createToken(ServletRequest request, ServletResponse response) {
String loginName = getLoginName(request);
String password = getPassword(request);
boolean rememberMe = isRememberMe(request);
String host = getHost(request);
String custom = getCustom(request);
return new CustomToken(loginName, password, rememberMe, host, custom);
}
protected boolean isLoginSubmission(ServletRequest request, ServletResponse response) {
return (request instanceof HttpServletRequest)
&& WebUtils.toHttp(request).getMethod().equalsIgnoreCase(POST_METHOD);
}
protected boolean isRememberMe(ServletRequest request) {
return WebUtils.isTrue(request, getRememberMeParam());
}
protected boolean onLoginSuccess(AuthenticationToken token, Subject subject, ServletRequest request,
ServletResponse response) throws Exception {
issueSuccessRedirect(request, response);
return false;
}
protected boolean onLoginFailure(AuthenticationToken token, AuthenticationException e,
ServletRequest request, ServletResponse response) {
setFailureAttribute(request, e);
return true;
}
protected void setFailureAttribute(ServletRequest request, AuthenticationException ae) {
String className = ae.getClass().getName();
request.setAttribute(getFailureKeyAttribute(), className);
}
protected String getLoginName(ServletRequest request) {
return WebUtils.getCleanParam(request, getLoginNameParam());
}
protected String getPassword(ServletRequest request) {
return WebUtils.getCleanParam(request, getPasswordParam());
}
protected String getCustom(ServletRequest request) {
return WebUtils.getCleanParam(request, getCustomParam());
}
public String getLoginNameParam() {
return loginNameParam;
}
public void setLoginNameParam(String loginNameParam) {
this.loginNameParam = loginNameParam;
}
public String getPasswordParam() {
return passwordParam;
}
public void setPasswordParam(String passwordParam) {
this.passwordParam = passwordParam;
}
public String getRememberMeParam() {
return rememberMeParam;
}
public void setRememberMeParam(String rememberMeParam) {
this.rememberMeParam = rememberMeParam;
}
public String getCustomParam() {
return customParam;
}
public void setCustomParam(String customParam) {
this.customParam = customParam;
}
public String getFailureKeyAttribute() {
return failureKeyAttribute;
}
public void setFailureKeyAttribute(String failureKeyAttribute) {
this.failureKeyAttribute = failureKeyAttribute;
}
}4.Realm实现
Realm用于登陆认证和权限的鉴权工作
package com.myapp.rbac.authentication.realm;
import java.util.ArrayList;
import java.util.List;
import javax.annotation.PostConstruct;
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.credential.HashedCredentialsMatcher;
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 org.springframework.beans.factory.annotation.Autowired;
import com.myapp.rbac.authentication..domain.ShiroUser;
import com.genertech.commons.core.utils.Encodes;
import com.myapp.rbac.authentication.token.CustomToken;
import com.myapp.rbac.domain.Permission;
import com.myapp.rbac.domain.Role;
import com.myapp.rbac.domain.User;
import com.myapp.rbac.service.PermissionService;
import com.myapp.rbac.service.RoleService;
import com.myapp.rbac.service.UserService;
public class ShiroDbRealm extends AuthorizingRealm {
public static final String HASH_ALGORITHM = "SHA-1";
public static final int SALT_SIZE = 8;
public static final int HASH_INTERATIONS = 1024;
@Autowired
private UserService userService;
@Autowired
protected PermissionService permissionService;
@Autowired
protected RoleService roleService;
public ShiroDbRealm() {
super();
setAuthenticationTokenClass(CustomToken.class);
}
/**
* 认证回调函数,登录时调用.
*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authcToken){
CustomToken token = (CustomToken) authcToken;
String loginName = token.getLoginName();
String host = token.getHost();
User user = userService.getUserByLoginName(loginName);
if (user != null) {
ShiroUser root = new ShiroUser(user.getId(), loginName, user.getName(),
user.getIsAdmin() == 1 ? true : false, host);
byte[] salt = Encodes.decodeHex(user.getSalt());
return new SimpleAuthenticationInfo(root, user.getPassword(), ByteSource.Util.bytes(salt),
getName());
} else {
return null;
}
}
/**
* 授权查询回调函数, 进行鉴权但缓存中无用户的授权信息时调用.
*/
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
ShiroUser shiroUser = (ShiroUser) principals.getPrimaryPrincipal();
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
List<Role> roleList = null;// 角色集合//
List<String> pList = new ArrayList<String>();
List<Permission> listP = null;// 权限集合//
if (shiroUser.isAdmin()) {
// 超级管理员获取所有角色//
roleList = roleService.getAll();
// 超级管理员获取所有权限//
listP = permissionService.getAllPermissions();
} else {
roleList = roleService.getRolesByUserId(shiroUser.getId());
listP = permissionService.getByUserId(shiroUser.getId());
}
// 遍历角色//
for (Role role : roleList) {
info.addRole(role.getName());
}
// 遍历权限//
for (Permission per : listP) {
if (per != null) {
String[] ps = per.getCode().split(";");
for (int i = 0; i < ps.length; i++) {
pList.add(ps[i]);
}
}
}
if (shiroUser.isAdmin()) {
pList.add("permissionmgt:administrator");
}
// 基于Permission的权限信息//
info.addStringPermissions(pList);
return info;
}
/**
* 设定Password校验的Hash算法与迭代次数.
*/
@PostConstruct
public void initCredentialsMatcher() {
HashedCredentialsMatcher matcher = new HashedCredentialsMatcher(HASH_ALGORITHM);
matcher.setHashIterations(HASH_INTERATIONS);
setCredentialsMatcher(matcher);
}
}注意
1.实现登陆的前提是通过POST方法，提交到 loginUrl 配置的路径上。
2.doGetAuthenticationInfo完成登陆的认证工作。Shiro通过return的SimpleAuthenticationInfo中的参数，自动判断password是否正确。再次提醒，user保存在数据库中的password是通过salt加密过的密码；
3.认证的方法通过initCredentialsMatcher设置；
4.doGetAuthorizationInfo方法完成的是鉴权工作，这里需要注意的事情是，由于权限和角色都是通过整合Ehcache，缓存起来，所以当缓存失效的时候，会再次鉴权。
5.注意权限定义中 : 号有特殊用途,不要随便使用。
5.控制器
最后完成一个控制器，用于登陆跳转到登陆页面，或登陆失败后的页面调整
这里用的是spring mvc
@Controller
public class LoginController {
Logger logger = LoggerFactory.getLogger(LoginController.class);
@RequestMapping(value = "/login", method = RequestMethod.GET)
public String login(Model model) {
return "common/login";
}
@RequestMapping(value = "/login", method = RequestMethod.POST)
public String fail(@RequestParam(CustomFormAuthenticationFilter.DEFAULT_LOGINNAME_PARAM) String userName,
Model model) {
model.addAttribute(CustomFormAuthenticationFilter.DEFAULT_LOGINNAME_PARAM, userName);
return "common/login";
}
}五.使用
JSP内容控制
页面部分可以通过导入 <%@ taglib prefix="shiro" uri="http://shiro.apache.org/tags" %> 使用标签
常用的有hasPermission、hasAnyRole等，参考http://shiro.apache.org/web.html#Web-taglibrary
方法级控制
@RequiresPermissions("User:Edit")
@RequiresRoles(value = { "Admin", "User" }, logical = Logical.OR)等等
可以参考http://shiro.apache.org/authorization.html#Authorization-ProgrammaticAuthorization
通过Shiro保存到Session中的对象可以通过以下方法得到
Subject shiroUser = SecurityUtils.getSubject();
六. 概念
。
· Authentication
身份验证是验证Subject 身份的过程——实质上是证明某些人是否真的是他们所说的他们是谁。当认证尝试成
功后，应用程序能够相信该subject 被保证是其所期望的。
· Authorization
授权，又称为访问控制，是决定一个user/Subject 是否被允许做某事的过程。它通常是通过检查和解释。
· Subject
的角色和权限（见下文），然后允许或拒绝到一个请求的资源或功能来完成的。
· Cipher
密码是进行加密或解密的一种算法。该算法一般依赖于一块被称为key 的信息。基于不同的key 的加密算法
也是不一样的，所有解密没有它是非常困难的。
密码有不同的表现形式。分组密码致力于符号块，通常是固定大小的，而流密码致力于连续的符号流。对称
性密码加密和解密使用相同的密钥（key），而非对称性加密使用不同的密钥。如果非对称性加密的密钥不能
从其他地方得到，那么可以创建公钥/私钥对公开共享。
· Credential
凭证是一块信息，用来验证user/Subject 的身份。在认证尝试期间，一个（或多个）凭证与Principals(s)被一
同提交，来验证user/Subject 所提交的确实是所关联的用户。证书通常是非常秘密的东西，只有特定的
user/Subject 才知道，如密码或PGP 密钥或生物属性或类似的机制。
这个想法是为principal 设置的，只有一个人会知道正确的证书来“匹配”该principal。如果当前user/Subject
提供了正确的凭证匹配了存储在系统中的，那么系统可以假定并信任当前user/Subject 是真的他们所说的他们
是谁。信任度随着更安全的凭证类型加深（如，生物识别签名 > 密码）。
· Cryptography
加密是保护信息不受不希望的访问的习惯做法，通过隐藏信息或将它转化成无意义的东西，这样没人可以理
解它。Shiro 致力于加密的两个核心要素：加密数据的密码，如使用公钥或私钥的邮件，以及散列表（也称消
息摘要），它对数据进行不可逆的加密，如密码。
· Hash
散列函数是单向的，不可逆转的输入源，有时也被称为消息，在一个编码的哈希值内部，有时也被称为消息
摘要。它通常用于密码，数字指纹，或以字节数组为基础的数据。
· Permission
权限，至少按照Shiro 的解释，是在应用程序中描述原始功能的一份声明并没有更多的功能。权限是在安全策
略中最低级别的概念。它们仅定义了应用程序能够做“什么”。它们没有说明“谁”能够执行这些操作。权
限只是行为的声明，仅此而已。
一些权限的例子：
· 打开文件
· 浏览'/user/list'页面
· 打印文档
· 删除'jsmith'用户
· Principal
Principal 是一个应用程序用户（Subject）的任何标志属性。“标志属性”可以是任何对你应用程序有意义的东
西——用户名，姓，名，社会安全号码，用户ID 等。这就是它——没什么古怪的。
Shiro 也引用一些我们称之为Subject 的primary principal 的东西。一个primary principal 是在整个应用程序中唯
一标识Subject 的principal。理想的primary principal 是用户名或RDBMS 用户表主键——用户ID。对于在应用
程序中的用户（Subject）来说，只有一个primary principal
· Realm
Realm 是一个能够访问应用程序特定的安全数据（如用户，角色和权限）的组件。它可以被看作是一个特定
安全的DAO（Data Access Object）。Realm 将这些应用程序特定的数据转换成Shiro 能够理解的格式，这样Shiro
反过来能够提供一个单一的易于理解的Subject 编程API，无论有多少数据源存在或无论你的数据是什么样的
应用程序特定的格式。
Realm 通常和数据源是一对一的对应关系，如关系数据库，LDAP 目录，文件系统，或其他类似资源。因此，
Realm 接口的实现使用数据源特定的API 来展示授权数据（角色，权限等），如JDBC，文件IO，Hibernate 或
JPA，或其他数据访问API。
· Role
基于你对话的对象，一个角色的定义是可以多变的。在许多应用程序中，它充其量是个模糊不清的概念，人
们用它来隐式定义安全策略。Shiro 偏向于把角色简单地解释为一组命名的权限的集合。这就是它——一个应
用程序的唯一名称，聚集一个或多个权限声明。
这是一个比许多应用程序使用的隐式的定义更为具体的定义。如果你选择了你的数据模型反映Shiro 的假设，
你会发现将有更多控制安全策略的权力。
· Session
会话是一个在一段时间内有状态的数据，其上下文与一个单一的与软件系统交互的user/Subject 相关联。当
Subject 使用应用程序时，能够从会话中添加/读取/删除数据，并且应用程序稍后能够在需要的地方使用该数
据。会话会被终止，由于user/Subject 注销或会话不活动而超时。
对于那些熟悉HttpSession 的，Shiro Session 服务于同一目标，除了Shiro 会话能够在任何环境下使用，甚至在
没有Servlet 容器或EJB 容器的环境。
· Subject
Subject 只是一个精挑细选的安全术语，基本上的意思是一个应用程序用户的安全特定的“视图”。然而Subject
不总是需要反映为一个人——它可以代表一个调用你应用程序的外部进程，或许是一个系统帐户的守护进程，
在一段时间内执行一些间歇性的东西（如一个cron job）。它基本上是任何使用应用程序做某事的实体的一个
代表。
相关推荐
MicroBoy 2020-08-02
MicroBoy 2020-07-05
杜鲁门 2020-11-05
luckyxl0 2020-08-16
Dullonjiang 2020-08-09
xclxcl 2020-08-03
zmzmmf 2020-08-03
ganjing 2020-08-02
likesyour 2020-08-01
zmzmmf 2020-07-09
zzhao 2020-06-26
子云 2020-06-18
visionzheng 2020-06-07
neweastsun 2020-06-04
ErixHao 2020-06-03
GDreams0 2020-06-01
ganjing 2020-05-29
zmzmmf 2020-05-28
nullcy 2020-05-26