AI 助理
备案控制台
开发者社区 数据库 文章 正文

Hibernate与Sping框架的整合

2022-11-22 102
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
RDS MySQL Serverless 基础系列，0.5-2RCU 50GB
推荐场景：
学生管理系统数据库设计 搭建个人博客
云数据库 RDS MySQL，集群系列 2核4GB
推荐场景：
搭建个人博客
RDS MySQL Serverless 高可用系列，价值2615元额度，1个月
简介： Hibernate与Sping框架的整合

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


文章标签：
云数据库 RDS MySQL 版
Java
SQL
Maven
数据库
数据库连接
关键词：
Hibernate框架
相关实践学习
如何快速连接云数据库RDS MySQL
本场景介绍如何通过阿里云数据管理服务DMS快速连接云数据库RDS MySQL，然后进行数据表的CRUD操作。
全面了解阿里云能为你做什么
阿里云在全球各地部署高效节能的绿色数据中心，利用清洁计算为万物互联的新世界提供源源不断的能源动力，目前开服的区域包括中国（华北、华东、华南、香港）、新加坡、美国（美东、美西）、欧洲、中东、澳大利亚、日本。目前阿里云的产品涵盖弹性计算、数据库、存储与CDN、分析与搜索、云通信、网络、管理与监控、应用服务、互联网中间件、移动服务、视频服务等。通过本课程，来了解阿里云能够为你的业务带来哪些帮助 &nbsp; &nbsp; 相关的阿里云产品：云服务器ECS 云服务器 ECS（Elastic Compute Service）是一种弹性可伸缩的计算服务，助您降低 IT 成本，提升运维效率，使您更专注于核心业务创新。产品详情: https://www.aliyun.com/product/ecs
害恶细君
目录
相关文章
学编程的小程
|
9月前
|
SQL 缓存 Java
框架分析（9）-Hibernate
框架分析（9）-Hibernate
学编程的小程
90 2
蓝易云
|
3月前
|
缓存 Java 数据库连接
Hibernate：Java持久层框架的高效应用
通过上述步骤，可以在Java项目中高效应用Hibernate框架，实现对关系数据库的透明持久化管理。Hibernate提供的强大功能和灵活配置，使得开发者能够专注于业务逻辑的实现，而不必过多关注底层数据库操作。
蓝易云
34 1
众所周知
|
6月前
|
SQL Java 数据库连接
Hibernate 是一款开源 ORM（对象关系映射）框架，封装了 JDBC，允许以面向对象的方式操作数据库，简化了数据访问层的开发。
Hibernate 是一款开源 ORM（对象关系映射）框架，封装了 JDBC，允许以面向对象的方式操作数据库，简化了数据访问层的开发。通过映射机制，它可以自动处理对象与数据库表之间的转换，支持主流数据库，提高了代码的可移植性和可维护性。其核心接口包括 SessionFactory、Session 和 Transaction 等，通过它们可以执行数据库的 CRUD 操作。配置方面，需在项目中引入 Hibernate 及数据库驱动依赖，并创建 `hibernate.cfg.xml` 配置文件来设置数据库连接和 Hibernate 行为参数。
众所周知
83 1
土木林森
|
6月前
|
数据库 Java 数据库连接
Struts 2 与 Hibernate 的完美邂逅：如何无缝集成两大框架，轻松玩转高效 CRUD 操作？
【8月更文挑战第31天】本文通过具体示例介绍了如何在 Struts 2 中整合 Hibernate，实现基本的 CRUD 操作。首先创建 Maven 项目并添加相关依赖，接着配置 Hibernate 并定义实体类及其映射文件。然后创建 DAO 接口及实现类处理数据库操作，再通过 Struts 2 的 Action 类处理用户请求。最后配置 `struts.xml` 文件并创建 JSP 页面展示用户列表及编辑表单。此示例展示了如何配置和使用这两个框架，使代码更加模块化和可维护。
土木林森
202 0
杰哥在此
|
7月前
|
SQL Java 数据库连接
Java面试题：简述ORM框架（如Hibernate、MyBatis）的工作原理及其优缺点。
Java面试题：简述ORM框架（如Hibernate、MyBatis）的工作原理及其优缺点。
杰哥在此
108 0
土木林森
|
8月前
|
Java 数据库连接 数据库
探索JPA生态：Hibernate与其他ORM框架的对比分析
【6月更文挑战第25天】**JPA标准下的Hibernate是流行的ORM实现，提供丰富功能如二级缓存和延迟加载，但其学习曲线较陡，性能优化复杂。相比如MyBatis，Hibernate的JPQL更面向对象，MyBatis则接近SQL。选择ORM需考虑项目需求和个人偏好。**
土木林森
112 0
杨校
|
8月前
|
Java 数据库连接
杨老师课堂之JavaEE三大框架Hibernate入门第一课
杨老师课堂之JavaEE三大框架Hibernate入门第一课
杨校
48 0
L&ecirc;v&iuml;
|
9月前
|
SQL Java 数据库连接
Java从入门到精通：3.1.2深入学习Java EE技术——Hibernate与MyBatis等ORM框架的掌握
Java从入门到精通：3.1.2深入学习Java EE技术——Hibernate与MyBatis等ORM框架的掌握
L&ecirc;v&iuml;
98 1
众所周知
|
9月前
|
SQL Java 关系型数据库
数据库访问：什么是Hibernate框架？
【4月更文挑战第15天】Hibernate是开源ORM框架，将Java对象与数据库表映射，简化对象-关系映射，提升开发效率和性能。它自动化处理数据操作，支持多种数据库，自动生成SQL，提供配置选项和高级特性，减少手动SQL编写，便于切换数据库。
众所周知
84 2
长梦
|
9月前
|
SQL 缓存 Java
Java一分钟之-Hibernate：ORM框架实践
【5月更文挑战第15天】Hibernate是Java的ORM框架，简化数据库操作。本文列举并解决了一些常见问题： 1. 配置SessionFactory，检查数据库连接和JDBC驱动。 2. 实体类需标记主键，属性映射应匹配数据库列。 3. 使用事务管理Session，记得关闭。 4. CRUD操作时注意对象状态和查询结果转换。 5. 使用正确HQL语法，防止SQL注入。 6. 根据需求配置缓存。 7. 懒加载需在事务内处理，避免`LazyInitializationException`。理解和避免这些问题能提升开发效率。
长梦
89 0

