Springboot2集成Shiro框架（九）配置多个realm

最新推荐文章于 2024-05-07 01:30:00 发布
最新推荐文章于 2024-05-07 01:30:00 发布
阅读量2.7k 收藏 21
点赞数 6
分类专栏： shiro SpringBoot 文章标签： shiro java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/New_Yao/article/details/100761408
版权

目录

1、使用场景

用户名和密码登录是一种非常常规的登录方式，但是随着手机的普及，越来越多的人采用手机号+验证码的登录方式，还有一些网站更是提供了邮箱、扫码登录等，面对一个个新增的登录方式，如何在不改变代码的情况下完成对登录方式的新增，shiro提供了多realm认证机制，我们可以利用shiro轻松的完成对一个项目的登录方式的新增、修改等。

2、多realm认证处理方式

2.1 两种认证方式

shiro给我们提供了两种认证方式,可以根据图片来理解，如下图，方式1可以理解为只要满足一个realm的条件验证即可完成登录，但是方式2则需要同时满足realm3和realm4两个的条件才可以通过登录验证，绝大部分场景是只需要方式1的，方式2用的不多，并且使用方式2会导致一个异常的问题，后续会贴出修复的方法代码。 我们只需要告诉shiro使用哪一个或者多个realm即可。
在这里插入图片描述

2.2 使用多realm时的认证策略

shiro在多个realm同时生效时提供了三种策略：

  1. AtLeastOneSuccessFulAtrategy 至少一个成功的策略-默认使用
  2. AllSuccessFulStrategy 全部成功策略
  3. FirstSuccessFulStrategy 第一个成功策略
    可以通过setAuthenticationStrategy方法设置策略

3、处理思路

之前的几章已经讲过shiro可拓展性非常好，那我们如果需要多个realm的话，只需要重写shiro自带的realm选择器，并且把自定义的选择器注入到SecurityManager中，应该就可以完成多realm的处理。

4、代码部分

4.1新建realm

4.1.1 自定义realm抽象类

因为每个realm都需要重写清除缓存的方法，因此新建了ParentRealm抽象类继承AuthorizingRealm

public abstract class ParentRealm extends AuthorizingRealm {

    /**
     * 重写方法,清除当前用户的的 授权缓存
     * 
     * @param principals
     */
    public void clearCachedAuthorizationInfo() {
        super.clearCachedAuthorizationInfo(SecurityUtils.getSubject().getPrincipals());
    }

    /**
     * 重写方法，清除当前用户的 认证缓存
     * 
     * @param principals
     */
    public void clearCachedAuthenticationInfo() {
        super.clearCachedAuthenticationInfo(SecurityUtils.getSubject().getPrincipals());
    }

    /**
     * 清除某个用户认证和授权缓存
     */
    @Override
    public void clearCache(PrincipalCollection principals) {
        super.clearCache(principals);
    }

    /**
     * 自定义方法：清除所有 授权缓存
     */
    public void clearAllCachedAuthorizationInfo() {
        getAuthorizationCache().clear();
    }

    /**
     * 自定义方法：清除所有 认证缓存
     */
    public void clearAllCachedAuthenticationInfo() {
        getAuthenticationCache().clear();
    }

    /**
     * 自定义方法：清除所有的 认证缓存 和 授权缓存
     */
    public void clearAllCache() {
        clearAllCachedAuthenticationInfo();
        clearAllCachedAuthorizationInfo();
    }

}
4.1.2新增其他的realm

1.RealmEmail

public class RealmEmail extends ParentRealm {
    @Autowired
    @Lazy
    UserService userService;

