1. Conclusión
La gestión de transacciones de Spring solo revierte las excepciones de tiempo de ejecución (java.lang.RuntimeException y sus subclases) de forma predeterminada.
Si un método arroja una excepción o una excepción marcada, la administración de transacciones de Spring no realiza la reversión de forma predeterminada.
Una introducción detallada a la clasificación de excepciones:
1. Conceptos básicos <BR>Mire el diagrama de estructura de excepciones de Java
Throwable es la raíz de todas las excepciones, java.lang.Throwable
El error es un error, java.lang.Error
La excepción es una excepción, java.lang.Exception
2.Excepción
Generalmente dividido en excepciones marcadas y excepciones de tiempo de ejecución. Todas las instancias de la clase RuntimeException y sus subclases se denominan excepciones de tiempo de ejecución, y las excepciones que no entran en esta categoría se denominan excepciones marcadas.
① Excepción marcada Solo el lenguaje Java proporciona excepciones marcadas. Java considera que las excepciones marcadas son excepciones que se pueden manejar, por lo que los programas Java deben manejar explícitamente las excepciones marcadas. Si el programa no maneja la excepción marcada, se producirá un error cuando se compila el programa y no se podrá compilar. Esto refleja la filosofía de diseño de Java: el código sin un manejo perfecto de errores no tiene ninguna posibilidad de ser ejecutado. Hay dos formas de manejar las excepciones marcadas.
(1) Si el método actual sabe cómo manejar la excepción, utiliza el bloque try...catch para manejar la excepción.
(2) Si el método actual no sabe cómo manejarlo, declare que lanzará la excepción al definir el método.
Copie el código de código de la siguiente manera:
paquete cn.xy.test;
importar java.io.IOException;
/**
* Método de prueba de excepción comprobado
* @autor xy
*
*/
Métodos CheckedException de clase pública
{
// La clase de excepción total incluye checkException y RuntimeException, por lo que checkException debe procesarse
El método público vacío 1 () lanza una excepción
{
System.out.println("Soy el método de la clase general que arroja excepciones");
}
//Captura y maneja esta excepción
prueba de anulación públicaMétodo1_01()
{
intentar
{
método1();
}
captura (Excepción e)
{
e.printStackTrace();
}
}
// Pasa la excepción
testMethod1_02() nulo público arroja una excepción
{
método1();
}
public void testMethod1_03() lanza una excepción
{
lanzar nueva excepción();
}
prueba de anulación públicaMétodo1_04()
{
intentar
{
lanzar nueva excepción();
}
captura (Excepción e)
{
e.printStackTrace();
}
}
// checkException normalmente representa IOException
El método público vacío 2 () lanza IOException
{
System.out.println("Soy el método que genera una excepción IO");
}
prueba de anulación públicaMétodo2_01()
{
intentar
{
método2();
}
captura (Excepción e)
{
e.printStackTrace();
}
}
testMethod2_02() nulo público arroja una excepción
{
método2();
}
}
Las excepciones marcadas con las que estamos más familiarizados incluyen
Java.lang.ClassNotFoundException
Java.lang.NoSuchMetodException
java.io.IOExcepción
②Excepción de tiempo de ejecución
En tiempo de ejecución, si el divisor es 0 o el subíndice de la matriz está fuera de los límites, etc., ocurren con frecuencia y son problemáticos de manejar. La visualización de declaraciones o capturas tendrá un gran impacto en la legibilidad y eficiencia operativa del programa. Entonces el sistema los detecta automáticamente y los entrega al controlador de excepciones predeterminado. Por supuesto, también puede capturarlos explícitamente si tiene requisitos de procesamiento.
Copie el código de código de la siguiente manera:
paquete cn.xy.test;
/**
* Método de prueba de excepción en tiempo de ejecución
* @autor xy
*
*/
clase pública RuntimeExcetionMethods
{
El método público vacío 3 () lanza RuntimeException
{
System.out.println("Soy un método que genera excepciones de tiempo de ejecución");
}
prueba de anulación públicaMétodo3_01()
{
método3();
}
prueba de anulación públicaMétodo1_02()
{
lanzar nueva RuntimeException();
}
}
Las subclases de la clase RumtimeException con las que estamos más familiarizados incluyen
Java.lang.ArithmeticException
Java.lang.ArrayStoreExcetpion
Java.lang.ClassCastException
Java.lang.IndexOutOfBoundsException
Java.lang.NullPointerException
3.Error Cuando ocurre un error incontrolable en un programa, el enfoque habitual es notificar al usuario y finalizar la ejecución del programa. A diferencia de las excepciones, los objetos de Error y sus subclases no deben lanzarse.
Error es una subclase de throwable que representa errores del sistema y en tiempo de compilación y se utiliza para indicar problemas graves que las aplicaciones razonables no deberían intentar detectar.
Los errores son generados y arrojados por la máquina virtual Java, incluidas fallas de enlaces dinámicos, errores de la máquina virtual, etc. El programa no lo procesa.
2. Cambie el modo predeterminado <BR> Defina noRollbackFor y RollbackFor en la anotación @Transaction para especificar si se deben revertir ciertas excepciones.
@Transaction(noRollbackFor=RuntimeException.clase)
@Transaction(RollbackFor=Exception.clase)
Esto cambia el método de procesamiento de transacciones predeterminado.
3. Iluminación <BR>Esto requiere que hagamos que la excepción personalizada herede de RuntimeException cuando personalicemos la excepción, de modo que cuando se lance, sea manejada con precisión por el procesamiento de transacciones predeterminado de Spring.
