Spring Shiro基础组件 PrincipalCollection

已于 2022-02-07 22:34:21 修改
阅读量1.3k 收藏 1
点赞数
分类专栏： Spring Shiro 文章标签： spring shiro
于 2022-02-03 23:01:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xing_hung/article/details/122753809
版权

相关阅读

简介

Subject关联的Principal集合；

核心方法

/**
 * 获取首要principal
 */
Object getPrimaryPrincipal();

/**
 * 获取满足指定类型的首个Principal
 */
<T> T oneByType(Class<T> type);

/**
 * 获取满足指定类型的所有principal
 */
<T> Collection<T> byType(Class<T> type);

/**
 * 将principal集合以List形式返回
 */
List asList();

/**
 * 将principal集合以Set形式返回
 */
Set asSet();

/**
 * 获取来自指定Realm的principal集合
 */
Collection fromRealm(String realmName);

/**
 * 获取Realm的集合
 */
Set<String> getRealmNames();

/**
 * principal集合是否为空
 */
boolean isEmpty();

实现子类

public interface PrincipalCollection extends Iterable, Serializable
    public interface MutablePrincipalCollection extends PrincipalCollection
        public class SimplePrincipalCollection implements MutablePrincipalCollection
    public interface PrincipalMap extends PrincipalCollection, Map<String,Object>
        public class SimplePrincipalCollection implements MutablePrincipalCollection

MutablePrincipalCollection

简介

扩展PrincipalCollection接口，支持修改；

核心方法

/**
 * 增加principal
 */
void add(Object principal, String realmName);

/**
 * 增加principal集合
 */
void addAll(Collection principals, String realmName);

/**
 * 增加principalCollection
 */
void addAll(PrincipalCollection principals);

/**
 * 清空所有principal
 */
void clear();

SimplePrincipalCollection

简介

内部使用LinkedHashMap存储Principal的MutablePrincipalCollection的简单实现；

核心方法

// 存储来自各个Realm的principal
private Map<String, Set> realmPrincipals;
// 缓存toString()的结果，日志中使用
private transient String cachedToString;

/**
 * 构造方法
 */
public SimplePrincipalCollection(Object principal, String realmName) {
    if (principal instanceof Collection) {
        // 添加principal集合
        addAll((Collection) principal, realmName);
    } else {
        // 添加单个principal
        add(principal, realmName);
    }
}

/**
 * 获取指定Realm的principal集合
 */
protected Collection getPrincipalsLazy(String realmName) {
    if (realmPrincipals == null) {
        // 如果还未初始化，则先初始化
        realmPrincipals = new LinkedHashMap<String, Set>();
    }
    Set principals = realmPrincipals.get(realmName);
    if (principals == null) {
        // 如果还不存在该Realm的principal集合，则先创建空principal集合
        principals = new LinkedHashSet();
        realmPrincipals.put(realmName, principals);
    }
    return principals;
}

/**
 * 获取首要principal
 */
public Object getPrimaryPrincipal() {
    if (isEmpty()) {
        return null;
    }
    // 返回首个principal
    // Realm的配置顺序很重要
    return iterator().next();
}

/**
 * 增加principal
 */
public void add(Object principal, String realmName) {
    // 校验Realm名称
    if (realmName == null) {
        throw new NullPointerException("realmName argument cannot be null.");
    }
    // 校验principal
    if (principal == null) {
        throw new NullPointerException("principal argument cannot be null.");
    }
    // 清除缓存结果
    this.cachedToString = null;
    // 添加该Realm的principal
    getPrincipalsLazy(realmName).add(principal);
}

/**
 * 增加principal集合
 */
public void addAll(Collection principals, String realmName) {
    // 校验Realm名称
    if (realmName == null) {
        throw new NullPointerException("realmName argument cannot be null.");
    }
    // 校验principals
    if (principals == null) {
        throw new NullPointerException("principals argument cannot be null.");
    }
    // 校验principals
    if (principals.isEmpty()) {
        throw new IllegalArgumentException("principals argument cannot be an empty collection.");
    }
    // 清除缓存结果
    this.cachedToString = null;
    // 添加该Realm的principal集合
    getPrincipalsLazy(realmName).addAll(principals);
}

