Shiro的学习

一、Shiro

为什么要用shiro：

1.项目中的密码是否可以明文存储？

2.是否任意访客，无论是否登录都可以访问任何功能?

3.项目中的各种功能操作，是否是所有用户都可以随意使用？

综上，当项目中的某些功能被使用时，需要进行安全校验，进而保证整个系统的运行秩序。

1.1 Shiro是什么

• Apache Shiro 是 Java 的一个安全（权限）框架。
  Shiro 可以轻松的完成：身份认证、授权、加密、会话管理等功能
• Shiro 可以非常容易的开发出足够好的应用，其不仅可以用在JavaSE 环境，也可以用在 JavaEE 环境。
  功能强大且易用，可以快速轻松地保护任何应用程序 ( 从最小的移动应用程序到最大的Web和企业应用程序。)
• 方便的与Web 集成和搭建缓存。
• 下载：http://shiro.apache.org/

1.2 功能简介

• 基本功能点如下图所示：

• Authentication
	身份认证/登录，验证用户是不是拥有相应的身份；
• Authorization
	授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能进行什么操作
	如：验证某个用户是否拥有某个角色。或者细粒度的验证某个用户对某个资源是否具有某个权限；
• Session Manager
	会话管理，即用户登录后就是一次会话，在没有退出之前，它的所有
    信息都在会话中；会话可以是普通 JavaSE 环境，也可以是 Web 环境的；
• Cryptography
	加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储；
• Web Support
	Web 支持，可以非常容易的集成到Web 环境；
• Caching
	缓存，比如用户登录后，其用户信息、拥有的角色/权限不必每次去查，这样可以提高效率；
• Remember Me
	记住我，这个是非常常见的功能，即一次登录后，下次再来的话可以立即知道你是哪个用户
。。。。

二、Shiro 架构

2.1 工作流程

shiro 运行流程中，3个核心的组件:

Subject、SecutiryManager、Realm

shiro使用中，必须有的3个概念！！

• Subject
	安全校验中，最常见的问题是"当前用户是谁?" "当前用户是否有权做x事?",所以考虑安全校验过程最自
    然的方式就是基于当前用户。Subject 代表了当前“用户”，
    应用代码直接交互的对象是 Subject，只要得到Subject对象马上可以做绝大多数的shiro操作。
    也就是说 Shiro 的对外API 核心就是 Subject。
    Subject 会将所有交互都会委托给 SecurityManager。
    ==Subject是安全管理中直接操作的对象==

• SecurityManager
	安全管理器；即所有与安全有关的操作都会与SecurityManager 交互；
	且其管理着所有 Subject；它是 Shiro的核心，
	它负责与 Shiro 的其他组件进行交互，它相当于 SpringMVC 中DispatcherServlet 的角色

• Realm
	Shiro 从 Realm 获取安全数据（如用户、角色、权限），就是说SecurityManager 要验证用户身份，那么 
	它需要从 Realm 获取相应的用户进行比较以确定用户身份是否合法；
	也需要从 Realm 得到用户相应的角色/权限进行验证用户是否能进行操作；
	可以把 Realm 看成 DAO，( 数据访问入口 )

2.2 RBAC模型

Role Base Access Controll 基于角色的访问控制

shiro采用的安全管理模型

模型中3个主体：用户、角色、权限

每个角色可以有多个权限，每个权限可以分配给多个角色

每个用户可以有多个角色，每个角色可以分配给多个用户

两个多对多

则权限访问控制，做的事是：

身份校验：判断是否为合法用户

权限校验：用户要做做某件事或使用某些资源，必须要拥有某角色，或必须拥有某权限

2.3 架构(了解)

简单了解，在对shiro有了完整的应用体验后可以重点了解！

• Subject
	任何可以与应用交互的“用户”；
• SecurityManager 
	相当于SpringMVC 中的 DispatcherServlet；是 Shiro 的心脏；
	所有具体的交互都通过 SecurityManager 进行控制；它管理着所有 Subject、且负责进行认证、授权、会话及
	缓存的管理。
• Authenticator
	负责 Subject 身份认证，是一个扩展点，可以自定义实现；可以使用认证
	策略（Authentication Strategy），即什么情况下算用户认证通过了；
• Authorizer
	授权器、即访问控制器，用来决定主体是否有权限进行相应的操作；即控制着用户能访问应用中的哪些功能；
• Realm
	可以有 1 个或多个 Realm，可以认为是安全实体数据源，即用于获取安全实体
	的；可以是JDBC 实现，也可以是内存实现等等；由用户提供；所以一般在应用中都需要
	实现自己的 Realm；
• SessionManager
	管理 Session 生命周期的组件；而 Shiro 并不仅仅可以用在 Web环境，也可以用在如普通的 JavaSE 环境
• CacheManager
	缓存控制器，来管理如用户、角色、权限等的缓存的；因为这些数据基本上很少改变，
	放到缓存中后可以提高访问的性能
• Cryptography
	密码模块，Shiro 提供了一些常见的加密组件用于如密码加密/解密。

三、HelloWorld

3.1 pom 文件

<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-core</artifactId>
    <version>1.4.0</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.12</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.12</version>
</dependency>
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.16</version>
</dependency>
<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.2</version>
</dependency>

ops : require JDK 1.6+ and Maven 3.0.3+

