权限概述

什么是权限

• 什么是权限

  权限管理，一般指根据系统设置的安全策略或者安全规则，用户可以访问而且只能访问自己被授权的资源，不多不少。权限管理几乎出现在任何系统里面，只要有用户和密码的系统。

• 权限管理再系统中一般分为

  访问权限

  一般表示你能做什么样的操作，或者能够访问那些资源。例如：给张三赋予“店铺主管”角色，“店铺主管”具有“查询员工”、“添加员工”、“修改员工”和“删除员工”权限。此时张三能够进入系统，则可以进行这些操作
  

  数据权限

  一般表示某些数据你是否属于你，或者属于你可以操作范围。例如：张三是"店铺主管"角色，他可以看他手下客服人员所有的服务的买家订单信息，他的手下只能看自己负责的订单信息
  

认证概念

• 认证：

  ​ 身份认证，就是判断一个用户是否为合法用户的处理过程。最常用的简单身份认证方式是系统通过核对用户输入的用户名和密码，看其是否与系统中存储的该用户的用户名和密码一致，来判断用户身份是否正确。例如：密码登录，手机短信验证、三方授权等

• 认证流程

  

• 关键对象

  上边的流程图中需要理解以下关键对象

  Subject：主体：访问系统的用户，主体可以是用户、程序等，进行认证的都称为主体；

  Principal：身份信息是主体（subject）进行身份认证的标识，标识必须具有唯一性，如用户名、手机号、邮箱地址等，一个主体可以有多个身份，但是必须有一个主身份（Primary Principal）

  credential：凭证信息：是只有主体自己知道的安全信息，如密码、证书等。

授权概念

• 什么是授权

  授权，即访问控制，控制谁能访问哪些资源。主体进行身份认证后，系统会为其分配对应的权限，当访问资源时，会校验其是否有访问此资源的权限

  用户对象user：当前操作的用户、程序

  资源对象resource：当前被访问的对象

  角色对象role ：一组 “权限操作许可权” 的集合

  权限对象permission：权限操作许可权

• 授权流程

  

Shrio概述

shiro简介

• 什么是shiro

  Shiro是apache旗下一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。

• shiro的特点

  Shiro 是一个强大而灵活的开源安全框架，能够非常清晰的处理认证、授权、管理会话以及密码加密。如下是它所具有的特点：

  • 易于理解的 Java Security API；
  • 简单的身份认证（登录），支持多种数据源（LDAP，JDBC 等）；
  • 对角色的简单的签权（访问控制），也支持细粒度的鉴权
  • 支持一级缓存，以提升应用程序的性能
  • 内置的基于 POJO 企业会话管理，适用于 Web 以及非 Web 的环境
  • 异构客户端会话访问
  • 非常简单的加密 API
  • 不跟任何的框架或者容器捆绑，可以独立运行

核心组件

Shiro架构图

1. Subject

   Subject主体，外部应用与subject进行交互，subject将用户作为当前操作的主体，这个主体：可以是一个通过浏览器请求的用户，也可能是一个运行的程序。Subject在shiro中是一个接口，接口中定义了很多认证授相关的方法，外部程序通过subject进行认证授，而subject是通过SecurityManager安全管理器进行认证授权

2. SecurityManager

   SecurityManager权限管理器，它是shiro的核心，负责对所有的subject进行安全管理。通过SecurityManager可以完成subject的认证、授权等，SecurityManager是通过Authenticator进行认证，通过Authorizer进行授权，通过SessionManager进行会话管理等。SecurityManager是一个接口，继承了Authenticator, Authorizer, SessionManager这三个接口

3. Authenticator

   Authenticator即认证器，对用户登录时进行身份认证

4. Authorizer

   Authorizer授权器，用户通过认证器认证通过，在访问功能时需要通过授权器判断用户是否有此功能的操作权限。

