Hibernate与Sping框架的整合

已于 2022-04-24 20:26:25 修改
阅读量497 收藏 2
点赞数 2
分类专栏： Java后端 Spring全家桶 文章标签： 后端 spring hibernate sql mysql
于 2022-04-24 20:22:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50216991/article/details/124390913
版权

Hibernate与spring的整合与基本使用

1.创建一个maven项目Hibernate01，然后导入下面的依赖：

    <dependencies>
    <!--Spring Ioc相关依赖-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>5.3.18</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.18</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>5.3.18</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>5.3.18</version>
    </dependency>

    <!--Spring Aop的相关依赖-->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.8.RC2</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>5.3.18</version>
    </dependency>

    <!--Spring jdbc的相关依赖-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.3.18</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>5.3.18</version>
    </dependency>

    <!--spring orm的相关依赖-->
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-orm -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>5.3.18</version>
    </dependency>

    <!--单元测试用的依赖-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13</version>
        <scope>test</scope>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.3.18</version>
    </dependency>

    <!--日志依赖-->
    <!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>

    <!--Hibernate的核心依赖,9个必须要导入-->
    <!-- https://mvnrepository.com/artifact/antlr/antlr -->
    <dependency>
        <groupId>antlr</groupId>
        <artifactId>antlr</artifactId>
        <version>2.7.7</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.dom4j/dom4j -->
    <dependency>
        <groupId>org.dom4j</groupId>
        <artifactId>dom4j</artifactId>
        <version>2.1.3</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.apache.geronimo.specs/geronimo-jta_1.1_spec -->
    <dependency>
        <groupId>org.apache.geronimo.specs</groupId>
        <artifactId>geronimo-jta_1.1_spec</artifactId>
        <version>1.1.1</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.hibernate.common/hibernate-commons-annotations -->
    <dependency>
        <groupId>org.hibernate.common</groupId>
        <artifactId>hibernate-commons-annotations</artifactId>
        <version>5.1.2.Final</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>5.6.5.Final</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.hibernate.javax.persistence/hibernate-jpa-2.1-api -->
    <dependency>
        <groupId>org.hibernate.javax.persistence</groupId>
        <artifactId>hibernate-jpa-2.1-api</artifactId>
        <version>1.0.0.Final</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.jboss/jandex -->
    <dependency>
        <groupId>org.jboss</groupId>
        <artifactId>jandex</artifactId>
        <version>2.0.0.Final</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.javassist/javassist -->
    <dependency>
        <groupId>org.javassist</groupId>
        <artifactId>javassist</artifactId>
        <version>3.28.0-GA</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.jboss.logging/jboss-logging -->
    <dependency>
        <groupId>org.jboss.logging</groupId>
        <artifactId>jboss-logging</artifactId>
        <version>3.4.1.Final</version>
    </dependency>

    <!--mysql数据驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.25</version>
    </dependency>

    <!--连接池相关的依赖-->
    <dependency>
        <groupId>com.mchange</groupId>
        <artifactId>c3p0</artifactId>
        <version>0.9.5.5</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-c3p0 -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-c3p0</artifactId>
        <version>5.6.7.Final</version>
    </dependency>

    <dependency>
        <groupId>com.mchange</groupId>
        <artifactId>mchange-commons-java</artifactId>
        <version>0.2.19</version>
    </dependency>

</dependencies>

在resources目录下创建一个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"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

</beans>

2.然后在resources中创建一个jdbc.properties的jdbc配置文件：

jdbc.url=jdbc:mysql://localhost:3306/hibernate01
jdbc.driver.class=com.mysql.cj.jdbc.Driver
jdbc.username=root
jdbc.password=zc20020106

3.然后配置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"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--配置读取properties文件的工具类-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--配置c3p0数据库连接池-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="driverClass" value="${jdbc.driver.class}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!--配置Hibernate的SessionFactory-->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--hibernateProperties属性配置与Hibernate相关的内容-->
        <property name="hibernateProperties">
            <props>
                <!--显示当前执行的sql语句-->
                <prop key="hibernate.show_sql">true</prop>
                <!--开启正向工程，根据实体创建表的字段-->
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
        <!--扫描实体所在的包-->
        <property name="packagesToScan">
            <list>
                <value>com.haiexijun.pojo</value>
            </list>
        </property>
    </bean>

    <!--配置Hibernate的事务管理器-->
    <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>

    <!--开启注解事务处理-->
    <tx:annotation-driven transaction-manager="transactionManager"/>

    <!--配置springIOC的注解扫描-->
    <context:component-scan base-package="com.haiexijun"/>

