JPA规范

[TOC]

ORM思想

ORM全称Object Relational Mapping，即对象关系映射，是一种程序设计技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换。

通俗点讲，用来把对象映射到基于sql的关系模型数据库结构中去。这样，我们在具体的操作实体对象的时候，就不需要再去和复杂的sql语句打交道，只需简单的操作实体对象的属性和方法。ORM技术是在对象和关系之间提供了一条桥梁，前台的对象型数据和数据库中的关系型的数据通过这个桥梁来相互转化。

JPA规范

JPA（Java持久化API）是一种Java应用程序接口规范，描述java应用中关系数据的管理，充当面向对象的领域模型和关系数据库系统之间的桥梁。

Application code ---> JPA ---->实现JPA规范的框架（比如hibernate、spring data jpa） ----> 数据库

graph LR

A[Application code] --> |jpa规范| B(hibernate)
B -->|jdbc| C(mysql数据库)

hibernate框架

hibernate是一个开源的对象关系映射框架，它对jdbc进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成sql语句，自动执行，使得java程序员可以随心所欲的使用对象编程思维来操纵数据库。

入门案例

1、创建项目工程，导入相关依赖

    compile group: 'org.hibernate', name: 'hibernate-entitymanager', version: '5.4.3.Final'
    compile group: 'mysql', name: 'mysql-connector-java', version: '8.0.16'
    compile group: 'org.hibernate', name: 'hibernate-c3p0', version: '5.4.3.Final'

2、配置jpa的核心配置文件

配置到路径下的一个叫做META-INF的文件夹下
文件名字必须为 persistence.xml
- 必须配置persistence-unit（持久化单元）节点
- name：持久化单元名称，自定义
- transaction-type：事务管理的方式
  - JTA：分布式事务管理
  - RESOURCE_LOCAL：本地事务管理
- 配置jpa的实现方式
- 配置实体类
- 配置数据库信息
- 配置jpa实现方的配置信息（可选）

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
    <!--必须配置persistence-unit节点-->
    <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
        <!--jpa实现方式-->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <!--配置实体类-->
        <class>com.lxf.User</class>
        <properties>
            <!--数据库信息-->
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="crystal1024"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/study?serverTimezone=GMT"/>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>

            <!--jpa实现方的配置信息-->
            <!--日志显示sql语句-->
            <property name="hibernate.show_sql" value="true"/>
            <!--
            自动创建数据库的方式：
                create：程序运行时创建数据库表，如果表存在，先删除再创建
                update：程序运行时创建数据库表，如果表存在，不会创建，表有改动的话会更新
                none：不会创建表
            -->
            <property name="hibernate.hbm2ddl.auto" value="update"/>
        </properties>
    </persistence-unit>
</persistence>

3、编写实体类POJO

public class User {
    private Integer id;
    private String name;
    private Integer age;
    private Integer sex;//0未知1男2女
    private String address;
    private String phone;
    ...省略getter setter
}

4、配置实体类和表，类中属性和表中字段的映射关系

类与表的映射关系
- @Entity：声明实体类
- @Table：配置实体类与表的映射关系
  - name：配置数据库表的名称
属性与表字段的映射关系
- @Id：声明主键的配置
- @GeneratedValue：配置主键的生成策略
  - GenerationType.IDENTITY：自增，使用底层数据库支持的自动增长方式对id自增（比如mysql）
  - GenerationType.SEQUENCE：序列，（比如oracle）
  - GenerationType.TABLE：jpa提供的一种机制，通过一张数据库表的形式帮助我们完成主键自增
  - GenerationType.AUTO：由程序自动的帮助我们选择主键生成策略
- @Column：配置属性与字段的映射关系
  - name：数据库中表字段的名字

import javax.persistence.*;

@Entity
@Table(name = "user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Integer id;
    @Column(name = "name")
    private String name;
    @Column(name = "age")
    private Integer age;
    @Column(name = "sex")
    private Integer sex;//0未知1男2女
    @Column(name = "address")
    private String address;
    @Column(name = "phone")
    private String phone;
    ...省略getter setter
}

