Shiro之多Realm篇

已于 2022-03-19 20:03:27 修改
阅读量325 收藏 1
点赞数
分类专栏： shiro 文章标签： shiro
于 2021-10-19 14:39:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43654581/article/details/120845511
版权

1、功能实现

定义两个Realm(User、Admin)，然后登录账号，分别认证、授权

2、shiro10 子工程

在这里插入图片描述

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>com.yzm</groupId>
        <artifactId>shiro</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <relativePath>../pom.xml</relativePath> <!-- lookup parent from repository -->
    </parent>

    <artifactId>shiro10</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
    <name>shiro10</name>
    <description>Demo project for Spring Boot</description>

    <dependencies>
        <dependency>
            <groupId>com.yzm</groupId>
            <artifactId>common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

application.yml

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://192.168.192.128:3306/testdb2?useUnicode=true&characterEncoding=utf8&useSSL=false&allowMultiQueries=true&zeroDateTimeBehavior=convertToNull&serverTimezone=Asia/Shanghai
    username: root
    password: 1234

mybatis-plus:
  mapper-locations: classpath:/mapper/*Mapper.xml
  type-aliases-package: com.yzm.shiro10.entity
  configuration:
    map-underscore-to-camel-case: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

3、定义UserRealm、AdminRealm

这两个Realm实现的方法内容大致一样，主要通过日志打印查看认证和授权的时候分别调用了什么Realm

package com.yzm.shiro10.config;

import com.yzm.shiro10.entity.Permissions;
import com.yzm.shiro10.entity.Role;
import com.yzm.shiro10.entity.User;
import com.yzm.shiro10.service.PermissionsService;
import com.yzm.shiro10.service.RoleService;
import com.yzm.shiro10.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;

import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * 自定义UserRealm 
 */
@Slf4j
public class UserRealm extends AuthorizingRealm {

    private final UserService userService;
    private final RoleService roleService;
    private final PermissionsService permissionsService;

    public UserRealm(UserService userService, RoleService roleService, PermissionsService permissionsService) {
        // 设置Realm名称
        setName("UserRealm");
        this.userService = userService;
        this.roleService = roleService;
        this.permissionsService = permissionsService;
    }

    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof CustomToken;
    }

    /**
     * 授权
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        log.info("User 授权");
        String username = (String) principalCollection.getPrimaryPrincipal();
        // 查询用户，获取角色ids
        User user = userService.lambdaQuery().eq(User::getUsername, username).one();
        List<Integer> roleIds = Arrays.stream(user.getRIds().split(","))
                .map(Integer::parseInt)
                .collect(Collectors.toList());

        // 查询角色，获取角色名、权限ids
        List<Role> roles = roleService.listByIds(roleIds);
        Set<String> roleNames = new HashSet<>(roles.size());
        Set<Integer> permIds = new HashSet<>();
        roles.forEach(role -> {
            roleNames.add(role.getRName());
            Set<Integer> collect = Arrays.stream(
                    role.getPIds().split(",")).map(Integer::parseInt).collect(Collectors.toSet());
            permIds.addAll(collect);
        });

        // 获取权限名称
        List<Permissions> permissions = permissionsService.listByIds(permIds);
        List<String> permNames = permissions.stream().map(Permissions::getPName).collect(Collectors.toList());

        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        authorizationInfo.addRoles(roleNames);
        authorizationInfo.addStringPermissions(permNames);
        return authorizationInfo;
    }

    /**
     * 认证
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        log.info("User 认证");
        // 获取用户名跟密码
        UsernamePasswordToken usernamePasswordToken = (UsernamePasswordToken) authenticationToken;
        String username = usernamePasswordToken.getUsername();

        // 查询用户是否存在
        User user = userService.lambdaQuery().eq(User::getUsername, username).one();
        if (user == null) {
            throw new UnknownAccountException();
        }

        return new SimpleAuthenticationInfo(
                user.getUsername(),
                user.getPassword(),
                // 用户名 + 盐
                ByteSource.Util.bytes(user.getUsername() + user.getSalt()),
                getName()
        );
    }
}


package com.yzm.shiro10.config;

import com.yzm.shiro10.entity.Permissions;
import com.yzm.shiro10.entity.Role;
import com.yzm.shiro10.entity.User;
import com.yzm.shiro10.service.PermissionsService;
import com.yzm.shiro10.service.RoleService;
import com.yzm.shiro10.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;

import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * 自定义AdminRealm 
 */
