Spring和Hibernate集成

最新推荐文章于 2018-12-14 15:33:04 发布
最新推荐文章于 2018-12-14 15:33:04 发布
阅读量416 收藏
点赞数
分类专栏： spring 文章标签： hibernate spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/changxinhua/article/details/44921199
版权
本文详细介绍了如何使用Spring和Hibernate进行集成实践，包括环境搭建、类结构设计、服务层实现、事务配置及测试代码编写，旨在为读者提供一份易于理解的教程，帮助其快速上手。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

第一次写博客，以前一直想写，由于自己文笔不好，一直没有尝试。前几天看了一篇文章，说写博文其实主要是给自己看，把所学所想留下来方便以后回顾，同时也给其他人些许帮助，于是下决心开始写。
这两天正在学spring，就把一些笔记放在这里，希望能给大家一些帮助。今天主要练习了spring和hibernate的继承，spring的其他知识以后有时间再来总结好了。
ps：纯属个人总结，为了以后看方便，可能会很啰嗦，各位切莫吐槽。

  1. 搭建环境
    （1）新建web工程
    （2）引入相关jar包
    spring相关jar包
    hibernate包有点多就不截图了
    注：aspectjrt.jar 和 aspectjweaver.jar是AOP相关包，原有spring2.5.6中的两个包貌似版本有问题，通过注解方式使用aop时没有效果，而通过xml配置文件使用aop时却有效果，搞了好久都不行，后来替换了这两个包才行。之后会上传到我的csdn上
    （3）程序结构
    这里写图片描述
    三个实体类：
    User.java
package com.turbo.entity;

public class User {
    private int id;
    private String name;
    private Role role;
    private Department department;
    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 Role getRole() {
        return role;
    }
    public void setRole(Role role) {
        this.role = role;
    }
    public Department getDepartment() {
        return department;
    }
    public void setDepartment(Department department) {
        this.department = department;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", name=" + name + ", role=" + role
                + ", department=" + department + "]";
    }


}

User.hbm.xml
这里写图片描述

Role.java

package com.turbo.entity;

public class Role {
    private int rid;
    private String rname;
    public int getRid() {
        return rid;
    }
    public void setRid(int rid) {
        this.rid = rid;
    }
    public String getRname() {
        return rname;
    }
    public void setRname(String rname) {
        this.rname = rname;
    }
    @Override
    public String toString() {
        return "Role [rid=" + rid + ", rname=" + rname + "]";
    }



}

Department.java

package com.turbo.entity;

public class Department {
    private int did;
    private String dname;
    public int getDid() {
        return did;
    }
    public void setDid(int did) {
        this.did = did;
    }
    public String getDname() {
        return dname;
    }
    public void setDname(String dname) {
        this.dname = dname;
    }
    @Override
    public String toString() {
        return "Department [did=" + did + ", dname=" + dname + "]";
    }


}

Service层：
接口代码就不往出给了
UserServiceImpl.java

package com.turbo.service.impl;

import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.turbo.dao.UserDao;
import com.turbo.entity.User;
import com.turbo.service.UserService;
@Service("userService")
public class UserServiceImpl implements UserService{
    @Resource(name="userDao")
    private UserDao userDao;
    public void addUser(User user) {
        // TODO Auto-generated method stub
        System.out.println("调用service保存user");
        userDao.addUser(user);

    }

    public void updateUser(User user) {
        // TODO Auto-generated method stub
        userDao.updateUser(user);
    }

    public User getUserById(int id) {
        // TODO Auto-generated method stub
        System.out.println("userService");
        return userDao.getUserById(id);
    }

    public void deleteUserById(int id) {
        // TODO Auto-generated method stub
        userDao.deleteUserById(id);
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }


}

Dao层：
同样不给接口代码了
UserDaoImpl.java

package com.turbo.dao.impl;

import java.util.Iterator;
import java.util.List;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.stereotype.Repository;

import com.turbo.dao.UserDao;
import com.turbo.entity.User;
public class UserDaoImpl extends HibernateDaoSupport implements UserDao{

    public void addUser(User user) {
        // TODO Auto-generated method stub
        this.getHibernateTemplate().save(user);
    }

    public void updateUser(User user) {
        // TODO Auto-generated method stub
        this.getHibernateTemplate().update(user);
    }

    public User getUserById(int id) {
        // TODO Auto-generated method stub
        String hql = "from User u where u.id="+id;
        List users = this.getHibernateTemplate().find(hql);
        User user = null;
        if(!users.isEmpty()){
            user = (User) users.get(0);
        }
        return user;
    }

