详解登录认证及授权--Shiro系列（一）

Apache Shiro 是一个强大而灵活的开源安全框架，它干净利落地处理身份认证，授权，企业会话管理和加密。
Apache Shiro 的首要目标是易于使用和理解。安全有时候是很复杂的，甚至是痛苦的，但它没有必要这样。框架应该尽可能掩盖复杂的地方，露出一个干净而直观的 API，来简化开发人员在使他们的应用程序安全上的努力。
以下是你可以用 Apache Shiro 所做的事情：
验证用户来核实他们的身份
对用户执行访问控制，如：
判断用户是否被分配了一个确定的安全角色。
判断用户是否被允许做某事。
在任何环境下使用 Session API，即使没有 Web 或 EJB 容器。
在身份验证，访问控制期间或在会话的生命周期，对事件作出反应。
聚集一个或多个用户安全数据的数据源，并作为一个单一的复合用户“视图”。

启用单点登录（SSO）功能。

并发登录管理（一个账号多人登录作踢人操作）。

为没有关联到登录的用户启用"Remember Me"服务。
…

以及更多——全部集成到紧密结合的易于使用的 API 中。

目前Java领域主流的安全框架有SpringSecurity和Shiro，相比于SpringSecurity，Shiro轻量化，简单容易上手，且不局限于Java和Spring；SpringSecurity太笨重了，难以上手，且只能在Spring里用，所以博主极力推荐Shiro。

spring集成shiro要用到shiro-all-1.2.4.jar

jar包下载地址：http://download.csdn.net/detail/qq_33556185/9540257

第一步：配置shiro.xml文件

shiro.xml配置文件代码：

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
3. xmlns:mvc="http://www.springframework.org/schema/mvc"
4. xsi:schemaLocation="http://www.springframework.org/schema/beans
5. http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
6. http://www.springframework.org/schema/tx
7. http://www.springframework.org/schema/tx/spring-tx-4.2.xsd
8. http://www.springframework.org/schema/context
9. http://www.springframework.org/schema/context/spring-context-4.2.xsd
10. http://www.springframework.org/schema/mvc
11. http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd">
12. <!-- Shiro Filter 拦截器相关配置 -->
13. <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
14. <!-- securityManager -->
15. <property name="securityManager" ref="securityManager" />
16. <!-- 登录路径 -->
17. <property name="loginUrl" value="/toLogin" />
18. <!-- 用户访问无权限的链接时跳转此页面  -->
19. <property name="unauthorizedUrl" value="/unauthorizedUrl.jsp" />
20. <!-- 过滤链定义 -->
21. <property name="filterChainDefinitions">
22. <value>
23. /loginin=anon
24. /toLogin=anon
25. /css/**=anon
26. /html/**=anon
27. /images/**=anon
28. /js/**=anon
29. /upload/**=anon
30. <!-- /userList=roles[admin] -->
31. /userList=authc,perms[/userList]
32. /toDeleteUser=authc,perms[/toDeleteUser]
33. /** = authc
34. </value>
35. </property>
36. </bean>
37. <!-- securityManager -->
38. <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
39. <property name="realm" ref="myRealm" />
40. </bean>
41. <!-- 自定义Realm实现 -->
42. <bean id="myRealm" class="com.core.shiro.realm.CustomRealm" />
43. <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor" />
44. <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
45. <property name="prefix" value="/"/>
46. <property name="suffix" value=".jsp"></property>
47. </bean>
48. </beans>

anno代表不需要授权即可访问，对于静态资源，访问权限都设置为anno

authc表示需要登录才可访问

/userList=roles[admin]的含义是要访问/userList需要有admin这个角色，如果没有此角色访问此URL会返回无授权页面

/userList=authc,perms[/userList]的含义是要访问/userList需要有/userList的权限，要是没分配此权限访问此URL会返回无授权页面

1. <bean id="myRealm" class="com.core.shiro.realm.CustomRealm" />

这个是业务对象，需要我们去实现。

第二步：在web.xml文件里加载shiro.xml,和加载其他配置文件是一样的，就不多说了

1. <context-param>
2. <param-name>contextConfigLocation</param-name>
3. <param-value>
4. classpath*:/spring/spring-common.xml,
5. classpath*:/spring/shiro.xml
6. </param-value>
7. </context-param>

第三步：配置shiroFilter，所有请求都要先进shiro的代理类

1. <!--
2. DelegatingFilterProxy类是一个代理类，所有的请求都会首先发到这个filter代理
3. 然后再按照"filter-name"委派到spring中的这个bean。
4. 在Spring中配置的bean的name要和web.xml中的<filter-name>一样.
5. targetFilterLifecycle，是否由spring来管理bean的生命周期，设置为true有个好处，可以调用spring后续的bean
6. -->
7. <filter>
8. <filter-name>shiroFilter</filter-name>
9. <filter-class>
10. org.springframework.web.filter.DelegatingFilterProxy
11. </filter-class>
12. <init-param>
13. <param-name>targetFilterLifecycle</param-name>
14. <param-value>true</param-value>
15. </init-param>
16. </filter>
17. <filter-mapping>
18. <filter-name>shiroFilter</filter-name>
19. <url-pattern>/*</url-pattern>
20. </filter-mapping>

第四步：自定义realm

1. package com.core.shiro.realm;
2. import java.util.List;
3. import javax.annotation.Resource;
4. import org.apache.shiro.authc.AuthenticationException;
5. import org.apache.shiro.authc.AuthenticationInfo;
6. import org.apache.shiro.authc.AuthenticationToken;
7. import org.apache.shiro.authc.SimpleAuthenticationInfo;
8. import org.apache.shiro.authc.UsernamePasswordToken;
9. import org.apache.shiro.authz.AuthorizationInfo;
10. import org.apache.shiro.authz.SimpleAuthorizationInfo;
11. import org.apache.shiro.realm.AuthorizingRealm;
12. import org.apache.shiro.subject.PrincipalCollection;
13. import org.springframework.util.StringUtils;
14. import com.core.shiro.dao.IPermissionDao;
15. import com.core.shiro.dao.IRoleDao;
16. import com.core.shiro.dao.IUserDao;
17. import com.core.shiro.entity.Permission;
18. import com.core.shiro.entity.Role;
19. import com.core.shiro.entity.User;
20. public class CustomRealm extends AuthorizingRealm{
21. @Resource
22. private IUserDao userDao;
23. @Resource
24. private IPermissionDao permissionDao;
25. @Resource
26. private IRoleDao roleDao;
27. /**
28. * 添加角色
29. * @param username
30. * @param info
31. */
32. private void addRole(String username, SimpleAuthorizationInfo info) {
33. List<Role> roles = roleDao.findByUser(username);
34. if(roles!=null&&roles.size()>0){
35. for (Role role : roles) {
36. info.addRole(role.getRoleName());
37. }
38. }
39. }
40. /**
41. * 添加权限
42. * @param username
43. * @param info
44. * @return
45. */
46. private SimpleAuthorizationInfo addPermission(String username,SimpleAuthorizationInfo info) {
47. List<Permission> permissions = permissionDao.findPermissionByName(username);
48. for (Permission permission : permissions) {
49. info.addStringPermission(permission.getUrl());//添加权限
50. }
51. return info;
52. }
53. /**
54. * 获取授权信息
55. */
56. protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
57. //用户名
58. String username = (String) principals.fromRealm(getName()).iterator().next();
59. //根据用户名来添加相应的权限和角色
60. if(!StringUtils.isEmpty(username)){
61. SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
62. addPermission(username,info);
63. addRole(username, info);
64. return info;
65. }
66. return null;
67. }
68. /**
69. * 登录验证
70. */
71. protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authcToken ) throws AuthenticationException {
72. //令牌——基于用户名和密码的令牌
73. UsernamePasswordToken token = (UsernamePasswordToken) authcToken;
74. //令牌中可以取出用户名
75. String accountName = token.getUsername();
76. //让shiro框架去验证账号密码
77. if(!StringUtils.isEmpty(accountName)){
78. User user = userDao.findUser(accountName);
79. if(user != null){
80. return new SimpleAuthenticationInfo(user.getUserName(), user.getPassword(), getName());
81. }
82. }
83. return null;
84. }
85. }