3.2 配置

创建一个shiro.ini文件

#定义用户信息
#格式：用户名=密码,角色1,角色2,....
[users]
zhangsan=123,admin
lisi=456,manager,seller
wangwu=789,clerk
# -----------------------------------------------------------------------------
# 角色及其权限信息
# 预定权限：user:query
#          user:detail:query
#          user:update
#          user:delete
#          user:insert
#          order:update
#          ....
[roles]
# admin 拥有所有权限,用*表示
admin=*
# clerk 只有查询权限
clerk=user:query,user:detail:query
# manager 有 user 的所有权限
manager=user:*

3.3 代码

通过在ini中设置的身份信息、角色、权限，做安全管理

1.身份认证: subject.login(token)

2.是否认证身份判断：subject.isAuthenticated()

3.角色校验：subject.hasRole(String:role); subject.hasRoles(List:roles)

4.权限校验：subject.isPermitted(String:perm); subject.isPermittedAll(List:perms)

// 定义main函数测试效果
// 创建 "SecurityFactory",加载ini配置,并通过它创建SecurityManager 
Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro.ini");
SecurityManager securityManager = factory.getInstance();

// 将SecurityManager托管到SecurityUtils工具类中(ops:之后可以不必关心SecurityManager)
SecurityUtils.setSecurityManager(securityManager);

// 获得Subject，通过subject可以执行shiro的相关功能操作(身份认证或权限校验等)
Subject currentUser = SecurityUtils.getSubject();

// 身份认证( 类似登录逻辑 )
if (!currentUser.isAuthenticated()) {//判断是否已经登录
    //如果未登录，则封装一个token，其中包含 用户名和密码
    UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123");
    try {
        //将token传入login方法，进行身份认证 (判断用户名和密码是否正确)
        currentUser.login(token);//如果失败则会抛出异常
    } catch (UnknownAccountException uae) {//用户不存在
        System.out.println("There is no user with username of " + token.getPrincipal());
    } catch (IncorrectCredentialsException ice) {//密码错误
        System.out.println("Password for account " + token.getPrincipal() + " was incorrect!");
    } catch (LockedAccountException lae) {//账户冻结
        System.out.println("The account for username " + token.getPrincipal() + " is locked.  " 
                           +"Please contact your administrator to unlock it.");
    }catch (AuthenticationException ae) {//其他认证异常
        
    }
}

// 认证成功则用户信息会存入 currentUser（Subject）
System.out.println("User [" + currentUser.getPrincipal() + "] logged in successfully.");

// 可以进一步进行角色校验 和 权限校验
if (currentUser.hasRole("admin")) { //校验角色
    System.out.println("hello,boss");
} else {
    System.out.println("Hello, you");
}
if (currentUser.isPermitted("user:update")) { //校验权限
    System.out.println("you can update user");
} else {
    System.out.println("Sorry, you can not update.");
}

// 用户退出，会清除用户状态
currentUser.logout();

// System.exit(0);

3.4 权限规则

最常用的权限标识：【资源：操作】

1> user:query , user:insert , order:delete , menu:show
  	【:】 作为分隔符，分隔资源和操作【资源:操作】
  	【,】 作为分隔，分隔多个权限【权限1,权限2,权限3】
2> user:* , *:query
  	【*】 作为通配符，代表所有操作、资源
  	【user:* 即user的所有操作】
  	【*:query 即所有资源的查询操作】
3> *
  	【代表一切资源的一切权限 = 最高权限】
4> 细节：
	1)【user:*  可以匹配 user:xx, user:xx:xxx】
  	  【*:query 只可以匹配 xx:query,不能匹配 xx:xx:query. 除非 *:*:query】
  	2)【user:update,user:insert】 可以简写为 【"user:update,insert"】
       [roles]
       manager1=user:query,user:update,user:insert
       manager2="user:query,update,insert" #注意要加引号
       #如上manager1和manager2权限等价
       #subject.isPermittedAll("user:update","user:insert","user:query")

实例级权限标识：【资源：操作：实例】，粒度细化到具体某个资源实例

1> user:update:1 , user:delete:1
   # 对用户1可以update,对用户1可以delete
2> "user:update,delete:1" #和上面等价
   # subject.isPermittedAll("user:update,delete:1","user:update:1","user:delete:1")
3> user:*:1 , user:update:* , user:*:*

四、自定义Realm

存在的问题：目前所有的用户、角色、权限数据都在ini文件中，不利于管理。

实际项目开发中这些信息，应该在数据库中。所以需要为这3类信息建表

4.1 建表

用户表，角色表，权限表

create table t_user(
	id int primary key auto_increment,
    username varchar(20) not null unique,
    password varchar(100) not null
)engine=innodb default charset=utf8;

create table t_role(
	id int primary key auto_increment,
	role_name varchar(50) not null unique,
	create_time timestamp not null
)engine=innodb default charset=utf8;
  
create table t_permission(
	id int primary key auto_increment,
	permission_name varchar(50) not null unique,
	create_time timestamp
)engine=innodb default charset=utf8;
  
create table t_user_role(
	id int primary key auto_increment,
	user_id int references t_user(id),
	role_id int references t_role(id),
	unique(user_id,role_id)
)engine=innodb default charset=utf8;

