Web开发 | Hibernate - 15.Hibernate的JPA注解

最新推荐文章于 2023-08-20 19:14:44 发布
最新推荐文章于 2023-08-20 19:14:44 发布
阅读量194 收藏
点赞数
分类专栏： Web开发 | Hibernate 文章标签： Hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JasonSen_wu666/article/details/80117084
版权

  JPA是SUN公司的一个 ORM 规范，只有接口和注解，没有具体实现。JPA是 EJB3 中的子规范。

  Hibernate中有两套注解规范：一套JPA，一套自己的；

  使用注解开发，效率更高。

一、单表常用注解

新建项目Hibernate5_d04_c04，引入必要的jar包、配置、util类

1、简单自动创建一张数据表

  /Hibernate5_d04_c04/src/hibernate/domain/Book.java
程序代码如下：

package hibernate.domain;

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

@Entity //引入javax.persistence包中的Entity注解
//表示book类是一个实体类
public class Book {
    @Id //对应数据表中的主键
    private Integer id;
    private String name;
    private Double price;

    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 Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }
}

  /Hibernate5_d04_c04/src/hibernate/test/TestBook.java
程序代码如下：

package hibernate.test;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import hibernate.domain.Book;
import hibernate.util.HibernateUtils;

public class TestBook {
    //在数据库中自动生成一张数据表
    @Test
    public void testInit(){
        HibernateUtils.getCurrentSession();
    }
}

  /Hibernate5_d04_c04/src/hibernate.cfg.xml
程序代码如下：

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
        <!-- 必选配置 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
                <!-- jdbc:mysql:///hibernate_day01 -->
        <property name="hibernate.connection.url">jdbc:mysql://127.0.0.1:3306/hibernate_day04</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">root</property>
                <!--数据库方言 使用的数据库类型  -->
        <property name="hibernate.dialect org.hibernate.dialect.MySQLDialect"></property>

        <!-- 可选配置 -->
                <!-- 在控制台输出sql语句 -->
        <property name="show_sql">true</property>
                <!-- 在控制台输出的sql语句格式化 -->
        <property name="hibernate.format_sql">true</property>
                <!-- 配置c3p0连接池 -->
                    <!-- C3P0 的供应商 -->
        <property name="hibernate.connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
                    <!-- 最小连接 -->
        <property name="hibernate.c3p0.min_size">5</property>
                    <!-- 最大连接数 -->
        <property name="hibernate.c3p0.max_size">10</property>
                    <!-- 每 120 秒检查空闲连接 -->
        <property name="hibernate.c3p0.timeout">120</property>
                <!-- 自动建表 -->
        <property name="hibernate.hbm2ddl.auto">update</property>
                <!-- 把session绑定到当前线程中,使用getCurrentSession()获取当前session -->
        <property name="hibernate.current_session_context_class">thread</property>

        <!-- 映射文件 -->
        <!-- 关联 xml 配置文件,注解方式配置 -->
        <!-- 单表 -->
        <mapping class="hibernate.domain.Book"/>
    </session-factory>
</hibernate-configuration>

运行效果
运行效果

2、保存数据

  /Hibernate5_d04_c04/src/hibernate/domain/Book.java
程序代码如下：

package hibernate.domain;

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

@Entity //引入javax.persistence包中的Entity注解
//表示book类是一个实体类
public class Book {
    @Id //对应数据表中的主键
    //主键生成策略
    //AUTO = native
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Integer id;
    private String name;
    private Double price;


    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 Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }
}

  /Hibernate5_d04_c04/src/hibernate/test/TestBook.java
程序代码如下：

package hibernate.test;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import hibernate.domain.Book;
import hibernate.util.HibernateUtils;

public class TestBook {
    //在数据表中插入一条数据
    @Test
    public void testSave(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        Book book = new Book();
        book.setName("西游记");
        book.setPrice(88.88);
        session.save(book);
        tr.commit();
    }
}

运行结果

3、指定操作某个表

  /Hibernate5_d04_c04/src/hibernate/domain/Book.java
程序代码如下：

package hibernate.domain;

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

