Autor | árabe, Zebian | Guo Rui
Cabeza Figura | RDCC descarga de IC del Este
Exposición | RDCC (ID: CSDNnews)
Hoy entendemos juntos bajo las operaciones de base de datos de transacciones de la primavera. En la base de datos operación, a menudo utilizamos a la transacción, tiene como objetivo proporcionar un cómodo desarrollador API primavera especializado para las operaciones de procesamiento de llamadas, entonces este artículo se centrará en hablar de sus funciones relacionadas con resortes para la transacción.
Core asuntos interfaz de primavera
Primavera a través de un muelle de paquetes JAR-TX-4.3.6-LIBERACIÓN DE nombrados para administrar los asuntos, org.Springframework.transaction paquete en el paquete JAR contiene archivo de tres interfaces:
PlatformTramsactionManager utiliza principalmente para gestionar la transacción, incluyendo la obtención de la situación de una transacción, confirmar la transacción y deshacer la transacción;
TramsactionDefinition La interfaz se define materias, incluyendo el nombre del nivel de aislamiento de transacción de adquisición, comportamiento de la propagación de la transacción, tiempo de espera, si la transacción es de sólo lectura;
TramsactionStatus La interfaz es un estado de cosas, describe un cierto punto en el tiempo la información de estado de la transacción, incluyendo al ras de la transacción, si hay o no una adquisición de punto de guardado, si se trata de una nueva transacción, ya sea o no revierte, establece la transacción se revierte.
Ejemplos que ilustran
A continuación vamos a explicar la forma en cómo utilizar las anotaciones a modo de ejemplo para procesar transacciones a través de la primavera, aumentamos los procedimientos paquete JAR asuntos de la pom.xml en maven:
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>4.3.6.RELEASE</version>
</dependency>
En primer lugar, preparamos una base de datos:
CREATE TABLE IF NOT EXISTS `user`(
`id` INT UNSIGNED AUTO_INCREMENT,
`username` VARCHAR(100) NOT NULL,
`password` VARCHAR(40) NOT NULL,
`jifen` int(10) NOT NULL,
PRIMARY KEY ( `id` ))ENGINE=InnoDB DEFAULT CHARSET=utf8;
A continuación, escribe algunos datos a la base de datos, incluyendo el nombre de usuario, la contraseña y la integral, de la siguiente manera:
MariaDB [spring_db]> select * from user;
+----+----------+----------+-------+
| id | username | password | jifen |
+----+----------+----------+-------+
| 1 | zhangsan | 123 | 1000 |
| 2 | lisi | 1234 | 1000 |
| 3 | wangwu | 1234 | 1000 |
+----+----------+----------+-------+
3 rows in set (0.000 sec)
Que tenemos que hacer es ser transferido a puntos de John Doe Joe Smith.
Tenemos que crear una clase de usuario, de la siguiente manera:
package com.SpringDemo;
public class User {
private Integer id;
private String username;
private String password;
private Integer jifen;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setJifen(Integer jifen){
this.jifen = jifen;
}
public Integer getjifen() {
return jifen;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String toString() {
return "User [id=" + id + ", username=" + username + ", password=" + password + "]";
}
}
A continuación, crear una interfaz de UserDao:
package com.SpringDemo;
import java.util.List;
public interface UserDao {
public int addUser(User user);
public int updateUser(User user);
public int deleteUser(int id);
//通过id查询用户
public User findUserById(int id);
//查询所有用户
public List<User> findAllUser();
public void transfer(String outUser,String inUser,Integer jifen);
}
En UserDao interfaz definimos un método de transferencia, que incluye los tres parámetros son outUser, inUser, Jifen.
Luego de definir nuestros UserDAOImpl clase de implementación:
package com.SpringDemo;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
public class UserDaoImpl implements UserDao {
private JdbcTemplate jdbcTemplate;
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
@Override
public int addUser(User user) {
String sql="insert into user(username,password) value(?,?)";
Object[] obj=new Object[]{
user.getUsername(),
user.getPassword()
};
int num=this.jdbcTemplate.update(sql,obj);
return num;
}
@Override
public int updateUser(User user) {
String sql="update user set username=?,password=? where id=?";
Object[] params=new Object[]{
user.getUsername(),
user.getPassword(),
user.getId()
};
int num=this.jdbcTemplate.update(sql,params);
return num;
}
@Override
public int deleteUser(int id) {
String sql="delete from user where id=?";
int num=this.jdbcTemplate.update(sql,id);
return num;
}
@Override
public User findUserById(int id) {
String sql="select * from user where id=?";
RowMapper<User> rowMapper=new BeanPropertyRowMapper<User>(User.class);
return this.jdbcTemplate.queryForObject(sql,rowMapper,id);
}
@Override
public List<User> findAllUser() {
String sql="select * from user";
RowMapper<User> rowMapper=new BeanPropertyRowMapper<User>(User.class);
return this.jdbcTemplate.query(sql,rowMapper);
}
@Override
public void transfer(String outUser, String inUser, Integer jifen) {
// 赠送积分
this.jdbcTemplate.update("update user set jifen=jifen+? where username=?",jifen,inUser);
// 模拟系统运行时的突发性问题
int i =1/0;
//赠送出积分
this.jdbcTemplate.update("update user set jifen=jifen-? where username=?",jifen,outUser);
}
}
A continuación se define una applicationContext.xml:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-4.3.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
<!--1.配置数据源 -->
<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<!--数据库驱动 -->
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
<!--连接数据库的ur1 -->
<property name="url" value="jdbc:mysql://192.168.10.128:3306/spring_db" />
<!--连接数据库的用户名 -->
<property name="username" value="root" />
<!--连接数据库的密码 -->
<property name="password" value="123456" />
</bean>
<!--2.配置JDBC模板 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!--默认必须使用数据源 -->
<property name="dataSource" ref="dataSource" />
</bean>
<!--3.定义id为userDao的Bean -->
<bean id="userDao" class="com.SpringDemo.UserDaoImpl">
<!--将 jdbcTemplate注入到 userDao实例中 -->
<property name="jdbcTemplate" ref="jdbcTemplate" />
</bean>
<!--4.事务管理器，依赖于数据源 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<!--5.注册事务管理驱动 -->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
</beans>
métodos de gestión de transacciones de primavera son dos tipos, uno es la gestión de transacciones programada tradicional, que consiste en gestionar el inicio de una transacción a través de la ejecución de código y de excepción y reversión, una es la gestión declarativa, es decir, por medio del archivo de configuración, el principio de AOP es a través de la tecnología, se recomienda utilizar la gestión de transacciones declarativa en el proceso de desarrollo real, la eficiencia se verá muy mejorado, ya que sólo necesita configurar.
En esta interfaz, reescribimos nuestro método de transferencia, actualización se incrementa la base de datos puntos inUser, mientras que los puntos outUser correspondientes a reducirse, pero aquí queremos simular algunos problemas repentinos de la operación del sistema. Luego añadimos un notas @Transactionl, y establecer propagación, Aislamiento, readOnly tres parámetros.
@Override
@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT,
readOnly = false)
public void transfer(String outUser, String inUser, Integer jifen) {
// 赠送积分
this.jdbcTemplate.update("update user set jifen=jifen+? where username=?",jifen,inUser);
// 模拟系统运行时的突发性问题
int i =1/0;
//赠送出积分
this.jdbcTemplate.update("update user set jifen=jifen-? where username=?",jifen,outUser);
}
Parámetros Significado Notas @Transactional de la siguiente manera:
@Transactional Además DEFAULT, hay otros atributos, podemos ver el posicionamiento relativo en este Aislamiento clase de anotación @Transactional puede añadirse a nivel de clase. Cuando la anotación @Transactional en el nivel de clase, representan todos los métodos públicos de la clase configurada con la misma información de atributo de transacción.
public enum Isolation {
DEFAULT(-1),
READ_UNCOMMITTED(1),
READ_COMMITTED(2),
REPEATABLE_READ(4),
SERIALIZABLE(8);
private final int value;
private Isolation(int value) {
this.value = value;
}
public int value() {
return this.value;
}
}
propiedades de propagación de la siguiente manera:
public enum Propagation {
REQUIRED(0),//表示当前方法必须运行在一个事务环境中，如果存在就直接使用，否则开启一个新的事务执行该方法
SUPPORTS(1),//如果当前方法处于事务环境中则使用，否则不使用事务
MANDATORY(2),//表示该方法的线程必须在事务中否则抛出异常
REQUIRES_NEW(3), //要求在新事务中执行，如果已经在事务中了则先暂停然后启动新事务执行，如果不在则启动一个新事务后执行
NOT_SUPPORTED(4), //不支持当前事务，总是以非事务状态执行，如果调用该方法的线程处于事务中泽先暂停然后执行
NEVER(5), //不支持当前执行的方法在事务中，如果在抛出异常
NESTED(6); //即便当前执行的方法在事务中也会启动一个新事务，然后执行该方法
private final int value;
private Propagation(int value) {
this.value = value;
}
public int value() {
return this.value;
}
}
Además, el @Transactional debe asegurar que se utilice en un nivel público método, @ transaccional sólo se aplican al método público para ser eficaz, es porque cuando se utiliza la primavera AOP proxy, primavera TransactionInterceptor antes de llamar a un lado a otro para interceptar la ejecución del método objetivo, DynamicAdvisedInterceptor (CglibAopProxy clases internas) el método de intercepción JdkDynamicAopProxy o indirectamente invoke método llama AbstractFallbackTransactionAttributeSource (transacción primavera atributos get anotación @Transactional a través de esta información de atributos de configuración de clase) de método computeTransactionAttribute.
A continuación, creamos una clase de prueba para ser probado:
package com.SpringDemo;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TransactionTest {
public static void main(String[] args) {
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao = (UserDao) applicationContext.getBean("userDao");
userDao.transfer("zhangsan","lisi",100);
System.out.println("赠送积分成功");
}
}
Llevamos a cabo los procedimientos anteriores, se puede encontrar en el error. Programa de Noticias:
Exception in thread "main" java.lang.ArithmeticException: / by zero
Como se muestra:
En este punto, vemos los datos en la base de datos sin ningún cambio:
MariaDB [spring_db]> select * from user;
+----+----------+----------+-------+
| id | username | password | jifen |
+----+----------+----------+-------+
| 1 | zhangsan | 123 | 1000 |
| 2 | lisi | 1234 | 1000 |
| 3 | wangwu | 1234 | 1000 |
+----+----------+----------+-------+
3 rows in set (0.000 sec)
Cuando int i = 1/0; Zhushidiao encontrará la ejecución del programa vuelve a realizar no está dando, y cambió los datos:
MariaDB [spring_db]> select * from user;
+----+----------+----------+-------+
| id | username | password | jifen |
+----+----------+----------+-------+
| 1 | zhangsan | 123 | 900 |
| 2 | lisi | 1234 | 1100 |
| 3 | wangwu | 1234 | 1000 |
+----+----------+----------+-------+
3 rows in set (0.000 sec)
Bueno, eso es acerca de la presentación de gestión de transacciones de primavera.
【FIN】
Más emocionante recomendada
☞ 2020 Nian, AI chip de memoria fuerte ¿Qué?
☞ Por favor, no me pregunte lo que es un árbol B +
☞ programador Por qué debería oponerse de manera inequívoca "mejores prácticas"?
☞ formación de cien millones de escala de conocimiento mapeo media hora, de código abierto Amazon AI marco de la representación del conocimiento mapa incrustado DGL-KE
☞ "debut" tasa de adopción de los 5 años del 78%, ¿cuál es la receta para el éxito Kubernetes?
☞ alerta! Aparición de nuevos trucos: el generador de código de dos dimensiones falsa ha sido exitosamente robar $ 460 millones de dólares!
bienestar de hoy: Área de mensajes Comentarios seleccionado, obtener el valor de 299 yuanes, "2020 millones de desarrolladores de AI Encuentro" en línea billete vivo . Ven yemas de los dedos, escribe lo que quiere decir que.
Haga clic para leer el original, maravillosa para continuar!
Su punto de cada una "mirada", en serio como favorito