create table t_role_permission(
	id int primary key auto_increment,
	permission_id int references t_user(id),
	role_id int references t_role(id),
	unique(permission_id,role_id)
)engine=innodb default charset=utf8;

4.2 自定义Realm

Realm的职责是，为shiro加载用户，角色，权限数据，以供shiro内部校验。

之前定义在ini中的数据，默认有IniRealm去加载。

现在库中的数据，需要自定义Realm去加载。

ops : 没必要在Realm中定义大量的查询数据的代码，可以为Realm定义好查询数据的DAO和Service。

4.2.1 父类

如下是Realm接口的所有子类，其中IniRealm是默认的Realm，负责加载shiro.ini中的[users]和[roles]信息,当shiro需要用户，角色，权限信息时，会通过IniRealm获得。****

自定义realm有两个父类可以选择：

1> 如果realm只负责做身份认证，则可以继承：AuthenticatingRealm

2> 如果realm要负责身份认证和权限校验，则可以继承：AuthorizingRealm

4.2.2 定义Realm

public class MyRealm extends AuthorizingRealm {
    /**
     * 是否支持某种token
     * @param token
     * @return
     */
    @Override
    public boolean supports(AuthenticationToken token) {
        System.out.println("is support in realm1");
        if(token instanceof UsernamePasswordToken){
            return true;
        }
        return false;
    }

