Condiciones previas | guayaba | Java

Introducción: la clase de condiciones previas proporciona una lista de métodos estáticos para comprobar que se invoca un método o un constructor con valores de parámetros válidos. Si una condición previa falla, se genera una excepción personalizada.

• Estos métodos generalmente aceptan una expresión booleana que se espera que sea verdadera.
• En el caso de checkNotNull, estos métodos aceptan una referencia de objeto que se espera que no sea nula.
• Cuando se pasa false/null en su lugar, el método de condiciones previas lanza una excepción no verificada.

Declaración :

@GwtCompatible
public final class Preconditions
extends Object

Ejemplo 1: en este ejemplo, checkArgument lanza una IllegalArgumentException para indicar que examplePre1 cometió un error en su llamada a sqrt porque el argumento pasado es negativo.

// Returns the positive square
// root of the given value.
// throws IllegalArgumentException
// if the value is negative
public static double sqrt(double value)
{
    Preconditions.checkArgument(value >= 0.0, "negative value: %s", value);
    // calculate the square root
}
  
void examplePre1()
{
    // Function calling
    double ans = sqrt(-5.0);
}

Ejemplo 2: Digamos que tenemos un método que toma una Lista como argumento. Cuando se invoca este método, queremos verificar que la lista no sea nula y que no esté vacía. Una solución simple de Java para el problema se vería así:

// Method to check if passed list
// is null or empty
public void example(List<Object> myList)
{
    // To check if passed list is null
    if (myList == null) {
        throw new IllegalArgumentException("List must not be null");
    }
  
    // To check if passed list is empty
    if (myList.isEmpty()) {
        throw new IllegalArgumentException("List must not be empty");
    }
  
    // Function calling
    example(myList);
}

Pero cuando usamos las Precondiciones de Guava, la cantidad de código se reduce significativamente. La solución se parece a:

// Method to check if passed list
// is null or empty
public void example(List<Object> myList)
{
    // Check if list is null or not
    checkArgument(myList != null, "List must not be null");
  
    // Check if list is empty or not
    checkArgument(!myList.isEmpty(), "List must not be empty");
  
    // Function calling
    example(myList);
}

Ejemplo 3: si se quiere validar la edad para asegurarse de que sea mayor de 18 años, se puede usar Precondition.checkArgument().

// To check if age is greater than 18 or not
public static void validateAge(int age)
{
    // Guava Preconditions
    checkArgument(age > 18);
}

La siguiente tabla muestra algunos de los métodos proporcionados por Guava Preconditions.

Cada método tiene tres variantes , que se enumeran a continuación:

• Sin argumentos adicionales: las excepciones se lanzan sin mensajes de error.
• Un argumento de objeto adicional: cualquier excepción se lanza con el mensaje de error object.toString().
• Un argumento de string adicional: este método toma un argumento de string adicional con un número arbitrario de argumentos de objeto adicionales. Esto se comporta como printf, pero para la compatibilidad y eficiencia de GWT, solo permite indicadores %s .

Ejemplos de la tercera variante:

checkArgument(i >= 0, "Argument was %s but expected nonnegative", i);
checkArgument(i < j, "Expected i = %s", i, j);

Algunos otros métodos proporcionados por Guava Preconditions son:

Puntos importantes: A continuación se dan algunos puntos importantes con respecto a las condiciones previas de la guayaba.

• Por supuesto, es posible utilizar los métodos de esta clase para verificar si hay condiciones no válidas que no sean culpa de la persona que llama. No se recomienda hacerlo porque es engañoso para los futuros lectores del código.
• Los proyectos que usan com.google.common generalmente deben evitar el uso de Objects.requireNonNull(Object). En su lugar, use cualquiera de checkNotNull(Object) o Verify.verifyNotNull(Object) que sea apropiado para la situación.
• En las strings de plantilla de mensaje de error de condiciones previas, solo se admite el especificador «%s» , no la gama completa de especificadores de formateador.

Ejemplo :

// Java code to show implementation of
// Guava Preconditions
import com.google.common.base.Preconditions;
  
class GFG {
  
    // Driver code
    public static void main(String args[])
    {
  
        // Creating object of GFG Class
        GFG obj = new GFG();
  
        // try block
        try {
            System.out.println(obj.sum(5, null));
        }
  
        // catch block
        catch (NullPointerException e) {
            System.out.println(e.getMessage());
        }
    }
  
    // Method to compute sum of 2 Integers
    public int sum(Integer num1, Integer num2)
    {
        // Guava Preconditions
        num1 = Preconditions.checkNotNull(num1,
                                          "Illegal Argument, First parameter is Null.");
  
        // Guava Preconditions
        num2 = Preconditions.checkNotNull(num2,
                                          "Illegal Argument, Second parameter is Null.");
  
        return (num1 + num2);
    }
}

Producción :

Illegal Argument, Second parameter is Null.

Referencia: Google Guayaba