5、jpa操作数据库

加载配置文件，创建工厂（实体管理类工厂）对象。
- Persistence：用于创建实体管理器工厂（EntityManagerFactory）
  - createEntityManagerFactory：根据持久化单元名称创建实体管理器工厂
- EntityManagerFactory：用于创建实体管理器对象（EntityManager），创建比较浪费资源，线程安全对象。所以一般会以静态代码块的形式创建一个公共的EntityManagerFactory对象。
  - createEntityManager：内部维护了数据库信息、缓存、实体管理器对象等很多信息
获取实体管理器
- EntityManager：实体管理器。
  - getTransaction：创建事务对象
  - persist：保存
  - merge：更新
  - remove：删除
  - find/getRefrence：根据id查询
获取事务对象，开启事务
- EntityTransaction：事务对象。
  - begin：开启事务
  - commit：提交事务
  - rollback：回滚事务
完成CRUD操作
提交事务（异常时回滚事务）
释放资源

    @Test
    public void testSave(){
        //1.加载配置文件，获取工厂对象
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory("myJpa");
        //2.创建实体管理器
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        //3.获取事务对象
        EntityTransaction transaction = entityManager.getTransaction();
        //4.开启事务
        transaction.begin();
        try {
            //5.相关CRUD操作
            User user = new User();
            user.setName("tom");
            user.setAge(18);
            user.setSex(1);
            //保存
            entityManager.persist(user);
            //6.提交事务
            transaction.commit();
        }catch (Exception e){
            //6.回滚事务
            transaction.rollback();
            throw new RuntimeException("出异常啦");
        }finally {
            //7.释放资源
            entityManager.close();
            entityManagerFactory.close();
        }
    }

控制台打印出的sql日志：

Hibernate: create table user (id integer not null auto_increment, address varchar(255), age integer, name varchar(255), phone varchar(255), sex integer, primary key (id)) engine=InnoDB

Hibernate: insert into user (address, age, name, phone, sex) values (?, ?, ?, ?, ?)

优化EntityManagerFactory的创建

上面有提到，EntityManagerFactory的创建比较浪费资源，而且它是线程安全对象。所以一般会以静态代码块的形式创建一个公共的EntityManagerFactory对象。

public class JPAUtil {
    private static EntityManagerFactory factory;
    
    static {
        factory = Persistence.createEntityManagerFactory("myJpa");
    }
    
    public static EntityManager getEntityManager(){
        return factory.createEntityManager();
    }
}

此时我们的代码会变成这样：

    @Test
    public void testSave(){
        EntityManager entityManager = JPAUtil.getEntityManager();
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        try {
            User user = new User();
            user.setName("tom");
            user.setAge(18);
            user.setSex(1);
            entityManager.persist(user);
            transaction.commit();
        }catch (Exception e){
            transaction.rollback();
            throw new RuntimeException("出异常啦");
        }finally {
            entityManager.close();
        }
    }

数据库操作

插入操作

User user = new User();
user.setName("tom");
user.setAge(18);
user.setSex(1);
//接收要插入的对象
entityManager.persist(user);

删除操作

//先查询出我们要删除的对象
User user = entityManager.getReference(User.class, 1);
//接收要删除的对象
entityManager.remove(user);

更新操作

User user = entityManager.getReference(User.class, 2);
user.setName("lili");
//接收要修改的对象
entityManager.merge(user);

查询操作

内置API

根据主键查询单个：

 /**
  * 参数：
  *  1. class对象：查询数据结果需要包装的实体类类型的字节码
  *  2. 主键  这里是id
  */
 User user = entityManager.find(User.class, 1);

 /**
  * 参数：
  *  1. class对象：查询数据结果需要包装的实体类类型的字节码
  *  2. 主键  这里是id
  */
 User user = entityManager.getReference(User.class, 1);

find和getReference两者的区别：

