0Pricing
Java Academy · Aula

Políticas de Retenção e Tipos de Destino

Escolha a retenção SOURCE, CLASS ou RUNTIME e restrinja os elementos de destino com @Target.

Políticas de Retenção e Tipos de Destino é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

As três políticas de retenção

SOURCE: descartada pelo compilador (útil apenas para APT). CLASS: gravada em arquivos .class, mas não disponível em tempo de execução. RUNTIME: disponível por reflexão. A maioria das anotações de estruturas usa RUNTIME.

Retenção SOURCE: somente em tempo de compilação

As anotações SOURCE são processadas por processadores de anotações e depois descartadas. @Override e @SuppressWarnings são SOURCE — informam o compilador, mas não ficam no arquivo .class.

@Retention(RetentionPolicy.SOURCE)
public @interface GenerateBuilder {}
// APT generates a Builder class when it sees @GenerateBuilder
// The annotation itself disappears from the compiled output

Retenção CLASS: análise de bytecode

As anotações CLASS são incluídas em arquivos .class para ferramentas de análise de bytecode (PMD, FindBugs, ASM), mas NÃO são legíveis em tempo de execução por reflexão.

@Retention(RetentionPolicy.CLASS)
public @interface ThreadSafe {}
// Visible in bytecode, invisible to Class.getAnnotation() at runtime

Retenção RUNTIME: processamento por reflexão

As anotações RUNTIME permanecem disponíveis em tempo de execução e podem ser lidas com getAnnotation(). Spring, JUnit, Jackson e Hibernate usam retenção RUNTIME.

@Retention(RetentionPolicy.RUNTIME)
public @interface Route {
    String path();
    String method() default "GET";
}
// At runtime:
Route r = handler.getClass().getMethod("handle").getAnnotation(Route.class);
System.out.println(r.path()); // e.g. "/users"

@Target: restringindo os pontos de aplicação

@Target usa constantes de ElementType para restringir onde a anotação pode aparecer. Aplicá-la a um elemento não permitido causa um erro em tempo de compilação.

import static java.lang.annotation.ElementType.*;
@Target({METHOD, CONSTRUCTOR})
@Retention(RetentionPolicy.RUNTIME)
public @interface Measured {}

Todos os valores de ElementType

Lista completa: TYPE (classe/interface/enumeração), FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, ANNOTATION_TYPE, PACKAGE, TYPE_PARAMETER (parâmetro de tipo genérico), TYPE_USE (qualquer uso de um tipo).

// TYPE_USE: annotate any type reference
@NotNull String name;
List<@NonNull String> items;
public @Valid User createUser(@NotNull String name) { ... }

TYPE vs TYPE_USE

TYPE tem como alvo declarações de classe/interface/enumeração. TYPE_USE (Java 8+) tem como alvo qualquer uso de um tipo, incluindo tipos genéricos, conversões e cláusulas extends — permitindo anotações de segurança contra valores nulos no nível do tipo.

@Target(ElementType.TYPE_USE)
@interface NonNull {}
// Can be applied to:
List<@NonNull String> list;
@NonNull String result = (@NonNull String) obj;

Combinando Target e Retention

A maioria das anotações úteis de estruturas combina retenção RUNTIME com alvos específicos. Exemplo: uma anotação de validação aplicada somente a campos.

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Range {
    int min() default 0;
    int max() default Integer.MAX_VALUE;
}

Herdando anotações com @Inherited

@Inherited é uma meta-anotação que faz com que anotações no nível da classe sejam herdadas pelas subclasses. Ela não tem efeito sobre anotações de métodos ou campos.

@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@interface Framework {}
@Framework class Base {}
class Child extends Base {} // @Framework visible on Child too

@Documented: inclusão no Javadoc

Aplique @Documented para que a anotação apareça no Javadoc gerado para os elementos anotados. Sem ela, as anotações ficam invisíveis na documentação da API.

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Auditable {
    String description() default "";
}

Lendo informações de retenção em tempo de execução

Você pode inspecionar a retenção de um tipo de anotação usando getAnnotation(Retention.class) no objeto de classe que representa a classe da anotação.

Retention r = Retry.class.getAnnotation(Retention.class);
System.out.println(r.value()); // RUNTIME, CLASS, or SOURCE

Verificação rápida

Qual ElementType abrange declarações de classe, interface e enumeração?

Recapitulação

Use SOURCE para ferramentas de tempo de compilação, CLASS para análise de bytecode e RUNTIME para estruturas baseadas em reflexão. Restrinja o uso com @Target para evitar usos indevidos. Adicione @Documented para anotações de API e @Inherited para anotações de hierarquias de classes.

Perguntas Frequentes

A aula “Políticas de Retenção e Tipos de Destino” é grátis?

Sim — o texto completo de “Políticas de Retenção e Tipos de Destino” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Políticas de Retenção e Tipos de Destino”?

Escolha a retenção SOURCE, CLASS ou RUNTIME e restrinja os elementos de destino com @Target. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Políticas de Retenção e Tipos de Destino”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Definição de Anotações: Elementos e Valores Padrão
  2. Políticas de Retenção e Tipos de Destino
  3. Processamento de Anotações em Tempo de Execução
  4. Processadores de Anotações em Tempo de Compilação
← Voltar para Java Academy