Shiro - 冰可乐的基地

一、现存问题

1.1 现存问题

认证（登录）：认证操作流程都差不多，但是每次都需要手动的基于业务代码去实现，很麻烦！

授权：如果权限控制粒度比较粗，可以自身去实现，但是如果控制粒度比较细，操作麻烦！

分布式会话管理：单体项目时，需要依赖Web容器的Session实现会话，搭建了集群或者是分布式项目，手动去基于Redis或者其他拥有公共存储能力的中间件实现分布式会话管理。

单点登录：在一处服务认证，所有其他服务都信任。（了解）

1.2 Shiro框架介绍

Shiro是基于Java语言编写的，Shiro最核心的功能就是认证和授权。

Shiro官方：http://shiro.apache.org

Shiro的核心架构图

二、Shiro的基本使用

2.1 SimpleAccountRealm

认证流程：

授权流程：

具体操作代码：

@Test
public void authen() {
    //认证的发起者(subject)，   SecurityManager，   Realm
    //1. 准备Realm（基于内存存储用户信息）
    SimpleAccountRealm realm = new SimpleAccountRealm();
    realm.addAccount("admin", "admin", "超级管理员", "商家");

    //2. 准备SecurityManager
    DefaultSecurityManager securityManager = new DefaultSecurityManager();

    //3. SecurityManager和Realm建立连接
    securityManager.setRealm(realm);

    //4. subject和SecurityManager建立联系
    SecurityUtils.setSecurityManager(securityManager);

    //5. 声明subject
    Subject subject = SecurityUtils.getSubject();

    //6. 发起认证
    subject.login(new UsernamePasswordToken("admin", "admin"));
    // 如果认证时，用户名错误，抛出：org.apache.shiro.authc.UnknownAccountException异常
    // 如果认证时，密码错误，抛出：org.apache.shiro.authc.IncorrectCredentialsException:

    //7. 判断是否认证成功
    System.out.println(subject.isAuthenticated());

    //8. 退出登录后再判断
    //        subject.logout();
    //        System.out.println("logout方法执行后，认证的状态：" + subject.isAuthenticated());

    //9. 授权是在认证成功之后的操作！！！
    // SimpleAccountRealm只支持角色的授权
    System.out.println("是否拥有超级管理员角色：" + subject.hasRole("超级管理员"));
    subject.checkRole("商家");
    // check方法校验角色时，如果没有指定角色，会抛出异常：org.apache.shiro.authz.UnauthorizedException: Subject does not have role [角色信息]
}

2.2 IniRealm

基于文件存储用户名，密码，角色等信息

准备一个.ini文件，存储用户信息，并且IniRealm支持权限校验

[users]
username=password,role1,role2
admin=admin,超级管理员,运营
[roles]
role1=perm1,perm2
超级管理员=user:add,user:update,user:delete
具体实现业务的代码：

@Test
public void authen(){
    //1. 构建IniRealm
    IniRealm realm = new IniRealm("classpath:shiro.ini");

    //2. 构建SecurityManager绑定Realm
    DefaultSecurityManager securityManager = new DefaultSecurityManager();
    securityManager.setRealm(realm);

    //3. 基于SecurityUtils绑定SecurityManager并声明subject
    SecurityUtils.setSecurityManager(securityManager);
    Subject subject = SecurityUtils.getSubject();

    //4. 认证操作
    subject.login(new UsernamePasswordToken("admin","admin"));

    //5. 角色校验
    // 超级管理员
    System.out.println(subject.hasRole("超级管理员"));
    subject.checkRole("运营");

    //6. 权限校验
    System.out.println(subject.isPermitted("user:update"));
    // 如果没有响应的权限，就抛出异常：UnauthorizedException: Subject does not have permission [user:select]
    subject.checkPermission("user:delete");
}

2.3 JdbcRealm

实现权限校验时，库表设计方案

用户认证、授权时推荐的表结构设计，经典五张表！

具体实现业务代码：

@Test
public void authen(){
    //1. 构建IniRealm
    JdbcRealm realm = new JdbcRealm();

    DruidDataSource dataSource = new DruidDataSource();
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql:///shiro");
    dataSource.setUsername("root");
    dataSource.setPassword("root");
    realm.setDataSource(dataSource);

    realm.setPermissionsLookupEnabled(true);

    //2. 构建SecurityManager绑定Realm
    DefaultSecurityManager securityManager = new DefaultSecurityManager();
    securityManager.setRealm(realm);

    //3. 基于SecurityUtils绑定SecurityManager并声明subject
    SecurityUtils.setSecurityManager(securityManager);
    Subject subject = SecurityUtils.getSubject();

    //4. 认证操作
    subject.login(new UsernamePasswordToken("admin","admin"));

    //5. 授权操作(角色)
    System.out.println(subject.hasRole("超级管1理员"));

    //6. 授权操作(权限)
    System.out.println(subject.isPermitted("user:add"));

}

SQL构建代码

DROP TABLE IF EXISTS `roles_permissions`;

CREATE TABLE `roles_permissions` (

`id` int(11) NOT NULL AUTO_INCREMENT,

`permission` varchar(128) NOT NULL,

`role_name` varchar(128) NOT NULL,

PRIMARY KEY (`id`)

) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb4;

— —————————-

— Records of roles_permissions

— —————————-

INSERT INTO `roles_permissions` VALUES (‘1’, ‘user:add’, ‘超级管理员’);

INSERT INTO `roles_permissions` VALUES (‘2’, ‘user:update’, ‘超级管理员’);

INSERT INTO `roles_permissions` VALUES (‘3’, ‘user:select’, ‘运营’);

— —————————-

— Table structure for `users`

— —————————-

DROP TABLE IF EXISTS `users`;

CREATE TABLE `users` (

`id` int(11) NOT NULL AUTO_INCREMENT,

`username` varchar(32) NOT NULL,

`password` varchar(32) NOT NULL,

PRIMARY KEY (`id`)

) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4;

— —————————-

— Records of users