    public void deleteUserById(int id) {
        // TODO Auto-generated method stub
        User user = getUserById(id);
        this.getHibernateTemplate().delete(user);
    }

}

全都以User为例

  1. 配置hibernate
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.url">jdbc:mysql://localhost/spring_hibernate_test</property>
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">111111</property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.current_session_context_class">thread</property>
        <!-- 
        <property name="hibernate.current_session_context_class">jta</property>
         -->        
        <mapping resource="com/turbo/entity/User.hbm.xml"/>
        <mapping resource="com/turbo/entity/Role.hbm.xml"/>
        <mapping resource="com/turbo/entity/Department.hbm.xml"/>
    </session-factory>
</hibernate-configuration>
  1. 配置事务

关键配置spring

<?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"
         xmlns:context="http://www.springframework.org/schema/context"
         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-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
           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd"
           >
    <aop:aspectj-autoproxy proxy-target-class="true"/>
    <context:annotation-config/>
    <context:component-scan base-package="com.turbo"/>
    <!-- 配置sessionFactory，将hibernate的配置文件引入，交给sessionFactory -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="configLocation">
            <value>classpath:hibernate.cfg.xml</value>
        </property>
    </bean>
    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory">
            <ref bean="sessionFactory"/>
        </property>
    </bean>

    <!-- 配置事务的传播特性 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="add*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="*" read-only="true"/>
        </tx:attributes>
    </tx:advice>

    <!-- 配置切点 -->
    <aop:config>
        <aop:pointcut expression="bean (*Service)" id="serviceMethod"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceMethod"/>
    </aop:config>


    <bean id="departmentDao" class="com.turbo.dao.impl.DepartmentDaoImpl">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
    <bean id="roleDao" class="com.turbo.dao.impl.RoleDaoImpl">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
    <bean id="userDao" class="com.turbo.dao.impl.UserDaoImpl">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
</beans>

4.写测试代码

package com.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.turbo.entity.Department;
import com.turbo.entity.Role;
import com.turbo.entity.User;
import com.turbo.service.DepartmentService;
import com.turbo.service.RoleService;
import com.turbo.service.UserService;

public class TestUser {
//  @Test
    public void testAdd(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext-bean.xml");
        UserService userService = (UserService) ctx.getBean("userService");
        DepartmentService departmentService = (DepartmentService) ctx.getBean("departmentService");
        RoleService roleService = (RoleService) ctx.getBean("roleService");

        Role role = roleService.getRoleByRid(1);
        Department department = departmentService.getDepartmentByDid(1);
        System.out.println("role:"+role);
        System.out.println(department);
        User user = new User();
        user.setDepartment(department);
        user.setRole(role);
        user.setName("张三");

        userService.addUser(user);

    }
    @Test
    public void testGet(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext-bean.xml");
        UserService userService = (UserService) ctx.getBean("userService");

        User user = userService.getUserById(1);

        System.out.println(user);
    }
}

当然，在测试之前要先建立数据库，建立相应的表