5. Realm==（数据库读取+认证功能+授权功能实现）==

   比如：

   ​ 如果用户身份数据在数据库那么realm就需要从数据库获取用户身份信息。

   注意：

   ​ 不要把realm理解成只是从数据源取数据，在realm中还有认证授权校验的相关的代码。

6. SessionManager

   SessionManager会话管理，shiro框架定义了一套会话管理，它不依赖web容器的session，所以shiro可以使用在非web应用上，也可以将分布式应用的会话集中在一点管理，此特性可使它实现单点登录。

7. SessionDAO

   SessionDAO即会话dao，是对session会话操作的一套接口

   比如：

   ​ 可以通过jdbc将会话存储到数据库

   ​ 也可以把session存储到缓存服务器

8. CacheManager

   CacheManager缓存管理，将用户权限数据存储在缓存，这样可以提高性能

9. Cryptography

   Cryptography密码管理，shiro提供了一套加密/解密的组件，方便开发。比如提供常用的散列、加/解密等功能

Shiro入门

身份认证

身份认证基本流程

1. Shiro把用户的数据封装成标识token，token一般封装着用户名，密码等信息
2. 使用Subject门面获取到封装着用户的数据的标识token
3. Subject把标识token交给SecurityManager，在SecurityManager安全中心中，SecurityManager把标识token委托给认证器Authenticator进行身份验证。认证器的作用一般是用来指定如何验证，它规定本次认证用到哪些Realm
4. 认证器Authenticator将传入的标识token，与数据源Realm对比，验证token是否合法

代码实现身份认证：

1. 导入pom.xml文件坐标

   <!--shiro-->
   <dependency>
       <groupId>org.apache.shiro</groupId>
       <artifactId>shiro-core</artifactId>
       <version>1.3.2</version>
   </dependency>
   <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>4.12</version>
       <scope>test</scope>
   </dependency>
   <!--日志-->
   <dependency>
       <groupId>commons-logging</groupId>
       <artifactId>commons-logging</artifactId>
       <version>1.1.3</version>
   </dependency>
   

2. 编写配置文件shiro-test.ini

   [users]
   #模拟从数据库查询用户
   #数据格式 用户名=密码
   liuls=654321
   wangls=123456
   

3. 编写代码

   1. 根据配置文件创建SecurityManagerFactory
   2. 通过工厂获取SecurityManager
   3. 将SecurityManager绑定到当前运行环境
   4. 从当前运行环境中构造subject
   5. 构造shiro登录的数据
   6. 主体登陆

   @Test
   public void testLogin() {
     //1.根据配置文件创建SecurityManagerFactory
     Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-test-1.ini");
     //2.通过工厂获取SecurityManager
     SecurityManager securityManager = factory.getInstance();
     //3.将SecurityManager绑定到当前运行环境
     SecurityUtils.setSecurityManager(securityManager);
     //4.从当前运行环境中构造subject
     Subject subject = SecurityUtils.getSubject();
     //5.构造shiro登录的数据
     String username = "liuls";
     String password = "65432";
     UsernamePasswordToken token = new UsernamePasswordToken(username,password);
     //6.主体登陆
     subject.login(token);
     //7.验证用户是否登录成功
     System.out.println("用户是否登录成功="+subject.isAuthenticated());
   }
   

   此处构造shiro登录的数据若和配置文件中写的相同，是否登陆成功显示true，否则false

★★★Realm★★★

Reaml：顶级接口

CachingRealm：带有缓存的Reaml

AuthenticatingRealm：继承CachingRealm，支持认证；能缓存能认证

AuthorizingRealm：继承AuthenticatingRealm，支持授权；能缓存能认证能授权

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

自定义realms对象–>继承AuthorizingRealm–>重新方法：

doGetAuthorizationInfo：授权；获取到用户的授权数据（用户的权限数据）

doGetAuthenticationInfo：认证；根据用户名密码登录，将用户数据保存（安全数据）

逻辑：用户输入账号密码，构造令牌token，通过realm查找，realm中一个方法做认证一个方法做授权