— —————————-

INSERT INTO `users` VALUES (‘1’, ‘admin’, ‘admin’);

— —————————-

— Table structure for `user_roles`

— —————————-

DROP TABLE IF EXISTS `user_roles`;

CREATE TABLE `user_roles` (

`id` int(11) NOT NULL AUTO_INCREMENT,

`role_name` varchar(128) NOT NULL,

`username` varchar(32) NOT NULL,

PRIMARY KEY (`id`)

) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4;

— —————————-

— Records of user_roles

— —————————-

INSERT INTO `user_roles` VALUES (‘1’, ‘超级管理员’, ‘admin’);

INSERT INTO `user_roles` VALUES (‘2’, ‘运营’, ‘admin’);

2.4 CustomRealm（自定义Realm）

仿照JdbcRealm实现一个自定义的Realm对象

声明POJO类，继承AuthorizingRealm
public class CustomRealm extends AuthorizingRealm {
……………………
}
重写doGetAuthenticationInfo方法（认证）

/**
 * 认证方法，只需要完成用户名校验即可，密码校验由Shiro内部完成
 * @param token  用户传入的用户名和密码
 * @return
 * @throws AuthenticationException
 */
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
    //1. 基于Token获取用户名
    String username = (String) token.getPrincipal();

    //2. 判断用户名（非空）
    if(StringUtils.isEmpty(username)){
        // 返回null，会默认抛出一个异常，org.apache.shiro.authc.UnknownAccountException
        return null;
    }

    //3. 如果用户名不为null，基于用户名查询用户信息
    User user = this.findUserByUsername(username);

    //4. 判断user对象是否为null
    if(user == null){
        return null;
    }

    //5. 声明AuthenticationInfo对象，并填充用户信息
    SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user,user.getPassword(),"CustomRealm!!");

    //6. 返回info
    return info;
}

// 模拟数据库操作
private User findUserByUsername(String username) {
if(“admin”.equals(username)){
User user = new User();
user.setId(1);
user.setUsername(“admin”);
user.setPassword(“admin”);
return user;
}
return null;
}

重写doGetAuthenticationInfo方法（密码加密加盐）
{
HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
matcher.setHashAlgorithmName(“MD5”);
matcher.setHashIterations(1024);
this.setCredentialsMatcher(matcher);
}

/**

认证方法，只需要完成用户名校验即可，密码校验由Shiro内部完成
@param token 用户传入的用户名和密码
@return
@throws AuthenticationException
*/
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
//1. 基于Token获取用户名
String username = (String) token.getPrincipal();
//2. 判断用户名（非空）
if(StringUtils.isEmpty(username)){
// 返回null，会默认抛出一个异常，org.apache.shiro.authc.UnknownAccountException
return null;
}
//3. 如果用户名不为null，基于用户名查询用户信息
User user = this.findUserByUsername(username);
//4. 判断user对象是否为null
if(user == null){
return null;
}
//5. 声明AuthenticationInfo对象，并填充用户信息
SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(user,user.getPassword(),”CustomRealm!!”);
// 设置盐！
info.setCredentialsSalt(ByteSource.Util.bytes(user.getSalt()));
//6. 返回info
return info;
}

// 模拟数据库操作

private User findUserByUsername(String username) {

if(“admin”.equals(username)){

User user = new User();

user.setId(1);

user.setUsername(“admin”);

user.setPassword(“1ebc4dcaf1e21b814ece65f27531f1a9”);

user.setSalt(“weruiothergjkdfnbgjkdfngjkdf”);

return user;

}

return null;

}

* 重写doGetAuthorizationInfo方法（授权）

