A1.领域驱动设计(DDD)之领域层与Spring Data Jpa实践

package com.iokays.sample.customer.domain;

import com.iokays.common.domain.jpa.AbstractAggregateRoot;
import com.iokays.sample.customer.domain.command.RegisterCustomer;
import com.iokays.sample.customer.domain.event.CustomerRegistered;
import jakarta.persistence.*;
import org.apache.commons.lang3.Validate;

import java.time.LocalDateTime;
import java.util.Objects;


@Entity(name = "t_customer")
public class Customer extends AbstractAggregateRoot<Customer> {

    @AttributeOverride(name = "id", column = @Column(name = "customer_id"))
    private CustomerId customerId;

    @AttributeOverride(name = "value", column = @Column(name = "email_address"))
    private EmailAddress emailAddress;

    @Embedded
    @AttributeOverride(name = "firstName", column = @Column(name = "first_name"))
    @AttributeOverride(name = "lastName", column = @Column(name = "last_name"))
    private FullName fullName;

    @Enumerated(EnumType.STRING)
    private Gender gender;

    private LocalDateTime registeredAt;

    protected Customer() {
        super();
    }

    public Customer(FullName fullName, Gender gender, EmailAddress emailAddress) {
        this();
        this.customerId = CustomerId.makeCustomerId();
        this.registeredAt = LocalDateTime.now();

        this.fullName = Validate.notNull(fullName, "name must not be null");
        this.gender = Validate.notNull(gender, "gender must not be null");
        this.emailAddress = Validate.notNull(emailAddress, "emailAddress must not be null");

        this.registerEvent(CustomerRegistered.issue(this.customerId, this.registeredAt));
    }

    public static Customer registerBy(final RegisterCustomer cmd) {
        Validate.notNull(cmd, "注册客户的命令不能为空");

        return new Customer(
                cmd.fullName(),
                cmd.gender(),
                cmd.emailAddress());
    }

    public CustomerId customerId() {
        return customerId;
    }

    @Override
    public boolean sameIdentityAs(Customer other) {
        return Objects.equals(this.customerId, other.customerId);
    }

}

package com.iokays.sample.customer.domain;

import com.iokays.common.domain.jpa.AbstractId;
import jakarta.persistence.Embeddable;
import org.apache.commons.lang3.Validate;

import java.util.UUID;

@Embeddable
public class CustomerId extends AbstractId {

    private static final String UUID_REGEX = "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$";

    private CustomerId() {
        super();
    }

    public CustomerId(String id) {
        super(id);
    }

    public static CustomerId makeCustomerId() {
        return new CustomerId(UUID.randomUUID().toString());
    }

    /**
     * 验证是否是UUID字符串
     *
     * @param anId
     */
    @Override
    protected void validateId(String anId) {
        Validate.notNull(anId);
        Validate.isTrue(anId.matches(UUID_REGEX));
    }
}

package com.iokays.sample.customer.domain;

import com.iokays.common.core.domain.ValueObject;
import jakarta.persistence.Embeddable;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.Validate;
import org.apache.commons.validator.routines.EmailValidator;

import java.util.Objects;

/**
 * 客户的邮箱地址
 *
 * @param value {@link Integer}邮箱地址的值
 */
@Embeddable
public record EmailAddress(String value) implements ValueObject<EmailAddress> {

    /**
     * 默认构造函数
     *
     * @param value {@link Integer}邮箱地址的值
     */
    public EmailAddress {
        Validate.isTrue(StringUtils.isNotEmpty(value), "邮箱地址不能为空");
        Validate.isTrue(isValidEmailAddress(value), "邮箱地址不合法");
    }

    /**
     * 创建邮箱地址 {@link EmailAddress}
     *
     * @param value {@link Integer}邮箱地址的值
     * @return 邮箱地址 {@link EmailAddress}
     */
    public static EmailAddress from(String value) {
        return new EmailAddress(value);
    }

    /**
     * 验证邮箱地址是否合法
     *
     * @param value {@link String} 邮箱地址的值
     * @return {@link Boolean} 邮箱地址是否合法
     */
    private boolean isValidEmailAddress(String value) {
        return EmailValidator.getInstance().isValid(value);
    }

