powerdesigner错误提示实体属性名称唯一性_领域驱动设计战术篇--实体

在问题空间中存在很多具有固有身份的概念，通常情况下，这些概念将建模为实体。

实体是具有唯一标识的概念，找到领域中的实体并对其进行建模是非常重要的环节。如果理解一个概念是一个实体，就应该追问领域专家相关的细节，比如概念生命周期、核心数据、具体操作、不变规则等；从技术上来说，我们可以应用实体相关模式和实践。

1 理解实体

一个实体是一个唯一的东西，并且可以在相当长的一段时间内持续变化。

实体是一个具有身份和连贯性的概念。

• 身份 是一个重要的领域概念，应该显示建模以提高其在领域中的表达性。
• 连贯性 指通过唯一身份来让某个概念，在生命周期的各阶段被发现、被更新甚至被删除。

一个实体就是一个独立的事物。每个实体都拥有一个 唯一标识符 （也就是身份），并通过 标识 与和 类型 对实体进行区分开。通常情况下，实体是可变的，也就是说，他的状态随着时间发生变化。

唯一身份标识 和 可变性特征 将实体对象和值对象区分开来。

由于从数据建模出发，通常情况下，CRUD 系统不能创建出好的业务模型。在使用 DDD 的情况下，我们会将数据模型转化成实体模型。

从根本上说，实体主要与身份有关，它关注“谁”而非 “什么”。

2 实现实体

大多数实体都有类似的特征，因此存在一些设计和实现上的技巧，其中包括唯一标识、属性、行为、验证等。

在实体设计早期，我们刻意将关注点放在能体现实体 唯一性属性 和 行为 上，同时还将关注如何对实体进行查询。

2.1 唯一标识

有时，实体具有明确的自然标识，可以通过对概念的建模来实现；有时，可能没有已存的自然标识，将由应用程序生成并分配一个合理的标识，并将其用于数据存储。

• 值对象 作为实体的唯一标识，能够更好的表达领域概念。
• 标识具有稳定性 在为实体分配标识后，我们绝对不允许对其进行修改。如果键改变了，那么系统中所有引用该键的地方都需要同步更新，通常情况下，这是不可能做到的。不然，将导致严重的业务问题。

2.1.1 自然键作为唯一标识

在考虑实体身份时，首先考虑该实体所在问题空间是否已经存在唯一标识符，这些标识符被称为自然键。

通常情况下，以下几类信息可以作为自然键使用：

• 身份证号
• 国家编号
• 税务编号
• 书籍 ISBN
• ...

在使用时，我们通常使用值对象模式对自然键进行建模，然后为实体添加一个构造函数，并在构造函数中完成唯一标识的分配。

首先，需要对书籍 ISBN 值对象建模：

@Value
public class ISBN {
    private String value;
}

然后，对 Book 实体建模：

@Data
public class Book {
    private ISBN id;

    public Book(ISBN isbn){
        this.setId(isbn);
    }

    public ISBN getId(){
        return this.id;
    }

    private void setId(ISBN id){
        Preconditions.checkArgument(id != null);
        this.id = id;
    }
}

Book 在构造函数中完成 id 的赋值，之后便不会修改，以保护实体标识的稳定性。

自然键，在实际研发中，很少使用。特别是在需要用户手工输入的情况下，难免会造成输入错误。对标识的修改会导致引用失效，因此，我们很少使用用户提供的唯一标识。通常情况下，会将用户输入作为实体属性，这些属性可以用于对象匹配，但是我们并不将这样的属性作为唯一身份标识。

2.1.2 应用程序生成唯一标识

当问题域中没有唯一标识时，我们需要决定标识生成策略并生成它。

最常见的生成方式包括自增数值、全局唯一标识符（UUID、GUID等）以及字符串等。

自增数值

数字通常具有最小的空间占用，非常利于持久化，但需要维护分配 ID 的全局计数器。

我们可以使用全局的静态变量作为全局计数器，如：

public final class NumberGenerator {
    private static final AtomicLong ATOMIC_LONG = new AtomicLong(1);

    public static Long nextNumber(){
        return ATOMIC_LONG.getAndIncrement();
    }
}

但是，但应用崩溃或重启时，静态变量就会丢失它的值，这意味着会生成重复的 ID，从而导致业务问题。为了纠正这个问题，我们需要利用全局持久化资源构建计数器。

我们可以使用 Redis 或 DB 构建自己的全局计数器。

基于 Redis inc 指令的全局计数器：

@Component
public class RedisBasedNumberGenerator {
    private static final String NUMBER_GENERATOR_KEY = "number-generator";

    @Autowired
    private RedisTemplate<String, Long> redisTemplate;

    public Long nextNumber(){
        return this.redisTemplate.boundValueOps(NUMBER_GENERATOR_KEY)
                .increment();
    }
}

基于 DB 乐观锁的全局计数器： 首先，定义用于生成 Number 的表结构：

create table tb_number_gen
(
 	id bigint auto_increment primary key,
 	`version` bigint not null,
 	type varchar(16) not null,
 	current_number bigint not null
 );
create unique index 'unq_type' on tb_number_gen ('type');

然后，使用乐观锁完成 Number 生成逻辑：