/**
 * 增加principalCollection
 */
public void addAll(PrincipalCollection principals) {
    // 当principalCollection存在Realms
    if (principals.getRealmNames() != null) {
        for (String realmName : principals.getRealmNames()) {
            for (Object principal : principals.fromRealm(realmName)) {
                // 依次增加Realm的principal
                // 如果使用addAll(principals.fromRealm(realmName), realmName)，当存在空principal集合会抛出异常
                add(principal, realmName);
            }
        }
    }
}

/**
 * 获取满足指定类型的首个Principal
 */
public <T> T oneByType(Class<T> type) {
    // 校验principal集合
    if (realmPrincipals == null || realmPrincipals.isEmpty()) {
        return null;
    }
    Collection<Set> values = realmPrincipals.values();
    // 遍历各Realm下的所有principal
    for (Set set : values) {
        for (Object o : set) {
            // 类型判断
            if (type.isAssignableFrom(o.getClass())) {
                return (T) o;
            }
        }
    }
    return null;
}

/**
 * 获取满足指定类型的所有principal
 */
public <T> Collection<T> byType(Class<T> type) {
    // 校验principal集合
    if (realmPrincipals == null || realmPrincipals.isEmpty()) {
        return Collections.EMPTY_SET;
    }
    Set<T> typed = new LinkedHashSet<T>();
    Collection<Set> values = realmPrincipals.values();
    // 遍历各Realm下的所有principal
    for (Set set : values) {
        for (Object o : set) {
            // 类型判断
            if (type.isAssignableFrom(o.getClass())) {
                typed.add((T) o);
            }
        }
    }
    if (typed.isEmpty()) {
        return Collections.EMPTY_SET;
    }
    return Collections.unmodifiableSet(typed);
}

/**
 * 将principal集合以List形式返回
 */
public List asList() {
    // 先转换为Set形式
    Set all = asSet();
    if (all.isEmpty()) {
        return Collections.EMPTY_LIST;
    }
    // 转换成List形式
    return Collections.unmodifiableList(new ArrayList(all));
}

/**
 * 将principal集合以Set形式返回
 */
public Set asSet() {
    // 校验principal集合
    if (realmPrincipals == null || realmPrincipals.isEmpty()) {
        return Collections.EMPTY_SET;
    }
    // 使用LinkedHashSet保证原顺序
    Set aggregated = new LinkedHashSet();
    Collection<Set> values = realmPrincipals.values();
    for (Set set : values) {
        aggregated.addAll(set);
    }
    if (aggregated.isEmpty()) {
        return Collections.EMPTY_SET;
    }
    return Collections.unmodifiableSet(aggregated);
}

/**
 * 获取来自指定Realm的principal集合
 */
public Collection fromRealm(String realmName) {
    // 校验principal集合
    if (realmPrincipals == null || realmPrincipals.isEmpty()) {
        return Collections.EMPTY_SET;
    }
    Set principals = realmPrincipals.get(realmName);
    if (principals == null || principals.isEmpty()) {
        principals = Collections.EMPTY_SET;
    }
    return Collections.unmodifiableSet(principals);
}

/**
 * 获取Realm的集合
 */
public Set<String> getRealmNames() {
    // 校验principal集合
    if (realmPrincipals == null) {
        return null;
    } else {
        return realmPrincipals.keySet();
    }
}

/**
 * principal集合是否为空
 */
public boolean isEmpty() {
    return realmPrincipals == null || realmPrincipals.isEmpty();
}

/**
 * 清空所有principal
 */
public void clear() {
    // 清除缓存结果
    this.cachedToString = null;
    if (realmPrincipals != null) {
        realmPrincipals.clear();
        // 设置为null，便于垃圾回收
        realmPrincipals = null;
    }
}

