class Product {
    private Set<BacklogItem> backlogItems;
    private String description;
    private String name;
    private ProductId productId;
    private Set<Release> releases;
    private Set<Spring> sprints;
    private TenantId tenantId;
}

class Product {
    public void planBacklogItem(
        String summary, String category, BacklogItemType type, StoryPorints storyPoints) {
        ...
    }
    ...
    public void scheduleRelease(
        String name, String description, Date begins, Date ends) {
        ...
    }
    ...
    public void scheduleSprint(
        String name, String goals, Date begins, Date ends) {
        ...
    }
    ...
}

class Product {
    public BacklogItem planBacklogItem(
        String summary, String category, BacklogItemType type, StoryPorints storyPoints) {
        ...
    }
    ...
    public Release scheduleRelease(
        String name, String description, Date begins, Date ends) {
        ...
    }
    ...
    public Sprint scheduleSprint(
        String name, String goals, Date begins, Date ends) {
        ...
    }
    ...
}

@Service
class ProductBacklogItemService {
    @Transactional
    public void planProductBacklogItem(
        String tenantId, String productId
        String summary, String category
        String backlogItemType, String storyPoints) {

        Product product = 
            productRepository.producetOfId(
                new TenantId(tenantId),
                new ProductId(productId));
        BacklogItem plannedBacklogItem = 
            product.planBacklogItem(
                summary, category,
                BacklogItemType.valueOf(aBacklogItemType),
                StoryPoints.valueOf(stroyPoints));
        backlogItemRepository.add(plannedBacklogItem);
    }
    ...
}

class BacklogItem {
    private ProductId productId;
}

@Service
class ProductBacklogItemService {
    @Transactional
    public void assignTeaMemberToTask(
        String aTenantId,
        String aBacklogItemId,
        String aTaskId,
        String aTeamMemberId) {

        BacklogItem backlogItem = 
            backlogItemRepository.findById(
                new TenantId(aTenantId), new BacklogItemId(aBacklogItemId));
        Team ofTeam = 
            teamRepository.findById(
                backlogItem.tenantId(), backlogItem.teamId());
        backlogItem.assignTeamMemberToTask(
            new TeamMemberId(aTeamMemberId), ofTeam, new TaskId(aTaskId));
    }
}

@Entity
@Table(name = "orders")
public class Order {
    @Id
    private Long id;
    @Version
    private int version;
    private String description;
}

@Embeddable
@Value
public class GroupMember {
    private String name;
    @Enumerated(EnumType.STRING)
    private GroupMemberType type;

    // For JPA
    GroupMember() {
        this.name = null;
        this.type = null;
    }

    // For Jackson
    @JsonCreator
    public GroupMember(@JsonProperty("name") String name, 
                       @JsonProperty("type") GroupMemberType type) {
        this.name = name;
        this.type = type;
    }
}

@Entity
@Table(name = "GROUPS")
@Getter
@EqualsAndHashCode
@ToString
@NoArgsConstructor(access = AccessLevel.PACKAGE)
public class Group {
    @Id
    @GeneratedValue
    private Long groupId;
    private String description;
    private String name;

    /**
     * ORM과 한 열로 직렬화되는 여러 값 : ORM and Many Values Serialized into a Single Column
     */
    @Convert(converter = GroupMembersConverter.class)
    @Column(name = "GROUP_MEMBERS", length = 4000)
    private Set<GroupMember> group1Members = new HashSet<>();
    ...
}

@Converter
public class GroupMembersConverter implements AttributeConverter<Set<GroupMember>, String> {
    private ObjectMapper om = new ObjectMapper();

    @Override
    public String convertToDatabaseColumn(Set<GroupMember> attribute) {
        return om.writeValueAsString(attribute);
    }

    @Override
    public Set<GroupMember> convertToEntityAttribute(String dbData) {
        return om.readValue(dbData, new TypeReference<Set<GroupMember>>() { });
    }
}

@MappedSuperclass
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public abstract class IdentifiedValueObject {
    @Id
    @GeneratedValue
    @Getter(AccessLevel.PACKAGE)
    @Setter(AccessLevel.PACKAGE)
    private Long id;    // 패키지 접근제어를 통해서 식별자 은닉. 단, hibernate는 접근 가능
}

@Entity
@Table(name = "GROUP_MEMBERS")
@Value
@EqualsAndHashCode(callSuper = false)
public class GroupMember extends IdentifiedValueObject {
    private String name;
    @Enumerated(EnumType.STRING)
    private GroupMemberType type;

    // For JPA
    GroupMember() {
        this.name = null;
        this.type = null;
    }
}

