BOS项目练习(权限概述,权限数据模型,shiro入门{bos中应用})
2016-06-20 15:37
316 查看
内容安排:
1、权限概述（认证、授权）
2、常见的权限控制的方式（URL拦截、方法注解）
3、权限的数据模型（权限表、角色表、用户表、角色权限关系表、用户角色关系表）
4、apache shiro框架
5、将shiro应用到bos项目中（认证、授权）
系统中提供了很多功能，并不是所有的用户都可以操作这些功能，需要对功能的访问进行控制。
认证：系统提供的用于识别用户身份的功能，通常是登录功能（你是谁？？？）
授权：系统提供的赋予用户可以操作系统某些功能能力（你能做什么？？？）
菜单和按钮是访问某个功能的入口，都是发起一次请求，由服务端进行相应的操作。
2.1 URL拦截进行权限校验
2.2 方法注解权限控制
权限表
角色表:引入角色是为了简化授权
用户表
角色权限关系表(多对多中间表)
用户角色关系表(多对多中间表)
关键字:注解后面可以使用
路径:访问action的路径
菜单:有些资源会挂到菜单上
优先级:用户菜单排序
父权限编号:权限的上下级,指向本表的主键
实体类
权限实体
[java] view
plain copy
/**
* 权限实体
*
*/
public class Function implements java.io.Serializable {
// Fields
private String id;//编号
private Function parentFunction;//当前权限对应的上一级权限
private String name;//权限名称
private String code;//关键字
private String description;//描述
private String page;//访问URL
private String generatemenu;//当前权限是否生成到菜单 1:生成 0:不生成
private Integer zindex;//排序
private Set children = new HashSet(0);//当前权限对应的多个下级权限
private Set roles = new HashSet(0);//当前权限对应的多个角色
角色实体
[java] view
plain copy
/**
* 角色实体
*
*/
public class Role implements java.io.Serializable {
// Fields
private String id;//编号
private String name;//角色名称
private String code;//关键字
private String description;//描述
private Set functions = new HashSet(0);//当前角色对应的多个权限
private Set users = new HashSet(0);//当前角色对应的多个用户
用户
[java] view
plain copy
public class User implements java.io.Serializable {
private String id;
private String username;
private String password;
private Double salary;
private Timestamp birthday;
private String gender;
private String station;
private String telephone;
private String remark;
private Set noticebills = new HashSet(0);
private Set roles = new HashSet(0);//当前用户对应的多个角色
提供的进行权限控制的方式：
1、URL拦截进行权限控制
2、方法注解权限控制
3、页面标签权限控制
4、代码方式权限控制（了解）
shiro提供的功能：
Shiro的4大部分——身份验证，授权，会话管理和加密
• Authentication：身份验证，简称“登录”。
• Authorization：授权，给用户分配角色或者权限资源
• Session Management：用户session管理器，可以让CS程序也使用session来控制权限
• Cryptography：把JDK中复杂的密码加密方式进行封装
除了以上功能，shiro还提供很多扩展
• Web Support：主要针对web应用提供一些常用功能。
• Caching：缓存可以使应用程序运行更有效率。
• Concurrency：多线程相关功能。
• Testing：帮助我们进行测试相关功能
• "Run As"：一个允许用户假设为另一个用户身份（如果允许）的功能，有时候在管理脚本很有用。
• “Remember Me”：记住用户身份，提供类似购物车功能。
shiro框架运行流程图：
Application Code：应用程序代码，由开发人员负责
Subject：
由框架提供的,是与程序进行交互的对象，可以是人也可以是服务或者其他，通常就理解为用户。
所有Subject 实例都必须绑定到一个SecurityManager上。我们与一个 Subject
交互，运行时shiro会自动转化为与 SecurityManager交互的特定 subject的交互
SecurityManager:
安全管理器，由框架提供的，SecurityManager 是 Shiro的核心，初始化时协调各个模块运行。然而，一旦 SecurityManager协调完毕，SecurityManager 会被单独留下，且我们只需要去操作Subject即可，无需操作SecurityManager 。 但是我们得知道，当我们正与一个 Subject 进行交互时，实质上是 SecurityManager在处理 Subject 安全操作。
Realm：
安全数据桥，类似于项目中的DAO，访问安全数据的，框架提供，开发人员也可自己编写
Realms在 Shiro中作为应用程序和安全数据之间的“桥梁”或“连接器”。他获取安全数据来判断subject是否能够登录，subject拥有什么权限。他有点类似DAO。在配置realms时，需要至少一个realm。而且Shiro提供了一些常用的 Realms来连接数据源，如LDAP数据源的JndiLdapRealm，JDBC数据源的JdbcRealm，ini文件数据源的IniRealm，properties文件数据源的PropertiesRealm，等等。我们也可以插入自己的 Realm实现来代表自定义的数据源。
像其他组件一样，Realms也是由SecurityManager控制
小结
1.Subject(org.apache.shiro.subject.Subject):简称用户
2.SecurityManager(org.apache.shiro.mgt.SecurityManager)
如上所述，SecurityManager是shiro的核心，协调shiro的各个组件
3.Authenticator(org.apache.shiro.authc.Authenticator)：
登录控制
注：AuthenticationStrategy
(org.apache.shiro.authc.pam.AuthenticationStrategy)
如果存在多个realm，则接口AuthenticationStrategy会确定什么样算是登录成功（例如，如果一个Realm成功，而其他的均失败，是否登录成功？）。
4.Authorizer(org.apache.shiro.authz.Authorizer)：
决定subject能拥有什么样角色或者权限。
5.SessionManager(org.apache.shiro.session.SessionManager)：
创建和管理用户session。通过设置这个管理器，shiro可以在任何环境下使用session。
6.CacheManager(org.apahce.shiro.cache.CacheManager)：
缓存管理器，可以减少不必要的后台访问。提高应用效率，增加用户体验。
7.Cryptography(org.apache.shiro.crypto.*) :
Shiro的api大幅度简化Java api中繁琐的密码加密。
8.Realms(org.apache.shiro.realm.Realm) ：程序与安全数据的桥梁
因为官方例子虽然中有更加简洁的ini配置形式，但是使用ini配置无法与spring整合
第一步：导入shiro的jar包到项目中
shiro-all-1.2.2.jar
第二步：在web.xml中配置一个过滤器，是由spring提供的，用于整合shiro
注意:配置到struts2核心过滤器的前面
filter-name 与spring xml 配置的 bean id一致
org.springframework.web.filter.DelegatingFilterProxy
[html] view
plain copy
<!-- 配置spring提供的过滤器，用于整合shiro框架 ,
在项目启动过程中，当前过滤器会从spring工厂中获取一个和当前过滤器同名的bean对象-->
<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>
</filter-mapping>
第三步：在applicationContext.xml中配置bean，ID必须为shiroFilter
org.apache.shiro.spring.web.ShiroFilterFactoryBean
[html] view
plain copy
<!-- 配置shiro的过滤器对象,当前对象用于创建shiro框架需要的过滤器对象 -->
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
<!-- 注入安全管理器 -->
<property name="securityManager" ref="securityManager"/>
<!-- 注入系统的登录访问路径 -->
<property name="loginUrl" value="/login.jsp"/>
<!-- 成功页面 -->
<property name="successUrl" value="/index.jsp"/>
<!-- 权限不足提示页面 -->
<property name="unauthorizedUrl" value="/unauthorizedUrl.jsp"/>
<!-- 基于URL拦截权限控制 -->
<property name="filterChainDefinitions">
<value>
/css/** = anon
/js/** = anon
/images/** = anon
/validatecode.jsp* = anon
/login.jsp* = anon
/userAction_login.action = anon
/page_base_staff.action = perms["staff"]
/* = authc
</value>
</property>
</bean>
securityManager：这个属性是必须的。
安全管理器配置代码
[html] view
plain copy
<!-- 定义安全管理器 -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
<!-- 注入realm -->
<property name="realm" ref="bosRealm"></property>
</bean>
<!-- 自定义Realm -->
<bean id="bosRealm" class="com.itheima.bos.shiro.BOSRealm"></bean>
loginUrl ：没有登录的用户请求需要登录的页面时自动跳转到登录页面，不是必须的属性，不输入地址的话会自动寻找项目web项目的根目录下的”/login.jsp”页面。
successUrl ：登录成功默认跳转页面，不配置则跳转至”/”。如果登陆前点击的一个需要登录的页面，则在登录自动跳转到那个需要登录的页面。不跳转到此。
unauthorizedUrl ：没有权限默认跳转的页面。
过滤器
anon:
例子/admins/**=anon没有参数，表示可以匿名使用。
authc:
例如/admins/user/**=authc表示需要认证(登录)才能使用，没有参数
roles：
例子/admins/user/**=roles[admin],参数可以写多个，多个时必须加上引号，并且参数之间用逗号分割，当有多个参数时，例如admins/user/**=roles["admin,guest"],每个参数通过才算通过，相当于hasAllRoles()方法。
perms：
例子/admins/user/**=perms[user:add:*],参数可以写多个，多个时必须加上引号，并且参数之间用逗号分割，例如/admins/user/**=perms["user:add:*,user:modify:*"]，当有多个参数时必须每个参数都通过才通过，想当于isPermitedAll()方法。
Rest：
例子/admins/user/**=rest[user],根据请求的方法，相当于/admins/user/**=perms[user:method],其中method为post，get，delete等。
port：
例子/admins/user/**=port[8081],当请求的url的端口不是8081是跳转到schemal://serverName:8081?queryString,其中schmal是协议http或https等，serverName是你访问的host,8081是url配置里port的端口，queryString
是你访问的url里的？后面的参数。
authcBasic：
例如/admins/user/**=authcBasic没有参数表示httpBasic认证
ssl:
例子/admins/user/**=ssl没有参数，表示安全的url请求，协议为https
user:
例如/admins/user/**=user没有参数表示必须存在用户，当登入操作时不做检查
注：
anon，authcBasic，auchc，user是认证过滤器，
perms，roles，ssl，rest，port是授权过滤器
第四步：修改UserAction中的login方法，使用shiro提供的方式进行认证
过程:
1.通过subjec对象的login方法进行认证
2.Subject会调用securityManager安全管理器,安全管理器会调用Realm
3.securityManager安全管理器不是通过返回参数的方式而是通过抛异常来做出判定结果
用户名不存在异常：
org.apache.shiro.authc.UnknownAccountException
密码错误异常：
org.apache.shiro.authc.IncorrectCredentialsException
代码
[java] view
plain copy
//提供属性接收验证码
private String checkcode;
public void setCheckcode(String checkcode) {
this.checkcode = checkcode;
}
/**
* 使用shiro方式进行认证
*/
public String login(){
//从session中获取自动生成的验证码
String key = (String) ActionContext.getContext().getSession().get("key");
if(StringUtils.isNotBlank(checkcode) && checkcode.equals(key)){
//使用shiro方式进行认证
String username = model.getUsername();
String password = model.getPassword();
password = MD5Utils.md5(password);
Subject subject = SecurityUtils.getSubject();//主体,当前状态为“未认证”状态
AuthenticationToken token = new UsernamePasswordToken(username, password);//用户名密码令牌
try{
subject.login(token);//使用subject调用SecurityManager,安全管理器调用Realm
User user = (User) subject.getPrincipal();
//登录成功,将User对象放入session
ActionContext.getContext().getSession().put("loginUser", user);
}catch (UnknownAccountException e) {//用户名不存在异常
e.printStackTrace();
return "login";
}catch (IncorrectCredentialsException e) {//密码错误异常
e.printStackTrace();
return "login";
}
return "home";
}else{
//验证码有误,添加错误信息，跳转到登录页面
this.addActionError(this.getText("checkcodeError"));
return "login";
}
}
第五步：自定义一个Realm，实现认证方法
继承抽象类 重写认证与授权方法
[java] view
plain copy
public class BOSRealm extends AuthorizingRealm {
// 注入dao
@Resource
private IUserDao userDao;
// 认证方法
protected AuthenticationInfo doGetAuthenticationInfo(
AuthenticationToken token) throws AuthenticationException {
System.out.println("认证方法。。。。");
UsernamePasswordToken pwdToken = (UsernamePasswordToken) token;
String username = pwdToken.getUsername();
// 根据用户名查询密码，由安全管理器负责比对查询出的数据库中的密码和页面输入的密码是否一致
User user = userDao.findUserByUsername(username);
if(user == null){
return null;
}
String dbPassword = user.getPassword();
//参数一：
AuthenticationInfo info = new SimpleAuthenticationInfo(user,
dbPassword, this.getClass().getSimpleName());
return info;
}
//授权方法
protected AuthorizationInfo doGetAuthorizationInfo(
PrincipalCollection principals) {
//根据当前登陆用户,查询当前用户的角色,根据角色获取相应的权限,把权限添加到授权信息对象中
//三种获得当前登陆用户的方式
User user1 = (User) principals.getPrimaryPrincipal();
User user2 = (User) SecurityUtils.getSubject().getPrincipal();
//User user3 = (User) ActionContext.getContext().getSession().get("session_user");
//由于添加权限 角色的 相应方法还没学习编码 暂用伪代码添加权限
//spring是shrio配置中filterChainDefinitions 添加了/page_base_staff.action=perms["staff"]
SimpleAuthorizationInfo info=new SimpleAuthorizationInfo();
info.addStringPermission("staff");
// info.addStringPermission("region.query");
return info;
}
第六步：在applicationContext.xml中注册Realm，并注入给安全管理器
[html] view
plain copy
<!-- 定义安全管理器 -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
<!-- 注入realm -->
<property name="realm" ref="bosRealm"></property>
</bean>
<!-- 自定义Realm -->
<bean id="bosRealm" class="com.itheima.bos.shiro.BOSRealm"></bean>
第七步：在自定义Realm中实现授权方法
*授权方法执行的时机:为当访问的路径需要权限认证的时候,才执行授权
*这样每次访问权限路径都执行一次授权方法,效率很低,需要增加缓存管理器
[java] view
plain copy
public class BosRealm extends AuthorizingRealm{
@Resource
private IUserDao userDao;
@Resource
private IRoleDao roleDao;
@Resource
private IFunctionDao functionDao;
//认证方法
protected AuthenticationInfo doGetAuthenticationInfo(
AuthenticationToken token) throws AuthenticationException {
System.out.println("认证方法。。。");
UsernamePasswordToken usernamePasswordToken = (UsernamePasswordToken) token;
String username = usernamePasswordToken.getUsername();
//1 根据用户名查询密码
User user = userDao.findUserByUserName(username);
if(user == null){
// 用户名不存在
return null;
}
//2 返回AuthenticationInfo对象
Object principal = user;//将当前查询到的用户对象放入SimpleAuthenticationInfo中，可以通过subject获得
Object credentials = user.getPassword();//密码，shiro负责比较查询到的密码和用户输入的密码是否一致
String realmName = super.getName();
AuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(principal, credentials, realmName);
return authenticationInfo;
}
//授权方法
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
System.out.println("授权...");
// 获取当前登陆用户 ，根据当前登陆用户，查询对应角色信息
Subject subject = SecurityUtils.getSubject();
User user = (User) subject.getPrincipal();
SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
if (user.getUsername().equals("admin")) {
// 如果admin ，查询所有角色和所有权限
List<Role> roles = roleDao.findAll();
for (Role role : roles) {
authorizationInfo.addRole(role.getCode());
}
List<Function> functions = functionDao.findAll();
for (Function function : functions) {
authorizationInfo.addStringPermission(function.getCode());
}
} else {
// 普通用户 ， 根据当前用户，查询具有角色，通过角色获取权限
List<Role> roles = roleDao.findRolesByUser(user);
// 添加角色
for (Role role : roles) {
authorizationInfo.addRole(role.getCode());
// 添加角色对应权限
Set<Function> functions = role.getFunctions();
for (Function function : functions) {
authorizationInfo.addStringPermission(function.getCode());
}
}
}
return authorizationInfo;
}
protected AuthorizationInfo doGetAuthorizationInfo_bak(
PrincipalCollection principals) {
System.out.println("授权方法。。。");
User user = (User) principals.getPrimaryPrincipal();
System.out.println(user);
//根据当前登录用户查询对应的权限和角色
SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
authorizationInfo.addStringPermission("staff:query");
authorizationInfo.addStringPermission("abc");
authorizationInfo.addRole("admin");
return authorizationInfo;
}
}
第一步：在spring配置文件中开启shiro注解功能
[html] view
plain copy
<!-- 开启shiro注解自动代理 -->
<bean id="defaultAdvisorAutoProxyCreator"
class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator">
<!-- 指定强制使用cglib为Action创建代理对象 -->
<property name="proxyTargetClass" value="true"/>
</bean>
<!-- 切面 -->
<bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor"></bean>
第二步：在Action方法上使用注解进行权限控制
[java] view
plain copy
/**
* 分页查询方法
* @throws IOException
*/
@RequiresPermissions(value="region.query")//执行这个方法需要region.query权限
//@RequiresRoles(value="admin")
public String pageQuery() throws IOException{
regionService.pageQuery(pageBean);
this.writePageBean2Json(pageBean, new String[]{"currentPage","pageSize","detachedCriteria","subareas"});
return NONE;
}
控制精度：
注解方式控制权限只能是在方法上控制，无法控制类级别访问。
过滤器方式控制是根据访问的URL进行控制。允许使用*匹配URL，所以可以进行粗粒度，也可以进行细粒度控制。
其他注解
@RequiresAuthentication
验证用户是否登录，等同于方法subject.isAuthenticated() 结果为true时。
@ RequiresUser
验证用户是否被记忆，user有两种含义：
一种是成功登录的（subject.isAuthenticated() 结果为true）；
另外一种是被记忆的（ subject.isRemembered()结果为true）。
@ RequiresGuest
验证是否是一个guest的请求，与@ RequiresUser完全相反。
换言之，RequiresUser == ! RequiresGuest 。
此时subject.getPrincipal() 结果为null.
@ RequiresRoles
例如：@RequiresRoles("aRoleName");
void someMethod();
如果subject中有aRoleName角色才可以访问方法someMethod。如果没有这个权限则会抛出异常AuthorizationException。
@RequiresPermissions
例如： @RequiresPermissions( {"file:read", "write:aFile.txt"} ) void someMethod();
要求subject中必须同时含有file:read和write:aFile.txt的权限才能执行方法someMethod()。否则抛出异常AuthorizationException。
第三步：修改BaseAction的构造方法
[java] view
plain copy
// 构造方法
@SuppressWarnings("unchecked")
public BaseAction() {
//获取父类类型(baseAction)
ParameterizedType superclass = null;
Type type = this.getClass().getGenericSuperclass();
//获取父类泛型 强制转化参数类型 需要判断 生成action是否使用代理 既父类是否是参数化类型
if(type instanceof ParameterizedType){
//没有使用代理直接强制转换
superclass = (ParameterizedType) type;
}else{
//type 不属于参数化类型 则action是cglib代理生成
//CGLib是针对目标类生产子类,需要获取父类的父类的类型再强转成参数化类型
superclass = (ParameterizedType) this.getClass().getSuperclass().getGenericSuperclass();
}
...
第四步：在自定义Realm中授权
略
内容安排:
1、权限概述（认证、授权）
2、常见的权限控制的方式（URL拦截、方法注解）
3、权限的数据模型（权限表、角色表、用户表、角色权限关系表、用户角色关系表）
4、apache shiro框架
5、将shiro应用到bos项目中（认证、授权）
系统中提供了很多功能，并不是所有的用户都可以操作这些功能，需要对功能的访问进行控制。
认证：系统提供的用于识别用户身份的功能，通常是登录功能（你是谁？？？）
授权：系统提供的赋予用户可以操作系统某些功能能力（你能做什么？？？）
菜单和按钮是访问某个功能的入口，都是发起一次请求，由服务端进行相应的操作。
2.1 URL拦截进行权限校验
2.2 方法注解权限控制
权限表
角色表:引入角色是为了简化授权
用户表
角色权限关系表(多对多中间表)
用户角色关系表(多对多中间表)
关键字:注解后面可以使用
路径:访问action的路径
菜单:有些资源会挂到菜单上
优先级:用户菜单排序
父权限编号:权限的上下级,指向本表的主键
实体类
权限实体
[java] view
plain copy
/**
* 权限实体
*
*/
public class Function implements java.io.Serializable {
// Fields
private String id;//编号
private Function parentFunction;//当前权限对应的上一级权限
private String name;//权限名称
private String code;//关键字
private String description;//描述
private String page;//访问URL
private String generatemenu;//当前权限是否生成到菜单 1:生成 0:不生成
private Integer zindex;//排序
private Set children = new HashSet(0);//当前权限对应的多个下级权限
private Set roles = new HashSet(0);//当前权限对应的多个角色
角色实体
[java] view
plain copy
/**
* 角色实体
*
*/
public class Role implements java.io.Serializable {
// Fields
private String id;//编号
private String name;//角色名称
private String code;//关键字
private String description;//描述
private Set functions = new HashSet(0);//当前角色对应的多个权限
private Set users = new HashSet(0);//当前角色对应的多个用户
用户
[java] view
plain copy
public class User implements java.io.Serializable {
private String id;
private String username;
private String password;
private Double salary;
private Timestamp birthday;
private String gender;
private String station;
private String telephone;
private String remark;
private Set noticebills = new HashSet(0);
private Set roles = new HashSet(0);//当前用户对应的多个角色
提供的进行权限控制的方式：
1、URL拦截进行权限控制
2、方法注解权限控制
3、页面标签权限控制
4、代码方式权限控制（了解）
shiro提供的功能：
Shiro的4大部分——身份验证，授权，会话管理和加密
• Authentication：身份验证，简称“登录”。
• Authorization：授权，给用户分配角色或者权限资源
• Session Management：用户session管理器，可以让CS程序也使用session来控制权限
• Cryptography：把JDK中复杂的密码加密方式进行封装
除了以上功能，shiro还提供很多扩展
• Web Support：主要针对web应用提供一些常用功能。
• Caching：缓存可以使应用程序运行更有效率。
• Concurrency：多线程相关功能。
• Testing：帮助我们进行测试相关功能
• "Run As"：一个允许用户假设为另一个用户身份（如果允许）的功能，有时候在管理脚本很有用。
• “Remember Me”：记住用户身份，提供类似购物车功能。
shiro框架运行流程图：
Application Code：应用程序代码，由开发人员负责
Subject：
由框架提供的,是与程序进行交互的对象，可以是人也可以是服务或者其他，通常就理解为用户。
所有Subject 实例都必须绑定到一个SecurityManager上。我们与一个 Subject
交互，运行时shiro会自动转化为与 SecurityManager交互的特定 subject的交互
SecurityManager:
安全管理器，由框架提供的，SecurityManager 是 Shiro的核心，初始化时协调各个模块运行。然而，一旦 SecurityManager协调完毕，SecurityManager 会被单独留下，且我们只需要去操作Subject即可，无需操作SecurityManager 。 但是我们得知道，当我们正与一个 Subject 进行交互时，实质上是 SecurityManager在处理 Subject 安全操作。
Realm：
安全数据桥，类似于项目中的DAO，访问安全数据的，框架提供，开发人员也可自己编写
Realms在 Shiro中作为应用程序和安全数据之间的“桥梁”或“连接器”。他获取安全数据来判断subject是否能够登录，subject拥有什么权限。他有点类似DAO。在配置realms时，需要至少一个realm。而且Shiro提供了一些常用的 Realms来连接数据源，如LDAP数据源的JndiLdapRealm，JDBC数据源的JdbcRealm，ini文件数据源的IniRealm，properties文件数据源的PropertiesRealm，等等。我们也可以插入自己的 Realm实现来代表自定义的数据源。
像其他组件一样，Realms也是由SecurityManager控制
小结
1.Subject(org.apache.shiro.subject.Subject):简称用户
2.SecurityManager(org.apache.shiro.mgt.SecurityManager)
如上所述，SecurityManager是shiro的核心，协调shiro的各个组件
3.Authenticator(org.apache.shiro.authc.Authenticator)：
登录控制
注：AuthenticationStrategy
(org.apache.shiro.authc.pam.AuthenticationStrategy)
如果存在多个realm，则接口AuthenticationStrategy会确定什么样算是登录成功（例如，如果一个Realm成功，而其他的均失败，是否登录成功？）。
4.Authorizer(org.apache.shiro.authz.Authorizer)：
决定subject能拥有什么样角色或者权限。
5.SessionManager(org.apache.shiro.session.SessionManager)：
创建和管理用户session。通过设置这个管理器，shiro可以在任何环境下使用session。
6.CacheManager(org.apahce.shiro.cache.CacheManager)：
缓存管理器，可以减少不必要的后台访问。提高应用效率，增加用户体验。
7.Cryptography(org.apache.shiro.crypto.*) :
Shiro的api大幅度简化Java api中繁琐的密码加密。
8.Realms(org.apache.shiro.realm.Realm) ：程序与安全数据的桥梁
因为官方例子虽然中有更加简洁的ini配置形式，但是使用ini配置无法与spring整合
第一步：导入shiro的jar包到项目中
shiro-all-1.2.2.jar
第二步：在web.xml中配置一个过滤器，是由spring提供的，用于整合shiro
注意:配置到struts2核心过滤器的前面
filter-name 与spring xml 配置的 bean id一致
org.springframework.web.filter.DelegatingFilterProxy
[html] view
plain copy
<!-- 配置spring提供的过滤器，用于整合shiro框架 ,
在项目启动过程中，当前过滤器会从spring工厂中获取一个和当前过滤器同名的bean对象-->
<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>
</filter-mapping>
第三步：在applicationContext.xml中配置bean，ID必须为shiroFilter
org.apache.shiro.spring.web.ShiroFilterFactoryBean
[html] view
plain copy
<!-- 配置shiro的过滤器对象,当前对象用于创建shiro框架需要的过滤器对象 -->
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
<!-- 注入安全管理器 -->
<property name="securityManager" ref="securityManager"/>
<!-- 注入系统的登录访问路径 -->
<property name="loginUrl" value="/login.jsp"/>
<!-- 成功页面 -->
<property name="successUrl" value="/index.jsp"/>
<!-- 权限不足提示页面 -->
<property name="unauthorizedUrl" value="/unauthorizedUrl.jsp"/>
<!-- 基于URL拦截权限控制 -->
<property name="filterChainDefinitions">
<value>
/css/** = anon
/js/** = anon
/images/** = anon
/validatecode.jsp* = anon
/login.jsp* = anon
/userAction_login.action = anon
/page_base_staff.action = perms["staff"]
/* = authc
</value>
</property>
</bean>
securityManager：这个属性是必须的。
安全管理器配置代码
[html] view
plain copy
<!-- 定义安全管理器 -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
<!-- 注入realm -->
<property name="realm" ref="bosRealm"></property>
</bean>
<!-- 自定义Realm -->
<bean id="bosRealm" class="com.itheima.bos.shiro.BOSRealm"></bean>
loginUrl ：没有登录的用户请求需要登录的页面时自动跳转到登录页面，不是必须的属性，不输入地址的话会自动寻找项目web项目的根目录下的”/login.jsp”页面。
successUrl ：登录成功默认跳转页面，不配置则跳转至”/”。如果登陆前点击的一个需要登录的页面，则在登录自动跳转到那个需要登录的页面。不跳转到此。
unauthorizedUrl ：没有权限默认跳转的页面。
过滤器
anon:
例子/admins/**=anon没有参数，表示可以匿名使用。
authc:
例如/admins/user/**=authc表示需要认证(登录)才能使用，没有参数
roles：
例子/admins/user/**=roles[admin],参数可以写多个，多个时必须加上引号，并且参数之间用逗号分割，当有多个参数时，例如admins/user/**=roles["admin,guest"],每个参数通过才算通过，相当于hasAllRoles()方法。
perms：
例子/admins/user/**=perms[user:add:*],参数可以写多个，多个时必须加上引号，并且参数之间用逗号分割，例如/admins/user/**=perms["user:add:*,user:modify:*"]，当有多个参数时必须每个参数都通过才通过，想当于isPermitedAll()方法。
Rest：
例子/admins/user/**=rest[user],根据请求的方法，相当于/admins/user/**=perms[user:method],其中method为post，get，delete等。
port：
例子/admins/user/**=port[8081],当请求的url的端口不是8081是跳转到schemal://serverName:8081?queryString,其中schmal是协议http或https等，serverName是你访问的host,8081是url配置里port的端口，queryString
是你访问的url里的？后面的参数。
authcBasic：
例如/admins/user/**=authcBasic没有参数表示httpBasic认证
ssl:
例子/admins/user/**=ssl没有参数，表示安全的url请求，协议为https
user:
例如/admins/user/**=user没有参数表示必须存在用户，当登入操作时不做检查
注：
anon，authcBasic，auchc，user是认证过滤器，
perms，roles，ssl，rest，port是授权过滤器
第四步：修改UserAction中的login方法，使用shiro提供的方式进行认证
过程:
1.通过subjec对象的login方法进行认证
2.Subject会调用securityManager安全管理器,安全管理器会调用Realm
3.securityManager安全管理器不是通过返回参数的方式而是通过抛异常来做出判定结果
用户名不存在异常：
org.apache.shiro.authc.UnknownAccountException
密码错误异常：
org.apache.shiro.authc.IncorrectCredentialsException
代码
[java] view
plain copy
//提供属性接收验证码
private String checkcode;
public void setCheckcode(String checkcode) {
this.checkcode = checkcode;
}
/**
* 使用shiro方式进行认证
*/
public String login(){
//从session中获取自动生成的验证码
String key = (String) ActionContext.getContext().getSession().get("key");
if(StringUtils.isNotBlank(checkcode) && checkcode.equals(key)){
//使用shiro方式进行认证
String username = model.getUsername();
String password = model.getPassword();
password = MD5Utils.md5(password);
Subject subject = SecurityUtils.getSubject();//主体,当前状态为“未认证”状态
AuthenticationToken token = new UsernamePasswordToken(username, password);//用户名密码令牌
try{
subject.login(token);//使用subject调用SecurityManager,安全管理器调用Realm
User user = (User) subject.getPrincipal();
//登录成功,将User对象放入session
ActionContext.getContext().getSession().put("loginUser", user);
}catch (UnknownAccountException e) {//用户名不存在异常
e.printStackTrace();
return "login";
}catch (IncorrectCredentialsException e) {//密码错误异常
e.printStackTrace();
return "login";
}
return "home";
}else{
//验证码有误,添加错误信息，跳转到登录页面
this.addActionError(this.getText("checkcodeError"));
return "login";
}
}
第五步：自定义一个Realm，实现认证方法
继承抽象类 重写认证与授权方法
[java] view
plain copy
public class BOSRealm extends AuthorizingRealm {
// 注入dao
@Resource
private IUserDao userDao;
// 认证方法
protected AuthenticationInfo doGetAuthenticationInfo(
AuthenticationToken token) throws AuthenticationException {
System.out.println("认证方法。。。。");
UsernamePasswordToken pwdToken = (UsernamePasswordToken) token;
String username = pwdToken.getUsername();
// 根据用户名查询密码，由安全管理器负责比对查询出的数据库中的密码和页面输入的密码是否一致
User user = userDao.findUserByUsername(username);
if(user == null){
return null;
}
String dbPassword = user.getPassword();
//参数一：
AuthenticationInfo info = new SimpleAuthenticationInfo(user,
dbPassword, this.getClass().getSimpleName());
return info;
}
//授权方法
protected AuthorizationInfo doGetAuthorizationInfo(
PrincipalCollection principals) {
//根据当前登陆用户,查询当前用户的角色,根据角色获取相应的权限,把权限添加到授权信息对象中
//三种获得当前登陆用户的方式
User user1 = (User) principals.getPrimaryPrincipal();
User user2 = (User) SecurityUtils.getSubject().getPrincipal();
//User user3 = (User) ActionContext.getContext().getSession().get("session_user");
//由于添加权限 角色的 相应方法还没学习编码 暂用伪代码添加权限
//spring是shrio配置中filterChainDefinitions 添加了/page_base_staff.action=perms["staff"]
SimpleAuthorizationInfo info=new SimpleAuthorizationInfo();
info.addStringPermission("staff");
// info.addStringPermission("region.query");
return info;
}
第六步：在applicationContext.xml中注册Realm，并注入给安全管理器
[html] view
plain copy
<!-- 定义安全管理器 -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
<!-- 注入realm -->
<property name="realm" ref="bosRealm"></property>
</bean>
<!-- 自定义Realm -->
<bean id="bosRealm" class="com.itheima.bos.shiro.BOSRealm"></bean>
第七步：在自定义Realm中实现授权方法
*授权方法执行的时机:为当访问的路径需要权限认证的时候,才执行授权
*这样每次访问权限路径都执行一次授权方法,效率很低,需要增加缓存管理器
[java] view
plain copy
public class BosRealm extends AuthorizingRealm{
@Resource
private IUserDao userDao;
@Resource
private IRoleDao roleDao;
@Resource
private IFunctionDao functionDao;
//认证方法
protected AuthenticationInfo doGetAuthenticationInfo(
AuthenticationToken token) throws AuthenticationException {
System.out.println("认证方法。。。");
UsernamePasswordToken usernamePasswordToken = (UsernamePasswordToken) token;
String username = usernamePasswordToken.getUsername();
//1 根据用户名查询密码
User user = userDao.findUserByUserName(username);
if(user == null){
// 用户名不存在
return null;
}
//2 返回AuthenticationInfo对象
Object principal = user;//将当前查询到的用户对象放入SimpleAuthenticationInfo中，可以通过subject获得
Object credentials = user.getPassword();//密码，shiro负责比较查询到的密码和用户输入的密码是否一致
String realmName = super.getName();
AuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(principal, credentials, realmName);
return authenticationInfo;
}
//授权方法
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
System.out.println("授权...");
// 获取当前登陆用户 ，根据当前登陆用户，查询对应角色信息
Subject subject = SecurityUtils.getSubject();
User user = (User) subject.getPrincipal();
SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
if (user.getUsername().equals("admin")) {
// 如果admin ，查询所有角色和所有权限
List<Role> roles = roleDao.findAll();
for (Role role : roles) {
authorizationInfo.addRole(role.getCode());
}
List<Function> functions = functionDao.findAll();
for (Function function : functions) {
authorizationInfo.addStringPermission(function.getCode());
}
} else {
// 普通用户 ， 根据当前用户，查询具有角色，通过角色获取权限
List<Role> roles = roleDao.findRolesByUser(user);
// 添加角色
for (Role role : roles) {
authorizationInfo.addRole(role.getCode());
// 添加角色对应权限
Set<Function> functions = role.getFunctions();
for (Function function : functions) {
authorizationInfo.addStringPermission(function.getCode());
}
}
}
return authorizationInfo;
}
protected AuthorizationInfo doGetAuthorizationInfo_bak(
PrincipalCollection principals) {
System.out.println("授权方法。。。");
User user = (User) principals.getPrimaryPrincipal();
System.out.println(user);
//根据当前登录用户查询对应的权限和角色
SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
authorizationInfo.addStringPermission("staff:query");
authorizationInfo.addStringPermission("abc");
authorizationInfo.addRole("admin");
return authorizationInfo;
}
}
第一步：在spring配置文件中开启shiro注解功能
[html] view
plain copy
<!-- 开启shiro注解自动代理 -->
<bean id="defaultAdvisorAutoProxyCreator"
class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator">
<!-- 指定强制使用cglib为Action创建代理对象 -->
<property name="proxyTargetClass" value="true"/>
</bean>
<!-- 切面 -->
<bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor"></bean>
第二步：在Action方法上使用注解进行权限控制
[java] view
plain copy
/**
* 分页查询方法
* @throws IOException
*/
@RequiresPermissions(value="region.query")//执行这个方法需要region.query权限
//@RequiresRoles(value="admin")
public String pageQuery() throws IOException{
regionService.pageQuery(pageBean);
this.writePageBean2Json(pageBean, new String[]{"currentPage","pageSize","detachedCriteria","subareas"});
return NONE;
}
控制精度：
注解方式控制权限只能是在方法上控制，无法控制类级别访问。
过滤器方式控制是根据访问的URL进行控制。允许使用*匹配URL，所以可以进行粗粒度，也可以进行细粒度控制。
其他注解
@RequiresAuthentication
验证用户是否登录，等同于方法subject.isAuthenticated() 结果为true时。
@ RequiresUser
验证用户是否被记忆，user有两种含义：
一种是成功登录的（subject.isAuthenticated() 结果为true）；
另外一种是被记忆的（ subject.isRemembered()结果为true）。
@ RequiresGuest
验证是否是一个guest的请求，与@ RequiresUser完全相反。
换言之，RequiresUser == ! RequiresGuest 。
此时subject.getPrincipal() 结果为null.
@ RequiresRoles
例如：@RequiresRoles("aRoleName");
void someMethod();
如果subject中有aRoleName角色才可以访问方法someMethod。如果没有这个权限则会抛出异常AuthorizationException。
@RequiresPermissions
例如： @RequiresPermissions( {"file:read", "write:aFile.txt"} ) void someMethod();
要求subject中必须同时含有file:read和write:aFile.txt的权限才能执行方法someMethod()。否则抛出异常AuthorizationException。
第三步：修改BaseAction的构造方法
[java] view
plain copy
// 构造方法
@SuppressWarnings("unchecked")
public BaseAction() {
//获取父类类型(baseAction)
ParameterizedType superclass = null;
Type type = this.getClass().getGenericSuperclass();
//获取父类泛型 强制转化参数类型 需要判断 生成action是否使用代理 既父类是否是参数化类型
if(type instanceof ParameterizedType){
//没有使用代理直接强制转换
superclass = (ParameterizedType) type;
}else{
//type 不属于参数化类型 则action是cglib代理生成
//CGLib是针对目标类生产子类,需要获取父类的父类的类型再强转成参数化类型
superclass = (ParameterizedType) this.getClass().getSuperclass().getGenericSuperclass();
}
...
第四步：在自定义Realm中授权
略
1、权限概述（认证、授权）
2、常见的权限控制的方式（URL拦截、方法注解）
3、权限的数据模型（权限表、角色表、用户表、角色权限关系表、用户角色关系表）
4、apache shiro框架
5、将shiro应用到bos项目中（认证、授权）
1. 权限概述
系统中提供了很多功能，并不是所有的用户都可以操作这些功能，需要对功能的访问进行控制。认证：系统提供的用于识别用户身份的功能，通常是登录功能（你是谁？？？）
授权：系统提供的赋予用户可以操作系统某些功能能力（你能做什么？？？）
菜单和按钮是访问某个功能的入口，都是发起一次请求，由服务端进行相应的操作。
2. 常见的权限控制方式
2.1 URL拦截进行权限校验2.2 方法注解权限控制
3. 权限的数据模型
权限表角色表:引入角色是为了简化授权
用户表
角色权限关系表(多对多中间表)
用户角色关系表(多对多中间表)
关键字:注解后面可以使用
路径:访问action的路径
菜单:有些资源会挂到菜单上
优先级:用户菜单排序
父权限编号:权限的上下级,指向本表的主键
实体类
权限实体
[java] view
plain copy
/**
* 权限实体
*
*/
public class Function implements java.io.Serializable {
// Fields
private String id;//编号
private Function parentFunction;//当前权限对应的上一级权限
private String name;//权限名称
private String code;//关键字
private String description;//描述
private String page;//访问URL
private String generatemenu;//当前权限是否生成到菜单 1:生成 0:不生成
private Integer zindex;//排序
private Set children = new HashSet(0);//当前权限对应的多个下级权限
private Set roles = new HashSet(0);//当前权限对应的多个角色
角色实体
[java] view
plain copy
/**
* 角色实体
*
*/
public class Role implements java.io.Serializable {
// Fields
private String id;//编号
private String name;//角色名称
private String code;//关键字
private String description;//描述
private Set functions = new HashSet(0);//当前角色对应的多个权限
private Set users = new HashSet(0);//当前角色对应的多个用户
用户
[java] view
plain copy
public class User implements java.io.Serializable {
private String id;
private String username;
private String password;
private Double salary;
private Timestamp birthday;
private String gender;
private String station;
private String telephone;
private String remark;
private Set noticebills = new HashSet(0);
private Set roles = new HashSet(0);//当前用户对应的多个角色
4. apache shiro框架
提供的进行权限控制的方式：1、URL拦截进行权限控制
2、方法注解权限控制
3、页面标签权限控制
4、代码方式权限控制（了解）
shiro提供的功能：
Shiro的4大部分——身份验证，授权，会话管理和加密
• Authentication：身份验证，简称“登录”。
• Authorization：授权，给用户分配角色或者权限资源
• Session Management：用户session管理器，可以让CS程序也使用session来控制权限
• Cryptography：把JDK中复杂的密码加密方式进行封装
除了以上功能，shiro还提供很多扩展
• Web Support：主要针对web应用提供一些常用功能。
• Caching：缓存可以使应用程序运行更有效率。
• Concurrency：多线程相关功能。
• Testing：帮助我们进行测试相关功能
• "Run As"：一个允许用户假设为另一个用户身份（如果允许）的功能，有时候在管理脚本很有用。
• “Remember Me”：记住用户身份，提供类似购物车功能。
shiro框架运行流程图：
Application Code：应用程序代码，由开发人员负责
Subject：
由框架提供的,是与程序进行交互的对象，可以是人也可以是服务或者其他，通常就理解为用户。
所有Subject 实例都必须绑定到一个SecurityManager上。我们与一个 Subject
交互，运行时shiro会自动转化为与 SecurityManager交互的特定 subject的交互
SecurityManager:
安全管理器，由框架提供的，SecurityManager 是 Shiro的核心，初始化时协调各个模块运行。然而，一旦 SecurityManager协调完毕，SecurityManager 会被单独留下，且我们只需要去操作Subject即可，无需操作SecurityManager 。 但是我们得知道，当我们正与一个 Subject 进行交互时，实质上是 SecurityManager在处理 Subject 安全操作。
Realm：
安全数据桥，类似于项目中的DAO，访问安全数据的，框架提供，开发人员也可自己编写
Realms在 Shiro中作为应用程序和安全数据之间的“桥梁”或“连接器”。他获取安全数据来判断subject是否能够登录，subject拥有什么权限。他有点类似DAO。在配置realms时，需要至少一个realm。而且Shiro提供了一些常用的 Realms来连接数据源，如LDAP数据源的JndiLdapRealm，JDBC数据源的JdbcRealm，ini文件数据源的IniRealm，properties文件数据源的PropertiesRealm，等等。我们也可以插入自己的 Realm实现来代表自定义的数据源。
像其他组件一样，Realms也是由SecurityManager控制
小结
1.Subject(org.apache.shiro.subject.Subject):简称用户
2.SecurityManager(org.apache.shiro.mgt.SecurityManager)
如上所述，SecurityManager是shiro的核心，协调shiro的各个组件
3.Authenticator(org.apache.shiro.authc.Authenticator)：
登录控制
注：AuthenticationStrategy
(org.apache.shiro.authc.pam.AuthenticationStrategy)
如果存在多个realm，则接口AuthenticationStrategy会确定什么样算是登录成功（例如，如果一个Realm成功，而其他的均失败，是否登录成功？）。
4.Authorizer(org.apache.shiro.authz.Authorizer)：
决定subject能拥有什么样角色或者权限。
5.SessionManager(org.apache.shiro.session.SessionManager)：
创建和管理用户session。通过设置这个管理器，shiro可以在任何环境下使用session。
6.CacheManager(org.apahce.shiro.cache.CacheManager)：
缓存管理器，可以减少不必要的后台访问。提高应用效率，增加用户体验。
7.Cryptography(org.apache.shiro.crypto.*) :
Shiro的api大幅度简化Java api中繁琐的密码加密。
8.Realms(org.apache.shiro.realm.Realm) ：程序与安全数据的桥梁
5.将shiro应用到bos项目中
因为官方例子虽然中有更加简洁的ini配置形式，但是使用ini配置无法与spring整合第一步：导入shiro的jar包到项目中
shiro-all-1.2.2.jar
第二步：在web.xml中配置一个过滤器，是由spring提供的，用于整合shiro
注意:配置到struts2核心过滤器的前面
filter-name 与spring xml 配置的 bean id一致
org.springframework.web.filter.DelegatingFilterProxy
[html] view
plain copy
<!-- 配置spring提供的过滤器，用于整合shiro框架 ,
在项目启动过程中，当前过滤器会从spring工厂中获取一个和当前过滤器同名的bean对象-->
<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>
</filter-mapping>
第三步：在applicationContext.xml中配置bean，ID必须为shiroFilter
org.apache.shiro.spring.web.ShiroFilterFactoryBean
[html] view
plain copy
<!-- 配置shiro的过滤器对象,当前对象用于创建shiro框架需要的过滤器对象 -->
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
<!-- 注入安全管理器 -->
<property name="securityManager" ref="securityManager"/>
<!-- 注入系统的登录访问路径 -->
<property name="loginUrl" value="/login.jsp"/>
<!-- 成功页面 -->
<property name="successUrl" value="/index.jsp"/>
<!-- 权限不足提示页面 -->
<property name="unauthorizedUrl" value="/unauthorizedUrl.jsp"/>
<!-- 基于URL拦截权限控制 -->
<property name="filterChainDefinitions">
<value>
/css/** = anon
/js/** = anon
/images/** = anon
/validatecode.jsp* = anon
/login.jsp* = anon
/userAction_login.action = anon
/page_base_staff.action = perms["staff"]
/* = authc
</value>
</property>
</bean>
securityManager：这个属性是必须的。
安全管理器配置代码
[html] view
plain copy
<!-- 定义安全管理器 -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
<!-- 注入realm -->
<property name="realm" ref="bosRealm"></property>
</bean>
<!-- 自定义Realm -->
<bean id="bosRealm" class="com.itheima.bos.shiro.BOSRealm"></bean>
loginUrl ：没有登录的用户请求需要登录的页面时自动跳转到登录页面，不是必须的属性，不输入地址的话会自动寻找项目web项目的根目录下的”/login.jsp”页面。
successUrl ：登录成功默认跳转页面，不配置则跳转至”/”。如果登陆前点击的一个需要登录的页面，则在登录自动跳转到那个需要登录的页面。不跳转到此。
unauthorizedUrl ：没有权限默认跳转的页面。
过滤器
anon:
例子/admins/**=anon没有参数，表示可以匿名使用。
authc:
例如/admins/user/**=authc表示需要认证(登录)才能使用，没有参数
roles：
例子/admins/user/**=roles[admin],参数可以写多个，多个时必须加上引号，并且参数之间用逗号分割，当有多个参数时，例如admins/user/**=roles["admin,guest"],每个参数通过才算通过，相当于hasAllRoles()方法。
perms：
例子/admins/user/**=perms[user:add:*],参数可以写多个，多个时必须加上引号，并且参数之间用逗号分割，例如/admins/user/**=perms["user:add:*,user:modify:*"]，当有多个参数时必须每个参数都通过才通过，想当于isPermitedAll()方法。
Rest：
例子/admins/user/**=rest[user],根据请求的方法，相当于/admins/user/**=perms[user:method],其中method为post，get，delete等。
port：
例子/admins/user/**=port[8081],当请求的url的端口不是8081是跳转到schemal://serverName:8081?queryString,其中schmal是协议http或https等，serverName是你访问的host,8081是url配置里port的端口，queryString
是你访问的url里的？后面的参数。
authcBasic：
例如/admins/user/**=authcBasic没有参数表示httpBasic认证
ssl:
例子/admins/user/**=ssl没有参数，表示安全的url请求，协议为https
user:
例如/admins/user/**=user没有参数表示必须存在用户，当登入操作时不做检查
注：
anon，authcBasic，auchc，user是认证过滤器，
perms，roles，ssl，rest，port是授权过滤器
第四步：修改UserAction中的login方法，使用shiro提供的方式进行认证
过程:
1.通过subjec对象的login方法进行认证
2.Subject会调用securityManager安全管理器,安全管理器会调用Realm
3.securityManager安全管理器不是通过返回参数的方式而是通过抛异常来做出判定结果
用户名不存在异常：
org.apache.shiro.authc.UnknownAccountException
密码错误异常：
org.apache.shiro.authc.IncorrectCredentialsException
代码
[java] view
plain copy
//提供属性接收验证码
private String checkcode;
public void setCheckcode(String checkcode) {
this.checkcode = checkcode;
}
/**
* 使用shiro方式进行认证
*/
public String login(){
//从session中获取自动生成的验证码
String key = (String) ActionContext.getContext().getSession().get("key");
if(StringUtils.isNotBlank(checkcode) && checkcode.equals(key)){
//使用shiro方式进行认证
String username = model.getUsername();
String password = model.getPassword();
password = MD5Utils.md5(password);
Subject subject = SecurityUtils.getSubject();//主体,当前状态为“未认证”状态
AuthenticationToken token = new UsernamePasswordToken(username, password);//用户名密码令牌
try{
subject.login(token);//使用subject调用SecurityManager,安全管理器调用Realm
User user = (User) subject.getPrincipal();
//登录成功,将User对象放入session
ActionContext.getContext().getSession().put("loginUser", user);
}catch (UnknownAccountException e) {//用户名不存在异常
e.printStackTrace();
return "login";
}catch (IncorrectCredentialsException e) {//密码错误异常
e.printStackTrace();
return "login";
}
return "home";
}else{
//验证码有误,添加错误信息，跳转到登录页面
this.addActionError(this.getText("checkcodeError"));
return "login";
}
}
第五步：自定义一个Realm，实现认证方法
继承抽象类 重写认证与授权方法
[java] view
plain copy
public class BOSRealm extends AuthorizingRealm {
// 注入dao
@Resource
private IUserDao userDao;
// 认证方法
protected AuthenticationInfo doGetAuthenticationInfo(
AuthenticationToken token) throws AuthenticationException {
System.out.println("认证方法。。。。");
UsernamePasswordToken pwdToken = (UsernamePasswordToken) token;
String username = pwdToken.getUsername();
// 根据用户名查询密码，由安全管理器负责比对查询出的数据库中的密码和页面输入的密码是否一致
User user = userDao.findUserByUsername(username);
if(user == null){
return null;
}
String dbPassword = user.getPassword();
//参数一：
AuthenticationInfo info = new SimpleAuthenticationInfo(user,
dbPassword, this.getClass().getSimpleName());
return info;
}
//授权方法
protected AuthorizationInfo doGetAuthorizationInfo(
PrincipalCollection principals) {
//根据当前登陆用户,查询当前用户的角色,根据角色获取相应的权限,把权限添加到授权信息对象中
//三种获得当前登陆用户的方式
User user1 = (User) principals.getPrimaryPrincipal();
User user2 = (User) SecurityUtils.getSubject().getPrincipal();
//User user3 = (User) ActionContext.getContext().getSession().get("session_user");
//由于添加权限 角色的 相应方法还没学习编码 暂用伪代码添加权限
//spring是shrio配置中filterChainDefinitions 添加了/page_base_staff.action=perms["staff"]
SimpleAuthorizationInfo info=new SimpleAuthorizationInfo();
info.addStringPermission("staff");
// info.addStringPermission("region.query");
return info;
}
第六步：在applicationContext.xml中注册Realm，并注入给安全管理器
[html] view
plain copy
<!-- 定义安全管理器 -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
<!-- 注入realm -->
<property name="realm" ref="bosRealm"></property>
</bean>
<!-- 自定义Realm -->
<bean id="bosRealm" class="com.itheima.bos.shiro.BOSRealm"></bean>
第七步：在自定义Realm中实现授权方法
*授权方法执行的时机:为当访问的路径需要权限认证的时候,才执行授权
*这样每次访问权限路径都执行一次授权方法,效率很低,需要增加缓存管理器
[java] view
plain copy
public class BosRealm extends AuthorizingRealm{
@Resource
private IUserDao userDao;
@Resource
private IRoleDao roleDao;
@Resource
private IFunctionDao functionDao;
//认证方法
protected AuthenticationInfo doGetAuthenticationInfo(
AuthenticationToken token) throws AuthenticationException {
System.out.println("认证方法。。。");
UsernamePasswordToken usernamePasswordToken = (UsernamePasswordToken) token;
String username = usernamePasswordToken.getUsername();
//1 根据用户名查询密码
User user = userDao.findUserByUserName(username);
if(user == null){
// 用户名不存在
return null;
}
//2 返回AuthenticationInfo对象
Object principal = user;//将当前查询到的用户对象放入SimpleAuthenticationInfo中，可以通过subject获得
Object credentials = user.getPassword();//密码，shiro负责比较查询到的密码和用户输入的密码是否一致
String realmName = super.getName();
AuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(principal, credentials, realmName);
return authenticationInfo;
}
//授权方法
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
System.out.println("授权...");
// 获取当前登陆用户 ，根据当前登陆用户，查询对应角色信息
Subject subject = SecurityUtils.getSubject();
User user = (User) subject.getPrincipal();
SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
if (user.getUsername().equals("admin")) {
// 如果admin ，查询所有角色和所有权限
List<Role> roles = roleDao.findAll();
for (Role role : roles) {
authorizationInfo.addRole(role.getCode());
}
List<Function> functions = functionDao.findAll();
for (Function function : functions) {
authorizationInfo.addStringPermission(function.getCode());
}
} else {
// 普通用户 ， 根据当前用户，查询具有角色，通过角色获取权限
List<Role> roles = roleDao.findRolesByUser(user);
// 添加角色
for (Role role : roles) {
authorizationInfo.addRole(role.getCode());
// 添加角色对应权限
Set<Function> functions = role.getFunctions();
for (Function function : functions) {
authorizationInfo.addStringPermission(function.getCode());
}
}
}
return authorizationInfo;
}
protected AuthorizationInfo doGetAuthorizationInfo_bak(
PrincipalCollection principals) {
System.out.println("授权方法。。。");
User user = (User) principals.getPrimaryPrincipal();
System.out.println(user);
//根据当前登录用户查询对应的权限和角色
SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
authorizationInfo.addStringPermission("staff:query");
authorizationInfo.addStringPermission("abc");
authorizationInfo.addRole("admin");
return authorizationInfo;
}
}
6. 基于shiro注解实现权限控制
第一步：在spring配置文件中开启shiro注解功能[html] view
plain copy
<!-- 开启shiro注解自动代理 -->
<bean id="defaultAdvisorAutoProxyCreator"
class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator">
<!-- 指定强制使用cglib为Action创建代理对象 -->
<property name="proxyTargetClass" value="true"/>
</bean>
<!-- 切面 -->
<bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor"></bean>
第二步：在Action方法上使用注解进行权限控制
[java] view
plain copy
/**
* 分页查询方法
* @throws IOException
*/
@RequiresPermissions(value="region.query")//执行这个方法需要region.query权限
//@RequiresRoles(value="admin")
public String pageQuery() throws IOException{
regionService.pageQuery(pageBean);
this.writePageBean2Json(pageBean, new String[]{"currentPage","pageSize","detachedCriteria","subareas"});
return NONE;
}
控制精度：
注解方式控制权限只能是在方法上控制，无法控制类级别访问。
过滤器方式控制是根据访问的URL进行控制。允许使用*匹配URL，所以可以进行粗粒度，也可以进行细粒度控制。
其他注解
@RequiresAuthentication
验证用户是否登录，等同于方法subject.isAuthenticated() 结果为true时。
@ RequiresUser
验证用户是否被记忆，user有两种含义：
一种是成功登录的（subject.isAuthenticated() 结果为true）；
另外一种是被记忆的（ subject.isRemembered()结果为true）。
@ RequiresGuest
验证是否是一个guest的请求，与@ RequiresUser完全相反。
换言之，RequiresUser == ! RequiresGuest 。
此时subject.getPrincipal() 结果为null.
@ RequiresRoles
例如：@RequiresRoles("aRoleName");
void someMethod();
如果subject中有aRoleName角色才可以访问方法someMethod。如果没有这个权限则会抛出异常AuthorizationException。
@RequiresPermissions
例如： @RequiresPermissions( {"file:read", "write:aFile.txt"} ) void someMethod();
要求subject中必须同时含有file:read和write:aFile.txt的权限才能执行方法someMethod()。否则抛出异常AuthorizationException。
第三步：修改BaseAction的构造方法
[java] view
plain copy
// 构造方法
@SuppressWarnings("unchecked")
public BaseAction() {
//获取父类类型(baseAction)
ParameterizedType superclass = null;
Type type = this.getClass().getGenericSuperclass();
//获取父类泛型 强制转化参数类型 需要判断 生成action是否使用代理 既父类是否是参数化类型
if(type instanceof ParameterizedType){
//没有使用代理直接强制转换
superclass = (ParameterizedType) type;
}else{
//type 不属于参数化类型 则action是cglib代理生成
//CGLib是针对目标类生产子类,需要获取父类的父类的类型再强转成参数化类型
superclass = (ParameterizedType) this.getClass().getSuperclass().getGenericSuperclass();
}
...
第四步：在自定义Realm中授权
略
内容安排:
1、权限概述（认证、授权）
2、常见的权限控制的方式（URL拦截、方法注解）
3、权限的数据模型（权限表、角色表、用户表、角色权限关系表、用户角色关系表）
4、apache shiro框架
5、将shiro应用到bos项目中（认证、授权）
1. 权限概述
系统中提供了很多功能，并不是所有的用户都可以操作这些功能，需要对功能的访问进行控制。认证：系统提供的用于识别用户身份的功能，通常是登录功能（你是谁？？？）
授权：系统提供的赋予用户可以操作系统某些功能能力（你能做什么？？？）
菜单和按钮是访问某个功能的入口，都是发起一次请求，由服务端进行相应的操作。
2. 常见的权限控制方式
2.1 URL拦截进行权限校验2.2 方法注解权限控制
3. 权限的数据模型
权限表角色表:引入角色是为了简化授权
用户表
角色权限关系表(多对多中间表)
用户角色关系表(多对多中间表)
关键字:注解后面可以使用
路径:访问action的路径
菜单:有些资源会挂到菜单上
优先级:用户菜单排序
父权限编号:权限的上下级,指向本表的主键
实体类
权限实体
[java] view
plain copy
/**
* 权限实体
*
*/
public class Function implements java.io.Serializable {
// Fields
private String id;//编号
private Function parentFunction;//当前权限对应的上一级权限
private String name;//权限名称
private String code;//关键字
private String description;//描述
private String page;//访问URL
private String generatemenu;//当前权限是否生成到菜单 1:生成 0:不生成
private Integer zindex;//排序
private Set children = new HashSet(0);//当前权限对应的多个下级权限
private Set roles = new HashSet(0);//当前权限对应的多个角色
角色实体
[java] view
plain copy
/**
* 角色实体
*
*/
public class Role implements java.io.Serializable {
// Fields
private String id;//编号
private String name;//角色名称
private String code;//关键字
private String description;//描述
private Set functions = new HashSet(0);//当前角色对应的多个权限
private Set users = new HashSet(0);//当前角色对应的多个用户
用户
[java] view
plain copy
public class User implements java.io.Serializable {
private String id;
private String username;
private String password;
private Double salary;
private Timestamp birthday;
private String gender;
private String station;
private String telephone;
private String remark;
private Set noticebills = new HashSet(0);
private Set roles = new HashSet(0);//当前用户对应的多个角色
4. apache shiro框架
提供的进行权限控制的方式：1、URL拦截进行权限控制
2、方法注解权限控制
3、页面标签权限控制
4、代码方式权限控制（了解）
shiro提供的功能：
Shiro的4大部分——身份验证，授权，会话管理和加密
• Authentication：身份验证，简称“登录”。
• Authorization：授权，给用户分配角色或者权限资源
• Session Management：用户session管理器，可以让CS程序也使用session来控制权限
• Cryptography：把JDK中复杂的密码加密方式进行封装
除了以上功能，shiro还提供很多扩展
• Web Support：主要针对web应用提供一些常用功能。
• Caching：缓存可以使应用程序运行更有效率。
• Concurrency：多线程相关功能。
• Testing：帮助我们进行测试相关功能
• "Run As"：一个允许用户假设为另一个用户身份（如果允许）的功能，有时候在管理脚本很有用。
• “Remember Me”：记住用户身份，提供类似购物车功能。
shiro框架运行流程图：
Application Code：应用程序代码，由开发人员负责
Subject：
由框架提供的,是与程序进行交互的对象，可以是人也可以是服务或者其他，通常就理解为用户。
所有Subject 实例都必须绑定到一个SecurityManager上。我们与一个 Subject
交互，运行时shiro会自动转化为与 SecurityManager交互的特定 subject的交互
SecurityManager:
安全管理器，由框架提供的，SecurityManager 是 Shiro的核心，初始化时协调各个模块运行。然而，一旦 SecurityManager协调完毕，SecurityManager 会被单独留下，且我们只需要去操作Subject即可，无需操作SecurityManager 。 但是我们得知道，当我们正与一个 Subject 进行交互时，实质上是 SecurityManager在处理 Subject 安全操作。
Realm：
安全数据桥，类似于项目中的DAO，访问安全数据的，框架提供，开发人员也可自己编写
Realms在 Shiro中作为应用程序和安全数据之间的“桥梁”或“连接器”。他获取安全数据来判断subject是否能够登录，subject拥有什么权限。他有点类似DAO。在配置realms时，需要至少一个realm。而且Shiro提供了一些常用的 Realms来连接数据源，如LDAP数据源的JndiLdapRealm，JDBC数据源的JdbcRealm，ini文件数据源的IniRealm，properties文件数据源的PropertiesRealm，等等。我们也可以插入自己的 Realm实现来代表自定义的数据源。
像其他组件一样，Realms也是由SecurityManager控制
小结
1.Subject(org.apache.shiro.subject.Subject):简称用户
2.SecurityManager(org.apache.shiro.mgt.SecurityManager)
如上所述，SecurityManager是shiro的核心，协调shiro的各个组件
3.Authenticator(org.apache.shiro.authc.Authenticator)：
登录控制
注：AuthenticationStrategy
(org.apache.shiro.authc.pam.AuthenticationStrategy)
如果存在多个realm，则接口AuthenticationStrategy会确定什么样算是登录成功（例如，如果一个Realm成功，而其他的均失败，是否登录成功？）。
4.Authorizer(org.apache.shiro.authz.Authorizer)：
决定subject能拥有什么样角色或者权限。
5.SessionManager(org.apache.shiro.session.SessionManager)：
创建和管理用户session。通过设置这个管理器，shiro可以在任何环境下使用session。
6.CacheManager(org.apahce.shiro.cache.CacheManager)：
缓存管理器，可以减少不必要的后台访问。提高应用效率，增加用户体验。
7.Cryptography(org.apache.shiro.crypto.*) :
Shiro的api大幅度简化Java api中繁琐的密码加密。
8.Realms(org.apache.shiro.realm.Realm) ：程序与安全数据的桥梁
5.将shiro应用到bos项目中
因为官方例子虽然中有更加简洁的ini配置形式，但是使用ini配置无法与spring整合第一步：导入shiro的jar包到项目中
shiro-all-1.2.2.jar
第二步：在web.xml中配置一个过滤器，是由spring提供的，用于整合shiro
注意:配置到struts2核心过滤器的前面
filter-name 与spring xml 配置的 bean id一致
org.springframework.web.filter.DelegatingFilterProxy
[html] view
plain copy
<!-- 配置spring提供的过滤器，用于整合shiro框架 ,
在项目启动过程中，当前过滤器会从spring工厂中获取一个和当前过滤器同名的bean对象-->
<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>
</filter-mapping>
第三步：在applicationContext.xml中配置bean，ID必须为shiroFilter
org.apache.shiro.spring.web.ShiroFilterFactoryBean
[html] view
plain copy
<!-- 配置shiro的过滤器对象,当前对象用于创建shiro框架需要的过滤器对象 -->
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
<!-- 注入安全管理器 -->
<property name="securityManager" ref="securityManager"/>
<!-- 注入系统的登录访问路径 -->
<property name="loginUrl" value="/login.jsp"/>
<!-- 成功页面 -->
<property name="successUrl" value="/index.jsp"/>
<!-- 权限不足提示页面 -->
<property name="unauthorizedUrl" value="/unauthorizedUrl.jsp"/>
<!-- 基于URL拦截权限控制 -->
<property name="filterChainDefinitions">
<value>
/css/** = anon
/js/** = anon
/images/** = anon
/validatecode.jsp* = anon
/login.jsp* = anon
/userAction_login.action = anon
/page_base_staff.action = perms["staff"]
/* = authc
</value>
</property>
</bean>
securityManager：这个属性是必须的。
安全管理器配置代码
[html] view
plain copy
<!-- 定义安全管理器 -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
<!-- 注入realm -->
<property name="realm" ref="bosRealm"></property>
</bean>
<!-- 自定义Realm -->
<bean id="bosRealm" class="com.itheima.bos.shiro.BOSRealm"></bean>
loginUrl ：没有登录的用户请求需要登录的页面时自动跳转到登录页面，不是必须的属性，不输入地址的话会自动寻找项目web项目的根目录下的”/login.jsp”页面。
successUrl ：登录成功默认跳转页面，不配置则跳转至”/”。如果登陆前点击的一个需要登录的页面，则在登录自动跳转到那个需要登录的页面。不跳转到此。
unauthorizedUrl ：没有权限默认跳转的页面。
过滤器
anon:
例子/admins/**=anon没有参数，表示可以匿名使用。
authc:
例如/admins/user/**=authc表示需要认证(登录)才能使用，没有参数
roles：
例子/admins/user/**=roles[admin],参数可以写多个，多个时必须加上引号，并且参数之间用逗号分割，当有多个参数时，例如admins/user/**=roles["admin,guest"],每个参数通过才算通过，相当于hasAllRoles()方法。
perms：
例子/admins/user/**=perms[user:add:*],参数可以写多个，多个时必须加上引号，并且参数之间用逗号分割，例如/admins/user/**=perms["user:add:*,user:modify:*"]，当有多个参数时必须每个参数都通过才通过，想当于isPermitedAll()方法。
Rest：
例子/admins/user/**=rest[user],根据请求的方法，相当于/admins/user/**=perms[user:method],其中method为post，get，delete等。
port：
例子/admins/user/**=port[8081],当请求的url的端口不是8081是跳转到schemal://serverName:8081?queryString,其中schmal是协议http或https等，serverName是你访问的host,8081是url配置里port的端口，queryString
是你访问的url里的？后面的参数。
authcBasic：
例如/admins/user/**=authcBasic没有参数表示httpBasic认证
ssl:
例子/admins/user/**=ssl没有参数，表示安全的url请求，协议为https
user:
例如/admins/user/**=user没有参数表示必须存在用户，当登入操作时不做检查
注：
anon，authcBasic，auchc，user是认证过滤器，
perms，roles，ssl，rest，port是授权过滤器
第四步：修改UserAction中的login方法，使用shiro提供的方式进行认证
过程:
1.通过subjec对象的login方法进行认证
2.Subject会调用securityManager安全管理器,安全管理器会调用Realm
3.securityManager安全管理器不是通过返回参数的方式而是通过抛异常来做出判定结果
用户名不存在异常：
org.apache.shiro.authc.UnknownAccountException
密码错误异常：
org.apache.shiro.authc.IncorrectCredentialsException
代码
[java] view
plain copy
//提供属性接收验证码
private String checkcode;
public void setCheckcode(String checkcode) {
this.checkcode = checkcode;
}
/**
* 使用shiro方式进行认证
*/
public String login(){
//从session中获取自动生成的验证码
String key = (String) ActionContext.getContext().getSession().get("key");
if(StringUtils.isNotBlank(checkcode) && checkcode.equals(key)){
//使用shiro方式进行认证
String username = model.getUsername();
String password = model.getPassword();
password = MD5Utils.md5(password);
Subject subject = SecurityUtils.getSubject();//主体,当前状态为“未认证”状态
AuthenticationToken token = new UsernamePasswordToken(username, password);//用户名密码令牌
try{
subject.login(token);//使用subject调用SecurityManager,安全管理器调用Realm
User user = (User) subject.getPrincipal();
//登录成功,将User对象放入session
ActionContext.getContext().getSession().put("loginUser", user);
}catch (UnknownAccountException e) {//用户名不存在异常
e.printStackTrace();
return "login";
}catch (IncorrectCredentialsException e) {//密码错误异常
e.printStackTrace();
return "login";
}
return "home";
}else{
//验证码有误,添加错误信息，跳转到登录页面
this.addActionError(this.getText("checkcodeError"));
return "login";
}
}
第五步：自定义一个Realm，实现认证方法
继承抽象类 重写认证与授权方法
[java] view
plain copy
public class BOSRealm extends AuthorizingRealm {
// 注入dao
@Resource
private IUserDao userDao;
// 认证方法
protected AuthenticationInfo doGetAuthenticationInfo(
AuthenticationToken token) throws AuthenticationException {
System.out.println("认证方法。。。。");
UsernamePasswordToken pwdToken = (UsernamePasswordToken) token;
String username = pwdToken.getUsername();
// 根据用户名查询密码，由安全管理器负责比对查询出的数据库中的密码和页面输入的密码是否一致
User user = userDao.findUserByUsername(username);
if(user == null){
return null;
}
String dbPassword = user.getPassword();
//参数一：
AuthenticationInfo info = new SimpleAuthenticationInfo(user,
dbPassword, this.getClass().getSimpleName());
return info;
}
//授权方法
protected AuthorizationInfo doGetAuthorizationInfo(
PrincipalCollection principals) {
//根据当前登陆用户,查询当前用户的角色,根据角色获取相应的权限,把权限添加到授权信息对象中
//三种获得当前登陆用户的方式
User user1 = (User) principals.getPrimaryPrincipal();
User user2 = (User) SecurityUtils.getSubject().getPrincipal();
//User user3 = (User) ActionContext.getContext().getSession().get("session_user");
//由于添加权限 角色的 相应方法还没学习编码 暂用伪代码添加权限
//spring是shrio配置中filterChainDefinitions 添加了/page_base_staff.action=perms["staff"]
SimpleAuthorizationInfo info=new SimpleAuthorizationInfo();
info.addStringPermission("staff");
// info.addStringPermission("region.query");
return info;
}
第六步：在applicationContext.xml中注册Realm，并注入给安全管理器
[html] view
plain copy
<!-- 定义安全管理器 -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
<!-- 注入realm -->
<property name="realm" ref="bosRealm"></property>
</bean>
<!-- 自定义Realm -->
<bean id="bosRealm" class="com.itheima.bos.shiro.BOSRealm"></bean>
第七步：在自定义Realm中实现授权方法
*授权方法执行的时机:为当访问的路径需要权限认证的时候,才执行授权
*这样每次访问权限路径都执行一次授权方法,效率很低,需要增加缓存管理器
[java] view
plain copy
public class BosRealm extends AuthorizingRealm{
@Resource
private IUserDao userDao;
@Resource
private IRoleDao roleDao;
@Resource
private IFunctionDao functionDao;
//认证方法
protected AuthenticationInfo doGetAuthenticationInfo(
AuthenticationToken token) throws AuthenticationException {
System.out.println("认证方法。。。");
UsernamePasswordToken usernamePasswordToken = (UsernamePasswordToken) token;
String username = usernamePasswordToken.getUsername();
//1 根据用户名查询密码
User user = userDao.findUserByUserName(username);
if(user == null){
// 用户名不存在
return null;
}
//2 返回AuthenticationInfo对象
Object principal = user;//将当前查询到的用户对象放入SimpleAuthenticationInfo中，可以通过subject获得
Object credentials = user.getPassword();//密码，shiro负责比较查询到的密码和用户输入的密码是否一致
String realmName = super.getName();
AuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(principal, credentials, realmName);
return authenticationInfo;
}
//授权方法
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
System.out.println("授权...");
// 获取当前登陆用户 ，根据当前登陆用户，查询对应角色信息
Subject subject = SecurityUtils.getSubject();
User user = (User) subject.getPrincipal();
SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
if (user.getUsername().equals("admin")) {
// 如果admin ，查询所有角色和所有权限
List<Role> roles = roleDao.findAll();
for (Role role : roles) {
authorizationInfo.addRole(role.getCode());
}
List<Function> functions = functionDao.findAll();
for (Function function : functions) {
authorizationInfo.addStringPermission(function.getCode());
}
} else {
// 普通用户 ， 根据当前用户，查询具有角色，通过角色获取权限
List<Role> roles = roleDao.findRolesByUser(user);
// 添加角色
for (Role role : roles) {
authorizationInfo.addRole(role.getCode());
// 添加角色对应权限
Set<Function> functions = role.getFunctions();
for (Function function : functions) {
authorizationInfo.addStringPermission(function.getCode());
}
}
}
return authorizationInfo;
}
protected AuthorizationInfo doGetAuthorizationInfo_bak(
PrincipalCollection principals) {
System.out.println("授权方法。。。");
User user = (User) principals.getPrimaryPrincipal();
System.out.println(user);
//根据当前登录用户查询对应的权限和角色
SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
authorizationInfo.addStringPermission("staff:query");
authorizationInfo.addStringPermission("abc");
authorizationInfo.addRole("admin");
return authorizationInfo;
}
}
6. 基于shiro注解实现权限控制
第一步：在spring配置文件中开启shiro注解功能[html] view
plain copy
<!-- 开启shiro注解自动代理 -->
<bean id="defaultAdvisorAutoProxyCreator"
class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator">
<!-- 指定强制使用cglib为Action创建代理对象 -->
<property name="proxyTargetClass" value="true"/>
</bean>
<!-- 切面 -->
<bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor"></bean>
第二步：在Action方法上使用注解进行权限控制
[java] view
plain copy
/**
* 分页查询方法
* @throws IOException
*/
@RequiresPermissions(value="region.query")//执行这个方法需要region.query权限
//@RequiresRoles(value="admin")
public String pageQuery() throws IOException{
regionService.pageQuery(pageBean);
this.writePageBean2Json(pageBean, new String[]{"currentPage","pageSize","detachedCriteria","subareas"});
return NONE;
}
控制精度：
注解方式控制权限只能是在方法上控制，无法控制类级别访问。
过滤器方式控制是根据访问的URL进行控制。允许使用*匹配URL，所以可以进行粗粒度，也可以进行细粒度控制。
其他注解
@RequiresAuthentication
验证用户是否登录，等同于方法subject.isAuthenticated() 结果为true时。
@ RequiresUser
验证用户是否被记忆，user有两种含义：
一种是成功登录的（subject.isAuthenticated() 结果为true）；
另外一种是被记忆的（ subject.isRemembered()结果为true）。
@ RequiresGuest
验证是否是一个guest的请求，与@ RequiresUser完全相反。
换言之，RequiresUser == ! RequiresGuest 。
此时subject.getPrincipal() 结果为null.
@ RequiresRoles
例如：@RequiresRoles("aRoleName");
void someMethod();
如果subject中有aRoleName角色才可以访问方法someMethod。如果没有这个权限则会抛出异常AuthorizationException。
@RequiresPermissions
例如： @RequiresPermissions( {"file:read", "write:aFile.txt"} ) void someMethod();
要求subject中必须同时含有file:read和write:aFile.txt的权限才能执行方法someMethod()。否则抛出异常AuthorizationException。
第三步：修改BaseAction的构造方法
[java] view
plain copy
// 构造方法
@SuppressWarnings("unchecked")
public BaseAction() {
//获取父类类型(baseAction)
ParameterizedType superclass = null;
Type type = this.getClass().getGenericSuperclass();
//获取父类泛型 强制转化参数类型 需要判断 生成action是否使用代理 既父类是否是参数化类型
if(type instanceof ParameterizedType){
//没有使用代理直接强制转换
superclass = (ParameterizedType) type;
}else{
//type 不属于参数化类型 则action是cglib代理生成
//CGLib是针对目标类生产子类,需要获取父类的父类的类型再强转成参数化类型
superclass = (ParameterizedType) this.getClass().getSuperclass().getGenericSuperclass();
}
...
第四步：在自定义Realm中授权
略
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 在CentOS 7上利用systemctl添加自定义系统服务
- 简单的求文本占用的高度、范围 boundingRectWithSize sizeWithAttributes
- String[] 转Long[]
- 频率学派和贝叶斯学派的参数估计
- NumberOf1 Java解法
- Android:layout_weight详解
- 字符串处理------最长回文子串
- IOS中实现图片点击全屏预览
- android studio匪夷所思的问题
- Linux 下三种方式设置环境变量
- JS相关事件
- java中的函数式编程（一）
- 二手房交易 维修基金不可马虎
- 在Android M及更高版本中使用 Settings.System 抛出异常"You cannot keep your settings in the secure settings. "
- 从百度地图批量获取中国县级以上行政区划边界坐标
- Android-启动模式task-lunchmodle-intent flag 总结
- js前端实现多图图片上传预览的两个方法
- WinAPI—— CallNextHookEx调用下一个钩子
- IPSC 2016 Practice Session 题解（待续）
- Geek爱旅行 - 午安