“`java

// 授权方法，授权是在认证之后的操作

@Override

protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {

//1. 获取认证用户的信息

User user = (User) principals.getPrimaryPrincipal();

//2. 基于用户信息获取当前用户拥有的角色。

Set<String> roleSet = this.findRolesByUser();

//3. 基于用户拥有的角色查询权限信息

Set<String> permSet = this.findPermsByRoleSet(roleSet);

//4. 声明AuthorizationInfo对象作为返回值，传入角色信息和权限信息

SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();

info.setRoles(roleSet);

info.setStringPermissions(permSet);

//5. 返回

return info;

}

private Set<String> findPermsByRoleSet(Set<String> roleSet) {

Set<String> set = new HashSet<>();

set.add(“user:add”);

set.add(“user:update”);

return set;

}

private Set<String> findRolesByUser() {

Set<String> set = new HashSet<>();

set.add(“超级管理员”);

set.add(“运营”);

return set;

}

三、Shiro的Web流程

四、Shiro整合Web（SpringMVC，SpringBoot）

4.1 SSM方式

准备SSM的配置（掌握跳过）
准备经典五张表，完成测试
准备Shiro的配置

- 准备核心过滤器
- <!– 配置Shiro整合web的过滤器–>
  <filter>
  <!– 默认情况下，请求到达这个过滤器，会去Spring容器中名字为filter-name的实例去处理–>
  <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>
- 准备shiroFilter实例
- <bean id=”shiroFilter” class=”org.apache.shiro.spring.web.ShiroFilterFactoryBean”>
  …..
  </bean>
- 注入SecurityManager，登录页面路径，过滤器链
- <!– 构建realm–>
  <bean id=”realm” class=”com.mashibing.realm.ShiroRealm” />
  
  <!– 构建securityManager–>
  <bean id=”securityManager” class=”org.apache.shiro.web.mgt.DefaultWebSecurityManager”>
  <property name=”realm” ref=”realm”/>
  </bean>
  
  <!– 构建ShiroFilter实例–>
  <bean id=”shiroFilter” class=”org.apache.shiro.spring.web.ShiroFilterFactoryBean”>
  <property name=”securityManager” ref=”securityManager”/>
  <property name=”loginUrl” value=”/login.html” />
  <property name=”filterChainDefinitionMap”>
  <map>
  <entry key=”/login.html” value=”anon” />
  <entry key=”/user/**” value=”anon” />
  <entry key=”/**” value=”authc” />
  </map>
  </property>
  </bean>
- 将ShiroRealm的模拟数据库操作，修改为与数据库交互
- 编写登录功能，并测试效果
- @PostMapping(“/login”)
  public String login(String username,String password){
  // 执行Shiro的认证操作
  //1. 直接基于SecurityUtils获取subject主体,不需要手动的将SecurityManager和SecurityUtils手动整合，Spring已经奥丁
  Subject subject = SecurityUtils.getSubject();
  
  //2. 发起认证
  try {
  subject.login(new UsernamePasswordToken(username,password));
  return “SUCCESS”;
  } catch (UnknownAccountException exception){
  return “username fail!!!”;
  } catch (IncorrectCredentialsException exception){
  return “password fail!!!”;
  } catch (AuthenticationException e) {
  return “donot know…!!!”;
  }
  }

4.2 SpringBoot方式

搭建SpringBoot工程（准备工作）
配置Shiro整合SpringBoot内容
@Configuration
public class ShiroConfig {

@Bean
public DefaultWebSecurityManager securityManager(ShiroRealm realm){
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
securityManager.setRealm(realm);
return securityManager;
}

@Bean
public DefaultShiroFilterChainDefinition shiroFilterChainDefinition(){
DefaultShiroFilterChainDefinition shiroFilterChainDefinition = new DefaultShiroFilterChainDefinition();

Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>();
filterChainDefinitionMap.put(“/login.html”,”anon”);
filterChainDefinitionMap.put(“/user/**”,”anon”);
filterChainDefinitionMap.put(“/**”,”authc”);

shiroFilterChainDefinition.addPathDefinitions(filterChainDefinitionMap);

return shiroFilterChainDefinition;
}
}

五、Shiro的授权方式

5.1 过滤器链

public enum DefaultFilter {

// ….

perms(PermissionsAuthorizationFilter.class),

roles(RolesAuthorizationFilter.class),

// ….

}

filterChainDefinitionMap.put(“/item/select”,”roles[超级管理员,运营]”);

filterChainDefinitionMap.put(“/item/delete”,”perms[item:delete,item:insert]”);

5.2 自定义过滤器

仿照RolesAuthorizationFilter实现自定义过滤器
/**
* 在要求的多个角色中，有一个满足要求，就放行
* @author zjw
* @description
*/
public class RolesOrAuthorizationFilter extends AuthorizationFilter {
@Override
protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {
// 获取主体subject
Subject subject = getSubject(request, response);
// 将传入的角色转成数组操作
String[] rolesArray = (String[]) mappedValue;
// 健壮性校验
if (rolesArray == null || rolesArray.length == 0) {
return true;
}
// 开始校验
for (String role : rolesArray) {
if(subject.hasRole(role)){
return true;
}
}

return false;
}
}
将自定义过滤器配置给Shiro
@Configuration
public class ShiroConfig {

@Bean
public DefaultWebSecurityManager securityManager(ShiroRealm realm){
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
securityManager.setRealm(realm);
return securityManager;
}

@Bean
public DefaultShiroFilterChainDefinition shiroFilterChainDefinition(){
DefaultShiroFilterChainDefinition shiroFilterChainDefinition = new DefaultShiroFilterChainDefinition();

Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>();
filterChainDefinitionMap.put(“/login.html”,”anon”);
filterChainDefinitionMap.put(“/user/**”,”anon”);
filterChainDefinitionMap.put(“/item/select”,”rolesOr[超级管理员,运营]”);
filterChainDefinitionMap.put(“/item/delete”,”perms[item:delete,item:insert]”);
filterChainDefinitionMap.put(“/**”,”authc”);

shiroFilterChainDefinition.addPathDefinitions(filterChainDefinitionMap);

return shiroFilterChainDefinition;
}

@Value(“#{ @environment[‘shiro.loginUrl’] ?: ‘/login.jsp’ }”)
protected String loginUrl;

@Value(“#{ @environment[‘shiro.successUrl’] ?: ‘/’ }”)
protected String successUrl;

@Value(“#{ @environment[‘shiro.unauthorizedUrl’] ?: null }”)
protected String unauthorizedUrl;

@Bean

protected ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager,ShiroFilterChainDefinition shiroFilterChainDefinition) {

//1. 构建ShiroFilterFactoryBean工厂

ShiroFilterFactoryBean filterFactoryBean = new ShiroFilterFactoryBean();

//2. 设置了大量的路径

filterFactoryBean.setLoginUrl(loginUrl);

filterFactoryBean.setSuccessUrl(successUrl);

filterFactoryBean.setUnauthorizedUrl(unauthorizedUrl);

//3. 设置安全管理器

filterFactoryBean.setSecurityManager(securityManager);

//4. 设置过滤器链

filterFactoryBean.setFilterChainDefinitionMap(shiroFilterChainDefinition.getFilterChainMap());

//5. 设置自定义过滤器，这里一定要手动的new出来这个自定义过滤器，如果使用Spring管理自定义过滤器，会造成无法获取到Subject

filterFactoryBean.getFilters().put(“rolesOr”,new RolesOrAuthorizationFilter());

//6. 返回工厂

return filterFactoryBean;

}

* 测试功能

“`java

// 修改当前用户的角色授权过滤器

filterChainDefinitionMap.put(“/item/select”,”rolesOr[超级管理员,运营]”);

5.3 注解

注解进行授权时，是基于对Controller类进行代理，在前置增强中对请求进行权限校验
因为咱们使用SpringBoot的测试方式，直接在Controller方法上添加注解即可
@GetMapping(“/update”)
@RequiresRoles(value = {“超级管理员”,”运营”})
public String update(){
return “item Update!!!”;
}

@GetMapping(“/insert”)
@RequiresRoles(value = {“超级管理员”,”运营”},logical = Logical.OR)
public String insert(){
return “item Update!!!”;
}