代码实现：

1. pom文件：

   <!--shiro-->
   <dependency>
       <groupId>org.apache.shiro</groupId>
       <artifactId>shiro-core</artifactId>
       <version>1.3.2</version>
   </dependency>
   <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>4.12</version>
       <scope>test</scope>
   </dependency>
   <!--日志-->
   <dependency>
       <groupId>commons-logging</groupId>
       <artifactId>commons-logging</artifactId>
       <version>1.1.3</version>
   </dependency>
   

2. MyRealm：

   创建MyRealm继承AuthorizingRealm；

   doGetAuthorizationInfo方法：做授权

   doGetAuthoricationInfo方法：做认证

   public class MyRealm extends AuthorizingRealm {
     //授权:授权的主要目的就是根据认证数据获取到用户的权限信息
     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
       System.out.println("执行授权方法");
       //1.获取安全数据  username，用户id
       String username = (String) principalCollection.getPrimaryPrincipal();
       //2.通过认证传递的安全数据，去数据库查询角色以及权限，实现授权
       List<String> perms = new ArrayList<String>();
       perms.add("user:save");
       perms.add("user:update");
       perms.add("user:delete");
       perms.add("user:find");
       List<String> roles = new ArrayList<String>();
       roles.add("role1");
       roles.add("role2");
       // 构造返回值
       SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
       // 设置角色和权限集合
       info.addStringPermissions(perms);
       info.addRoles(roles);
       return info;
     }
     //认证：认证的主要目的，比较用户名和密码是否与数据库中的一致
     //将安全数据存入到shiro进行保管
     //参数：authenticationToken登录构造的usernamepasswordtoken
     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
       System.out.println("执行认证方法");
       //1.构造uptoken
       // subject.loogin传递过来的参数是UsernamePasswordToken类型，
       // 是AuthenticationToken的一个子类，向下类型转化一下拿到构造的用户令牌
       UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken; 	 		//2.获取输入的用户名密码
       String username = token.getUsername();
       String password = new String(token.getPassword());
   		//3.根据用户名查询数据库，正式系统查询
       //4.比较密码和数据库中的密码是否一致
       if("123456".equals(password) && username.equals("dongjianxiang")){
         //5.如果成功，向shiro存入安全数据
         SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(username, password,"MyRealm");
         return info;
       }else{
         //6.失败，抛出异常或返回null
         throw new RuntimeException("账号密码错误");
       }
     }
   }
   

3. 配置文件shiro-test.ini：

   配置加载MyReaml

   [main]
   #声明Realm
   myClass=com.dong.shiro.MyRealm
   #注册realm到securityManager中
   securityManager.realms=$myClass
   

4. 测试类：

   @Test
   public void testLogin() {
     //1.根据配置文件创建SecurityManagerFactory
     Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-test.ini");
     //2.通过工厂获取SecurityManager
     SecurityManager securityManager = factory.getInstance();
     //3.将SecurityManager绑定到当前运行环境
     SecurityUtils.setSecurityManager(securityManager);
     Subject subject = SecurityUtils.getSubject();
     String username = "liuls";
     String password = "654321";
     UsernamePasswordToken token = new UsernamePasswordToken(username,password);
   
     //执行login-->realm域中的认证方法
     subject.login(token);
     System.out.println(subject.isAuthenticated());
     //鉴权
     System.out.println(subject.hasRole("role1"));//true
     System.out.println(subject.hasRole("role2"));//true
     System.out.println(subject.isPermitted("user:save"));//true
     System.out.println(subject.isPermitted("user:update"));//true
     System.out.println(subject.isPermitted("user:find"));//true
   }
   

编码与解码

1. Shiro提供了base64和16进制字符串编码/解码的API支持，方便一些编码解码操作
2. Shiro内部的一些数据的【存储/表示】都使用了base64和16进制字符串

代码实现：