</beans>

通过hibernate进行CRUD的操作

1.创建数据库

创建数据库就好了，不用创建表，后面Hibernate会根据编写的实体类来自动生成数据表

2.编写实体类Users

package com.haiexijun.pojo;

import javax.persistence.*;
import java.io.Serializable;

@Entity
@Table(name = "t_users")
public class Users  implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)//自增
    @Column(name = "userid")
    private Integer userId;
    @Column(name = "username")
    private String userName;
    @Column(name = "userage")
    private Integer userAge;

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public Integer getUserAge() {
        return userAge;
    }

    public void setUserAge(Integer userAge) {
        this.userAge = userAge;
    }
}

3.编写userDao接口与接口实现类

package com.haiexijun.dao;

import com.haiexijun.pojo.Users;

public interface userDao {
    void insertUsers(Users users);
    void updateUsers(Users users);
    void deleteUsers(Users users);
    Users selectUsersById(Integer userid);
}

修改配置文件，添加HibernateTemplate对象：

    <!--配置HibernateTemplate对象-->
    <bean id="HibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>

编写userDao的实现类

package com.haiexijun.dao.impl;

import com.haiexijun.dao.userDao;
import com.haiexijun.pojo.Users;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class userDaoImpl implements userDao {

    @Autowired
    private HibernateTemplate hibernateTemplate;

    @Override
    public void insertUsers(Users users) {
        hibernateTemplate.save(users);
    }

    @Override
    public void updateUsers(Users users) {
        hibernateTemplate.update(users);
    }

    @Override
    public void deleteUsers(Users users) {
        hibernateTemplate.delete(users);
    }

    @Override
    public Users selectUsersById(Integer userid) {
        return hibernateTemplate.get(Users.class,userid);
    }
}

4.编写测试类

package com.haiexijun.dao.impl;

import com.haiexijun.dao.userDao;
import com.haiexijun.pojo.Users;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class userDaoImpl implements userDao {

    @Autowired
    private HibernateTemplate hibernateTemplate;

    @Override
    public void insertUsers(Users users) {
        hibernateTemplate.save(users);
    }

    @Override
    public void updateUsers(Users users) {
        hibernateTemplate.update(users);
    }

    @Override
    public void deleteUsers(Users users) {
        hibernateTemplate.delete(users);
    }

    @Override
    public Users selectUsersById(Integer userid) {
        return hibernateTemplate.get(Users.class,userid);
    }
}

5.HQL查询
Hibernate语言查询( Hibernate Query Language，HQL) ：它是完全面向对象的查询语句，查询功能非常强大，具备继承、多态和关联等特性 。Hibernate官方推荐使用HQL进行查询。Hibernate查询语言（HQL）是面向对象的查询语言，其结构与SQL查询相似，不同的是，HQL查询的主体是持久化类而不是数据表。HQL提供了一种应用和数据库之间的抽象，提高了可移植性。HQL子句本身大小写无关，但是其中出现的类名和属性名必须注意大小写。

HQL的语法就是将原来sql语句中的表与字段名换成对象与属性的名称就可以了。

dao方法：

    @Override
    public List<Users> selectUserByAge(Integer age){
        // getCurrentSession方法返回的session，必须要有事务边界，名且只能处理唯一的一个事务。当前事务提交或者回滚后session自动失效
        // openSession方法：每次都会打开一个新的session，加入每次使用多次，则获得的是不同的session对象。使用完毕后我们要手动调用close方法关闭session
        Session session = hibernateTemplate.getSessionFactory().getCurrentSession();
        Query query=session.createQuery("from Users where userAge= :abc");
        Query queryTemp=query.setInteger("abc",age);
        return queryTemp.list();
    }

测试代码

    @Test
    @Transactional
    public void testSelectUserByAge(){
        List<Users> usersList= userDao.selectUserByAge(20);
        System.out.println(usersList);
    }

6.SQL查询

