第二节 DDD领域部分

用户1418372

发布于 2018-09-13 10:11:43

4070

DDD补充部分

统一建模语言UML，为方便设计人员、领域专家和程序员都能看懂的一种通用语言
多层架构是DDD的一个通用解决方案，他包含四个层面

1. 表示层或者用户界面层（ui层）
2. 应用层
3. 领域层
4. 基础设施层

一般只有领域层负责领域模型，其他层为其服务，这设计的好处是将领域相关的代码分离开来具体每层的含义不再赘述。

本节考虑在编写代码时，使用DDD领域驱动的理念设计部分code

实体的实现对于第一个接口，可以提供一个实体所需的抽象类或者接口

public abstract class Entity<T> {
    T id;
    String name;
}

基于此抽象可以实现一个抽象的基础实体类

public abstract  class BaseEntity<T> extends  Entity<T>{

    private T id;
    public BaseEntity(T id, String name){
        super.id = id;
        super.name = name;
    }

    //.... get set 方法 以及其他相关代码
}

基于前面的抽象类创建restaurant实体，我们开发的是餐馆订座系统，所以Table是领域模型中另一个重要的实体，这里由于业务，我们可以采用聚合模式，restaurant会作为一个根来工作，而Table将是restaurant实体中的内部实体。因此Table实体始终都可以使用restaurant来访问。下面作为示范，添加了基本属性

/**
 * @author xzg
 */
public class Table  extends BaseEntity<BigInteger> {

private  int capacity;

    public Table(BigInteger id, String name, int capacity) {
        super(id, name);
        this.capacity = capacity;
    }

    public void setCapacity(int capacity) {
        this.capacity = capacity;
    }

    public int getCapacity() {
        return capacity;
    }
}

现在我们实现restaurant聚合实体

**
 * @author xzg
 */
public class Restaurant extends  BaseEntity<String> {
    private List<Table> tables = new ArrayList<>();

    public Restaurant(String id, String name,List<Table> tables) {
        super(id, name);
        this.tables = tables;
    }

    public List<Table> getTables() {
        return tables;
    }

    public void setTables(List<Table> tables) {
        this.tables = tables;
    }
}

接下来存储库设计作为开始我们先创建两接口Repository 和 ReadOnlyRepository。ReadOnlyRepository作为制度操作的抽象，Repository 将作为所有类型的接口

/**
 * @author xzg
 */
public interface ReadOnlyRepository<TE,T> {

    boolean contain(T id);
    Entity  get(T id);

    Collection<TE> getAll();
}

基于只读接口我再添加额外的操作

/**
 * @author xzg
 */
public interface Repository<TE,T> extends  ReadOnlyRepository {

    void add(TE entity);

    void  remove(T id);

    void  update(TE entity);
}

前面定义的抽象层可以使用合适的方式使用，上面属于存储服务的公共抽象层，具体不同存储业务，还需要我们根据具体去添加定义下面提供餐馆服务的存储服务接口以及相应的实现类

/**
 * @author xzg
 */
public interface RestaurantRepository<Restaurant,String> extends Repository<Restaurant,String> {

    boolean cotainsName(String name);
}

下面实现：

**
 * @author xzg
 * @这里为方便
 * 使用内存作为存储，实际生产请使用数据库库或者缓存
 */
public class InMemRestaurantRepository implements  RestaurantRepository<Restaurant,String> {

    private Map<String,Restaurant> entities;

    public InMemRestaurantRepository(){
        entities = new HashMap<>();
    }
    @Override
    public boolean cotainsName(String name) {
        return entities.containsKey(name);
    }

    @Override
    public void add(Restaurant entity) {
        entities.put(entity.getName(),entity);
    }

    @Override
    public void remove(String id) {
        if(entities.containsKey(id))
            entities.remove(id);
    }

    @Override
    public void update(Restaurant entity) {
            if(entities.containsKey(entity.getName()))
                entities.put(entity.getName(),entity);
    }

    @Override
    public boolean contains(Object id) {
        throw  new UnsupportedOperationException("not support yet");
    }

    @Override
    public Entity get(Object id) {
        throw  new UnsupportedOperationException("not support yet");
    }
    @Override
    public Collection getAll() {
        return entities.values();
    }
}

服务层的设计实现

和前面的存储库服务一样我们把领域服务也抽象出，主抽象服务和只读抽象服务

/**
 * @author xzg
 */
public abstract class ReadOnlyBaseService<TE,T> {

    private  Repository<TE,T> repository;

    ReadOnlyBaseService(Repository<TE,T> repository){
        this.repository = repository;
    }
    //....
}

同理我们使用一个base服务去实现这个只读的服务,这里使用依赖注入的方式将存储服务注入到领域服务中去。

   /**
 * @author xzg
 */
public  abstract  class BaseService<TE,T> extends  ReadOnlyBaseService<TE,T> {

    private Repository<TE,T> _repository;

    BaseService(Repository<TE,T> repository){
        super(repository);
        _repository = repository;
    }
    public  void add(TE entity) throws  Exception{
        _repository.add(entity);
    }

    public Collection<TE> getAll(){
        return _repository.getAll();
    }
}

有了基础的服务层，我们的具体领域服务也就可以根据自身业务需求设计

/**
 * @author xzg
 */
public class RestaurantService extends  BaseService<Restaurant, BigInteger> {

    private RestaurantRepository<Restaurant,String> restaurantRepository;

    public RestaurantService(RestaurantRepository restaurantRepository){
        super(restaurantRepository);
        this.restaurantRepository = restaurantRepository;
    }

    @Override
    public  void add(Restaurant restaurant) throws Exception{
        if(restaurantRepository.cotainsName(restaurant.getName()))
            throw  new Exception("name is repeat");
        if(StringUtils.isEmpty(restaurant.getName()))
            throw  new NullPointerException("name is null");
        super.add(restaurant);
    }
//...others
}

总结：以上通过一个简单的订餐的领域，通过DDD分层设计。之后的篇章将会实现具体的业务。

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2018.08.15 ，如有侵权请联系 cloudcommunity@tencent.com 删除

其他

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

其他

登录后参与评论

0 条评论

热度