Explication détaillée du code de Spring et Hibernate pour l'apprentissage de la gestion des transactions Java

Cet article vous présente principalement les informations pertinentes de Spring et Hibernate pour apprendre la gestion des transactions Java. L'article le présente en détail à travers un exemple de code. Les amis qui en ont besoin peuvent s'y référer.

Environnement et version

En plus des bibliothèques liées à la mise en veille prolongée dans un article précédant la publication de cet article

Hibernate pour la gestion des transactions Java

Vous devez également ajouter le package spring lib et les packages de dépendances suivants

org.aopalliance

org.aspectj

org.apache.commons

La version de Spring est Spring 4.1.5.

Les packages de dépendances peuvent également être téléchargés sur le site officiel de Spring, avec des noms similaires à spring-framework-3.0.2.RELEASE-dependencies

Connaissances théoriques

Après avoir intégré Spring et Hibernate, lors de l'exécution des opérations de base de données via l'API d'Hibernate, j'ai trouvé que opensession, close,bebeTransaction, et commit sont requis à chaque fois. Ce sont des tâches répétitives, et nous pouvons laisser la partie gestion des transactions au framework spring.

Après avoir utilisé Spring pour gérer les transactions, vous n'avez plus besoin d'appeler BeginTransaction et de commit dans dao, ni d'appeler session.close() Utiliser l'API sessionFactory.getCurrentSession() au lieu de sessionFactory.openSession()

* si utilisé Il s'agit d'une transaction locale (transaction jdbc)

<property name="hibernate.current_session_context_class">thread</property>

* Si vous utilisez une transaction globale (transaction jta)

<property name="hibernate.current_session_context_class">jta</property>

Classe de propagation au printemps Explication détaillée des attributs de transaction :

PROPAGATION_REQUIRED : prend en charge la transaction en cours. S'il n'y a pas de transaction en cours, créez une nouvelle transaction. C'est le choix le plus courant.

PROPAGATION_SUPPORTS : Prend en charge la transaction en cours. S'il n'y a pas de transaction actuellement, elle sera exécutée de manière non transactionnelle.

PROPAGATION_MANDATORY : Prend en charge la transaction en cours. S'il n'y a pas de transaction en cours, une exception sera levée.

PROPAGATION_REQUIRES_NEW : Créez une nouvelle transaction si une transaction existe actuellement, suspendez la transaction en cours.

PROPAGATION_NOT_SUPPORTED : Effectuer des opérations de manière non transactionnelle. Si une transaction existe actuellement, suspendez la transaction en cours.

PROPAGATION_NEVER : Exécuté de manière non transactionnelle, si une transaction existe actuellement, une exception sera levée.

PROPAGATION_NESTED : Prend en charge la transaction en cours. Si la transaction en cours existe, une transaction imbriquée sera exécutée. S'il n'y a pas de transaction en cours, une nouvelle transaction sera créée.

Spring peut utiliser XML pour la configuration ou la déclaration d'annotation pour la gestion des transactions.

Exemple de code de transaction de configuration du mode XML

La structure du code est la suivante :

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:p="http://www.springframework.org/schema/p" 
 xmlns:context="http://www.springframework.org/schema/context" 
 xmlns:util="http://www.springframework.org/schema/util" xmlns:mvc="http://www.springframework.org/schema/mvc" 
 xmlns:tx="http://www.springframework.org/schema/tx" 
 xmlns:aop="http://www.springframework.org/schema/aop" 
 xsi:schemaLocation=" 
  http://www.springframework.org/schema/util 
  http://www.springframework.org/schema/util/spring-util-3.1.xsd 
  http://www.springframework.org/schema/beans 
  http://www.springframework.org/schema/beans/spring-beans-3.1.xsd 
  http://www.springframework.org/schema/context 
  http://www.springframework.org/schema/context/spring-context-3.1.xsd 
  http://www.springframework.org/schema/mvc 
  http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd 
  http://www.springframework.org/schema/tx 
  http://www.springframework.org/schema/tx/spring-tx-3.0.xsd 
  http://www.springframework.org/schema/aop 
  http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"> 
 
 <context:component-scan base-package="com.oscar999.trans.sprhib" /> 
 <context:property-placeholder location="classpath:/com/oscar999/trans/sprhib/config.properties" /> 
 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" 
  destroy-method="close"> 
  <!-- Connection Info --> 
  <property name="driverClassName" value="${jdbc.driver}" /> 
  <property name="url" value="${jdbc.url}" /> 
  <property name="username" value="${jdbc.username}" /> 
  <property name="password" value="${jdbc.password}"></property> 
 </bean> 
 
 <bean id="sessionFactory" 
  class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"> 
  <property name="dataSource" ref="dataSource"></property> 
  <property name="hibernateProperties"> 
   <props> 
    <prop key="hibernate.dialect">org.hibernate.dialect.OracleDialect</prop> 
    <prop key="hibernate.hbm2ddl.auto">update</prop> 
    <prop key="hibernate.show_sql">true</prop> 
    <prop key="hibernate.format_sql">true</prop> 
    <prop key="hibernate.jdbc.batch_size">20</prop> 
    <prop key="hibernate.enable_lazy_load_no_trans">true</prop> 
    <prop key="hibernate.current_session_context_class">org.springframework.orm.hibernate4.SpringSessionContext</prop> 
    <prop key="jdbc.use_streams_for_binary">true</prop> 
   </props> 
  </property> 
  <property name="packagesToScan"> 
   <list> 
    <value>com.oscar999.trans.sprhib.model</value> 
   </list> 
  </property> 
 </bean> 
 
 <!-- Transaction --> 
 <bean id="transactionManager" 
  class="org.springframework.orm.hibernate4.HibernateTransactionManager"> 
  <property name="sessionFactory" ref="sessionFactory" /> 
 </bean> 
 <tx:advice id="txAdvice" transaction-manager="transactionManager"> 
  <tx:attributes> 
   <tx:method name="save*" propagation="REQUIRED" /> 
   <tx:method name="*" read-only="true" /> 
  </tx:attributes> 
 </tx:advice> 
 <aop:config proxy-target-class="true"> 
  <aop:pointcut expression="execution(* com.oscar999.trans.sprhib.dao.ProductDAOImpl.*(..))" id="pointcut" /> 
  <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" /> 
 </aop:config> 
 