@Entity //引入javax.persistence包中的Entity注解
//表示book类是一个实体类
@Table(name="t_book") //指定操作某个表
public class Book {
    @Id //对应数据表中的主键
    //主键生成策略
    //AUTO = native
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Integer id;
    private String name;
    private Double price;
    ...
}

运行效果
运行效果

4、更多常用注解

  @Entity //注意引入的包名为javax.persistence.Entity

  注解：可以放到属性声明上面设置，也可以在getter方法上设置，效果一样。但是：要么都放属性，要么都放getter，不能混着用。

推荐标准最小化配置 

//po实体类
@Entity //指定该po对象为实体对象，对应表
@Table(name="t_book") //类似：table="t_book"
public class Book {
    @Id //指定该字段是主键，注解也可以写在getter方法上
    //主键生成策略
    //@GeneratedValue默认是自适应的主键策略：strategy=GenerationType.AUTO
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Integer id;
    private String name;
    private Double price;
    ...
    getter和setter方法
}

实体和表本身相关
实体和表本身相关

主键相关的
主键相关的

Auto 相当与 native,默认值

自定义主键策略（使用Hibernate实现）

  /Hibernate5_d04_c04/src/hibernate/domain/Book.java
程序代码如下：

...
public class Book {
    @Id //指定该字段是主键，直接也可以写在getter方法上
    //@GeneratedValue //默认是自适应的主键策略：strategy=GenerationType.AUTO
    //@GeneratedValue(strategy=GenerationType.AUTO) //有点像native
    @GenericGenerator(name="myIdGenerator",strategy="uuid")  //主键策略生成器，name:是主键策略的名字，给下面用
    @GeneratedValue(generator="myIdGenerator") //generator:指定一个具体的主键策略，可以自定义
    private Integer id;
    ...
}

其他字段相关的

  /Hibernate5_d04_c04/src/hibernate/domain/Book.java
程序代码如下：

...
public class Book {
    ...
    //如果不加任何注解，则默认的属性名就是字段名
    @Column(name="bname",length=30,nullable=false,unique=true) //name:字段名字
    private String name;
    //忽略属性:该属性不想映射为字段
    @Transient //该属性不会作为数据库字段
    private Double price;
    ...
}

属性字段官方参考配置

name 可选。列名（默认是属性名）
unique 可选。是否在该列上设置唯一约束（默认值false）
nullable 可选。是否设置该列的值可以为空（默认值false）
insertable 可选。该列是否作为生成的insert语句中的一个列（默认值true）
updatable 可选。该列是否作为生成的update语句中的一个列（默认值true）
columnDefinition 可选。为这个特定列覆盖SQL DDL片段（这可能导致无法在不同数据库间移植）
table 可选。定义对应的表（默认为主表）
length 可选。列长度（默认值255）
precision 可选。列十进制精度（decimal precision）（默认值0）
scale 可选。如果列十进制数值范围（decimal scale）可用，在此设置（默认值0）

较完整配置

  /Hibernate5_d04_c04/src/hibernate/domain/Book.java
程序代码如下：

...
//po实体类
@Entity //将当前类标识为一个实力类po，表名，默认就是实体类的名字
@Table(name="t_book",catalog="hb21")//table="t_book"
public class Book {
    @Id //将当前字段标识为一个oid的属性，主键，主键策略默认为自动（根据数据库自动适应）
    //@GeneratedValue //默认值是auto，相当于native
    //@GeneratedValue(strategy=GenerationType.AUTO) //jpa内置的主键策略
    //Hibernate的主键策略生成器，name:是主键策略生成器的名字，strategy:Hibernate的主键策略
    @GenericGenerator(name="myIdGenerator",strategy="assigned") 
    @GeneratedValue(generator="myIdGenerator") //generator使用自定义扩展的主键生成器
    private Integer id;
    @Column(name="bname",length=30,unique=true)
    //@Basic //该字段有效
    private String name;
    //Hibernate就不会将该属性作为字段的映射，忽略了该字段
    @Transient
    private Double price;
    ...
}

二、多表常用注解之一对多

