Spring Boot 和 Hibernate 的简单整合

已于 2024-08-13 11:34:18 修改
阅读量1.1k 收藏 26
点赞数 16
文章标签： spring boot hibernate mysql
于 2024-08-12 22:02:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40718345/article/details/141133879
版权

1，引言

Hibernate是一个全自动的ORM框架。ORM框架通过其独特的优势，‌可以简化开发、‌提高可维护性、‌跨数据库支持和提高性能等。为开发者节约大量的时间（当您用过其它的持久层框架后，你会对这句话深有体会）。

Spring Data JPA是由Spring公司开发的JPA应用框架，用于整合市面上已有的ORM框架，它默认使用Hibernate，可见Hibernate仍然是一个强大且稳定的持久层解决方案。

  • 请事先准备一个可以访问的MySQL数据库，记录下访问连接，用户名，密码。

2，创建项目

创建一个名为hibernate-demo的项目，使用Maven+JDK17。不会的请看 IntelliJ IDEA快速创建Spring Boot项目
在这里插入图片描述

3，编写代码

3.1 整体结构

最终项目结构，如下图。
在这里插入图片描述

3.3 修改pom.xml

这里用的springboot3.x的版本，对应的MySQL驱动需要mysql-connector-j。修改完成后，更新maven，等待资源下载完成。
在这里插入图片描述

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>hibernate-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <!--  为Spring Boot项目提供一系列默认的配置和依赖管理-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.3.2</version>
        <relativePath/>
    </parent>

    <dependencies>
        <!--  Spring Boot核心依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!-- Spring Boot单元测试和集成测试的依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- Spring Boot构建Web应用程序的依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- Spring Boot使用Spring Data JPA的依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <!-- mysql驱动-->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
        </dependency>

    </dependencies>

</project>

3.4 在resources下创建application.properties文件

需要配置好自己的数据库连接，用户名，密码。
在这里插入图片描述

#数据库连接
spring.datasource.primary.jdbc-url=jdbc:mysql://localhost:3306/test1
#数据库用户名
spring.datasource.primary.username=您的数据库用户名
#数据库密码
spring.datasource.primary.password=您的数据库密码
#自动更新数据库
spring.jpa.properties.hibernate.hbm2ddl.auto=update
#显示sql
spring.jpa.show-sql=true
#在视图渲染过程中不执行数据库查询
spring.jpa.open-in-view=false

3.5 将Main类，修改为Spring Boot启动类

在这里插入图片描述

package org.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Main {

    public static void main(String[] args) {
        SpringApplication.run(Main.class, args);
    }

}

3.6 创建entity包和User类

User类就是实体类，和数据库中的表对应。
在这里插入图片描述

package org.example.entity;


import jakarta.persistence.*;

import java.io.Serializable;
import java.util.Date;

@Entity
@Table(name = "t_user")
public class User implements Serializable {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private Long createrId;

    private Date createTime;

    private Long modifierId;

    private Date modificationTime;

    private String name;

    private String phone;