// @RequiresPermissions(value = “”,logical = Logical.AND)
在SpringBoot中注解默认就生效，是因为自动装配中，已经配置好了对注解的支持
@Configuration
@ConditionalOnProperty(name = “shiro.annotations.enabled”, matchIfMissing = true)
public class ShiroAnnotationProcessorAutoConfiguration extends AbstractShiroAnnotationProcessorConfiguration {

@Bean
@DependsOn(“lifecycleBeanPostProcessor”)
@ConditionalOnMissingBean
@Override
public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
return super.defaultAdvisorAutoProxyCreator();
}

@Bean
@ConditionalOnMissingBean
@Override
public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
return super.authorizationAttributeSourceAdvisor(securityManager);
}
}
注解的形式无法将错误页面的信息定位到401.html，因为配置的这种路径，只针对过滤器链有效，注解无效。为了实现友好提示的效果，可以配置异常处理器，@RestControllerAdvice，@ControllerAdvice

5.4 标签（前端，不玩，JSP、Freemarker、Thymeleaf）

5.5 记住我

记住我在开启后，可以针对一些安全级别相对更低的页面采用user过滤器拦截，只要登录过，不需要重新登录就可以访问
准备工作：

- 准备两个接口
- @GetMapping(“/rememberMe”)
  public String rememberMe(){
  return “rememberMe!!!”;
  }
  
  @GetMapping(“/authentication”)
  public String authentication(){
  return “authentication!!!”;
  }
- 配置不同的过滤器
- filterChainDefinitionMap.put(“/item/rememberMe”,”user”);
  filterChainDefinitionMap.put(“/item/authentication”,”authc”);

在页面追加记住我按钮，并且在登录是，添加rememberMe效果
<form action=”/user/login” method=”post”>
用户名：<input name=”username” /> <br />
密码：<input name=”password” /> <br />
记住我：<input type=”checkbox” name=”rememberMe” value=”on” /> <br />
<button type=”submit”>登录</button>
</form>

<!– ================================== –>
UsernamePasswordToken token = new UsernamePasswordToken(username, password);
token.setRememberMe(rememberMe != null && “on”.equals(rememberMe));
subject.login(token);
测试效果
问题1：认证后，后台报错，原因是记住我，需要以浏览器的cookie和后台的user对象绑定，user对象需要序列化。
public class User implements Serializable { ……}
问题2：认证后，重新打开浏览器，还可以访问角色授权、权限授权的地址。没有在Realm的授权方法中先判断用户是否认证，导致可以直接方案，因为cookie绑定的是认证成功后，返回的第一个参数，而第一个参数和授权方法中参数能获得到的用户信息是一个内容。直接在授权方法中先做认证判断
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
//0. 判断是否认证
Subject subject = SecurityUtils.getSubject();
if(subject == null){
return null;
}
if (!subject.isAuthenticated()) {
return null;
}
………………
}
测试效果：需要认证的接口地址，无法在关闭浏览器后重新访问，必须要重新认证。
测试效果：需要记住我的接口地址，可以在浏览器重新打开后正常访问。

六、Shiro的分布式Session的处理

6.1 Shiro的Session管理

Shiro在认证成功后，可以不依赖Web容器的Session，也可以依赖！

在SpringBoot自动装配之后，Shiro默认将HttpSession作为存储用户认证成功信息的位置。

但是SpringBoot也提供了一个基于JVM内存存储用户认证信息的位置。

修改Shiro默认使用的SessionDAO，修改为默认构建好的MemorySessionDAO

// 构建管理SessionDAO的SessionManager

@Bean

public SessionManager sessionManager(SessionDAO sessionDAO) {

DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();

sessionManager.setSessionDAO(sessionDAO);

return sessionManager;

}

@Bean

public DefaultWebSecurityManager securityManager(ShiroRealm realm,SessionManager sessionManager){

DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();

securityManager.setRealm(realm);

// 将使用MemorySessionDAO的SessionManager注入到SecurityManager

securityManager.setSessionManager(sessionManager);

return securityManager;

}

6.2 Shiro解决分布式Session

在服务搭建集群后，或者是服务是分布式架构的，导致单台服务的认证无法让其他服务也得知到信息：

基于Nginx做ip_hash策略，但是也只是针对单台服务搭建集群有效果
基于Shiro提供的SessionDAO解决，让SessionDAO去与公共的Redis进行交互，存储用户信息

6.3 实现Shiro的分布式Session处理

项目连接Redis

- 导入依赖
- <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
  </dependency>
- 编写配置
- spring:
  redis:
  host: 49.233.115.171
  port: 6379
  password: xxxxx

声明SessionDAO的实现类，并重写核心方法
@Component
public class RedisSessionDAO extends AbstractSessionDAO {

@Resource
private RedisTemplate redisTemplate;

// 存储到Redis时，sessionId作为key，Session作为Value
// sessionId就是一个字符串
// Session可以和sessionId绑定到一起，绑定之后，可以基于Session拿到sessionId
// 需要给Key设置一个统一的前缀，这样才可以方便通过keys命令查看到所有关联的信息

private final String SHIOR_SESSION = “session:”;

@Override
protected Serializable doCreate(Session session) {
System.out.println(“Redis—doCreate”);
//1. 基于Session生成一个sessionId（唯一标识）
Serializable sessionId = generateSessionId(session);

//2. 将Session和sessionId绑定到一起（可以基于Session拿到sessionId）
assignSessionId(session, sessionId);

//3. 将前缀:sessionId 作为key，session作为value存储
redisTemplate.opsForValue().set(SHIOR_SESSION + sessionId,session,30, TimeUnit.MINUTES);

//4. 返回sessionId
return sessionId;
}

@Override
protected Session doReadSession(Serializable sessionId) {
//1. 基于sessionId获取Session （与Redis交互）
if (sessionId == null) {
return null;
}
Session session = (Session) redisTemplate.opsForValue().get(SHIOR_SESSION + sessionId);
if (session != null) {
redisTemplate.expire(SHIOR_SESSION + sessionId,30,TimeUnit.MINUTES);
}
return session;
}

@Override
public void update(Session session) throws UnknownSessionException {
System.out.println(“Redis—update”);
//1. 修改Redis中session
if(session == null){
return ;
}
redisTemplate.opsForValue().set(SHIOR_SESSION + session.getId(),session,30, TimeUnit.MINUTES);
}

@Override
public void delete(Session session) {
// 删除Redis中的Session
if(session == null){
return ;
}
redisTemplate.delete(SHIOR_SESSION + session.getId());
}

@Override
public Collection<Session> getActiveSessions() {
Set keys = redisTemplate.keys(SHIOR_SESSION + “*”);

Set<Session> sessionSet = new HashSet<>();
// 尝试修改为管道操作，pipeline（Redis的知识）
for (Object key : keys) {
Session session = (Session) redisTemplate.opsForValue().get(key);
sessionSet.add(session);
}
return sessionSet;
}
}
将RedisSessionDAO交给SessionManager
@Bean
public SessionManager sessionManager(RedisSessionDAO sessionDAO) {
DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
sessionManager.setSessionDAO(sessionDAO);
return sessionManager;
}
将SessionManager注入到SecurityManager
@Bean
public DefaultWebSecurityManager securityManager(ShiroRealm realm,SessionManager sessionManager){
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
securityManager.setRealm(realm);
securityManager.setSessionManager(sessionManager);
return securityManager;
}

