Entendiendo las Java annotations: una guía rápida

Las Java annotations son un herramientas que permiten asociar metadatos a elementos de tu código, entre los que se encuentran clases, métodos o variables. Si bien no modifican el comportamiento de un programa, las Java annotations nos facilitan muchas tareas, como el manejo de configuraciones y optimizaciones en el código. Por eso, el día de hoy queremos darte una guía rápida de qué son las anotaciones y cómo funcionan por medio de ejemplos.

¿Qué son las Java annotations?

Las Java annotations son etiquetas que se añaden a nuestro código con la finalidad de proporcionar información adicional sobre elementos del programa. Estas no cambian el comportamiento del código, pero le permiten a las herramientas externas y al compilador mismo, interpretar y procesar todos los metadatos.

Hay algunas cosas que debemos tener en cuenta con las Java annotations:

• Comienzan con el símbolo @.
• Pueden aplicarse a clases, métodos, variables, y más.
• No son simples comentarios, ya que pueden influir en cómo se compila o ejecuta el código.
• Son frecuentemente usadas en frameworks como Spring, especialmente en spring annotations para configurar comportamientos del framework.

Usar Java annotations nos permite modificar la manera en la que escribimos código, ya que estas ayudan a reducir la complejidad, suprimen configuraciones XML ininteligibles y eternas y permiten generar metadatos claros.

¿Son comentarios?

¡NO! Las java annotations no son lo mismo que los comentarios de nuestro código. Estos últimos no modifican el comportamiento del código. Por otro lado, las Java annotations son una especie de etiquetas que se le agrega al código para brindarle información extra y estas sí pueden afectar el funcionamiento del programa. Por ejemplo, @Override le dice al compilador que el método está sobreescribiendo uno de la clase superior.

Tipos de Java annotations

Entre las Java annotations tenemos algunos tipos, a saber:

Marker annotations

Las marker annotations no contienen ningún valor y solo marcan una declaración. Su simple presencia en el código es suficiente para proporcionar información. Un ejemplo clásico es @Override, que indica que un método está sobrescribiendo uno de su clase padre:

@Override
public void metodoSobrescrito() {
    // código
}

Single value annotations

Estas anotaciones tienen un único valor que se pasa directamente sin especificar el nombre del parámetro. Por ejemplo, la anotación @Test en JUnit acepta un valor que indica si se espera que el test falle:

@Test(expected = Exception.class)

Full annotations

Este tipo de anotaciones permite definir varios miembros o valores, en un formato de pares clave-valor. Un ejemplo es la anotación @RequestMapping en Spring, que se utiliza para asignar una URL a un método controlador:

@RequestMapping(path = "/api/usuarios", method = RequestMethod.GET)

Type annotations

Las type annotations pueden aplicarse a cualquier lugar donde se use un tipo, por ejemplo, en variables o tipos de retorno de métodos. Estas anotaciones son útiles cuando se necesita añadir metadatos a nivel de tipos:

public @Nullable String getNombre() {
    return this.nombre;
}

Repeating annotations

Las repeating annotations permiten aplicar la misma anotación más de una vez a un mismo elemento. Esto es posible desde Java 8 utilizando la anotación @Repeatable.

@Filter(name = "filter1")
@Filter(name = "filter2")
public class MiClase {
    // código
}

Principales Java annotations predefinidas

Java incluye varias anotaciones predefinidas que son muy útiles en el desarrollo diario. Algunas de las más importantes son:

• @Override: Se utiliza para indicar que un método sobrescribe el de una superclase. Ayuda a evitar errores cuando el método en la subclase no coincide correctamente con el de la clase base.
• @Deprecated: Esta anotación marca que un método, clase o variable no debe ser utilizada más, ya que ha sido reemplazada por una nueva implementación.

@Deprecated
public void metodoAntiguo() {
    // código
}

• @SuppressWarnings: Permite suprimir advertencias que el compilador pueda generar. Podemos hacer uso de ella cuando estamos trabajando con código heredado o experimentando con nuevas APIs.

@SuppressWarnings("unchecked")
public void miMetodo() {
    List lista = new ArrayList(); 
}

¿Cómo crear tus propias Java annotations?

Además de las anotaciones predefinidas, Java te permite crear tus propias annotations personalizadas. Si es requerido añadir información específica a tu código o para desarrollar tus propios frameworks, esta es tu opción más adecuada:

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MiAnotacion {
    String valor() default "valorPorDefecto";
}

En este ejemplo estamos creando una anotación que se puede aplicar a métodos (ElementType.METHOD) y que estará disponible en tiempo de ejecución (RetentionPolicy.RUNTIME). La anotación tiene un parámetro llamado valor, que tiene un valor predeterminado.

public class MiClase {
    @MiAnotacion(valor = "personalizado")
    public void miMetodo() {
        // código
    }
}

Esta es solo una de las temáticas que abordaremos en nuestro curso de Keepcoding. Únete al bootcamp de java y sigue aprendiendo sobre el lenguaje de programación que ha cambiado el mundo. ¡Anímate!