1、注解案例

  /Hibernate5_d04_c04/src/hibernate/domain/Customer.java
程序代码如下：

package hibernate.domain;

import java.util.HashSet;
import java.util.Set;

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

@Entity
@Table(name="t_customer")
public class Customer {
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Integer id;
    private String name;
    private String city;

    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 getCity() {
        return city;
    }
    public void setCity(String city) {
        this.city = city;
    }
}

  /Hibernate5_d04_c04/src/hibernate/domain/Order.java
程序代码如下：

package hibernate.domain;

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

@Entity
@Table(name="t_order")
public class Order {
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Integer id;
    private String name;
    private Double price;

    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 Double getPrice() {
        return price;
    }
    public void setPrice(Double price) {
        this.price = price;
    }
}

  /Hibernate5_d04_c04/src/hibernate.cfg.xml
程序代码如下：

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
        <!-- 必选配置 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
                <!-- jdbc:mysql:///hibernate_day01 -->
        <property name="hibernate.connection.url">jdbc:mysql://127.0.0.1:3306/hibernate_day04</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">root</property>
                <!--数据库方言 使用的数据库类型  -->
        <property name="hibernate.dialect org.hibernate.dialect.MySQLDialect"></property>

        <!-- 可选配置 -->
                <!-- 在控制台输出sql语句 -->
        <property name="show_sql">true</property>
                <!-- 在控制台输出的sql语句格式化 -->
        <property name="hibernate.format_sql">true</property>
                <!-- 配置c3p0连接池 -->
                    <!-- C3P0 的供应商 -->
        <property name="hibernate.connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
                    <!-- 最小连接 -->
        <property name="hibernate.c3p0.min_size">5</property>
                    <!-- 最大连接数 -->
        <property name="hibernate.c3p0.max_size">10</property>
                    <!-- 每 120 秒检查空闲连接 -->
        <property name="hibernate.c3p0.timeout">120</property>
                <!-- 自动建表 -->
        <property name="hibernate.hbm2ddl.auto">update</property>
                <!-- 把session绑定到当前线程中,使用getCurrentSession()获取当前session -->
        <property name="hibernate.current_session_context_class">thread</property>

        <!-- 映射文件 -->
        <!-- 关联 xml 配置文件,注解方式配置 -->
        <!-- 一对多 -->
        <mapping class="hibernate.domain.Customer"/>
        <mapping class="hibernate.domain.Order"/>
    </session-factory>
</hibernate-configuration>

配置一对多

  /Hibernate5_d04_c04/src/hibernate/domain/Customer.java
程序代码如下：

...
@Entity
@Table(name="t_customer")
public class Customer {
    ...
    //一对多
    @OneToMany
    private Set<Order> orders = new HashSet<>();

    ...

    public Set<Order> getOrders() {
        return orders;
    }
    public void setOrders(Set<Order> orders) {
        this.orders = orders;
    }
}

  /Hibernate5_d04_c04/src/hibernate/domain/Order.java
程序代码如下：

...
@Entity
@Table(name="t_order")
public class Order {
    ...
    //多对一
    @ManyToOne
    private Customer customer;

    ...

    public Customer getCustomer() {
        return customer;
    }
    public void setCustomer(Customer customer) {
        this.customer = customer;
    }
}

  /Hibernate5_d04_c04/src/hibernate/test/TestOne2Many.java
程序代码如下：

package hibernate.test;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import hibernate.domain.Customer;
import hibernate.domain.Order;
import hibernate.util.HibernateUtils;

public class TestOne2Many {
    //保存数据
    @Test
    public void testOne2Many(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        //新建一个客户
        Customer c = new Customer();
        c.setName("冠希");

        //新建2个订单
        Order o1 = new Order();
        o1.setName("摄像机");

        Order o2 = new Order();
        o2.setName("电脑");

        //双向关联
        c.getOrders().add(o1);
        c.getOrders().add(o2);

        o1.setCustomer(c);
        o2.setCustomer(c);

        //保存操作
        session.save(o1);
        session.save(o2);
        session.save(c);

        tr.commit();
    }
}

