Java實現DDD中UnitOfWork

時間 2020-05-21

標籤 java 實現 ddd unitofwork 欄目 Java 简体版

原文原文鏈接

Java實現DDD中UnitOfWork

背景

Maintains a list of objects affected by a business transaction and coordinates the writing out of changes and the resolution of concurrency problems.
Unit of Work --Martin Fowler
Unit Of Work模式，由馬丁大叔提出，是一種數據訪問模式。UOW模式的做用是在業務用例的操做中跟蹤對象的全部更改（增長、刪除和更新），並將全部更改的對象保存在其維護的列表中。在業務用例的終點，經過事務，一次性提交全部更改，以確保數據的完整性和有效性。總而言之，UOW協調這些對象的持久化及併發問題。html

Uow的本質

UOW跟蹤變化
UOW維護了一個變動列表
UOW將跟蹤到的已變動的對象保存到變動列表中
UOW藉助事務一次性提交變動列表中的全部更改
UOW處理併發

對於以上這些點，在C#的EF框架中，DBContext已經實現。
而這裏主要描述如何用java實現以上要點。java

Repository

將倉儲Repo做爲聚合的範型類
在Repo中維護一個聚合與聚合狀態的集合
在Repo中每次add/update/delete等操做時，將操做的聚合對象，和其最終狀態存入集合中
在Repo中的retrieve方法，將聚合檢索出來並存入Repo的集合中
代碼以下：

public class RepositoryBase<T extends IBusinessObjectRoot> implements IRepository<T> {

    private HashMap<IBusinessKey, RepositoryComponent<T>> map = new HashMap<IBusinessKey, RepositoryComponent<T>>();

    private Class<T> tClass;

    public RepositoryBase(Class<T> tClass) {
        RepositoryThreadLocalHelper.newInstance().put(tClass.getSimpleName(), this);
        this.tClass = tClass;
    }

    public void add(T t) {
        IBusinessKey bk = t.getBusinessKey();
        if (map.containsKey(bk) && RepositoryComponentState.DELETED.equals(map.get(bk).getState())) {
            map.put(bk, new RepositoryComponent<T>(t, RepositoryComponentState.UNCHANGED));
        } else {
            map.put(bk, new RepositoryComponent<T>(t, RepositoryComponentState.ADDED));
        }
    }

    public void update(T t) {
        IBusinessKey bk = t.getBusinessKey();
        if (map.containsKey(bk) && RepositoryComponentState.ADDED.equals(map.get(bk).getState())) {
            map.put(bk, new RepositoryComponent<T>(t, RepositoryComponentState.ADDED));
        } else {
            map.put(bk, new RepositoryComponent<T>(t, RepositoryComponentState.MODIFIED));
        }
    }

    public void delete(IBusinessKey bk) {
        if (map.containsKey(bk) && RepositoryComponentState.ADDED.equals(map.get(bk).getState())) {
            map.get(bk).setState(RepositoryComponentState.UNCHANGED);
        } else {
            map.put(bk, new RepositoryComponent<T>(retrieve(bk), RepositoryComponentState.DELETED));
        }
    }

    public void delete(T t) {
        IBusinessKey bk = t.getBusinessKey();
        if (map.containsKey(bk) && RepositoryComponentState.ADDED.equals(map.get(bk).getState())) {
            map.get(bk).setState(RepositoryComponentState.UNCHANGED);
        } else {
            map.put(bk, new RepositoryComponent<T>(t, RepositoryComponentState.DELETED));
        }
    }

    public T retrieve(IBusinessKey bk) {
        if (map.containsKey(bk)) {
            return map.get(bk).getT();
        } else {
            RepositoryBuilder<T> builder = new RepositoryBuilder<T>();
            T t = builder.buildBo(tClass, bk);
            map.put(bk, new RepositoryComponent<T>(t, RepositoryComponentState.UNCHANGED));
            return t;
        }
    }
}

RepositoryComponentState

聚合存在於內存中的狀態，主要分爲如下5個狀態

Added	4	
The entity is being tracked by the context but does not yet exist in the database.
Deleted	2	
The entity is being tracked by the context and exists in the database. It has been marked for deletion from the database.
Detached	0	
The entity is not being tracked by the context.
Modified	3	
The entity is being tracked by the context and exists in the database. Some or all of its property values have been modified.
Unchanged	1	
The entity is being tracked by the context and exists in the database. Its property values have not changed from the values in the database.

Uow

增長自定義註解UowTransaction

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface UowTransaction {
}

增長註解切面，在所註解的方法上執行完畢後調用uowService.saveChange()

@Slf4j
@Component
public class UowService {

