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)。它基本上是任何使用应用程序做某事的实体的一个
代表。
相关推荐
手把手教你集成spring cloud + shiro微服务框架;用最少的工作量,改造基于shiro安全框架的微服务项目,实现spring cloud + shiro 框架集成。博客地址:...
Spring 整合 Shiro 主要是为了实现更高效、灵活的安全管理,包括身份验证(Authentication)、授权(Authorization)、会话管理(Session Management)和加密(Cryptography)。下面我们将详细探讨这个整合过程及其...
1. **Spring与Shiro的集成**:讲解如何在Spring应用中引入Shiro,包括配置Shiro的依赖、设置Shiro的过滤器链以及Spring与Shiro的Bean配置。 2. **身份认证**:介绍Shiro的Subject、Realms和CredentialsMatcher等...
适用于spring集成的javaweb环境
这个"spring整合shiro登录小例子"提供了一个简化的实例,展示了如何在 Spring 框架中集成 Shiro 进行用户登录验证和权限控制。下面我们将深入探讨相关的知识点。 **1. Spring 框架** Spring 是一个广泛使用的 Java ...
通过学习和实践"spring-shiro整合",开发者不仅可以掌握Web安全框架的使用,还能深入理解Spring MVC和MyBatis的集成,提升项目开发能力。在实际项目中,这样的整合可以帮助我们快速构建出健壮、安全的Web应用。
此外,Spring还集成了数据访问、事务管理、安全性、消息传递等多个领域,使得开发者可以方便地将各种组件整合到应用中。 **Shiro** Apache Shiro是一个轻量级的安全框架,主要用于身份认证、授权(权限控制)和会话...
**Spring Boot 集成 Shiro 深度解析** Spring Boot 是一款基于 Spring 的轻量级框架,它简化了 Spring 应用的初始搭建以及开发过程。而 Apache Shiro 是一个强大且易用的 Java 安全框架,提供了认证、授权、加密和...
通过以上步骤,我们就能在Spring应用中有效地集成Shiro,实现细粒度的权限控制。SpringShiroHibernateSearch这个文件名可能意味着整合了Hibernate搜索引擎,这使得我们可以利用Hibernate对数据进行全文检索,进一步...
**Spring MVC 整合 Shiro 知识点详解** Spring MVC 是一款强大的MVC框架,用于构建企业级的Web应用程序,而Apache Shiro则是一款安全框架,负责处理身份验证、授权(权限控制)、会话管理和安全性相关的其他功能。...
6. Session管理:集成Shiro的Session管理,可以选择使用Spring的Session管理或者Shiro的独立Session管理,根据实际需求进行选择。 7. 国际化支持:如果需要,还可以配置Shiro的国际化,提供多语言的错误提示。 8. ...
总之,"spring+shiro简单整合"涉及了Spring框架的MVC设计模式、Shiro的安全管理机制,以及两者如何协同工作来实现用户认证、授权和会话管理。这个过程不仅需要理解Spring和Shiro的基本原理,还需要掌握如何在实际...
Spring Shiro 整合入门教程 在Web应用开发中,安全是至关重要的一个环节。Spring框架作为Java领域最流行的框架之一,提供了丰富的功能,而Apache Shiro则是一款强大的安全管理框架,专注于身份验证、授权和会话管理...
总结来说,Spring Boot与Shiro的整合使得我们能够轻松地搭建一个权限管理系统。通过Spring Boot的自动配置和Shiro的安全特性,我们可以快速地实现用户认证和授权功能,从而保护应用程序的资源。这个过程包括配置...
本文将深入探讨"spring-shiro.rar"这个压缩包中的入门示例,帮助开发者理解如何在Spring项目中集成Shiro,实现用户身份验证和权限控制。 一、Spring与Shiro概述 1. Spring框架:Spring是Java企业级应用开发的事实...
此外,我们还需要配置Shiro的Session管理,可以使用Spring Session来集成Shiro的会话管理,以便跨多个节点共享会话数据。 至于`ztree`,它是一个用于构建前端树形结构的JavaScript库,常用于展示权限节点。在权限...
在实际项目中,我们可以创建一个简单的 Spring Boot 应用,然后配置 Shiro,定义 Realm 类,处理认证和授权逻辑。在 `WebSecurityConfig` 类中配置 Shiro 过滤器链,最后在 Controller 层添加权限控制注解,实现对...
SpringBoot整合Shiro示例实现动态权限加载更新+Session共享+单点登录 SpringBoot整合Shiro示例实现动态权限加载更新+Session共享+单点登录 SpringBoot整合Shiro示例实现动态权限加载更新+Session共享+单点登录 ...