运行效果
运行效果

从数据库中可以知道，Hibernate会自动生成一张中间表，我们可以通过注解去掉这个中间表

  /Hibernate5_d04_c04/src/hibernate/domain/Customer.java
程序代码如下：

...
@Entity
@Table(name="t_customer")
public class Customer {
    ...
    //一对多
    //mappedBy 除去中间表
    //mappedBy 是关联对象Order类在自己的实体类中一方的属性（需要在一方配置）
    //mappedBy="customer" 会在order表中生成一个外键，这里将生成叫customer_id的外键
    @OneToMany(mappedBy="customer")
    private Set<Order> orders = new HashSet<>();
    ...
}

运行效果

2、更多配置

  /Hibernate5_d04_c04/src/hibernate/domain/Customer.java
程序代码如下：

...
public class Customer {
    ...

    //关系：注解都直接配置关系
    //@OneToMany(mappedBy="customer") //mappedBy是关联属性order在自己的实体类中的一方的属性（需要在一方配置）
    //它会自动将Customer的主键作为外键，并且，自动将外键名称设置为：实体类小写_id
    @OneToMany(cascade=CascadeType.ALL //级联
            ,fetch=FetchType.LAZY //是否懒加载
            ,orphanRemoval=true //是否支持孤儿删除
            ,mappedBy="Customer" //关系对象中关系属性的名字
            ,targetEntity=hibernate.domain.Order.class //关联属性的实体类的名字（全名），一般忽略。
            //某些情况下不能忽略，Order如果是个借口，不是具体的实现的情况下，这里就要配置具体的实现类
            )
    private Set<Order> orders = new HashSet<>();

    ...
}

  /Hibernate5_d04_c04/src/hibernate/domain/Order.java
程序代码如下：

...

@Entity
@Table(name="t_order")
public class Order {
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Integer id;
    private String name;
    private Double price;

    //关系
    @ManyToOne
    @JoinColumn(name="c_id") //在关系（对象）表中配置外键名称，如果不配置，默认：实体类小写_id
    private Customer customer;

    ...
}

三、多表常用注解之多对多

1、注解案例

  /Hibernate5_d04_c04/src/hibernate/domain/Student.java
程序代码如下：

package hibernate.domain;

import java.util.HashSet;
import java.util.Set;

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

@Entity
@Table(name="t_student")
public class Student {
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Integer id;
    private String name;
    //多对多
    @ManyToMany
    private Set<Course> courses = new HashSet<>();

    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 Set<Course> getCourses() {
        return courses;
    }
    public void setCourses(Set<Course> courses) {
        this.courses = courses;
    }


}

  /Hibernate5_d04_c04/src/hibernate/domain/Course.java
程序代码如下：

package hibernate.domain;

import java.util.HashSet;
import java.util.Set;

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

@Entity
@Table(name="t_course")
public class Course {
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    private Integer id;
    private String name;
    //多对多
    @ManyToMany
    private Set<Student> students = new HashSet<>();


    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 Set<Student> getStudents() {
        return students;
    }
    public void setStudents(Set<Student> students) {
        this.students = students;
    }
}

  /Hibernate5_d04_c04/src/hibernate/test/TestMany2Many.java
程序代码如下：

package hibernate.test;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import hibernate.domain.Course;
import hibernate.domain.Student;
import hibernate.util.HibernateUtils;

public class TestMany2Many {
    @Test
    public void testMany2Many(){
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        //新建一个学生
        Student s = new Student();
        s.setName("冠希");

        //新建一门课程
        Course c = new Course();
        c.setName("摄影");

        //双向关联
        s.getCourses().add(c);
        c.getStudents().add(s);

        //保存
        session.save(c);
        session.save(s);


        tr.commit();
    }
}

  /Hibernate5_d04_c04/src/hibernate.cfg.xml
