吃透Shiro源码2----PrincipalCollection、ThreadState

技术手法

（1）工厂返回单例与多例

创建内部实例对象，如果是单例对象，那么就把创建出来的对象塞到singletonInstance中并返回这个单例对象。如果不是，那么就创建一个新对象给调用者

public abstract class AbstractFactory<T> 
           implements Factory<T> ...
   
    @Override
    public T getInstance() {
        T instance;
        if (isSingleton()) {
            //如果是单例的，创建单例对象
            if (this.singletonInstance == null) {
                this.singletonInstance = createInstance();
            }
            instance = this.singletonInstance;

        } else {
            //如果不是单例的，创建一个实例对象
            instance = createInstance();
        }

        //我自己写的时候，没有想到这一步
        //大佬的心思真细腻，再来一次健壮性判断
        //异常用了IllegalStateException
        if (instance == null) {
            String msg = "工厂返回了一个空的对象";
            throw new IllegalStateException(msg);
        }

        return instance;
    }

    protected abstract T createInstance();
}

（2）备忘录：如何保住旧对象状态？

如何保住对象的状态呢？备忘录设计模式的精髓就在于保住以前对象的状态。这里大佬提供了较为完整的实现代码，学到了。

public interface ThreadState {

    /**
     * 保存当前线程数据
     */
    void bind();

    /**
     * 恢复数据
     */
    void restore();

    /**
     * 清空数据
     */
    void clear();
}
public class SubjectThreadState implements ThreadState ...
    /**
     * 保存以前的Subject与SecurityManager
     * 然后把这个类中的Subject与SecurityManager绑定到当前线程
     */
    @Override
    public void bind() {
        SecurityManager securityManager = this.securityManager;
        if (securityManager == null) {
            //防止为空，从当前线程中再拿一次
            securityManager = ThreadContext.getSecurityManager();
        }
        //绑定当前线程中的Subject与SecurityManager到originResources
        this.originResources = ThreadContext.getResources();
        //清空当先线程
        ThreadContext.remove();

        //重新绑定
        ThreadContext.bind(this.subject);
        if (securityManager != null) {
            ThreadContext.bind(securityManager);
        }
    }
    @Override
    public void restore() {
        //先清空
        ThreadContext.remove();

        if(!CollectionUtils.isEmpty(this.originResources)){
             //把之前保存的对象再重新设置到当前线程中
            ThreadContext.setResources(this.originResources);
        }

    }

（3）集合如何懒加载

某个对象内部有一个private Map<String, Set> realmPrincipals;属性。需要在第一次添加数据的时候创建Set集合。这里提供了一种懒加载机制，非常值得借鉴

/**
     * 创建 realmName - Set 这种对象关联关系并添加进内部Map中
     * 最后返回Set对象引用方便操作
     * 添加新凭证到Set中
     *
     * @param realmName realmName
     * @return realmName对应的Set对象引用
     */
    protected Set getPrincipalsLazy(String realmName) {

        Set principalsFromRealm = this.realmPrincipals.get(realmName);

        if (principalsFromRealm == null) {
            principalsFromRealm = new LinkedHashSet();
            this.realmPrincipals.put(realmName, principalsFromRealm);
        }
        //返回此Set集合引用给调用者
        return principalsFromRealm;
    }

重点研究类

public interface ThreadState {


    /**
     * 绑定任何状态,应该可以在一个线程的执行
     */
    void bind();

    /**
     * 恢复一个线程绑定之前其状态
     */
    void restore();

    /**
     * Completely clears/removes the {@code ThreadContext} state
     */
    void clear();
}

package com.wise.security.subject.support;

import com.wise.security.mgt.SecurityManager;
import com.wise.security.subject.Subject;
import com.wise.security.util.CollectionUtils;
import com.wise.security.util.ThreadContext;
import com.wise.security.util.ThreadState;

import java.util.Map;

/**
 *
 * 当前类的作用：
 * 首先通过构造函数创建此对象,构造函数封装一个Subject对象
 * 通过Subject对象又拿到SecurityManager对象
 * 通过bind()将这组对象存放到此此对象的originResources中
 * 通过restore()清除ThreadContext中的resources，然后把originResources重新塞到ThreadContext中
 * 通过clear()方法删除ThreadContext中的Subject与SecurityManager对象
 *
 */
public class SubjectThreadState implements ThreadState {

    private final Subject subject;

    private SecurityManager securityManager;

    private Map<Object, Object> originResources;


