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);
    }
时间： 2024-10-10 19:31:08

spring的orm模块的相关文章

Spring之ORM模块

ORM模块对Hibernate.JDO.TopLinkiBatis等ORM框架提供支持 ORM模块依赖于dom4j.jar.antlr.jar等包 在Spring里,Hibernate的资源要交给Spring管理,Hibernate以及其SessionFactory等知识Spring一个特殊的Bean,有Spring负责实例化与销毁.因此DAO层只需要继承HibernateDaoSupport,而不需要与Hibernate的API打交道,不需要开启.关闭Hibernate的Session.Tra

spring的核心模块有哪些？

Spring的七个核心模块,供大家参考,具体内容如下 1.Spring core:核心容器 核心容器提供spring框架的基本功能.Spring以bean的方式组织和管理Java应用中的各个组件及其关系.Spring使用BeanFactory来产生和管理Bean,它是工厂模式的实现.BeanFactory使用控制反转(IoC)模式将应用的配置和依赖性规范与实际的应用程序代码分开.BeanFactory使用依赖注入的方式提供给组件依赖.主要实现控制反转IoC和依赖注入DI.Bean配置以及加载.

Spring之WEB模块

Spring的WEB模块用于整合Web框架,例如Struts 1.Struts 2.JSF等 整合Struts 1 继承方式 Spring框架提供了ActionSupport类支持Struts 1的Action.继承了ActionSupport后就能获取Spring的BeanFactory,从而获得各种Spring容器内的各种资源 import org.springframework.web.struts.ActionSupport; public class CatAction extends

一头扎进Spring之---------Spring七大核心模块

Spring七大核心模块 核心容器(Spring Core) 核心容器提供Spring框架的基本功能.Spring以bean的方式组织和管理Java应用中的各个组件及其关系.Spring使用BeanFactory来产生和管理Bean,它是工厂模式的实现.BeanFactory使用控制反转(IoC)模式将应用的配置和依赖性规范与实际的应用程序代码分开 应用上下文(Spring Context) Spring上下文是一个配置文件,向Spring框架提供上下文信息.Spring上下文包括企业服务,如J

Spring Framework------&gt;version4.3.5.RELAESE-----&gt;Reference Documentation学习心得-----&gt;Spring Framework中的spring web MVC模块

spring framework中的spring web MVC模块 1.概述 spring web mvc是spring框架中的一个模块 spring web mvc实现了web的MVC架构模式,可以被用于开发web网站 spring web mvc 实现web网站的原理,如下图: 2.使用spring web mvc开发web应用的步骤 step1:在自己的工程中引入spring web mvc模块 step2:配置spring web mvc模块 中的DispatcherServlet,告

Spring整合ORM技术 -- 集成Hibernate

1.Spring整合ORM方案的好处: 方便基础设施的搭建.不同的ORM技术都有一套自己的方案以初始化框架.搭建基础设施等.在搭建基础设施中,数据源是不可或缺的资源,不同的ORM框架的实现方式各不相同.Spring针对不同的ORM框架,采用相同的方式配置数据源,并为不同的ORM框架提供相同的FactoryBean,用以初始化ORM框架的基础设施,可以把它们当成普通Bean对待. 异常封装.Spring能够转化各种ORM框架抛出的异常,将ORM框架专有的或检查型异常转换为SpringDAO异常体系

Spring的DAO模块

Spring的DAO模块提供了对JDBC.Hibernate.JDO等DAO层支持. DAO模块依赖 commons-pool.jar.commons-collections.jar package com.dao; import java.util.ArrayList; import java.util.Date; import java.util.List; import java.util.Map; import org.springframework.jdbc.core.support.

Maven 搭建spring boot多模块项目

Maven 搭建spring boot多模块项目 备注:所有项目都在idea中创建 1.idea创建maven项目 1-1: 删除src,target目录,只保留pom.xml 1-2: 根目录pom.xml可被子模块继承,因此项目只是demo,未考虑太多性能问题,所以将诸多依赖 都写在根级`pom.xml`,子模块只需继承就可以使用. 1-3: 根级pom.xml文件在附录1 1-4: 依赖模块 mybatis spring-boot相关模块 2.创建子模块(module) 2-1: file

Spring之DAO模块

Spring的DAO模块提供了对JDBC.Hibernate.JDO等DAO层支持 DAO模块依赖于commons-pool.jar.commons-collections.jar Spring完全抛弃了JDBC API,开发者只需要使用封装好的JdbcTemplate执行SQL语句,然后得到需要的结果 DAO层业务逻辑 public interface IpersonDao{ public String getPersonName(Integer id); public void addPer