Detaillierte Code-Erklärung von Spring und Hibernate für das Erlernen der Java-Transaktionsverwaltung

Dieser Artikel führt Sie hauptsächlich in die relevanten Informationen zu Spring und Hibernate ein, um das Java-Transaktionsmanagement zu erlernen. Freunde, die es benötigen, können es sich gemeinsam ansehen.

Umgebung und Version

Zusätzlich zu den Ruhezustand-bezogenen Bibliotheken in einem Artikel vor der Veröffentlichung dieses Artikels

Hibernate für Java-Transaktionsmanagement

Sie müssen außerdem das Spring-Lib-Paket und die folgenden Abhängigkeitspakete hinzufügen

org.aopalliance

org.aspectj

org.apache.commons

Springs Version ist Spring 4.1.5.

Abhängigkeitspakete können auch von der offiziellen Spring-Website heruntergeladen werden, mit Namen ähnlich wie spring-framework-3.0.2.RELEASE-dependencies

Theoretische Kenntnisse

Nach der Integration von Spring und Hibernate habe ich bei der Ausführung von Datenbankoperationen über die Hibernate-API Folgendes festgestellt: opensession, close, beginTransaction, und Commit sind jedes Mal erforderlich. Dies sind sich wiederholende Aufgaben, und wir können den Teil der Transaktionsverwaltung dem Spring-Framework überlassen.

Nachdem Sie Spring zum Verwalten von Transaktionen verwendet haben, müssen Sie nicht mehr beginTransaction und Commit in Dao aufrufen und auch nicht session.close() verwenden. API sessionFactory.getCurrentSession() anstelle von sessionFactory.openSession()

* falls verwendet Es handelt sich um eine lokale Transaktion (JDBC-Transaktion)

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

* Wenn Sie eine globale Transaktion (JTA-Transaktion) verwenden

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

Propagation-Klasse im Frühjahr Detaillierte Erläuterung der Transaktionsattribute:

PROPAGATION_REQUIRED: Unterstützt die aktuelle Transaktion. Wenn keine aktuelle Transaktion vorhanden ist, erstellen Sie eine neue Transaktion. Dies ist die häufigste Wahl.

PROPAGATION_SUPPORTS: Unterstützt die aktuelle Transaktion. Wenn derzeit keine Transaktion vorhanden ist, wird sie auf nicht-transaktionale Weise ausgeführt.

PROPAGATION_MANDATORY: Unterstützt die aktuelle Transaktion. Wenn keine aktuelle Transaktion vorhanden ist, wird eine Ausnahme ausgelöst.

PROPAGATION_REQUIRES_NEW: Erstellen Sie eine neue Transaktion. Wenn derzeit eine Transaktion vorhanden ist, unterbrechen Sie die aktuelle Transaktion.

PROPAGATION_NOT_SUPPORTED: Vorgänge auf nicht-transaktionale Weise ausführen. Wenn derzeit eine Transaktion vorhanden ist, unterbrechen Sie die aktuelle Transaktion.

PROPAGATION_NEVER: Wird nicht transaktional ausgeführt. Wenn derzeit eine Transaktion vorhanden ist, wird eine Ausnahme ausgelöst.

PROPAGATION_NESTED: Unterstützt die aktuelle Transaktion. Wenn keine aktuelle Transaktion vorhanden ist, wird eine neue Transaktion erstellt.

Spring kann XML für die Konfiguration oder Anmerkungsdeklaration für die Transaktionsverwaltung verwenden.

Beispiel für einen XML-Modus-Konfigurationstransaktionscode

Die Codestruktur ist wie folgt:

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(); 
 } 
 
}

Die Beschreibung lautet wie folgt:

Get erfordert keine Transaktion

Wenn keine Einfügung oder Aktualisierung erfolgt, ist die Aktualisierung nicht erfolgreich

Deklarativ konfigurieren Die Transaktion

muss in der XML-Konfiguration festgelegt werden. Alle Methoden führen die Transaktionsverarbeitung durch. Der folgende Code führt die Transaktionsverarbeitung in der Serviceschicht durch (dies ist eine bessere Möglichkeit, Transaktionen für den Service zu konfigurieren). Schicht, da eine Service-Schicht-Methodenoperation mehreren DAO-Vorgängen zugeordnet werden kann. Führen Sie diese Dao-Vorgänge in der Service-Schicht aus, und mehrere DAO-Vorgänge werden alle zurückgesetzt, wenn sie fehlschlagen, und alle werden übermittelt, wenn sie erfolgreich sind) 3832b7f60b35c979934ab8147f86b2bd

Wenn einige Methoden in der Klasse keine Dinge erfordern:

Zusammenfassung

@Service


 @Transactional


 public class UserServiceImpl implements UserService {


  @Autowired


  private UserDao userDao;


 
  public User getUserById(int id) {


   return userDao.findUserById(id);


  }


 }

Das obige ist der detaillierte Inhalt vonDetaillierte Code-Erklärung von Spring und Hibernate für das Erlernen der Java-Transaktionsverwaltung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!