6、JPA-映射-单向一对多

一个用户对应多个订单

用户类：Customer

import lombok.Data;

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;

@Data
@Entity(name = "OneToMany_CUTOMERS")
@Table(name = "OneToMany_CUTOMERS")
public class Customer {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;

    @Column(name = "LAST_NAME", length = 50, nullable = false)
    private String lastName;

    private String email;

    // 映射单向 1-n 的关联关系
    // 使用 @OneToMany 来映射 1-n 的关联关系
    // 使用 @JoinColumn 来映射外键列的名称
    // 可使用 @ManyToOne 的 fetch 属性来修改默认的关联属性的加载策略，在左外连接和两条SQL间切换
    // 使用 @OneToMany 的 cascade 属性来修改默认的删除策略，例在删除 1 的一端时，把 n 的一段也删除，级联删除
    @JoinColumn(name = "CUSTOMER_ID")
    @OneToMany(fetch = FetchType.EAGER, cascade = {CascadeType.REMOVE})
    private Set<Order> orders = new HashSet<>();
}

订单类：Order

import lombok.Data;

import javax.persistence.*;

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

    @Id
    @GeneratedValue
    private Integer id;

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

测试

建表

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

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

public class JPAyingshe {
    private EntityManagerFactory entityManagerFactory;
    private EntityManager entityManager;
    private EntityTransaction transaction;

    @Before
    public void init() {
        entityManagerFactory = Persistence.createEntityManagerFactory("jpaname");
        entityManager = entityManagerFactory.createEntityManager();
        transaction = entityManager.getTransaction();
        transaction.begin();
    }

    @After
    public void destroy() {
        transaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }

    @Test
    public void createTable() {}
}

添加

// 单向 1-n 关联关系执行保存时, 一定会多出 UPDATE 语句，与保存先后顺序无关
// 因为 n 的一端在插入时不会同时插入外键列
@Test
public void testOneToManyPersist() {
    Customer customer = new Customer();
    customer.setEmail("[e-mail]");
    customer.setLastName("MM");

    Order order1 = new Order();
    order1.setOrderName("O-MM-1");

    Order order2 = new Order();
    order2.setOrderName("O-MM-2");

    //建立关联关系
    customer.getOrders().add(order1);
    customer.getOrders().add(order2);

    //执行保存操作
    entityManager.persist(customer);

    entityManager.persist(order1);
    entityManager.persist(order2);
}

查询

// 默认对关联的多的一方使用懒加载策略
// 可以使用 @OneToMany 的 fetch 属性来修改默认的加载策略
@Test
public void testOneToManyFind() {
    Customer customer = entityManager.find(Customer.class, 14);
    System.out.println(customer.getLastName());

    System.out.println(customer.getOrders().size());
}

关闭懒加载

// 使用 @OneToMany 的 fetch 属性来修改默认的加载策略
@JoinColumn(name="CUSTOMER_ID")
@OneToMany(fetch=FetchType.EAGER)
public Set<Order> getOrders() {
    return orders;
}

删除

// 默认情况下, 若删除 1 的一端, 则会先把关联的 n 的一端的外键置空, 然后进行删除
// 可以通过 @OneToMany 的 cascade 属性来修改默认的删除策略
@Test
public void testOneToManyRemove() {
    Customer customer = entityManager.find(Customer.class, 14);
    entityManager.remove(customer);
}

修改删除策略，例在删除 1 的一端时，把 n 的一段也删除，级联删除

// 使用 @OneToMany 的 cascade 属性来修改默认的删除策略
@JoinColumn(name="CUSTOMER_ID")
@OneToMany(cascade={CascadeType.REMOVE})
public Set<Order> getOrders() {
    return orders;
}

修改

@Test
public void testUpdate(){
    Customer customer = entityManager.find(Customer.class, 20);

    customer.getOrders().iterator().next().setOrderName("YD-20");
}