spring hibernate整合

最新推荐文章于 2024-07-20 20:04:43 发布

Rain1203

最新推荐文章于 2024-07-20 20:04:43 发布

阅读量344

点赞数 1

文章标签： spring hibernate 事务

本文链接：https://blog.csdn.net/u013929318/article/details/37905655

版权

spring为什么要整合hibernate?

原因一：如果单独使用hibernate就要创建session工厂，而这个工厂是轻量级的，创建很耗资源。而spring主要是以反射为基础的，写在配置文件里，在启动项目的时候直接创建，不必在真实连接数据库才创建，节省时间，资源。

spring hibernate整合步骤：

1）导入spring3.，hibernate4.的jar包

spring_aop:

aopalliance-1.0.jar

aspectjweaver-1.6.8.jar

spring_commons:

commons-logging-1.1.3.jar

spring_core:

spring-aop-3.2.5.RELEASE.jar

spring-aspects-3.2.5.RELEASE.jar

spring-beans-3.2.5.RELEASE.jar

spring-context-3.2.5.RELEASE.jar

spring-core-3.2.5.RELEASE.jar

spring-expression-3.2.5.RELEASE.jar

spring-jdbc-3.2.5.RELEASE.jar

spring-orm-3.25.RELEASE.jar

spring-tx-3.2.5.RELEASE.jar

mysql:

mysql-connector-java-5.1.22-bin.jar

hibernate_requierd:

antlr-2.7.7.jar

dom4j-1.6.1.jar

hibernate-commons-annotations-4.0.2.Final.jar

hibernate-core-4.2.12.Final.jar

hibernate-jpa-2.0-api-1.0.1.Final.jar

javassist-3.18.1-GA.jar

jboss-logging-3.1.0.GA.jar

jboss-transaction-api_1.1_spec-1.0.1.Final.jar

c3p0:

c3p0-0.9.5-pre6.jar

2)创建spring.xml主配置文件

2.1）配置数据源

2.2）配置sessionFactory

2.3）配置事物管理器

<?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: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.xsd

http://www.springframework.org/schema/tx

http://www.springframework.org/schema/tx/spring-tx.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop.xsd">

<bean id="c3p0DataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"

destroy-method="close">

<!-- JDBC标准参数，用来控制数据源内加载的PreparedStatement对象的数量但是由于缓存的statement是属于单个Connection的而不是整个连接池的，所以这项配置需要考虑多方面的因素

如果maxStatement和maxStatementPerConnection都为0，则缓存关闭，模式：0 -->

<!-- 对连接池的一种保护机制，当获取连接失败时会引起所有等待连接池来获取连接的线程抛出异常但是数据源仍然有效保留，并在下次调用getConnection时继续重新尝试获取连接

如果设置为true，那么在尝试获取连接失败后，该数据源将申明已断开并永久关闭；默认:false -->

</bean>

<props>

<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>

<prop key="hibernate.hbm2ddl.auto">create</prop>

<prop key="hibernate.current_session_context_class">org.springframework.orm.hibernate4.SpringSessionContext</prop>

</props>

</property>

<list>

<value>com/phome/model/User.hbm.xml</value>

</list>

</property>

</bean>

</bean>

<!--常见几张几种事务传播行为类型

PROPAGATION_REQUIRED 如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。

PROPAGATION_SUPPORTS 支持当前事务，如果当前没有事务，就以非事务方式执行。

PROPAGATION_MANDATORY 使用当前的事务，如果当前没有事务，就抛出异常。

PROPAGATION_REQUIRES_NEW 新建事务，如果当前存在事务，把当前事务挂起。

-->

<tx:advice id="txAdvice" transaction-manager="transactionManager">

<tx:attributes>

<tx:method name="save*" propagation="REQUIRED"/>

</tx:attributes>

</tx:advice>

<aop:config>

<aop:pointcut expression="execution(* com.phome.service.*.*(..))" id="testPointCut"/>

<aop:advisor advice-ref="txAdvice" pointcut-ref="testPointCut"/>

</aop:config>

</bean>

</bean>

</beans>

3）创建model下的实体类

package com.phome.model;

import java.util.Date;

/**

* @ClassName:User

* @Description:用户实体类

* @author.Rain

* @date 2014-7-17 上午11:06:12

public class User {

private long id;// 编号

private String username;// 账号

private String password;// 密码

private String email;// 邮箱

private String phone;// 电话

private int age;// 年龄

private Date birthday;// 生日

public long getId() {

return id;

}

public void setId(long id) {

this.id = id;

}

public String getUsername() {

return username;

}

public void setUsername(String username) {

this.username = username;

}

public String getPassword() {

return password;

}

public void setPassword(String password) {

this.password = password;

}

public String getEmail() {

return email;

}

public void setEmail(String email) {

this.email = email;

}

public String getPhone() {

return phone;

}

public void setPhone(String phone) {

this.phone = phone;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public Date getBirthday() {

return birthday;

}

public void setBirthday(Date birthday) {

this.birthday = birthday;

}

3.1）实体类的映射文件

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.phome.model">

</id>

</class>

</hibernate-mapping>

spring为什么要整合hibernate?

4）创建BaseDAO

package com.phome.dao;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

/**

* @ClassName:BaseDAO

* @Description:父类DAO

* @author.Rain

* @date 2014-7-17 上午11:13:16

public class BaseDAO {

private SessionFactory sessionFactory;

private Session session;

public SessionFactory getSessionFactory() {

return sessionFactory;

}

public void setSessionFactory(SessionFactory sessionFactory) {

this.sessionFactory = sessionFactory;

}

public Session getSession() {

return sessionFactory.getCurrentSession();

}

public void setSession(Session session) {

this.session = session;

}

5)创建普通DAO

package com.phome.dao;

import com.phome.model.User;

/**

* @ClassName:UserDAO

* @Description:DAO

* @author.Rain

* @date 2014-7-17 上午11:15:23

public class UserDAO extends BaseDAO{

public void add(User user){

getSession().save(user);

}

6)创建service，在spring.xml中的<aop:pointcut/>中配置事物

package com.phome.service;

import com.phome.dao.UserDAO;

import com.phome.model.User;

/**

* @ClassName:UserService

* @Description:服务层

* @author.Rain

* @date 2014-7-17 上午11:16:34

public class UserService {

private UserDAO userDAO;

public UserDAO getUserDAO() {

return userDAO;

}

public void setUserDAO(UserDAO userDAO) {

this.userDAO = userDAO;

}

public void save(User user){

userDAO.add(user);

}

Junit测试：

package com.phome.service;

/**

* Junit测试类

import org.junit.Test;

import org.springframework.beans.BeansException;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.phome.model.User;

public class UserServiceTest {

@Test

public void testSave() {

try {

ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

UserService us = (UserService) context.getBean("userService");

User user = new User();

us.save(user);

} catch (BeansException e) {

e.printStackTrace();

}

运行结果如下：

spring为什么要整合hibernate?

Rain1203

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
spring hibernate整合

spring为什么要整合hibernate? 原因一：如果单独使用hibernate就要创建session工厂，而这个工厂是轻量级的，创建很耗资源。而spring主要是以反射为基础的，写在配置文件里，在启动项目的时候直接创建，不必在真实连接数据库才创建，节省时间，资源。spring hibernate整合步骤： 1）导入spring3.*，hibernate4.
复制链接

扫一扫