6.4 RedisSessionDAO问题

将传统的基于Web容器或者ConcurrentHashMap切换为Redis之后，发现每次请求需要访问多次Redis服务，这个访问的频次会出现很长时间的IO等待，对每次请求的性能减低了，并且对Redis的压力也提高了。

基于装饰者模式重新声明SessionManager中提供的retrieveSession方法，让每次请求先去request域中查询session信息，request域中没有，再去Redis中查询
public class DefaultRedisWebSessionManager extends DefaultWebSessionManager {
@Override
protected Session retrieveSession(SessionKey sessionKey) throws UnknownSessionException {
// 通过sessionKey获取sessionId
Serializable sessionId = getSessionId(sessionKey);

// 将sessionKey转为WebSessionKey
if(sessionKey instanceof WebSessionKey){
WebSessionKey webSessionKey = (WebSessionKey) sessionKey;
// 获取到request域
ServletRequest request = webSessionKey.getServletRequest();
// 通过request尝试获取session信息
Session session = (Session) request.getAttribute(sessionId + “”);
if(session != null){
System.out.println(“从request域中获取session信息”);
return session;
}else{
session = retrieveSessionFromDataSource(sessionId);
if (session == null) {
//session ID was provided, meaning one is expected to be found, but we couldn’t find one:
String msg = “Could not find session with ID [” + sessionId + “]”;
throw new UnknownSessionException(msg);
}
System.out.println(“Redis—doReadSession”);
request.setAttribute(sessionId + “”,session);
return session;
}
}
return null;
}
}
配置DefaultRedisWebSessionManager到SecurityManager中
@Bean
public SessionManager sessionManager(RedisSessionDAO sessionDAO) {
DefaultRedisWebSessionManager sessionManager = new DefaultRedisWebSessionManager();
sessionManager.setSessionDAO(sessionDAO);
return sessionManager;
}

七、Shiro的授权缓存

如果后台接口存在授权操作，那么每次请求都需要去数据库查询对应的角色信息和权限信息，对数据库来说，这样的查询压力太大了。

在Shiro中，发现每次在执行自定义Realm的授权方法查询数据库之前，会有一个执行Cache的操作。

先从Cache中基于一个固定的key去查询角色以及权限的信息。

只需要提供好响应的CacheManager实例，还要实现一个与Redis交互的Cache对象，将Cache对象设置到CacheManager实例中。

将上述设置好的CacheManager设置到SecurityManager对象中

7.1 实现RedisCache

@Component