1. 导入pom.xml文件

   <!--shiro-->
   <dependency>
       <groupId>org.apache.shiro</groupId>
       <artifactId>shiro-core</artifactId>
       <version>1.3.2</version>
   </dependency>
   <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>4.12</version>
       <scope>test</scope>
   </dependency>
   <!--日志-->
   <dependency>
       <groupId>commons-logging</groupId>
       <artifactId>commons-logging</artifactId>
       <version>1.1.3</version>
   </dependency>
   

2. 实现编码与解码

   import org.apache.shiro.codec.Base64;
   import org.apache.shiro.codec.Hex;
   public class EncodesUtil {
       // 16进制编码
       public static String encodeHex(byte[] input){
           return Hex.encodeToString(input);
       }
       // 16进制解码
       public static byte[] decodeHex(String input){
           return Hex.decode(input);
       }
       // base64编码
       public static String encodeBase64(byte[] input){
           return Base64.encodeToString(input);
       }
       // base64解码
       public static byte[] decodeBase64(String input){
           return Base64.decode(input);
       }
   }
   

3. 测试

   public class ClientTest {
       // 16进制编码测试
       @Test
       public void testHex(){
           String val = "apache";
           String falg = EncodesUtil.encodeHex(val.getBytes());
           String valHandler = new String(EncodesUtil.decodeHex(falg));
           System.out.println("编码内容"+falg);
           System.out.println("解码内容"+valHandler);
           System.out.println("比较结果："+val.equals(valHandler));
       }
       // base64 编码测试
       @Test
       public void testBase64(){
           String val= "shiro";
           String falg = EncodesUtil.encodeBase64(val.getBytes());
           String valHandler = new String(EncodesUtil.decodeBase64(falg));
           System.out.println("编码内容"+falg);
           System.out.println("解码内容"+valHandler);
           System.out.println("比较结果："+val.equals(valHandler));
       }
   }
   

   16进制和base64编码再解码后的内容与编码前的值相同，比较结果返回true

散列算法

散列算法一般用于生成数据的摘要信息，是一种不可逆的算法，一般适合存储密码之类的数据，常见的散列算法如MD5、SHA等。一般进行散列时最好提供一个salt（盐），比如加密密码“admin”，产生的散列值是“21232f297a57a5a743894a0e4a801fc3”，可以到一些md5解密网站很容易的通过散列值得到密码“admin”，即如果直接对密码进行散列相对来说破解更容易，此时我们可以加一些只有系统知道的干扰数据，如salt（即盐）；这样散列的对象是“密码+salt”，这样生成的散列值相对来说更难破解。shiro支持的散列算法：

Md2Hash、Md5Hash、Sha1Hash、Sha256Hash、Sha384Hash、Sha512Hash

散列算法主要用于密码的加密和解密

散列算法密码加密

代码实现：

1. pom文件到坐标

   <dependency>
     <groupId>org.apache.shiro</groupId>
     <artifactId>shiro-core</artifactId>
     <version>1.3.2</version>
   </dependency>
   <dependency>
     <groupId>junit</groupId>
     <artifactId>junit</artifactId>
     <version>4.12</version>
     <scope>test</scope>
   </dependency>
   <dependency>
     <groupId>commons-logging</groupId>
     <artifactId>commons-logging</artifactId>
     <version>1.1.3</version>
   </dependency>
   

2. 加密工具类：

   public class DigestsUtil {
   
       private static final String SHA1="SHA-1";  // 加密的方式（加密算法）
   
       private static final Integer COUNTS=369;   // 加密的次数
       
     	// 获取salt混淆字符串（固定方法）
       public static String generateSalt(){
             SecureRandomNumberGenerator randomNumberGenerator = new SecureRandomNumberGenerator();
             return randomNumberGenerator.nextBytes().toHex();
         }
     
   		// SimpleHash方法生成密文密码，需要四个参数，加密方式，输入的明文密码
     	// salt混淆字符串，加密次数
       public static String show(String input ,String salt){
           return new SimpleHash(SHA1,input,salt,COUNTS).toString();
       }
   	
     	// 模拟存数据，以便测试查看
       public static Map<String,String> entryptPassword(String passwordPlain){
           Map<String,String> map = new HashMap<String, String>();
           String salt = generateSalt();
           String password = show(passwordPlain,salt);
           map.put("salt",salt);
           map.put("password(明文)：",passwordPlain);
           map.put("password(密文)",password);
           return map;
       }
   }
   

