注解讲解
@OneToMany(fetch=FetchType,cascade=CascadeType)
可选
@OneToMany描述一个一对多的关联,该属性应该为集体类型,在数据库中并没有实际字段.
fetch:表示抓取策略,默认为FetchType.LAZY,因为关联的多个对象通常不必从数据库预先读取到内存
cascade:表示级联操作策略,对于OneToMany类型的关联非常重要,通常该实体更新或删除时,其关联的实体也应当被更新或删除
例如:实体User和Order是OneToMany的关系,则实体User被删除时,其关联的实体Order也应该被全部删除
示例：
@OneTyMany(cascade=ALL)
public List getOrders() {
return orders;
}
@ManyToOne(fetch=FetchType,cascade=CascadeType)
可选
@ManyToOne表示一个多对一的映射,该注解标注的属性通常是数据库表的外键
optional:是否允许该字段为null,该属性应该根据数据库表的外键约束来确定,默认为true
fetch:表示抓取策略,默认为FetchType.EAGER
cascade:表示默认的级联操作策略,可以指定为ALL、PERSIST、MERGE、REFRESH和REMOVE中的若干组合,默认为无级联操作
targetEntity:表示该属性关联的实体类型.该属性通常不必指定,ORM框架根据属性类型自动判断targetEntity.
示例：
//订单Order和用户User是一个ManyToOne的关系
//在Order类中定义
@ManyToOne
@JoinColumn(name=”USER”)
public User getUser() {
return user;
}
@JoinColumn
可选
@JoinColumn和@Column类似,介量描述的不是一个简单字段,而一一个关联字段,例如.描述一个@ManyToOne的字段.
name:该字段的名称.由于@JoinColumn描述的是一个关联字段,如ManyToOne,则默认的名称由其关联的实体决定.
例如,实体Order有一个user属性来关联实体User,则Order的user属性为一个外键,
其默认的名称为实体User的名称+下划线+实体User的主键名称
示例：见@ManyToOne
@OneToMany和@ManyToOne单向关联配置
@ManyToOne单向关联配置
Order实体类
package com.master.bean;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.persistence.*;
/**
* Created by daizhao.
* User: tony
* Date: 2018-9-17
* Time: 9:48
* info:
*/
@Table(name="t_order")
@Entity
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Order {
@Id
@GeneratedValue(strategy= GenerationType.IDENTITY)
private Long orderId;
private String orderName;
@ManyToOne(fetch = FetchType.EAGER)
@JoinColumn(name = "user_id") //单向关联必须要指定关联字段
private User user;
}
User实体类
package com.master.bean;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.persistence.*;
/**
* @author tony
*/
@Entity
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
@Id
@GeneratedValue(strategy= GenerationType.IDENTITY)
private Long id;
@Column(nullable = false)
private String name;
@Column(nullable = false)
private Integer age;
}
dao
package com.master.dao;
import com.master.bean.Order;
import org.springframework.data.jpa.repository.JpaRepository;
/**
* @author tony
*/
public interface OrderRepository extends JpaRepository<Order, Long> {
}
//=======================================================================================
package com.master.dao;
import com.master.bean.User;
import org.springframework.data.jpa.repository.JpaRepository;
/**
* @author tony
*/
public interface UserRepository extends JpaRepository<User, Long> {
}
测试
package com.master;
import com.master.bean.Order;
import com.master.bean.User;
import com.master.dao.OrderRepository;
import com.master.dao.UserRepository;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.Optional;
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootJpaCascadeApplicationTests {
@Autowired
private OrderRepository orderRepository;
@Autowired
private UserRepository userRepository;
@Test
public void contextLoads() {
}
/**
* @ManyToOne 单向关联测试
*/
@Test
public void cascadeSingle(){
User user = new User();
user.setId(1l);
user.setAge(20);
user.setName("ALLEN");
userRepository.save(user);
Order order = new Order(null,"袜子", user);
Order order2 = new Order(null,"裤子", user);
//保存
orderRepository.save(order);
orderRepository.save(order2);
//获取
//getOne仅仅是通过代理获取并且仅仅是延迟加载策略
//findById两种策略都支持
Order getOrder = orderRepository.findById(order.getOrderId()).get();
System.out.println("getOrder.getOrderName() = " + getOrder.getOrderName());
System.out.println("getOrder.getUser().getName() = " + getOrder.getUser().getName());
}
}
说明：
单向关联的一方，必须配置其JoinColumn，指定关联字段，注意延迟加载和立即抓取策略的使用方式，代码里已经注释，
注意其实体类名不能与Mysql关键字冲突等问题MySQL server version for the right syntax to use near
@OneToMany单向关联配置
相关的配置还是上面的实体类，下面做了如下的修改
User实体类
package com.master.bean;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.persistence.*;
import java.util.LinkedHashSet;
import java.util.Set;
/**
* @author tony
*/
@Entity
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
@Id
@GeneratedValue(strategy= GenerationType.IDENTITY)
private Long id;
@Column(nullable = false)
private String name;
@Column(nullable = false)
private Integer age;
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER)//级联操作所有
@JoinColumn(name = "user_id")
private Set<Order> orders = new LinkedHashSet<>();
}
Order实体类
package com.master.bean;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.persistence.*;
/**
* Created by daizhao.
* User: tony
* Date: 2018-9-17
* Time: 9:48
* info:
*/
@Table(name="t_order")
@Entity
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Order {
@Id
@GeneratedValue(strategy= GenerationType.IDENTITY)
private Long orderId;
private String orderName;
@Column(name = "user_id")
private Integer userId;
}
dao 参加上面
测试类
/**
* @OneToMany单向关联测试
*/
@Test
public void testOneToMany(){
Order order1 = new Order(1l, "上衣", 1);
Order order2 = new Order(2l, "裤子", 1);
Order order3 = new Order(3l, "胸罩", 1);
Set<Order> orders = new LinkedHashSet<>();
orders.add(order1);
orders.add(order2);
orders.add(order3);
User user = new User(1l, "Kobe", 20, orders);
//保存
userRepository.save(user);//级联保存，因为配置了CascadeType.ALL
//级联查询
//findAll方法默认是 FetchType.LAZY策略，需要修改FetchType.EAGER，可以抓取到子表
List<User> userList = userRepository.findAll();
userList.forEach(user1 -> {
System.out.println("user1.getName() = " + user1.getName());
user1.getOrders().forEach(order -> {
System.out.println("order.getOrderName() = " + order.getOrderName());
});
});
}
说明：
单向关联的一方，必须配置其JoinColumn，指定关联字段，注意延迟加载和立即抓取策略的使用方式，代码里已经注释，
注意其实体类名不能与Mysql关键字冲突等问题MySQL server version for the right syntax to use near，
注意级联保存的使用方式，CascadeType.ALL，注意抓取策略的实现方式FetchType.EAGER、FetchType.Lazy
@OneToMany和@ManyToOne双向关联配置
oneToMany配置方
@Table(name = "micro_page")
@Entity
@Setter
@Getter
@AllArgsConstructor
@NoArgsConstructor
@Log
public class MicroPage {
/** */
@Id
@GeneratedValue(generator = "uuidGenerator")
@GenericGenerator(name = "uuidGenerator", strategy = "uuid")
@Column(name = "ID")
private String id;
/**
* 作品编号
*/
@Column(name = "WORK_NO")
private String workNo;
/**
* 最后修改人
*/
@Column(name = "LAST_MODIFIER")
private String lastModifier;
@OneToMany(mappedBy = "microPage", cascade = {CascadeType.ALL}, orphanRemoval = true)//"orphanRemoval"级联更新时同时删除旧的数据
private List<MicroAppraisal> details = new ArrayList<MicroAppraisal>();
manyToOne配置方
@Table(name = "micro_appraisal")
@Entity
@Setter
@Getter
@AllArgsConstructor
@NoArgsConstructor
public class MicroAppraisal {
/** */
@Id
@GeneratedValue(generator = "uuidGenerator")
@GenericGenerator(name = "uuidGenerator", strategy = "uuid")
@Column(name = "ID")
private String id;
/**
* 标点编号
*/
@Column(name = "POINT_NO")
private String pointNo;
/**
* 页面编号/关联显微检测页面，PAGE_ID做完关联外键字段
*/
@ManyToOne(cascade=CascadeType.PERSIST)//级联更新时同时删除旧的数据
@JoinColumn(name="PAGE_ID")
private MicroPage microPage;
}
说明：
双向配置关联：@OneToMany一方配置相对简单，不需要配置关联字段，@manyToOne一方配置除了基本配置外，需要配置关联字段映射。
orphanRemoval = true：可以参考 更新的同时删除多的一方的旧数据
级联清空关联关系操作如下：
public void updateAttributes(MicroForm microForm){
BeanUtilsHelper.copyProperties(this, microForm);
microForm.getMicroAppraisalForms().stream().forEach(microAppraisalForm -> {
MicroAppraisal microAppraisal = new MicroAppraisal();
BeanUtilsHelper.copyProperties(microAppraisal, microAppraisalForm);
this.clearDetail();
this.details.add(microAppraisal);
microAppraisal.setMicroPage(this);
});
this.updateTime = new Date();
}
private void clearDetail(){
this.details.stream().forEach(microAppraisal -> {
microAppraisal.setMicroPage(null);
});
this.details.clear();
}
@OneToMany、@ManyToOne做双向关联时，如何避免产生中间表自动生成
使用JPA的时候，如果A B两个实体间是一对多，多对一的关系双向配置时，如果不在@OneToMany里加入mappedBy属性会导致自动生成一个多余的中间表，上面的双向关联配置是最佳配置
在进行双向一对多的关联关系时，建议使用多的一方来维护关联关系，而1的一方不维护关联关系，这样会有效的减少sql语句
注意：若在一的一端@oneToMany 中使用mapperBy属性，则@oneToMany端就不能在使用@JoinColumn(name="CUSTOMER_ID")属性进行级联保存如下示例：
@Test
public void testOneToManyPersist(){
Customer customer=new Customer();
customer.setAge(16);
customer.setBirth(new Date());
customer.setCreatedTime(new Date());
customer.setEmail("CC@163.com");
customer.setLastName("AA");
Order order1=new Order();
order1.setOrderName("o-CC-1");
Order order2=new Order();
order2.setOrderName("o-CC-2");
//建立关联关系
customer.getOrders().add(order1);
customer.getOrders().add(order2);
//执行保存操作
entityManager.persist(customer);
entityManager.persist(order1);
entityManager.persist(order2);
}