扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 数据库 >Spring+JPA如何集成Hibernate
  • 216

0
分享到

Spring+JPA如何集成Hibernate

2024-04-02 19:04:59 216人浏览 八月长安
摘要

这篇文章主要介绍spring+JPA如何集成Hibernate，文中介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们一定要看完！1.JPA简介 Java Persistence api (JP

这篇文章主要介绍spring+JPA如何集成Hibernate，文中介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们一定要看完！

1.JPA简介

 Java Persistence api (JPA)，为开发人员提供了一种对象/关系映射(O-R Mapping)工具,用来管理 Java 应用中的关系数据。JPA是EJB3.0的一部分，现在公认为ORM行业标准。JPA本身只是一个规范，而不是产品; 它本身不能进行持续性或其他任何东西。JPA只是一组接口，需要一个实现。JPA允许通过标准的XML格式和注解格式声明，用于定义Java类如何映射到关系数据库表的映射规则。。JPA也定义了在对数据库中的对象处理查询和事务运行时的EntityManager的API。JPA定义一个对象级查询语言，JPQL，以允许从所述数据库中的对象的查询。JPA常用的解决方案：

    EclipseLink (Eclipse)
    Hibernate (RedHat)
    Open JPA (Apache)
    DataNucleus
    Ebean (SourceForge)
    TopLink Essentials (Glassfish)
    TopLink (oracle)
    Kodo (Oracle)
JPA 规范也不是一成不变的。从2006年的JPA1.0，到2009年JPA2.0，最后到2013年JPA2.1。版本之间的特性具体参照

https://en.wikibooks.org/wiki/Java_Persistence/What_is_JPA%3F

Https://en.wikipedia.org/wiki/Java_Persistence_API

2.Spring Hibernate JPA整合

准备

表
CREATE TABLE `Employee` (
  `id` int(11) unsigned NOT NULL,
  `name` varchar(20) DEFAULT NULL,
  `role` varchar(20) DEFAULT NULL,
  PRIMARY KEY (`id`)) ENGINE=InnoDB DEFAULT CHARSET=utf8;

2.1项目结构

Spring+JPA如何集成Hibernate

2.2 pom.xml

<?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.springframework</groupId>
    <artifactId>gs-relational-data-access</artifactId>
    <version>0.1.0</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>com.h3Database</groupId>
            <artifactId>h3</artifactId>
        </dependency>
        <dependency>
            <groupId>Mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

    <repositories>
        <repository>
            <id>spring-releases</id>
            <name>Spring Releases</name>
            <url>https://repo.spring.io/libs-release</url>
        </repository>
        <repository>
            <id>org.jboss.repository.releases</id>
            <name>JBoss Maven Release Repository</name>
            <url>https://repository.jboss.org/nexus/content/repositories/releases</url>
        </repository>
    </repositories>
    <pluginRepositories>
        <pluginRepository>
            <id>spring-releases</id>
            <name>Spring Releases</name>
            <url>https://repo.spring.io/libs-release</url>
        </pluginRepository>
    </pluginRepositories>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>io.spring.platform</groupId>
                <artifactId>platform-bom</artifactId>
                <version>1.1.2.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

使用了platform-bom，方便了包的依赖管理。

依赖树结构

Spring+JPA如何集成Hibernate

2.3 persistence.xml

<persistence version="2.1"
             xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
    <persistence-unit name="JPAExamples">
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
    </persistence-unit>
</persistence>

2.4 spring.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:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       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/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
      http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd">
<!--数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="url" value="jdbc:mysql://localhost:3306/exampledb"/>
        <property name="username" value="root"/>
        <property name="passWord" value="root"/>
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    </bean>
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="persistenceXmlLocation" value="META-INF/persistence.xml"/>
        <property name="persistenceUnitName" value="JPAExamples"/>
        <property name="jpaVendorAdapter" ref="jpaVendorAdapter"/>
        <property name="jpaDialect" ref="jpaDialect"/>
        <property name="jpaProperties">
            <props>
                <prop key="hibernate.show_sql">true</prop>
            </props>
        </property>
    </bean>

    <bean id="jpaVendorAdapter" class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
        <property name="generateDdl" value="false" />
        <property name="database" value="MYSQL"/>
    </bean>

    <bean id="jpaDialect" class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"/>

    <bean id="entityManager" factory-bean="entityManagerFactory"  factory-method="createEntityManager"></bean>
    <!-- Jpa 事务管理器  -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"
          p:entityManagerFactory-ref="entityManagerFactory" />
    <!-- 开启注解事务 -->
    <tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" />

    <!-- 启动对@AspectJ（面向切面）注解的支持 -->
    <aop:aspectj-autoproxy />

    <context:component-scan base-package="com.journaldev.spring.jpa"></context:component-scan>
</beans>

有的对象，不是必须的。为了保持完整性，做了保留。

可以配置entityManagerFactory的packagesToScan属性，没有配置也是可以的。

2.5 entity

package com.journaldev.spring.jpa.model;
import javax.persistence.Entity;
import javax.persistence.Id;
@Entity
public class Employee {
    @Id
    private int id;
    private String name;
    private String role;

    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 String getRole() {
        return role;
    }

    public void setRole(String role) {
        this.role = role;
    }

    @Override
    public String toString() {
        return "{ID=" + id + ",Name=" + name + ",Role=" + role + "}";
    }
}

2.6 接口

public interface EmployeeDAO {
    //Create
    public void save(Employee employee);
    //Read
    public Employee getById(int id);
    //Update
    public void update(Employee employee);
    //Delete
    public void deleteById(int id);
    //Get All
    public List<Employee> getAll();
}

实现类

package com.journaldev.spring.jpa.dao;

import com.journaldev.spring.jpa.model.Employee;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.transaction.Transactional;

import java.util.List;


@Transactional
@Repository
public class EmployeeDAOImpl implements EmployeeDAO {
    @PersistenceContext
    EntityManager em;


    @Override
    public void save(Employee employee) {
        em.persist(employee);
    }

    @Override
    public Employee getById(int id) {
        return em.find(Employee.class, id);
    }

    public void update(Employee employee) {  
        em.merge(employee);
    }

    @Override
    public void deleteById(int id) {
        em.remove(this.getById(id));
    }

    @Override
    public List<Employee> getAll() {
        CriteriaBuilder builder =em.getCriteriaBuilder();
        final CriteriaQuery<Employee> query = builder.createQuery(Employee.class);
        return this.em.createQuery(query).getResultList();
    }
}

2.7测试

测试类

import com.journaldev.spring.jpa.dao.EmployeeDAO;
import com.journaldev.spring.jpa.model.Employee;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.AbstractTransactionalJUnit4SprinGContextTests;
import org.springframework.test.context.junit4.SpringJUnit4Cla***unner;
import javax.annotation.Resource;

import java.util.Random;


@RunWith(SpringJUnit4Cla***unner.class)
@ContextConfiguration(locations = "classpath:spring.xml")
public class SpringJPATest extends AbstractTransactionalJUnit4SpringContextTests {

    @Resource
    private EmployeeDAO employeeDAO;

    @Test
    public void testSave(){
        Employee emp = new Employee();
        int rand = new Random().nextInt(1000);
        emp.setId(rand);
        emp.setName("Pankaj");
        emp.setRole("Java Developer");
        employeeDAO.save(emp);
    }
    @Test
    public void testUpdate(){
        Employee emp = new Employee();
        int rand = new Random().nextInt(1000);
        emp.setId(rand);
        emp.setName("Pankaj");
        emp.setRole("Java Developer");
        employeeDAO.save(emp);
        emp.setName(emp.getName()+"_update");
        employeeDAO.update(emp);
    }
}

OR

import com.journaldev.spring.jpa.dao.EmployeeDAO;
import com.journaldev.spring.jpa.model.Employee;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.Random;


public class Main {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml");
        final EmployeeDAO employeeDAO = ctx.getBean(EmployeeDAO.class);
        Employee emp = new Employee();
        int rand = new Random().nextInt(1000);
        emp.setId(rand);
        emp.setName("Pankaj");
        emp.setRole("Java Developer");
        employeeDAO.save(emp);

        Employee employee = employeeDAO.getById(rand);
        employee.setName(employee.getName() +"_update");
        employeeDAO.update(employee);
    }
}

