JPA

JPA 是什么

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

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

JPA和Hibernate的关系

JPA 是 hibernate 的一个抽象（就像JDBC和JDBC驱动的关系）：

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

– Hibernate 是实现：Hibernate 除了作为 ORM 框架之外，它也是一种 JPA 实现

从功能上来说， JPA 是 Hibernate 功能的一个子集

JPA的优势

标准化: 提供相同的 API，这保证了基于JPA 开发的企业应用能够经过少量的修改就能够在不同的 JPA 框架下运行。
简单易用，集成方便: JPA 的主要目标之一就是提供更加简单的编程模型，在 JPA 框架下创建实体和创建 Java 类一样简单，只需要使用 javax.persistence.Entity 进行注释；JPA 的框架和接口也都非常简单，
可媲美JDBC的查询能力: JPA的查询语言是面向对象的，JPA定义了独特的JPQL，而且能够支持批量更新和修改、JOIN、GROUP BY、HAVING 等通常只有 SQL 才能够提供的高级查询特性，甚至还能够支持子查询。

支持面向对象的高级特性: JPA 中能够支持面向对象的高级特性，如类之间的继承、多态和类之间的复杂关系，最大限度的使用面向对象的模型

需要用的包

    <!--jpa-->

    <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-entitymanager -->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-entitymanager</artifactId>
      <version>4.2.4.Final</version>
    </dependency>

 
    <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-ehcache -->
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-ehcache</artifactId>
      <version>4.2.4.Final</version>
    </dependency>

创建配置文件，固定的位置

标红名字要一致

文件内容

<?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要和项目名称一致 -->
    <persistence-unit name="jap_test" transaction-type="RESOURCE_LOCAL">
        <!-- 
        配置使用什么 ORM 产品来作为 JPA 的实现 
        1. 实际上配置的是  javax.persistence.spi.PersistenceProvider 接口的实现类
        2. 若 JPA 项目中只有一个 JPA 的实现产品, 则也可以不配置该节点. 
        -->
        <provider>org.hibernate.ejb.HibernatePersistence</provider>
    
        <!-- 添加持久化类 -->
        <!-- <class>com.jy.pojo.User</class> -->
        
        <!-- 
        配置二级缓存的策略 
        ALL：所有的实体类都被缓存
        NONE：所有的实体类都不被缓存. 
        ENABLE_SELECTIVE：标识 @Cacheable(true) 注解的实体类将被缓存
        DISABLE_SELECTIVE：缓存除标识 @Cacheable(false) 以外的所有实体类
        UNSPECIFIED：默认值，JPA 产品默认值将被使用
        -->
        <shared-cache-mode>ENABLE_SELECTIVE</shared-cache-mode>
    
        <properties>
            <!-- 连接数据库的基本信息 -->
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://192.168.100.101:3306/jap_test?useUnicode=true&amp;characterEncoding=UTF8"/>
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="123"/>
            
            <!-- 配置 JPA 实现产品的基本属性. 配置 hibernate 的基本属性 -->
            <property name="hibernate.format_sql" value="true"/><!-- 控制台展示sql语句格式化 -->
            <property name="hibernate.show_sql" value="true"/><!-- 控制台展示sql语句 -->
            <property name="hibernate.hbm2ddl.auto" value="update"/><!-- 动态建表 -->
            
            <!-- 二级缓存相关 -->
            <property name="hibernate.cache.use_second_level_cache" value="true"/>
            <property name="hibernate.cache.region.factory_class" value="org.hibernate.cache.ehcache.EhCacheRegionFactory"/>
            <property name="hibernate.cache.use_query_cache" value="true"/>
        </properties>
    </persistence-unit>
</persistence>

使用JPA持久化对象的步骤

创建 persistence.xml, 在这个文件中配置持久化单元

– 需要指定跟哪个数据库进行交互;

– 需要指定 JPA 使用哪个持久化的框架以及配置该框架的基本属性

创建实体类, 使用 annotation 来描述实体类跟数据库表之间的映射关系.
使用 JPA API 完成数据增加、删除、修改和查询操作

– 创建 EntityManagerFactory (对应 Hibernate 中的 SessionFactory);

创建 EntityManager (对应 Hibernate 中的Session);

JPA 基本注解

类级别注解

@Entity 实体类

@Table(name = "t_user") 实体类对应的表

属性级别

@Id 对象主键OID（Object ID）是由主键生成策略生成

@GeneratedValue(strategy=GenerationType.AUTO)//主键生成策略，代理主键IDENTITY mysql数据库主键生成策略，SEQUENCE oracle

@Column(length=30) 属性与表中的列的映射

@Transient 该属性不与表中的列表映射

实体的状态

新建状态: 新创建的对象，尚未拥有持久性主键。

持久化状态：已经拥有持久性主键并和持久化建立了上下文环境

游离状态：拥有持久化主键，但是没有与持久化建立上下文环境

