1. Ejemplos de escenarios de uso
Antes de entender cómo se usa @Transactional, primero debemos saber qué es útil @Transactional. Permítanme darle un pulgar hacia arriba: por ejemplo, hay muchos miembros en un departamento, y estos dos se almacenan en la tabla del departamento y la tabla de miembros respectivamente. Al eliminar un determinado departamento, supongamos que eliminamos los miembros correspondientes de forma predeterminada. Sin embargo, esto puede ocurrir durante la ejecución. Primero eliminamos el departamento y luego eliminamos a los miembros. Sin embargo, el departamento lo ha eliminado con éxito, y se produjo una excepción al eliminar a los miembros. En este momento, esperamos que si la eliminación del miembro falla, el departamento previamente eliminado también cancelará la eliminación. Este escenario se puede revertir usando @Transactional Things.
2. Excepción verificada y excepción sin control
La razón por la que les permitimos que todos sepan los conceptos de excepciones verificadas y excepciones sin control es que:
Spring utiliza procesamiento de transacciones declarativas. Por defecto, si se produce una excepción sin control en el método de operación de la base de datos anotado, todas las operaciones de la base de datos serán reversiones; Si se produce la excepción es una excepción verificada, las operaciones de la base de datos aún se enviarán de forma predeterminada.
Excepción verificada:
Inválido, no predecible en el programa. Por ejemplo, la entrada del usuario no válida, el archivo no existe, los errores de enlace de red o base de datos. Todas estas son razones externas y no están controlados por el programa.
Debe manejarse explícitamente en el código. Por ejemplo, el procesamiento de bloques de captura de try o lanza la excepción a la capa anterior de la pila de llamadas con la descripción de lanzamientos.
Heredado de java.lang.exception (excepto java.lang.runtimeexception).
Excepción sin control:
Indica un error, la lógica del programa es incorrecta. Es una subclase de RuntimeException, como ilegalargumentException, nullpointerexception y ilegalstateException.
No hay necesidad de detectar explícitamente excepciones sin control en el código para su procesamiento.
Heredado de java.lang.runtimeexception (y java.lang.runtimeexception hereda de java.lang.exception).
Mirando el diagrama de estructura anormal a continuación, puede estar más en capas:
3. Ejemplo de uso de @Transactional
Este ejemplo usa Eclipse+Maven. Maven solo se gestiona como un frasco, e incluso los amigos de Ape de Maven que no entienden pueden entenderlo.
3.1. Archivo de configuración de resorte
El espacio de nombres TX debe configurarse primero de la siguiente manera:
Para usar la administración de transacciones basada en transaccional, la siguiente configuración se requiere en Spring:
<bean id = "appTransactionManager"> <Property name = "dataSource" ref = "dataSource" /> < /bean> <tx: proxy-target-class = "false" transaction-ganager = "apptransactionManager" />
Todo el archivo de configuración de primavera del blogger:
<? xml versión = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" "" "" xmlns: context = "http://www.springframework.org/schema/context" xmlns: tx = "http://www.springframework.org/schema/tx" xmlns: aoP = "http://www.springframework.org/aop" xsi: schemalocation = "http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd http://www.springframework.org/schema/Beansd http://www.springframework.org/schema/Beans http://www.springframework.org/schema/Beans/Spring-Beans-3.0.xsd http://www.springframework.org/schema http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/contex Archivo de configuración de JDBC-> <bean id = "PropertyConfigurer"> <Property Name = "ubicaciones"> <list> <valor> classpath: propiedades/*. Propiedades </valor> <!-Si hay múltiples archivos de configuración, solo continúe agregándolos aquí-> </list> </propiets> </bean> <!-Configure la fuente de datos-> <bean id = "dataurce" Propiedades-> <!-Configurar Propiedades-> <!-<Property name = "DriverClassName" value = "com.mysql.jdbc.driver" /> <propiedad name = "url" valor = "jdbc: mysql: // localhost: 3306 /aprendizaje" /> <name de propiedad = "user" value = "root" /> <sperse name = "contraseña" valor "valor" valorar "@"@"@" "@" "@" "@" "@" "@" "@" "@" "@" "@" "". < name="password"> <value>${jdbc_password}</value> </property> </bean> <bean id="appTransactionManager"> <property name="dataSource" ref="dataSource" /> </bean> <tx:annotation-driven proxy-target-class="false" transaction-manager="appTransactionManager" /> <!-- Automatically scan all mapper Los archivos de interfaz correspondientes a xxxxmapper.xml, para que no necesite configurar manualmente el mapeo MPPER uno por uno. Siempre que la clase de interfaz MAPPER y el archivo de mapeo mapper se corresponden entre sí. -> <Bean> <Property Name = "BasePackage" value = "com.luo.dao" /> </ bean> <!-Configurar el archivo myBatis, mapperLocations Configurar ** mapper.xml ubicación del archivo, configuración configurar mybatis-config ubicación del archivo-> <bean id = "sqlSessionFactory"> <nombre de propiedad = "dataSource" ref = "dataSource" /" /" dataSource " /" dataSource " /" dataSoUn name = "mApperLocations" value = "classpath: mapper/*. xml"/> <propiedad name = "configLocation" value = "classpath: myBatis/mybatis-config.xml"/> <!-<Property name = "typealesespackage" value = "com.tiantian.ckeditor.model"/>-> </<rematic annotatate "beays-beans-beans-beans-beans-beans-beans-beans-beaper <context: componente-escan-scan-backage = "com.luo.service" /> < /beans>3.2. Use @Transactional para agregar anotaciones al método de clase de implementación del usuario
@TransActional (propagation = propagation.required) public void adduser (usuario de usuario) {userdao.adduser (usuario); String String = null; if (string.equals ("")) {int i = 0; }}En el método anterior, deliberadamente hice que tuviera una excepción de puntero nulo y las cosas retrocedirán
3.3. Ejecute la clase de prueba unitaria
@Test public void addUsertest () {user user = new user (); user.setUsername ("LUOGUOHUI1"); user.setUserPassword ("LUOGUOHUI1"); Userservice.adduser (usuario);}Descubrí que no podía insertarse, pero si se elimina @Transactional, el código es el siguiente. Aunque se produce una excepción, todavía se agregan datos correspondientes a la base de datos:
3.4. Descarga del código fuente
Descargue el código fuente final de este artículo: first_maven_project_jb51.rar
4. Conceptos que @Transactional en primavera deben entenderse
@Transactional in Spring se basa en el mecanismo de proxy dinámico y proporciona un mecanismo transparente de gestión de transacciones para facilitar y resolver rápidamente los problemas encontrados en el desarrollo.
En general, es para comentar métodos o interfaces o clases a través del siguiente código:
@Transactional (propagation = propagation.not_supported)
La propagación admite 7 mecanismos de propagación diferentes:
Requerido: si existe una transacción, la transacción actual es compatible. Si no hay transacción, se inicia una nueva transacción.
Soporte: si existe una transacción, se admite la transacción actual. Si no hay transacción, la ejecución de la no transacción. Sin embargo, para los administradores de transacciones de sincronización de transacciones, la propagation_supports es ligeramente diferente de no usar transacciones.
No_Supported: siempre ejecute no transaccionalmente y suspenda cualquier transacción existente.
RequiereNEW: Siempre comience una nueva transacción. Si ya existe una transacción, la transacción existente está suspendida.
Obligatorio: si ya existe una transacción, admite la transacción actual. Si no hay una transacción activa, se lanza una excepción.
Nunca: siempre ejecute no transaccional, si existe una transacción activa, se lanza una excepción
Anidado: si existe una transacción activa, se ejecuta en una transacción anidada. Si no hay una transacción activa, presione la propiedad requerida para ejecutar.
Aquí hay algunas cosas a tener en cuenta, que deben leerse, de lo contrario, si encuentra varias dificultades, el blogger no le ha recordado:
Aquí hay algunas cosas a tener en cuenta, que deben leerse, de lo contrario, si encuentra varias dificultades, el blogger no le ha recordado:
Aquí hay algunas cosas a tener en cuenta, que deben leerse, de lo contrario, si encuentra varias dificultades, el blogger no le ha recordado:
Agregar anotación @Transactional donde se requiere la gestión de transacciones. @Las anotaciones transaccionales se pueden aplicar a las definiciones de interfaz y métodos de interfaz, definiciones de clase y métodos públicos de clases.
@Las anotaciones transaccionales solo se pueden aplicar a los métodos con visibilidad pública. Si usa la anotación @Transactional en métodos protegidos, privados o visibles, no informará un error, pero este método anotado no mostrará la configuración de transacción configurada.
Tenga en cuenta que la aparición de la anotación @Transactional no es suficiente para habilitar el comportamiento de la transacción, es solo un tipo de metadatos. El elemento de configuración debe usarse en el archivo de configuración para habilitar realmente el comportamiento de la transacción.
Controla si se crea un proxy basado en la interfaz o basado en la clase a través del valor del atributo "proxy-target-class". Si el valor de género "proxy-target-class" se establece en "verdadero", entonces el proxy basado en la clase funcionará (esto se requiere para cglib.jar en classpath). Si el valor de género "proxy-target-class" se establece en "falso" o se omite esta propiedad, entonces el proxy basado en la interfaz JDK estándar funcionará.
El equipo de primavera recomienda usar la anotación @Transactional en clases específicas (o métodos de clases) en lugar de en cualquier interfaces que la clase quiera implementar. Usar la anotación @Transactional en una interfaz solo entrará en vigencia cuando configure un proxy basado en la interfaz. Debido a que las anotaciones no pueden ser heredadas, esto significa que si se utiliza un proxy basado en la clase, la configuración de la transacción no será reconocida por el proxy basado en la clase, y el objeto no será envuelto por el proxy de la transacción.
La transacción de @Transactional está habilitada, ya sea un proxy basado en la interfaz o se crea un proxy basado en la clase. Entonces, en la misma clase, un método llama a otro método con transacciones, la transacción no funcionará.
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.