@Slf4j
public class AdminRealm extends AuthorizingRealm {

    private final UserService userService;
    private final RoleService roleService;
    private final PermissionsService permissionsService;

    public AdminRealm(UserService userService, RoleService roleService, PermissionsService permissionsService) {
        setName("AdminRealm");
        this.userService = userService;
        this.roleService = roleService;
        this.permissionsService = permissionsService;
    }

    @Override
    public boolean supports(AuthenticationToken token) {
        return token instanceof CustomToken;
    }

    /**
     * 授权
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        log.info("Admin 授权");
        String username = (String) principalCollection.getPrimaryPrincipal();
        // 查询用户，获取角色ids
        User user = userService.lambdaQuery().eq(User::getUsername, username).one();
        List<Integer> roleIds = Arrays.stream(user.getRIds().split(","))
                .map(Integer::parseInt)
                .collect(Collectors.toList());

        // 查询角色，获取角色名、权限ids
        List<Role> roles = roleService.listByIds(roleIds);
        Set<String> roleNames = new HashSet<>(roles.size());
        Set<Integer> permIds = new HashSet<>();
        roles.forEach(role -> {
            roleNames.add(role.getRName());
            Set<Integer> collect = Arrays.stream(
                    role.getPIds().split(",")).map(Integer::parseInt).collect(Collectors.toSet());
            permIds.addAll(collect);
        });

        // 获取权限名称
        List<Permissions> permissions = permissionsService.listByIds(permIds);
        List<String> permNames = permissions.stream().map(Permissions::getPName).collect(Collectors.toList());

        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        authorizationInfo.addRoles(roleNames);
        authorizationInfo.addStringPermissions(permNames);
        return authorizationInfo;
    }

    /**
     * 认证
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        log.info("Admin 认证");
        // 获取用户名跟密码
        String username = (String) authenticationToken.getPrincipal();
        //String password = new String((char[]) authenticationToken.getCredentials());

        // 查询用户是否存在
        User user = userService.lambdaQuery().eq(User::getUsername, username).one();
        if (user == null) {
            throw new UnknownAccountException();
        }

        return new SimpleAuthenticationInfo(
                user.getUsername(),
                user.getPassword(),
                // 用户名 + 盐
                ByteSource.Util.bytes(user.getUsername() + user.getSalt()),
                getName()
        );
    }
}

CustomToken 不同角色登录时，通过loginType来区分

package com.yzm.shiro10.config;

import org.apache.shiro.authc.UsernamePasswordToken;

public class CustomToken extends UsernamePasswordToken {
    private static final long serialVersionUID = 2496490278578779482L;
    private String loginType;

    public CustomToken(final String username, final String password) {
        super(username, password);
    }

    public CustomToken(final 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;
    }
}

LoginType 枚举

package com.yzm.shiro10.config;

public enum LoginType {
    USER("User"), ADMIN("Admin");

    private final String type;

    LoginType(String type) {
        this.type = type;
    }

    public String type() {
        return this.type;
    }
}

4、登录接口

修改登录接口，通过角色来决定不同的认证授权

package com.yzm.shiro10.controller;

import com.yzm.shiro10.config.CustomToken;
import com.yzm.shiro10.config.LoginType;
import com.yzm.shiro10.entity.User;
import com.yzm.shiro10.service.UserService;
import com.yzm.shiro10.utils.EncryptUtils;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class HomeController {

    private final UserService userService;

    public HomeController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping(value = {"/", "/home"})
    public String home(ModelMap map) {
        Subject subject = SecurityUtils.getSubject();
        map.addAttribute("subject", subject.getPrincipals());
        return "home";
    }

    @GetMapping("login")
    public String login() {
        return "login";
    }

    @GetMapping("401")
    public Object notRole() {
        return "401";
    }

    @PostMapping("register")
    public Object register(ModelMap map, @RequestParam String username, @RequestParam String password) {
        User user = new User();
        user.setUsername(username);
        user.setPassword(password);
        // 密码加密
        EncryptUtils.encryptPassword(user);
        userService.save(user);
        map.addAttribute("user", user);
        return "home";
    }

    @PostMapping("login")
    public Object login(@RequestParam String username, @RequestParam String password, boolean rememberMe) {
        UsernamePasswordToken token;
        if ("admin".equals(username)) {
            token = new CustomToken(username, password, LoginType.ADMIN.type());
        } else {
            token = new CustomToken(username, password, LoginType.USER.type());
        }
        token.setRememberMe(rememberMe);

        String url = "/home";
        try {
            Subject subject = SecurityUtils.getSubject();
            subject.login(token);
        } catch (IncorrectCredentialsException e) {
            url = "/login?failure";
        } catch (UnknownAccountException e) {
            url = "/login";
        }
        return "redirect:" + url;
    }

    @PostMapping("/logout")
    public Object logout() {
        Subject subject = SecurityUtils.getSubject();
        if (subject.isAuthenticated() || subject.isRemembered()) {
            subject.logout();
        }
        return "redirect:/login";
    }
}

5、多Realm认证

自定义MultiRealmAuthenticator，重写doAuthenticate

package com.yzm.shiro10.config;

import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.pam.ModularRealmAuthenticator;
import org.apache.shiro.realm.Realm;

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

/**
 * 自定义多领域认证器
 */
public class MultiRealmAuthenticator extends ModularRealmAuthenticator {