    public SubjectThreadState(Subject subject) {


        if (subject == null) {
            throw new IllegalArgumentException("Subject参数不能为空");
        }

        this.subject = subject;

        SecurityManager securityManager = null;

        //todo:从Subject中生产SecurityManager
//        if ( subject instanceof DelegatingSubject) {
//            securityManager = ((DelegatingSubject)subject).getSecurityManager();
//        }

        if (securityManager == null) {
            securityManager = ThreadContext.getSecurityManager();
        }

        this.securityManager = securityManager;
    }

    /**
     * 保存以前的Subject与SecurityManager
     * 然后把这个类中的Subject与SecurityManager绑定到当前线程
     */
    @Override
    public void bind() {
        SecurityManager securityManager = this.securityManager;

        if (securityManager == null) {
            //防止为空，从当前线程中再拿一次
            securityManager = ThreadContext.getSecurityManager();
        }
        //绑定当前线程中的Subject与SecurityManager到originResources
        this.originResources = ThreadContext.getResources();
        //清空当先线程
        ThreadContext.remove();

        //重新绑定
        ThreadContext.bind(this.subject);
        if (securityManager != null) {
            ThreadContext.bind(securityManager);
        }
    }


    /**
     * 之前的Subject与SecurityManager被存放到了originResources里面
     * 如果没有originResources，说明之前就没调用bind()方法绑定
     * @see #bind()
     */
    @Override
    public void restore() {
        //先清空
        ThreadContext.remove();

        if(!CollectionUtils.isEmpty(this.originResources)){
            ThreadContext.setResources(this.originResources);
        }

    }

    /**
     * 清除当前线程中存放的SecurityManager与Subject
     */
    @Override
    public void clear() {
        ThreadContext.remove();
    }

    protected Subject getSubject() {
        return this.subject;
    }
}

package com.wise.security.subject;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Set;

public interface PrincipalCollection extends Iterable, Serializable {

    /**
     * 返回主凭证
     * <p>
     * 返回主应用程序主要用来唯一地标识拥有账户或Subject
     *
     * @return
     */
    Object getPrimaryPrincipal();

    /**
     * 返回指定类型的第一个凭证，返回指定类型
     *
     * @param type 指定类型
     * @param <T>  泛型
     * @return 指定类型的凭证
     */
    <T> T oneByType(Class<T> type);

    /**
     * 返回指定类型的所有凭证
     *
     * @param type 指定类型
     * @param <T>  泛型
     * @return 指定类型的所有凭证
     */
    <T> Collection<T> byType(Class<T> type);


    /**
     * 所有凭证作为List
     *
     * @return 所有凭证
     */
    List asList();

    /**
     * 所有凭证作为Set
     *
     * @return 所有凭证
     */
    Set asSet();


    /**
     * 从指定Realm中返回主凭证
     *
     * @param realName realm名称
     * @return 主凭证
     */
    Collection fromRealm(String realName);

    /**
     * 返回提供了凭证的Realm对象们的Names
     *
     * @return 提供了凭证的Realm对象们的Names
     */
    Set<String> getRealmNames();


    /**
     * 是否有凭证
     *
     * @return 是否有凭证
     */
    boolean isEmpty();

}

package com.wise.security.subject;

import java.util.Collection;

/**
 * 可变的凭证集合
 */
public interface MutablePrincipalCollection extends PrincipalCollection {


    /**
     * 添加一个凭证
     *
     * @param principal 凭证对象
     * @param realmName realmName
     */
    void add(Object principal, String realmName);


    /**
     * 添加所有的凭证
     *
     * @param principals
     */
    void addAll(PrincipalCollection principals);

    /**
     * 添加所有的凭证集合
     *
     * @param principals 凭证集合
     * @param realmName  这些凭证的realm来源
     */
    void addAll(Collection principals, String realmName);

    /**
     * 删除所有凭证
     */
    void clear();
}

package com.wise.security.subject;

import com.wise.security.util.CollectionUtils;

import java.util.*;

@SuppressWarnings({"unchecked"})
public class SimplePrincipalCollection implements MutablePrincipalCollection {

    /**
     * 字符串(realm)对应一批Set (Principal)
     */
    private Map<String, Set> realmPrincipals;

    private String cachedToString;

    public SimplePrincipalCollection() {

        //fromRealm()方法可能报空指针，因此用这个
        realmPrincipals = new LinkedHashMap<>();
    }

    public SimplePrincipalCollection(Object principal, String realmName) {
        if (principal == null) {
            throw new IllegalArgumentException("principal is null");
        }

        if (realmName == null) {
            throw new IllegalArgumentException("realmName is null");
        }

        add(principal, realmName);
    }

    public SimplePrincipalCollection(Collection principals, String realmName) {
        addAll(principals, realmName);
    }

    public SimplePrincipalCollection(PrincipalCollection principals) {
        addAll(principals);
    }