    /**
     * 权限设置
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        if (userService == null) {
            userService = (UserService) SpringBeanFactoryUtil.getBeanByName("userServiceImpl");
        }
        System.out.println("进入RealmEmail权限设置方法！");
        String username = (String) principals.getPrimaryPrincipal();
        // 从数据库或换村中获取用户角色信息
        User user = userService.findByEmail(username);
        // 获取用户角色
        Set<String> roles = user.getRole();
        // 获取用户权限
        Set<String> permissions = user.getPermission();
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        // 设置权限
        simpleAuthorizationInfo.setStringPermissions(permissions);
        // 设置角色
        simpleAuthorizationInfo.setRoles(roles);

        return simpleAuthorizationInfo;
    }

    /**
     * 身份验证
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        System.out.println("进入RealmEmail登录验证方法！");
        if (userService == null) {
            userService = (UserService) SpringBeanFactoryUtil.getBeanByName("userServiceImpl");
        }
        UsernamePasswordToken usernamePasswordToken = (UsernamePasswordToken) token;
        String username = usernamePasswordToken.getUsername();// 用户输入用户名
        User user = userService.findByEmail(username);// 根据用户输入用户名查询该用户
        if (user == null) {
            throw new UnknownAccountException();// 用户不存在
        }
        if("2".equals(user.getState())) {
            throw new LockedAccountException();
        }
        String password = user.getPassword();// 数据库获取的密码
        // 主要的（用户名，也可以是用户对象（最好不放对象）），资格证书(数据库获取的密码)，区域名称（当前realm名称）
        SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(username, password, getName());
        // 加盐，对比的时候会使用该参数对用户输入的密码按照密码比较器指定规则加盐，加密，再去对比数据库密文
        simpleAuthenticationInfo.setCredentialsSalt(ByteSource.Util.bytes(username));
        return simpleAuthenticationInfo;
    }

}

2.RealmPhone


public class RealmPhone extends ParentRealm {
    @Autowired
    @Lazy
    UserService userService;

    /**
     * 权限设置
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        if (userService == null) {
            userService = (UserService) SpringBeanFactoryUtil.getBeanByName("userServiceImpl");
        }
        System.out.println("进入RealmPhone权限设置方法！");
        String username = (String) principals.getPrimaryPrincipal();
        // 从数据库或换村中获取用户角色信息
        User user = userService.findByPhone(username);// 根据用户输入用户名查询该用户
        // 获取用户角色
        Set<String> roles = user.getRole();
        // 获取用户权限
        Set<String> permissions = user.getPermission();
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        // 设置权限
        simpleAuthorizationInfo.setStringPermissions(permissions);
        // 设置角色
        simpleAuthorizationInfo.setRoles(roles);
        return simpleAuthorizationInfo;
    }

    /**
     * 身份验证
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        if (userService == null) {
            userService = (UserService) SpringBeanFactoryUtil.getBeanByName("userServiceImpl");
        }
        System.out.println("进入RealmPhone登录验证方法！");
        UsernamePasswordToken usernamePasswordToken = (UsernamePasswordToken) token;
        String username = usernamePasswordToken.getUsername();// 用户输入用户名
        User user = userService.findByPhone(username);// 根据用户输入用户名查询该用户.
        if (user == null) {
            throw new UnknownAccountException();// 用户不存在
        }
        if("2".equals(user.getState())) {
            throw new LockedAccountException();
        }
        String password = user.getPassword();// 数据库获取的密码
        // 主要的（用户名，也可以是用户对象（最好不放对象）），资格证书(数据库获取的密码)，区域名称（当前realm名称）
        SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(username, password, getName());
        // 加盐，对比的时候会使用该参数对用户输入的密码按照密码比较器指定规则加盐，加密，再去对比数据库密文
        simpleAuthenticationInfo.setCredentialsSalt(ByteSource.Util.bytes(username));
        return simpleAuthenticationInfo;
    }

}

3.RealmUsername

public class RealmUsername extends ParentRealm {

    @Autowired
    @Lazy
    UserService userService;

    /**
     * 权限设置
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        if (userService == null) {
            userService = (UserService) SpringBeanFactoryUtil.getBeanByName("userServiceImpl");
        }
        System.out.println("进入RealmUsername权限设置方法！");
        String username = (String) principals.getPrimaryPrincipal();
        // 从数据库或换村中获取用户角色信息
        User user = userService.findByUsername(username);// 根据用户输入用户名查询该用户
        // 获取用户角色
        Set<String> roles = user.getRole();
        // 获取用户权限
        Set<String> permissions = user.getPermission();
        SimpleAuthorizationInfo simpleAuthorizationInfo = new SimpleAuthorizationInfo();
        // 设置权限
        simpleAuthorizationInfo.setStringPermissions(permissions);
        // 设置角色
        simpleAuthorizationInfo.setRoles(roles);
        return simpleAuthorizationInfo;
    }

    /**
     * 身份验证
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        if (userService == null) {
            userService = (UserService) SpringBeanFactoryUtil.getBeanByName("userServiceImpl");
        }
        System.out.println("进入RealmUsername自定义登录验证方法！");
        UsernamePasswordToken usernamePasswordToken = (UsernamePasswordToken) token;
        String username = usernamePasswordToken.getUsername();// 用户输入用户名
        User user = userService.findByUsername(username);// 根据用户输入用户名查询该用户
        if (user == null) {
            throw new UnknownAccountException();// 用户不存在
        }
        if ("2".equals(user.getState())) {
            throw new LockedAccountException();
        }
        String password = user.getPassword();// 数据库获取的密码
        // 主要的（用户名，也可以是用户对象（最好不放对象）），资格证书(数据库获取的密码)，区域名称（当前realm名称）
        SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(username, password, getName());
        // 加盐，对比的时候会使用该参数对用户输入的密码按照密码比较器指定规则加盐，加密，再去对比数据库密文
        simpleAuthenticationInfo.setCredentialsSalt(ByteSource.Util.bytes(username));
        return simpleAuthenticationInfo;
    }

}

4.2重写ModularRealmAuthenticator，自定义realm的使用


import java.util.ArrayList;
import java.util.Collection;

import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.pam.AuthenticationStrategy;
import org.apache.shiro.authc.pam.ModularRealmAuthenticator;
import org.apache.shiro.realm.Realm;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 自定义身份认证realm控制器
 * 
 * @ClassName: MyModularRealmAuthenticator
 * @Description 用于告诉shiro使用哪个realm处理
 * @version
 * @author JH
 * @date 2019年12月31日 下午4:19:13
 */
public class MyModularRealmAuthenticator extends ModularRealmAuthenticator {
    private static final Logger log = LoggerFactory.getLogger(ModularRealmAuthenticator.class);