第五步：控制层代码

1. package com.core.shiro.controller;
2. import javax.servlet.http.HttpServletRequest;
3. import org.apache.shiro.SecurityUtils;
4. import org.apache.shiro.authc.AuthenticationException;
5. import org.apache.shiro.authc.UsernamePasswordToken;
6. import org.apache.shiro.crypto.hash.Md5Hash;
7. import org.apache.shiro.subject.Subject;
8. import org.springframework.stereotype.Controller;
9. import org.springframework.web.bind.annotation.RequestMapping;
10. @Controller
11. public class ShiroAction {
12. @RequestMapping("loginin")
13. public String login(HttpServletRequest request){
14. //当前Subject
15. Subject currentUser = SecurityUtils.getSubject();
16. //加密（md5+盐），返回一个32位的字符串小写
17. String salt="("+request.getParameter("username")+")";
18. String md5Pwd=new Md5Hash(request.getParameter("password"),salt).toString();
19. //传递token给shiro的realm
20. UsernamePasswordToken token = new UsernamePasswordToken(request.getParameter("username"),md5Pwd);
21. try {
22. currentUser.login(token);
23. return "welcome";
24. } catch (AuthenticationException e) {//登录失败
25. request.setAttribute("msg", "用户名和密码错误");
26. }
27. return "login";
28. }
29. @RequestMapping("toLogin")
30. public String toLogin(){
31. return "login";
32. }
33. }

第六步：login页面 略

login请求调用currentUser.login之后，shiro会将token传递给自定义realm,此时realm会先调用doGetAuthenticationInfo(AuthenticationToken authcToken )登录验证的方法，验证通过后会接着调用 doGetAuthorizationInfo(PrincipalCollection principals)获取角色和权限的方法（授权），最后返回视图。

当其他请求进入shiro时，shiro会调用doGetAuthorizationInfo(PrincipalCollection principals)去获取授权信息，若是没有权限或角色，会跳转到未授权页面，若有权限或角色，shiro会放行，ok，此时进入真正的请求方法……

到此shiro的认证及授权便完成了。

http://blog.csdn.net/qq_33556185/article/details/51579680