Gestão de transações programáticas

A abordagem de gerenciamento de transação programática permite que você gerencie a transação com a ajuda da programação em seu código-fonte. Isso proporciona extrema flexibilidade, mas é difícil de manter.

Antes de começar, é importante ter pelo menos duas tabelas de banco de dados nas quais possamos realizar várias operações CRUD com a ajuda de transações. Vamos considerar umStudent tabela, que pode ser criada no banco de dados MySQL TEST com o seguinte DDL -

CREATE TABLE Student(
   ID   INT NOT NULL AUTO_INCREMENT,
   NAME VARCHAR(20) NOT NULL,
   AGE  INT NOT NULL,
   PRIMARY KEY (ID)
);

Segunda mesa é Marksno qual manteremos notas para os alunos com base em anos. AquiSID é a chave estrangeira para a tabela Student.

CREATE TABLE Marks(
   SID INT NOT NULL,
   MARKS  INT NOT NULL,
   YEAR   INT NOT NULL
);

Vamos usar PlatformTransactionManager diretamente para implementar a abordagem programática para implementar transações. Para iniciar uma nova transação, você precisa ter uma instância de TransactionDefinition com os atributos de transação apropriados. Para este exemplo, vamos simplesmente criar uma instância deDefaultTransactionDefinition para usar os atributos de transação padrão.

Uma vez que TransactionDefinition é criado, você pode iniciar sua transação chamando o método getTransaction () , que retorna uma instância de TransactionStatus . Os objetos TransactionStatus ajudam a rastrear o status atual da transação e, finalmente, se tudo correr bem, você pode usar o método commit () de PlatformTransactionManager para confirmar a transação, caso contrário, você pode usar rollback () para reverter a operação completa.

Agora, vamos escrever nosso aplicativo Spring JDBC que implementará operações simples nas tabelas Student e Marks. Vamos ter um Eclipse IDE funcionando e seguir os seguintes passos para criar um aplicativo Spring -

Passos Descrição
1 Crie um projeto com um nome SpringExample e crie um pacote com.tutorialspoint sob osrc pasta no projeto criado.
2 Adicione as bibliotecas Spring necessárias usando a opção Adicionar JARs externos, conforme explicado no capítulo Exemplo do Spring Hello World .
3 Adicionar as bibliotecas mais recentes específicas do Spring JDBC mysql-connector-java.jar, org.springframework.jdbc.jar e org.springframework.transaction.jarno projeto. Você pode baixar as bibliotecas necessárias se ainda não as tiver.
4 Crie a interface do DAO StudentDAO e liste todos os métodos necessários. Embora não seja obrigatório e você possa escrever diretamente a classe StudentJDBCTemplate , mas como uma boa prática, vamos fazê-lo.
5 Criar outras classes Java necessários StudentMarks , StudentMarksMapper , StudentJDBCTemplate e MainApp sob a com.tutorialspoint pacote. Você pode criar outras classes POJO, se necessário.
6 Certifique-se de que você já criou Student e Markstabelas no banco de dados TEST. Verifique também se o servidor MySQL está funcionando bem e se você tem acesso de leitura / gravação no banco de dados usando o nome de usuário e a senha fornecidos.
7 Crie o arquivo de configuração do Beans Beans.xml sob osrc pasta.
8 A etapa final é criar o conteúdo de todos os arquivos Java e do arquivo de configuração do Bean e executar o aplicativo conforme explicado abaixo.

A seguir está o conteúdo do arquivo de interface do Data Access Object StudentDAO.java

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

public interface StudentDAO {
   /** 
      * This is the method to be used to initialize
      * database resources ie. connection.
   */
   public void setDataSource(DataSource ds);
   
   /** 
      * This is the method to be used to create
      * a record in the Student and Marks tables.
   */
   public void create(String name, Integer age, Integer marks, Integer year);
   
   /** 
      * This is the method to be used to list down
      * all the records from the Student and Marks tables.
   */
   public List<StudentMarks> listStudents();
}

A seguir está o conteúdo do StudentMarks.java Arquivo

package com.tutorialspoint;

public class StudentMarks {
   private Integer age;
   private String name;
   private Integer id;
   private Integer marks;
   private Integer year;
   private Integer sid;