    @Override
    public Object getPrimaryPrincipal() {
        if (isEmpty()) {
            return null;
        }

        return iterator().next();
    }

    @Override
    public <T> T oneByType(Class<T> type) {
        if (type == null) {
            return null;
        }
        //获取所有凭证
        List principals = asList();
        for (Object principal : principals) {
            if (type.isAssignableFrom(principal.getClass())) {
                return (T) principal;
            }
        }
        return null;
    }

    @Override
    public <T> Collection<T> byType(Class<T> type) {
        if (type == null) {
            return null;
        }
        //获取所有凭证
        List principals = asList();

        LinkedHashSet result = new LinkedHashSet();
        for (Object principal : principals) {
            if (type.isAssignableFrom(principal.getClass())) {
                result.add(principal);
            }
        }
        return result;
    }

    @Override
    public List asList() {
        Set allPrincipals = asSet();
        if (CollectionUtils.isEmpty(allPrincipals)) {
            return Collections.EMPTY_LIST;
        }

        return Collections.unmodifiableList(new ArrayList(allPrincipals));

    }

    @Override
    public Set asSet() {

        if (this.realmPrincipals == null || this.realmPrincipals.isEmpty()) {
            return Collections.EMPTY_SET;
        }

        //获取Map中所有的凭证Set集合
        Collection<Set> allPrincipalSet = this.realmPrincipals.values();

        Set result = new LinkedHashSet();
        for (Set principals : allPrincipalSet) {
            result.addAll(principals);
        }

        if (result.isEmpty()) {
            return Collections.EMPTY_SET;
        }
        //返回不可修改的视图
        return Collections.unmodifiableSet(result);
    }

    @Override
    public Collection fromRealm(String realName) {

        if (CollectionUtils.isEmpty(this.realmPrincipals)) {
            return Collections.EMPTY_SET;
        }

        Set principals = this.realmPrincipals.get(realName);
        //如果是空，返回空集合。
        if (CollectionUtils.isEmpty(principals)) {
            principals = Collections.EMPTY_SET;
        }
        //返回一个不可修改的凭证视图
        return Collections.unmodifiableSet(principals);
    }

    @Override
    public Set<String> getRealmNames() {

        if (CollectionUtils.isEmpty(this.realmPrincipals)) {
            return Collections.EMPTY_SET;
        }

        return Collections.unmodifiableSet(this.realmPrincipals.keySet());
    }

    @Override
    public boolean isEmpty() {
        return this.realmPrincipals == null || this.realmPrincipals.isEmpty();
    }

    @Override
    public Iterator iterator() {
        return asSet().iterator();
    }

    @Override
    public void add(Object principal, String realmName) {
        if (principal == null) {
            throw new IllegalArgumentException("principal is null");
        }

        if (realmName == null) {
            throw new IllegalArgumentException("realmName is null");
        }

        //???
        this.cachedToString = null;

        //内部的realmPrincipals Map 可能没有初始化.
        Set principals = getPrincipalsLazy(realmName);
        principals.add(principal);
    }

    @Override
    public void addAll(PrincipalCollection principals) {
        //获取所有的realmNames
        Set<String> realmNames = principals.getRealmNames();

        for (String realmName : realmNames) {
            //找到此realm对应的Set凭证
            Collection set = fromRealm(realmName);
            addAll(set, realmName);
        }
    }

    @Override
    public void addAll(Collection principals, String realmName) {

        if (realmName == null) {
            throw new IllegalArgumentException("realmName is null");
        }

        if (principals == null) {
            throw new IllegalArgumentException("principals is null");
        }

        if (principals.isEmpty()) {
            throw new IllegalArgumentException("principals is empty collection");
        }

        //???
        this.cachedToString = null;

        Set principalSet = getPrincipalsLazy(realmName);
        principalSet.addAll(principals);
    }

    @Override
    public void clear() {
        this.cachedToString = null;
        if (!CollectionUtils.isEmpty(this.realmPrincipals)) {
            //realmPrincipals是一个map集合，调用clear方法清空数据
            this.realmPrincipals.clear();
            this.realmPrincipals = null;
        }
    }

    /**
     * 创建 realmName - Set 这种对象关联关系并添加进内部Map中
     * 最后返回Set对象引用方便操作
     * 添加新凭证到Set中
     *
     * @param realmName realmName
     * @return realmName对应的Set对象引用
     */
    protected Set getPrincipalsLazy(String realmName) {

        Set principalsFromRealm = this.realmPrincipals.get(realmName);

        if (principalsFromRealm == null) {
            principalsFromRealm = new LinkedHashSet();
            this.realmPrincipals.put(realmName, principalsFromRealm);
        }
        //返回此Set集合引用给调用者
        return principalsFromRealm;
    }
}