程序代码如下：

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
        <!-- 必选配置 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
                <!-- jdbc:mysql:///hibernate_day01 -->
        <property name="hibernate.connection.url">jdbc:mysql://127.0.0.1:3306/hibernate_day04</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">root</property>
                <!--数据库方言 使用的数据库类型  -->
        <property name="hibernate.dialect org.hibernate.dialect.MySQLDialect"></property>

        <!-- 可选配置 -->
                <!-- 在控制台输出sql语句 -->
        <property name="show_sql">true</property>
                <!-- 在控制台输出的sql语句格式化 -->
        <property name="hibernate.format_sql">true</property>
                <!-- 配置c3p0连接池 -->
                    <!-- C3P0 的供应商 -->
        <property name="hibernate.connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
                    <!-- 最小连接 -->
        <property name="hibernate.c3p0.min_size">5</property>
                    <!-- 最大连接数 -->
        <property name="hibernate.c3p0.max_size">10</property>
                    <!-- 每 120 秒检查空闲连接 -->
        <property name="hibernate.c3p0.timeout">120</property>
                <!-- 自动建表 -->
        <property name="hibernate.hbm2ddl.auto">update</property>
                <!-- 把session绑定到当前线程中,使用getCurrentSession()获取当前session -->
        <property name="hibernate.current_session_context_class">thread</property>

        <!-- 映射文件 -->
        <!-- 关联 xml 配置文件,注解方式配置 -->
        <!-- 多对多 -->
        <mapping class="hibernate.domain.Course"/>
        <mapping class="hibernate.domain.Student"/>
    </session-factory>
</hibernate-configuration>

运行效果

从数据库中可以知道，Hibernate会自动生成两张中间表，我们可以通过注解去掉其中一张中间表

  * *
程序代码如下：

...
@Entity
@Table(name="t_course")
public class Course {
    ...
    //多对多
    //mappedBy只会生成一张中间表
    //必须在某一方配置外键关联字段
    //mappedBy="courses" 对应Student类中的Set<Course> courses
    //应该配置中间表的信息
    //如果不配置，默认中间表的名字就是表名 1_表名 2，字段是各自的:实体类名字_id
    @ManyToMany(mappedBy="courses")
    private Set<Student> students = new HashSet<>();
    ...
}

运行效果

2、更多配置

  /Hibernate5_d04_c04/src/hibernate/domain/Student.java
程序代码如下：

...
@Entity
@Table(name="t_student")
public class Student {
    @Id
    @GeneratedValue
    private Integer id;
    private String name;

    //多对多关系
    @ManyToMany
    //应该配置中间表的信息，如果不配置，默认的中间表的名字就是：表名1_表名2,字段是各自的:实体类字段_id
    @JoinTable(name="t_student_course" //自定义中间关系表信息，name:中间表的名字
                ,joinColumns=@JoinColumn(name="s_id") //自己在关系表中的外键的名字
                ,inverseJoinColumns={@JoinColumn(name="c_id")} //对方在关系表中外键的名称
            )
    private Set<Course> courses = new HashSet<>();

    ...
}

  /Hibernate5_d04_c04/src/hibernate/domain/Course.java
程序代码如下：

...

@Entity
@Table(name="t_course")
public class Course {
    @Id
    @GeneratedValue
    private Integer id;
    private String name;
    //多对多关系
    @ManyToMany(mappedBy="courses") //外键维护权，多表只能在一方配置
    //必须在某一方面配置外键关联字段
    private Set<Student> students = new HashSet<>();

    ...
}

四、抓取策略注解

.在一方Customer类中配置抓取策略

  /Hibernate5_d04_c04/src/hibernate/test/TestFetch.java
程序代码如下：

package hibernate.test;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import hibernate.domain.Customer;
import hibernate.util.HibernateUtils;

public class TestFetch {
    @Test
    public void testFetch(){
        //获取11号客户
        Session session = HibernateUtils.getCurrentSession();
        Transaction tr = session.beginTransaction();
        Customer c = session.get(Customer.class, 11);
        //获取客户对应的所有订单数量
        System.out.println(c.getName()+"-->"+c.getOrders().size());

        tr.commit();
    }
}

  /Hibernate5_d04_c04/src/hibernate/domain/Customer.java
程序代码如下：

