spring-data-jpa正向工程生成数据表（一对多）

用jpa的正向工程创建表

• 1、配置实体类的映射关系（主要是配置id主键，和外键）
• 2、运行springboot容器，容器自动帮我创建表
• film对filmType
• 一部电影对应一个类型
• 一个类型可以有多部电影
• 电影对类型是 多对一的关系，电影是多方，类型是一方
• 一对多关系中，外键设在多方

使用javax提供的一套注解，配置pojo和数据表，pojo属性和表字段的映射

package com.gec.jpa.pojo;

import java.io.Serializable;

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  //声明Film是一个可持久化的类.
@Table(name="film")   //数据表的名字
public class Film implements Serializable{

	
	private Integer id;
	private String filmName;
	private String actor;
	private String editor;
	private Double ticketPrice;
	
	private FilmType typeId;

	public Film() {
		super();
	}
	
	public Film(String filmName, String actor, String editor, Double ticketPrice, FilmType typeId) {
		super();
		this.filmName = filmName;
		this.actor = actor;
		this.editor = editor;
		this.ticketPrice = ticketPrice;
	}

	//映射属性和字段的关系，除了可以在定义属性时设置，还可以在属性的get方法设置
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY) //主键生成策略，自增长
	public Integer getId() {
		return id;
	}

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

	public String getFilmName() {
		return filmName;
	}

	public void setFilmName(String filmName) {
		this.filmName = filmName;
	}

	public String getActor() {
		return actor;
	}

	public void setActor(String actor) {
		this.actor = actor;
	}

	public String getEditor() {
		return editor;
	}

	public void setEditor(String editor) {
		this.editor = editor;
	}

	public Double getTicketPrice() {
		return ticketPrice;
	}

	public void setTicketPrice(Double ticketPrice) {
		this.ticketPrice = ticketPrice;
	}

	@ManyToOne   //在本类Film中，电影是多方，所以是多对一关系
	@JoinColumn(name="type_id")  //在一对多的关系中，在多方添加外键列。  其实，如果对于每一部具体的电影，一部电影只对应一个电影类型，是一对一关系
	public FilmType getTypeId() {
		return typeId;
	}

	public void setTypeId(FilmType typeId) {
		this.typeId = typeId;
	}
	
}

package com.gec.jpa.pojo;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

@Entity
@Table(name="filmtype")
public class FilmType implements Serializable {

	private Integer id;
	private String typeName;
	
	private Set<Film> films = new HashSet<>();

	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	public Integer getId() {
		return id;
	}

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

	public String getTypeName() {
		return typeName;
	}

	public void setTypeName(String typeName) {
		this.typeName = typeName;
	}

	
	//mappedBy属性表示关系由对方的外键去维护， 相当于hibernate中 设置inverse=true，使用该属性，可以减少sql语句的执行
	//cascade= {CascadeType.MERGE}设置级联关系
	//fetch=FetchType.LAZY  延迟加载
   // fetch=FetchType.EAGER 立即加载
	@OneToMany(mappedBy="typeId",cascade= {CascadeType.MERGE},fetch=FetchType.EAGER)  
	public Set<Film> getFilms() {
		return films;
	}

	public void setFilms(Set<Film> films) {
		this.films = films;
	}
}

本文使用到的注解

@Entity               //用于类上，声明一个类是一个可持久化的类.
@Table(name="film")   //数据表的名字

映射属性和字段的关系，可以在定义属性时设置，也可以在属性的get方法设置
@Id					  //声明某个属性为数据表中的主键
@GeneratedValue(strategy=GenerationType.IDENTITY) //用于@Id之后，声明主键生成策略，自增长


@ManyToOne                   //在本类中声明时多对一关系，本类为多方
@JoinColumn(name="type_id")  //声明在外键属性上，添加一个外键列
@OneToMany(mappedBy="typeId",cascade= {CascadeType.MERGE},fetch=FetchType.EAGER)  
    //声明时一对多关系
    //mappedBy属性表示关系由对方的外键去维护， 相当于hibernate中 设置inverse=true，使用该属性，可以减少sql语句的执行
  	//cascade= {CascadeType.MERGE}设置级联关系
	//fetch=FetchType.LAZY  延迟加载
    //fetch=FetchType.EAGER 立即加载