/**
 * 返回principal集合的迭代器
 */
public Iterator iterator() {
    // 借助含有所有principal的不可变Set的迭代器
    return asSet().iterator();
}

PrincipalMap

简介

扩展PrincipalCollection接口，支持根据realmName和principalName查找Principal，内部使用HashMap存储来自不同Realm的所有Principal；
还处于实验中，暂时不能使用；

核心方法

/**
 * 获取指定Realm的principal集合
 */
Map<String,Object> getRealmPrincipals(String realmName);

/**
 * 设置指定Realm的principal集合
 */
Map<String,Object> setRealmPrincipals(String realmName, Map<String,Object> principals);

/**
 * 设置指定Realm的指定名称的principal
 */
Object setRealmPrincipal(String realmName, String principalName, Object principal);

/**
 * 获取指定Realm的指定名称的principal
 */
Object getRealmPrincipal(String realmName, String realmPrincipal);

/**
 * 移除指定Realm的指定principal
 */
Object removeRealmPrincipal(String realmName, String principalName);

SimplePrincipalMap

简介

PrincipalMap的默认实现；
还处于实验中，暂时不能使用；

核心方法

// 按照Realm分级存储所有principal
private Map<String, Map<String, Object>> realmPrincipals;
// principal集合
private Map<String, Object> combinedPrincipals;

/**
 * 构造方法
 */
public SimplePrincipalMap(Map<String, Map<String, Object>> backingMap) {
    if (!CollectionUtils.isEmpty(backingMap)) {
        this.realmPrincipals = backingMap;
        for (Map<String, Object> principals : this.realmPrincipals.values()) {
            if (!CollectionUtils.isEmpty(principals) ) {
                ensureCombinedPrincipals().putAll(principals);
            }
        }
    }
}

/**
 * 获取当前principal数量
 */
public int size() {
    return CollectionUtils.size(this.combinedPrincipals);
}

/**
 * 确保存储principal的Map有效
 */
protected Map<String, Object> ensureCombinedPrincipals() {
    if (this.combinedPrincipals == null) {
        this.combinedPrincipals = new HashMap<String, Object>();
    }
    return this.combinedPrincipals;
}

/**
 * 是否存在指定的principalName
 */
public boolean containsKey(Object o) {
    return this.combinedPrincipals != null && this.combinedPrincipals.containsKey(o);
}

/**
 * 是否存在指定的principal
 */
public boolean containsValue(Object o) {
    return this.combinedPrincipals != null && this.combinedPrincipals.containsKey(o);
}

/**
 * 获取指定的principal
 */
public Object get(Object o) {
    return this.combinedPrincipals != null && this.combinedPrincipals.containsKey(o);
}

/**
 * 设置指定的principal
 */
public Object put(String s, Object o) {
    return ensureCombinedPrincipals().put(s, o);
}

/**
 * 移除指定的principal
 */
public Object remove(Object o) {
    return this.combinedPrincipals != null ? this.combinedPrincipals.remove(o) : null;
}

/**
 * 添加principal集合
 */
public void putAll(Map<? extends String, ?> map) {
    if (!CollectionUtils.isEmpty(map)) {
        ensureCombinedPrincipals().putAll(map);
    }
}

/**
 * 获取所有的principalName
 */
public Set<String> keySet() {
    return CollectionUtils.isEmpty(this.combinedPrincipals) ?
            Collections.<String>emptySet() :
            Collections.unmodifiableSet(this.combinedPrincipals.keySet());
}

/**
 * 获取所有的principal
 */
public Collection<Object> values() {
    return CollectionUtils.isEmpty(this.combinedPrincipals) ?
            Collections.emptySet() :
            Collections.unmodifiableCollection(this.combinedPrincipals.values());
}

/**
 * 获取所有的principalName/principal健值对
 */
