jpa-mapping

单向一对多

　　一的一端：FeiZi.java　　没什么特别的。

package danXiangOne2Many;

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

@Table(name = "FEIZI")
@Entity
public class FeiZi {
    private Integer id;
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

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

 

　　　　多的一端：HuangDi.java

package danXiangOne2Many;

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

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

@Table(name = "HUANGDI")
@Entity
public class HuangDi {
    private Integer id;
    private String name;
    private Set<FeiZi> houGong = new HashSet<>();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

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

    @JoinColumn(name = "HUANGDI_ID")
    @OneToMany(fetch=FetchType.EAGER)//这时就不是懒加载了
    public Set<FeiZi> getHouGong() {
        return houGong;
    }

    public void setHouGong(Set<FeiZi> houGong) {
        this.houGong = houGong;
    }
}

单向多对一

　　一的一端，没什么特别的：Customer.java

package danXiangMany2One;

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

@Table
@Entity
public class Customer {
    private int id;

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

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

}

 

　　多的一端：Order.java

package danXiangMany2One;

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;

/*
今天在写一个程序，用的数据库是mysql5.1，建一张名为order的表，使用jpa，调试了很长时间都不对，
以为是设置映射关系错误，检查和实验了很多遍都不对。
最后自信检查了后台报错的提示，
说是版本不支持，这才想起可能order这个词为MySQL的关键字，然后改为t_order，调试就通过了。
很小的错误，由于不细心，忘记了order为mysql的关键字，哎哎，还需要多仔细啊，更重要的是去详细分析后台报错的信息。
*/

@Table(name = "ORDERS") // 非常奇怪。这里若写成ORDER或者不设name就会报错??????????原因见上面
@Entity
public class Order {
    private int id;
    private Customer customer;

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

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

    @JoinColumn(name = "CUSTOMER_ID")
    @ManyToOne
    public Customer getCustomer() {
        return customer;
    }

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

 

双向一对一

　　不维护关联关系的一方，只需@OneToOne(mappedBy = "department")即可

　　Department.java

package shuangXiangOne2one;

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

@Table
@Entity
public class Department {
    private int id;
    private DiZhi dizhi;

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

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

    //mappedBy = "department"：表示Department不维护关联关系，department为维护关联关系的类中对应此类的属性名
    @OneToOne(mappedBy = "department")
    public DiZhi getDizhi() {
        return dizhi;
    }

    public void setDizhi(DiZhi dizhi) {
        this.dizhi = dizhi;
    }
}

 

　　维护关联关系的一方：DiZhi.java

package shuangXiangOne2one;

import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;

@Table
@Entity
public class DiZhi {
    private int id;
    private Department department;

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

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

    @JoinColumn(unique=true)//因为是121所以要unique
    @OneToOne(fetch=FetchType.LAZY)
    //这里查询维护关联关系的类和查询非维护关联关系的类是默认都是使用左外连接都给查出来
    //只是查询非维护关联关系的类时，不管是否设置了懒加载都会全部查出来，因为如果使用代理类，
    //那么可能关联的是null（即没有关联），那会就会出错
    //但查询维护关连关系的类就可以使用懒加载。
    public Department getDepartment() {
        return department;
    }

    public void setDepartment(Department department) {
        this.department = department;
    }
}

双向多对多

　　不维护关联关系的一方：Teacher.java

package shuangXiangn2n;

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

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

@Table(name = "TEACHER")
@Entity
public class Teacher {
    private Integer id;
    private String name;
    private Set<Student> students = new HashSet<>();

    @Column(name="TEACHER_ID")
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Id
    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;
    }

    @ManyToMany(mappedBy="teachers")//意思是让Student类的teachers属性来维护关联关系
    public Set<Student> getStudents() {
        return students;
    }

    public void setStudents(Set<Student> students) {
        this.students = students;
    }
}

 

 

 

　　维护关联关系的一方：Student.java

package shuangXiangn2n;

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

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

@Table(name = "STUDENT")
@Entity
public class Student {
    private Integer id;
    private String name;
    private Set<Teacher> teachers = new HashSet<>();

    @Column(name="STUDENT_ID")
    @GeneratedValue(strategy=GenerationType.AUTO)
    @Id
    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;
    }

    //n2n只有一方可以维护关连关系因为都维护的话会在中间表中存在相同的主键
    //介入一个中间表，此表的主键为两个关联类的主键联合。        写在维护关联关系的类中的set属性的get方法前
    @JoinTable(name="STUDENT_TEACHER",//中间表的名字
            //将维护关联关系的此类的主键插入表中，name列名，referencedColumnName为维护关联的类的主键在表中的列名
            joinColumns={@JoinColumn(referencedColumnName="STUDENT_ID",name="JSTUDENT_ID")},
            //将委托维护关连关系的类的主键插入表中，name列名，referencedColumnName为委托维护关联的类的主键在表中的列名
            inverseJoinColumns={@JoinColumn(referencedColumnName="TEACHER_ID",name="JTEACHER_ID")})
    @ManyToMany(fetch=FetchType.EAGER)    //表名这属性为n2n,默认是懒加载的
    public Set<Teacher> getTeachers() {
        return teachers;
    }

    public void setTeachers(Set<Teacher> teachers) {
        this.teachers = teachers;
    }
}