Como Crear anotaciones en Java
Published: 2023-07-22 21:02:55

Las anotaciones en Java son una poderosa herramienta que permite agregar metadatos personalizados a clases, métodos, variables y otros elementos del código. Estas anotaciones pueden ser utilizadas para proporcionar información adicional, configurar comportamientos especiales o simplificar la lógica de programación. En este artículo, exploraremos cómo crear anotaciones en Java y cómo aprovechar su potencial para mejorar la legibilidad y funcionalidad de tu código.


**¿Qué son las anotaciones en Java?**


En esencia, una anotación en Java es una forma de metadatos que se puede agregar al código fuente. Las anotaciones comienzan con el símbolo @, seguido del nombre de la anotación. Estas pueden incluir parámetros que se utilizan para personalizar su comportamiento.

Java incluye muchas anotaciones integradas, como `@Override`, `@Deprecated` y `@SuppressWarnings`, que proporcionan información adicional sobre el código. Sin embargo, también puedes crear tus propias anotaciones personalizadas para adaptarlas a tus necesidades específicas.

**Creando una Anotación Personalizada**

Para crear una anotación personalizada en Java, debes definir una nueva interfaz y marcarla con la anotación `@interface`. Veamos un ejemplo sencillo de una anotación para marcar métodos que requieren ser probados exhaustivamente:

```
package com.asinaluisa.annotations;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface ApiClass {
    String value() default "";

    String keyProjectId() default "{projectId}";

    String[] methods() default {};

    String[] methodclass() default {};

    String[] keyPath() default {};    

}
```

En este ejemplo, hemos creado la anotación `@ApiClass`. También hemos especificado que la anotación debe conservarse en tiempo de ejecución `(RetentionPolicy.RUNTIME)`, lo que permitirá que se acceda a ella mediante reflexión.

La anotación tiene varios parámetros, responsable y casos, que son de tipo String y String[], respectivamente. Estos parámetros permitirán proporcionar información adicional al marcar una clase con esta anotación. 


**Aplicando la Anotación en Código**

Una vez creada la anotación, podemos aplicarla a un método en nuestro código. Supongamos que tenemos una clase `Folder `y queremos relacionarla con una url para enviar los datos a un API Rest, 

```

@ApiClass(value="/projects/{projectId}/testcase-folders",
            keyProjectId = "{projectId}", methods = {"POST","GET","PUT","DELETE","GET"},
            methodclass = {"save","get","update","delete","getAll"}, keyPath = {"{projectId}"}
)
public class Folder extends QMetryAPI<Folder>  {

    private String folderName;
    private int parentId;

    public Folder() {
        super("10000");
    }


    public Folder(String folderName, int parentId) {
        this.folderName = folderName;
        this.parentId = parentId;
    }


    public String getFolderName() {
        return folderName;
    }

    public int getParentId() {
        return parentId;
    }

    public void setFolderName(String folderName) {
        this.folderName = folderName;
    }

    public void setParentId(int parentId) {
        this.parentId = parentId;
    }

}
```

En este caso, hemos aplicado la anotación `@ApiClass` a la clase `Folder`, proporcionando valores para los parámetros.

**Recuperando Anotaciones mediante Reflexión**

Un aspecto interesante de las anotaciones en Java es que puedes recuperar la información que contienen mediante reflexión. Esto es útil cuando deseas analizar o procesar la anotación en tiempo de ejecución. A continuación, se muestra un ejemplo sencillo de cómo recuperar la información de la anotación 

```
@ApiClass
```
 aplicada en la clase Padre `QMetryAPI<T>`

```
public class QMetryAPI<T>{
    
    private final String URL = "https://private-anon-643f6a92e0-qmetryforjiracloud40.apiary-mock.com/rest/api/latest";

    private final String APIKEY = "";
    


    public T save() {
        ApiClass api = null ;
        Class<?> subclase =  this.getClass();

        api = getApiClass(subclase);
        
       
        String[] methods = api.methods();
        String[] methodsClass = api.methodclass();
        String Path =api.value();
        
    }

    protected ApiClass getApiClass(Class<?> c){
        ApiClass apiClass = null;

        boolean isApiClass = c.isAnnotationPresent(ApiClass.class);
        
        
        
        if (isApiClass) {
            apiClass = c.getAnnotation(ApiClass.class);
        }
        return apiClass;
    }
}
```


Las anotaciones en Java son una característica valiosa que te permite agregar metadatos personalizados a tu código. Al crear tus propias anotaciones, puedes mejorar la legibilidad, el mantenimiento y la funcionalidad de tus programas, proporcionando información adicional o configurando comportamientos específicos. Además, la capacidad de recuperar anotaciones mediante reflexión abre un mundo de posibilidades para la creación de bibliotecas y marcos avanzados.