public class RedisCache<K, V> implements Cache<K, V> {

@Autowired

private RedisTemplate redisTemplate;

private final String CACHE_PREFIX = “cache:”;

/**

* 获取授权缓存信息

* @param k

* @return

* @throws CacheException

@Override

public V get(K k) throws CacheException {

V v = (V) redisTemplate.opsForValue().get(CACHE_PREFIX + k);

if(v != null){

redisTemplate.expire(CACHE_PREFIX + k,15, TimeUnit.MINUTES);

}

return v;

}

/**

* 存放缓存信息

* @param k

* @param v

* @return

* @throws CacheException

@Override

public V put(K k, V v) throws CacheException {

redisTemplate.opsForValue().set(CACHE_PREFIX + k,v,15,TimeUnit.MINUTES);

return v;

}

/**

* 清空当前缓存

* @param k

* @return

* @throws CacheException

@Override

public V remove(K k) throws CacheException {

V v = (V) redisTemplate.opsForValue().get(CACHE_PREFIX + k);

if(v != null){

redisTemplate.delete(CACHE_PREFIX + k);

}

return v;

}

/**

* 清空全部的授权缓存

* @throws CacheException

@Override

public void clear() throws CacheException {

Set keys = redisTemplate.keys(CACHE_PREFIX + “*”);

redisTemplate.delete(keys);

}

/**

* 查看有多个权限缓存信息

* @return

@Override

public int size() {

Set keys = redisTemplate.keys(CACHE_PREFIX + “*”);

return keys.size();

}

/**

* 获取全部缓存信息的key

* @return

@Override

public Set<K> keys() {

Set keys = redisTemplate.keys(CACHE_PREFIX + “*”);

return keys;

}

/**

* 获取全部缓存信息的value

* @return

@Override

public Collection<V> values() {

Set values = new HashSet();

Set keys = redisTemplate.keys(CACHE_PREFIX + “*”);

for (Object key : keys) {

Object value = redisTemplate.opsForValue().get(key);

values.add(value);

}

return values;

}

7.2 实现CacheManager并测试

实现CachaManager

@Component

public class RedisCacheManager implements CacheManager {

@Autowired

private RedisCache redisCache;

@Override

public <K, V> Cache<K, V> getCache(String s) throws CacheException {

return redisCache;

}

将RedisCacheManager配置到SecurityManager

@Bean

public DefaultWebSecurityManager securityManager(ShiroRealm realm, SessionManager sessionManager, RedisCacheManager redisCacheManager){

DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();

securityManager.setRealm(realm);

securityManager.setSessionManager(sessionManager);

// 设置CacheManager，提供与Redis交互的Cache对象

securityManager.setCacheManager(redisCacheManager);

return securityManager;

}

八、Shiro整合CAS框架实现单点登录

8.1 单点登录

单点登录（Single Sign On），简称为 SSO，是比较流行的企业业务整合的解决方案之一。SSO的定义是在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统。

一般这种单点登录的实现方案，分为两种

中心化方式：

去中心化方式：

去中心化方式：不存在单点故障，并且在访问时，可以减少网络IO所占用的时间，并且针对认证服务器没有请求压力。去中心化的方式，采用JWT实现。

中心化方式：存在单点故障，单台服务的访问压力较大，每次请求认证身份都需要访问认证服务器，导致压力相对比较大，效率也比较低。

咱们即将搞定的Shiro+CAS的方式，就是基于中心化实现的。

8.2 CAS介绍&搭建

8.2.1 CAS介绍

CAS是一个开源项目，CAS是应用于企业级别的单点登录的服务，CAS分为CAS Server，CAS Client

CAS Server是需要一个单独部署的Web工程

CAS Client是一个项目中的具体业务服务，并且在需要认证或授权时，找到CAS Server即可

整体CAS的认证和授权流程就是中心化的方式

8.2.2 CAS搭建

在知道CAS是什么内容后，第一步就是将CAS Server单独部署并运行起来

CAS Server的5.x版本更改为使用gradle构建，平时更多的是使用Maven，采用4.x版本、

采用CAS的4.x版本使用……

下载CAS：https://github.com/apereo/cas/archive/refs/tags/v4.1.10.zip

使用IDEA打开CAS Server，并修改一些配置信息，将CAS Server进行打包，扔到Tomcat服务中运行

采用IDEA打开CAS Server，并加载
CAS Server默认只支持HTTPS，需要让CAS Server支持HTTP

- Apereo-10000002.json
- HTTPSandIMAPS-10000001.json
- ticketGrantingTicketCookieGenerator.xml
- warnCookieGenerator.xml
- deployerConfigContext.xml

将项目进行打包，采用项目中的Maven插件，war的形式打包

- 打包前，先将CAS Server进行compile，避免启动项目时，出现类路径下的配置文件无法找到
- 再执行plugins中提供的war:war执行打包

将war包扔到Tomcat的webapps里，并运行即可
访问CAS Server首页，并且完成认证

- 默认用户名&密码
- 访问首页测试

8.2.3 CAS连接数据库认证

注释掉之前采用配置文件内认证的方式，修改为与数据库交互实现

导入依赖
<!– mysql驱动–>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<!– druid连接池–>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.10</version>
</dependency>
<!– jdbc的支持–>
<dependency>
<groupId>org.jasig.cas</groupId>
<artifactId>cas-server-support-jdbc</artifactId>
<version>4.1.10</version>
</dependency>
编写配置
<!– 数据源–>
<bean id=”dataSource” class=”com.alibaba.druid.pool.DruidDataSource”>
<property name=”driverClassName” value=”com.mysql.jdbc.Driver” />
<property name=”url” value=”jdbc:mysql:///shiro-web” />
<property name=”username” value=”root” />
<property name=”password” value=”root” />
</bean>
<!–配置primaryAuthenticationHandler，QueryDatabaseAuthenticationHandler–>
<bean id=”primaryAuthenticationHandler” class=”org.jasig.cas.adaptors.jdbc.QueryDatabaseAuthenticationHandler”>
<property name=”dataSource” ref=”dataSource” />
<property name=”sql” value=”select password from tb_user where username = ?” />
</bean>
需要将webapp项目进行compile，然后再执行war:war
最终经过测试，得知，CAS Server在认证成功后，会给客户端返回一些TGC并写入浏览器的Cookie中，每次客户端携带者正确的TGC来访问时，就会与CAS Server端存储的TGT进行配对，只要正确，证明认证成功，直接跳转到登录成功页面，否则跳转到登录页面

8.2.4 CAS实现对密码的加密&加盐

在实现CAS与数据库交互时，采用了QueryDatabaseAuthenticationHandler类实现。

同时这个类提供了一个属性passwordEncoder，可以基于passwordEncoder实现对密码进行加密校验。

但是基于咱们的业务，需要对密码进行加密和加盐的操作。

QueryDatabaseAuthenticationHandler无法实现业务需求。

需要参考QueryDatabaseAuthenticationHandler认证处理器去实现可以满足自身业务的认证处理器

需要实现属于自己的认证处理器：

需要编写一个MD5HashQueryDatabaseAuthenticationHandler，去继承AbstractJdbcUsernamePasswordAuthenticationHandler
/**
* @author zjw
* @since 3.0
*/
public class MD5HashQueryDatabaseAuthenticationHandler extends AbstractJdbcUsernamePasswordAuthenticationHandler {
// …..
}
声明saltSql，需要注入查询盐的SQL语句，在做密码校验时，需要先将用户输入的密码进行加密和加盐，然后再做比较
/*
* Licensed to Apereo under one or more contributor license
* agreements. See the NOTICE file distributed with this work
* for additional information regarding copyright ownership.
* Apereo licenses this file to you under the Apache License,
* Version 2.0 (the “License”); you may not use this file
* except in compliance with the License. You may obtain a
* copy of the License at the following location:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.jasig.cas.adaptors.jdbc;

import org.apache.shiro.crypto.hash.Md5Hash;
import org.jasig.cas.authentication.HandlerResult;
import org.jasig.cas.authentication.PreventedException;
import org.jasig.cas.authentication.UsernamePasswordCredential;
import org.springframework.dao.DataAccessException;
import org.springframework.dao.IncorrectResultSizeDataAccessException;

import javax.security.auth.login.AccountNotFoundException;
import javax.security.auth.login.FailedLoginException;
import javax.validation.constraints.NotNull;
import java.security.GeneralSecurityException;

/**
* @author zjw
* @since 3.0
*/
public class MD5HashQueryDatabaseAuthenticationHandler extends AbstractJdbcUsernamePasswordAuthenticationHandler {

@NotNull
private String sql;

@NotNull
private String saltSql;

private final Integer hashIterations = 1024;

/**
* {@inheritDoc}
*/
@Override
protected final HandlerResult authenticateUsernamePasswordInternal(final UsernamePasswordCredential credential)
throws GeneralSecurityException, PreventedException {
// 获取用户输入的用户名
final String username = credential.getUsername();
// 获取用户输入的密码
final String encryptedPassword = this.getPasswordEncoder().encode(credential.getPassword());
try {
// 基于用户名查询数据库的密码
final String dbPassword = getJdbcTemplate().queryForObject(this.sql, String.class, username);
// 基于用户名查询当前用户的salt
final String salt = getJdbcTemplate().queryForObject(this.saltSql, String.class, username);
// 将用户输入的密码进行加密和加盐操作~
final String password = new Md5Hash(encryptedPassword, salt, hashIterations).toString();
// 比较密码
if (!dbPassword.equals(password)) {
throw new FailedLoginException(“Password does not match value on record.”);
}
} catch (final IncorrectResultSizeDataAccessException e) {
if (e.getActualSize() == 0) {
throw new AccountNotFoundException(username + ” not found with SQL query”);
} else {
throw new FailedLoginException(“Multiple records found for ” + username);
}
} catch (final DataAccessException e) {
throw new PreventedException(“SQL exception while executing query for ” + username, e);
}
return createHandlerResult(credential, this.principalFactory.createPrincipal(username), null);
}

/**
* @param sql The sql to set.
*/
public void setSql(final String sql) {
this.sql = sql;
}

/**
* @param saltSql The sql to set – select salt.
*/
public void setSaltSql(final String saltSql) {
this.saltSql = saltSql;
}
}

回到webapp项目中，采用MD5HashQueryDatabaseAuthenticationHandler作为认证处理器

<!–配置primaryAuthenticationHandler，QueryDatabaseAuthenticationHandler–>

</bean>

在第一次重新打包并发布时，出现了ClassNotFountException，需要将JDBC项目进行install操作，然后才可以对webapp重新war:war，然后才可以生效，避免出现ClassNotFountException

8.3 Shiro + pac4j + CAS

8.3.1 认证流程

本质上和ShiroWeb的流程没有变化，只不过内部使用的一些Realm和过滤器交由pac4j提供

8.3.2 构建项目并设置配置信息

导入依赖
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>1.4.0</version>
</dependency>

<dependency>
<groupId>io.buji</groupId>
<artifactId>buji-pac4j</artifactId>
<version>4.0.0</version>
</dependency>

<dependency>
<groupId>org.pac4j</groupId>
<artifactId>pac4j-cas</artifactId>
<version>3.0.2</version>
</dependency>
</dependencies>
配置Realm
@Component
public class CasRealm extends Pac4jRealm {

/**

* 授权操作，需要自己编写，并且也可以基于RedisSessionDAO实现缓存……

* @param principals

* @return

@Override

protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {

// do something , find DB or Cache

return null;

}

* 编写SecurityManager

“`java

@Configuration

public class ShiroConfig {

@Bean

public SubjectFactory subjectFactory(){

return new Pac4jSubjectFactory();

}

@Bean

public SecurityManager securityManager(CasRealm casRealm,SubjectFactory subjectFactory){

DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();

securityManager.setRealm(casRealm);

securityManager.setSubjectFactory(subjectFactory);

return securityManager;

}

配置过滤器
@Configuration
public class ShiroConfig {

/**

* 配置核心过滤器

* @return

@Bean

public FilterRegistrationBean filterRegistrationBean(){

FilterRegistrationBean filterRegistration =new FilterRegistrationBean();

filterRegistration.setFilter(new DelegatingFilterProxy(“shiroFilter”));

filterRegistration.addUrlPatterns(“/*”);

return filterRegistration;

}

* 配置ShiroFiler（ShiroConfig）

“`java

/**

* shiroFilter核心配置

* @return

@Bean

public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager){

ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();

factoryBean.setSecurityManager(securityManager);

putFilterChain(factoryBean);

return factoryBean;

}

private void putFilterChain(ShiroFilterFactoryBean factoryBean) {

Map<String,String> filterChain = new LinkedHashMap<>();

// 后面在声明好pac4j提供的过滤器后，需要重新设置！

filterChain.put(“/**”,”anon”);

factoryBean.setFilterChainDefinitionMap(filterChain);

}

设置pac4j对CAS的设置
@Configuration
public class Pac4jConfig {

@Value(“${cas.server.url:http://localhost:8080/cas}”)
private String casServerUrl;

@Value(“${cas.project.url:http://localhost:81}”)
private String casProjectUrl;

@Value(“${cas.clientName:test}”)
private String clientName;

/**
* 核心Config
* @param casClient
* @return
*/
@Bean
public Config config(CasClient casClient){
Config config = new Config(casClient);
return config;
}

/**
* casClient，主要设置回调
* @param casConfiguration
* @return
*/
@Bean
public CasClient casClient(CasConfiguration casConfiguration){
CasClient casClient = new CasClient(casConfiguration);
// 设置CAS访问后的回调地址
casClient.setCallbackUrl(casProjectUrl + “/callback?client_name=” + clientName);
casClient.setName(clientName);
return casClient;
}

/**
* CAS服务地址
* @return
*/
@Bean
public CasConfiguration casConfiguration(){
CasConfiguration casConfiguration = new CasConfiguration();
// 设置CAS登录页面
casConfiguration.setLoginUrl(casServerUrl + “/login”);
// 设置CAS协议
casConfiguration.setProtocol(CasProtocol.CAS20);
casConfiguration.setPrefixUrl(casServerUrl + “/”);
casConfiguration.setAcceptAnyProxy(true);
return casConfiguration;
}

}
ShiroFilter二次配置（ShiroConfig）
/**
* shiroFilter核心配置
* @return
*/
@Bean
public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager, Config config){
ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();
factoryBean.setSecurityManager(securityManager);
putFilterChain(factoryBean);
// 后面在声明好pac4j提供的过滤器后
Map<String, Filter> filters = factoryBean.getFilters();
//1. 准备SecurityFilter
SecurityFilter securityFilter = new SecurityFilter();
securityFilter.setConfig(config);
securityFilter.setClients(clientName);
filters.put(“security”,securityFilter);

//2. 设置回调的拦截器
CallbackFilter callbackFilter = new CallbackFilter();
callbackFilter.setConfig(config);
callbackFilter.setDefaultUrl(casProjectUrl);
filters.put(“callback”,callbackFilter);

//3. 退出登录
LogoutFilter logoutFilter = new LogoutFilter();
logoutFilter.setConfig(config);
logoutFilter.setCentralLogout(true);
logoutFilter.setLocalLogout(true);
logoutFilter.setDefaultUrl(casProjectUrl + “/callback?client_name=” + clientName);
filters.put(“logout”,logoutFilter);

return factoryBean;
}