3. 测试：

   public class Test01 {
       @Test
       public void testDigestsUtil(){
           Map<String, String> map = DigestsUtil.entryptPassword("123666");
           System.out.println("结果："+map.toString());
       }
   }
   

   结果：{password(密文)=8ec65316412c6b8725730bf6ac8c73a1cf27f3ce, salt=b8317a553b2b64ce5c78144d1bacaf7f, password(明文)：=123666}

加密解密整合案例

实现步骤：

1. pom文件：

   <!--shiro-->
   <dependency>
       <groupId>org.apache.shiro</groupId>
       <artifactId>shiro-core</artifactId>
       <version>1.3.2</version>
   </dependency>
   <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>4.12</version>
       <scope>test</scope>
   </dependency>
   <!--日志-->
   <dependency>
       <groupId>commons-logging</groupId>
       <artifactId>commons-logging</artifactId>
       <version>1.1.3</version>
   </dependency>
   

2. 加密工具类：

   模拟演示，数据写死

   public class DigestsUtil {
     public static final String SHA1= "SHA-1";
     public static final Integer COUNTS = 369;
   
     // 获取salt字符串
     public static String generateSalt(){
       SecureRandomNumberGenerator randomNumberGenerator = new SecureRandomNumberGenerator();
       return randomNumberGenerator.nextBytes().toHex();
     }
   
     //  加密得到密文密码
     public static String show(String input,String salt){
       return new SimpleHash(SHA1,input,salt,COUNTS).toString();
     }
   
     // 生成用户信息（账号，密文密码，salt混淆字符串）
     public static Map<String,String> entryptPassword(String passwordPlain){
       HashMap<String, String> map = new HashMap<String, String>();
       String salt = generateSalt();
       String password = show(passwordPlain, salt);
       map.put("name","刘老板");
       map.put("salt",salt);
       map.put("password",password);
       return map;
     }
   }
   

3. MyRealm：

   public class MyRealm extends AuthorizingRealm {
     //告诉shiro使用的散列算法
     public MyRealm() {
       //指定密码匹配方式sha1
       HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher(DigestsUtil.SHA1);
       //指定密码迭代此时
       hashedCredentialsMatcher.setHashIterations(DigestsUtil.COUNTS);
       //使用父层方法是匹配方式生效
       setCredentialsMatcher(hashedCredentialsMatcher);
     }
       
     // 认证方法
     @Override
     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
       //获取登录名
       //1.构造uptoken
       UsernamePasswordToken upToken = (UsernamePasswordToken) authenticationToken;
       //2.获取输入的用户名密码
       String username = upToken.getUsername();
       //3.通过用户名称查询数据库相关信息
       SecurityService securityService = new SecurityServiceImpl();//创建业务对象
       //4.调用业务方法(按照用户名称查询用户相关信息)
       Map<String, String> map = securityService.findPasswordByLoginName(username);
       if(map == null){
         throw  new UnknownAccountException("账户不存在");
       }
       String salt = map.get("salt");
       String password = map.get("password");//匿名密码
       //参数1：安全数据   参数2：密码   参数3：混淆字符串  参数4：realm名称
       return new SimpleAuthenticationInfo(username,password, ByteSource.Util.bytes(salt),"myRealm");
       // 参数1：安全数据写什么，未来授权方法就能拿到什么
       // 参数2：现在认证需要给shiro密文密码
       // 参数3：shiro需要知道混淆字符串
       
     }
     
     // 授权方法
       protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
           return null;
       }
   }
   