Spring 和 Hibernate的集成
交换一个思想，能得到俩思想
05-13 1万+
Spring对Hibernate的集成提供了很好的支持,Spring提供了对sessionfactory的初始化,用户不用再关心session的open,close,同时,Spring还提供了灵活的事务声明. 本文通过实例简单讲述如何在Spring中集成Hibernate. 1,将hibernate的配置加入到Spring的配置中(对datasource和sessionfactory进行配置)
Spring集成Hibernate
天之道居同文。
03-10 985
HibernateDaoSupport 包含HibernateTemplate 模板类，spring 对Hibernate再一次的封装， 使得代码可以更加简洁。声明式事务： 即在配置文件里，配置哪些方法是需要事务的。这些方法的事务的启动和提交，都交给 Spring 来处理。如果只是读取数据但不修改数据，可以设置read-only为true，对hibernate 可以有更好的优化。注意，dao的配置的parent 属性要设置成baseDao。业务操作可能是包含不同的dao的几个操作的。
Spring与Hibernate整合
11-26
Spring3.3与Hibernate2.1整合
spring与hibernate集成--关于配置文件的最优化使用
行云流水
04-26 7229
spring对hibernate整合的相当完美，并且spring对hibernate配置文件hibernate.cfg.xml也做了整合，在spring中利用LocalSessionFactoryBean就可以把hibernate.cfg.xml文件的内容整合到spring的配置文件中，这确实相当好，减少了配置文件。其实，LocalSessionFactoryBean最吸引我的原因是mappi
Spring 与 Hibernate 集成
王如霜
04-15 585
集成的好处 由IOC容器来管理Hibernate的SessionFactory 让Hibernate使用上Spring的声明式事务（就不用手动的开启，关闭事务了） 过程讲解 1.Hibernate对应的DAO层继承HibernateDaoSupport类，这个类属于Spring框架的，是Spring对Hibernate的集成，该类需要使用Spring向其注入sessionFactor...
Spring和Hibernate整合
quge_name_harder的博客
12-14 293
Spring与Hibernate整合关键点：         1） Hibernate的SessionFactory对象交给Spring创建；         2） hibernate事务交给spring的声明式事务管理。 整合步骤 1）引入jar包 （后面有提供的）         连接池/数据库驱动包         Hibernate相关jar         Spring 核心包(...
Spring与Hibernate集成
03-26
**Spring与Hibernate集成详解** 在Java企业级应用开发中，Spring和Hibernate是两个非常重要的框架。Spring是一个全方位的轻量级应用框架，提供了强大的依赖注入、AOP（面向切面编程）以及各种服务管理功能。而...
spring和hibernate集成Demo
01-15
这篇关于"Spring和Hibernate集成Demo"的内容将深入探讨这两者如何协同工作，以及如何构建一个集成的小型项目。 **Spring框架** Spring的核心是依赖注入（Dependency Injection，DI），它允许开发者通过配置文件或...
spring和hibernate集成后，通用的basedao
08-03
当Spring和Hibernate集成时，Spring可以管理Hibernate的SessionFactory和Session对象，避免了手动创建和关闭Session，减少了资源泄露的风险。Spring还提供了HibernateTemplate或JPA的EntityManagerFactory，进一步...
xfire跟spring和hibernate集成例子
05-19
将XFire、Spring和Hibernate集成，我们可以创建一个服务，该服务能够通过SOAP接口接收请求，然后利用Spring的管理能力调用Hibernate持久化操作来处理业务逻辑。以下是集成的步骤： 1. **配置Spring**：首先，我们...
spring和hibernate整合
12-06
在web.Xml中<context-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/spring/*.bean.xml</param-value> </context-param> <listener> <listener-class> org.springframework.web.context.ContextLoaderListener </listener-class> </listener> <listener> <listener-class>org.springframework.web.context.request.RequestContextListener</listener-class> </listener>
Spring与HIbernate整合
bighuan的博客
05-08 520
一,概述 1)Spring与Hibernate整合关键点:Hibernate的SessionFactory对象交给Spring创建;Hibernate事务交给Spring的声明式事务管理. 2)SH整合步骤: a)引入jar包 C3P0连接池/数据库驱动jar包 Hibernate相关jar包 Spring核心jar包 5个 Spring aop包 4个 Spring-orm-3.
spring和Hibernate整合
u011277123的博客
12-29 282
达人科技 2016-12-19 14:30 首先导入spring和Hibernate的jar包，以及JDBC和c3p0的jar包， 然后就是Hibernate的XML配置文件，不需要加入映射文件，这里用spring容器管理了。 Hibernate的XML文件 之后就是连接池的db.properpies文件。 之后就是包的定义，要实现spring和Hibernate的整合必
spring和hibernate的集成
小白说
10-05 546
spring:主jar，两个日志包，aop，cglib，juit包                spring可以替hibernate生成session工厂：         //先创建session工厂的代理对象                             classpath:hibernate.cfg.xml                        
spring 和hibernate的整合
mawujun1234的专栏
04-12 1410
      在当前的整合过程中，最常见的整合就是利用spring的HibernateTemplate或者是HibernateDaoSupport ，但是这都对底层的hibernater产生了侵入性，如果利用hibernate3的一个新的特性：“带上下文环境的Session”。 这与Spring中每个Hibernate的 Session 与事务同步的功能大致相同。即：sessionFactory.g
Spring与Hibernate的整合
热门推荐
morris
11-07 18万+
1. Spring与Hibernate的整合 1.1. 在Spring容器中创建SessionFactory 为了避免硬编码的资源查找与应用程序对象紧密耦合，Spring允许你在Spring容器中以bean的方式定义诸如JDBC DataSource或者Hibernate SessionFactory 的数据访问资源。任何需要进行资源访问的应用程序对象只需要持有这些事先定义好的实例的引用，下面
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值