dao的方法

    @Override
    public List<Users> selectUserByAgeUseSQL(Integer age){
        Session session=hibernateTemplate.getSessionFactory().getCurrentSession();
        Query query=session.createSQLQuery("select * from t_users where userage =?").addEntity(Users.class).setInteger(0,age);
        return query.list();
    }

测试代码

    @Test
    @Transactional
    public void testSelectByAgeUseSQL(){
        List<Users> usersList=userDao.selectUserByAge(20);
        System.out.println(usersList);
    }

7.QBC查询
QBC是query by criteria的缩写。可以通过这个语法，彻底放弃掉sql语句。

dao代码：

    @Override
public List<Users> selectUserByAgeUseQBC(Integer age){
        Session session=hibernateTemplate.getSessionFactory().getCurrentSession();
        Criteria c=session.createCriteria(Users.class);
        c.add(Restrictions.eq("userAge",age));
        return c.list();
        }

测试代码：

    @Test
    @Transactional
    public void testSelectUserByAgeUseQBC(){
        List<Users> usersList=userDao.selectUserByAgeUseQBC(20);
        System.out.println(usersList);
    }

项目源代码GitHub地址：https://github.com/haiexijun/Hibernate01

害恶细君
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
最新版本的Struts2+Spring4+Hibernate4框架整合
10-15
整合使用最新版本的三大框架（即Struts2、Spring4和Hibernate4），搭建项目架构原型。 项目架构原型：Struts2.3.16 + Spring4.1.1 + Hibernate4.3.6。 此外，还有：log4j、slf4j、junit4、ehcache等知识点。 项目...
struts2、hibernate和spring框架整合所需的jar以及配置文档
10-22
3. **Spring** 相关的jar：包括`spring-context.jar`、`spring-beans.jar`、`spring-aop.jar`、`spring-jdbc.jar`、`spring-orm.jar`等，这些库文件是Spring框架的基础。 4. **其他依赖**：如`commons-logging.jar`...
Springframework和Hibernate版本对应关系
jingde528的博客
05-05 2138
Springframework和Hibernate版本对应关系，配置Hibernate4，Spring和Hibernate版本兼容问题
Hibernate 6 中文文档（二）（版本6.3.1.Final）
风间琉璃c
10-24 1239
文中相关链接需要科学上网方可访问，后续有时间再逐个翻译。文章中如果存在任何不准确的地方，欢迎指正。尚未完成，不断更新中....我们希望这一节可以很简短。不幸的是，有几种不同的方法可以配置和引导Hibernate，我们将至少需要详细描述其中两种。这里我们将重点放在前两个选项上。在容器中的Hibernate 实际上，最后一个选项非常受欢迎，因为每个主要的Java应用服务器和微服务框架都内置了对Hibernate的支持。
Spring与Hibernate整合
热门推荐
张晨光老师的播客
11-10 2万+
本章简介第1章、第2章中分别介绍了 Spring的控制反转和面向切面编程，我们了解了依赖注入的含义、依赖注入的方式、面向切面的编程以及4种通知。本章先介绍Spring与Hibernate整合的目的，然后采用对Emp表的CURD作为综合案例，介绍两大框架整合的步骤、关键整合点、整合之后如何操作数据库。最后采用Spring的声明式事务对Hibernate进行管理，增加程序的健壮性。核心技能部分第1章
spring整合hibernate
Dumb_Brother的博客
10-21 678
/ getCurrentSession:当前session必须要有事务边界(即查询也受事务控制)，且只能处理唯一的一个事务，当事提交或是回滚后session自动失效。//openSession：每次都回打开一个新的session，每次使用多次，获得的是不同的session的对象，使用完毕需手动调用close方法关闭session。create-drop:sessionFactory已关闭，删除之前的表，重新建立新表。
Spring 项目快速整合 Hibernate
大鹏的博客
07-20 2710
Hibernate 作为前些年广为流行的 ORM 框架，Spring 在诞生之初也进行了支持，并且抽象出一个 spring-orm 模块。这篇希望用简短的内容介绍如何在 Spring 项目中整合 Hibernate。
spring框架整合hibernate框架
SmallSweets的博客
04-24 1811
这里写自定义目录标题FLowchart流程图导出与导入导出 #mermaid-svg-93g1xwqrkHOtaT8h .label{font-family:'trebuchet ms', verdana, arial;font-family:var(--mermaid-font-family);fill:#333;color:#333}#mermaid-svg-93g1xwqrkHOtaT8h .label text{fill:#333}#mermaid-svg-93g1xwqrkHOtaT8h .nod
hibernate入门，springboot整合hibernate
沐雨橙风ιε的博客
07-19 3911
Mybatis和Hibernate是我们常用的两大ORM框架，这篇文章主要介绍hibernate的使用，如何通过springboot整合hibernate，实现简单的crud功能。
Struts2/Spring/Hibernate框架的整合与综合实例
pan_junbiao的博客
10-22 2812
1、框架介绍 1.1 Struts2框架 Struts是最早的Java开源框架之一，也是现在Java Web框架的事实标准。Struts是MVC设计模式一个优秀的实现。Struts定义了通用的Controller（控制器），通过配置文件（一般是struts-config.xml）隔离了Model（模型）和View（视图），以Action的概念对用户请求做了封装，使代码更清晰易读。到目前为止，S...
SSH 框架 —— Struts2 框架、Spring 框架、Hibernate 框架三大框架整合
Jsundoku的博客
03-07 1207
文章目录一、SSH 框架整合1、SSH 整合概述二、SSH 框架整合步骤1、在 WEB 项目中加载 Spring 框架2、使用 Spring 框架整合 Struts23、使用 Spring 框架整合 Hibernate4、使用 SpringAOP 实现声明式事务管理5、使用 OpenSessionInView 延迟加载后 session 的关闭问题 一、SSH 框架整合 1、SSH 整合概述 SS...
Spring+Struts2+Hibernate三大框架整合
西雅图奶奶
01-13 647
ssh三大框架整合首先要明白它的整体思想： 1. web应用的三层为：     1.1 web层，（struts2），Struts2框架用的最多的是action     1.2 service层（spring），spring中用的最多的是IoC和AOP，把对象的创建交给Spring进行管理     1.3 dao层（hibernate），hibernate则是用来操作数
Spring框架整合Spring MVC与Hibernate实现
07-23
Hibernate 是一个流行的 Java 对象关系映射（ORM）框架，它简化了数据库操作，通过将 Java 类与数据库表进行映射，允许开发者使用 Java 对象而不是 SQL 查询来处理数据。Hibernate 提供了缓存机制、事务管理、连接池...
hibernate与spring整合demo
11-23
二、Spring框架简介 Spring以其模块化的结构和强大的功能成为Java EE应用开发的首选框架。它提供了IOC（Inversion of Control，控制反转）和DI（Dependency Injection，依赖注入）机制，简化了对象的创建和管理。...
hibernate和spring整合Java项目
03-28
二、Spring框架详解 Spring是一个全面的企业级应用开发框架，核心特性包括依赖注入、面向切面编程（AOP）以及一系列的模块，如Spring MVC、Spring Data、Spring Security等。Spring的DI机制使得组件间的依赖关系得以...
45 前后端交互
qq_51415791的博客
07-23 328
读前思考：什么是前端？什么是后端？前端就是通过各种技术（下面会提到）将后端提供的数据以可视化的方式展示。后端就是通过各种技术将数据库的数据以API接口的形式封装，然后提供给前端使用。
实现一个全栈模糊搜索匹配的功能
最新发布
前端原创分享，常年坚持记录和分享，全网阅读量超百万
07-27 198
提供一个全栈实现的方案，包括 Vue 3 前端、Express 后端和 MySQL 数据库的分类模糊搜索功能。
nginx的配置和使用
AReallyMan的博客
07-23 482
server_name要监听的服务地址，可能是ip,也可能是域名，如果是ip则只有符合ip+端口才会被监听，如果是域名（域名已经指向了一个端口）则符合这个域名或者这个域名的一部分也会被监听，如果域名指向的端口和Listen的不一样则不监听。3、upstream tomcat_server这里是后台的服务地址，tomcat_server是自定义命名的服务名称，当location 配置了。2、在1条件满足下，会进入Location，可以对不同的url进行设置，比如完全匹配，前后缀匹配，部分匹配。
浅谈监听器之后端监听器
测试人，测试魂
07-24 716
JMeter的后端监听器为性能测试提供了强大的数据收集和分析能力，是进行大规模、复杂测试不可或缺的工具。通过合理的配置和使用，可以有效地管理和优化应用的性能测试流程，为软件的性能优化和监控提供坚实的基础。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

害恶细君

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值