@Component
public class DBBasedNumberGenerator {
    private static final String NUMBER_KEY = "common";
    private JdbcTemplate jdbcTemplate;

    @Autowired
    public void setDataSource(DataSource dataSource){
        this.jdbcTemplate = new JdbcTemplate(dataSource);
    }

    public Long nextNumber(){
        do {
            try {
                Long number = nextNumber(NUMBER_KEY);
                if (number != null){
                    return number;
                }
            }catch (Exception e){
                // 乐观锁更新失败，进行重试
//                LOGGER.error("opt lock failure to generate number, retry ...");
            }
        }while (true);
    }

    /**
     * 表结构：
     * create table tb_number_gen
     * (
     * 	id bigint auto_increment primary key,
     * 	`version` bigint not null,
     * 	type varchar(16) not null,
     * 	current_number bigint not null
     * );
     * add unique index 'unq_type' on tb_number_gen ('type');
     *
     * @param type
     * @return
     */
    private Long nextNumber(String type){
        NumberGen numberGen = jdbcTemplate.queryForObject(
                "select id, type, version, current_number as currentNumber " +
                        "from tb_number_gen " +
                        "where type = '" + type +"'",
                NumberGen.class);

        if (numberGen == null){
            // 不存在时，创建新记录
            int result = jdbcTemplate.update("insert into tb_number_gen (type, version, current_number) value ('" + type +" ', '0', '1')");
            if (result > 0){
                return 1L;
            }else {
                return null;
            }
        }else {
            // 存在时，使用乐观锁 version 更新记录
            int result = jdbcTemplate.update("update tb_number_gen " +
                    "set version = version + 1," +
                    "current_number = current_number + 1 " +
                    "where " +
                    "id = " + numberGen.getId() + " " +
                    " and " +
                    "version = " + numberGen.getVersion()
            );
            // 更新成功，说明从读取到更新这段时间，数据没有发生变化，numberGen 有效，结果为 number + 1
            if (result > 0){
                return numberGen.getCurrentNumber() + 1;
            }else {
                // 更新失败，说明从读取到更新这段时间，数据发生变化，numberGen 无效，获取 number 失败
                return null;
            }
        }
    }

    @Data
    class NumberGen{
        private Long id;
        private String type;
        private int version;
        private Long currentNumber;
    }
}

全局唯一标识符

GUID 生成非常方便，并且自身就保障是唯一的，不过在持久化时会占用更多的存储空间。这些额外的空间相对来说微不足道，因此对大多数应用来说，GUID 是默认方法。

有很多算法可以生成全局唯一的标识，如 UUID、GUID 等。

生成策略，需要参考很多因子，以产生唯一标识：

1. 计算节点当前时间，以毫秒记；
2. 计算节点的 IP 地址；
3. 虚拟机中工厂对象实例的对象标识；
4. 虚拟机中由同一个随机数生成器生成的随机数

但，我们没有必要自己写算法构建唯一标识。Java 中的 UUID 是一种快速生成唯一标识的方法。

@Component
public class UUIDBasedNumberGenerator {

    public String nextId(){
        return UUID.randomUUID().toString();
    }
}

如果对性能有很高要求的场景，可以将 UUID 实例缓存起来，通过后台线程不断的向缓存中添加新的 UUID 实例。

@Component
public class UUIDBasedPoolNumberGenerator {
    private static final Logger LOGGER = LoggerFactory.getLogger(UUIDBasedPoolNumberGenerator.class);

    private final BlockingQueue<String> idQueue = new LinkedBlockingQueue<>(100);
    private Thread createThread;

    /**
     * 直接从队列中获取已经生成的 ID
     * @return
     */
    public String nextId(){
        try {
            return idQueue.take();
        } catch (InterruptedException e) {
            LOGGER.error("failed to take id");
            return null;
        }
    }

    /**
     * 创建后台线程，生成 ID 并放入到队列中
     */
    @PostConstruct
    public void init(){
        this.createThread = new Thread(new CreateTask());
        this.createThread.start();
    }

    /**
     * 销毁线程
     */
    @PreDestroy
    public void destroy(){
        this.createThread.interrupt();
    }

    /**
     * 不停的向队列中放入 UUID
     */
    class CreateTask implements Runnable{

        @Override
        public void run() {
            while (!Thread.currentThread().isInterrupted()){
                try {
                    idQueue.put(UUID.randomUUID().toString());
                } catch (InterruptedException e) {
                    LOGGER.error("failed to create uuid");
                }
            }
        }
    }
}

当在浏览器中创建一个实体并提交回多个后端 API 时，GUID 就会非常有用。如果没有 ID 后端服务将无法对相同实体进行识别。这时，最好使用 JavaScript 在客户端创建一个 GUID 来解决。
在浏览器中生成 GUID，可以有效控制提交数据的幂等性。

字符串

字符串常用于自定义 ID 格式，比如基于时间戳、多特征组合等。

如下例订单唯一标识：

public class OrderIdUtils {

    public static String createOrderId(String day, String owner, Long number){
        return String.format("%s-%s-%s", day, owner, number);
    }
}

一个订单 ID 由日期、所有者和序号三者组成。

对于标识，使用 String 来维护并不是很好的方法，无法对其生成策略、具体格式进行