    @Override
    protected AuthenticationInfo doAuthenticate(AuthenticationToken authenticationToken) throws AuthenticationException {
        if (authenticationToken instanceof CustomToken) {
            assertRealmsConfigured();

            CustomToken customToken = (CustomToken) authenticationToken;

            // 根据登录类型选择对应的Realm
            Collection<Realm> typeRealms = new ArrayList<>();
            for (Realm realm : getRealms()) {
                if (realm.getName().contains(customToken.getLoginType())) typeRealms.add(realm);
            }

            return typeRealms.size() == 1 ?
                    this.doSingleRealmAuthentication(typeRealms.iterator().next(), authenticationToken) :
                    this.doMultiRealmAuthentication(typeRealms, authenticationToken);
        }
        return super.doAuthenticate(authenticationToken);
    }

}

6、多Realm授权

自定义MultiRealmAuthorizer，重写hasRole、isPermitted

package com.yzm.shiro10.config;

import org.apache.shiro.authz.Authorizer;
import org.apache.shiro.authz.ModularRealmAuthorizer;
import org.apache.shiro.realm.Realm;
import org.apache.shiro.subject.PrincipalCollection;

import java.util.Set;

/**
 * 自定义多领域授权器
 */
public class MultiRealmAuthorizer extends ModularRealmAuthorizer {

    @Override
    public boolean hasRole(PrincipalCollection principals, String roleIdentifier) {
        assertRealmsConfigured();

       // 当前登录人认证时使用的Realm名
        Set<String> realmNames = principals.getRealmNames();
        String realmName = realmNames.iterator().next();
        for (Realm realm : getRealms()) {
            if (!(realm instanceof Authorizer)) continue;
            // admin
            if (realmName.contains(LoginType.ADMIN.type()) && realm instanceof AdminRealm) {
                return ((AdminRealm) realm).hasRole(principals, roleIdentifier);
            }
            // user
            if (realmName.contains(LoginType.USER.type()) && realm instanceof UserRealm) {
                return ((UserRealm) realm).hasRole(principals, roleIdentifier);
            }
        }
        return false;
    }