    /**
     * 当subject.login()时，shiro会调用Realm的此方法做用户信息的查询，然后做校验
     * 职责：通过用户传递来的用户名查询用户表，获得用户信息
     * 返回值：将查到的用户信息（用户名+密码）封装在AuthenticationInfo对象中返回
     * 异常：如果没有查到用户可抛出用户不存在异常；如果用户被锁定可抛出用户被锁异常；或其它自定义异常.
     * @param token
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        //获得用户名
        String username = (String) token.getPrincipal();
        System.out.println("user:"+username+" is authenticating~~");
        UserService userService = 
            (UserService)ContextLoader.getCurrentWebApplicationContext().getBean("userService");
        //身份认证
        User user = userService.queryUser(username);
        System.out.println("user:"+user);
        /**
        如果查询结果为空，直接返回null即可，
        shiro的后续流程有null判断逻辑，为null时会抛出UnknownAccountException
        **/
        if(user == null){
            return null;
        }
        // 将 当前用户的认证信息存入 SimpleAuthenticationInfo 并返回
        // 注意此方法的本职工作就是查询用户的信息，所以查到后不用比对密码是否正确，那是shiro后续流程的职责。
        // 如果密码错误，shiro的后续流程中会抛出异常IncorrectCredentialsException
        return new SimpleAuthenticationInfo(user.getUsername(),user.getPassword(),getName());
        /** 
        补充: 可以在user表中增加一列，用于存储用户是否被锁定，则查询的User对象中会有是否锁定的属性
             如果发现锁定则可以在此方法中抛出异常：LockedAccountException，
        **/
    }

    /**
     * 当触发权限或角色校验时：subject.isPermitted() / subject.checkPermission();
     *                       subject.hasRole() / subject.checkRole() 等。
     * 此时需要数据库中的 权限和角色数据，shiro会调用Realm的此方法来查询
     * 角色和权限信息存入SimpleAuthorizationInfo对象
     * @param principals
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        //获得username
        String username  = (String)principals.getPrimaryPrincipal();
        //新建SimpleAuthorizationInfo对象
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        //查询当前用户的所有 "角色" 和 "权限"
        UserService userService = 
            (UserService)ContextLoader.getCurrentWebApplicationContext().getBean("userService");
        Set<String> roles = userService.queryRolesByUsername(username);
        Set<String> perms = userService.queryPermissionsByUsername(username);
        //“角色” 和 “权限” 存入 SimpleAuthorizationInfo对象
        info.setRoles(roles);
        info.setStringPermissions(perms);
        //返回SimpleAuthorizationInfo
        return info;
    }
}

4.3 配置Realm

shiro.ini中配置自定义Realm

注意：[users] [roles] 两个部分不再需要

[main]
#注意：此处实在安装自定义Realm 指定realm
#声明Realm 名称 = Realm类路径
realm1 = com.zhj.realm.MyRealm
realm2 = com.zhj.realm.MyRealm2
#安装Reaml 关联到SecurityManager
securityManager.realms=$realm1,$realm2

五、与Web 集成

与web项目集成后，shiro的工作模式如下：

如上：ShiroFilter拦截所有请求，对于请求做访问控制

如请求对应的功能是否需要有认证的身份，是否需要某种角色，是否需要某种权限。

1> 如果没有做身份认证，则将请求强制跳转到登录页面。

如果没有充分的角色或权限，则将请求跳转到权限不足的页面。

2> 如果校验成功，则执行请求的业务逻辑

5.1 pom

<!-- ============ Servlet ============ -->
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.1</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
</dependency>
<!-- ============== SpringMVC ============== -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>4.3.6.RELEASE</version>
</dependency>

<!-- ============ shiro ============ -->
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-core</artifactId>
    <version>1.4.0</version>
</dependency>
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-web</artifactId>
    <version>1.4.0</version>
</dependency>

<!-- ============ log ============ -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.12</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.12</version>
</dependency>
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.16</version>
</dependency>

5.2 代码：Controller

定义一些Servlet 或 springMVC的controller，发送请求，验证shiro的验证

如下代码，除了登录中要用到 Shiro的Subject，其余没改动

@Controller
@RequestMapping("/user")
public class ShiroController {
    @RequestMapping("/delete")
    public String deleteUser(){//访问此删除功能时要先经过shiro的安全校验
        System.out.println("delete User");
        return "forward:/xx.jsp";
    }
    @RequestMapping("/update")
    public String updateUser(){//访问此更新功能时要先经过shiro的安全校验
        System.out.println("update User");
        return "forward:/xx.jsp";
    }
    @RequestMapping("/insert")
    public String insertUser(){//访问此增加功能时要先经过shiro的安全校验
        System.out.println("insert User");
        return "forward:/xx.jsp";
    }
    @RequestMapping("/login/page")
    public String login(String username,String password){
    	System.out.println("goto login.jsp");
        return "forward:/login.jsp";
    }
    @RequestMapping("/login/logic")
    public String login(String username,String password){//登录功能不能被shiro校验，否则永不能登录
        try{
            Subject subject = SecurityUtils.getSubject();
            subject.login(new UsernamePasswordToken(username,password));
            String uname = (String)subject.getPrincipal();
            System.out.println("uname:"+uname);
        }catch (AuthenticationException e){
            e.printStackTrace();
            return "redirect:/login.jsp";
        }
        return "forward:/success.jsp";
    }
}

5.3 配置

5.3.1 web.xml

安装 ShiroFilter

<!-- 接收所有请求，以通过请求路径 识别是否需要 安全校验，如果需要则触发安全校验
     做访问校验时，会遍历过滤器链。(链中包含shiro.ini中urls内使用的过滤器)
     
     会通过ThreadContext在当前线程中绑定一个subject和SecurityManager，供请求内使用
     可以通过SecurityUtils.getSubject()获得Subject
-->
<filter>
    <filter-name>shiroFilter</filter-name>
    <filter-class>org.apache.shiro.web.servlet.ShiroFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>shiroFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
<!-- 在项目启动时，加载web-info 或 classpath下的 shiro.ini ，并构建WebSecurityManager。
     构建所有配置中使用的过滤器链(anon,authc等)，ShiroFilter会获取此过滤器链
-->
<listener>
    <listener-class>org.apache.shiro.web.env.EnvironmentLoaderListener</listener-class>
</listener>
<!-- 自定义ini文件名称和位置
<context-param>
    <param-name>shiroConfigLocations</param-name>
    <param-value>classpath:shiro9.ini</param-value>
</context-param>-->
<!-- springMVC的配置照旧，此处省略...-->

5.3.2 shiro.ini

新增部分(section) [urls]

如下定义shiro的Realm、访问控制细节

[main]
#没有身份认证时，跳转地址
shiro.loginUrl = /user/login/page
#角色或权限校验不通过时，跳转地址
shiro.unauthorizedUrl=/author/error
#登出后的跳转地址,回首页
shiro.redirectUrl=/
#注意：此处实在安装自定义Realm 指定realm
#声明Realm 名称 = Realm类路径
realm1 = com.zhj.realm.MyRealm
realm2 = com.zhj.realm.MyRealm2
#安装Reaml 关联到SecurityManager
securityManager.realms=$realm1,$realm2
[urls]
# 如下格式："访问路径 = 过滤器"
#【1.ant路径：？ *  ** 细节如下】
# /user/login/page , /user/login/logic 是普通路径
# /user/* 代表/user后还有一级任意路径 ： /user/a , /user/b , /user/c , /user/xxxxxxxxxxx
# /user/** 代表/user后还有任意多级任意路径: /user/a , /user/a/b/c , /user/xxxx/xxxxxx/xxxxx
# /user/hello? 代表hello后还有一个任意字符: /user/helloa , /user/hellob , /user/hellox

#【2.过滤器，细节如下】
# anon => 不需要身份认证
# authc => 指定路径的访问，会验证是否已经认证身份，如果没有则会强制转发到 最上面配置的loginUrl上
#         ( ops:登录逻辑本身千万不要被认证拦截，否则无法登录 )
# logout => 访问指定的路径，可以登出,不用定义handler。
# roles["manager","seller"] => 指定路径的访问需要subject有这两个角色
# perms["user:update","user:delete"] => 指定路径的访问需要subject有这两个权限
/user/login/page = anon
/user/login/logic = anon
/user/query = authc
/user/update = authc,roles["manager","seller"]
/user/delete = authc, perms["user:update","user:delete"]
/user/logout = logout
#其余路径都需要身份认证【用此路径需谨慎】
/** = authc
#【3.注意】
# url的匹配，是从上到下匹配，一旦找到可以匹配的则停止，所以，通配范围大的url要往后放，
# 如"/user/delete" 和 "/user/**"

5.3.3 其他默认过滤器

5.5 总结

通过ShiroFilter和定义在shiro.ini中的配置信息，即可在项目接收用户访问时，进行身份，角色，权限进行访问控制啦！！！！

现在的项目架构

六、Spring集成

web项目的核心组件都在spring工厂中管理，利用IOC和AOP，组建了关系松散，稳健的系统。

shiro的诸多组件也需要由spring统一管理，进而可以更好的和其他组件协作。

之前的Realm中一直有如下代码：

//由于Realm还未进入spring工厂，所以无法直接注入工厂内部的DAO组件
UserService userService =(UserService)ContextLoader.getCurrentWebApplicationContext().getBean("xx");

ops：shiro的组件都是pojo组件，非常容易用spring管理，可以方便的从ini迁移到spring

6.1 pom

<!-- 其他依赖和web集成中 一致 ，此处省略-->
<!-- 新增一个依赖 用于在工厂中生产 ShiroFilter-->
<!-- 会传递导入shiro-core 和 shiro-web -->
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring</artifactId>
    <version>1.4.0</version>
</dependency>

6.2 aplicationContext.xml

将SecurityManager和Realm和ShiroFilter 都迁移到applicationContext.xml中

建议将如下配置，单独定义在一个配置文件：shiro-spring.xml,然后在applicationContext.xml中引入：

<import resource="classpath:shiro-spring.xml"/>

<!-- 连接池，SqlSessionFactory，MapperScannerConfigurer,事务控制等 配置不变 -->
<!-- 添加如下shiro配置 -->
<!-- shiro -->
<!-- 声明realm -->
<bean id="realm1" class="com.zhj.realm.MyRealm">
    <property name="userService" ref="userService"/>
</bean>
<!-- 声明SecurityManager -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
    <!-- 注入Realm -->
    <property name="realm" ref="realm1"/>
</bean>
<!-- 生产SpringShiroFilter
     （ 持有shiro的过滤相关规则，可进行请求的过滤校验，校验请求是否合法 ） 
-->
<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
    <property name="securityManager" ref="securityManager"/>
    <property name="loginUrl" value="/user/login/page"/>
    <property name="unauthorizedUrl" value="/error.jsp"/>
    <property name="filterChainDefinitions">
        <value>
            /user/query=anon
            /user/insert=authc,roles["banfu"]
            /user/update=authc,perms["student:update"]
            /order/insert=authc,roles["xuewei"]
            /user/logout=logout
        </value>
    </property>
</bean>

6.3 web.xml

<!-- 会从spring工厂中获取和它同名的bean，（id="shiroFilter"）
     接到请求后调用bean的doFilter方法，进行访问控制。
-->
<filter>
    <filter-name>shiroFilter</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    <init-param>
        <param-name>targetFilterLifecycle</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>shiroFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
<!-- EnvironmentLoaderListener不再需要，因为shiro环境已由spring初始化 
     springMVC,spring配置不变 -->

七、记住我

在登录后，可以将用户名存在cookie中，下次访问时，可以先不登录，就可以识别身份。

在确实需要身份认证时，比如购买，支付或其他一些重要操作时，再要求用户登录即可，用户体验好。

由于可以保持用户信息，系统后台也可以更好的监控、记录用户行为，积累数据。

7.1 代码

”记住我“ 起点在登录时刻：Subject.login(UsernameAndPasswordToken)

而是否确定要“记住我”，由登录时的token控制开关：token.setRememberMe(true);

Subject subject = SecurityUtils.getSubject();
UsernamePasswordToken token = new UsernamePasswordToken(username, password);
//如果需要记住我的话，需要在token中设置
token.setRememberMe(true);//shiro默认支持”记住我“，只要有此设置则自动运作。
subject.login(token);

7.2 效果

登录后效果

7.3 页面中显示

在页面中显示，cookie中记录的用户信息

<shiro:user> 当有记住我信息，或已登录，则显示标签体内容

<shiro:principal> 获取用户信息

注意：首页的访问路径的过滤器不能是 authc，只能是 user 或 anon

<!-- 首页 xx.jsp -->
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="shiro" uri="http://shiro.apache.org/tags" %>
<html>
    <body>
        <h2>Hello World! </h2>
        <!-- 重点在此：通过如下shiro标签显示 -->
        <shiro:user>
            欢迎您，<shiro:principal/>  <a href="#">退出登录</a>
        </shiro:user>
    </body>
</html>

<!-- 登录页面 login.jsp 自动填充用户名 -->
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@taglib prefix="shiro" uri="http://shiro.apache.org/tags" %>
<html>
    <head>
        <title>Title</title>
    </head>
    <body>
        <form action="<c:url value="/user/login"/>" method="post">
            <!-- 重点在此：<shiro:principal/> -->
            username:<input type="text" name="username" value="<shiro:principal/>"> <br>
            password:<input type="password" name="password"><br>
            <input type="submit" value="登录">
        </form>
    </body>
</html>

7.4 自定义

如果需要做自定义，可以明确定义如下两个组件：

SimpleCookie：封装cookie的相关属性，定制cookie写出逻辑(详见：addCookieHeader())

CookieRememberMeManager：接受SecurityManager调度，获取用户信息，加密数据，并调度SimpleCookie写出cookie。

<!-- 之前的配置不变，添加如下配置 -->
<!-- remember me -->
<bean id="rememberMeCookie" class="org.apache.shiro.web.servlet.SimpleCookie">
    <!-- rememberMe是cookie值中的key，value时用户名的密文
		 cookie["rememberMe":"deleteMe"] 此cookie每次登陆后都会写出，用于清除之前的cookie
         cookie["rememberMe":username的密文] 此cookie也会在登录后写出，用于记录最新的username
		（ops: 如上设计，既能保证每次登陆后重新记录cookie，也能保证切换账号时，记录最新账号）
    -->
    <property name="name" value="rememberMe"/>
    <!-- cookie只在http请求中可用，那么通过js脚本将无法读取到cookie信息，有效防止cookie被窃取 -->
    <property name="httpOnly" value="true"/>
    <!-- cookie的生命周期，单位：秒 -->
    <property name="maxAge" value="2592000"/><!-- 30天 -->
</bean>
<bean id="rememberMeManager" class="org.apache.shiro.web.mgt.CookieRememberMeManager">
    <!-- 注入SimpleCookie -->
    <property name="cookie" ref="rememberMeCookie"/>
</bean>
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
	...
    <!-- CookieRememberMeManager注入给SecurityManager,
         SecurityManager在处理login时，如果login成功，则会通过rememberMeManager做"记住我"，
         将用户名存入cookie
	-->
    <property name="rememberMeManager" ref="rememberMeManager"/>
</bean>

八、shiro标签

shiro提供了很多标签，用于在jsp中做安全校验。

完成对页面元素的访问控制

8.1 导入shiro标签库

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="shiro" uri="http://shiro.apache.org/tags"%>
<html>
    ....
</html>

8.2 身份认证

**shiro:authenticated shiro:user shiro:guest ** **已登录已登录或记住我游客(未登录且未记住我) **

**shiro:notAuthenticated shiro:principal ** 未登录获取用户身份信息

<shiro:authenticated>
    欢迎您，<shiro:principal/>
</shiro:authenticated>

<shiro:user> <!-- 常用，包含已登录 且配合记住我，用户体验好 -->
    欢迎您,<shiro:principal/>
</shiro:user>

<shiro:guest>
    欢迎您，未登录，请<a href="<c:url value="/user/login/page"/>">登录</a>
</shiro:guest>

<shiro:notAuthenticated>
    您尚未登录(记住我也算在未登录中)
</shiro:notAuthenticated>

8.3 角色校验

<shiro:hasAnyRoles name="admin,manager"> <shiro:hasRole name="admin"> 是其中任何一种角色是指定角色

<shiro:lacksRole name="admin"> 不是指定角色

<table>
    <tr>
        <td>id</td>
        <td>name</td>
        <td>operation</td>
    </tr>
    <tr>
        <td>001</td>
        <td>张三</td>
        <td>
            <shiro:hasAnyRoles name="admin,manager">
                <a href="#" style="text-decoration:none">详情</a>
            </shiro:hasAnyRoles>
            <shiro:hasRole name="admin">
                <a href="#" style="text-decoration: none">删除</a>
            </shiro:hasRole>
            <shiro:lacksRole name="admin">
                <a href="#" style="text-decoration: none">点击升级</a>
            </shiro:lacksRole>
        </td>
    </tr>
</table>

8.4 权限校验

<shiro:hasPermission name="user:delete"> 有指定权限

<shiro:lacksPermission name="user:delete"> 缺失指定权限

...
<td>
    <a href="#" style="text-decoration:none">查看详情</a>
    <shiro:hasPermission name="user:delete">
        <a href="#" style="text-decoration: none">删除</a>
    </shiro:hasPermission>
    <shiro:lacksPermission name="user:delete">
        <a href="#" style="text-decoration: none" >无权删除</a>
    </shiro:lacksPermission>
</td>
...

8.5 自定义标签(了解)

jsp中允许自定义标签，所以可以根据需求自定义一些shiro标签。

8.5.1 定义标签类

public class MyAllRoleTag extends RoleTag {
    // jsp中使用：<xxx:xx name="角色参数1,角色参数2,..."/>
    private String name;//存储传入的角色参数
    @Override
    public String getName() {
        return name;
    }
    @Override
    public void setName(String name) {
        this.name = name;
    }

    @Override
    protected boolean showTagBody(String name) {
        System.out.println("验证角色:"+name);
        String[] roles = name.split(",");
        Subject subject = getSubject();
        for(String role:roles) {
            if(!subject.hasRole(role)){
                return false;
            }
        }
        return true;
    }
}

8.5.2 定义tld文件

要放在WEB-INF目录下，名称任意

<!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
        "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
<taglib>
    <tlib-version>1.1.2</tlib-version>
    <jsp-version>1.2</jsp-version>
    <short-name>zhj</short-name>
    <uri>http://zhj.apache.org/tags</uri>
    <description>Apache Shiro JSP Tag Library.</description>
    <tag>
        <!-- 标签名 <zhj:hasAllRoles .../> -->
        <name>hasAllRoles</name>
      	<!-- 自定义Tag类路径 -->
        <tag-class>com.zhj.tag.MyAllRoleTag</tag-class>
        <body-content>JSP</body-content>
        <description>Displays body content only if the current Subject (user)
            'has' (implies) all the specified roles
        </description>
        <!-- 自定义Tag中属性名：name
        	 <zhj:hasAllRoles name="role1,role2"/>
        -->
        <attribute>
            <name>name</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>
</taglib>

8.5.3 使用

<%@ taglib prefix="zhj" uri="http://zhj.apache.org/tags" %>
<!-- tld中定义的标签名：hasAllRoles, 向Tag类中传递参数：“seller,manager” -->
<zhj:hasAllRoles name="seller,manager">
    有所有的角色2：manager，seller
</zhj:hasAllRoles>

九、Session管理

shiro作为一款安全管理框架，对状态保持有很强的需要。

比如最常用的用户认证，就必需状态的保持，以及其他的一些功能实现的需要。

【shiro需要：认证中的 记住我中的用户名 正式登陆的用户名】【开发者需要：其他功能中需要存入session的值】

shiro提供了一整套session管理方案.

1. shiro的session方案和任何容器无关(如servlet容器)；

2. javaSE也可以使用；相关组件都是pojo对ioc极其友好(方便的管理对象和满足依赖关系，定制参数)

3. 可以方便的扩展定制存储位置(内存，缓存，数据库等)

4. 对web透明支持：用了shiro的session后，项目中关于session的代码完全不用任何改动

5. 提供了全面的session监听机制，和session检测机制，对session可以细粒度操作

即，使用了shiro后，采用shiro的session方案是最优的方案。

9.1 配置

<!-- 会话Cookie模板 默认可省-->
<bean id="sessionIdCookie" class="org.apache.shiro.web.servlet.SimpleCookie">
    <!-- cookie的 key="sid" -->
    <property name="name" value="JSESSIONID"/>
    <!-- 只允许http请求访问cookie -->
    <property name="httpOnly" value="true"/>
    <!-- cookie过期时间，-1:存活一个会话 ,单位:秒 ，默认为-1-->
    <property name="maxAge" value="-1"/>
</bean>

<bean id="sessionManager" 
      class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">
    <property name="sessionDAO" ref="sessionDAO"/>
    <!-- 默认为true，代表用cookie存储session的id -->
    <property name="sessionIdCookieEnabled" value="true"/>
    <!-- 默认值和配置中给出的一致，所bean:sessionIdCookie 可以省略 -->
    <property name="sessionIdCookie" ref="sessionIdCookie"/>
    <!-- session全局超时时间, 单位:毫秒 ，30分钟 默认值为1800000-->
    <property name="globalSessionTimeout" value="1800000"/>
</bean>

<!-- 将sessionManager关联到SecurityManager -->
<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
    ...
    <!-- 增加配置sessionManager -->
    <property name="sessionManager" ref="sessionManager"/>
</bean>

9.2 Session监听

session有三个核心过程：创建、过期、停止

过期：session的默认过期时间为30分钟。通过比对最近一次使用时间和当前使用时间判断

session不会自动报告过期，需检测器检测时，或再次访问时，才可以识别是否过期并移除。

停止：用户主动logout；主动调用session.stop(); 两种情况会将session标志为停止状态。

// 定义监听类 exentends SessionListenerAdapter
public class MySessionListener extends SessionListenerAdapter{
    //当有session创建时 触发
    @Override
    public void onStart(Session session) {
        System.out.println("session:"+session.getId()+" start");
    }
    //当有session停止时 触发
    @Override
    public void onStop(Session session) {
        System.out.println("session:"+session.getId()+" stop");
    }
    //当有session过期时 触发
    // 但不会主动触发，需要再次访问时，即又要使用session时才会发现session过期，并触发。
    @Override
    public void onExpiration(Session session) {
        System.out.println("session:"+session.getId()+" expired");
    }
}

配置监听类，关联给SessionManager

<bean id="sessionManager" class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">
    ...
    <property name="sessionListeners">
        <list>
            <bean class="com.zhj.listener.MySessionListener"></bean>
        </list>
    </property>
    ...
</bean>

9.3 Session检测

用户如果没有主动退出登录，只是关闭浏览器，则session是否过期无法获知，也就不能停止session。

为此，shiro提供了session的检测机制，可以定时发起检测，识别session过期并停止session。

<!-- sessionManager默认开启session检测机制 -->
<bean id="sessionManager" class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">
    ...
    <!-- 开启检测器，默认开启 -->
    <property name="sessionValidationSchedulerEnabled" value="true"/>
    <!--- 检测器运行间隔，单位：毫秒  默认1小时
		    //检测到过期后，会直接将session删除
		    protected void afterExpired(Session session) {
                if (isDeleteInvalidSessions()) {
                    delete(session);
                }
            }
    -->
    <property name="sessionValidationInterval" value="3600000"/>
    ...
</bean>

如上，通过检测器，定时的检测session，并及时移除无效session，释放资源。

十、加密

用户的密码是不允许明文存储的，因为一旦数据泄露，用户的隐私信息会完全暴露。

密码必须结果加密，生成密文，然后数据库中只存储用户的密码的密文。

在加密过程中需要使用到一些"不可逆加密"，如 md5,sha等

所谓不可逆是指：

加密函数A, 明文 “abc”, A("abc") = "密文"，不能通过 "密文" 反推出 "abc"，即使密文泄露密码仍然安全。

10.1 加密介绍

shiro支持hash(散列)加密，常见的如 md5, sha等

基本加密过程

md5(明文)，sha(明文) 得到明文的密文，但明文可能比较简单导致密文容易被破解。

加盐加密过程

系统生成一个随机salt="xxxxxx", md5(明文+salt) ,sha(明文+salt)，则提升了密文的复杂度。

加盐多次迭代加密过程

如果迭代次数为2，则加密2次： md5(明文+salt)=密文a ， md5(密文a+salt)=最终密文

sha(明文+salt)=密文a ， sha(密文a+salt)=最终密文

则进一步提升了密文的复杂度，和被破解的难度。

加密过程中建议使用salt，并指定迭代次数，迭代次数的建议值1000+

实例代码：

String password="abc";//密码明文
String salt=UUID.randomUUID().toString();//盐
Integer iter = 1000;//迭代次数
String pwd = new Md5Hash(password, salt,iter).toString(); //md5加密
String pwd = new Md5Hash(password, salt, iter).toBase64(); //加密后转base64

String pwd = new Sha256Hash(password, salt, iter).toString();//sha256加密
String pwd = new Sha256Hash(password, salt, iter).toBase64();//加密后转base64

String pwd = new Sha512Hash(password, salt, iter).toString();//sha256加密
String pwd = new Sha512Hash(password, salt, iter).toBase64()//加密后转base64

10.2 加密

增加用户，或修改用户密码时，涉及到密码的加密

在注册用户的业务中，对用户提交的密码加密即可。

注意：之前的用户表，并未考虑存储加密相关信息，所以此时需要对用户表做出改进,

加一列【 salt varchar(50) 】，用于存储每个用户的盐。

class UserServiceImpl implements UserService{
    @Autowired
    private UserDAO userDAO;
    public void createUser(User user){
        user.setSalt(UUID.randomUUID().toString());//设置随机盐
        //设置加密属性：sha256算法，随机盐，迭代1000次
        Sha256Hash sha256Hash = new Sha256Hash(user.getPassword(),user.getSalt(),1000);
        //将用户信息 (包括密码的密文 和 盐) 存入数据库
        user.setPassword(sha256Hash.toBase64());//密文采用base64格式化        
        userDAO.createUser(user);
    }
}

10.3 密码比对

登录认证身份时，涉及到密码比对过程

注意，加密过程中使用的加密属性，和此处使用的加密属性必须一致：

【sha256,迭代1000次，使用base64格式化密文】

10.3.1 指定比对器

<!-- 声明realm -->
<bean id="realm1" class="com.zhj.realm.MyRealm">
    <property name="userService" ref="userService"/>
    <!-- 此属性如果通过注解注入，则需要将注解加载set方法上，不能用在属性上。
 		 此属性是父类属性，所以只有在set方法上注入，才能覆盖父类属性值。
	-->
    <property name="credentialsMatcher">
        <bean class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
            <property name="hashAlgorithmName" value="SHA-256"/>
            <!-- true means hex encoded, false means base64 encoded -->
            <property name="storedCredentialsHexEncoded" value="false"/>
            <property name="hashIterations" value="1000"/>
        </bean>
    </property>
</bean>

10.3.2 修改Realm

doGetAuthenticationInfo方法的返回值中需要添加salt：

ByteSource.Util.bytes(user.getSalt())

protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
    String username = (String) token.getPrincipal();
    UserService userService = 
        (UserService)ContextLoader.getCurrentWebApplicationContext().getBean("userService");
    User user = userService.queryUser(username);
    System.out.println("user:"+user);
    if(user==null){
        System.out.println("用户不存在");
        throw new UnknownAccountException("username:"+username+"不存在");
    }
    //以上逻辑不变
    //在最后返回用户认证info时，添加一个属性：ByteSource.Util.bytes(user.getSalt()) = 盐
    //用于密码比对
    return new SimpleAuthenticationInfo(user.getUsername(),
                                        user.getPassword(), 
                                        ByteSource.Util.bytes(user.getSalt()),
                                        getName());
}

至此，可以进行注册，注册中已经会加密密码。

然后登陆认证身份，认证时realm会调用比对器比对密文。

Shiro的学习

一、Shiro

综上，当项目中的某些功能被使用时，需要进行安全校验，进而保证整个系统的运行秩序。

1.1 Shiro是什么

1.2 功能简介

二、Shiro 架构

2.1 工作流程

Subject、SecutiryManager、Realm

shiro使用中，必须有的3个概念！！

2.2 RBAC模型

Role Base Access Controll 基于角色的访问控制

shiro采用的安全管理 模型

模型中3个主体：用户、角色、权限

2.3 架构(了解)

三、HelloWorld

3.1 pom 文件

3.2 配置

3.3 代码

3.4 权限规则

四、自定义Realm

4.1 建表

4.2 自定义Realm

4.2.1 父类

4.2.2 定义Realm

4.3 配置Realm

五、与Web 集成

5.1 pom

5.2 代码：Controller

5.3 配置

5.3.1 web.xml

5.3.2 shiro.ini

5.3.3 其他默认过滤器

5.5 总结

六、Spring集成

6.1 pom

6.2 aplicationContext.xml

6.3 web.xml

七、记住我

7.1 代码

7.2 效果

7.3 页面中显示

7.4 自定义

八、shiro标签

8.1 导入shiro标签库

8.2 身份认证

8.3 角色校验

8.4 权限校验

8.5 自定义标签(了解)

8.5.1 定义标签类

8.5.2 定义tld文件

8.5.3 使用

九、Session管理

shiro提供了一整套session管理方案.

9.1 配置

9.2 Session监听

9.3 Session检测

十、加密

10.1 加密介绍

10.2 加密

在注册用户的业务中，对用户提交的密码加密即可。

10.3 密码比对

10.3.1 指定比对器

10.3.2 修改Realm

`Subject、SecutiryManager、Realm`

shiro采用的安全管理模型