Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Rollback con la anotación transactional

26/31
Recursos

Aportes 4

Preguntas 3

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Al aplicar la anotación @transactional podemos presenciar al conjunto de operaciones ejecutándose de manera total, integral y atómica. Se sigue el acrónimo ACID (Atomicity, Consistency, Isolation and Durability: Atomicidad, Consistencia, Aislamiento y Durabilidad, en español).

Las características de una transacción tienen el acrónimo ACID:

  • Atomicidad: Las actividades de un método se consideran como una unidad de trabajo. Esto se conoce como Atomicidad. Este concepto asegura que todas las operaciones en una transacción se ejecuta todo o nada.
    Si todas las instrucciones o líneas de código de un método transaccional son ejecutadas con éxito, entonces al finalizar se realiza un commit, es decir, guardado de la información.
    Si alguna de las instrucciones falla se realiza un rollback, es decir, ninguna de la información es guardada en la base de datos o el repositorio donde ser persiste dicha información…

  • Consistente: Una vez que termina una transacción (sin importar si ha sido exitosa o no) la información queda en estado consistente, ya que se realizó todo o nada, y por lo tanto los datos no deben estar corruptos en ningún aspecto.

  • Aislado: Múltiples usuarios pueden utilizar los métodos transaccionales, sin afectar el acceso de otros usuarios. Sin embargo debemos prevenir errores por accesos múltiples, aislando en la medida de lo posible nuestros métodos transaccionales. El aislamiento normalmente involucra el bloqueo de registros o tablas de base de datos, esto se conoce como locking…

  • Durable: Sin importar si hay una caída del servidor, una transacción exitosa debe guardarse y perdurar posterior al termino de una transacción.

private void saveWithErrorTransational(){
        User test1 = new User("TestTransactional1", "[email protected]", LocalDate.now());
        User test2 = new User("TestTransactional2", "[email protected]", LocalDate.now());
        User test3 = new User("TestTransactional3", "[email protected]", LocalDate.now());
        User test4 = new User("TestTransactional4", "[email protected]", LocalDate.now());

        List<User> users = Arrays.asList(test1,test2,test3,test4);

        try{
            userService.saveTransactional(users);
        }catch (Exception e){
            LOGGER.error("Esta es una excepcion dentro del metodo transational" + e);
        }
        userService.getAllUsers()
                .stream()
                .forEach(user -> LOGGER.info("Este es el usuario dentro del metodo Transational :" + user));
    }
¿ por qué en el caso del Repository solo creamos una Interface y no fue necesario implementar una clase ?