</beans>

config.properties

jdbc.driver=oracle.jdbc.driver.OracleDriver 
jdbc.url=jdbc:oracle:thin:@12.6.18.43:1521:orcl 
jdbc.username= 
jdbc.password=oracle

Product.Java

/** 
 * @Title: Product.java 
 * @Package com.oscar999.trans.hibernate 
 * @Description: 
 * @author XM 
 * @date Feb 15, 2017 1:44:47 PM 
 * @version V1.0 
 */ 
package com.oscar999.trans.sprhib.model; 
 
import java.io.Serializable; 
 
import javax.persistence.Column; 
import javax.persistence.Entity; 
import javax.persistence.Id; 
import javax.persistence.Table; 
 
/** 
 * @author XM 
 * 
 */ 
@Entity 
@Table(name = "TEST_PRODUCT") 
public class Product implements Serializable { 
 
 public Product() { 
 } 
 
 @Id 
 @Column(name = "ID") 
 private Integer id; 
 
 @Column(name = "NAME") 
 private String name; 
 
 @Column(name = "PRICE") 
 private String price; 
 
 private static final long serialVersionUID = 1L; 
 
 public Integer getId() { 
  return id; 
 } 
 
 public void setId(Integer id) { 
  this.id = id; 
 } 
 
 public String getName() { 
  return name; 
 } 
 
 public void setName(String name) { 
  this.name = name; 
 } 
 
 public String getPrice() { 
  return price; 
 } 
 
 public void setPrice(String price) { 
  this.price = price; 
 } 
 
}

ProductDAOImpl.java

/** 
 * @Title: ProductDAOImpl.java 
 * @Package com.oscar999.trans.sprhib 
 * @Description: 
 * @author XM 
 * @date Feb 15, 2017 4:15:09 PM 
 * @version V1.0 
 */ 
package com.oscar999.trans.sprhib.dao; 
 
import org.hibernate.Session; 
import org.hibernate.SessionFactory; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.stereotype.Repository; 
 
import com.oscar999.trans.sprhib.model.Product; 
 
/** 
 * @author XM 
 * 
 */ 
@Repository 
public class ProductDAOImpl { 
 
 @Autowired 
 private SessionFactory sessionFactory; 
 
 public Product findProductById(int id) { 
  Session session = sessionFactory.getCurrentSession(); 
  Product product = (Product) session.get(Product.class, id); 
  return product; 
 } 
  
 public Product saveProduct(Product product) { 
  Session session = sessionFactory.getCurrentSession(); 
  session.save(product); 
  return product; 
 } 
}

ProductServiceImpl.java

package com.oscar999.trans.sprhib; 
 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.stereotype.Service; 
 
import com.oscar999.trans.sprhib.dao.ProductDAOImpl; 
import com.oscar999.trans.sprhib.model.Product; 
 
@Service 
public class ProductServiceImpl { 
 
 @Autowired 
 private ProductDAOImpl productdao; 
 
 public void findProduct(int id) { 
  Product product = productdao.findProductById(id); 
  if (product != null) { 
   System.out.println(product.getName()); 
  } 
 } 
 
 public void saveProduct() { 
  Product product = new Product(); 
  product.setId(2); 
  product.setName("product2"); 
  product.setPrice("price2"); 
  productdao.saveProduct(product); 
 
 } 
}

TestMain.java

/** 
 * @Title: TestMain.java 
 * @Package com.oscar999.trans.sprhib 
 * @Description: 
 * @author XM 
 * @date Feb 15, 2017 3:54:54 PM 
 * @version V1.0 
 */ 
package com.oscar999.trans.sprhib; 
 
import org.springframework.context.ApplicationContext; 
import org.springframework.context.support.ClassPathXmlApplicationContext; 
 
/** 
 * @author XM 
 * 
 */ 
public class TestMain { 
 
 /** 
  * @param args 
  */ 
 public static void main(String[] args) { 
  // TODO Auto-generated method stub 
  ApplicationContext applicationContext = new ClassPathXmlApplicationContext("com/oscar999/trans/sprhib/applicationContext.xml"); 
  ProductServiceImpl productService = applicationContext.getBean(ProductServiceImpl.class); 
  //productService.findProduct(1); 
  productService.saveProduct(); 
 } 
 
}

La description est la suivante :

Get ne nécessite pas de transaction

S'il n'y a pas d'insertion ou de mise à jour, la mise à jour ne réussira pas

Configurer de manière déclarative la transaction

doit être définie dans la configuration XML. Les méthodes effectuent toutes le traitement des transactions. Le code suivant effectue le traitement des transactions dans la couche de service (c'est une meilleure façon de configurer les transactions pour le service. couche, car une opération de méthode de couche Service peut être associée à plusieurs opérations DAO. Exécutez ces opérations Dao dans la couche Service, et plusieurs opérations DAO seront toutes annulées si elles échouent, et toutes seront soumises si elles réussissent)

3832b7f60b35c979934ab8147f86b2bd
Quand certaines méthodes de la classe ne nécessitent pas de choses :

Résumé.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!