find：立即加载
- 获取的对象就是要查询的对象本身
- 调用find方法时，会立即通过sql语句查询数据库
getReference：延迟加载（懒加载）
- 获取的对象是一个动态代理对象
- 调用getReference方法并不会立即通过sql语句查询数据库，而是当你使用这个对象的时候才会进行数据库查询

语句查询

创建查询对象Query

jpa提供了一系列create方法来获取一个Query对象进行复杂查询。

jpql全称Java Persistence Query Language，java持久化查询语言，它和sql的语法很像，不过操作的是类和属性。

createQuery：接收jpql语句

String jpql = "select u.name from User u";
//String jpql = "select name from User";//和上面语句效果是一样的
Query query = entityManager.createQuery(jpql);

createNamedQuery：执行命名查询，其实和createQuery是一样的，提前定义好的jpql语句

@Entity
@Table(name = "user")
@NamedQuery(name = "queryName",query = "select u.name from User u")
public class User {
    ...
}

Query query = entityManager.createNamedQuery("queryName");

createNativeQuery：接收原生sql语句

Query query = entityManager.createNativeQuery("select u.name from user as u");

常用查询操作

排序

sql：select * from user order by id desc
jpql：from User order by id desc

统计

sql：select count(id) from user
jpql：select count(id) from User

分页

sql：select * from user limit 1,10
jpql：from User

String jpql = "from User";
Query query = entityManager.createQuery(jpql);
query.setFirstResult(1);
query.setMaxResults(10);

条件查询

sql：select * from user where id > 1
jpql：from User where id > 1

Query的常用方法

executeUpdate：执行更新和删除操作。
getFirstResult：返回查询对象设置为检索的第一个定位结果。
getMaxResults：返回查询对象设置为检索的最大结果数。
getResultList：返回结果列表。
setFirstResult：分配要检索的第一个结果的位置。
setMaxResults：分配要检索的最大结果数。
setParameter：设置jpql语句中的占位符

Criteria查询

Criteria查询是在jpa 2.0的版本加入的一个更加符合面向对象思维的类型安全的查询方式。

首先介绍几个概念：

CriteriaBuilder：用于构造过滤条件（Predicate），内部提供了==大量的api==。在该接口中使用Predicate代替Expression <Boolean>可以解决java泛型向下兼容的问题。
CriteriaQuery<T>：定义顶级查询的功能。内部提供where、groupBy、orderby、having等方法。
Root<X>：根查询通常指向实体。

举个列子：select * from User where id > 3 and age >18

通俗点讲，select * from User属于Root，where属于CriteriaQuery，查询方式，id > 3 and age >18属于CriteriaBuilder构建出来的查询条件，这么讲可能不是很准确，但很容易理解。

简单翻译一下上面的语句：

public class JpaCriteriaTest {
    @Test
    public void testCriteria(){
        EntityManager entityManager = JPAUtil.getEntityManager();
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        try {
            //拿到CriteriaBuilder、CriteriaQuery、Root三个对象
            CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
            CriteriaQuery<User> criteriaQuery = criteriaBuilder.createQuery(User.class);
            Root<User> root = criteriaQuery.from(User.class);

            //构建过滤条件
            Predicate idCondition = criteriaBuilder.greaterThan(root.get("id"), 3);
            Predicate ageCondition = criteriaBuilder.greaterThan(root.get("age"), 18);
            Predicate predicate = criteriaBuilder.and(idCondition, ageCondition);

            //组合查询
            criteriaQuery.where(predicate);

            //查询并获取结果
            TypedQuery<User> typedQuery = entityManager.createQuery(criteriaQuery);
            List<User> resultList = typedQuery.getResultList();//得到id>3的所有数据
            resultList.forEach(new Consumer<User>() {
                @Override
                public void accept(User user) {
                    System.out.println(user);
                }
            });

            transaction.commit();
        }catch (Exception e){
            transaction.rollback();
            e.printStackTrace();
            throw new RuntimeException("出异常啦");
        }finally {
            entityManager.close();
        }
    }
}

如果我们只想查询某几个字段，可以使用CriteriaQuery<Tuple>：