    @Override
    public boolean isPermitted(PrincipalCollection principals, String permission) {
        assertRealmsConfigured();

        // 当前登录人认证时使用的Realm名
        Set<String> realmNames = principals.getRealmNames();
        String realmName = realmNames.iterator().next();
        for (Realm realm : getRealms()) {
            if (!(realm instanceof Authorizer)) continue;
            // admin
            if (realmName.contains(LoginType.ADMIN.type()) && realm instanceof AdminRealm) {
                return ((AdminRealm) realm).isPermitted(principals, permission);
            }
            // user
            if (realmName.contains(LoginType.USER.type()) && realm instanceof UserRealm) {
                return ((UserRealm) realm).isPermitted(principals, permission);
            }
        }
        return false;
    }
}

7、ShiroConfig 配置类

package com.yzm.shiro10.config;

import com.yzm.shiro10.service.PermissionsService;
import com.yzm.shiro10.service.RoleService;
import com.yzm.shiro10.service.UserService;
import com.yzm.shiro10.utils.EncryptUtils;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.apache.shiro.authc.pam.FirstSuccessfulStrategy;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.handler.SimpleMappingExceptionResolver;

import java.util.Arrays;
import java.util.Properties;

@Configuration
public class ShiroConfig {

    private final UserService userService;
    private final RoleService roleService;
    private final PermissionsService permissionsService;

    public ShiroConfig(UserService userService, RoleService roleService, PermissionsService permissionsService) {
        this.userService = userService;
        this.roleService = roleService;
        this.permissionsService = permissionsService;
    }

    /**
     * 凭证匹配器
     */
    @Bean
    public HashedCredentialsMatcher hashedCredentialsMatcher() {
        HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
        hashedCredentialsMatcher.setHashAlgorithmName(EncryptUtils.ALGORITHM_NAME);
        hashedCredentialsMatcher.setHashIterations(EncryptUtils.HASH_ITERATIONS);
        return hashedCredentialsMatcher;
    }

    /**
     * UserRealm
     */
    @Bean
    public UserRealm userRealm() {
        UserRealm userRealm = new UserRealm(userService, roleService, permissionsService);
        userRealm.setCredentialsMatcher(hashedCredentialsMatcher());
        return userRealm;
    }

    /**
     * AdminRealm
     */
    @Bean
    public AdminRealm adminRealm() {
        AdminRealm adminRealm = new AdminRealm(userService, roleService, permissionsService);
        adminRealm.setCredentialsMatcher(hashedCredentialsMatcher());
        return adminRealm;
    }

    /**
     * 安全管理
     */
    @Bean
    public SecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();

        // 自定义认证器、认证策略
        // FirstSuccessfulStrategy：只要有一个Realm验证成功即可，只返回第一个Realm身份验证成功的认证信息，其他的忽略；
        // AtLeastOneSuccessfulStrategy：只要有一个Realm验证成功即可，和FirstSuccessfulStrategy不同，返回所有Realm身份验证成功的认证信息；
        // AllSuccessfulStrategy：所有Realm验证成功才算成功，且返回所有Realm身份验证成功的认证信息，如果有一个失败就失败了。
        ModularRealmAuthenticator multiRealmAuthenticator = new MultiRealmAuthenticator();
        multiRealmAuthenticator.setAuthenticationStrategy(new FirstSuccessfulStrategy());
        securityManager.setAuthenticator(multiRealmAuthenticator);

        // 自定义授权器
        ModularRealmAuthorizer multiRealmAuthorizer = new MultiRealmAuthorizer();
        securityManager.setAuthorizer(multiRealmAuthorizer);

        // 多个Realm
        securityManager.setRealms(Arrays.asList(userRealm(), adminRealm()));
        return securityManager;
    }

    /**
     * 开启注解
     */
    @Bean
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator defaultAAP = new DefaultAdvisorAutoProxyCreator();
        defaultAAP.setProxyTargetClass(true);
        return defaultAAP;
    }

    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor() {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager());
        return authorizationAttributeSourceAdvisor;
    }

    @Bean
    public ShiroFilterFactoryBean shiroFilter() {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager());
        return shiroFilterFactoryBean;
    }

    /**
     * 问题：未登录不会自动跳转到登录页、无权访问页面不跳转
     * 原因：Shiro注解模式下，登录失败与没有权限都是通过抛出异常,并且默认并没有去处理或者捕获这些异常。
     * 解决：通过在SpringMVC下配置捕获相应异常来通知用户信息
     */
    @Bean
    public SimpleMappingExceptionResolver simpleMappingExceptionResolver() {
        SimpleMappingExceptionResolver simpleMappingExceptionResolver = new SimpleMappingExceptionResolver();
        Properties properties = new Properties();
        // 未登录访问接口跳转到/login、登录后没有权限跳转到/401
        properties.setProperty("org.apache.shiro.authz.UnauthenticatedException", "redirect:/login");
        properties.setProperty("org.apache.shiro.authz.UnauthorizedException", "redirect:/401");
        simpleMappingExceptionResolver.setExceptionMappings(properties);
        return simpleMappingExceptionResolver;
    }
}