    @Override
    protected AuthenticationInfo doAuthenticate(AuthenticationToken authenticationToken)
            throws AuthenticationException {
        // 判断getRealms()是否返回为空
        assertRealmsConfigured();
        // 强制转换回自定义的CustomizedToken
        MyUsernamePasswordToken userToken = (MyUsernamePasswordToken) authenticationToken;
        // 登录类型
        String loginType = userToken.getLoginType();
        // 所有Realm
        Collection<Realm> realms = getRealms();
        // 登录类型对应的所有Realm
        Collection<Realm> typeRealms = new ArrayList<>();
        for (Realm realm : realms) {
            if (realm.getName().contains(loginType)) {
                typeRealms.add(realm);
            }
        }

        // 判断是单Realm还是多Realm
        if (typeRealms.size() == 1) {
            //单realm处理
            return doSingleRealmAuthentication(((ArrayList<Realm>) typeRealms).get(0), userToken);
        } else {
            //多realm处理，需满足全部realm认证
            return doMultiRealmAuthentication(typeRealms, userToken);
        }
    }

    /**
     * 重写doMultiRealmAuthentication，修复多realm联合认证只出现AuthenticationException异常，而未处理其他异常
     */
    protected AuthenticationInfo doMultiRealmAuthentication(Collection<Realm> realms, AuthenticationToken token) throws AuthenticationException {

        AuthenticationStrategy strategy = getAuthenticationStrategy();

        AuthenticationInfo aggregate = strategy.beforeAllAttempts(realms, token);

        if (log.isTraceEnabled()) {
            log.trace("Iterating through {} realms for PAM authentication", realms.size());
        }

        for (Realm realm : realms) {

            aggregate = strategy.beforeAttempt(realm, token, aggregate);

            if (realm.supports(token)) {

                log.trace("Attempting to authenticate token [{}] using realm [{}]", token, realm);

                AuthenticationInfo info = null;
                Throwable t = null;
                try {
                    info = realm.getAuthenticationInfo(token);
                } catch (Throwable throwable) {
                    t = throwable;
                    if (log.isDebugEnabled()) {
                        String msg = "Realm [" + realm + "] threw an exception during a multi-realm authentication attempt:";
                        log.debug(msg, t);
                    }
                }
                //处理只提示AuthenticationException异常问题
                if(t instanceof AuthenticationException) {
                    log.debug("realmName:"+realm.getName(), t);
                    throw (AuthenticationException)t;
                }
                aggregate = strategy.afterAttempt(realm, token, info, aggregate, t);

            } else {
                log.debug("Realm [{}] does not support token {}.  Skipping realm.", realm, token);
            }
        }

        aggregate = strategy.afterAllAttempts(token, aggregate);

        return aggregate;
    }
}

4.3重写UsernamePasswordToken

新增loginType字段

public class MyUsernamePasswordToken extends UsernamePasswordToken {
    private static final long serialVersionUID = 1L;
    //登录类型
    private String loginType;