public Set<Entry<String, Object>> entrySet() {
    return CollectionUtils.isEmpty(this.combinedPrincipals) ?
            Collections.<Entry<String,Object>>emptySet() :
            Collections.unmodifiableSet(this.combinedPrincipals.entrySet());
}

/**
 * 清除数据
 */
public void clear() {
    this.realmPrincipals = null;
    this.combinedPrincipals = null;
}

/**
 * 获取首要principal
 */
public Object getPrimaryPrincipal() {
    //heuristic - just use the first one we come across:
    return !CollectionUtils.isEmpty(this.combinedPrincipals) ?
            this.combinedPrincipals.values().iterator().next() :
            null;
}

/**
 * 获取满足指定类型的首个Principal
 */
public <T> T oneByType(Class<T> type) {
    if (CollectionUtils.isEmpty(this.combinedPrincipals)) {
        return null;
    }
    for( Object value : this.combinedPrincipals.values()) {
        if (type.isInstance(value) ) {
            return type.cast(value);
        }
    }
    return null;
}

/**
 * 获取满足指定类型的所有principal
 */
public <T> Collection<T> byType(Class<T> type) {
    if (CollectionUtils.isEmpty(this.combinedPrincipals)) {
        return Collections.emptySet();
    }
    Collection<T> instances = null;
    for( Object value : this.combinedPrincipals.values()) {
        if (type.isInstance(value) ) {
            if (instances == null) {
                instances = new ArrayList<T>();
            }
            instances.add(type.cast(value));
        }
    }
    return instances != null ? instances : Collections.<T>emptyList();
}

/**
 * 将principal集合以List形式返回
 */
public List asList() {
    if (CollectionUtils.isEmpty(this.combinedPrincipals)) {
        return Collections.emptyList();
    }
    List<Object> list = new ArrayList<Object>(this.combinedPrincipals.size());
    list.addAll(this.combinedPrincipals.values());
    return list;
}

/**
 * 将principal集合以Set形式返回
 */
public Set asSet() {
    if (CollectionUtils.isEmpty(this.combinedPrincipals)) {
        return Collections.emptySet();
    }
    Set<Object> set = new HashSet<Object>(this.combinedPrincipals.size());
    set.addAll(this.combinedPrincipals.values());
    return set;
}

/**
 * 获取来自指定Realm的principal集合
 */
public Collection fromRealm(String realmName) {
    if (CollectionUtils.isEmpty(this.realmPrincipals)) {
        return Collections.emptySet();
    }
    Map<String,Object> principals = this.realmPrincipals.get(realmName);
    if (CollectionUtils.isEmpty(principals)) {
        return Collections.emptySet();
    }
    return Collections.unmodifiableCollection(principals.values());
}

/**
 * 获取Realm的集合
 */
public Set<String> getRealmNames() {
    if (CollectionUtils.isEmpty(this.realmPrincipals)) {
        return Collections.emptySet();
    }
    return Collections.unmodifiableSet(this.realmPrincipals.keySet());
}

/**
 * principal集合是否为空
 */
public boolean isEmpty() {
    return CollectionUtils.isEmpty(this.combinedPrincipals);
}

/**
 * 获取principal集合的迭代器
 */
public Iterator iterator() {
    return asList().iterator();
}

/**
 * 获取指定Realm的principal集合
 */
public Map<String, Object> getRealmPrincipals(String name) {
    if (this.realmPrincipals == null) {
        return null;
    }
    Map<String,Object> principals = this.realmPrincipals.get(name);
    if (principals == null) {
        return null;
    }
    return Collections.unmodifiableMap(principals);
}

/**
 * 设置指定Realm的principal集合
 */
public Map<String,Object> setRealmPrincipals(String realmName, Map<String, Object> principals) {
    if (realmName == null) {
        throw new NullPointerException("realmName argument cannot be null.");
    }
    if (this.realmPrincipals == null) {
        if (!CollectionUtils.isEmpty(principals)) {
            this.realmPrincipals = new HashMap<String,Map<String,Object>>();
            return this.realmPrincipals.put(realmName, new HashMap<String,Object>(principals));
        } else {
            return null;
        }
    } else {
        Map<String,Object> existingPrincipals = this.realmPrincipals.remove(realmName);
        if (!CollectionUtils.isEmpty(principals)) {
            this.realmPrincipals.put(realmName, new HashMap<String,Object>(principals));
        }
        return existingPrincipals;
    }
}

