JPA整合Hibernate快速入门

ORM概述

ORM(Object-Relational Mapping) 表示对象关系映射。在面向对象的软件开发中,通过ORM,就可以把对象映射到关系型数据库中。只要有一套程序能够做到建立对象与数据库的关联,操作对象就可以直接操作数据库数据,就可以说这套程序实现了ORM对象关系映射

简单的说:ORM就是建立实体类和数据库表之间的关系,从而达到操作实体类就相当于操作数据库表的目的。

为什么使用ORM

当实现一个应用程序时(不使用O/R Mapping),我们可能会写特别多数据访问层的代码,从数据库保存数据、修改数据、删除数据,而这些代码都是重复的。而使用ORM则会大大减少重复性代码。对象关系映射(Object Relational Mapping,简称ORM),主要实现程序对象到关系数据库数据的映射。

常见ORM框架

Mybatis、Mybatis-Plus、Hibernate、Jpa

 

JPA概述

JPA的全称是Java Persistence API, 即Java 持久化API,是SUN公司推出的一套基于ORM的规范,内部是由一系列的接口和抽象类构成。

JPA通过JDK 5.0注解描述对象-关系表的映射关系,并将运行期的实体对象持久化到数据库中。

JPA的优势

1. 标准化

   JPA 是 JCP 组织发布的 Java EE 标准之一,因此任何声称符合 JPA 标准的框架都遵循同样的架构,提供相同的访问API,这保证了基于JPA开发的企业应用能够经过少量的修改就能够在不同的JPA框架下运行。

2. 容器级特性的支持

   JPA框架中支持大数据集、事务、并发等容器级事务,这使得 JPA 超越了简单持久化框架的局限,在企业应用发挥更大的作用。

3. 简单方便

   JPA的主要目标之一就是提供更加简单的编程模型:在JPA框架下创建实体和创建Java 类一样简单,没有任何的约束和限制,只需要使用 javax.persistence.Entity进行注释,JPA的框架和接口也都非常简单,没有太多特别的规则和设计模式的要求,开发者可以很容易的掌握。JPA基于非侵入式原则设计,因此可以很容易的和其它框架或者容器集成

4. 查询能力

   JPA的查询语言是面向对象而非面向数据库的,它以面向对象的自然语法构造查询语句,可以看成是Hibernate HQL的等价物。JPA定义了独特的JPQL(Java Persistence Query Language),JPQL是EJB QL的一种扩展,它是针对实体的一种查询语言,操作对象是实体,而不是关系数据库的表,而且能够支持批量更新和修改、JOIN、GROUP BY、HAVING 等通常只有 SQL 才能够提供的高级查询特性,甚至还能够支持子查询。

5. 高级特性

   JPA 中能够支持面向对象的高级特性,如类之间的继承、多态和类之间的复杂关系,这样的支持能够让开发者最大限度的使用面向对象的模型设计企业应用,而不需要自行处理这些特性在关系数据库的持久化。

JPA与hibernate的关系

JPA规范本质上就是一种ORM规范,注意不是ORM框架——因为JPA并未提供ORM实现,它只是制订了一些规范,提供了一些编程的API接口,但具体实现则由服务厂商来提供实现。         

JPA快速入门

  1.   创建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>com.lzx.spring-jpa-hibernate</groupId>
    <artifactId>spring-jpa-hibernate</artifactId>
    <version>1.0-SNAPSHOT</version>



    <dependencies>

        <!-- junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!-- hibernate对jpa的支持包 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>5.0.7.Final</version>
        </dependency>

        <!-- c3p0 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
            <version>5.0.7.Final</version>
        </dependency>

        <!-- log日志 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

        <!-- Mysql and MariaDB -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
    </dependencies>



    
    <build>
        <plugins>
            <plugin>
               <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>utf-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>


</project>

  2.   创建数据库表和实体类,编写映射关系

package pojo;

import javax.persistence.*;
import java.util.Date;


/**
 *		* 所有的注解都是使用JPA的规范提供的注解,
 *		* 所以在导入注解包的时候,一定要导入javax.persistence下的
 */
@Entity    //声明实体类
@Table(name = "spider")   //对应数据库表名
public class Article {

    @Id     //声明当前属性为主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)   //主键策略
    @Column(name = "id")     //声明实体类属性和表字段关系
    private Integer id;

    @Column(name = "title")
    private String title;

    @Column(name = "content")
    private String content;

    @Column(name = "create_time")
    private Date createTime;

    @Column(name = "user")
    private String user;

    @Column(name = "read_count")
    private Integer readCount;


    @Override
    public String toString() {
        return "Article{" +
                "id=" + id +
                ", title='" + title + '\'' +
                ", content='" + content + '\'' +
                ", createTime=" + createTime +
                ", user='" + user + '\'' +
                ", readCount=" + readCount +
                '}';
    }

    public Date getCreateTime() {
        return createTime;
    }

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

    public Integer getReadCount() {
        return readCount;
    }

    public void setReadCount(Integer readCount) {
        this.readCount = readCount;
    }

    public Integer getId() {
        return id;
    }

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

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }




    public String getUser() {
        return user;
    }

    public void setUser(String user) {
        this.user = user;
    }




}

  3.   配置JPA的核心配置文件

        在java工程的src路径下创建一个名为META-INF的文件夹,在此文件夹下创建一个名为persistence.xml的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
    http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
             version="2.0">
    <!--配置持久化单元
        name:持久化单元名称
        transaction-type:事务类型
             RESOURCE_LOCAL:本地事务管理
             JTA:分布式事务管理 -->
    <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
        <!--配置JPA规范的服务提供商 -->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <properties>
            <!-- 数据库驱动 -->
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
            <!-- 数据库地址 -->
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/spider" />
            <!-- 数据库用户名 -->
            <property name="javax.persistence.jdbc.user" value="root" />
            <!-- 数据库密码 -->
            <property name="javax.persistence.jdbc.password" value="123" />

            <!--jpa提供者的可选配置:我们的JPA规范的提供者为hibernate,所以jpa的核心配置中兼容hibernate的配 -->
            <property name="hibernate.show_sql" value="true" />
            <property name="hibernate.format_sql" value="true" />
            <property name="hibernate.hbm2ddl.auto" value="create" />
        </properties>
    </persistence-unit>
</persistence>

  4.   测试JPA操作

  

import org.junit.Test;
import pojo.Article;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
import java.util.Date;

/**
 * JPA测试
 */

public class JPADemo {


    @Test
    public void test1(){

        /**
         * 创建实体管理类工厂,借助Persistence的静态方法获取
         * 		其中传递的参数为持久化单元名称,需要jpa配置文件中指定
         */
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
        //创建实体管理类
        EntityManager em = factory.createEntityManager();
        //获取事务对象
        EntityTransaction tx = em.getTransaction();
        //开启事物
        tx.begin();
        //-------------------------- 执行任务
        Article article = new Article();
        article.setContent("dadsadasda156151......");
        article.setCreateTime(new Date());
        article.setReadCount(0);
        article.setTitle("1");
        article.setUser("lzx");
        em.persist(article);
        //--------------------------  结束任务
        //提交事务
        tx.commit();
        //释放资源
        em.close();
        factory.close();
    }


}

 JPA的主键生成策略

通过annotation(注解)来映射hibernate实体的,基于annotation的hibernate主键标识为@Id, 其生成规则由@GeneratedValue设定的.这里的@id和@GeneratedValue都是JPA的标准用法。

JPA提供的四种标准用法为TABLE,SEQUENCE,IDENTITY,AUTO

具体说明如下:

IDENTITY:主键由数据库自动生成(主要是自动增长型)

SEQUENCE:根据底层数据库的序列来生成主键,条件是数据库支持序列。

AUTO:主键由程序控制

TABLE:使用一个特定的数据库表格来保存主键

JPA对象介绍

    Persistence对象

Persistence对象主要作用是用于获取EntityManagerFactory对象的 。通过调用该类的createEntityManagerFactory静态方法,根据配置文件中持久化单元名称创建EntityManagerFactory。

EntityManagerFactory

EntityManagerFactory 接口主要用来创建 EntityManager 实例

由于EntityManagerFactory 是一个线程安全的对象(即多个线程访问同一个EntityManagerFactory 对象不会有线程安全问题),并且EntityManagerFactory 的创建极其浪费资源,所以在使用JPA编程时,我们可以对EntityManagerFactory 的创建进行优化,只需要做到一个工程只存在一个EntityManagerFactory 即可

EntityManager

在 JPA 规范中, EntityManager是完成持久化操作的核心对象。实体类作为普通 java对象,只有在调用 EntityManager将其持久化后才会变成持久化对象。EntityManager对象在一组实体类与底层数据源之间进行 O/R 映射的管理。它可以用来管理和更新 Entity Bean, 根椐主键查找 Entity Bean, 还可以通过JPQL语句查询实体。

我们可以通过调用EntityManager的方法完成获取事务,以及持久化数据库的操作

方法说明:

   getTransaction : 获取事务对象

   persist : 保存操作

   merge : 更新操作

   remove : 删除操作

   find/getReference : 根据id查询

EntityTransaction

在 JPA 规范中, EntityTransaction是完成事务操作的核心对象,对于EntityTransaction在我们的java代码中承接的功能比较简单

方法:

begin:开启事务

commit:提交事务

rollback:回滚事务

JPA复杂方法

增:em.persist(Object o);

删:em.remove(Object o);

改:

    Articlec1 = em.find(Article.class, 6);

             c1.settitle("XXXXX");

         em.clear();     //c1对象从缓存中清除出去

             em.merge(c1);

查(根据ID查):em.find(Article.class, 1);  //实体类class和主键

复杂查询(SQL语句查询):

        查询全部:

             // 创建query对象

            String jpql = "from Article";

            Query query = em.createQuery(jpql);

            // 查询并得到返回结果

            List list = query.getResultList(); // 得到集合返回类型

        分页查询:

            //创建query对象

            String jpql = "from Article";

            Query query = em.createQuery(jpql);

            //起始索引

            query.setFirstResult(0);

            //每页显示条数

            query.setMaxResults(2);

            //查询并得到返回结果

            List list = query.getResultList(); //得到集合返回类型

        条件查询:

             //创建query对象

            String jpql = "from Article where title like ? ";

            Query query = em.createQuery(jpql);

            //对占位符赋值,从1开始

            query.setParameter(1, "大三%");

            //查询并得到返回结果

            Object object = query.getSingleResult(); //得到唯一的结果集对象

        排序查询:

                // 创建query对象

            String jpql = "from Article order by create_time desc";

            Query query = em.createQuery(jpql);

            // 查询并得到返回结果

            List list = query.getResultList(); // 得到集合返回类型

        统计查询:

            // 1.创建query对象

            String jpql = "select count(id) from Article";

            Query query = em.createQuery(jpql);

            // 2.查询并得到返回结果

            Object count = query.getSingleResult(); // 得到集合返回类型

  • 5
    点赞
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JPAJava Persistence API)和Hibernate是两种在Java平台上用于对象关系映射(ORM)的技术。 JPAJava EE规范中定义的一套ORM接口,它为开发人员提供了一种标准的方式来访问持久化数据。而Hibernate是一个实现了JPA规范的ORM框架,它提供了强大的对象关系映射功能以及其他与持久化相关的特性。 以下是JPAHibernate之间的一些区别: 1. 概念层面:JPA是一种规范,而Hibernate是实现该规范的一个框架。 2. 灵活性:JPA是一种标准化的接口,允许开发人员在不同的JPA实现之间进行切换。因此,使用JPA可以更容易地切换到其他ORM框架,而不仅仅局限于Hibernate。 3. 学习曲线:由于JPA是一个较为抽象的接口,学习和使用JPA可能需要更多时间和学习成本。相比之下,Hibernate提供了更具体和易于理解的API,并且有更多的文档和教程可供参考。 4. 生态系统:Hibernate是一个成熟且广泛使用的ORM框架,拥有强大的社区支持和丰富的生态系统。它提供了丰富的功能和性能优化选项。虽然JPA也有一些实现,但Hibernate被认为是JPA最常用和最流行的实现之一。 总结起来,JPAJava EE规范中定义的一套ORM接口,而Hibernate是一个实现了JPA规范的强大ORM框架。通过使用JPA,开发人员可以获得更高的灵活性和可移植性,而Hibernate则提供了更具体和易于使用的API以及丰富的功能。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值