    public MyUsernamePasswordToken(String username, final String password, String loginType) {
        super(username, password);
        this.loginType = loginType;
    }

    public String getLoginType() {
        return loginType;
    }

    public void setLoginType(String loginType) {
        this.loginType = loginType;
    }

}

4.4 登录controller把loginType加入

 @RequestMapping("/login")
    public ReturnMap login(String username, Boolean rememberMe, String password, String loginType) {
        
        Subject subject = SecurityUtils.getSubject();
        MyUsernamePasswordToken token = new MyUsernamePasswordToken(username, password, loginType);
        
        if (rememberMe != null) {
            token.setRememberMe(rememberMe);
        }
        try {
            // 登录
            subject.login(token);
        } catch (UnknownAccountException uae) {
            // 用户名未知...
            return new ReturnMap().fail().message("用户不存在！");
        } catch (IncorrectCredentialsException ice) {
            // 凭据不正确，例如密码不正确 ...
            return new ReturnMap().fail().message("密码不正确！");
        } catch (LockedAccountException lae) {
            // 用户被锁定，例如管理员把某个用户禁用...
            return new ReturnMap().fail().message("用户被锁定！");
        } catch (ExcessiveAttemptsException eae) {
            // 尝试认证次数多余系统指定次数 ...
            return new ReturnMap().fail().message("尝试认证次数过多，请稍后重试！");
        } catch (AuthenticationException ae) {
            // 其他未指定异常
            return new ReturnMap().fail().message("未知异常！");
        }
        return new ReturnMap().success().data("登录成功！");
    }

4.5 模拟数据库数据处理



@Service
public class UserServiceImpl implements UserService {

    @Override
    public User findByUsername(String username) {
        User user = new User();
        if ("username".equals(username)) {
            Set<String> roleList = new HashSet<>();
            Set<String> permissionsList = new HashSet<>();
            roleList.add("admin");
            permissionsList.add("admin");
            user.setUsername("username");
            user.setPassword("b6d3d2a23b4d5e313d3f2efe3cda2614");
            user.setRole(roleList);
            user.setPermission(permissionsList);
            return user;
        } else {
            return null;
        }
    }

    @Override
    public User findByEmail(String email) {
        User user = new User();
        if ("email".equals(email)) {
            Set<String> roleList = new HashSet<>();// 角色
            Set<String> permissionsList = new HashSet<>();// 权限
            roleList.add("consumer");
            permissionsList.add("consumer");
            user.setUsername("email");
            user.setPassword("5fb06af6320cb2f9f090c4f9e1337ffb");
            return user;
        } else {
            return null;
        }
    }

    @Override
    public User findByPhone(String phone) {
        User user = new User();
        Set<String> roleList = new HashSet<>();// 角色
        Set<String> permissionsList = new HashSet<>();// 权限
        if ("phone".equals(phone)) {
            user.setUsername("guest");
            user.setPassword("94585d3850aa9fe1156d272ce3447a07");
            roleList.add("guest");
            permissionsList.add("guest");
            return user;
        } else {
            return null;
        }
    }

}

4.6把自定义的realm和MyModularRealmAuthenticator 注入SecurityManager