有一点需要说明。默认使用的日志是logback.号称比log4j更优秀的一款。

默认的日志配置logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <layout class="ch.qos.logback.classic.PatternLayout">
            <Pattern>
                %d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n
            </Pattern>
        </layout>
    </appender>
    <logger name="org.hibernate" level="debug" additivity="false">
        <appender-ref ref="STDOUT" />
    </logger>

    <root level="error">
        <appender-ref ref="STDOUT" />
    </root>

</configuration>

以上是“Spring+JPA如何集成Hibernate”这篇文章的所有内容，感谢各位的阅读！希望分享的内容对大家有帮助，更多相关知识，欢迎关注编程网数据库频道！

您可能感兴趣的文档:

--结束END--

本文标题: Spring+JPA如何集成Hibernate

本文链接: https://lsjlt.com/news/67005.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • Spring+JPA如何集成Hibernate
    这篇文章主要介绍Spring+JPA如何集成Hibernate，文中介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们一定要看完！1.JPA简介 Java Persistence API (JP...
    99+
    2024-04-02
  • 基于spring boot 1.5.4 集成 jpa+hibernate+jdbcTemplate(详解)
    1.pom添加依赖<!-- spring data jpa,会注入tomcat jdbc pool/hibernate等 -->　　　　 <dependency> <groupId>org.sp...
    99+
    2023-05-31
    spring boot 集成
  • 如何进行spring hibernate的集成
    如何进行spring hibernate的集成，很多新手对此不是很清楚，为了帮助大家解决这个难题，下面小编将为大家详细讲解，有这方面需求的人可以来学习下，希望你能有所收获。Hibernate有很多值得学习的地方，这里主要介绍Spring H...
    99+
    2023-06-17
  • 如何在已有spring的基础上集成hibernate
    小编给大家分享一下如何在已有spring的基础上集成hibernate，希望大家阅读完这篇文章之后都有所收获，下面让我们一起去探讨吧！1.导入hibernate的包和spring的包hibernate3、hibernate-jpa-2.0-...
    99+
    2023-05-30
    spring hibernate
  • hibernate,jpa与spring data jpa之间有什么关系
    小编给大家分享一下hibernate,jpa与spring data jpa之间有什么关系，希望大家阅读完这篇文章之后都有所收获，下面让我们一起去探讨吧！文字说明HibernateHibernate是一个开放源代码的对象...
    99+
    2023-06-25
  • Spring整合JPA与Hibernate流程详解
    目录设置Spring的配置文件编写范例的Java类编写Customer实体类编写CustomerDao数据访问接口和类编写CustomerService业务逻辑服务接口和类编写测试类...
    99+
    2023-01-09
    Spring整合JPA Spring整合Hibernate
  • 详谈hibernate,jpa与spring data jpa三者之间的关系
    目录前提文字说明CRUD操作前提 其实很多框架都是对另一个框架的封装，我们在学习类似的框架的时候，难免会进入误区，所以我们就应该对其进行总结归纳，对比。本文就是对hibernate，...
    99+
    2024-04-02
  • springboot如何集成spring cache
    这篇文章给大家分享的是有关springboot如何集成spring cache的内容。小编觉得挺实用的，因此分享给大家做个参考，一起跟随小编过来看看吧。声明式缓存Spring 定义 CacheManager 和 Cache 接口用来统一不同...
    99+
    2023-06-19
  • spring如何集成redis cluster
    本篇内容介绍了“spring如何集成redis cluster”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！客户端采用最新的jedis 2....
    99+
    2023-05-30
    spring redis
  • Spring 4+ElasticSearch如何集成
    小编给大家分享一下Spring 4+ElasticSearch如何集成，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！一: ElasticSearch 基本概念IN...
    99+
    2023-06-04
  • spring boot如何集成redisson
    这篇文章主要介绍了spring boot如何集成redisson的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇spring boot如何集成redisson文章都会有所收获，下面我们一起来看...
    99+
    2023-07-04
  • Spring Boot + Jpa(Hibernate) 架构基本配置详解
    基于springboot-1.4.0.RELEASE版本测试springBoot + hibernate + Druid + MySQL + servlet(jsp)不废话，直接上代码一、maven的pom文件<?xml ve...
    99+
    2023-05-31
    spring boot jpa
  • Spring Web MVC和Hibernate集成配置的示例分析
    这篇文章主要介绍Spring Web MVC和Hibernate集成配置的示例分析，文中介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们一定要看完！添加项目依赖首先我们需要一个Java Web项目，最好使用Maven或Gradle构建工...
    99+
    2023-05-30
  • Springboot如何集成spring cache缓存
    这篇“Springboot如何集成spring cache缓存”文章的知识点大部分人都不太理解，所以小编给大家总结了以下内容，内容详细，步骤清晰，具有一定的借鉴价值，希望大家阅读完这篇文章能有所收获，下面我们一起来看看这篇“Spr...
    99+
    2023-06-30
  • SpringBoot项目里怎么集成Hibernate
    本篇内容介绍了“SpringBoot项目里怎么集成Hibernate”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！在Spring Boot项...
    99+
    2023-07-05
  • Spring Boot深入学习数据访问之Spring Data JPA与Hibernate的应用
    目录前言Spring Boot的支持前言 Hibernate是一个开源的对象关系映射框架，它对JDBC及进行了非常轻量级的对象封装，它将POJO简单的java对象与数据库表建立映射关...
    99+
    2022-11-13
    Spring Data JPA Spring Boot Hibernate
  • Struts+Hibernate+Spring如何组合使用
    这篇文章给大家分享的是有关Struts+Hibernate+Spring如何组合使用的内容。小编觉得挺实用的，因此分享给大家做个参考，一起跟随小编过来看看吧。其实对于S2SH的组合，其实注意几点就可以了：第一： 由于Struts2的Acti...
    99+
    2023-06-17
  • MyEclipse下Spring、Hibernate、Struts如何结合
    这篇文章给大家分享的是有关MyEclipse下Spring、Hibernate、Struts如何结合的内容。小编觉得挺实用的，因此分享给大家做个参考，一起跟随小编过来看看吧。数据库准备：数据库名称：AT_SMS表名称：admin字段如下：s...
    99+
    2023-06-03
  • spring cloud如何集成nacos配置中心
    目录spring cloud集成nacos配置中心一、添加依赖二、添加bootstrap.yml配置文件三、添加远程配置nacos作为SpringCloud配置中心一、背景介绍二、项...
    99+
    2024-04-02
  • LeetCode 算法题如何与 Java Spring 集成？
    LeetCode 算法题是许多程序员在面试和日常工作中经常遇到的问题。Java Spring 是一个流行的开源框架，用于构建企业级应用程序。将这两个技术集成起来，可以为开发人员提供更好的工作体验和更高效的解决方案。 本文将介绍如何将 Lee...
    99+
    2023-07-30
    spring 存储 leetcode
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作