//拿到CriteriaBuilder、CriteriaQuery、Root三个对象
CriteriaBuilder criteriaBuilder = entityManager.getCriteriaBuilder();
CriteriaQuery<Tuple> tupleQuery = criteriaBuilder.createTupleQuery();
Root<User> root = tupleQuery.from(User.class);
tupleQuery.multiselect(root.get("name"),root.get("age"));

//构建过滤条件
Predicate idCondition = criteriaBuilder.greaterThan(root.get("id"), 3);
Predicate ageCondition = criteriaBuilder.greaterThan(root.get("age"), 18);
Predicate predicate = criteriaBuilder.and(idCondition, ageCondition);

//组合查询
tupleQuery.where(predicate);

//查询并获取结果
TypedQuery<Tuple> typedQuery = entityManager.createQuery(tupleQuery);
List<Tuple> resultList = typedQuery.getResultList();//得到id>3的所有数据
resultList.forEach(new Consumer<Tuple>() {
   @Override
   public void accept(Tuple tuple) {
      System.out.println(tuple.get(0,String.class));
       System.out.println(tuple.get(1,Integer.class));
   }
});

多表关系映射

一对多

主表：一的一方为主表
从表：多的一方为从表
外键：需要再从从表上新建一列作为外键，它的取值来源于主表的主键

另外，一对一其实就是一种特殊的一对多。

案例

一个student表，一个school表，一个学校可以有很多学生，一个学生只属于一个学校。

表关系：一对多
- 主表：school
- 从表：student，我们需要在从表上添加外键
编写实体
- School：除了自有属性外应该包含一个List<Student>。
- Student：除了自有属性外应该有一个School属性，一个外键字段。
使用JPA注解配置映射关系：一般一方映射，另一方参照即可
- @OneToMany：声明一对多
  - targetEntity：目标实体（从表实体）
  - mappedBy：参照映射
- @ManyToOne：声明多对一
  - targetEntity：目标实体（从表实体）
- @JoinColumn：配置外键
  - name：从表上的外键字段名称
  - referencedColumnName：参照的主表主键字段名称

@Entity
@Table
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column
    private Integer studentId;
    @Column
    private String name;
    @Column
    private Double score;
    @Column
    private Integer sex;
    @Column(name = "school_id",insertable = false,updatable = false)//外键字段
    private Integer schoolId;

    @ManyToOne(targetEntity = School.class)//配置多对一关系
    @JoinColumn(name = "school_id",referencedColumnName = "schoolId")//配置外键
    private School school;
    ...
}

@Entity
@Table
public class School {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer schoolId;
    @Column
    private String name;
    @Column
    private String address;

//    @OneToMany(targetEntity = Student.class)//声明关系，一对多
//    @JoinColumn(name = "school_id",referencedColumnName = "schoolId")//配置外键
    @OneToMany(mappedBy = "school")//Student里面已经配置了映射关系，表示参照Student里面的school
    private List<Student> students = new ArrayList<>();
    ...
}

保存测试

public class JpaOneToManyTest {

    @Test
    public void testSave(){
        EntityManager entityManager = JPAUtil.getEntityManager();
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        try {
            Student student = new Student();
            student.setName("石昊");
            School school = new School();
            school.setName("天神书院");

            //创建关系
            student.setSchool(school);
//            school.getStudents().add(student);//两句代码都可以创建关系

            entityManager.persist(school);//先保存主表，如果先保存从表的话最好需要多一个update操作设置从表外键字段值
            entityManager.persist(student);

            transaction.commit();
        }catch (Exception e){
            transaction.rollback();
            e.printStackTrace();
            throw new RuntimeException("出异常啦");
        }finally {
            entityManager.close();
        }
    }
}

删除测试

主表配置外键映射：这种情况下删除会先将从表外键值设为null，再删除主表数据。
主表放弃外键维护，参照从表的映射：这种情况下只能使用级联删除。

级联操作

操作一个对象的同时操作它的关联对象。（先操作关联对象）

