每个系统都有权限设计，本篇主要将初始的权限设计的原理，不依赖任何框架，以直观的角度剖析web的权限设计。
权限设计的原理知识
什么是权限管理
只要有用户参与的系统一般都有权限管理，权限管理实现对用户访问系统的控制。按照安全规则或者安全策略控制用户可以访问而且只能访问自己被授权的资源。
权限管理包括用户认证和用户授权两部分。
用户认证
概念
用户认证-----用户访问系统，系统需要验证用户身份的合法性。常用的验证方法：1.用户名密码验证。2.指纹验证。3.证书验证。系统验证用户身份合法，用户才可以访问资源。
用户认证的流程
关键对象
subject ：主体，理解为用户，可能是程序，都要去访问系统的资源，系统需要对subject进行身份验证。
principal ：身份信息，通常是唯一的，一个主题可以有多个身份信息，但是只能有一个主身份信息(primary principal)。
credential ：凭证信息，可以是密码，证书，指纹等。
主体在进行身份认证时需要提供身份信息和凭证信息。
用户授权
概念
用户授权，简单理解为访问控制，在用户认证通过后，系统对用户访问资源进行控制，当用户具有资源的访问权限方可访问。
授权流程
关键对象
授权的过程可以理解为 who 对 what（which）进行how操作
who ： 主体，即subject，subject在认证通过后，系统可以进行访问控制。
what（which）： 资源（Resource），subject必须具备资源访问权限才可以访问改权限。资源包括很多方面，比如：用户列表页面，商品修改菜单等。资源分为资源类型和资源实例：
例如系统的用户信息就是资源类型，相当于java类。
系统中id为1的用户就是资源实例，相当于java对象。
how ： 权限（permission），针对资源的权限或许可，subject必须具有permission方可访问资源，如何访问/操作需要定义permission，权限比如：用户添加，修改，删除等。
权限模型
主体（账号、密码）
资源（资源名称、访问地址）
权限（权限名称、资源id）
角色（角色名称）
角色和权限的关系，用户和角色的关系。
如下图：
通常企业开发中将资源和权限合并成一张权限表，如下：
资源（资源名称，访问地址）
权限（权限名称，资源id）
合并为：
权限（权限名称，资源名称，资源访问地址）
上图是权限管理的通用模型，当然在实际开发中也可以根据自己的需要修改。
分配权限
用户需要分配相应的权限才可以访问相应的资源。权限是对资源的操作许可。
通常给用户分配资源权限需要将权限信息持久化，比如存储到关系数据库中。
把用户信息，权限管理，角色信息写入数据库中。
基于角色的访问控制
RBAC(role based access control)，基于角色的访问控制。
比如：
系统角色包括 ：部门经理、总经理。。（角色针对用户来划分）
系统代码中实现：
//如果该user是部门经理则可以访问if中的代码
if(user.hasRole('部门经理')){
//系统资源内容
//用户报表查看
}
问题：
角色针对人划分的，人作为用户在系统中属于活动内容，如果该 角色可以访问的资源出现变更，需要修改你的代码了，比如：需要变更为部门经理和总经理都可以进行用户报表查看，代码改为：
if(user.hasRole('部门经理') || user.hasRole('总经理') ){
//系统资源内容
//用户报表查看
}
基于角色的访问控制是不利于系统维护(可扩展性不强)。
基于资源的访问控制
RBAC（Resource based access control），基于资源的访问控制。
资源在系统中是不变的，比如资源有：类中的方法，页面中的按钮等。
对资源的访问需要具有permission权限，代码可以写成：
if(user.hasPermission ('用户报表查看（权限标识符）')){
//系统资源内容
//用户报表查看
}
上边的方法就可以解决用户角色变更不用修改上边权限控制的代码。
如果需要变更权限只需要在分配权限模块去操作，给部门经理或总经理增或删除权限。
建议使用基于资源的访问控制实现权限管理。
权限管理解决方案
粗粒度和细粒度权限
粗粒度权限管理，对资源类型的权限管理。资源类型比如：菜单，url连接，用户添加页面，用户信息，类方法，页面按钮。
粗粒度权限管理比如：超级管理员可以访问用户添加页面，用户信息等全部页面。
部门管理员可以访问用户信息页面，包括页面中的按钮。
细粒度权限管理，对资源实例的权限管理。资源实例就是资源类型的具体化，比如：行政部门的员工，id为1的用户的查看页面等。
细粒度权限管理就是数据级别的权限管理
细粒度权限管理比如：部门经理只可以访问本部门的员工信息，用户只可以看到自己的菜单，大区经理只能查看本辖区的销售订单。。
粗粒度和细粒度例子：
系统有一个用户列表查询页面，对用户列表查询分权限，如果粗颗粒管理，张三和李四都有用户列表查询的权限，张三和李四都可以访问用户列表查询。
进一步进行细颗粒管理，张三（行政部）和李四(开发部)只可以查询自己本部门的用户信息。张三只能查看行政部 的用户信息，李四只能查看开发部门的用户信息。
如何实现粗粒度和细粒度权限管理
如何实现粗粒度权限管理？
粗粒度权限管理比较容易将权限管理的代码抽取出来在系统架构级别统一处理。比如：通过springmvc的拦截器实现授权。
如何实现细粒度权限管理？
对细粒度权限管理在数据级别是没有共性可言，针对细粒度权限管理就是系统业务逻辑的一部分，如果在业务层去处理相对比较简单，如果将细粒度权限管理统一在系统架构级别去抽取，比较困难，即使抽取的功能可能也存在扩展不强。
建议细粒度权限管理在业务层去控制。
比如：部门经理只查询本部门员工信息，在service接口提供一个部门id的参数，controller中根据当前用户的信息得到该 用户属于哪个部门，调用service时将部门id传入service，实现该用户只查询本部门的员工。
基于url拦截的方式实现
基于url拦截的方式实现在实际开发中比较常用的一种方式。
对于web系统，通过filter过虑器实现url拦截，也可以springmvc的拦截器实现基于url的拦截。
基于权限框架的方式实现
对于粗粒度权限管理，建议使用优秀权限管理框架来实现，节省开发成功，提高开发效率。
shiro就是一个优秀权限管理框架。
基于url的权限管理
基于url的权限管理流程
搭建环境
数据库
mysql数据库中创建表：用户表、角色表、权限表(实质上是权限和资源的结合 )、用户角色表、角色权限表。
创建好的表如下：
shiro_sql_table.sql：
CREATE TABLE `sys_permission` (
`id` bigint(20) NOT NULL COMMENT '主键',
`name` varchar(128) NOT NULL COMMENT '资源名称',
`type` varchar(32) NOT NULL COMMENT '资源类型：menu,button,',
`url` varchar(128) DEFAULT NULL COMMENT '访问url地址',
`percode` varchar(128) DEFAULT NULL COMMENT '权限代码字符串',
`parentid` bigint(20) DEFAULT NULL COMMENT '父结点id',
`parentids` varchar(128) DEFAULT NULL COMMENT '父结点id列表串',
`sortstring` varchar(128) DEFAULT NULL COMMENT '排序号',
`available` char(1) DEFAULT NULL COMMENT '是否可用,1：可用，0不可用',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
/*Table structure for table `sys_role` */
CREATE TABLE `sys_role` (
`id` varchar(36) NOT NULL,
`name` varchar(128) NOT NULL,
`available` char(1) DEFAULT NULL COMMENT '是否可用,1：可用，0不可用',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
/*Table structure for table `sys_role_permission` */
CREATE TABLE `sys_role_permission` (
`id` varchar(36) NOT NULL,
`sys_role_id` varchar(32) NOT NULL COMMENT '角色id',
`sys_permission_id` varchar(32) NOT NULL COMMENT '权限id',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
/*Table structure for table `sys_user` */
CREATE TABLE `sys_user` (
`id` varchar(36) NOT NULL COMMENT '主键',
`usercode` varchar(32) NOT NULL COMMENT '账号',
`username` varchar(64) NOT NULL COMMENT '姓名',
`password` varchar(32) NOT NULL COMMENT '密码',
`salt` varchar(64) DEFAULT NULL COMMENT '盐',
`locked` char(1) DEFAULT NULL COMMENT '账号是否锁定，1：锁定，0未锁定',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
/*Table structure for table `sys_user_role` */
CREATE TABLE `sys_user_role` (
`id` varchar(36) NOT NULL,
`sys_user_id` varchar(32) NOT NULL,
`sys_role_id` varchar(32) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
shiro_sql_table_data.sql
insert into `sys_permission`(`id`,`name`,`type`,`url`,`percode`,`parentid`,`parentids`,`sortstring`,`available`) values
(1,'权限','','',NULL,0,'0/','0','1'),(11,'商品管理','menu','/item/queryItem.action',NULL,1,'0/1/','1.','1'),
(12,'商品新增','permission','/item/add.action','item:create',11,'0/1/11/','','1'),
(13,'商品修改','permission','/item/editItem.action','item:update',11,'0/1/11/','','1'),
(14,'商品删除','permission','','item:delete',11,'0/1/11/','','1'),
(15,'商品查询','permission','/item/queryItem.action','item:query',11,'0/1/15/',NULL,'1'),
(21,'用户管理','menu','/user/query.action','user:query',1,'0/1/','2.','1'),
(22,'用户新增','permission','','user:create',21,'0/1/21/','','1'),
(23,'用户修改','permission','','user:update',21,'0/1/21/','','1'),
(24,'用户删除','permission','','user:delete',21,'0/1/21/','','1');
/*Data for the table `sys_role` */
insert into `sys_role`(`id`,`name`,`available`) values
('ebc8a441-c6f9-11e4-b137-0adc305c3f28','商品管理员','1'),
('ebc9d647-c6f9-11e4-b137-0adc305c3f28','用户管理员','1');
/*Data for the table `sys_role_permission` */
insert into `sys_role_permission`(`id`,`sys_role_id`,`sys_permission_id`) values
('ebc8a441-c6f9-11e4-b137-0adc305c3f21','ebc8a441-c6f9-11e4-b137-0adc305c','12'),
('ebc8a441-c6f9-11e4-b137-0adc305c3f22','ebc8a441-c6f9-11e4-b137-0adc305c','11'),
('ebc8a441-c6f9-11e4-b137-0adc305c3f24','ebc9d647-c6f9-11e4-b137-0adc305c','21'),
('ebc8a441-c6f9-11e4-b137-0adc305c3f25','ebc8a441-c6f9-11e4-b137-0adc305c','15'),
('ebc9d647-c6f9-11e4-b137-0adc305c3f23','ebc9d647-c6f9-11e4-b137-0adc305c','22'),
('ebc9d647-c6f9-11e4-b137-0adc305c3f26','ebc8a441-c6f9-11e4-b137-0adc305c','13');
/*Data for the table `sys_user` */
insert into `sys_user`(`id`,`usercode`,`username`,`password`,`salt`,`locked`) values
('lisi','lisi','李四','bf07fd8bbc73b6f70b8319f2ebb87483','uiwueylm','0'),
('zhangsan','zhangsan','张三','cb571f7bd7a6f73ab004a70322b963d5','eteokues','0');
/*Data for the table `sys_user_role` */
insert into `sys_user_role`(`id`,`sys_user_id`,`sys_role_id`) values
('ebc8a441-c6f9-11e4-b137-0adc305c3f28','zhangsan','ebc8a441-c6f9-11e4-b137-0adc305c'),
('ebc9d647-c6f9-11e4-b137-0adc305c3f28','lisi','ebc9d647-c6f9-11e4-b137-0adc305c');
整个工程如下：
系统登陆
系统登录相当于用户身份认证，用户登录成功，要在Session中记录用户的身份信息。
操作流程：
用户进入登录页面。
输入用户名和密码进行登陆。
进行用户名和密码校验。
如果校验通过，在Session中记录用户身份信息。
用户身份信息
创建专门类用于记录用户身份信息。
/**
* 用户身份信息，存入Session 由于Tomcat正常关闭时会将Session序列化的本地硬盘上，所以实现Serializable接口
* @author xushu
*
*/
public class ActiveUser implements Serializable {
private String userid; //用户id(主键)
private String usercode; // 用户账号
private String username; // 用户姓名
....
....
}
mapper
mapper接口：根据用户账号查询用户(sys_user)信息 （使用逆向工程生成权限相关的PO类和mapper接口）
如下所示：
service（进行用户名和密码校验）
接口功能：根据用户的身份和密码进行认证，如果认证通过，返回用户身份信息。
认证过程：
根据用户身份(账号)查询数据库，如果查询不到 则抛出用户不存在
对输入的密码和数据库密码进行比对，如果一致，认证通过。
新建权限管理Service接口 添加身份认证方法
/**
* 认证授权服务接口
* @author liuxun
*
*/
public interface SysService {
//根据用户的身份和密码进行认证，如果认证通过，返回用户身份信息
public ActiveUser authenticat(String usercode,String password) throws Exception;
//根据用户账号查询用户信息
public SysUser findSysUserByUserCode(String userCode) throws Exception;
......
}
方法实现：
public class SysServiceImpl implements SysService {
@Autowired
private SysUserMapper sysUserMapper;
public ActiveUser authenticat(String usercode, String password) throws Exception {
/**
* 认证过程： 根据用户身份(账号)查询数据库，如果查询不到则用户不存在
* 对输入的密码和数据库密码进行比对，如果一致则认证通过
*/
// 根据用户账号查询数据库
SysUser sysUser = this.findSysUserByUserCode(usercode);
if (sysUser == null) {
// 抛出异常
throw new CustomException("用户账号不存在");
}
// 数据库密码（MD5加密后的密码）
String password_db = sysUser.getPassword();
// 对输入的密码和数据库密码进行比对，如果一致，认证通过
// 对页面输入的密码进行MD5加密
String password_input_md5 = new MD5().getMD5ofStr(password);
if (!password_db.equalsIgnoreCase(password_input_md5)) {
//抛出异常
throw new CustomException("用户名或密码错误");
}
//得到用户id
String userid = sysUser.getId();
//认证通过，返回用户身份信息
ActiveUser activeUser = new ActiveUser();
activeUser.setUserid(userid);
activeUser.setUsercode(usercode);
activeUser.setUsername(sysUser.getUsername());
return activeUser;
}
public SysUser findSysUserByUserCode(String userCode) throws Exception {
SysUserExample sysUserExample = new SysUserExample();
SysUserExample.Criteria criteria = sysUserExample.createCriteria();
criteria.andUsercodeEqualTo(userCode);
List<SysUser> list = sysUserMapper.selectByExample(sysUserExample);
if (list != null && list.size() > 0) {
return list.get(0);
}
return null;
}
......
}
配置Service，往类Service中使用@Autowire 需要注册Service 注册有两种方法(注解或配置文件)，在架构时没有配置扫描Service 需要在配置文件中注册Service
<!-- 认证和授权的Service -->
<bean id="sysService" class="liuxun.ssm.service.impl.SysServiceImpl"></bean>
controller(记录Session)
//用户登录提交方法
@RequestMapping("/login")
public String login(HttpSession session,String randomcode,String usercode,String password) throws Exception{
// 校验验证码，防止恶性攻击
// 从Session中获取正确的验证码
String validateCode = (String) session.getAttribute("validateCode");
//输入的验证码和Session中的验证码进行对比
if (!randomcode.equalsIgnoreCase(validateCode)) {
//抛出异常
throw new CustomException("验证码输入错误");
}
//调用Service校验用户账号和密码的正确性
ActiveUser activeUser = sysService.authenticat(usercode, password);
//如果Service校验通过，将用户身份记录到Session
session.setAttribute("activeUser", activeUser);
//重定向到商品查询页面
return "redirect:/first.action";
}
用户认证拦截器
anonymousURL.properties配置匿名URL
配置可以匿名访问的URL。这个意思是，还没有登陆就能访问的连接，一般的后台管理系统就是登陆注册链接。
编写身份认真拦截器
//用于用户认证校验、用户权限校验
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//得到请求的url
String url = request.getRequestURI();
//判断是否是公开地址
//实际开发中需要将公开地址配置在配置文件中
//从配置文件中取出可以匿名访问的URL
List<String> open_urls = ResourcesUtil.getKeyList("anonymousURL");
for (String open_url : open_urls) {
if (url.indexOf(open_url)>=0) {
//如果是公开地址 则放行
return true;
}
}
//判断用户身份在Session中是否存在
HttpSession session = request.getSession();
ActiveUser activeUser = (ActiveUser) session.getAttribute("activeUser");
//如果用户身份在session中存在则放行
if (activeUser!=null) {
return true;
}
//执行到这里拦截，跳转到登录页面，用户进行身份认证
request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request, response);
//如果返回false表示拦截器不继续执行handler，如果返回true表示放行
return false;
}
配置认证拦截器
<!-- 拦截器 -->
<mvc:interceptors>
<mvc:interceptor>
<!-- 用户认证拦截 -->
<mvc:mapping path="/**"/>
<bean class="xushu.ssm.controller.interceptor.LoginInterceptor"></bean>
</mvc:interceptor>
</mvc:interceptors>
用户授权
commonURL.properties配置公用访问地址
在此配置文件中配置公用访问地址，公用访问地址只需要通过用户认证，不需要对公用访问地址分配权限即可访问。这个意思是，只要登陆进去了，不管什么用户都可以进行访问的链接
获取用户权限范围的菜单
思路：
在用户认证时，认证通过，根据用户id从数据库获取用户权限范围内的菜单，将菜单的集合存储在Session中。
编辑存储用户身份信息的类ActiveUser 如下所示：
public class ActiveUser implements Serializable {
private String userid; //用户id(主键)
private String usercode; // 用户账号
private String username; // 用户姓名
private List<SysPermission> menus; //菜单
//......setter和getter方法
}
自定义权限Mapper
因为使用逆向工程生成的Mapper是不建议去修改的 因为它的代码联系非常紧密，一旦修改错误 就会牵一发而动全身。所以需要自定义一个权限的Mapper(SysPermissionMapperCustom)
在SysPermissionMapperCustom.xml中添加根据用户id查询用户权限的菜单
<!-- 根据用户id查询菜单 -->
<select id="findMenuListByUserId" parameterType="string" resultType="liuxun.ssm.po.SysPermission">
SELECT
*
FROM
sys_permission
WHERE TYPE = 'menu'
AND id IN
(SELECT
sys_permission_id
FROM
sys_role_permission
WHERE sys_role_id IN
(SELECT
sys_role_id
FROM
sys_user_role
WHERE sys_user_id = #{userid}))
</select>
在SysPermissionMapperCustom.java接口中添加对应的方法
public interface SysPermissionMapperCustom {
//根据用户id查询菜单
public List<SysPermission> findMenuListByUserId(String userid) throws Exception;
.......
}
在权限Service接口中添加对应的方法 在实现中注入SysPermissionMapperCustom
SysServiceImpl.java中添加如下内容
@Override
public List<SysPermission> findMenuListByUserId(String userid) throws Exception {
return sysPermissionMapperCustom.findMenuListByUserId(userid);
}
获取用户权限范围的URL
思路：
在用户认证时，认证通过后，根据用户id从数据库中获取用户权限范围的URL，将URL的集合存储在Session中。
修改ActiveUser 添加URL的权限集合
public class ActiveUser implements Serializable {
private String userid; //用户id(主键)
private String usercode; // 用户账号
private String username; // 用户姓名
private List<SysPermission> menus; //菜单
private List<SysPermission> permissions; //权限
//...setter和getter方法
}
在SysPermissionMapperCustom.xml中添加根据用户id查询用户权限的URL
<!-- 根据用户id查询URL -->
<select id="findPermissionListByUserId" parameterType="string" resultType="liuxun.ssm.po.SysPermission">
SELECT
*
FROM
sys_permission
WHERE TYPE = 'permission'
AND id IN
(SELECT
sys_permission_id
FROM
sys_role_permission
WHERE sys_role_id IN
(SELECT
sys_role_id
FROM
sys_user_role
WHERE sys_user_id = #{userid}))
</select>
在SysPermissionMapperCustom.java接口中添加对应的方法
//根据用户id查询权限URL
public List<SysPermission> findPermissionListByUserId(String userid) throws Exception;
SysServiceImpl.java中添加如下内容
@Override
public List<SysPermission> findPermissionListByUserId(String userid) throws Exception {
return sysPermissionMapperCustom.findPermissionListByUserId(userid);
}
用户认证通过后取出菜单和URL放入Session
修改权限SysServiceImpl中用户认证方法的代码
//得到用户id
String userid = sysUser.getId();
//根据用户id查询菜单
List<SysPermission> menus = this.findMenuListByUserId(userid);
//根据用户id查询权限url
List<SysPermission> permissions = this.findPermissionListByUserId(userid);
//认证通过，返回用户身份信息
ActiveUser activeUser = new ActiveUser();
activeUser.setUserid(userid);
activeUser.setUsercode(usercode);
activeUser.setUsername(sysUser.getUsername());
//放入权限范围的菜单和url
activeUser.setMenus(menus);
activeUser.setPermissions(permissions);
菜单动态显示
<c:if test="${activeUser.menus!=null }">
<ul>
<c:forEach items="${activeUser.menus }" var="menu">
<li><div>
<a title="${menu.name }" ref="1_1" href="#"
rel="${baseurl }/${menu.url }" icon="icon-log"><span
class="icon icon-log"> </span><span class="nav"><a href=javascript:addTab('${menu.name }','${baseurl }/${menu.url }')>${menu.name }</a></span></a>
</div></li>
</c:forEach>
</ul>
</c:if>
授权拦截器
public class PermissionInterceptor implements HandlerInterceptor{
//在执行handler之前执行的
//用于用户认证校验、用户权限校验
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//得到请求的url
String url = request.getRequestURI();
//判断是否是公开地址
//实际开发中需要将公开地址配置在配置文件中
//从配置文件中取出可以匿名访问的URL
List<String> open_urls = ResourcesUtil.getKeyList("anonymousURL");
for (String open_url : open_urls) {
if (url.indexOf(open_url)>=0) {
//如果是公开地址 则放行
return true;
}
}
//从配置文件中获取公用访问url
List<String> common_urls = ResourcesUtil.getKeyList("commonURL");
//遍历公用地址 如果是公开地址则放行
for (String common_url : common_urls) {
if (url.indexOf(common_url)>0) {
//如果是公开，则放行
return true;
}
}
//判断用户身份在Session中是否存在
HttpSession session = request.getSession();
ActiveUser activeUser = (ActiveUser) session.getAttribute("activeUser");
//从Session中取出权限范围的URL
List<SysPermission> permissions = activeUser.getPermissions();
for (SysPermission sysPermission : permissions) {
//权限url
String permission_url = sysPermission.getUrl();
if (url.indexOf(permission_url)>0) {
return true;
}
}
//执行到这里拦截，跳转到无权访问的提示页面
request.getRequestDispatcher("/WEB-INF/jsp/refuse.jsp").forward(request, response);
//如果返回false表示拦截器不继续执行handler，如果返回true表示放行
return false;
}
......
}
配置授权拦截器
注意：要将授权拦截器配置在用户认证拦截器的下边，这是因为SpringMVC拦截器的放行方法是顺序执行的，如果是Struts的话则正好相反。
<!-- 拦截器 -->
<mvc:interceptors>
<mvc:interceptor>
<!-- 用户认证拦截 -->
<mvc:mapping path="/**"/>
<bean class="liuxun.ssm.controller.interceptor.LoginInterceptor"></bean>
</mvc:interceptor>
<mvc:interceptor>
<!-- 资源拦截 -->
<mvc:mapping path="/**"/>
<bean class="liuxun.ssm.controller.interceptor.PermissionInterceptor"></bean>
</mvc:interceptor>
</mvc:interceptors>
关键代码如下
PO类ActiveUser.java 存放用户身份和权限信息的类
package liuxun.ssm.po;
import java.io.Serializable;
import java.util.List;
/**
* 用户身份信息，存入Session 由于Tomcat正常关闭时会将Session序列化的本地硬盘上，所以实现Serializable接口
* @author liuxun
*
*/
public class ActiveUser implements Serializable {
private static final long serialVersionUID = 1L;
private String userid; //用户id(主键)
private String usercode; // 用户账号
private String username; // 用户姓名
private List<SysPermission> menus; //菜单
private List<SysPermission> permissions; //权限
// 提供对应setter和getter方法
......
}
自定义权限的Mapper
SysPermissionMapperCustom.java
package liuxun.ssm.mapper;
import java.util.List;
import liuxun.ssm.po.SysPermission;
import liuxun.ssm.po.SysPermissionExample;
import org.apache.ibatis.annotations.Param;
/**
* 权限mapper
* @author liuxun
*
*/
public interface SysPermissionMapperCustom {
//根据用户id查询菜单
public List<SysPermission> findMenuListByUserId(String userid) throws Exception;
//根据用户id查询权限URL
public List<SysPermission> findPermissionListByUserId(String userid) throws Exception;
}
SysPermissionMapperCustom.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="liuxun.ssm.mapper.SysPermissionMapperCustom">
<!-- 根据用户id查询菜单 -->
<select id="findMenuListByUserId" parameterType="string" resultType="liuxun.ssm.po.SysPermission">
SELECT
*
FROM
sys_permission
WHERE TYPE = 'menu'
AND id IN
(SELECT
sys_permission_id
FROM
sys_role_permission
WHERE sys_role_id IN
(SELECT
sys_role_id
FROM
sys_user_role
WHERE sys_user_id = #{userid}))
</select>
<!-- 根据用户id查询URL -->
<select id="findPermissionListByUserId" parameterType="string" resultType="liuxun.ssm.po.SysPermission">
SELECT
*
FROM
sys_permission
WHERE TYPE = 'permission'
AND id IN
(SELECT
sys_permission_id
FROM
sys_role_permission
WHERE sys_role_id IN
(SELECT
sys_role_id
FROM
sys_user_role
WHERE sys_user_id = #{userid}))
</select>
</mapper>
自定义权限的Service接口以及实现类
SysService.java
package liuxun.ssm.service;
import java.util.List;
import liuxun.ssm.po.ActiveUser;
import liuxun.ssm.po.SysPermission;
import liuxun.ssm.po.SysUser;
/**
* 认证授权服务接口
* @author liuxun
*
*/
public interface SysService {
//根据用户的身份和密码进行认证，如果认证通过，返回用户身份信息
public ActiveUser authenticat(String usercode,String password) throws Exception;
//根据用户账号查询用户信息
public SysUser findSysUserByUserCode(String userCode) throws Exception;
//根据用户id查询权限范围内的菜单
public List<SysPermission> findMenuListByUserId(String userid) throws Exception;
//根据用户id查询权限范围内的url
public List<SysPermission> findPermissionListByUserId(String userid) throws Exception;
}
SysServiceImpl.java
package liuxun.ssm.service.impl;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import liuxun.ssm.exception.CustomException;
import liuxun.ssm.mapper.SysPermissionMapperCustom;
import liuxun.ssm.mapper.SysUserMapper;
import liuxun.ssm.po.ActiveUser;
import liuxun.ssm.po.SysPermission;
import liuxun.ssm.po.SysUser;
import liuxun.ssm.po.SysUserExample;
import liuxun.ssm.service.SysService;
import liuxun.ssm.util.MD5;
public class SysServiceImpl implements SysService {
@Autowired
private SysUserMapper sysUserMapper;
@Autowired
private SysPermissionMapperCustom sysPermissionMapperCustom;
public ActiveUser authenticat(String usercode, String password) throws Exception {
/**
* 认证过程： 根据用户身份(账号)查询数据库，如果查询不到则用户不存在
* 对输入的密码和数据库密码进行比对，如果一致则认证通过
*/
// 根据用户账号查询数据库
SysUser sysUser = this.findSysUserByUserCode(usercode);
if (sysUser == null) {
// 抛出异常
throw new CustomException("用户账号不存在");
}
// 数据库密码（MD5加密后的密码）
String password_db = sysUser.getPassword();
// 对输入的密码和数据库密码进行比对，如果一致，认证通过
// 对页面输入的密码进行MD5加密
String password_input_md5 = new MD5().getMD5ofStr(password);
if (!password_db.equalsIgnoreCase(password_input_md5)) {
//抛出异常
throw new CustomException("用户名或密码错误");
}
//得到用户id
String userid = sysUser.getId();
//根据用户id查询菜单
List<SysPermission> menus = this.findMenuListByUserId(userid);
//根据用户id查询权限url
List<SysPermission> permissions = this.findPermissionListByUserId(userid);
//认证通过，返回用户身份信息
ActiveUser activeUser = new ActiveUser();
activeUser.setUserid(userid);
activeUser.setUsercode(usercode);
activeUser.setUsername(sysUser.getUsername());
//放入权限范围的菜单和url
activeUser.setMenus(menus);
activeUser.setPermissions(permissions);
return activeUser;
}
public SysUser findSysUserByUserCode(String userCode) throws Exception {
SysUserExample sysUserExample = new SysUserExample();
SysUserExample.Criteria criteria = sysUserExample.createCriteria();
criteria.andUsercodeEqualTo(userCode);
List<SysUser> list = sysUserMapper.selectByExample(sysUserExample);
if (list != null && list.size() > 0) {
return list.get(0);
}
return null;
}
@Override
public List<SysPermission> findMenuListByUserId(String userid) throws Exception {
return sysPermissionMapperCustom.findMenuListByUserId(userid);
}
@Override
public List<SysPermission> findPermissionListByUserId(String userid) throws Exception {
return sysPermissionMapperCustom.findPermissionListByUserId(userid);
}
}
登录控制器
package liuxun.ssm.controller;
import javax.servlet.http.HttpSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import liuxun.ssm.exception.CustomException;
import liuxun.ssm.po.ActiveUser;
import liuxun.ssm.service.SysService;
/**
* 登录和退出
* @author liuxun
*
*/
@Controller
public class LoginController {
@Autowired
private SysService sysService;
//用户登录提交方法
@RequestMapping("/login")
public String login(HttpSession session,String randomcode,String usercode,String password) throws Exception{
// 校验验证码，防止恶性攻击
// 从Session中获取正确的验证码
String validateCode = (String) session.getAttribute("validateCode");
//输入的验证码和Session中的验证码进行对比
if (!randomcode.equalsIgnoreCase(validateCode)) {
//抛出异常
throw new CustomException("验证码输入错误");
}
//调用Service校验用户账号和密码的正确性
ActiveUser activeUser = sysService.authenticat(usercode, password);
//如果Service校验通过，将用户身份记录到Session
session.setAttribute("activeUser", activeUser);
//重定向到商品查询页面
return "redirect:/first.action";
}
//用户退出
@RequestMapping("/logout")
public String logout(HttpSession session) throws Exception{
//session失效
session.invalidate();
//重定向到商品查询页面
return "redirect:/first.action";
}
}
身份认证拦截器LoginInterceptor.java
package liuxun.ssm.controller.interceptor;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import liuxun.ssm.po.ActiveUser;
import liuxun.ssm.util.ResourcesUtil;
/**
* 测试拦截器1
* @author liuxun
*
*/
public class LoginInterceptor implements HandlerInterceptor{
//在执行handler之前执行的
//用于用户认证校验、用户权限校验
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//得到请求的url
String url = request.getRequestURI();
//判断是否是公开地址
//实际开发中需要将公开地址配置在配置文件中
//从配置文件中取出可以匿名访问的URL
List<String> open_urls = ResourcesUtil.getKeyList("anonymousURL");
for (String open_url : open_urls) {
if (url.indexOf(open_url)>=0) {
//如果是公开地址 则放行
return true;
}
}
//判断用户身份在Session中是否存在
HttpSession session = request.getSession();
ActiveUser activeUser = (ActiveUser) session.getAttribute("activeUser");
//如果用户身份在session中存在则放行
if (activeUser!=null) {
return true;
}
//执行到这里拦截，跳转到登录页面，用户进行身份认证
request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request, response);
//如果返回false表示拦截器不继续执行handler，如果返回true表示放行
return false;
}
//在执行handler返回modelAndView之前执行
//如果需要向页面提供一些公用的数据或配置一些视图信息，使用此方法实现 从modelAndView入手
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
throws Exception {
System.out.println("HandlerInterceptor2...postHandle");
}
//执行handler之后执行此方法
//作为系统统一异常处理，进行方法执行性能监控，在preHandler中设置一个时间点 在afterCompletion设置一个时间点 二者时间差就是执行时长
//实现系统，统一日志记录
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception modelAndView)
throws Exception {
System.out.println("HandlerInterceptor2...afterCompletion");
}
}
资源授权拦截器PermissionInterceptor
package liuxun.ssm.controller.interceptor;
import java.security.acl.Permission;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import liuxun.ssm.po.ActiveUser;
import liuxun.ssm.po.SysPermission;
import liuxun.ssm.util.ResourcesUtil;
/**
* 授权拦截器
* @author liuxun
*
*/
public class PermissionInterceptor implements HandlerInterceptor{
//在执行handler之前执行的
//用于用户认证校验、用户权限校验
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//得到请求的url
String url = request.getRequestURI();
//判断是否是公开地址
//实际开发中需要将公开地址配置在配置文件中
//从配置文件中取出可以匿名访问的URL
List<String> open_urls = ResourcesUtil.getKeyList("anonymousURL");
for (String open_url : open_urls) {
if (url.indexOf(open_url)>=0) {
//如果是公开地址 则放行
return true;
}
}
//从配置文件中获取公用访问url
List<String> common_urls = ResourcesUtil.getKeyList("commonURL");
//遍历公用地址 如果是公开地址则放行
for (String common_url : common_urls) {
if (url.indexOf(common_url)>0) {
//如果是公开，则放行
return true;
}
}
//判断用户身份在Session中是否存在
HttpSession session = request.getSession();
ActiveUser activeUser = (ActiveUser) session.getAttribute("activeUser");
//从Session中取出权限范围的URL
List<SysPermission> permissions = activeUser.getPermissions();
for (SysPermission sysPermission : permissions) {
//权限url
String permission_url = sysPermission.getUrl();
if (url.indexOf(permission_url)>0) {
return true;
}
}
//执行到这里拦截，跳转到无权访问的提示页面
request.getRequestDispatcher("/WEB-INF/jsp/refuse.jsp").forward(request, response);
//如果返回false表示拦截器不继续执行handler，如果返回true表示放行
return false;
}
//在执行handler返回modelAndView之前执行
//如果需要向页面提供一些公用的数据或配置一些视图信息，使用此方法实现 从modelAndView入手
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
throws Exception {
System.out.println("HandlerInterceptor2...postHandle");
}
//执行handler之后执行此方法
//作为系统统一异常处理，进行方法执行性能监控，在preHandler中设置一个时间点 在afterCompletion设置一个时间点 二者时间差就是执行时长
//实现系统，统一日志记录
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception modelAndView)
throws Exception {
System.out.println("HandlerInterceptor2...afterCompletion");
}
}
拦截器配置
<!-- 拦截器 -->
<mvc:interceptors>
<mvc:interceptor>
<!-- 用户认证拦截 -->
<mvc:mapping path="/**"/>
<bean class="liuxun.ssm.controller.interceptor.LoginInterceptor"></bean>
</mvc:interceptor>
<mvc:interceptor>
<!-- 资源拦截 -->
<mvc:mapping path="/**"/>
<bean class="liuxun.ssm.controller.interceptor.PermissionInterceptor"></bean>
</mvc:interceptor>
</mvc:interceptors>
总结
使用基于url拦截的权限管理方式，实现起来比较简单，不依赖框架，使用web提供filter就可以实现。
问题：
需要将所有的url全部配置起来，有些繁琐，不易维护，url(资源)和权限表示方式不规范。