    public User() {
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public Long getCreaterId() {
        return createrId;
    }

    public void setCreaterId(Long createrId) {
        this.createrId = createrId;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public Long getModifierId() {
        return modifierId;
    }

    public void setModifierId(Long modifierId) {
        this.modifierId = modifierId;
    }

    public Date getModificationTime() {
        return modificationTime;
    }

    public void setModificationTime(Date modificationTime) {
        this.modificationTime = modificationTime;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }
}

3.7 创建dao包和PrimaryDaoService类、PrimaryDaoServiceImpl类

dao包中的类就是数据库操作类，封装了数据库操作的方法。在这里插入图片描述

package org.example.dao;

import java.io.Serializable;
import java.util.List;
import java.util.Map;

public interface PrimaryDaoService {

	public <T> void save(T o);

	public <T> void delete(T o);

	public <T> void update(T o);

	public <T> T get(Class<T> c, Serializable id);

	public List<Map<String, Object>> getListBySql(String sql);

}


package org.example.dao;

import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import jakarta.persistence.Query;
import org.example.entity.User;
import org.hibernate.query.sql.internal.NativeQueryImpl;
import org.hibernate.transform.Transformers;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import java.io.Serializable;
import java.util.Date;
import java.util.List;
import java.util.Map;


@Repository
public class PrimaryDaoServiceImpl implements PrimaryDaoService {

    @PersistenceContext(unitName = "primaryEntityManager")
    private EntityManager entityManager;


    @Override
    public <T> void save(T o) {
        if (null != o) {
            if (o instanceof User) {
                User data = (User) o;
                data.setCreateTime(new Date());
                data.setModificationTime(new Date());
                data.setCreaterId(-1l);
                data.setModifierId(-1l);
            }
            entityManager.persist(o);
        }
    }

    @Override
    public <T> void delete(T o) {
        if (null != o) {
            entityManager.remove(o);
        }
    }

    @Override
    public <T> void update(T o) {
        if (null != o) {
            entityManager.merge(o);
        }
    }

    @Override
    public <T> T get(Class<T> c, Serializable id) {
        if (null != id) {
            return (T) entityManager.find(c, id);
        }
        return null;
    }

    @Transactional(readOnly = true)
    @Override
    public List<Map<String, Object>> getListBySql(String sql) {
        Query q = entityManager.createNativeQuery(sql);
        q.unwrap(NativeQueryImpl.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
        return q.getResultList();
    }


}

3.8 创建controller包和UserController类

UserController类用于测试，正常情况下还需要创建service层，在service层操作数据库，但是这里为了方便测试，就直接在controller层操作数据库。
注意@Transactional(value = “primaryTransactionManager”)是事务注解，增、删、改数据时，必须加这个注解才能成功。
在这里插入图片描述

package org.example.controller;

import org.example.dao.PrimaryDaoService;
import org.example.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;


@Controller
@RequestMapping("/UserController")
public class UserController {
    @Autowired
    protected PrimaryDaoService primaryDao;


    @RequestMapping(value = "/test")
    @ResponseBody
    @Transactional(value = "primaryTransactionManager")
    public Object test() throws Exception {
        User user = new User();
        user.setName("张三");
        user.setPhone("12345678901");
        primaryDao.save(user);
        return user;
    }


}

3.9 创建conf包和PrimaryDbConfig类

PrimaryDbConfig类用于配置JPA相关信息。
在这里插入图片描述

package org.example.conf;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;

/*
 *
 * 数据库配置
 *
 * basePackages：JPA扫描配置
 * entityManagerFactoryRef：实体扫描配置
 * transactionManagerRef：事务配置
 *
 * */
@Configuration
@EnableJpaRepositories(basePackages = "org.example.dao", entityManagerFactoryRef = "primaryEntityManager", transactionManagerRef = "primaryTransactionManager")
public class PrimaryDbConfig {

    private final Logger log = LoggerFactory.getLogger(getClass());

    private DataSource dataSource;

    private LocalContainerEntityManagerFactoryBean entityManager;

    /*
     * 创建数据库连接
     * @Primary 配置多个数据源时，用于标记主库
     * @ConfigurationProperties 指定配置文件中的属性前缀
     *
     * */
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    @Bean(name = "primaryDataSource")
    public DataSource primaryDataSource() {
        dataSource = DataSourceBuilder.create().build();
        log.info("正在连接数据库1...");
        return dataSource;
    }

    /*
     * 实体扫描配置
     *
     * 方法名与类注解中的entityManagerFactoryRef的值保持一致，配置多个数据源时方法名不能相同
     *
     * */
    @Bean
    @Primary
    LocalContainerEntityManagerFactoryBean primaryEntityManager(EntityManagerFactoryBuilder builder) {
        log.info("正在扫描接数据库1的实体类...");
        entityManager = builder.dataSource(dataSource).packages("org.example.entity")
                .persistenceUnit("primaryPersistenceUnit").build();
        return entityManager;
    }

    /*
     * 事务配置
     *
     * 方法名与类注解中的transactionManagerRef的值保持一致，配置多个数据源时方法名不能相同
     *
     * */
    @Bean
    @Primary
    PlatformTransactionManager primaryTransactionManager(EntityManagerFactoryBuilder builder) {
        log.info("正在配置接数据库1的事务管理器...");
        return new JpaTransactionManager(entityManager.getObject());
    }
}

4，运行代码

4.1 创建数据库

首先在使用您的数据库工具，在MySQL中创建一个数据库test1，与application.properties中的配置的数据库相对应。
在这里插入图片描述

4.2 启动项目

在Main上右键Run，启动项目。
在这里插入图片描述

4.3 Hibernate自动创建表

项目启动后，控制台可以看出，Hibernate自动创建了t_user表，这与User类的@Table注释内容一致。
在这里插入图片描述然后从数据库工具中，也可以看到test1库下已创建了t_user表。
在这里插入图片描述

4.4 测试新增数据

打开浏览器访问http://localhost:8080/UserController/test，可以看到页面上有一行数据，刚好和UserController类中的代码功能一致，同时控制台也打印出了insert语句，说明调用成功。
在这里插入图片描述
在这里插入图片描述

4.5 测试成功

打开数据库工具中，看到t_user表里面多了一条数据，表示数据新增成功。自此Spring Boot和Hibernate 简单整合完成。
在这里插入图片描述

D_J_Dragon
关注
spring-boot 集成hibernate
01-10
spring-boot 集成hibernate，使用druid数据库连接池,dao继承HibernateDaoSupport 的实现,
SpringBoot+Hibernate搭建项目
打造专业技术博客
02-18 973
近期整理了对象关系映射对象的知识点，其中就涉及到了Hibernate相关的知识及内容，在此记录一下，以免忘记！PS：虽然不一定能用的上，有备无患吧。1）打开开发工具，选择maven项目，默认使用下一步，设定项目名称直至完成。以上项目搭建完成，启动SpringBoot服务进行测试。访问接口，观察数据库中的数据库已经查出。
SpringBoot集成Hibernate
weixin_42029450的博客
01-05 6996
Hibernate是什么？ Hibernate与MyBatis都是流行的持久层开发框架，只不过Hibernate是全自动ORM框架，不需要关心sql编写。 Hibernate 是一个高性能的对象/关系映射（ORM）持久化存储和查询的服务，不仅负责从Java类到数据库表的映射 （还包括从Java数据类型到SQL数据类型的映射），还提供了面向对象的数据查询检索机制，从而极大地缩短了手动处理SQL和JDBC上的开发时间。 同时，Hibernate还实现了JPA规范，在SpringBoot中，JPA的默认实现就
一文教会你如何在SpringBoot项目里集成Hibernate
郝老三~~~~~~~~~~~~~
03-27 4307
Hibernate是一个流行的ORM（对象关系映射）框架，它可以将Java对象映射到数据库表，从而方便地进行持久化操作。在Spring Boot项目中，集成Hibernate可以帮助我们更轻松地进行数据库操作，本文将介绍如何在Spring Boot项目中集成Hibernate，并提供相应的示例。
hibernate在springboot中简单使用
weixin_41657954的博客
01-07 8621
hibernate在springboot中简单使用 文章目录hibernate在springboot中简单使用1.前言2.springboot中整合hibernate2.1导入hibernate依赖和连接数据库依赖2.3配置实体类（我全用的注解方式）2.4创建一个接口操作hibernate自带的方法2.5controller类 1.前言 我这里整理出的是不涉及多表查询等复杂的sql实现，只为hibernate简单上手使用 一般用了hibernate的人都多多少少接触了mybatis，这里我简单说一哈我对这两
SpringBoot整合Hibernate
热门推荐
忆晨的博客
03-22 1万+
Hibernate是什么？ Hibernate与MyBatis都是流行的持久层开发框架，只不过Hibernate是全自动ORM框架，不需要关心sql编写。 Hibernate 是一个高性能的对象/关系映射（ORM）持久化存储和查询的服务，不仅负责从Java类到数据库表的映射 （还包括从Java数据类型到SQL数据类型的映射），还提供了面向对象的数据查询检索机制，从而极大地缩短了手动处理SQL和JDBC上的开发时间。 同时，Hibernate还实现了JPA规范，在SpringBoot中，JPA的默认实现就是使
spring-boot-hibernate5整合源码
08-03
spring-boot-hibernate5 整合源码
Spring boot hibernate ehcache maven 整合源码
01-19
在Spring Boot的基础上，我们常常会整合其他技术，如Hibernate和Ehcache，来构建高效的数据存储和缓存解决方案。Maven作为Java项目的构建工具，负责管理项目的依赖关系。在这个源码包中，我们将探讨如何将这些组件...
spring-boot-jpa-hibernate：这是将Hibernate与Spring Boot应用程序集成的非常简单的指南
02-04
在整合Spring Boot和Hibernate时，我们首先需要在`pom.xml`文件中添加相关的Maven依赖。对于Spring Boot，我们需要`spring-boot-starter-web`和`spring-boot-starter-data-jpa`。对于Hibernate，依赖项可能包括`...
spring boot+hibernate+thymeleaf 练习demo项目源码
11-27
在本项目中，"spring boot+hibernate+thymeleaf 练习demo项目源码" 是一个基于Spring Boot框架、Hibernate ORM工具和Thymeleaf模板引擎的实践示例。这个小而精简的Demo旨在帮助学习者理解如何整合这三个核心技术来...
spring boot和mybatis整合
04-23
Spring Boot和MyBatis的整合是现代Java Web开发中常见的一种技术组合，它结合了Spring Boot的便捷性和MyBatis的灵活性，使得数据库操作变得更加简单。以下是对这个整合实例的详细解析： 首先，Spring Boot是Spring...
spring-boot基于hibernate实现简单分页
03-31
Spring Boot以其简洁的配置和快速的应用开发而受到广泛欢迎，而Hibernate作为Java领域中的一个强大的ORM（对象关系映射）工具，使得数据库操作变得更为简单。下面我们将详细介绍如何在Spring Boot项目中集成...
Spring Boot整合Spring Data JPA过程解析
08-25
Spring Boot整合Spring Data JPA过程解析 Spring Boot是一种流行的Java框架，用于构建基于Spring框架的Web应用程序。Spring Data JPA是Spring框架的一部分，提供了Java Persistence API（JPA）的实现，用于简化...
Spring3.0+Hibernate4.0+SpringMVC整合Ext
10-06
1、fes，这项目是整合后的项目，运行这个项目可以看到整合后的效果。 2、ext4，这个项目是用来做ext的公共js库用的，这样不比没个项目都添加ext的js文件，方便开发。 切记将ext4项目部署上去，并且应用名称为ext4，...
Spring Boot中的Hibernate是什么，如何使用
Java徐师兄的博客
07-07 1764
Hibernate是一个流行的Java ORM框架，它提供了一种将Java对象映射到关系数据库表的方法。Hibernate将Java对象与数据库表之间的映射称为对象关系映射（ORM）。Hibernate使用注解或XML配置来定义对象映射，可以轻松地将Java对象持久化到关系数据库中。对象关系映射：将Java对象映射到关系数据库表。事务管理：在事务中执行多个数据库操作。查询：使用Hibernate Query Language（HQL）或SQL来查询数据库。
【SpringBoot整合JPA框架（hibernate实现）详解】（附详细代码）
最新发布
qq_45759093的博客
02-20 3407
Java Persistence API（JPA）是Java EE和Java SE平台的一部分，提供了一种简单的对象关系映射（ORM）机制，用于将Java对象持久化到关系型数据库中。JPA通过注解或XML配置文件实现实体类与数据库表之间的映射，简化了数据库操作的过程。
hibernate入门，springboot整合hibernate
沐雨橙风ιε的博客
07-19 4963
Mybatis和Hibernate是我们常用的两大ORM框架，这篇文章主要介绍hibernate的使用，如何通过springboot整合hibernate，实现简单的crud功能。
spring boot jap 整合hibernate
04-30
在Spring Boot中使用Hibernate需要进行以下步骤： 1. 添加相关依赖 在`pom.xml`文件中添加以下依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <!-- H2 database --> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <scope>runtime</scope> </dependency> ``` 2. 配置数据源 在`application.properties`文件中配置数据源信息，例如： ```properties spring.datasource.url=jdbc:h2:mem:testdb spring.datasource.driverClassName=org.h2.Driver spring.datasource.username=sa spring.datasource.password= ``` 3. 创建实体类 创建对应的实体类，例如： ```java @Entity @Table(name = "users") public class User { @Id @GeneratedValue(strategy = GenerationType.AUTO) private Long id; @Column(name = "username") private String username; @Column(name = "password") private String password; // getter and setter methods } ``` 4. 创建数据访问对象（DAO） 创建对应的数据访问对象（DAO），例如： ```java @Repository public interface UserRepository extends JpaRepository<User, Long> { User findByUsername(String username); } ``` 5. 使用Hibernate进行数据操作 在需要使用Hibernate进行数据操作的地方，例如Service层中，注入对应的DAO对象，并使用相应的方法进行数据操作，例如： ```java @Service public class UserService { @Autowired private UserRepository userRepository; public User findByUsername(String username) { return userRepository.findByUsername(username); } public void save(User user) { userRepository.save(user); } } ``` 以上就是在Spring Boot中使用Hibernate整合JPA的基本步骤。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值