    @Transaction
    public void saveChange() {
        SqlSessionFactory factory = (SqlSessionFactory) SpringContextUtil.getBean("sqlSessionFactory");
        SqlSession session = factory.openSession();

        Collection<IRepository> repos = RepositoryThreadLocalHelper.newInstance().getRepositories();
        for (IRepository repo : repos) {
            repo.flushDb(session);
        }
    }
}

RepositoryFlush

flushDb時將內存中的聚合集合統一刷新入數據庫
flushAdd：將聚合從聚合根到全部子節點依次入庫
flushModify：更改數據庫聚合時，先檢索出數據庫中原聚合originEntity，而後將原聚合與更改後聚合依次對比，子節點中根據對比內容作新增/刪除/修改
flushDelete：將聚合從聚合根到全部子節點依次刪除
具體參考代碼以下：

@Slf4j
public class RepositoryFlush {

    private SqlSession session;
    private RepositoryConfigHelper configHelper = new RepositoryConfigHelper();

    RepositoryFlush(SqlSession session) {
        this.session = session;
    }

    void flushAdd(IBusinessEntity bo) {
        RepositoryConfig repoConfig = configHelper.getRepositoryConfig(bo);
        //bo->do
        Object dataObject = TypeConversion.unWrapPrimitiveType(bo, repoConfig.getEntityClass());
        BaseMapper mapper = this.session.getMapper(repoConfig.getEntityMapperClass());

        mapper.insert(dataObject);

        List<String> childNames = BusinessObjectManager.getEntityNamesByComposition(
                bo.getBusinessObjectRoot().getArtifactName(),
                bo.getArtifactName());
        if (childNames.size() > 0) {
            for (String name : childNames) {
                List<IBusinessEntity> childBes = bo.getEntitiesByComposition(name);
                for (IBusinessEntity be : childBes) {
                    flushAdd(be);
                }
            }
        }
    }

    void flushModify(IBusinessEntity originBo, IBusinessEntity bo) {
        RepositoryConfig repoConfig = configHelper.getRepositoryConfig(bo);
        // bo->do
        Object dataObject = TypeConversion.unWrapPrimitiveType(bo, repoConfig.getEntityClass());
        BaseMapper mapper = this.session.getMapper(repoConfig.getEntityMapperClass());

        //1. gdt->基本類型
        //2. bk:駝峯形式改成下劃線形式
        Map<String, String> bkMap = RepositoryUtil.MapCamelCaseToUnderscore(
                UnWrapMapUtil.getGdtValue(
                        bo.getBusinessKey().getBusinessKeyMap()));

        // update root
        UpdateWrapper updateWrapper = new UpdateWrapper();
        updateWrapper.allEq(bkMap);
        mapper.update(dataObject, updateWrapper);

        // 遍歷子be
        List<String> originChildNames = BusinessObjectManager.getEntityNamesByComposition(
                originBo.getBusinessObjectRoot().getArtifactName(),
                originBo.getArtifactName()
        );
        if (originChildNames.size() > 0) {
            for (String name : originChildNames) {
                List<IBusinessEntity> originChildBes = originBo.getEntitiesByComposition(name);
                List<IBusinessEntity> childBes = bo.getEntitiesByComposition(name);
                for (IBusinessEntity be : childBes) {
                    // be在數據庫中，從originChildBes列表中刪除，全部刪除完剩下的->須要delete的
                    Optional<IBusinessEntity> optional = originChildBes.stream()
                            .filter(
                                    x -> {
                                        // 判斷bk是否相同
                                        return x.getBusinessKey().equals(be.getBusinessKey());
                                    }
                            ).findFirst();
                    if (optional.isPresent()) {
                        // 數據庫中存在：修改
                        IBusinessEntity originBe = optional.get();
                        originChildBes.remove(originBe);
                        flushModify(originBe, be);
                    } else {
                        // 數據庫中不存在：新增
                        flushAdd(be);
                    }
                }
                // 數據庫中存在，但modifyBo中沒有：刪除
                if (originChildBes.size() > 0) {
                    for (IBusinessEntity originDeleteBe : originChildBes) {
                        flushDelete(originDeleteBe);
                    }
                }
            }
        }
    }

    void flushDelete(IBusinessEntity bo) {
        RepositoryConfig repoConfig = configHelper.getRepositoryConfig(bo);
        BaseMapper mapper = this.session.getMapper(repoConfig.getEntityMapperClass());

        IBusinessKey bk = bo.getBusinessKey();
        Map<String, String> bkMap = RepositoryUtil.MapCamelCaseToUnderscore(
                UnWrapMapUtil.getGdtValue(
                        bo.getBusinessKey().getBusinessKeyMap()));

        mapper.deleteByMap(bkMap);

        List<String> childNames = BusinessObjectManager.getEntityNamesByComposition(
                bo.getBusinessObjectRoot().getArtifactName(),
                bo.getArtifactName()
        );
        if (childNames.size() > 0) {
            for (String name : childNames) {
                List<IBusinessEntity> childBes = bo.getEntitiesByComposition(name);
                for (IBusinessEntity be : childBes) {
                    flushDelete(be);
                }
            }
        }
    }
}