/**
 * 设置指定Realm的指定名称的principal
 */
public Object setRealmPrincipal(String realmName, String principalName, Object principal) {
    if (realmName == null) {
        throw new NullPointerException("realmName argument cannot be null.");
    }
    if (principalName == null) {
        throw new NullPointerException(("principalName argument cannot be null."));
    }
    if (principal == null) {
        return removeRealmPrincipal(realmName, principalName);
    }
    if (this.realmPrincipals == null) {
        this.realmPrincipals = new HashMap<String,Map<String,Object>>();
    }
    Map<String,Object> principals = this.realmPrincipals.get(realmName);
    if (principals == null) {
        principals = new HashMap<String,Object>();
        this.realmPrincipals.put(realmName, principals);
    }
    return principals.put(principalName, principal);
}

/**
 * 获取指定Realm的指定名称的principal
 */
public Object getRealmPrincipal(String realmName, String principalName) {
    if (realmName == null) {
        throw new NullPointerException("realmName argument cannot be null.");
    }
    if (principalName == null) {
        throw new NullPointerException(("principalName argument cannot be null."));
    }
    if (this.realmPrincipals == null) {
        return null;
    }
    Map<String,Object> principals = this.realmPrincipals.get(realmName);
    if (principals != null) {
        return principals.get(principalName);
    }
    return null;
}

/**
 * 移除指定Realm的指定principal
 */