我们使用cascade来配置级联关系：

CascadeType.ALL：级联所有操作
CascadeType.PERSIST：级联保存操作
CascadeType.MERGE：级联更新操作
CascadeType.REMOVE：级联删除操作
CascadeType.REFRESH：级联refresh操作
CascadeType.DETACH：级联detach操作

@ManyToOne(targetEntity = School.class,cascade = CascadeType.ALL)
@JoinColumn(name = "school_id",referencedColumnName = "schoolId")

级联保存

Student student = new Student();
student.setName("叶凡");
School school = new School();
school.setName("荒古禁地");

//创建关系
 student.setSchool(school);

//这里只保存从表，主表会被级联保存
entityManager.persist(school);

级联删除

@OneToMany(mappedBy = "school",cascade = CascadeType.ALL)
private List<Student> students = new ArrayList<>();

School school = entityManager.find(School.class, 10);
entityManager.remove(school);//此时主表和从表中相关的数据都会删除

多对多

案例

一个developer表，一个language表，一个开发者可以会多种语言，一种语言也会有很多开发者会。

中间表：中间表中最少应该由两个字段组成，这两个字段作为外键指向两张表的主键，又组成了联合主键。

表关系：多对多
- 开发者表
- 语言表
- 中间表：最少应该由两个字段组成，这两个字段作为外键指向两张表的主键，又组成了联合主键。
编写实体
- Develop：除了自有属性外应该包含一个List<Language>。
- Language：除了自有属性外应该包含一个List<Develop>。
- 中间表：可以建一个实体，也可以直接数据库建表，一般用不到这个实体。
使用JPA注解配置映射关系：一般一方映射，另一方参照即可
- @ManyToMany：声明多对多
  - targetEntity：目标实体
- @JoinTable：添加中间表
  - name：中间表名
  - joinColumns：添加一个@JoinColumn数组，表示==当前对象==在中间表的外键
  - inverseJoinColumns：添加一个@JoinColumn数组，表示==对方对象==在中间表的外键

@Entity
@Table
public class Developer {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column
    private Integer developerId;
    @Column
    private String name;

    @ManyToMany(targetEntity = Language.class)
    @JoinTable(name = "middle_develop_language",
            joinColumns = @JoinColumn(name = "develop_id", referencedColumnName = "developerId"),
            inverseJoinColumns = @JoinColumn(name = "language_id", referencedColumnName = "languageId"))
    private List<Language> languages = new ArrayList<>();
    ...
}


@Entity
@Table
public class Language {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column
    private Integer languageId;
    @Column
    private String des;

//    @ManyToMany(targetEntity = Developer.class)
//    @JoinTable(name = "middle_develop_language",
//            joinColumns = @JoinColumn(name = "language_id", referencedColumnName = "languageId"),
//            inverseJoinColumns = @JoinColumn(name = "develop_id", referencedColumnName = "developerId"))
    @ManyToMany(mappedBy = "languages")//放弃维护权，参照对方的映射关系
    private List<Developer> developers = new ArrayList<>();
    private List<Developer> developers = new ArrayList<>();
    ...
}

保存测试

public class JpaManyToManyTest {

    @Test
    public void testSave(){
        EntityManager entityManager = JPAUtil.getEntityManager();
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        try {
            Developer developer = new Developer();
            developer.setName("lxf");
            Language language = new Language();
            language.setDes("java");

            //创建关系
            developer.getLanguages().add(language);

            entityManager.persist(developer);
            entityManager.persist(language);

            transaction.commit();
        }catch (Exception e){
            transaction.rollback();
            e.printStackTrace();
            throw new RuntimeException("出异常啦");
        }finally {
            entityManager.close();
        }
    }
}

级联操作

级联的配置和一对多是一样的，只需要在@ManyToMany配上cascade = CascadeType.ALL属性。

    @ManyToMany(targetEntity = Language.class,cascade = CascadeType.ALL)
    @JoinTable(name = "middle_develop_language",
            joinColumns = @JoinColumn(name = "develop_id", referencedColumnName = "developerId"),
            inverseJoinColumns = @JoinColumn(name = "language_id", referencedColumnName = "languageId"))
    private List<Language> languages = new ArrayList<>();

