Spring与Hibernate整合

Spring+Hibernate整合

       在进行整合前，我认为将Hibernate的配置整合到Spring的配置中，由Spring进行管理，由Hibernate进行对数据库的操作。

       后来在网上找了一些整合的方法，但是整合都失败了，因为我的Hibernate的版本是5，所以有些包被集成进其他包，在Spring的xml文件中配置，是找不到那个包的，而且我也不清楚Hibernate5将这个包放在哪里，或者未来还将有多少类似的事情发生，所以还是重新下载Hibernate3.3来用。

 

项目目录如下：

 

下载好了Hibernate3.3后，我们开始整合Spring和Hibernate！

 

1.     建立一个User Library，向其中导入Hibernate需要用到的jar包。

 　在这里，我们一定要注意，宁可少导包，报错后按照提示进行导包，也不要多导，否则会出问题。以下是使用Hibernate3.3需要导入的包：

 

a)     连接mysql的jar包，我是为了方便直接导入了。

b)     hibernate-distribution-3.3.2.GA目录下的hibernate3.jar。

这是Hibernate3.3的核心包

c)     将hibernate-distribution-3.3.2.GA\lib\required目录下的6个jar包全部导入。

d)     因为我们要使用注解，就需要添加和注解有关的jar包，需要下载

hibernate-annotation-3.4.0.GA的所有jar包。

将hibernate-annotations-3.4.0.GA目录下的hibernate-annotations.jar导入。

e)    将hibernate-annotations-3.4.0.GA\hibernate-annotations-3.4.0.GA\lib目录下的ejb3-persistence.jar以及hibernate-sommons-annotations.jar导入。

f)    最后需要下载slf4j-1.5.8（一定要和上面导入的slf4j-api-1.5.8.jar版本相同）将目录下的slf4j-nop-1.5.8.jar导入。

 

至此，Hibernate需要的包全部导入了。

2.     建立Spring的User Library。

 

 需要的包如下：还是注意，宁可多导，不能少导。

3.     先建立个实体类

　　　建立实体类的时候，实体类名称尽量不要与Mysql的关键字重复，否则容易引起冲突。我在此建立一个Student实体类。在这里加上@Entity，@Id，@generatedValue注解。

package com.spring_hibernate.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Student {
    private int id;
    private String name;
    private int age;
    
    @Id
    @GeneratedValue
    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;
    }
    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
    }
    public Student(int id, String name, int age) {
        super();
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public Student() {
        super();
    }
    
    
}

4.     写DAO接口

　　我们写一个StudentDao接口，其中有一个方法save(Student student)用于向数据库存储学生数据。

　　

package com.spring_hibernate.dao;
import com.spring_hibernate.model.Student;

public interface StudentDao {
        public void save(Student student);
}

5.     配置文件

在写Dao实现前，我们先把配置文件搞定，我们只需要写关于Spring的配置文件就可以，让Spring控制SessionFactory，在其中将Hibernate集成进去。建立一个beans.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:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/tx 
           http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
    <context:annotation-config />
    <context:component-scan base-package="com.spring_hibernate" />
    
    <!-- 用Properties文件读取数据库连接信息  -->
    <bean
        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <value>classpath:jdbc.properties</value>
        </property>
    </bean>
    
    <!-- 数据源定义  -->
    <bean id="dataSource" destroy-method="close"
        class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>

    <!-- 最重要的配置：SessionFactory的配置  这里是用注解的SessionFactory  -->
    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
        <!-- 注入数据源 -->
        <property name="dataSource" ref="dataSource" />
        <!-- 注入实体类 -->
        <property name="annotatedClasses">
            <list>
                <value>com.spring_hibernate.model.Student</value>
            </list>
        </property>
        <!-- 将Hibernate的配置信息集成进来 -->
        <property name="hibernateProperties">
            <props>
                <!-- 方言：这里是Mysql  -->
                <prop key="hibernate.dialect">
                    org.hibernate.dialect.MySQLDialect
                </prop>
                <!-- 是否显示sql语句  -->
                <prop key="hibernate.show_sql">true</prop>
                <!-- sql语句按规范显示 -->
                <prop key="hibernate.format_sql">true</prop>
                <!-- 自动对表的操作 -->
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
    </bean>
</beans>

6.     StudentDao的实现类

我们建立一个StudentDao的实现类StudentDaoImpl。因为在这里要进行对数据库操作的实现，所以要用到SessionFactory，我们将SessionFactory作为StudentDaoImpl的一个私有成员。然后实现StudentDao的save方法，用Hibernate的方式进行存储。这里要用到@Repository(Dao层)，@Resource(在setSessionFactory方法上用到，对SessionFactory进行注入)

package com.spring_hibernate.daoImpl;

import javax.annotation.Resource;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.stereotype.Repository;

import com.spring_hibernate.dao.StudentDao;
import com.spring_hibernate.model.Student;

@Repository
public class StudentDaoImpl implements StudentDao{
    private SessionFactory sessionFactory;

    public SessionFactory getSessionFactory() {
        return sessionFactory;
    }
    
    @Resource
    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    @Override
    public void save(Student student) {
        Session session = sessionFactory.openSession();
        session.beginTransaction();
        session.save(student);
        session.getTransaction().commit();
        session.close();
        System.out.println("saved!");
    }
}

7.     StudentService类

　　在StudentService中，将StudentDao作为私有成员。添加get/set方法。用到@Service(Service层) @Resource(自动注入studentDao的实现类)再添加一个add方法，调用StudentDao的save方法。

package com.spring_hibernate.service;

import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import com.spring_hibernate.dao.StudentDao;
import com.spring_hibernate.model.Student;

@Service
public class StudentService {
        private StudentDao studentDao;

        public StudentDao getStudentDao() {
            return studentDao;
        }
        @Resource
        public void setStudentDao(StudentDao studentDao) {
            this.studentDao = studentDao;
        }
    
        public void add(Student student){
            studentDao.save(student);
        }
}

8.     ServiceTest类

新建一个test源目录，书写ServiceTest类。

package com.spring_hibernate.test;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.spring_hibernate.model.Student;
import com.spring_hibernate.service.StudentService;

public class ServiceTest {
        @Test
        public void testService(){
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
StudentService service = (StudentService)ctx.getBean("studentService");
            service.add(new Student(0, "li", 20));
            ctx.destroy();
        }
}

如果我们用到了properties文件保存数据库连接信息，我们要在src下添加jdbc. properties。

如果我们要显示hibernate日志信息，log4j.properties也加在src目录下。

 

成功运行：

 

 

看一下数据库：表是自动创建的

成功添加数据！

 

请尊重劳动成果，转载请注明链接。