public class Group {
    ...
    /**
     * ORM과 데이터베이스 엔터티로 지원되는 여러 값 : ORM and Many Values Backed by a Database Entity
     */
    @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true) // Aggregate Root 를 위한 일관성 설정
    @JoinColumn(name = "GROUP_ID")
    private Set<GroupMember> groupMembers = new HashSet<>();
    ...
}

public class Group {
    @Id
    @GeneratedValue
    private Long groupId;
    private String description;
    private String name;
    /**
     * ORM과 조인 테이블로 지원되는 여러 값 : ORM and Many Values Backed by a Join Table
     */
    @ElementCollection
    @CollectionTable(name = "GROUP_MEMBERS", joinColumns = @JoinColumn(name = "GROUP_ID"))
    private Set<GroupMember> groupMembers = new HashSet<>();
    ...
}

public class Group {
    ...
    @ElementCollection
    @CollectionTable(name = "GROUP_MEMBERS", joinColumns = @JoinColumn(name = "GROUP_ID"))
    @OrderColumn    // !!!
    private Set<GroupMember> groupMembers = new HashSet<>();
    ...
}

package com.saasovation.agilepm.domain.model.product;

@Value
class BacklogItemCommitted implements DomainEvent {
    Date occurredOn;
    BacklogItemId backlogItemId;
    SpringId committedToSprintId;
    TenantId tenantId;
}

package com.saasovation.agilepm.domain.model;

interface DomainEvent {
    Date occurredOn();
}

class BacklogItem extends AbstractAggregateRoot<BacklogItem> {
    void commitTo(Sprint spint) {
        // Some domain logic
        super.registerEvent(new BacklogItemCommitted(
                this.tenantId(),
                this.backlogItemId(),
                this.sprintId()
        ));
    }
}

class BacklogItemService {  // Application Service
     @TransactionalEventListener
    void commitBacklogItem(...) {
        backlogItem.commitTo(sprint);   // Publish BacklogItemCommitted event
    }
}

class BacklogItemService {  // Application Service
     @TransactionalEventListener
    void handleBacklogItemCommitted(BacklogItemCommitted event) {
        // BacklogItemCommitted 구독 후 처리
    }
}

@Aspect
class IdentityAccessEventProcessor {
    @Before("execution(* com.saasovation.identityaccess.application.*.**..))")
    public void listen() {
        DomainEventPublisher.instance()
            .subscribe(new DomainEventSubscriber<DomainEvent>() {
                public void handleEvent(DomainEvent aDomainEvent) {
                    store(aDomainEvent);
                }

                public Class<DomainEvent> subscribedToEventType() {
                    return DomainEvent.class;   // 모든 도메인 이벤트
                }
            });
    }
    private void store(DomainEvent aDomainEvent) {
        EventStore.instance().append(aDomainEvent);
    }
}

class StoreEvent {
    void append(DomainEvent aDomainEvent) {
        String eventSerializatoin = 
            EventStore.objectSerializer().serialize(aDomainEvent);
        StoredEvent storedEvent = 
            new StoredEvent(
                aDomainEvent.getClass().getName(),
                aDomainEvent.occuredOn(),
                eventSerialization);
        this.session().save(storedEvent);
        this.setStoredEvent(storedEvent);
    }
}

class Product {
    Set<BacklogItem> backlogItems;

    BusinessPriorityTotals businessPriorityTotals() {
        //...
    }
}

class Product {
    static BusinessPriorityTotals businessPriorityTotals(
            Set<BacklogItem> aBacklogItems) {
        // ...
    }
}

package com.saasovation.identityaccess.domain.model.identity;   // !!

interface AuthenticationService {
    UserDescriptor authenticate(
        TenantId tenantId,
        String username,
        Strin password);
}

package com.saasovation.identityaccess.infra.services;   // !!

class EncryptionAuthenticationService implements AuthenticationService {
    @Override
    UserDescriptor authenticate(
            @NonNull TenantId tenantId,
            @NonNull String username,
            @NonNull Strin password) {

        Tenant tenant = tenantRepository.findById(tenantId);
        if (tenant == null || !tenant.isActive()) {
            throw new TenantNotFoundException(tenantId);
        }
        String encryptedPassword = 
                encryptService.encryptedValue(passwod); // 암호화 책임도 도메인 서비스?
        User user = userRepository.findByTenantAndUsernameAndPassword(
            tenant, username, encryptedPassword);
        if (user == null || !user.isEnabled()) {
            throw new UserNotFoundException(username);
        }
        return user.userDescriptor();
    }
}

package com.saasovation.collaboration.infra.services;

class UserInRoleAdapter {
    <T extends Collaborator> T toCollaborator(
            Tenant tenant, String identity, String role, 
            Class<T> collaboratorClass);
}

package com.sasovation.collaboration.infra.services;

class CollbaratorTransaltor {
    <T extends Collaborator> T toCollaboratorFrom(
            String json, Class<T> collaboratorClass);
}