public Object removeRealmPrincipal(String realmName, String principalName) {
    if (realmName == null) {
        throw new NullPointerException("realmName argument cannot be null.");
    }
    if (principalName == null) {
        throw new NullPointerException(("principalName argument cannot be null."));
    }
    if (this.realmPrincipals == null) {
        return null;
    }
    Map<String,Object> principals = this.realmPrincipals.get(realmName);
    if (principals != null) {
        return principals.remove(principalName);
    }
    return null;
}
我家有猫已长成
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
shiro与spring集成基础Hello案例详解
08-25
主要介绍了shiro与spring集成基础Hello案例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
spring shiro整合
11-10
运用了springmvc，mybatis shiro安全框架搭建及整合等技术
Realm及相关对象PrincipalCollection的方法
qq_42298793的博客
07-14 1013
Subject subject = SecurityUtils.getSubject(); //得到一个身份集合，其包含了Realm验证成功的身份信息 PrincipalCollection principalCollection = subject.getPrincipals(); Assert.assertEquals(2, principalCollection.asList().size()); protected AuthorizationInfo doGetAuthorizatio..
第六章 Realm及相关对象（四） PrincipalCollection
yifanSJ的博客
08-24 2万+
之前使用过的（来点印象） login("classpath:shiro-authenticator-all-success.ini"); Subject subject = SecurityUtils.getSubject(); //得到一个身份集合，其包含了Realm验证成功的身份信息 PrincipalCollection principalCollection = subject.getP
有关Shiro中Principal的使用
热门推荐
依木前行的博客
11-20 2万+
1、定义principal代表什么那？如果阅读官方文档或者源码你会得到如下的定义：解释： 1）可以是uuid 2）数据库中的主键 3）LDAP UUID或静态DN 4）在所有用户帐户中唯一的字符串用户名。也就是说这个值必须是唯一的。也可以是邮箱、身份证等值。1、用法 进入其构造方法public SimpleAuthenticationInfo(Object principal, Objec
Shiro 下的principal 注意
amd2015的博客
12-02 322
在用户登陆证realm 认证返回结果注意 return new SimpleAuthenticationInfo(sysUserDO,sysUserDO.getPassword(),ByteSource.Util.bytes(sysUserDO.getSalt()),getName()); 这里 sysUserDO 第一个参数可为用户名即 return new ...
springShiro.rar
08-23
shiroSpringmvc_demo
详解spring与shiro集成
08-29
主要介绍了详解spring与shiro集成,需要的朋友可以参考下
spring cloud + shiro集成方案
01-15
手把手教你集成spring cloud + shiro微服务框架；用最少的工作量，改造基于shiro安全框架的微服务项目，实现spring cloud + shiro 框架集成。博客地址：...
吃透Shiro源码2----PrincipalCollection、ThreadState
大宇的博客，欢迎访问
12-07 836
文章目录技术手法（1）工厂返回单例与多例（2）备忘录：如何保住旧对象状态？（3）集合如何懒加载重点研究类 技术手法 （1）工厂返回单例与多例 创建内部实例对象，如果是单例对象，那么就把创建出来的对象塞到singletonInstance中并返回这个单例对象。如果不是，那么就创建一个新对象给调用者 public abstract class AbstractFactory<T> ...
shiro页面标签shiro:principal的使用
落拓子ю的博客
08-22 1733
<%@ taglib prefix="shiro" uri="http://shiro.apache.org/tags" %> <shiro:principal property="name"/> 相当于((User)Subject.getPrincipals()).getName() <%@ taglib prefix=“shiro” uri=“http...
Shiro（二）一篇文章入门Shiro（入门篇）
qq_40634246的博客
03-07 177
话不多说，直接上代码。 认真观看代码，里面含有大量的注释 github上的代码，修改一下数据库的信息，就可以直接使用。附带sql文件 遗憾的是，没有实现RBAC github地址：https://github.com/ZiCheng-Web/springboot-shiro 0、创建springboot项目（springboot-shiro） 项目结构 1、修改pom.xml <?...
JAVA----自定义`＜shiro:principal＞` 内容
Damys
03-05 317
自定义内容<shiro:principal> 自定义字段内容 字段名最好与 User 实体一致 @Data public class UserPrincipal implements Serializable { private static final long serialVersionUID = 2784409120011781423L; private Integer id; private String username; private Strin
Shiro使用RedisTemplate缓存序列化失败SimplePrincipalCollection问题
Love_YJ4Ever的博客
05-27 952
问题描述 配置RedisTemplate序列化方式导致 Shiro 反序列化失败 @Bean("shiroTemplate") public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) { RedisTemplate<String, Object> template = new RedisTemplate<>(); template.
Shiro概述，简单使用
慢慢的博客
07-29 262
shiro的内部结构 Subject：主体，代表了当前“用户”，通过Subject与Shiro框架进行交互。 SecurityManager：安全管理器，Shiro框架的核心，负责调度整个框架的运行 。 Realm：域，Shiro从Realm获取安全数据（如用户、角色、权限），就是说SecurityManager要验证用户身份， 那么它需要从Realm获取相应的用户进行比较以确定用户身份是否...
Shiro----授权
qq_48788523的博客
01-12 2147
Shiro授权 , 各司其职 , 慢慢道来
spring shiro怎么用
最新发布
05-26
Spring Shiro是一种基于Spring框架和Apache Shiro安全框架的整合，用于简化Web应用程序的安全性集成。Spring Shiro提供了一组易于使用的API，可以轻松地将Shiro与Spring集成，从而实现诸如身份验证、授权、加密等安全功能。 下面是使用Spring Shiro进行身份认证和授权的步骤： 1. 引入Spring Shiro的相关依赖。 2. 配置ShiroFilterFactoryBean，用于拦截请求并进行身份认证和授权。 3. 配置SecurityManager，用于管理身份认证和授权。 4. 实现自定义Realm，用于获取用户身份信息和授权信息。 5. 在Web应用程序中使用Shiro注解进行权限控制。 如果您需要更详细的介绍和使用示例，请参考Spring Shiro官方文档：https://shiro.apache.org/spring.html

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值