删除状态: 拥有持久化主键，已经和持久化建立上下文环境，但是从数据库中删除。

实例单表查询

JpaUtil.java

package com.zym.utils;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class JpaUtil {
    private static EntityManagerFactory sf;
    static {
        //jap_test是项目名称
        sf = Persistence.createEntityManagerFactory("jap_test");

    }
    //获得会话，jdbc Connection Mybatis SqlSession
    public static EntityManager getEntityManager(){
        return sf.createEntityManager();
    }

//    public static void main(String[] args) {
//        System.out.println(JpaUtil.getEntityManager());
//    }

}

UserDao.java

package com.zym.Dao;

import com.zym.entity.User;
import com.zym.utils.JpaUtil;
import org.junit.Test;

import javax.persistence.EntityManager;
import javax.persistence.EntityTransaction;
import javax.persistence.Query;
import java.util.List;

public class UserDao {

    @Test
    public void test_user(){
        List<User> users = this.select_all();
        System.out.println(users);

        User user = this.select_one(1);
        System.out.println(user);

//        this.addUser();
//        User qqq = new User(10,"qqq", null);
//        this.delUser(qqq);


        this.updateUser();
    }


    //查询所有用户
    public List<User> select_all(){
        EntityManager entityManager = JpaUtil.getEntityManager();
        Query from_user = entityManager.createQuery("from User");
        List resultList = from_user.getResultList();
        return resultList;
    }

    //查询单个用户
    public User select_one(int id){
        EntityManager entityManager = JpaUtil.getEntityManager();
        return entityManager.find(User.class, id);
    }

    //添加用户
    public void addUser(){
        EntityManager entityManager = JpaUtil.getEntityManager();
        //开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        //开启事务
        transaction.begin();
        User qqq = new User(null,"qqq", null);
        //保存
        entityManager.persist(qqq);
        //提交事务
        transaction.commit();
        //关闭事务
        entityManager.close();
    }

    //删除用户
    public void delUser(User user){
        EntityManager entityManager = JpaUtil.getEntityManager();
        //开启事务
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        User user1 = entityManager.find(User.class, user.getId());
        entityManager.remove(user1);
        transaction.commit();
        entityManager.close();


    }

    //修改用户
    public  void updateUser(){
        EntityManager entityManager = JpaUtil.getEntityManager();
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        User user = new User(10, null, "1010101010101");
        entityManager.merge(user);
        transaction.commit();
        entityManager.close();


    }




}

User.java

package com.zym.entity;

import org.hibernate.annotations.GenericGenerator;

import javax.persistence.*;


/**
 * ORM:Object relation mapping 对象关系(表)映射
 * 属性注解也可以写在对应属性的get方法上
 */

@Entity
@Table(name = "user")
public class User {

    //主键生成策略，代理主键IDENTITY mysql数据库主键生成策略，SEQUENCE oracle
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
    private String name;
    private String address;

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public User() {
    }

    public User(Integer id,String name, String address) {
        this.name = name;
        this.id =id;
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }


}

一对多

Goods.java

package com.jy.bean;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity@Table(name="t_goods")
public class Goods {
    @Id@GeneratedValue(strategy=GenerationType.AUTO)
    private Integer gid;
    private String gname;
    private Double price;
    @ManyToOne
    @JoinColumn(name="tid",insertable=true,updatable=true)//insertable,updateable是否在增加更新的时候维护关系
    private Type type;
    public Integer getGid() {
        return gid;
    }
    public void setGid(Integer gid) {
        this.gid = gid;
    }
    public String getGname() {
        return gname;
    }
    public void setGname(String gname) {
        this.gname = gname;
    }
    public Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }
    public Type getType() {
        return type;
    }
    public void setType(Type type) {
        this.type = type;
    }
    
    
}

type.java

package com.jy.bean;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity@Table(name="t_type")
public class Type {
    @Id@GeneratedValue(strategy=GenerationType.AUTO)
    private Integer tid;
    private String tname;
    
    public Integer getTid() {
        return tid;
    }
    public void setTid(Integer tid) {
        this.tid = tid;
    }
    public String getTname() {
        return tname;
    }
    public void setTname(String tname) {
        this.tname = tname;
    }
    
}

GoodsDao.java

package com.jy.dao;

import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.Query;

import com.jy.bean.Goods;
import com.jy.bean.Type;
import com.jy.util.JpaUtil;

public class GoodsDao {
    // 查询商品及类型
    public static void main(String[] args) {
        // 获得会话
        EntityManager em = JpaUtil.getEntityManager();
        Query q = em.createQuery("from Goods");
        List<Goods> list = q.getResultList();
        for (Goods g : list) {
            System.out.println(g.getGname());
            Type t = g.getType();
            System.out.println(t.getTname());
        }
    }
}

posted on 2019-07-21 08:33 睡觉的阿狸阅读(194) 评论(0) 编辑收藏举报