    @Override
    public boolean sameValueAs(EmailAddress other) {
        return Objects.equals(value, other.value);
    }
}

package com.iokays.sample.customer.domain.command;

import com.iokays.common.core.command.Command;
import com.iokays.common.core.command.CommandId;
import com.iokays.sample.customer.domain.EmailAddress;
import com.iokays.sample.customer.domain.FullName;
import com.iokays.sample.customer.domain.Gender;

import java.time.Instant;

/**
 * 注册新客户的不可变记录命令
 *
 * @param id           {@link CommandId} 命令ID
 * @param registeredAt {@link Instant} 登记时间
 * @param fullName     {@link FullName} 客户的姓名
 * @param gender       {@link Gender} 客户的性别
 * @param emailAddress {@link EmailAddress} 客户的邮箱地址
 */
public record RegisterCustomer(CommandId id,
                               Instant registeredAt,
                               FullName fullName,
                               Gender gender,
                               EmailAddress emailAddress) implements Command {

    /**
     * 发出一个注册新客户的命令
     *
     * @param fullName     {@link FullName} 客户的姓名
     * @param gender       {@link Gender} 客户的性别
     * @param emailAddress {@link EmailAddress} 客户的邮箱地址
     * @return 返回一个注册新客户的命令 {@link RegisterCustomer}
     */
    public static RegisterCustomer issue(final FullName fullName,
                                         final Gender gender,
                                         final EmailAddress emailAddress) {
        return new RegisterCustomer(
                CommandId.generate(),
                Instant.now(),
                fullName,
                gender,
                emailAddress
        );
    }
}

package com.iokays.sample.customer.domain.event;

import com.iokays.common.core.event.DomainEvent;
import com.iokays.common.core.event.EventId;
import com.iokays.sample.customer.domain.CustomerId;

import java.time.Instant;
import java.time.LocalDateTime;
import java.util.Objects;

/**
 * 客户已注册的领域事件
 *
 * @param id           {@link EventId} 事件标识
 * @param registeredAt {@link Instant} 事件发生时间
 * @param customerId   {@link CustomerId} 客户标识
 */
public record CustomerRegistered(EventId id, CustomerId customerId,
                                 LocalDateTime registeredAt) implements DomainEvent<CustomerRegistered> {

    /**
     * 发布一个领域事件
     *
     * @param customerId {@link CustomerId} 客户标识
     * @return {@link CustomerRegistered} 客户已注册的领域事件
     */
    public static CustomerRegistered issue(final CustomerId customerId, final LocalDateTime registeredAt) {
        return new CustomerRegistered(EventId.generate(), customerId, registeredAt);
    }

    @Override
    public boolean sameEventAs(CustomerRegistered other) {
        // 通过判断事件标识是否相等来判断事件是否相等
        return Objects.equals(this.id, other.id);
    }
}

package com.iokays.sample.customer.application.service;

import com.iokays.common.core.lock.DistributedLock;
import com.iokays.sample.customer.domain.Customer;
import com.iokays.sample.customer.domain.CustomerId;
import com.iokays.sample.customer.domain.CustomerRepository;
import com.iokays.sample.customer.domain.EmailAddress;
import com.iokays.sample.customer.domain.command.RegisterCustomer;
import org.apache.commons.lang3.Validate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;


@Service
public class CustomerApplicationService {

    private final CustomerRepository customers;

    public CustomerApplicationService(CustomerRepository customers) {
        this.customers = customers;
    }

    @Transactional
    @DistributedLock(value = "customer", key = "#cmd.emailAddress.value") //这里未实现
    public CustomerId registerCustomer(final RegisterCustomer cmd) {
        final EmailAddress emailAddress = cmd.emailAddress();

        Validate.isTrue(customers.findByEmailAddress(emailAddress).isEmpty(), String.format("给定的电子邮件地址: %s 已经存在", emailAddress));

        final Customer customer = Customer.registerBy(cmd);
        customers.save(customer);

        return customer.customerId();
    }

}