DDD在实践过程中，如何实现如丝般顺滑的类目树管理？

/** * 值对象抽象类 * */ public abstract class ValueObject { } /** * 字段型值对象 * * 表示这个值对象会使用表字段来存储。 * * 并不总是表示一个单一的字段, 可能是多个字段组合而成。 * * 你可以把枚举也看做值对象，但enum是没法继承这个类的。 */ public abstract class FieldValueObject extends ValueObject { } /** * 对象关系映射型值对象 * * 表示这个值对象会使用关系数据库映射的方式来存储。 * 这里没有使用id，需要视情况而定 */ public abstract class OrmValueObject extends ValueObject { /** * 创建时间 */ protected Date created; /** * 更新时间 */ protected Date lastModified; }

/** * 实体抽象类 * 封装了所有实体的通用属性 */ public abstract class Entity { /** * id */ protected Long id; /** * 创建时间 */ protected Date created; /** * 更新时间 */ protected Date lastModified; /** * 是否逻辑删除 */ protected Boolean deleted; }

/** * 聚合根 */ public abstract class Aggregate extends Entity{ }

/** * 内容类目节点 * */ public class Category extends Entity { /** * 名称 */ private String name; /** * 层级, 0表示根 */ private Integer level; /** * 父节点id, 如果不存在则为0 */ private Long parentId; /** * 根节点id, 如果是根节点则是它本身 */ private Long rootId; /** * 内容类型 */ private ContentTypeEnum contentType; /** * 节点状态 * 0-下架，1上架 */ private CategoryStatusEnum status; /** * 节点顺序, 有小到大递增 */ private Integer index; /** * 节点路径, 不含它自己 * 用于冗余 */ private List<Long> path; public boolean isOff() { return status!=null && StringUtils.equals(status.getCode(), CategoryStatusEnum.OFF.getCode()); } public boolean isOn() { return status!=null && StringUtils.equals(status.getCode(), CategoryStatusEnum.ON.getCode()); } }

/** * 类目节点上的内容 * */ public class Content extends Entity { /** * 所属的类目id */ private Long categoryId; /** * 所属类目节点的根id, 用于冗余查询 */ private Long rootId; /** * 内容id */ private String contentId; /** * 内容类型 */ private ContentTypeEnum contentType; /** * 内容在类目树上的路径(id)，,用于冗余查询 */ private List<Long> path; }