4. 配置Realm

   [main]
   # 配置realm
   myRealm=com.dong.realm.MyRealm
   securityManager.rea lms=$myRealm
   

5. 模拟一个认证业务

   接口：

   public interface IService {
     public Map<String,String> findPasswordByLoginName(String loginName);
   }
   

   实现类：

   public class ServiceImp implements IService {
     public Map<String, String> findPasswordByLoginName(String loginName) {
       if(loginName.equals("刘老板")){
         Map<String, String> map = DigestsUtil.entryptPassword("123456");
         return map;
       }
       return  null;
     }
   }
   

6. juint测试：

   public class Test01 {
       @Test
       public void shiroLogin(){
           // 导入ini配置创建工厂
           IniSecurityManagerFactory factory = new IniSecurityManagerFactory("classpath:shiro-test-1.ini");
           // 工厂构建安全管理器
           SecurityManager instance = factory.getInstance();
           // 使用工具生效安全管理器
           SecurityUtils.setSecurityManager(instance);
           // 使用工具获取subject主体
           Subject subject = SecurityUtils.getSubject();
           // 构建账号密码
           UsernamePasswordToken token = new UsernamePasswordToken("刘老板", "123456");
           // 使用subject主体登录
           subject.login(token);
   
           // 打印登录信息
           System.out.println("登陆结果："+subject.isAuthenticated());
       }
   }
   

   加密数据时数据写死了用户叫"刘老板"，密码123456，如果登录信息匹配则登录结果为true

身份授权

1. 首先调用Subject.isPermitted/hasRole接口，其会委托给SecurityManager
2. SecurityManager接着会委托给内部组件Authorizer
3. Authorizer再将其请求委托给我们的Realm去做；Realm才是真正干活的
4. Realm将用户请求的参数封装成权限对象。再从我们重写的doGetAuthorizationInfo方法中获取从数据库中查询到的权限集合
5. Realm将用户传入的权限对象，与从数据库中查出来的权限对象，进行一一对比。如果用户传入的权限对象在从数据库中查出来的权限对象中，则返回true，否则返回false

进行授权操作的前提：用户必须通过认证。

代码实现：

1. pom文件导坐标

   <!--shiro-->
   <dependency>
       <groupId>org.apache.shiro</groupId>
       <artifactId>shiro-core</artifactId>
       <version>1.3.2</version>
   </dependency>
   <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>4.12</version>
       <scope>test</scope>
   </dependency>
   <!--日志-->
   <dependency>
       <groupId>commons-logging</groupId>
       <artifactId>commons-logging</artifactId>
       <version>1.1.3</version>
   </dependency>
   

2. 配置类shiro-test.ini

   [users]
   #用户信息
   huichenyi=123456,role2
   dongjianxiang=654321,role1,role2
   
   [roles]
   # 角色
   # 角色名=权限列表
   role1=user:save,user:update,user:delete
   role2=user:find
   

