Java领域模型中条件属性的最佳实践：避免枚举陷阱

import java.util.List;
import java.util.Locale;
import java.util.Optional;

public enum TokenType {
    STANDARD,
    LOCALIZED
}

public class Token {
    private String id;
    private TokenType type;
    private List<Locale> locales; // 即使是STANDARD类型，也可能存在此字段

    public Token(String id, TokenType type, List<Locale> locales) {
        this.id = id;
        this.type = type;
        this.locales = locales;
    }

    public String getId() {
        return id;
    }

    public TokenType getType() {
        return type;
    }

    /**
     * 根据Token类型返回本地化信息。
     * 仅当type为LOCALIZED时返回实际值，否则返回Optional.empty()。
     */
    public Optional<List<Locale>> getLocales() {
        if (this.type == TokenType.LOCALIZED) {
            return Optional.ofNullable(locales);
        }
        return Optional.empty();
        // 另一种处理方式是抛出 UnsupportedOperationException
    }

    // ... 其他通用属性和方法
}

import java.util.List;
import java.util.Locale;

// 基础Token实体，包含所有通用属性
public class Token {
    private String id;

    public Token(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }
    // ... 其他通用属性和方法
}

// 扩展的LocalizedToken实体，包含特有的locales属性
public class LocalizedToken extends Token {
    private List<Locale> locales;

    public LocalizedToken(String id, List<Locale> locales) {
        super(id);
        this.locales = locales;
    }

    public List<Locale> getLocales() {
        return locales;
    }
}

// 示例：使用泛型在用例层操作不同类型的Token
public class CreateTokensUseCase<T extends Token> {

    // 假设有一个通用的TokenRepository
    private TokenRepository tokenRepository;

    public CreateTokensUseCase(TokenRepository tokenRepository) {
        this.tokenRepository = tokenRepository;
    }

    public T execute(T token) {
        // 在这里可以进行一些通用的Token创建逻辑
        // 如果需要访问特定属性，可以通过类型检查进行向下转型
        if (token instanceof LocalizedToken localizedToken) {
            System.out.println("Creating localized token with locales: " + localizedToken.getLocales());
        } else {
            System.out.println("Creating standard token.");
        }
        return tokenRepository.save(token); // 假设save方法也是泛型的
    }
}

// 示例：仓储接口设计
interface TokenRepository {
    <T extends Token> T save(T token);
    Optional<Token> findById(String id); // 返回基础Token
    Optional<LocalizedToken> findLocalizedTokenById(String id); // 特定类型查询
}

// 示例：服务层调用
public class TokenApplicationService {
    private final CreateTokensUseCase<Token> standardTokenCreator;
    private final CreateTokensUseCase<LocalizedToken> localizedTokenCreator;

    public TokenApplicationService(TokenRepository tokenRepository) {
        this.standardTokenCreator = new CreateTokensUseCase<>(tokenRepository);
        this.localizedTokenCreator = new CreateTokensUseCase<>(tokenRepository);
    }

    public Token createStandardToken(String id) {
        return standardTokenCreator.execute(new Token(id));
    }

    public LocalizedToken createLocalizedToken(String id, List<Locale> locales) {
        return localizedTokenCreator.execute(new LocalizedToken(id, locales));
    }
}