...
@Entity
@Table(name="t_customer")
public class Customer {
    ...
    @OneToMany(mappedBy="customer")
    //配置抓取策略
    @Fetch(FetchMode.JOIN)
    @LazyCollection(LazyCollectionOption.TRUE)
    private Set<Order> orders = new HashSet<>();
    ...
}
配置抓取策略前

运行效果
发送两条SQL语句

配置抓取策略后

运行效果

Cheat_Code
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hibernate-jpa-2.1-api-1.0.0.final.jar.zip
07-01
《深入理解Hibernate JPA 2.1 API》 在Java世界中，ORM（Object-Relational Mapping）框架已经成为开发数据库应用程序不可或缺的一部分。其中，Hibernate作为一款功能强大的ORM框架，极大地简化了Java对象与数据库...
hibernate-5.2.15. 最新jar包
08-17
1. **对象关系映射**：Hibernate通过XML配置文件或注解将Java类与数据库表进行映射，使得数据库操作可以通过对象的增删改查方法实现，无需编写SQL语句。 2. **Session接口**：作为主要的持久化层接口，Session提供...
JPA-Hibernate
Wqr_18390921824的博客
12-01 773
一. JPA与hibernate的关系 JPA规范本质上就是一种ORM规范，注意不是ORM框架——因为JPA并未提供ORM实现，它只是制订了一些规范，提供了一些编程的API接口，但具体实现则由服务厂商来提供实现。 JPA和Hibernate的关系就像JDBC和数据库JDBC驱动的关系，JPA是规范，Hibernate除了作为ORM框架之外，它也是一种JPA实现。JPA怎么取代Hibernate呢？JDBC规范可以驱动底层数据库吗？答案是否定的，也就是说，如果使用JPA规范进行数据库操作，底层需要..
hibernate-jpa-2.1-api-1.0.0.Final.jar中的所有注解
u014087286的专栏
05-21 3207
①、@Access AccessType.PROPERTY:               --> 通过getter和setter方法访问Entity的变量，可以把变量定义为private；              --> 需要在getter方法上定义字段的属性； AccessType.FIELD:              --> 直接访问Entity的变量，可以不定义getter和s
hibernate-release-5.4.3.Final快速开始教程---中文版
qq_42145816的博客
07-28 2091
目录 序言 1.获取hibernate 1.1.hibernate模块 1.2.版本包下载 1.3.Maven库工具 2.使用本地Hibernate API和hbm.xml映射的教程 2.1.Hibernate的配置文件 2.2.实体java类 2.3.映射文件 例一：类映射元素 例二：id元素 例三：属性映射元素 2.4.示例代码 例五：保存实体 例六：获取实...
Hibernate版本 支持 hibernate-jpa-2.0-api-1.0.0.Final.jar
热门推荐
z69183787的专栏
04-17 1万+
我记得hibernate3.5以前的版本使用注解使用hibernate-annotations.jar以及ejb-persistence.jar。其实这里的ejb-persistence.jar和前面提到的hibernate-jpa-2.0-api-1.0.0.Final.jar功能一样，实现持久化功能。但hibernate-jpa-2.0-api-1.0.0.Final.jar在ejb-pers
Hibernate JPA 快速入门
qq_35254085的博客
04-28 2093
1、Hibernate JPA简介 1.1、认识 hibernate Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将 POJO与数据库表建立映射关系，是一个全自动的 orm 框架，hibernate 可以自动生成 SQL 语句，自动执行，使得 Java 程序员可以随心所欲的使用对象编程思维来操纵数据库。 1.2、认识 JPA JPA的全称：Java Persistence API， 即Java 持久化API，是SUN公司推出的一套基于ORM的规范，
Spring.jpa使用Hibernate的配置和常用注解
吃茫茫的博客
05-26 8966
文章内容来自于： http://blog.didispace.com/springbootdata2/，作者：程序猿DD https://www.cnblogs.com/hoojjack/p/6568920.html，作者：hoojjack 文章主要用于自己学习SpringBoot，方便以后的查询 1.关于spring.jpa.properties.hibernat...
SpringBoot启动时初始化数据库及spring.jpa.generate-dll与spring.jpa.hibernate.ddl-auto之间的困惑
ywb201314的专栏
07-21 1434
参考文章 Springboot2.x 自动创建表并且执行初始化数据 --------------------------------- 1、SpringBoot根据脚本初始化 结构初始化脚本文件由spring.datasource.schema属性指定，数据初始化脚本由文件spring.datasource.data属性指定。 这两个脚本是否执行的开关由spring.datasource.initialization-mode决定：always-一定执行，embedded-只对内存数据库执行，n.
SpringBoot 使用Hibernate (JPA)
王德昌的博客
08-20 1386
Hibernate是一个开源的对象关系映射（ORM）框架，为Java语言提供了一种与数据库交互的简单、高效的方式。SpringBoot是一个快速开发框架，简化了Spring应用的配置和部署。本文将介绍如何在SpringBoot项目中使用Hibernate来进行数据持久化操作。
Spring Boot 学习研究笔记(八) - Spring Data JPA与Hibernate区别及配置
w风雨无阻w的专栏
01-22 7231
一、JPA、Hibernate、Spring Data JPA 的区别与联系 1、什么是 JPA， 它与Hibernate有什么关系？ JPA（Java Persistence API）：是Java EE 5的标准ORM接口，也是ejb3规范的一部分。可以通过注解或者XML描述【对象-关系表】之间的映射关系，并将实体对象持久化到数据库中。 JPA为我们提供了以下功能： ORM映射元数据：JPA支持XML和注解两种元数据的形式，元数据描述对象和表之间的映射关系，框架据此将实体对象持久化到数据库表中
Hibernate---JPA注解@DynamicUpdate与@DynamicInsert
PI_PIBOY的博客
01-08 709
@DynamicInsert属性（默认为false）: 如果将其设置为true,表示insert对象的时候,生成动态的insert语句,如果这个字段的值是null就不会加入到insert语句当中。 比如希望数据库插入日期或时间戳字段时，在对象字段为空的情况下，表字段能自动填写当前的sysdate。 @DynamicUpdate属性（默认为false）: 如果将其设置为true,表示upda...
hibernate-release-5.3.2.Final
07-16
Hibernate ORM（Object-Relational Mapping）是一种将Java对象模型与关系数据库进行映射的技术，旨在简化数据库操作，提高开发效率。它通过XML或注解的方式定义对象与数据库表之间的映射关系，使得开发者可以像操作...
hibernate-jpa.jar
07-14
总的来说，Hibernate JPA.jar文件是Java开发者进行企业级应用开发的重要工具，它提供了JPA规范的实现，简化了数据库操作，促进了面向对象编程与关系型数据库之间的无缝集成。通过深入理解和熟练运用Hibernate JPA，...
hibernate-release-5.2.10.Final
08-29
元模型是JPA中的一个重要概念，它包含了实体类的元数据信息，如字段、注解等，用于在运行时解析和验证查询表达式。通过这个生成器，开发者可以更加专注于业务逻辑，提高开发效率。 三、Envers审计模块 Hibernate ...
注册安全工程师预报考人员管理台账.xlsx
07-04
注册安全工程师预报考人员管理台账.xlsx
6-1机械波的产生和传播.ppt
最新发布
07-04
6-1机械波的产生和传播
2-3.ppt
07-04
2-3
9-3电通量 高斯定理.ppt
07-04
9-3电通量 高斯定理
+- tk.mybatis:mapper-spring-boot-starter:jar:1.2.3:compile [INFO] | +- tk.mybatis:mapper-spring-boot-autoconfigure:jar:1.2.3:compile [INFO] | \- tk.mybatis:mapper:jar:3.5.2:compile [INFO] | \- javax.persistence:persistence-api:jar:1.0:compile，如何引入依赖，使项目可以使用orphanRemoval？
05-24
要使用 `orphanRemoval` 功能，需要使用 JPA 的实现库，比如 Hibernate。 你可以在你的项目中引入 Hibernate 的 JPA 实现库，然后将 `orphanRemoval` 属性设置为 `true` 即可。以下是一个示例依赖： ```xml ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值