   public void setAge(Integer age) {
      this.age = age;
   }
   public Integer getAge() {
      return age;
   }
   public void setName(String name) {
      this.name = name;
   }
   public String getName() {
      return name;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public Integer getId() {
      return id;
   }
   public void setMarks(Integer marks) {
      this.marks = marks;
   }
   public Integer getMarks() {
      return marks;
   }
   public void setYear(Integer year) {
      this.year = year;
   }
   public Integer getYear() {
      return year;
   }
   public void setSid(Integer sid) {
      this.sid = sid;
   }
   public Integer getSid() {
      return sid;
   }
}

A seguir está o conteúdo do StudentMarksMapper.java Arquivo

package com.tutorialspoint;

import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;

public class StudentMarksMapper implements RowMapper<StudentMarks> {
   public StudentMarks mapRow(ResultSet rs, int rowNum) throws SQLException {
      StudentMarks studentMarks = new StudentMarks();
      studentMarks.setId(rs.getInt("id"));
      studentMarks.setName(rs.getString("name"));
      studentMarks.setAge(rs.getInt("age"));
      studentMarks.setSid(rs.getInt("sid"));
      studentMarks.setMarks(rs.getInt("marks"));
      studentMarks.setYear(rs.getInt("year"));

      return studentMarks;
   }
}

A seguir está o arquivo de classe de implementação StudentJDBCTemplate.java para a interface DAO definida, StudentDAO

package com.tutorialspoint;

import java.util.List;
import javax.sql.DataSource;

import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

public class StudentJDBCTemplate implements StudentDAO {
   private DataSource dataSource;
   private JdbcTemplate jdbcTemplateObject;
   private PlatformTransactionManager transactionManager;

   public void setDataSource(DataSource dataSource) {
      this.dataSource = dataSource;
      this.jdbcTemplateObject = new JdbcTemplate(dataSource);
   }
   public void setTransactionManager(PlatformTransactionManager transactionManager) {
      this.transactionManager = transactionManager;
   }
   public void create(String name, Integer age, Integer marks, Integer year){
      TransactionDefinition def = new DefaultTransactionDefinition();
      TransactionStatus status = transactionManager.getTransaction(def);

      try {
         String SQL1 = "insert into Student (name, age) values (?, ?)";
         jdbcTemplateObject.update( SQL1, name, age);

         // Get the latest student id to be used in Marks table
         String SQL2 = "select max(id) from Student";
         int sid = jdbcTemplateObject.queryForInt( SQL2 );

         String SQL3 = "insert into Marks(sid, marks, year) " + "values (?, ?, ?)";
         jdbcTemplateObject.update( SQL3, sid, marks, year);

         System.out.println("Created Name = " + name + ", Age = " + age);
         transactionManager.commit(status);
      } 
      catch (DataAccessException e) {
         System.out.println("Error in creating record, rolling back");
         transactionManager.rollback(status);
         throw e;
      }
      return;
   }
   public List<StudentMarks> listStudents() {
      String SQL = "select * from Student, Marks where Student.id=Marks.sid";
      List <StudentMarks> studentMarks = jdbcTemplateObject.query(SQL, 
         new StudentMarksMapper());
      
      return studentMarks;
   }
}

Agora vamos prosseguir com o arquivo principal do aplicativo MainApp.java, que é a seguinte -

package com.tutorialspoint;

import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;

public class MainApp {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
      StudentJDBCTemplate studentJDBCTemplate = 
         (StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
      
      System.out.println("------Records creation--------" );
      studentJDBCTemplate.create("Zara", 11, 99, 2010);
      studentJDBCTemplate.create("Nuha", 20, 97, 2010);
      studentJDBCTemplate.create("Ayan", 25, 100, 2011);

      System.out.println("------Listing all the records--------" );
      List<StudentMarks> studentMarks = studentJDBCTemplate.listStudents();
      
      for (StudentMarks record : studentMarks) {
         System.out.print("ID : " + record.getId() );
         System.out.print(", Name : " + record.getName() );
         System.out.print(", Marks : " + record.getMarks());
         System.out.print(", Year : " + record.getYear());
         System.out.println(", Age : " + record.getAge());
      }
   }
}

A seguir está o arquivo de configuração Beans.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" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">

   <!-- Initialization for data source -->
   <bean id = "dataSource" 
      class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
      <property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
      <property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
      <property name = "username" value = "root"/>
      <property name = "password" value = "password"/>
   </bean>

   <!-- Initialization for TransactionManager -->
   <bean id = "transactionManager" 
      class = "org.springframework.jdbc.datasource.DataSourceTransactionManager">
      <property name = "dataSource"  ref = "dataSource" />    
   </bean>

   <!-- Definition for studentJDBCTemplate bean -->
   <bean id = "studentJDBCTemplate"
      class = "com.tutorialspoint.StudentJDBCTemplate">
      <property name = "dataSource" ref = "dataSource" />
      <property name = "transactionManager" ref = "transactionManager" />    
   </bean>
      
</beans>

Assim que terminar de criar os arquivos de configuração de código-fonte e bean, vamos executar o aplicativo. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem -

------Records creation--------
Created Name = Zara, Age = 11
Created Name = Nuha, Age = 20
Created Name = Ayan, Age = 25
------Listing all the records--------
ID : 1, Name : Zara, Marks : 99, Year : 2010, Age : 11
ID : 2, Name : Nuha, Marks : 97, Year : 2010, Age : 20
ID : 3, Name : Ayan, Marks : 100, Year : 2011, Age : 25