Início / coding / Perguntas / 79473492
Accepted
Cilenco
Asked: 2025-02-28 01:33:52 +0800 CST

Obter propriedade de TypeElement no Processador de Anotação

  • 772

Na minha empresa temos muitos Enums que implementam uma interface como esta:

public interface DomainEnum {
    String getDomainId();
}

@Getter
@AllArgsConstructor
public enum ExampleEnum implements DomainEnum {
  A("1"), B("2"), C("3");

  private final String domainId;
}

Gostaria de usar o MapStruct para mapear Strings para qualquer Enum implementado DomainEnumusando o domainId. Nos documentos, vi que você pode implementar uma estratégia de nomeação de enum personalizada que descreve exatamente o que eu quero. Meu problema atual é que não tenho certeza de como obter o domainIddo enum. Este é meu código até agora:

public class CustomEnumMappingStrategy extends DefaultEnumMappingStrategy {

  // other methods like in example from docs
 
  protected String getCustomEnumConstant(TypeElement enumTypeElement, String enumConstant) {
    var enumValue = getEnumValue(enumTypeElement, enumConstant);
    // How can I now get the domainId from the ElementKind?
  }

  protected ElementKind getEnumValue(TypeElement enumTypeElement, String enumConstant) {
    return enumTypeElement.getEnclosedElements().stream()
      .filter(it -> it.getKind().equals(ElementKind.ENUM_CONSTANT))
      .filter(it -> it.toString().equals(enumConstant))
      .findFirst()
      .orElse(null);
  }
}

Então, como eu poderia começar domainIddo ElementKindagora para finalizar minha estratégia de mapeamento?

java

1 respostas

  1. Best Answer

    O Processamento de Anotações é limitado somente a assinaturas. Para definições de constantes enum, ele termina com o nome.

    • Não é possível inserir a ("1")peça A("1"), em um processador de anotações.
    • Não é viável carregar a classe enum e passar pelos valores com eg ExampleEnum.values()para então chamar .getDomainId()cada valor por vez de dentro do seu processador de anotações: Você executa durante a compilação , o ExampleEnumé apenas um arquivo de origem neste ponto, ele ainda não existe como um arquivo de classe. Mesmo que existisse, carregar classes arbitrárias durante a compilação é um problema de ovo e galinha e, portanto, uma ideia bastante ruim que tornará seu código muito frágil. Por exemplo, se um de seus enums usar um tipo não Java-core em qualquer lugar, por exemplo, um método public SomeTypeYouDefined getFoo()? A compilação explode; seu código não pode mais ser compilado.

    Assim chegamos à resposta à sua pergunta: Infelizmente, o que você quer é impossível .

    Outro problema é que sua "definição" do que você quer é fundamentalmente impraticável.

    Por exemplo, aqui está uma implementação correta do seu sistema:

    public enum MyHackyEnum implements DomainEnum {
  A, B, C;

  @Override public String getDomainId() {
    return "foo-" + LocalDateTime.now();
  }
}

    Você não terá um erro de compilador ou um erro de tempo de execução, isso 'simplesmente funcionará', mas obviamente qualquer tentativa em tempo de compilação de criar um mapeamento de todos os IDs de domínio falhará completamente. Esse é um lugar ruim para se estar.

    Eu sugiro fortemente que você pare com esse plano. Ele simplesmente não "se encaixa". Fazer coisas em tempo de compilação onde uma das entradas depende de implementações de um método decretado por uma interface nunca é uma boa ideia por esse exato motivo.

    É isso que você realmente quer.

    Anote as próprias constantes enum!

    > cat Test.java

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@interface DomainId {
  String value();
}

interface DomainEnum {
  public default String getDomainId() {
     try {
       Enum<?> self = (Enum<?>) this;
       return self.getDeclaringClass().getField(self.name()).getAnnotation(DomainId.class).value();
     } catch (ClassCastException e) {
       throw new IllegalStateException("Only enums must implement DomainEnum. Class " + this.getClass() + " violates this rule");
     } catch (NoSuchFieldException e) {
       throw new RuntimeException("Unexpected - an enum value isnt a field in its own def?", e);
     }
  }
}

enum MyDomainEnum implements DomainEnum {
  @DomainId("1") A,
  @DomainId("2") B,
  @DomainId("3") C,
}

public class Test {
  public static void main(String[] args) {
    System.out.println(MyDomainEnum.A.getDomainId());
  }
}

> javac Test.java
> java Test
1

    Este trecho é independente, basta inseri-lo Test.javae seguir em frente.

    O snippet mostra como você pode acessar os IDs de domínio em tempo de execução. Acessá-los em tempo de anotação seria um exemplo autônomo significativamente mais complexo, mas é lógica básica de processamento de anotação. Acione na anotação e inspecione o 'elemento' que a anotação está anotando. Os valores Enum são tratados como campos para esse propósito, e você pode obter o nome deles em seu processador de anotação muito bem.

    NB: O exemplo acima precisa de algum desenvolvimento; detectar que a DomainIdanotação está faltando e produzir uma exceção apropriada, por exemplo. Seu processador de anotação deve detectar quaisquer enums que implementam, DomainEnummas não têm uma @DomainIdanotação em cada constante que definem e emitir um erro. Isso é coisa básica de AP e não requer truques especiais: você pode 'obter' todos os arquivos de origem sendo compilados como AP facilmente (inscreva-se *como uma anotação para obtê-los), você pode perguntar por todos os tipos de nível superior neles, então filtrá-los para enums, então filtrar todos os enums que não implementam DomainEnume partir daí.

    Como o 'ID de domínio' é transmitido por meio de um parâmetro de anotação, o próprio compilador forçará os autores de quaisquer enumerações de domínio a tornar esses valores constantes, eliminando assim completamente o exemplo complicado.

    NB: O Lombok hackeia diretamente todo o AST, mas o lombok não é um processador de anotações e tem vários caminhos de código para as várias implementações AST comumente usadas por aí. Você provavelmente não quer seguir esse caminho, mas se realmente quiser, pode bifurcar o lombok e adicionar um processador lombok (você não precisa de uma anotação; os plugins do lombok veem todo o código e, portanto, podem decidir apenas escanear os tipos de enumeração que implementam DomainEnume procurar por eles). Mas você ainda teria que ditar, conforme a documentação, que todas as enumerações de domínio DEVEM ter seu ID de domínio como primeiro parâmetro de cada valor constante de enumeração. Eu seguiria o plano acima, muito mais simples e melhor.

    • 6

relate perguntas