热门文章

最新文章

  • 1
    【Jpa hibernate】一对多@OneToMany，多对一@ManyToOne的使用
  • 2
    hibernate之关于多对一单向关联映射
  • 3
    使用Hibernate 过程中 报—— cannot simultaneously fetch multiple bags
  • 4
    一口一口吃掉Hibernate（七）——继承映射
  • 5
    中文命名之Hibernate 5演示 - 使用注解(annotation)而非xml定义映射
  • 6
    hibernate load与get方法的区别
  • 7
    hibernate错误：IllegalArgumentException以及Could not execute JDBC batch update
  • 8
    用Spring的mappingDirectoryLocations来配置Hibernate映射文件
  • 9
    【hibernate】 hibernate的主键策略
  • 10
    hibernate之关于一对多单向关联映射
  • 1
    Java一分钟之-Hibernate：ORM框架实践
    89
  • 2
    Java从入门到精通：3.1.2深入学习Java EE技术——Hibernate与MyBatis等ORM框架的掌握
    98
  • 3
    使用Hibernate-Validate进行参数校验
    93
  • 4
    hibernate注解实体类（Emp.java）
    79
  • 5
    Hibernate中使用Criteria查询及注解——（Emp.java）
    41
  • 6
    ssh(Spring+Spring mvc+hibernate)——Emp.java
    29
  • 7
    使用Hibernate JSP 303 整合到SSM项目
    58
  • 8
    Hibernate - 继承关联关系映射
    81
  • 9
    Hibernate - Session方法与持久化对象详解
    189
  • 10
    Hibernate或MyBatis：ORM映射、缓存机制等知识讲解梳理
    151

    • 相关课程

    更多
  • 5天实战Spring Boot 2.5
  • Spring Boot 2.5.x开发实战
  • SpringBoot快速掌握 - 核心技术
  • 5天突破Spring Cloud
  • SpringBoot快速掌握 - 高级应用

    • 相关电子书

    更多
  • Spring框架入门
  • Java Spring Boot开发实战系列课程【第15讲】：Spring Boot 2.0 API与Spring REST Docs实战
  • Java Spring Boot开发实战系列课程【第6讲】：Spring Boot 2.0实战MyBatis与优化(Java面试题)

    • 相关实验场景

    更多
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    PAI Model Gallery 支持云上一键部署 DeepSeek-V3、DeepSeek-R1 系列模型