8、测试

登录yzm，访问/user/**
在这里插入图片描述
登录admin，也是一样的
在这里插入图片描述

相关链接

首页
上一篇：整合JWT篇
下一篇：认证流程篇

yzm4399
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Shiro基本使用详解以及多Realm使用和配置.rar
08-09
Shiro基本使用详解以及多Realm使用和配置，拿来可以直接使用，也可以在此基础上进行自己业务逻辑的添加和修改，如果希望进一步深入学习，可以查看我的博客，可以查看https://blog.csdn.net/u014748504/article/details/107813181，或给我留言
【Shiro权限管理】11.Shiro多 Realm 验证
程序猿之洞
11-20 1848
注：该系列所有测试均在之前创建的Shiro3的Web工程的基础上。 上一篇讲解了Shiro的密码MD5加盐校验，下面来讲解Shiro的多Realm验证。 在我们之前的样例中，一直使用的是ShiroRealm来获取数据源中的账号密码封装信息的，而该 Realm配置在securityManager中 而在实际的业务场景中，会遇到安全数据存储在不同的数据库中的情况(例如
shiro注册登录流程（如何加密加盐）+配置多个Ream+密码加密验证底层分析+Remember使用+不同密码比对器原理（二）
weixin_43189971的博客
07-08 1850
1.shiro注册登录流程（如何加密加盐）+ 2.配置多个Ream 3.密码加密验证底层分析 4.Remember使用 5.不同密码比对器原理
SpringBoot集成Shiro，并使用多个Realm，35岁程序员半月4轮面试
2401_83621004的博客
04-03 446
首先，我们先看Realm是怎么被执行的Realm是被一个名叫ModularRealmAuthenticator的类执行的具体细节如下//检验是否有Realm//获取所有的Realm//如果Realm只有1个，就只执行那一个，如果Realm有多个，全部都要执行自定义TokenShiro自带的UserNamePasswordToken感觉不太够用，因为下面我们要根据Token自带的属性进行区分，所以下面需要扩展UserNamePasswordToken。/***//**
Shiro+Jwt实现多Realm跨域登录认证
木子人弋山
01-04 4835
因公司项目需求，做一个微服务项目，相比于单体架构，难免涉及到跨域登录的问题，你可能是在一个模块写了登录操作，但是其他模块的请求未进行拦截，或者是拦截了请求，老是提示未登录，这个时候就需要进行多realm登录认证(同事说security+Oauth2也可以解决，不过我对这个不是很熟悉，就用的shiro) 使用多Realm登录认证的时候首先要明白一个问题，什么时候走哪个realm，比如，用户直接登录...
【Shiro权限管理】9.Shiro密码加密匹配
程序猿之洞
11-04 9957
下面我们来说一下在Shiro中对密码的加密。我们知道线上系统的数据库中存储的密码不应该是 明文，而是密码加密后的字符串，并且要求加密算法是不可逆的。 著名的加密算法有MD5、SHA1等。其中MD5是目前比较可靠的不可逆的加密方式。 我们如何利用Shiro实现用户登录密码的MD5加密呢？这就需要让Shiro的自定义Realm去使用带有加密 机制的CredentialsMatcher密码匹
shiro教程之三自定义realm
oatmeal2015的博客
08-22 300
使用java以及ini文件来测试如何利用散列以及自定义匹配器来测试自定义realm以及如何使用自己的自定义匹配器 自定义realm的项目结构 1、自定义realm，继承 AuthorizingRealm 重写3方法：getName doGetAuthorizationInfo doGetAuthenticationInfo 自定义realm public class MyReal...
shiro实现不同身份使用不同Realm进行验证
热门推荐
Alan_Xiang的博客
02-01 3万+
假设现在有这样一种需求：存在两张表user和admin，分别记录普通用户和管理员的信息。并且现在要实现普通用户和管理员的分开登录，即需要两个Realm——UserRealm和AdminRealm，分别处理普通用户和管理员的验证功能。 　　但是正常情况下，当定义了两个Realm，无论是普通用户登录，还是管理员登录，都会由这两个Realm共同处理。这是因为，当配置了多个Realm时，我们通常使用的认证
Shiro不同身份多个Realm的问题及反思
大吉的博客
12-01 940
文章目录需求存在的问题解决方案 需求 我在做项目时（个人博客），分为前台登录（User）和后台登录（Admin），因此数据库存在两张表user和admin，分别记录普通用户和管理员的信息。并且现在要实现普通用户和管理员的分开登录，即需要两个Realm——UserRealm和AdminRealm，分别处理普通用户和管理员的验证功能。 　　但是问题在于，Shiro本身并不支持这样做，必须通过自定义Shiro的一些配置和扩展，才可以实现想要的功能。 存在的问题 我经过了全网搜寻，大致上的解决方案就是重写doAut
Spring Boot 集成Shiro的多realm配置
C.
03-20 1万+
我在做毕设的时候采用shiro进行登录认证和权限管理的实现。其中需求涉及使用三个角色分别是：学生、教师、管理员。现在要三者实现分开登录。即需要三个Realm——StudentRealm和TeacherRealm、AdminRealm，分别处理学生、教师和管理员的验证功能。 但是正常情况下，当定义了多个Realm，无论是学生登录，教师登录，还是管理员登录，都会由这三个Realm共同处理。这是因为，...
Shiro【自定义Realm 、多Realm认证 、多Realm认证策略、异常处理】(二)-全面详解（学习总结---从入门到深化）
07-12 1048
Shiro【自定义Realm 、多Realm认证 、多Realm认证策略、异常处理】(二)-全面详解（学习总结---从入门到深化）
shiro-realm案例
03-02
shiro自定义realm案例，参考文档：http://blog.csdn.net/qq_19558705/article/details/50775509
用于测试shiro中自定义Realm的测试代码
04-05
这个程序是eclipse编写的，学习shiro框架，入门的，用于测试自定义的Realm的小例子，仅仅用于学习，不得用于商业用途
shiro权限框架自定义Realm示例
09-10
shiro权限框架自定义Realm示例
shiro第六章Realm完整Demo
08-23
shiro第六章Realm完整Demo
IEC 60364-7-722-2018 低压电气装置.第7-722部分：特殊装置或场所的要求.电动车辆的电源.pdf
05-06
IEC 60364-7-722-2018 低压电气装置.第7-722部分：特殊装置或场所的要求.电动车辆的电源.pdf
eNSP软件安装及拓扑结构搭建.docx
最新发布
05-06
、eNSP的安装 1．安装eNSP之前必须先安装以下三个插件： VirtualBox WinPcap Wireshack eNSP作为模拟器主体，需要对应版本的VirtualBox和WinPcap提供虚拟环境，Wireshack用于实验当中测试抓取数据包使用。 安装好这三个插件，只需要点下一步选择好对应的安装位置即可，然后就可以安装eNSP软件了。 eNSP的页面
vmware虚拟机安装教程
05-06
附件是vmware虚拟机安装教程，文件绿色安全，请大家放心下载，仅供交流学习使用，无任何商业目的！
大屏网站粒子效果实现方式
05-06
大屏网站粒子效果实现方式
shiro多个realm
09-02
Shiro 支持在一个应用程序中同时使用多个 Realm 来进行身份认证和授权。这种情况通常发生在应用程序中存在多个身份验证和授权的方式，或者需要与多个用户存储系统进行交互的情况下。 要配置多个 Realm，你可以在 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值