@Repository public class CategoryRepository { @Resource private CategoryDAO categoryDAO; // 其他方法略 /** * 创建根节点 */ @Transactional(rollbackFor = Exception.class) public long addRoot(Category category) { CategoryDO categoryDO = CategoryConverter.toDO(category); categoryDAO.insert(categoryDO); categoryDAO.updateRootId(categoryDO.getId()); category.setId(categoryDO.getId()); return categoryDO.getId(); } }

/** * 类目树 - 聚合根 * 领域对象(树)的领域方法, 本身包含了操作节点的持久化管理, 即所有操作需要满足: * 对树及树的节点的操作, 内存中的对象必须和持久化的保持一致, 如果进行持久化, 内存中存在的也需要进行更新, 反之亦然 * * 使用树进行操作, 需要注意不要在同一个流程中对同一个对象混用树和repository进行操作, 否则会发生数据不一致 * */ public class CategoryTree extends Aggregate { /** * 类目树的根节点id */ final private long rootId; /** * 类目节点缓存 * 可能不是全部的节点都会缓存 * key: 节点id * value: 节点 */ final private Map<Long, Category> nodeMap = Maps.newHashMap(); /** * 节点仓储 */ final private CategoryRepository categoryRepository; /** * 节点内容仓储 */ final private ContentRepository contentRepository; /** * 节点并发锁 */ final private RedisLock redisLock; /** * 初始化, 数据懒加载 * * @param rootId * @param categoryRepository * @param classifiedContentRepository * @param redisLock */ public categoryTree(Long rootId, categoryRepository categoryRepository, ContentRepository contentRepository, RedisLock redisLock) { this.rootId = rootId; this.deleted = false; this.categoryRepository = categoryRepository; this.contentRepository = contentRepository; this.redisLock = redisLock; } // 领域方法, 见下文 ... ... }

@Service public class CategoryTreeFactory { @Resource private CategoryRepository categoryRepository; @Resource private ContentRepository contentRepository; @Resource private RedisLock redisLock; /** * 通过根构造(加载)树 * @param rootId * @return */ public ContentCategoryTree build(long rootId) { ContentCategory root = categoryRepository.loadOne(rootId); if(root == null) { throw new RuntimeException("根节点不存在"); } if(root.getRootId() != rootId) { throw new RuntimeException("rootId对应的节点不是根节点"); } return new CategoryTree(rootId, categoryRepository, contentRepository, redisLock); } /** * 通过节点构造(加载)类目树 * * @param categoryId * @return */ public CategoryTree buildByNode(long categoryId) { Category category = categoryRepository.loadOne(categoryId); if(category == null) { throw new RuntimeException("类目节点不存在"); } return build(category.getRootId()); } /** * 创建一个只有根的新树 * @param name * @param contentType * @return */ public CategoryTree buildNewTree(String name, ContentTypeEnum contentType) { int index = 1; Set<String> rootNameSet = Sets.newHashSet(); List<ContentCategory> roots = contentCategoryRepository.loadRoots(); if(!CollectionUtils.isEmpty(roots)) { // 获得新的根节点的顺序 index = roots.get(roots.size()-1).getIndex() + 1; roots.forEach(p->rootNameSet.add(p.getName())); } // 以后改成按类型名称排序 if(rootNameSet.contains(name)) { throw new RuntimeException("根节点名称重复"); } Category root = new Category(); root.setName(name); root.setStatus(CategoryStatusEnum.OFF); root.setContentType(contentType); root.setIndex(index); // 临时设置一个id，规避持久化问题 root.setRootId(CategoryConstant.ROOT_PARENT_ID); root.setParentId(CategoryConstant.ROOT_PARENT_ID); root.setLevel(CategoryConstant.ROOT_LEVEL); root.setDeleted(false); long rootId = categoryRepository.addRoot(root); return build(rootId); } }

/** * 类目操作方法接口 * 只适用于单个节点 * */ public interface CategorySingleOperation<R> { /** * 方法接口 * @return */ R process(); }

/**

• 类目操作方法接口
• 适用于遍历时的节点

/
public interface CategoryTraverseOperation {
/*
* 方法接口
* @return
*/
void process(Long categoryNodeId);
}

/** * 对一个节点进行操作模板方法 * @param func 具体的操作 * @param nodeId 节点id * @param withLock 是否加互斥锁 * @param <R> * @return */ private <R> R executeForOneNode(Long nodeId, boolean withLock, CategorySingleOperation<R> func) { Category node = nodeMap.get(nodeId); if(node == null) { node = categoryRepository.loadOne(nodeId); nodeMap.put(nodeId, node); } if(node == null) { throw new RuntimeException("待处理的节点不存在"); } if(withLock) { if(!redisLock.acquire(buildLockKey(nodeId), SystemConstants.CATEGORY_LOCK_TIME)) { throw new RuntimeException("并发锁获取失败"); } R r = func.process(); redisLock.release(buildLockKey(nodeId)); return r; } else { return func.process(); } } /** * 从一个节点开始, 自上而下逐层进行操作模板方法 * @param func 具体的操作 * @param nodeId 节点id * @param withLock 是否加互斥锁 * @return */ private void executeForDownUpByLevel(Long nodeId, boolean withLock, CategoryTraverseOperation func) { Category node = loadOne(nodeId); if(node == null) { throw new MeiJianException(PbdErrorCodeEnum.NO_DATA.getCode(), "节点不存在!"); } // 按层组装节点 LinkedList<Category> queueForTraverse = Lists.newLinkedList(); LinkedList<Long> stackForHandle = Lists.newLinkedList(); queueForTraverse.offer(node); while(!queueForTraverse.isEmpty()) { Category currentNode = queueForTraverse.poll(); stackForHandle.push(currentNode.getId()); List<Category> children = categoryRepository.loadByParentId(currentNode.getId()); if(!CollectionUtils.isEmpty(children)) { children.forEach(queueForTraverse::offer); } } // 自底向上处理 while(!stackForHandle.isEmpty()) { Long currentCategoryId = stackForHandle.pop(); if(withLock) { if(!redisLock.acquire(buildLockKey(nodeId), SystemConstants.CATEGORY_LOCK_TIME)) { throw new RuntimeException("并发锁获取失败"); } func.process(currentCategoryId); redisLock.release(buildLockKey(nodeId)); } else { func.process(currentCategoryId); } } }

/** * 增加类目节点, 序号为父节点下最大值 * @param parentId * @param name * @param contentType * @return */ public Long addContentCategory(Long parentId, String name, ContentTypeEnum contentType) { return executeForOneNode(parentId, true, () -> { int index = 0; Category parent = loadOne(parentId); List<Category> children = categoryRepository.loadByParentId(parent.getId()); if(!CollectionUtils.isEmpty(children)) { for(Category child: children) { if(child.getIndex() > index) { index = child.getIndex(); } } } index++; return categoryRepository.add(buildCategory(name, contentType, parent, index)); }); } /** * 删除节点及节点上的内容 * 为了防止脏数据, 从底向上删 * * @param categoryId */ public void deleteNodes(Long categoryId) { executeForDownUpByLevel(categoryId, false, currentCategoryId-> { contentRepository.deleteByCategoryId(currentCategoryId); categoryRepository.delete(currentCategoryId); }); }