Maison > Java > javaDidacticiel > Explication détaillée du code du module ORM de Spring

Explication détaillée du code du module ORM de Spring

小云云
Libérer: 2017-12-05 11:40:50
original
2150 Les gens l'ont consulté

Le mappage objet-relationnel ORM est une technologie de programmation utilisée pour convertir des données entre différents types de systèmes dans des langages de programmation orientés objet. En fait, il crée une « base de données d'objets virtuels » qui peut être utilisée dans un langage de programmation. Cet article présente principalement une explication détaillée du code du module ORM de Spring, qui a une certaine valeur de référence. Les amis qui en ont besoin peuvent en savoir plus.

Une brève introduction aux sept modules majeurs du framework Spring

Explication détaillée du code du module MVC dans Spring

Le module ORM est très utile pour Hibernate, JDO, TopLinkiBatis et d'autres frameworks ORM fournissent un support

Les modules ORM s'appuient sur dom4j.jar, antlr.jar et d'autres packages

Au printemps, les ressources Hibernate doivent être géré par Spring, Hibernate et sa SessionFactory et d'autres connaissances Spring est un Bean spécial, Spring est responsable de l'instanciation et de la destruction. Par conséquent, la couche DAO n'a besoin que d'hériter d'HibernateDaoSupport et n'a pas besoin de gérer l'API d'Hibernate. Elle n'a pas besoin d'ouvrir ou de fermer la session d'Hibernate et Transaction Spring maintiendra automatiquement ces objets

public interface ICatDao{ 
   public void createCat(Cat cat); 
   public List<Cat> listCats(); 
   public int getCatsCount(); 
   public Cat findCatByName(String name); 
}
Copier après la connexion

import org.springframework.orm.hibernate3.support.HibernateDaoSupport; 
public class CatDaoImpl extends HibernateDaoSupportimplements ICatDao{ 
   public void createCat(Cat cat){ 
       this.getHibernateTemplate().persist(cat); 
   } 
   public List<Cat> listCats(){ 
       return this. getHibernateTemplate().find("select cfrom Cat c"); 
   } 
   public int getCatsCount(){ 
       Number n = (Number)this.getSession(true).createQuery("selectcount(c) from Cat c").uniqueResult(); 
       return n.intValue(); 
   } 
   public Cat findCatByName(String name){ 
       List<Cat> catList =this.getHibernateTemplate().find("select c from Cat where c.name = ?",name); 
       if(catList.size()>0) 
          return catList.get(0); 
       return null; 
   } 
  
}
Copier après la connexion

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean" destroy-method="destroy"> 
<property name="dataSource" ref="dataSource" /> 
<!-- 该Package下的所有类都会被当做实体类加载--> 
<property name="annotatedPackages" value="classpath:/com/clf/orm" /> 
<property name="anotatedClasses"> 
   <list> 
       <value>com.clf.spring.orm.Cat</value> 
       <value>com.clf.spring.orm.Dog</value> 
   </list> 
<property name="hibernateProperties"> 
   <props> 
       <prop key="hiberante.dialect">org.hibernate.dialect.MySQLDialect</prop> 
       <prop key="hibernate.show_sql">true</prop> 
       <prop key=" hibernate.format_sql">true</prop> 
       <prop key=" hibernate.hbm2ddl.auto">create</prop> 
   </props> 
</property> 
  
<bean id="catDao" class="com.clf.spring.orm.CatDaoImpl"> 
   <property name="sessionFactory" ref=" sessionFactory"/> 
</bean>
Copier après la connexion

Si vous utilisez des classes d'entités configurées en XML, remplacez par

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean" destroy-method="destroy"> 
<property name="mappingResources"> 
   <list> 
       <value>classpath:/com/clf/orm/Cat.hbm.xml</value> 
   </list> 
</property> 
…… 
</bean>
Copier après la connexion

Spring ajoute des transactions à la couche DAO par défaut, et chaque méthode de la couche DAO est une transaction. Dans la programmation Spring+Hibernate, l'approche habituelle consiste à ajouter une couche Service au-dessus de la couche DAO, puis à configurer la transaction dans la couche Service

public interface ICatService{ 
   public void createCat(Cat cat); 
   public List<Cat> listCats();  
   public int getCatsCount(); 
}
Copier après la connexion

en couches La méthode est que le programme appelle la couche Service, la couche Service appelle la couche DAO et la couche DAO appelle Hibernate pour implémenter l'accès aux données. En principe, l'accès croisé n'est pas autorisé. La superposition rend le niveau métier plus clair

public class CatServiceImpl implements ICatService{ 
   private IDao catDao; 
   public IDao getCatDao(){ 
       return catDao; 
   } 
  
   public void setCatDao(IDao dao){ 
       this.catDao = dao; 
   } 
    
   public void createCat(Cat cat){ 
       catDao.createCat(cat); 
   } 
   public List<Cat> listCats(){ 
       return catDao.listCats(); 
   } 
   public int getCatsCount(){ 
       return catDao.getCatsCount(); 
   } 
  
}
Copier après la connexion

Configurez ensuite la gestion des transactions au niveau de la couche Service

<!-- 事务管理器--> 
<bean id="hibernateTransactionManager" class=" org.springframework.orm.hibernate3.HibernateTransactionManager 
"> 
   <property name="sessionFactory" ref="sessionFactory"/> 
</bean> 
  
<!-- 事务管理规则--> 
<bean id="hibernateTransactionAttributeSource" class=" org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource"> 
   <property name="properties"> 
       <props><!-- 为所有方法加上事务--> 
          <propkeypropkey="*">PROPGATION_REQUIRED</prop> 
   </property> 
</bean> 
  
<!-- 事务工厂代理类,将Service实现类、事务管理器、事务管理规则组装在一起--> 
<bean id="catService" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"> 
   <property name="transactionManager" ref=" hibernateTransactionManager"> 
   <property name="target"> 
       <bean class="com.clf.spring.orm.CatServiceImpl" > 
          <property name="catDao" ref="catDao"/> 
       </bean> 
   </property> 
   <property name="transactionAttributeSource" ref=" hibernateTransactionAttributeSource" /> 
</bean>
Copier après la connexion

Le contenu ci-dessus est une explication détaillée du code du module ORM de Spring. J'espère qu'il pourra aider tout le monde.

Recommandations associées :

Avantages du framework Spring dans le framework Java

Explication détaillée de SpringAop en Java

Une brève introduction à Spring MVC

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!

Étiquettes associées:
source:php.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal