JAP入门01-基础

最新推荐文章于 2021-03-02 14:12:28 发布

绿谷小初九

最新推荐文章于 2021-03-02 14:12:28 发布

阅读量4.5k

点赞数

分类专栏： JPA

本文链接：https://blog.csdn.net/qq_36974281/article/details/81530037

版权

JPA 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

什么是Jpa
创建JPA项目
JPA注解详解
使用Table策略来生成主键(不常用)
- 这种方法不常用，只有遇到特殊业务需求时才会用到。
- 如何使用Table策略生成主键
JAP相关接口/类
EntityManager方法详解

什么是Jpa

JDBC

jdbc是一组规范，是接口，由不同的数据库厂商各自提供相应的实现类，打包成jar包，也就是所谓的数据库驱动。而我们的java应用程序，只需要调用jdbc的接口就可以了。

而JPA是和jdbc类似的东西

什么是JPA

Java Persistence API：用于对象持久化的 API

Java EE 5.0 平台标准的 ORM 规范，使得应用程序以统一的方式访问持久层

与JDBC类似，JPA统一了java应用程序访问ORM框架的规范。

以前我们的应用程序直接使用ORM框架，如hibernate，mybatis。但是不同的框架使用方法不一样，而JPA让我们以同样的方式访问不同的ORM框架。常用的框架是hibernate。

JPA与Hibernate的关系

JPA是一个规范，不是框架

hibernate是JPA的实现

JPA的提供商

hibernate
JPA的始作俑者就是hibernate的作者
OpenJPA
TopLink

创建JPA项目

创建JPA工程

配置配置文件 persistence.xml

事先建好数据库

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0"
             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">

    <!--
            name: 属性用于定义持久化单元的名字必选
            transaction-type: 指定Jpa的事物处理策略
                              RESOURCE_LOCAL:默认值 本地事务
                              JTA: 分布式事务
    -->
    <persistence-unit name="jpa-1" transaction-type="RESOURCE_LOCAL">
        <!--
            配置使用什么 ORM 产品来作为 JPA 的实现
                1. 实际上配置的是  javax.persistence.spi.PersistenceProvider 接口的实现类
                2. 若 JPA 项目中只有一个 JPA 的实现产品, 则也可以不配置该节点.
        -->
        <provider>org.hibernate.ejb.HibernatePersistence</provider>

        <!-- 添加持久化类 -->
        <class>com.xiaoming.jpa.domain.Customer</class>

        <properties>
            <!-- 连接数据库的基本信息 -->
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql:///jpa"/>
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="root"/>


            <!-- 配置 JPA 实现产品的基本属性. 配置 hibernate 的基本属性(使用hibernate作为实现) -->
            <!--格式化sql-->
            <property name="hibernate.format_sql" value="true"/>
            <!--在控制台显示sql-->
            <property name="hibernate.show_sql" value="true"/>
            <!--生成数据表的策略-->
            <property name="hibernate.hbm2ddl.auto" value="update"/>

        </properties>


    </persistence-unit>
</persistence>

创建实体类

@Table(name = "customers") //对应的表名(默认是类名)
@Entity //表明这是实体类
public class Customer {

    private Integer id;
    private String lastName;
    private String email;
    private int age;
    private Date createdTime;
    private Date birth;

    //主键生成策略(一般默认就行)
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Id  //主键(用与get方法或者是属性)
    public Integer getId() {
        return id;
    }

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

    //该属性在数据库表中对应的字段名称(默认为变量名)
    @Column(name = "last_name")
    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

@Id , @Column， @GeneratedValue 这些注解既可以放在属性上，也可以放在get方法上，个人觉得放在get方法上比较好。如果放在属性上，后期我们要查看这个实体类有哪些字段时，会觉得很乱，不清晰。

在persistence.xml中加入实体类

    <!-- 添加持久化类 -->
<class>com.xiaoming.jpa.domain.Customer</class>

完整版的配置文件如下

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0"
             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">

    <!--
            name: 属性用于定义持久化单元的名字必选
            transaction-type: 指定Jpa的事物处理策略
                              RESOURCE_LOCAL:默认值 本地事务
                              JTA: 分布式事务
    -->
    <persistence-unit name="jpa-1" transaction-type="RESOURCE_LOCAL">
        <!--
            配置使用什么 ORM 产品来作为 JPA 的实现
                1. 实际上配置的是  javax.persistence.spi.PersistenceProvider 接口的实现类
                2. 若 JPA 项目中只有一个 JPA 的实现产品, 则也可以不配置该节点.
        -->
        <provider>org.hibernate.ejb.HibernatePersistence</provider>

        <!-- 添加持久化类 -->
        <class>com.xiaoming.jpa.domain.Customer</class>

        <properties>
            <!-- 连接数据库的基本信息 -->
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql:///jpa"/>
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="root"/>


            <!-- 配置 JPA 实现产品的基本属性. 配置 hibernate 的基本属性(使用hibernate作为实现) -->
            <!--格式化sql-->
            <property name="hibernate.format_sql" value="true"/>
            <!--在控制台显示sql-->
            <property name="hibernate.show_sql" value="true"/>
            <!--生成数据表的策略-->
            <property name="hibernate.hbm2ddl.auto" value="update"/>

        </properties>


    </persistence-unit>
</persistence>

测试

    /**
     * helloword
     */
    public void helloword() {
        //1.创建EntityManagerFactory
        String persistenceUnitName = "jpa-1";
        EntityManagerFactory entityManagerFactory =
                Persistence.createEntityManagerFactory(persistenceUnitName);

        //2.创建 EntityManager 相当于hibernate中的session
        EntityManager entityManager = entityManagerFactory.createEntityManager();

        //3.开启事物
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();

        //4.进行持久化操作
        Customer customer = new Customer();
        customer.setAge(18);
        customer.setEmail("1502906867@qq.com");
        customer.setLastName("晓明");
        //持久化
        entityManager.persist(customer);

        //5.提交事务
        transaction.commit();

        //6关闭 EntityManager
        entityManager.close();

        //7关闭 EntityManagerFactory
        entityManagerFactory.close();

    }

==注意==

String persistenceUnitName = “jpa”; 这个要和 persistence.xml 中的 
<persistence-unit name="jpa" transaction-type="RESOURCE_LOCAL"> 一致（可以修改）

JPA注解详解

Entity

@Entity 标注用于实体类声明语句之前，==指出该Java 类为实体类，将映射到指定的数据库表==。如声明一个实体类 Customer，它将映射到数据库中的 customer 表上。
不加table的话默认生成的表名=类名

Table

==当实体类与其映射的数据库表名不同名时==需要使用 @Table 标注说明，==该标注与 @Entity标注并列使用，置于实体类声明语句之前==，可写于单独语句行，也可与声明语句同行。
@Table 标注的常用选项是 ==name==，用于指明数据库的表名
@Table标注还有一个两个选项 catalog 和 schema
用于设置表所属的数据库目录或模式，通常为数据库名。uniqueConstraints 选项用于设置约束条件，通常不须设置。

Id

@Id 标注用于声明一个实体类的属性映射为数据库的==主键列==。该属性通常置于属性声明语句之前，可与声明语句同行，也可写在单独行上。
@Id标注也可置于属性的==getter方法之前==。

GeneratedValue

==@GeneratedValue 用于标注主键的生成策略，通过 strategy 属性指定。默认情况下，JPA 自动选择一个最适合底层数据库的主键生成策略：SqlServer 对应 identity，MySQL 对应 auto increment。==
在 javax.persistence.GenerationType 中定义了以下几种可供选择的策略：
- IDENTITY：采用数据库 ID自增长的方式来自增主键字段，Oracle 不支持这种方式；
- ==AUTO： JPA自动选择合适的策略，是默认选项；==
- SEQUENCE：通过序列产生主键，通过 @SequenceGenerator 注解指定序列名，mysql不支持这种方式
- TABLE：通过表产生主键，框架借由表模拟序列产生主键，使用该策略可以使应用更易于数据库移植。

Basic

@Basic 表示一个简单的属性到数据库表的字段的映射,==对于没有任何标注的getXxxx() 方法,默认即为@Basic==
fetch: 表示该属性的读取策略,有 EAGER 和 LAZY 两种,分别表示主支抓取和延迟加载,默认为 EAGER.
optional:表示该属性是否允许为null, 默认为true
再重申一遍,不加注解的默认使用的是@Basic的

Column

==当实体的属性与其映射的数据库表的列不同名时需要使用@Column标注说明==，该属性通常置于实体的属性声明语句之前，还可与 @Id 标注一起使用。
@Column 标注的常用属性是==name==，用于设置映射数据库表的列名。此外，该标注还包含其它多个属性，如：==unique== 、==nullable==、==length== 等。
@Column 标注的 ==columnDefinition属性:表示该字段在数据库中的实际类型==.通常 ORM 框架可以根据属性类型自动判断数据库中字段的类型,但是对于Date类型仍无法确定数据库中字段类型究竟是DATE,TIME还是TIMESTAMP.此外,String的默认映射类型为VARCHAR, 如果要将 String 类型映射到特定数据库的 BLOB 或TEXT 字段类型.
@Column标注也可置于属性的getter方法之前

Transient

表示该属性并非一个到数据库表的字段的映射,==ORM框架将忽略该属性.==
如果一个属性并非数据库表的字段映射,就务必将其标示为@Transient,否则,ORM框架默认其注解为@Basic

Temporal

在核心的 Java API 中并没有定义Date类型的精度(temporalprecision).而在数据库中,表示 Date 类型的数据有 DATE, TIME, 和 TIMESTAMP 三种精度(即单纯的日期,时间,或者两者兼备). 在进行属性映射时可使用==@Temporal注解来调整时间类型的精度.==

使用Table策略来生成主键(不常用)

这种方法不常用，只有遇到特殊业务需求时才会用到。

如何使用Table策略生成主键

使用这种策略，需要创建一张表

表名：ID_GENERATOR

字段名	说明
ID	本条记录的ID
PK_NAME	主键名
PK_VALUE	主键值

看到这里，肯定会不明所以。后面会慢慢解释

往这张表里面插几条数据

ID	PK_NAME	PK_VALUE
1	CUSTOMER_ID	1
2	STUDENT_ID	10
3	ORDER_ID	100

PK_NAME 中，CUSTOMER_ID 表示为CUSTOMER这张表生成ID，它的值为PK_VALUE=1，这个值并不代表CUSTOMER的ID就是1，而是通过一种算法来自动生成ID，而这个算法跟这个PK_VALUE有关。

相同的，STUDENT_ID表示为STUDENT表生成ID，值为10

那么JPA怎么知道要根据这张表来为其他三张表生成ID呢？

根据横纵坐标来定位到PK_VALUE

使用注解来告诉JPA横纵坐标

@Table(name="T_ORDER")
@Entity
public class Order {

    @Column(name="ID")
    @TableGenerator(name="ID_GENERATOR",  //生成器名称
                    table="ID_GENERATOR", //生成器使用的表
                    pkColumnName="PK_NAME", //表中对应的字段名
                    pkColumnValue="ORDER_ID", //上述字段的值
                    valueColumnName="PK_VALUE", //值 
                    //根据上述三个属性，就可以定位到表中的PK_VALUE的值，如：1，10，100
                    allocationSize=10)//表示主键一次增加10
    @GeneratedValue(strategy=GenerationType.TABLE,
                    generator="ID_GENERATOR")//这里的生成器和上面的生成器名称对应
    @Id
    private Integer id;

    @Column(name="ORDER_NAME")
    private String orderName;

    @JoinColumn(name="USER_ID")
    @ManyToOne
    private User user;


    public Integer getId() {
        return id;
    }

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

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    public User getUser() {
        return user;
    }

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

    @Override
    public String toString() {
        return "Order [id=" + id + ", orderName=" + orderName + ", user="
                + user + "]";
    }

}

每次ORDER表增加的记录，主键增加10，如此同时，ID_GENERATOR这张表中，对应的PK_VALUE的值会增加1。但是这个值我们不需要去理会。

到了这一步，就全部完成

JAP相关接口/类

Persistence

Persistence类是用于获取 EntityManagerFactory 实例。该类包含一个名为 createEntityManagerFactory的静态方法
createEntityManagerFactory 方法有如下两个重载版本
- 带有一个参数的方法以配置文件persistence.xml中的持久化单元名为参数
- 带有两个参数的方法：前一个参数含义相同，后一个参数 Map类型，用于设置 JPA 的相关属性，这时将忽略其它地方设置的属性。Map 对象的属性名必须是 JPA 实现库提供商的名字空间约定的属性名。

EntityManagerFactory

EntityManagerFactory接口主要用来创建EntityManager实例。该接口约定了如下4个方法：
- ==createEntityManager()==：用于创建实体管理器对象实例
- createEntityManager(Map map)：用于创建实体管理器对象实例的重载方法，Map 参数用于提供 EntityManager 的属性。
- isOpen()：检查 EntityManagerFactory 是否处于打开状态。实体管理器工厂创建后一直处于打开状态，除非调用close()方法将其关闭。
- ==close()==：关闭 EntityManagerFactory 。 EntityManagerFactory 关闭后将释放所有资源，isOpen()方法测试将返回 false，其它方法将不能调用，否则将导致IllegalStateException异常。

EntityManager(重要)

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

实体的状态:
- 新建状态: 新创建的对象，尚未拥有持久性主键。
- 持久化状态：已经拥有持久性主键并和持久化建立了上下文环境
- 游离状态：拥有持久化主键，但是没有与持久化建立上下文环境
- 删除状态: 拥有持久化主键，已经和持久化建立上下文环境，但是从数据库中删除。

EntityTransaction

EntityTransaction 接口用来管理资源层实体管理器的事务操作。通过调用实体管理器的getTransaction方法获得其实例。

begin ()
- 用于启动一个事务，此后的多个数据库操作将作为整体被提交或撤消。若这时事务已启动则会抛出 IllegalStateException 异常。
commit ()
- 用于提交当前事务。即将事务启动以后的所有数据库更新操作持久化至数据库中。
rollback ()
- 撤消(回滚)当前事务。即撤消事务启动后的所有数据库更新操作，从而不对数据库产生影响。
setRollbackOnly ()
- 使当前事务只能被撤消。
getRollbackOnly ()
- 查看当前事务是否设置了只能撤消标志。
isActive ()
- 查看当前事务是否是活动的。如果返回true则不能调用begin方法，否则将抛出 IllegalStateException 异常；如果返回 false 则不能调用 commit、rollback、setRollbackOnly 及 getRollbackOnly 方法，否则将抛出 IllegalStateException 异常。

EntityManager方法详解

find()

find (Class entityClass,Object primaryKey)

返回指定的OID对应的实体对象,如果这个实体存在于当前的持久化环境(缓存中存在)则返回被缓存的对象,否则会创建一个新的Entity,并加载数据库中的相关信息,

若OID不存在于数据库中,则返回一个null

jpa中的find方法类似于hibernate中的get方法

getReference()

getReference (Class entityClass,Object primaryKey)

跟find方法类似,不同的是:如果缓存中不存在指定的Entity,EntytiManager对象会创建一个Entity的代理对象,但是不会立即加载数据库中的信息,只有第一次真正使用此Entity属性的时候才会加载,所以如果此OID在数据库中不存在,该方法不会返回null,而是直接抛出异常 EntityNotFoundException

类似于hibernate中的load方法

persist()

persist (Object entity)

将传入的Entity对象转换成持久态(纳入管理)
- 如果传入persist()方法的Entity对象已经处于持久化状态,则persist()方法什么也不做
- 如果对删除状态(已经纳入管理但是从数据库中删除了)的Entity进行persist()操作,会转为持久态
- 如果对游离态的实体执行persist()操作,可能会在persist()方法抛出PersistentObjectException(即要持久化的对象不能有id,否则会报错)

remove()

remove (Object entity)：删除实例
如果实例是被管理的,则同时会删除数据库中的记录

虽然跟hibernate的delete方法很像但是又有些不同
- remove()方法不能移除游离态的对象,只能移除持久化的对象


<!--会抛异常-->
Order order = new Order();
order.setId(140);
entityManager.remove(order);

<!--必须这样写-->
Order order = new Order();
order = entityManager.find(Order.class, 140);
entityManager.remove(order);

而hibernate都可以移除(只要对象有id)

<!--这样也可以删除数据库中的信息-->
Customer customer = new Customer();
customer.setCust_id(1l);

session.delete(customer);

merge()

merge (T entity)：

merge() 用于处理Entity的同步。即数据库的插入和更新操作

类似于hibernater中的saveOrUpdate方法

传入的对象是临时对象(没有id)

    public void testMerge1(){
        Customer customer = new Customer();
        customer.setAge(18);
        customer.setBirth(new Date());
        customer.setCreatedTime(new Date());
        customer.setEmail("cc@163.com");
        customer.setLastName("CC");

        Customer customer2 = entityManager.merge(customer);

        //自己创建的customer对象id为 null
        System.out.println("customer#id:" + customer.getId());
        //返回的customer对象有 id
        System.out.println("customer2#id:" + customer2.getId());
    }

==若传入的是一个临时对象会创建一个新的对象,把临时对象的属性复制到新的对象中, 然后对新的对象执行持久化操作.所以新的对象中有id,但以前的临时对象中没有 id==

传入一个游离对象1

    //若传入的是一个游离对象, 即传入的对象有 OID.
    //1. 若在 EntityManager 缓存中没有该对象
    //2. 若在数据库中也没有对应的记录
    //3. JPA 会创建一个新的对象, 然后把当前游离对象的属性复制到新创建的对象中
    //4. 对新创建的对象执行 insert 操作.
    @Test
    public void testMerge2(){
        Customer customer = new Customer();
        customer.setAge(18);
        customer.setBirth(new Date());
        customer.setCreatedTime(new Date());
        customer.setEmail("dd@163.com");
        customer.setLastName("DD");

        customer.setId(100);

        Customer customer2 = entityManager.merge(customer);

        //id=100
        System.out.println("customer#id:" + customer.getId());
        //id=原先数据库中的值+1
        System.out.println("customer2#id:" + customer2.getId());
    }

传入一个游离对象2

    //若传入的是一个游离对象, 即传入的对象有 OID. 
    //1. 若在 EntityManager 缓存中没有该对象
    //2. 若在数据库中也有对应的记录
    //3. JPA 会查询对应的记录, 然后返回该记录对一个的对象, 再然后会把游离对象的属性复制到查询到的对象中.
    //4. 对查询到的对象执行 update 操作. 
    @Test
    public void testMerge3(){
        Customer customer = new Customer();
        customer.setAge(18);
        customer.setBirth(new Date());
        customer.setCreatedTime(new Date());
        customer.setEmail("ee@163.com");
        customer.setLastName("EE");

        customer.setId(4);

        Customer customer2 = entityManager.merge(customer);

        System.out.println(customer == customer2); //false
    }

传入一个游离对象3

    //若传入的是一个游离对象, 即传入的对象有 OID. 
    //1. 若在 EntityManager 缓存中有对应的对象
    //2. JPA 会把游离对象的属性复制到查询到EntityManager 缓存中的对象中.
    //3. EntityManager 缓存中的对象执行 UPDATE. 
    @Test
    public void testMerge4(){
        Customer customer = new Customer();
        customer.setAge(18);
        customer.setBirth(new Date());
        customer.setCreatedTime(new Date());
        customer.setEmail("dd@163.com");
        customer.setLastName("DD");

        customer.setId(4);
        Customer customer2 = entityManager.find(Customer.class, 4);

        entityManager.merge(customer);

        System.out.println(customer == customer2); //false
    }

flush

同步持久上下文环境，即将持久上下文环境的所有未保存实体的状态信息保存到数据库中。(==会在事务未提交之前强制发送Sql,在事务提交之后数据库中的信息才会更新==)

不适用flush()方法,hibernate会在事务提交的时候刷新缓存执行Sql

其他方法

refresh

refresh (Object entity)

用数据库实体记录的值更新实体对象的状态，即更新实例的属性值。

Order order= entityManager.find(Order.class, 170);
order= entityManager.find(Order.class, 170);

运行以上代码，发现调用了两次find，但是只执行了一次select语句，这是缓存导致的

再看下面的代码：

Order order= entityManager.find(Order.class, 170);
entityManager.refresh(order);

只调用了一次find方法，却执行了两次select语句，这是因为refresh方法会去查看缓存中的数据状态和数据库中是否一致，因此又执行了一次select语句

clear ()

清除持久上下文环境，断开所有关联的实体。如果这时还有未提交的更新则会被撤消。

contains (Object entity)：

判断一个实例是否属于当前持久上下文环境管理的实体。

isOpen ()

判断当前的实体管理器是否是打开状态。

getTransaction ()

返回资源层的事务对象。EntityTransaction实例可以用于开始和提交多个事务。

close ()

关闭实体管理器。之后若调用实体管理器实例的方法或其派生的查询对象的方法都将抛出 IllegalstateException 异常，除了getTransaction 和 isOpen方法(返回 false)。不过，当与实体管理器关联的事务处于活动状态时，调用 close 方法后持久上下文将仍处于被管理状态，直到事务完成。

createQuery (String qlString)

创建一个查询对象。

createNamedQuery (String name)

根据命名的查询语句块创建查询对象。参数为命名的查询语句。

createNativeQuery (String sqlString)

使用标准 SQL语句创建查询对象。参数为标准SQL语句字符串。

createNativeQuery (String sqls, String resultSetMapping)

使用标准SQL语句创建查询对象，并指定返回结果集 Map的名称。

绿谷小初九

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
JAP入门01-基础

什么是JpaJDBC什么是JPAJPA与Hibernate的关系JPA的提供商创建JPA项目创建JPA工程配置配置文件 persistence.xml创建实体类在persistence.xml中加入实体类测试JPA注解详解EntityTableIdGeneratedValueBasicColumnTransientTemporal使用Tabl...
复制链接

扫一扫