Skip to main content

In this article

Mejora tu aplicación Java con Records

Escrito por
Headshot of Liran Tal

Liran Tal

0 minutos de lectura

Los records de Java son una nueva característica del lenguaje que se introdujo en JDK 16 para simplificar la creación de clases centradas en datos que sirven principalmente como contenedores de datos. En otras palabras, los records son una forma concisa de declarar una clase pensada para contener datos de manera sencilla, no para tener comportamientos complejos.

Los records ofrecen una sintaxis compacta para declarar clases que se usan principalmente para almacenar datos inmutables, lo que reduce el código repetitivo necesario al trabajar con ellas. Esto hace que crear y mantener clases de datos sea más fácil, rápido y menos propenso a errores.

Aquí tienes un ejemplo de cómo crear un record sencillo para un punto en un espacio 2D:

```java
record Point(int x, int y) { }
```

Esta única línea de código genera automáticamente un constructor, accesores para los campos y los métodos equals(), hashCode() y toString() con el comportamiento adecuado. Así, se reduce la cantidad de código que hay que escribir y mantener.

La importancia de Records para mejorar la seguridad de las aplicaciones y el desarrollo de software

Records ofrece varios beneficios:

Inmutabilidad

Una de las características clave de records es que son inmutables de forma predeterminada. Los objetos inmutables son aquellos cuyo estado no puede cambiar una vez creados. Esto es importante para la seguridad porque reduce la posibilidad de que se realicen modificaciones no autorizadas en los datos que contiene el record, lo que dificulta que un atacante aproveche vulnerabilidades relacionadas con un estado mutable.

La inmutabilidad también ofrece beneficios en el desarrollo de software, ya que facilita el razonamiento sobre el código y puede mejorar el rendimiento del código concurrente al reducir la necesidad de sincronización.

Menos código repetitivo

Records ayuda a reducir el código repetitivo al generar automáticamente métodos como equals(), hashCode() y toString(). Esto hace que el código sea más conciso y fácil de leer, y reduce la posibilidad de introducir errores o vulnerabilidades al implementar estos métodos.

Por ejemplo, un problema de seguridad común relacionado con el método equals() es la posibilidad de introducir un ataque de temporización al comparar datos confidenciales, como claves criptográficas. Al usar Records y sus métodos generados automáticamente, los desarrolladores pueden evitar el riesgo de introducir este tipo de vulnerabilidades.

Encapsulación

Records promueve buenas prácticas de encapsulación al exigir que los desarrolladores declaren los campos como parte de la declaración del record. Esto deja claro qué datos debe contener el record y garantiza que los campos sean finales y privados, lo que reduce el riesgo de acceso o modificación no autorizados de los datos.

Además, Records genera automáticamente accesores para los campos, que se pueden usar para aplicar comprobaciones de seguridad o lógica de validación adicionales, si es necesario.

En conclusión, Records en Java ofrece a los desarrolladores una forma concisa y segura de crear clases centradas en datos, menos propensas a vulnerabilidades y más fáciles de mantener. Al aprovechar la inmutabilidad, la reducción del código repetitivo y la encapsulación, Records puede ayudar a mejorar la seguridad y la calidad general de tus aplicaciones Java.

Comparación con las clases tradicionales de Java

Antes de la introducción de Records, crear una clase sencilla para transportar datos en Java requería mucho código repetitivo. Por ejemplo, una implementación tradicional de la clase Point sería así:

```java
public class Point {
    private final int x;
    private final int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        Point other = (Point) obj;
        return x == other.x && y == other.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }

    @Override
    public String toString() {
        return "Point{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }
}
```

Como puedes ver, la implementación de una clase tradicional de Java es mucho más extensa que su equivalente con Java Record. Con Records, los desarrolladores pueden centrarse en los datos esenciales que necesitan transportar sus clases y dedicar menos tiempo a escribir código repetitivo. El resultado es un código más claro, fácil de mantener y seguro, aspectos fundamentales para la seguridad de las aplicaciones y las buenas prácticas de desarrollo de software.

