Flowable源码注释（二十六）实体缓存类

Flowable源码地址：https://github.com/flowable/flowable-engine

Flowable-6.7.2 源码注释地址：https://github.com/solojin/flowable-6.7.2-annotated

包路径：org.flowable.common.engine.impl.persistence.cache

EntityCache 实体缓存接口类

/**
 * 这是在执行一个命令{@link命令}期间实体{@link Entity}实例的缓存.
 * 
 * @author Joram Barrez
 */
public interface EntityCache extends Session {

    /**
     * 以Map映射的形式返回所有缓存的实体{@link Entity}实例，其结构如下: { entityClassName, {entityId, entity} }
     */
    Map<Class<?>, Map<String, CachedEntity>> getAllCachedEntities();

    /**
     * 将实体{@link Entity}添加到缓存中。
     * 
     * @param entity
     *             实体{@link Entity} 实例
     * @param storeState
     *            如果为true，将存储当前状态{@link Entity#getPersistentState（）}，以备将来进行区分。请注意，如果为false，实体{@link Entity}将始终被视为已更改。
     * @return 返回一个缓存实体{@link CachedEntity}实例，稍后可以对其进行充实。
     */
    CachedEntity put(Entity entity, boolean storeState);

    /**
     * 使用提供的id返回给定类的缓存实体{@link Entity}实例。如果找不到这样的实体{@link Entity}，则返回null。
     */
    <T> T findInCache(Class<T> entityClass, String id);

    /**
     * 返回给定类型的所有缓存的实体{@link Entity}实例。 如果不存在给定类型的实例，则返回空列表。
     */
    <T> List<T> findInCache(Class<T> entityClass);

    /**
     * 返回给定类型的所有实体{@ link cachedential }实例。
     * 与{@link#findInCache（Class）}的不同之处在于，这里返回整个缓存实体{@link CachedEntity}，它允许访问将其放入缓存时的持久状态。
     */
    <T> Collection<CachedEntity> findInCacheAsCachedObjects(Class<T> entityClass);

    /**
     * 从缓存中删除具有给定id的给定类型的实体{@link Entity}。
     */
    void cacheRemove(Class<?> entityClass, String entityId);
}

EntityCacheImpl 实体缓存实现类

public class EntityCacheImpl implements EntityCache {

    protected Map<Class<?>, Map<String, CachedEntity>> cachedObjects = new HashMap<>();

    @Override
    public CachedEntity put(Entity entity, boolean storeState) {
        Map<String, CachedEntity> classCache = cachedObjects.get(entity.getClass());
        if (classCache == null) {
            classCache = new HashMap<>();
            cachedObjects.put(entity.getClass(), classCache);
        }
        CachedEntity cachedObject = new CachedEntity(entity, storeState);
        classCache.put(entity.getId(), cachedObject);
        return cachedObject;
    }

    @Override
    @SuppressWarnings("unchecked")
    public <T> T findInCache(Class<T> entityClass, String id) {
        CachedEntity cachedObject = null;
        Map<String, CachedEntity> classCache = cachedObjects.get(entityClass);

        if (classCache == null) {
            classCache = findClassCacheByCheckingSubclasses(entityClass);
        }

        if (classCache != null) {
            cachedObject = classCache.get(id);
        }

        if (cachedObject != null) {
            return (T) cachedObject.getEntity();
        }

        return null;
    }

    protected Map<String, CachedEntity> findClassCacheByCheckingSubclasses(Class<?> entityClass) {
        for (Class<?> clazz : cachedObjects.keySet()) {
            if (entityClass.isAssignableFrom(clazz)) {
                return cachedObjects.get(clazz);
            }
        }
        return null;
    }

    @Override
    public void cacheRemove(Class<?> entityClass, String entityId) {
        Map<String, CachedEntity> classCache = cachedObjects.get(entityClass);
        if (classCache == null) {
            return;
        }
        classCache.remove(entityId);
    }

    @Override
    public <T> Collection<CachedEntity> findInCacheAsCachedObjects(Class<T> entityClass) {
        Map<String, CachedEntity> classCache = cachedObjects.get(entityClass);
        if (classCache != null) {
            return classCache.values();
        }
        return null;
    }

    @Override
    @SuppressWarnings("unchecked")
    public <T> List<T> findInCache(Class<T> entityClass) {
        Map<String, CachedEntity> classCache = cachedObjects.get(entityClass);

        if (classCache == null) {
            classCache = findClassCacheByCheckingSubclasses(entityClass);
        }

        if (classCache != null) {
            List<T> entities = new ArrayList<>(classCache.size());
            for (CachedEntity cachedObject : classCache.values()) {
                entities.add((T) cachedObject.getEntity());
            }
            return entities;
        }

        return Collections.emptyList();
    }

    @Override
    public Map<Class<?>, Map<String, CachedEntity>> getAllCachedEntities() {
        return cachedObjects;
    }

    @Override
    public void close() {

    }

    @Override
    public void flush() {

    }
}