spring的orm模块
spring整合hibernate
1、hibernate使用注解。
daoImpl需要继承HibernateDaoSupport对象,针对给对象的getHibernateTemplate()进行hibernate操作。操作的语句是hql语句。
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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="configProperties"
class="org.springframework.beans.factory.config.PropertiesFactoryBean">
<property name="locations">
<list>
<value>jdbc.properties</value>
</list>
</property>
</bean> <bean id="propertyConfigure"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="properties" ref="configProperties" />
</bean> <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClassName" value="${jdbc.driver}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
<property name="url" value="${jdbc.url}" />
</bean> <bean id="sessionFactory"
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean"
destroy-method="destroy">
<property name="dataSource" ref="dataSource"></property>
<property name="annotatedPackages" value="classpath:com" /> 该package下的所有类都会当成实体类加载
<property name="annotatedClasses"> 配置实体类
<list>
<value>com.entity.Cat</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">true</prop>
<prop key="hibernate.dialect">${jdbc.dialect}</prop>
<prop key="hibernate.hbm2ddl.auto">saveorupdate</prop> 创建表结构
</props>
</property>
</bean> <bean id="catDao" class="com.dao.CatDaoImpl">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
Cat.java
package com.entity; import java.util.Date; import javax.jdo.annotations.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType; @Entity
@Table(name="cat")
public class Cat {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY) //主键规则配置
private int id;
@Column(name="name")
private String name;
@Column(name="createDate")
@Temporal(value=TemporalType.TIMESTAMP) <!--Date类型在数据库里面设定 -->
private Date createDate; public void setName(String name) {
this.name = name;
} public String getName() {
return name;
} public void setId(int id) {
this.id = id;
} public int getId() {
return id;
} public void setCreateDate(Date createDate) {
this.createDate = createDate;
} public Date getCreateDate() {
return createDate;
} }
测试:
public static void method1(){
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml"); CatDao catdao=context.getBean("catDao",CatDao.class);
/*Cat cat=new Cat();
cat.setName("喵咪");
cat.setCreateDate(new Date());
catdao.createCat(cat); List<Cat> cats=catdao.listCats();
for(int i=0;i<cats.size();i++){
System.out.println(cats.get(i).getId()+"\t"+cats.get(i).getName()+"\t"+cats.get(i).getCreateDate().toLocaleString());
}*/ Cat cat1=catdao.findCatByName("喵咪");
System.out.println(cat1.getId()+"\t"+cat1.getName()+"\t"+cat1.getCreateDate()); }
使用xml实现hibernate整合
1、sessionFactory的class由org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean变成了org.springframework.orm.hibernate3.LocalSessionFactoryBean
2、加入property名为mappingResources的注入实体类映射文件
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean" destroy-method="destroy">
<property name="dataSource" ref="dataSource" />
<property name="mappingResources"><!-- 配置实体类 -->
<list>
<value>com/entity/Dog.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">true</prop>
<prop key="hibernate.dialect">${jdbc.dialect}</prop>
<prop key="hibernate.hbm2ddl.auto">saveorupdate</prop><!-- 创建表结构
--></props>
</property>
</bean> <bean id="dogDao" class="com.dao.DogDaoImpl">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping>
<class name="com.entity.Dog" table="Dog">
<id name="id" type="int">
<column name="id"></column>
<generator class="identity" />
</id>
<property name="name" type="string">
<column name="name"></column>
</property>
<property name="age" type="int">
<column name="age"></column>
</property>
</class>
</hibernate-mapping> package com.entity; public class Dog {
private int id;
private String name;
private int age;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
} }
public static void method2(){
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
DogDao dogdao=context.getBean("dogDao",DogDao.class); /*Dog dog=new Dog();
dog.setName("旺旺");
dog.setAge(12);
dogdao.createDog(dog);*/ List<Dog> dogs=dogdao.findAll();
System.out.println(dogs.get(0).getName()); } package com.dao; import java.util.List; import com.entity.Dog; public interface DogDao {
public void createDog(Dog dog);
public List<Dog> findAll();
public void updateDog(Dog dog);
public Dog findDogByName(String name);
} package com.dao; import java.util.List; import org.hibernate.Session;
import org.hibernate.Transaction;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport; import com.entity.Dog; public class DogDaoImpl extends HibernateDaoSupport implements DogDao{ public void createDog(Dog dog) {
// Session session=this.getSession();
//Transaction tx=session.beginTransaction();
// try{ /* 我现在要将事物配置在applicationContext中 */
this.getHibernateTemplate().save(dog);
// tx.commit();}
// catch(Exception e){
// tx.rollback();
// }
} @SuppressWarnings("unchecked")
public List<Dog> findAll() { List<Dog> dogs=this.getHibernateTemplate().find("from Dog");
return dogs;
} public void updateDog(Dog dog) {
// Session session=this.getSession();
// Transaction tx=session.beginTransaction();
// try{
this.getHibernateTemplate().update(dog);
// tx.commit();}
// catch(Exception e){
// tx.rollback();
// } } public Session createSession(){
Session session=this.getSession();
if(session==null||!session.isOpen()){
session=getHibernateTemplate().getSessionFactory().openSession();
}
return session;
}
public void closeSession(){
this.getSession().close();
} @SuppressWarnings("unchecked")
public Dog findDogByName(String name) { List<Dog> dogs=this.getHibernateTemplate().find("select d from Dog d where name=?",name );
if(dogs.size()>0){
Dog d=dogs.get(1);
return d;
}
return null;
} }
整合后使用hibernate事务管理
另外一半使用service类,方便aop
package com.service; import java.util.List; import com.entity.Dog; public interface DogService {
public void createDog(Dog dog);
public List<Dog> findAll();
public void updateDog(Dog dog);
public Dog findDogByName(String name); } package com.service; import java.util.List; import com.dao.DogDao;
import com.entity.Dog; public class DogServiceImpl implements DogService{
private DogDao dogDao; public void setDogDao(DogDao dogDao) {
this.dogDao = dogDao;
} public DogDao getDogDao() {
return dogDao;
} public void createDog(Dog dog) {
dogDao.createDog(dog);
} public List<Dog> findAll() { return dogDao.findAll();
} public Dog findDogByName(String name) {
return dogDao.findDogByName(name);
} public void updateDog(Dog dog) {
dogDao.updateDog(dog);
} }
<bean id="hibernateTransactionAttributeSource" class="org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource"> <!-- 事务管理规则 -->
<property name="properties"> <!-- 具备事务管理的方法名 -->
<props>
<prop key="update*">PROPAGATION_REQUIRED</prop>
<prop key="create*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean> <bean id="hibernateTransactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <!-- hibernate 事务管理器 -->
<property name="sessionFactory" ref="sessionFactory"></property>
</bean> <bean id="dogService" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager" ref="hibernateTransactionManager"> </property>
<property name="target"> <!-- 被管理的对象,匿名Bean -->
<bean class="com.service.DogServiceImpl">
<property name="dogDao" ref="dogDao"></property>
</bean>
</property>
<property name="transactionAttributeSource" ref="hibernateTransactionAttributeSource" /> <!-- 设置事务管理规则 -->
</bean>
public static void method3(){
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
DogService dogservice=context.getBean("dogService",DogService.class); Dog d=new Dog();
d.setName("旺仔");
d.setAge(13); dogservice.createDog(d);
}
spring的orm模块的更多相关文章
- Spring之ORM模块
ORM模块对Hibernate.JDO.TopLinkiBatis等ORM框架提供支持 ORM模块依赖于dom4j.jar.antlr.jar等包 在Spring里,Hibernate的资源要交给Sp ...
- 1.Spring——七大主要模块
Spring有七大功能模块,分别是Spring Core,AOP,ORM,DAO,MVC,WEB,Content. 下面分别简单介绍: 1.Spring Core Core模块是Spring的核心类库 ...
- spring的核心模块有哪些?
Spring的七个核心模块,供大家参考,具体内容如下 1.Spring core:核心容器 核心容器提供spring框架的基本功能.Spring以bean的方式组织和管理Java应用中的各个组件及其关 ...
- Spring之WEB模块
Spring的WEB模块用于整合Web框架,例如Struts 1.Struts 2.JSF等 整合Struts 1 继承方式 Spring框架提供了ActionSupport类支持Struts 1的A ...
- [02] Spring主要功能模块概述
1.Spring主要功能模块 1.1 Core Container Spring的核心容器模块,其中包括: Beans Core Context SpEL Beans和Core模块,是框架的基础部 ...
- 一头扎进Spring之---------Spring七大核心模块
Spring七大核心模块 核心容器(Spring Core) 核心容器提供Spring框架的基本功能.Spring以bean的方式组织和管理Java应用中的各个组件及其关系.Spring使用BeanF ...
- Spring中各个模块
Spring中个模块介绍 核心模块 提供了对Bean的配置.管理.创建等以及IOC/DI.如果只需要提供IOC/DI功能,只需要引入Beans和Core两个jar包 Core 包含Spring框架 ...
- Spring Framework------>version4.3.5.RELAESE----->Reference Documentation学习心得----->Spring Framework中的spring web MVC模块
spring framework中的spring web MVC模块 1.概述 spring web mvc是spring框架中的一个模块 spring web mvc实现了web的MVC架构模式,可 ...
- Spring第七篇【Spring的JDBC模块】
前言 上一篇Spring博文主要讲解了如何使用Spring来实现AOP编程,本博文主要讲解Spring的对JDBC的支持- 对于JDBC而言,我们肯定不会陌生,我们在初学的时候肯定写过非常非常多的JD ...
随机推荐
- 移动端Css初始化
@charset "utf-8"; /* 禁用iPhone中Safari的字号自动调整 */ html { -webkit-text-size-adjust: %; -ms-tex ...
- git连接华为开发云devcloud
华为开发运在代码托管方面的个github很类似,引入了代码仓库的概念,同时需要本地安装git客户端,且只能与git进行连接,从这个角度上讲,华为开发云的代码管理部分就是github的功能,下面对git ...
- hdu 1573 X问题 两两可能不互质的中国剩余定理
X问题 Time Limit: 1000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Problem Desc ...
- Vim简本
参考链接:http://yannesposito.com/Scratch/en/blog/Learn-Vim-Progressively/ 本文将更简化,只保留其中的精华部分. Level One — ...
- sublime text3 (Mac) 快捷键
符号说明 符号 说明 ⌘ command ⌃ control ⌥ option ⇧ shift ↩ enter ⌫ delete 打开/关闭/前往 快捷键 功能 ⌘⇧N 打开一个新的sublime窗口 ...
- shell 逻辑操作符
Shell还提供了与( -a ).或( -o ).非( ! )三个逻辑操作符用于将测试条件连接起来,其优先级为:"!"最高,"-a"次之,"-o&qu ...
- 爱阅app --- 答复功能改进建议
共有四组评论,接下来一一答复. 第一组: 希望增加的功能: 1.希望能够继续完善书签功能,增加逐条删除书签功能. 2.能够在爱阅内部打开APP中提供的网址,用户选择一款阅读APP,当然不想每看一本新的 ...
- AMD,CMD.CommonJs和UMD还有es6的模块化对比
CommonJS CommonJS是服务器端模块的规范,Node.js采用了这个规范. 根据CommonJS规范,一个单独的文件就是一个模块.加载模块使用require方法,该方法读取一个文件并执行, ...
- m_Orchestrate learning system---三十一、模板和需求的关系
m_Orchestrate learning system---三十一.模板和需求的关系 一.总结 一句话总结:模板为了适应广大用户,有很多功能样式,但是,你需要的只是部分,所以删掉不需要的,如果有需 ...
- CentOS Redhat Linux安装 Oracle Client 的注意点
1) 安装文件要拷贝到本地文件系统执行 2) 虽然不知道 libXmu是什么,但是安装之后,关联包安装了许多,感觉很省心 yum install libXmu.i686 3) 还有找不到的包的话,用 ...