En conclusión, Java Records ofrece una forma concisa y segura de crear clases sencillas para transportar datos, reduce el código repetitivo y mejora la legibilidad y la facilidad de mantenimiento. Si usas Records para tus objetos de transferencia de datos, puedes mejorar la seguridad y la calidad general de tus aplicaciones Java.

Beneficios de usar Java Records

Simplicidad del código

En esta sección, veremos cómo el uso de Java Records puede mejorar la simplicidad y la legibilidad de tu código. Records es una forma concisa de modelar clases que solo contienen datos en Java, lo que facilita el mantenimiento y la comprensión de tu base de código. Esto es especialmente importante en el contexto de la seguridad de las aplicaciones, ya que el código complejo puede provocar vulnerabilidades de seguridad y dificultar la detección y corrección de posibles problemas.

Sintaxis concisa de Records

Java Records se introdujo en JDK 14 como una característica preliminar y, más adelante, se convirtió en una característica estándar en JDK 16. Ofrece una forma concisa de definir clases sencillas destinadas a contener datos. Al usar Records, los desarrolladores pueden reducir el código repetitivo y mejorar la legibilidad. Veamos un ejemplo.

Considera una clase Person sencilla, sin usar Records:

```java
public class Person {
    private final String name;
    private final int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}
```

Ahora veamos cómo se puede representar la misma clase Person con Records:

```java
public record Person(String name, int age) {}
```

Como puedes ver, la sintaxis de Records es mucho más concisa y fácil de leer, lo que la convierte en una herramienta valiosa para mejorar la simplicidad y la legibilidad del código.

Generación automática de métodos comunes

Otra ventaja de usar Java Records es la generación automática de métodos comunes, como equals(), hashCode() y toString(). Estos métodos son esenciales para comparar objetos y mostrar su contenido en un formato legible para las personas.

Al usar clases normales, los desarrolladores suelen tener que implementar estos métodos manualmente, lo que puede llevar tiempo y generar errores. En cambio, Records genera estos métodos automáticamente según los componentes declarados en la definición del record.

Veamos cómo puede beneficiar a nuestro ejemplo de Person. 

En una clase Person normal, podrías implementar los métodos equals() y hashCode() así:

```java
@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Person person = (Person) o;
    return age == person.age && Objects.equals(name, person.name);
}

@Override
public int hashCode() {
    return Objects.hash(name, age);
}
```

Y el método toString() así:

```java
@Override
public String toString() {
    return "Person{" +
            "name='" + name + '\'' +
            ", age=" + age +
            '}';
}
```

Sin embargo, al usar un Record, no tienes que implementar estos métodos manualmente. La misma funcionalidad se genera automáticamente para nuestro Record Person:

```java
public record Person(String name, int age) {}
```

La generación automática de métodos comunes ayuda a reducir el código repetitivo y a mejorar su legibilidad, lo que facilita que los desarrolladores mantengan una base de código segura y eficiente.

En conclusión, Java Records ofrece una forma concisa y legible de definir clases que solo contienen datos, reduce el código repetitivo y mejora la facilidad de mantenimiento general de tu aplicación. Al aprovechar los beneficios de Records, los desarrolladores pueden crear código más seguro y eficiente, lo que contribuye a mejorar la postura de seguridad general de la aplicación.

Mayor legibilidad y facilidad de mantenimiento

Una de las principales ventajas de usar Java Records es que mejora la legibilidad y la facilidad de mantenimiento del código. Records genera automáticamente implementaciones concisas y estandarizadas de métodos comunes, como equals(), hashCode() y toString(). Esto reduce el código repetitivo y elimina posibles errores e inconsistencias.

Considera el siguiente ejemplo de una clase tradicional de Java:

```java
public class Point {
    private final int x;
    private final int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    @Override
    public boolean equals(Object obj) {
        // ... implementation ...
    }

    @Override
    public int hashCode() {
        // ... implementation ...
    }

    @Override
    public String toString() {
        // ... implementation ...
    }
}
```