3. juint单元测试：

   public class ShiroTest02 {
     @Test
     public void testShiro2(){
       //1.根据配置文件创建SecurityManagerFactory
       Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-test-2.ini");
       //2.通过工厂获取SecurityManager
       SecurityManager securityManager = factory.getInstance();
       //3.将SecurityManager绑定到当前运行环境
       SecurityUtils.setSecurityManager(securityManager);
   
       Subject subject = SecurityUtils.getSubject();
       String username = "liuls";
       String password = "654321";
       UsernamePasswordToken token = new UsernamePasswordToken(username,password);
       //登录成功之后，完成授权
       subject.login(token);
       //开始鉴权
       System.out.println(subject.hasRole("role1"));//false
       System.out.println(subject.hasRole("role2"));//true
       System.out.println(subject.isPermitted("user:save"));//false
       System.out.println(subject.isPermitted("user:find"));//true
   }
   

   先授权，再鉴权

   shiro鉴权逻辑：登录成功后，先不授权鉴权，当访问资源，需要权限时，shiro会先查权限授权，再鉴权，判断是否具有访问权

Shiro默认过滤器

Shiro内置了很多默认的过滤器，比如身份验证、授权等相关的。默认过滤器可以参考

org.apache.shiro.web.filter.mgt.DefaultFilter中的枚举过滤器

• 认证相关过滤器

• 授权相关

实现分布式会话SessionManager

也叫有状态的身份认证

1. 会话问题

   

2. 分布式会话实现思路

   

   ​ 所有服务器的session信息都存储到了同一个Redis集群中，即所有的服务都将 Session 的信息存储到 Redis 集群中，无论是对 Session 的注销、更新都会同步到集群中，达到了 Session 共享的目的。

   ​ Cookie 保存在客户端浏览器中，而 Session 保存在服务器上。客户端浏览器访问服务器的候，服务器把客户端信息以某种形式记录在服务器上，这就是 Session。客户端浏览器再次访问时只需要从该 Session 中查找该客户的状态就可以了。

   ​ 在实际工作中我们建议使用外部的缓存设备(包括Redis)来共享 Session，避免单个服务器节点挂掉而影响服务，共享数据都会放到外部缓存容器中

3. 实现步骤

   1. 创建RedisSessionDao extends AbstractSessionDAO
   2. 配置ShiroConfig

   代码实现见SpringBoot中间件技术

SpringBoot+Shiro+Jwt前后端分离鉴权

Jwt也叫无状态的身份验证

前后端分离绘画问题

• 问题追踪：

  前面我们实现分布式的会话缓存，但是我们发现此功能的实现是基于浏览的cookie机制，也就是说用户禁用cookie后，我们的系统会就会产生会话不同的问题

• 解决方案：

  我们的前端可能是web、Android、ios等应用，同时我们每一个接口都提供了无状态的应答方式，这里我们提供了基于JWT的token生成方案

JWT概述

JWT（JSON WEB TOKEN）：JSON网络令牌，JWT是一个轻便的安全跨平台传输格式，定义了一个紧凑的自包含的方式在不同实体之间安全传输信息（JSON格式）。它是在Web环境下两个实体之间传输数据的一项标准。实际上传输的就是一个字符串。

首先Shiro是一套安全认证框架，已经有了对token的相关封装。而JWT只是一种生成token的机制，需要我们自己编写相关的生成逻辑

最后 Shiro是基于session保持会话 的，也就是说是有状态的。而JWT则是无状态的（服务端不保存session，而是生成token发送给客户端进行保存，之后的所有的请求都需要携带token，再对token进行解析判断）。

虽然Shiro也有相关的token（比如UsernamePasswordToken类），但是只是Shiro在服务端对用户信息进行判断的方式而已，并不是JWT所生成的可发送给客户端的字符串token。也就是说Shiro的token并不能响应给客户端。

• 广义上：JWT是一个标准的名称
• 狭义上：JWT指的就是用来传递的那个token字符串

JWT由三部分构成：header（头部）、payload（载荷）和signature（签名）。

1. Header：

   存储两个变量

   1. 秘钥（可以用来比对）
   2. 算法（也就是下面将Header和payload加密成Signature）

2. payload

   存储很多东西，基础信息有如下几个

   1. 签发人，也就是这个“令牌”归属于哪个用户。一般是 userId
   2. 创建时间，也就是这个令牌是什么时候创建的
   3. 失效时间，也就是这个令牌什么时候失效(session的失效时间)
   4. 唯一标识，一般可以使用算法生成一个唯一标识（jti==>sessionId）

3. Signature

   ​ 这个是上面两个经过Header中的算法加密生成的，用于比对信息，防止篡改Header和payload然后将这三个部分的信息经过加密生成一个 JwtToken 的字符串，发送给客户端，客户端保存在本地。当客户端发起请求的时候携带这个到服务端(可以是在 cookie ，可以是在 header )，在服务端进行验证，我们需要解密对于的payload的内容