private void putFilterChain(ShiroFilterFactoryBean factoryBean) {
Map<String,String> filterChain = new LinkedHashMap<>();
// 后面在声明好pac4j提供的过滤器后，需要重新设置！

filterChain.put(“/test”,”security”);
filterChain.put(“/logout”,”logout”);
filterChain.put(“/callback”,”callback”);
filterChain.put(“/**”,”security”);
factoryBean.setFilterChainDefinitionMap(filterChain);
}

8.3.3 测试功能

编写了一个Controller，并且要求当前/test地址，必须认证后才可以访问。

访问/test资源后，直接跳转到了CAS登录页面
在CAS登录页面输入用户名和密码认证成功后，跳转到/test地址
再次访问/logout地址，发现退出登录成功后，留在了CAS的退出登录成功页面

希望退出登录后，跳转到登录页面，并且避免出现401问题

需要配置两处位置：

CASServer需要支持退出登录后的重定向
修改CasClient对象，页面在退出登录后，会出现401
public class CasClient extends org.pac4j.cas.client.CasClient {
public CasClient() {
super();
}

public CasClient(CasConfiguration configuration) {
super(configuration);
}

@Override
public RedirectAction getRedirectAction(final WebContext context) {
init();
AjaxRequestResolver ajaxRequestResolver = getAjaxRequestResolver();
RedirectActionBuilder redirectActionBuilder = getRedirectActionBuilder();
// it’s an AJAX request -> appropriate action
if (ajaxRequestResolver.isAjax(context)) {
logger.info(“AJAX request detected -> returning the appropriate action”);
RedirectAction action = redirectActionBuilder.redirect(context);
cleanRequestedUrl(context);
return ajaxRequestResolver.buildAjaxResponse(action.getLocation(), context);
}
// authentication has already been tried -> unauthorized
final String attemptedAuth = (String) context.getSessionStore().get(context, getName() + ATTEMPTED_AUTHENTICATION_SUFFIX);
if (CommonHelper.isNotBlank(attemptedAuth)) {
cleanAttemptedAuthentication(context);
cleanRequestedUrl(context);
// 跑抛出异常，页面401,只修改这个位置！！
// throw HttpAction.unauthorized(context);
return redirectActionBuilder.redirect(context);
}

return redirectActionBuilder.redirect(context);
}

private void cleanRequestedUrl(final WebContext context) {
SessionStore<WebContext> sessionStore = context.getSessionStore();
if (sessionStore.get(context, Pac4jConstants.REQUESTED_URL) != null) {
sessionStore.set(context, Pac4jConstants.REQUESTED_URL, “”);
}
}

private void cleanAttemptedAuthentication(final WebContext context) {
SessionStore<WebContext> sessionStore = context.getSessionStore();
if (sessionStore.get(context, getName() + ATTEMPTED_AUTHENTICATION_SUFFIX) != null) {
sessionStore.set(context, getName() + ATTEMPTED_AUTHENTICATION_SUFFIX, “”);
}
}
}
修改Pac4jConfig，将之前使用的默认CasClient更改为修改的这个！

一、现存问题

1.1 现存问题

1.2 Shiro框架介绍

二、Shiro的基本使用

2.1 SimpleAccountRealm

2.2 IniRealm

2.3 JdbcRealm

2.4 CustomRealm（自定义Realm）

三、Shiro的Web流程

四、Shiro整合Web（SpringMVC，SpringBoot）

4.1 SSM方式

4.2 SpringBoot方式

五、Shiro的授权方式

5.1 过滤器链

5.2 自定义过滤器

5.3 注解

5.4 标签（前端，不玩，JSP、Freemarker、Thymeleaf）

5.5 记住我

六、Shiro的分布式Session的处理

6.1 Shiro的Session管理

6.2 Shiro解决分布式Session

6.3 实现Shiro的分布式Session处理

6.4 RedisSessionDAO问题

七、Shiro的授权缓存

7.1 实现RedisCache

7.2 实现CacheManager并测试

八、Shiro整合CAS框架实现单点登录

8.1 单点登录

8.2 CAS介绍&搭建

8.2.1 CAS介绍

8.2.2 CAS搭建

8.2.3 CAS连接数据库认证

8.2.4 CAS实现对密码的加密&加盐

8.3 Shiro + pac4j + CAS

8.3.1 认证流程

8.3.2 构建项目并设置配置信息

8.3.3 测试功能

发表评论 取消回复

发表评论取消回复