Ahora compárala con el Java Record equivalente:


```java
public record Point(int x, int y) {}
```

Como puedes ver, la versión con Record es mucho más corta, fácil de leer y menos propensa a errores.

Inmutabilidad y seguridad

La inmutabilidad es un aspecto esencial de la seguridad de las aplicaciones. Cuando los objetos son inmutables, no se pueden modificar después de crearse, lo que ayuda a prevenir varios problemas de seguridad, como la manipulación no autorizada de datos y las condiciones de carrera.

Java Records es inmutable por naturaleza, ya que su estado se define mediante campos finales que corresponden a los componentes del record. Esto significa que, una vez creado un objeto record, su estado no puede cambiar, por lo que es una opción segura para modelar tus datos.

```java
public final class ImmutablePerson {
    private final String firstName;
    private final String lastName;

    public ImmutablePerson(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }
}
```

Prevención de la manipulación involuntaria de datos

La inmutabilidad ofrece una sólida protección contra la manipulación o corrupción involuntaria de datos. Cuando un objeto es inmutable, su estado no puede cambiar por acción de código externo ni de actores maliciosos. Esto evita las modificaciones no autorizadas en los datos del objeto y garantiza la integridad del estado de la aplicación.

Considera una aplicación que administra datos confidenciales de usuarios. Si los datos se almacenan en objetos mutables, un atacante podría obtener acceso no autorizado y modificarlos. Al usar objetos inmutables, puedes prevenir este tipo de ataques, ya que el atacante no puede cambiar el estado de esos objetos.

```java
public class SensitiveData {
    private final ImmutablePerson owner;
    private final String secret;

    public SensitiveData(ImmutablePerson owner, String secret) {
        this.owner = owner;
        this.secret = secret;
    }

    public ImmutablePerson getOwner() {
        return owner;
    }

    public String getSecret() {
        return secret;
    }
}
```

Reducción de la superficie de ataque vulnerable

Los objetos inmutables ayudan a reducir la superficie de ataque de una aplicación Java, ya que limitan las posibilidades que tienen los atacantes de aprovechar el código. Cuando tienes un objeto inmutable, hay menos puntos de entrada que un atacante pueda usar para manipular el estado de la aplicación.

En los objetos mutables tradicionales, cada método setter o campo público es un posible punto de ataque. Al eliminar estos métodos y campos, puedes reducir considerablemente la posibilidad de que se produzca una vulnerabilidad de seguridad debido a cambios no autorizados en los datos de la aplicación.

Java Records, introducido en JDK 16, ofrece una forma sencilla de crear clases de datos inmutables con un mínimo de código repetitivo. Records es implícitamente final y sus campos son inmutables. Genera automáticamente constructores, accesores y los métodos equals(), hashCode() y toString() según los campos declarados.

```java
public record ImmutablePersonRecord(String firstName, String lastName) { }
```

Este record equivale a la clase ImmutablePerson que definimos antes, con la ventaja de que requiere menos código repetitivo.

En conclusión, la inmutabilidad es un concepto poderoso que puede mejorar considerablemente la seguridad y la resiliencia de tus aplicaciones Java. Los objetos inmutables pueden prevenir la manipulación involuntaria de datos, reducir la superficie de ataque y garantizar la integridad del estado de tu aplicación. Considera usar Java Records u otras técnicas para adoptar la inmutabilidad en tus aplicaciones Java y mejorar su postura de seguridad.

Mejor rendimiento

Records puede mejorar el rendimiento de tu aplicación gracias a su simplicidad e inmutabilidad. La inmutabilidad permite varias optimizaciones, como almacenar en caché los resultados de cálculos costosos o reducir la necesidad de sincronización en un entorno multiproceso.

Además, Records ofrece implementaciones más eficientes de los métodos equals(), hashCode() y toString(), lo que puede mejorar el rendimiento cuando se usan con frecuencia, por ejemplo, en colecciones o en canales de procesamiento de datos.

Reducción del código repetitivo