在repo中增長flushDb方法，以下：

public void flushDb(SqlSession session) {
    RepositoryFlush flush = new RepositoryFlush(session);
    for (Map.Entry<IBusinessKey, RepositoryComponent<T>> entry : map.entrySet()) {
        RepositoryComponentState state = entry.getValue().getState();
        T t = entry.getValue().getT();
        if (RepositoryComponentState.ADDED.equals(state)) {
            flush.flushAdd(t);
        } else if (RepositoryComponentState.MODIFIED.equals(state)) {
            RepositoryBuilder<T> builder = new RepositoryBuilder<T>();
            T rootT = builder.buildBo(tClass, t.getBusinessKey());
            flush.flushModify(rootT, t);
        } else if (RepositoryComponentState.DELETED.equals(state)) {
            flush.flushDelete(t);
        }
    }
}

Retrieve&&RepositoryBuilder

repo中提供retrieve方法用於檢索聚合
若聚合在repo的集合中已存在則直接返回聚合，若無聚合，則經過RepoBuilder從數據庫中撈取聚合

public class RepositoryBuilder<T extends IBusinessObjectRoot> {

    private RepositoryConfigHelper configHelper = new RepositoryConfigHelper();
    private Map<String, List<IBusinessEntity>> beValues = new HashMap<>();

    T buildBo(Class<T> tClass, IBusinessKey businessKey) {
        SqlSessionFactory factory = (SqlSessionFactory) SpringContextUtil.getBean("sqlSessionFactory");
        SqlSession session = factory.openSession();
        try {
            RepositoryConfig config = configHelper.getRepositoryConfig((IBusinessEntity) tClass.newInstance());
            BaseMapper mapper = session.getMapper(config.getEntityMapperClass());
            QueryWrapper queryWrapper = new QueryWrapper();
            queryWrapper.allEq(
                    RepositoryUtil.MapCamelCaseToUnderscore(
                            UnWrapMapUtil.getGdtValue(
                                    businessKey.getBusinessKeyMap()))
            );
            // 獲取到當前do object
            Object object = mapper.selectOne(queryWrapper);
            if (object == null) {
                throw new RuntimeException("未找到數據庫對應DO數據。");
            }
            // build child
            IBusinessObjectRoot rootT = (IBusinessObjectRoot) TypeConversion.wrapPrimitiveType(object, tClass);
            buildChildBe(session, tClass, object, rootT);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e.getMessage());
        } finally {
            session.close();
        }
        // beValues->bo
        return (T) BusinessObjectManager.newInstance().createBusinessObjectInstance(
                tClass.getSimpleName(),
                beValues
        );
    }

    /**
     * 1. do->beValue
     * 2. beValues.add(beValue)
     * 3. bo查子bo
     * 4. 返回
     */
    private void buildChildBe(SqlSession session, Class<T> tClass, Object object, IBusinessObjectRoot rootT)
            throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        T t = TypeConversion.wrapPrimitiveType(object, tClass);
        if (t == null) {
            throw new RuntimeException("DO數據類型轉BE異常");
        }
        // 加入beValues
        if (beValues.containsKey(t.getArtifactName())) {
            beValues.get(t.getArtifactName()).add(t);
        } else {
            beValues.put(t.getArtifactName(), new ArrayList<IBusinessEntity>() {{
                add(t);
            }});
        }
        //
        IBusinessKey bk = t.getBusinessKey();
        List<String> childClassNames = BusinessObjectManager.getEntityNamesByComposition(
                rootT.getArtifactName(),
                t.getArtifactName()
        );
        if (childClassNames.size() > 0) {
            for (String childClassName : childClassNames) {
                Class childClass = Class.forName(childClassName);
                // 構造函數：包含父be（無結構構造函數）
                IBusinessEntity nullChildBe = (IBusinessEntity) childClass
                        .getConstructor()
                        .newInstance();
                RepositoryConfig childConfig = configHelper.getRepositoryConfig(rootT, nullChildBe);
                BaseMapper childMapper = session.getMapper(childConfig.getEntityMapperClass());
                List dbList = childMapper.selectByMap(
                        RepositoryUtil.MapCamelCaseToUnderscore(
                                UnwrapMapUtil.getGdtValue(bk.getBusinessKeyMap())
                        )
                );
                for (Object dbObject : dbList) {
                    buildChildBe(session, childClass, dbObject, rootT);
                }
            }
        }
    }
}