级联保存

Developer developer = new Developer();
developer.setName("lxf");
Language language = new Language();
language.setDes("java");

developer.getLanguages().add(language);

entityManager.persist(developer);

级联删除

Developer developer = entityManager.find(Developer.class, 1);
entityManager.remove(developer);//注意此时只能通过developer级联删除，因为只有Developer配置了cascade

对象导航查询

对象导航查询并不是一种新的查询方式，而是在多表关系中，通过查询某个对象，可以直接通过get得到相关联的数据信息，这是jpa的一种特性，但需要注意：

jpa默认使用的是懒加载的方式来获取相关信息，即首次查询时只查了单表信息，如果需要使用其相关信息，才会再次发送sql语句查询数据库。
如果需要立即加载，即在一开始就直接查询关联表的所有信息，则需要在映射关系中配置fetch属性。
- FetchType.EAGER：立即加载
- FetchType.LAZY：懒加载
fetch的默认值：需要查多方的默认懒加载，需要查单方的默认立即加载
- @OneToMany：默认FetchType.LAZY
- @ManyToMany：默认FetchType.EAGER
- @ManyToMany：默认FetchType.LAZY

    @OneToMany(mappedBy = "school",cascade = CascadeType.ALL,fetch = FetchType.EAGER)
    private List<Student> students = new ArrayList<>();

通过一方查多方

以上面的一对多案例为例，通过查询一个学校，得到该学校的所有学生。

public class JpaObjectQueryTest {
    @Test
    public void test(){
        EntityManager entityManager = JPAUtil.getEntityManager();
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
        try {
//            School school = entityManager.find(School.class, 5);
            School school = entityManager.getReference(School.class, 5);
            //可以直接通过get方法来得到和其相关的信息，如果懒加载，则此时会发送sql语句查询关联表信息
            List<Student> students = school.getStudents();
            System.out.println(students.size());
            students.forEach(new Consumer<Student>() {
                @Override
                public void accept(Student student) {
                    System.out.println(student);
                }
            });

            transaction.commit();
        }catch (Exception e){
            transaction.rollback();
            e.printStackTrace();
            throw new RuntimeException("出异常啦");
        }finally {
            entityManager.close();
        }
    }
}

通过多方查一方

            Student student = entityManager.find(Student.class, 5);
//            Student student = entityManager.getReference(Student.class, 5);
            School school = student.getSchool();
            System.out.println(school);

Demo源码地址

https://github.com/lunxinfeng/jpa

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 203,271评论 5赞 476
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 85,275评论 2赞 380
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 150,151评论 0赞 336
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 54,550评论 1赞 273
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 63,553评论 5赞 365
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,559评论 1赞 281
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 37,924评论 3赞 395
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,580评论 0赞 257
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 40,826评论 1赞 297
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,578评论 2赞 320
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,661评论 1赞 329
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,363评论 4赞 318
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 38,940评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,926评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,156评论 1赞 259
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 42,872评论 2赞 349
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,391评论 2赞 342

JPA规范

ORM思想

JPA规范

hibernate框架

入门案例

1、创建项目工程，导入相关依赖

2、配置jpa的核心配置文件

3、编写实体类POJO

4、配置实体类和表，类中属性和表中字段的映射关系

5、jpa操作数据库

优化EntityManagerFactory的创建

数据库操作

插入操作

删除操作

更新操作

查询操作

内置API

语句查询

创建查询对象Query

常用查询操作

排序

统计

分页

条件查询

Query的常用方法

Criteria查询

多表关系映射

一对多

案例

保存测试

删除测试

级联操作

级联保存

级联删除

多对多

案例

保存测试

级联操作

级联保存

级联删除

对象导航查询

通过一方查多方

通过多方查一方

Demo源码地址

推荐阅读更多精彩内容