Java Records es una nueva característica introducida en JDK 14 que simplifica la creación de clases de datos. Al usar Records, puedes evitar escribir código repetitivo, como métodos getter y setter, y los métodos equals(), hashCode() y toString(). Records genera estos métodos automáticamente a partir de las propiedades proporcionadas.

Para mostrar cómo se reduce el código repetitivo, creemos una clase Person sencilla con Java tradicional y luego creemos la misma clase con un Record.

**Clase tradicional de Java:**

```java
public class Person {
    private final String firstName;
    private final String lastName;
    private final int age;

    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    @Override
    public boolean equals(Object o) {
        // ... implementation here
    }

    @Override
    public int hashCode() {
        // ... implementation here
    }

    @Override
    public String toString() {
        // ... implementation here
    }
}
```

**Versión con Record:**

```java
public record Person(String firstName, String lastName, int age) {}
```

Como puedes ver, la versión con Record de la clase Person es mucho más concisa y fácil de leer. Esto no solo mejora la legibilidad del código, sino que también reduce la posibilidad de introducir errores debido a equivocaciones humanas al escribir código repetitivo.

Uso optimizado de la memoria

Otra mejora del rendimiento que ofrece el uso de Records es la optimización del uso de memoria. Como Records es inmutable y sus propiedades son finales, la JVM puede optimizar el uso de memoria de manera más eficiente. Esto resulta especialmente útil cuando tienes varias instancias de una clase y quieres reducir al mínimo la huella de memoria.

Por ejemplo, supongamos que tienes una aplicación que procesa una lista de objetos Person. Si usas una clase tradicional de Java, cada objeto Person tendrá memoria asignada para almacenar las propiedades firstName, lastName y age.

Sin embargo, al usar un Record, la JVM puede optimizar el uso de memoria al compartir las propiedades entre instancias que tienen los mismos valores. Esto puede generar un ahorro considerable de memoria cuando tienes varios objetos con los mismos valores de propiedades.

Además, gracias a su inmutabilidad, los Records permiten usar la memoria de forma más eficiente en escenarios de programación concurrente.

En conclusión, Java Records es una potente función que puede ayudarte a mejorar el rendimiento de tus aplicaciones Java al reducir el código repetitivo y optimizar el uso de memoria. Al adoptar Records en tus proyectos, puedes escribir código más limpio y fácil de mantener, y lograr un mejor rendimiento de las aplicaciones.

Integración sencilla con el código existente

Java Records está diseñado para funcionar sin problemas con el código y las bibliotecas existentes de Java. Así, puedes incorporar Records gradualmente a tu aplicación sin tener que reescribirla ni modificar su arquitectura de forma significativa. Las clases existentes se pueden convertir fácilmente en Records, y puedes usar Records como argumentos de métodos, valores de retorno o en estructuras de datos, igual que cualquier otro objeto de Java.

Cómo usar Java Records en tu aplicación

Configura tu entorno de desarrollo

Para empezar a mejorar tu aplicación Java con Records, configura correctamente tu entorno de desarrollo. En esta sección, veremos la versión de JDK necesaria y la compatibilidad de los IDE con Java Records.

Versión de JDK necesaria