      /**
     * 自定义身份认证 realmEmail;
     * <p>
     * 必须写这个类，并加上 @Bean 注解，目的是注入 MyShiroRealm， 否则会影响 MyShiroRealm类 中其他类的依赖注入
     */
    @Bean
    public ParentRealm realmEmail() {
        RealmEmail myShiroRealm = new RealmEmail();
        // 设置密码比较器
        myShiroRealm.setCredentialsMatcher(CredentialsMatcher());
        // 启用身份验证缓存，即缓存AuthenticationInfo信息，默认false
        myShiroRealm.setAuthenticationCachingEnabled(true);
        // 启用授权缓存，即缓存AuthorizationInfo信息，默认false,一旦配置了缓存管理器，授权缓存默认开启
        myShiroRealm.setAuthorizationCachingEnabled(true);
        
        return myShiroRealm;
    }
    /**
     * 自定义身份认证 realmPhone;
     * <p>
     * 必须写这个类，并加上 @Bean 注解，目的是注入 MyShiroRealm， 否则会影响 MyShiroRealm类 中其他类的依赖注入
     */
    @Bean
    public ParentRealm realmPhone() {
        RealmPhone realmPhone = new RealmPhone();
        // 设置密码比较器
        realmPhone.setCredentialsMatcher(CredentialsMatcher());
        // 启用身份验证缓存，即缓存AuthenticationInfo信息，默认false
        realmPhone.setAuthenticationCachingEnabled(true);
        // 启用授权缓存，即缓存AuthorizationInfo信息，默认false,一旦配置了缓存管理器，授权缓存默认开启
        realmPhone.setAuthorizationCachingEnabled(true);
        
        return realmPhone;
    }
    /**
     * 自定义身份认证 realmUsername;
     * <p>
     * 必须写这个类，并加上 @Bean 注解，目的是注入 MyShiroRealm， 否则会影响 MyShiroRealm类 中其他类的依赖注入
     */
    @Bean
    public ParentRealm realmUsername() {
        RealmUsername realmUsername = new RealmUsername();
        // 设置密码比较器
        realmUsername.setCredentialsMatcher(CredentialsMatcher());
        // 启用身份验证缓存，即缓存AuthenticationInfo信息，默认false
        realmUsername.setAuthenticationCachingEnabled(true);
        // 启用授权缓存，即缓存AuthorizationInfo信息，默认false,一旦配置了缓存管理器，授权缓存默认开启
        realmUsername.setAuthorizationCachingEnabled(true);
        return realmUsername;
    }
    /**
     * 自定义身份认证realm控制器
     * @return
     */
    @Bean
    public ModularRealmAuthenticator myModularRealmAuthenticator(){
        //自定义身份认证realm控制器
        MyModularRealmAuthenticator modularRealmAuthenticator = new MyModularRealmAuthenticator();
        modularRealmAuthenticator.setAuthenticationStrategy(new AtLeastOneSuccessfulStrategy());
        return modularRealmAuthenticator;
    }
        /**
     * 注入 securityManager
     */
    @Bean
    public SecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setAuthenticator(myModularRealmAuthenticator());//配置自定义realm过滤器
        Set<Realm> realms  = new HashSet<>();
        realms.add(realmEmail());
        realms.add(realmPhone());
        realms.add(realmUsername());
        securityManager.setRealms(realms);;//配置自定义权限认证器
        securityManager.setRememberMeManager(rememberMeManager());//配置记住我管理器
        securityManager.setCacheManager(cacheManager());//配置缓存管理器
        return securityManager;
    }

5.测试

1.使用用户名密码登录方式，输入手机号的账号提示，后台进入用户名密码验证
在这里插入图片描述
2. 使用手机号码登录方式，提示登录成功
在这里插入图片描述

6.注意事项

6.1 realm分配方式

自定义realm分配器上面我们使用了类名包含LoginType的方式来判断使用哪个realm，因此需要规定前台logintype字段的值，才能正常使用。

6.2 多realm工作时抛出自定义异常获取不到的处理

在使用多realm同时生效时，使用AtLeastOneSuccessfulStrategy或者FirstSuccessFulStrategy策略，会导致无法抛出自定义异常而抛出AuthenticationException异常的问题，需要重写ModularRealmAuthenticator的doMultiRealmAuthentication方法，把catch捕获的异常抛出即可！

doMultiRealmAuthentication部分代码

try {
      info = realm.getAuthenticationInfo(token);
} catch (Throwable throwable) {//这里把所有异常捕获了但是并未抛出，导致继续运行
       t = throwable;
       if (log.isDebugEnabled()) {
           String msg = "Realm [" + realm + "] threw an exception during a multi-realm authentication attempt:";
       log.debug(msg, t);
  }
}

修改后

 try {
      info = realm.getAuthenticationInfo(token);
 } catch (Throwable throwable) {
      t = throwable;
      if (log.isDebugEnabled()) {
          String msg = "Realm [" + realm + "] threw an exception during a multi-realm authentication attempt:";
          log.debug(msg, t);
       }
 }
  //处理只提示AuthenticationException异常问题
   if(t instanceof AuthenticationException) {
       log.debug("realmName:"+realm.getName(), t);
       throw ((AuthenticationException)t);
   }