Java Records se introdujo como una función de vista previa en JDK 14 y se finalizó en JDK 16. Por lo tanto, para usar Java Records, necesitas tener instalado JDK 16 o una versión posterior en tu sistema. Puedes descargarlo desde el [sitio web oficial de Oracle](https://www.oracle.com/java/technologies/javase-jdk16-downloads.html).

Para comprobar la versión de JDK instalada, abre una terminal o un símbolo del sistema y ejecuta el siguiente comando:

```sh
java -version
```

Asegúrate de que el resultado muestre JDK 16 o una versión posterior. Si tienes varias versiones de JDK instaladas, puedes configurar la variable de entorno JAVA_HOME para que apunte al directorio de instalación de JDK 16.

Compatibilidad de los IDE con Java Records

La mayoría de los IDE modernos son compatibles con Java Records. A continuación, se indican los pasos para configurar algunos IDE populares para trabajar con Java Records:

IntelliJ IDEA

IntelliJ IDEA es compatible con Java Records desde la versión 2020.1. Asegúrate de tener instalada la versión más reciente de IntelliJ IDEA. Para configurar el JDK en IntelliJ IDEA, sigue estos pasos:

1. Abre IntelliJ IDEA y crea un proyecto o abre uno existente.

2. Ve a File > Project Structure.

3. En la sección Project Settings, haz clic en Project.

4. Configura Project SDK para que use JDK 16 o una versión posterior. Si no está disponible, haz clic en New... y selecciona el directorio de instalación de JDK 16.

5. Configura Project language level como 16 - Records, sealed types, patterns, local enums, and interfaces.

6. Haz clic en OK para guardar los cambios.

Ahora, IntelliJ IDEA está configurado para trabajar con Java Records.

Eclipse

Eclipse es compatible con Java Records desde la versión 4.16 (2020-06). Asegúrate de tener instalada la versión más reciente de Eclipse. Para configurar el JDK en Eclipse, sigue estos pasos:

1. Abre Eclipse y crea un proyecto de Java o abre uno existente.

2. Haz clic con el botón derecho en el proyecto en Package Explorer y selecciona Properties.

3. En la sección Java Build Path, haz clic en la pestaña Libraries.

4. Haz clic en Add Library..., selecciona JRE System Library y haz clic en Next.

5. Elige Workspace default JRE y selecciona JDK 16 o una versión posterior en la lista desplegable. Haz clic en Finish.

6. En la sección Java Compiler, configura Compiler compliance level como 16.

7. Haz clic en Apply and Close para guardar los cambios.

Ahora, Eclipse está configurado para trabajar con Java Records.

Visual Studio Code

Visual Studio Code es compatible con Java Records mediante la extensión [Language Support for Java(TM) by Red Hat](https://marketplace.visualstudio.com/items?itemName=redhat.java). Asegúrate de tener instalada la versión más reciente de Visual Studio Code y la extensión de Java. Para configurar el JDK en Visual Studio Code, sigue estos pasos:

1. Abre Visual Studio Code y crea un proyecto de Java o abre uno existente.

2. Presiona Ctrl+Shift+P (o Cmd+Shift+P en macOS) para abrir la paleta de comandos.

3. Escribe Java: Configure Java Runtime y presiona Enter.

4. En la sección Java Tooling Runtime, haz clic en JDK y selecciona JDK 16 o una versión posterior en la lista desplegable.

5. Reinicia Visual Studio Code para aplicar los cambios.


Ahora, Visual Studio Code está configurado para trabajar con Java Records.

Con tu entorno de desarrollo listo, ya puedes empezar a usar Java Records para mejorar la legibilidad, la inmutabilidad y la seguridad de tu aplicación Java.

Crear un Record

En esta sección, explicaremos la sintaxis y la estructura básicas de los records de Java, y presentaremos un ejemplo de código que muestra cómo crear una declaración de record sencilla. Los records son una función práctica que se introdujo como función de vista previa en Java 14 y se finalizó en Java 16 para simplificar la creación de clases de datos. En esencia, un record es una clase que se usa para almacenar datos inmutables con un mínimo de código repetitivo.

Sintaxis y estructura básicas

La sintaxis básica para declarar un record en Java es la siguiente:

```java
record RecordName (Type1 field1, Type2 field2, ..., TypeN fieldN) {
    // Additional methods and logic can be added here
}
```

Una declaración de record consta de la palabra clave record, seguida del nombre del record y una lista de campos entre paréntesis. Los campos se declaran con sus respectivos tipos y nombres, separados por comas. El cuerpo del record, delimitado por llaves, puede contener métodos y lógica adicionales si es necesario.

Veamos las características principales de los records:

1. Los records son inmutables de forma predeterminada, lo que significa que, una vez creada una instancia, no se pueden cambiar los valores de sus campos.

2. Los campos de un record son final y, por lo tanto, no se pueden modificar.

3. Los records generan automáticamente implementaciones predeterminadas de los siguientes métodos: equals(), hashCode(), toString() y los métodos de acceso (getters) de cada campo.

4. Los records pueden tener métodos y lógica adicionales, pero no pueden tener campos de instancia mutables.

Ejemplo de código: declaración de un record sencillo

En este ejemplo, crearemos una declaración de record sencilla para un record Person que contiene tres campos: firstName, lastName y age.

```java
public record Person(String firstName, String lastName, int age) {
    // Additional methods and logic can be added here, if needed
}
```

Ahora, creemos una instancia del record Person y veamos cómo funcionan los métodos generados automáticamente:

```java
public class Main {
    public static void main(String[] args) {
        Person person = new Person("John", "Doe", 30);

        // Accessor methods (getters) are automatically generated
        String firstName = person.firstName();
        String lastName = person.lastName();
        int age = person.age();

        // Default implementation of toString()
        System.out.println(person); // Output: Person[firstName=John, lastName=Doe, age=30]

        // Default implementation of equals()
        Person person2 = new Person("John", "Doe", 30);
        System.out.println(person.equals(person2)); // Output: true
    }
}
```

Como puedes ver, pudimos crear una declaración de record sencilla con muy poco código repetitivo, y los métodos de acceso generados, toString() y equals(), funcionan como se esperaba.

En conclusión, los records de Java ofrecen una forma concisa y práctica de crear clases de datos inmutables que requieren muy poco código. Al usar records, puedes mejorar la legibilidad y la facilidad de mantenimiento de tus aplicaciones Java, y también reforzar su seguridad al garantizar la inmutabilidad.

Agregar métodos y validación a los Records

Java Records, introducido en JDK 16, es una nueva forma de crear clases de datos sencillas y concisas, enfocadas en almacenar datos mutables. Aunque los Records están diseñados principalmente para ser inmutables y contener solo métodos de acceso sencillos, puedes agregarles métodos personalizados y lógica de validación. En esta sección, veremos cómo agregar métodos personalizados y lógica de validación a Java Records para mejorar la seguridad y la solidez de tu aplicación.

Agregar métodos personalizados a los Records

Una de las ventajas de usar Records es que generan automáticamente métodos de acceso, equals(), hashCode() y toString(). Sin embargo, tal vez quieras agregar métodos personalizados para realizar cálculos u operaciones específicas relacionadas con los datos almacenados en el Record. Para hacerlo, basta con definir el método personalizado dentro del cuerpo del Record. Ten en cuenta que estos métodos no deben modificar los datos almacenados en el Record, para mantener la inmutabilidad.

Este es un ejemplo de cómo agregar un método personalizado a un Record:

```java
record Employee(String name, int age, double salary) {
    public double calculateYearlyBonus() {
        return salary * 0.1;
    }
}
```

En este ejemplo, agregamos el método personalizado calculateYearlyBonus() al Record Employee. Este método calcula el bono anual según el salario del empleado.

Ejemplo de código: agregar validación a un Record

Agregar validación a un Record es esencial para garantizar que los datos almacenados en él sean válidos y seguros. La validación puede ayudar a prevenir vulnerabilidades de seguridad, como la manipulación de datos o los ataques de inyección. Para agregar validación a un Record, puedes usar el constructor compacto, una forma concisa de definir un constructor en un Record sin especificar los parámetros de manera explícita.

Este es un ejemplo de cómo agregar validación a un Record:

```java
record EmailAddress(String email) {
    public EmailAddress {
        if (email == null || email.isBlank()) {
            throw new IllegalArgumentException("Email cannot be null or blank");
        }

        if (!isValidEmail(email)) {
            throw new IllegalArgumentException("Invalid email format");
        }
    }

    private static boolean isValidEmail(String email) {
        // Use a regex pattern or a library to validate the email format
        // For simplicity, we use a basic regex pattern here
        String emailPattern = "^[A-Za-z0-9+_.-]+@(.+)$";
        return email.matches(emailPattern);
    }
}
```

En este ejemplo, agregamos validación al Record EmailAddress para asegurarnos de que el correo electrónico no sea nulo ni esté en blanco, y que tenga un formato válido. Usamos un constructor compacto para agregar la lógica de validación y un método privado isValidEmail() para comprobar el formato del correo electrónico.

Con estas técnicas, puedes mejorar la seguridad y la solidez de tus aplicaciones Java agregando métodos personalizados y lógica de validación a tus Records. Así, puedes garantizar que los datos de tu aplicación sigan siendo seguros y válidos, y mejorar su calidad y resiliencia generales.

Usar Records con otras funciones de Java

Java Records, que se introdujo como función de vista previa en JDK 14 y se finalizó en JDK 16, aporta un nuevo nivel de simplicidad y concisión al lenguaje. Son especialmente útiles para modelar clases que transportan datos, que tradicionalmente requieren mucho código repetitivo. En esta sección, veremos cómo usar Records con otras funciones de Java, como las interfaces y la herencia, para mejorar la seguridad y la facilidad de mantenimiento del código de tu aplicación Java.

Records e interfaces

Aunque un Record no puede extender otra clase, sí puede implementar una o más interfaces. Esto te permite usar Records junto con patrones de diseño establecidos y aprovechar las ventajas tanto de los Records como de las interfaces en tu aplicación. Veamos un ejemplo sencillo.

Supongamos que tenemos una interfaz llamada Displayable que representa objetos que se pueden mostrar en la pantalla:

```java
public interface Displayable {
    String display();
}
```

Podemos crear un Record que implemente esta interfaz:

```java
public record Person(String name, int age) implements Displayable {
    @Override
    public String display() {
        return "Name: " + name + ", Age: " + age;
    }
}
```

En este ejemplo, el Record Person implementa la interfaz Displayable y proporciona una implementación concreta del método display(). Esto permite usar el Record Person en cualquier contexto en el que se espere un objeto Displayable.

Records y herencia

Como se mencionó anteriormente, los Records no pueden extender otras clases. Esto se debe a que los Records son implícitamente final y heredan de la clase java.lang.Record, lo que les impide participar en la herencia tradicional de clases. Sin embargo, como se mostró en el ejemplo anterior, los Records pueden formar parte de una jerarquía de tipos mediante interfaces.

Es importante tener en cuenta que los Records no deben usarse como clases base de otras clases. Su propósito principal es servir como estructuras sencillas e inmutables para transportar datos, y extenderlos con funciones adicionales puede provocar efectos secundarios imprevistos y aumentar la complejidad.

Ejemplo de código: combinar Records con otras funciones de Java

Ahora que ya entendemos los conceptos básicos de cómo funcionan los Records con las interfaces y la herencia, veamos un ejemplo práctico. Supongamos que trabajamos en una aplicación de gestión de proyectos y queremos modelar distintos tipos de tareas.

Podemos empezar por definir una interfaz Task:

```java
public interface Task {
    String getDescription();
    int getPriority();
    boolean isCompleted();
}
```

A continuación, podemos crear un Record para cada tipo de tarea que implemente la interfaz Task:

```java
public record BugFix(String description, int priority) implements Task {
    @Override
    public boolean isCompleted() {
        // Implement logic to determine if the bug fix is completed
    }
}

public record Feature(String description, int priority) implements Task {
    @Override
    public boolean isCompleted() {
        // Implement logic to determine if the feature is completed
    }
}
```

En este ejemplo, tenemos dos Records, BugFix y Feature, que implementan la interfaz Task. Esto nos permite tratar ambos tipos de tareas de manera uniforme en nuestra aplicación de gestión de proyectos y, al mismo tiempo, aprovechar la simplicidad y la inmutabilidad que ofrecen los Records.

Prioriza lo que más importa

Las organizaciones necesitan un enfoque integral para priorizar los riesgos. Usa la priorización contextual basada en riesgos de Snyk.



Leer más