7、源码

New_Yao
关注
  • 6
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Shiro基本使用详解以及多Realm使用和配置.rar
08-09
Shiro基本使用详解以及多Realm使用和配置，拿来可以直接使用，也可以在此基础上进行自己业务逻辑的添加和修改，如果希望进一步深入学习，可以查看我的博客，可以查看https://blog.csdn.net/u014748504/article/details/107813181，或给我留言
Shiro实现多realm方案
程序员田同学的博客
07-02 2948
公司开始了新项目，新项目的认证采用的是Shiro实现。由于涉及到多端登录用户，而且多端用户还是来自不同的表。 这就涉及到了Shiro的多realm，今天的demo主要是介绍Shiro的多realm实现方案，文中包含所有的代码，需要的朋友可以无缝copy。...
Shiro——多个Realm的使用与实现
最新发布
程序员阿皓的博客
05-07 342
Shiro——多个Realm的使用与实现
Shiro系列（二）——Shiro 多 Realm 实现
玖涯博客
02-18 1250
写在前面 本文基于上一篇文章《 Shiro + Springboot + JWT 的整合》延续，示例项目也是在上篇文章的基础上扩展而来的。 一个系统一般都具有多种用户类型，如管理员、普通用户和运营者账号等，这些用户都存储在不同的表中。当然，通过对 Token 的内容进行条件判断，一个 Realm 是可以直接实现多个账号登录的，但是这样将导致不同用户的登录完全耦合在一起，这不是我们想看到的，所以有了多 Realm 的需求，并且 Shiro 是支持多 Realm 的。 1. 实现逻辑 1.1 分析 通过阅读 S
Shiro之多个Realm实现
qq_57907966的博客
12-26 421
实现原理：当应用程序配置多个Realm时，例如：用户名密码校验、手机验证码校验等等Shiro的ModularRealmAuthenticator会使用内部的AuthenticationStrategy组件判断认证成功还是失败。
Shiro【自定义Realm 、多Realm认证 、多Realm认证策略、异常处理】(二)-全面详解（学习总结---从入门到深化）
07-12 1250
Shiro【自定义Realm 、多Realm认证 、多Realm认证策略、异常处理】(二)-全面详解（学习总结---从入门到深化）
SpringBoot集成Shiro，并使用多个Realm，35岁程序员半月4轮面试
2401_83621004的博客
04-03 491
首先，我们先看Realm是怎么被执行的Realm是被一个名叫ModularRealmAuthenticator的类执行的具体细节如下//检验是否有Realm//获取所有的Realm//如果Realm只有1个，就只执行那一个，如果Realm有多个，全部都要执行自定义TokenShiro自带的UserNamePasswordToken感觉不太够用，因为下面我们要根据Token自带的属性进行区分，所以下面需要扩展UserNamePasswordToken。/***//**
Shiro实现多Realm认证、SecurityManager配置realms
Hern（宋兆恒）
09-04 2382
认证策略实际上是AuthenticationStrategy这个接口，它有三个实现： • AuthenticationStrategy 接口的默认实现： • FirstSuccessfulStrategy：只要有一个 Realm 验证成功即可，只返回第 一个 Realm 身份验证成功的认证信息，其他的忽略； • AtLeastOneSuccessfulStrategy：只要有一个Realm验...
Spring Boot（十一）Shiro 整合 配置多 Realm
好好学习 天天向上
07-08 359
import java.util.ArrayList; import java.util.Collection; import org.apache.shiro.authc.AuthenticationException; import org.apache.shiro.authc.AuthenticationInfo; import org.apache.shiro.authc.Authent...
SpringBoot整合Shiro多realm登录配置，另外附俩个教程
qq_35238997的博客
02-20 2154
SpringBoot整合Shiro，通过用户、角色、权限三者关联实现权限管理 本篇文章主要介绍 Shiro 多 realm，根据不同的登录类型指定不同的 realm。 所谓免密登录，就是区别正常的密码登录。比如，我现在要实现第三方登录，当验证了是李四，现在要让他通过 shiro 的 subject.login()，但是不知道他的密码(密码加密了)，我们不能拿数据库里的密码去登录，除非重新写 Rea...
shiro配置多个realm的方式
二十一克阳光！的博客
05-02 4162
当配置了多个Realm时，我们通常使用的认证器是shiro自带的org.apache.shiro.authc.pam.ModularRealmAuthenticator，其中决定使用的Realm的是doAuthenticate()方法 public class UserModularRealmAuthenticator extends ModularRealmAuthenticator { ...
shiro框架多realm权限认证配置
秋雨 De Blog
11-03 605
我们做shiro框架经常会遇到这种情况，用户数量很多，又不在同一个表里，比如管理员一个表，用户一个表，商家一个表。这时我们就需要用到多realm来配置让他们用不同得realm来进行权限认证
Spring Boot 集成Shiro的多realm实现以及shiro基本入门
weixin_41644145的博客
10-19 626
Spring Boot 集成Shiro的多realm实现以及shiro基本入门情景shiro的使用多realm实现原理多realm实现具体操作 情景 我的项目中有六个用户角色（学校管理员，学生等），需要进行分别登陆。如果在一个realm中，对controller封装好的Token进行Service验证，需要在此realm中注入六个数据库操作对象，然后写一堆if语句来判断应该使用那个Service服务，然后再在验证方法（doGetAuthorizationInfo）中写一堆if来进行分别授权，这样写不仅会让代
Spring Boot 集成Shiro的多realm配置
热门推荐
C.
03-20 1万+
我在做毕设的时候采用shiro进行登录认证和权限管理的实现。其中需求涉及使用三个角色分别是：学生、教师、管理员。现在要三者实现分开登录。即需要三个Realm——StudentRealm和TeacherRealm、AdminRealm，分别处理学生、教师和管理员的验证功能。 但是正常情况下，当定义了多个Realm，无论是学生登录，教师登录，还是管理员登录，都会由这三个Realm共同处理。这是因为，...
shiro框架多realm登录认证配置
秋雨 De Blog
11-03 1321
我们做shiro框架经常会遇到这种情况，用户数量很多，又不在同一个表里，比如管理员一个表，用户一个表，商家一个表。这时我们就需要用到多realm来配置让他们用不同得realm来进行登录
Shrio与SpringBoot整合（二）配置多个Realm
我是混IT圈的
12-10 1215
shrio与springboot的简单整合： 1、Spring Boot 与Shrio的简单整合，适合做单体项目 2、Shrio 的会话管理，可以用在前后端分离的项目 3、Shrio 使用redis做缓存 可以参考文章：Shrio与SpringBoot整合（一）_我是混IT圈的-CSDN博客 这里主要是Shiro配置多个Realm进行鉴权： 总共三个Reaml，分别是老师、家长、学生，其他老师是免密登录，家长和学生是账号密码登录。 Shrio配置的时候，这里没有配置密码加密，所以这里的账号密码
Shiro-多Realm验证
weixin_34341117的博客
01-08 570
2019独角兽企业重金招聘Python工程师标准>>> ...
SpringBoot 整合shiro实现多Realm的控制
yuemmm的博客
02-28 2122
文章目录SpringBoot 整合shiro实现多Realm的控制一、场景1、假设是让你设计这个表 你会怎么设计?2、管理员的表和用户的表 假设我们都使用shiro来进行认证 ? 怎么办?3、存在两个问题二、编写代码1、导包2、配置application.properies3、编写登陆页面4、编写user模块登陆成功的页面5、编写Admin模块登陆成功的页面6、编写登陆类型的枚举7、编写校验器...
SpringBoot集成Shiro，并使用多个Realm
GDUT_Trim的博客
04-26 795
Realm的执行自定义Token自定义ModularRealmAuthenticator创建多个RealmUserRealmManagerRealm和MerchantRealm配置ShiroConfig测试 Realm是用来做授权和认证的。 最近项目上有个需求是添加上一个新角色，导致要重写整个登录接口，又不太想修改原来的代码，看着那堆屎山就有点烦，所以就打算直接加一个Realm。 Realm的执行 首先，我们先看Realm是怎么被执行的 Realm是被一个名叫ModularRealmAuthenticat.
springboot集成shiro框架
06-28
Spring Boot 集成 Shiro 框架可以实现在应用中实现安全认证、权限控制等功能。下面是大致的集成步骤： 1. 添加 Shiro 依赖 在 `pom.xml` 文件中添加 Shiro 的依赖。可以选择适合自己项目的版本号。 ```xml ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值