JPA之实体之间的关系

JPA之实体之间的关系

10.1.1实体类创建

注解的应用

@Table，@Entity

@Id+@GeneratedValue指定主键，@Column

P174 实体类编写规范

@Table(name = "t_user")
@Entity(name = "User")
public class User implements Serializable {@Id@GeneratedValue(strategy =GenerationType.AUTO)
    private Integer id;@Column(name = "name",length = 50,unique = false,insertable = true,updatable = true,table = "t_user",nullable = true)
    private String name;
+get和setter方法
+有参无参构造
+toSTring方法    }

10.1.2jap的一对一，一对多，多对多用法

详见10.1.3-10.1.9

10.1.3单向一对一

P188 结合课本的单向一对一进行判断

本人理解的单向一对一的关系是。

往person表插入数据或者是删除数据的时候可以对idcard表进行操作。

但是操作idcard表无论如何也得不到person表的任何信息。

案例：person和身份证实体

• 通过用户可以找到身份证
• 通过身份证不能找到用户
• 关键是关系拥有方如何写

Person的代码：

@Table(name = "person")
@Entity(name="Person")
public class Person {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "personId")
    private Integer personId;    @Column(name="personName")
    private String personName;
//    ================单项一对一==============
    @OneToOne(optional = true,cascade = CascadeType.ALL)
    @JoinColumn(name = "id_card")
    private IdCard idCard;//构造函数+getter+setter+toString
...
}

IdCard的代码：就是编写一个实体类

@Table(name = "idcard")
@Entity(name="IdCard")
public class IdCard {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "cardId")
    private Integer cardId;    @Column(name="cardName")
    private String cardName;
//构造函数+getter+setter

测试代码：

import com.lxz.demo2.entity.IdCard;
import com.lxz.demo2.entity.Person;import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;public class PersonTest {
    public static void main(String[] args) {
        EntityManagerFactory factory=Persistence.createEntityManagerFactory("MyJPA2");
        EntityManager em=factory.createEntityManager();
        EntityTransaction transaction=em.getTransaction();
        transaction.begin();
        Person person=new Person(null,"李四");
        IdCard idCard=new IdCard(null,"李四身份证号码");
        person.setIdCard(idCard);
        em.persist(person);
        transaction.commit();
    }}

效果图：

10.1.4双向一对一

1.双向一对一

本人理解的双向一对一的关系是。

往person表插入数据或者是删除数据的时候可以对idcard表进行操作。

操作idcard表同样也会操作person表。

1.Person表的代码不变

@Table(name = "t_person")
@Entity(name="Person1")
public class Person {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "personId")
    private Integer personId;    @Column(name="personName")
    private String personName;
//    ================单项一对一==============
    @OneToOne(optional = true,cascade = CascadeType.ALL)
    @JoinColumn(name = "card_id")
    private IdCard idCard;}

2.IdCard的代码

@Table(name = "t_card")
@Entity(name="IdCard")
public class IdCard {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "cardId")
    private Integer cardId;    @Column(name="cardName")
    private String cardName;
//    =============双向一对一===================
//    mappedBy必须和前面设置的保持一致，idCard是person的属性，所以person表是关系的维护方
    @OneToOne(optional = false,cascade = CascadeType.REFRESH,mappedBy = "idCard")
    private Person person;//构造函数+getter+setter
}

测试代码：

public class PersonTest {
    public static void main(String[] args) {
        EntityManagerFactory factory=Persistence.createEntityManagerFactory("MyJPA2");
        EntityManager em=factory.createEntityManager();
        EntityTransaction transaction=em.getTransaction();
        transaction.begin();
        TPerson person=new TPerson(null,"王五");
        TIdCard idCard=new TIdCard(null,"李四身份证号码");
        person.setIdCard(idCard);
        idCard.settPerson(person);
        em.persist(person);
        em.persist(idCard);
        transaction.commit();
    }}

效果图：

10.1.5单向一对多

3.单向一对多

P193 单向一对多关系

案例：部门和员工的关系就是一对多的关系

• 外键关联
• 中间表

1.采用外键关联的方式

• 创建表

Department表：

Employee表：

• 创建

• 测试：

 EntityManagerFactory factory=Persistence.createEntityManagerFactory("MyJPA2");
        EntityManager em=factory.createEntityManager();
        EntityTransaction transaction=em.getTransaction();
        transaction.begin();
        Department department=new Department(null,"媒体部",null);
        Employee employee=new Employee(null,"王五");
        Employee employee2=new Employee(null,"赵六");
        List<Employee> e=new ArrayList<>();
        e.add(employee);
        e.add(employee2);
        department.setEmployees(e);
        em.persist(department);
        transaction.commit();

2.基于中间表方式

案例：学生和选课之间的关系是就是单向一对一，一个学生可以选择多门课程可以形成一个中间表（选课信息表）

基于中间表的方式的区别和基于外键的区别在于配置单方（关系拥有方的时候需要配置中间表）

• student类

@Table(name = "student")
@Entity(name = "Student")
public class Student implements Serializable {
    @Id
    @GeneratedValue
    @Column(name = "id")
    private Integer id;
    @Column(name = "name")
    private String name;    @OneToMany(cascade = CascadeType.ALL,fetch = FetchType.EAGER)
    @JoinTable(name="sc",
            joinColumns={
                    @JoinColumn(name = "student_id", referencedColumnName = "id")}
            ,inverseJoinColumns = {
            @JoinColumn(name = "course_id", referencedColumnName = "id")
    })    List<Course> courses;}

• Course类：

@Entity(name = "Course")
@Table(name = "course")
public class Course {@Id@GeneratedValue@Column(name = "id")
    private Integer id;@Column(name = "name")
    private String name;}

• 测试类：

 EntityManagerFactory factory=Persistence.createEntityManagerFactory("MyJPA2");
        EntityManager em=factory.createEntityManager();
        EntityTransaction transaction=em.getTransaction();
        transaction.begin();
        Student student=new Student(null,"张三",null);
        Course c1=new Course(null,"数据库");
        Course c2=new Course(null,"Java");
        List<Course> e=new ArrayList<>();
        e.add(c1);
        e.add(c2);
        student.setCourses(e);
        em.persist(student);
        transaction.commit();

查询测试：

  public static void main(String[] args) {
       EntityManagerFactory factory=Persistence.createEntityManagerFactory("MyJPA2");
       EntityManager em=factory.createEntityManager();
       Query query=em.createQuery("select student from Student student");
       System.out.println(query.getResultList());   }

• 查多端的

public static void main(String[] args) {
       EntityManagerFactory factory=Persistence.createEntityManagerFactory("MyJPA2");
       EntityManager em=factory.createEntityManager();
       Query query=em.createQuery("select course from Course course");
       System.out.println(query.getResultList());   }

10.1.6单向多对一/

1.单向一对多

10.1.7双向一对多/双向多对一

P193

从一方可以获取多方，从多方可以获取一方

@ManyToOne注解+@OneToMany注解的应用

• Student类：

@Table(name = "student")
@Entity(name = "Student")
public class Student implements Serializable {@Id@GeneratedValue@Column(name = "id")private Integer id;@Column(name = "name")private String name;@OneToMany(cascade = CascadeType.ALL,fetch = FetchType.EAGER)
    List<Course> courses;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 List<Course> getCourses() {return courses;}public void setCourses(List<Course> courses) {this.courses = courses;}public Student() {}public Student(Integer id, String name, List<Course> courses) {this.id = id;this.name = name;this.courses = courses;}@Overridepublic String toString() {return "Student{" +"id=" + id +", name='" + name + '\'' +", courses=" + courses +'}';}
}

• Course类

@Entity(name = "Course")
@Table(name = "course")
public class Course {
    @Id
    @GeneratedValue
    @Column(name = "id")
    private Integer id;
    @Column(name = "name")
    private String name;    @ManyToOne
    @JoinTable(name="sc",
            joinColumns={
                    @JoinColumn(name = "course_id", referencedColumnName = "id")}
            ,inverseJoinColumns = {
            @JoinColumn(name = "student_id", referencedColumnName = "id")
    })
     private Student student;}

10.1.8单向多对多

P196

• Student表

@Entity(name = "Student")
@Table(name = "student")
public class Student {
    @Id
    @GeneratedValue
    private Integer id;
    private String name;
    @ManyToMany(cascade = CascadeType.ALL,fetch = FetchType.EAGER)
    @JoinTable(name = "sc")
    private Collection<Course> course=new ArrayList();}

• course表：

@Entity(name = "theCourse")
@Table(name = "course")
public class Course {
    @Id
    @GeneratedValue
    private Integer id;
    private String name;

10.1.9双向多对多

P197

• Student

@Entity(name = "Student")
@Table(name = "student")
public class Student {
    @Id
    @GeneratedValue
    private Integer id;
    private String name;
    @ManyToMany(cascade = CascadeType.ALL,fetch = FetchType.EAGER)
    @JoinTable(name = "sc")
    private Collection<Course> courses=new ArrayList();

• Course

@Entity(name = "theCourse")
@Table(name = "course")
public class Course {
    @Id
    @GeneratedValue
    private Integer id;
    private String name;
    @ManyToMany(mappedBy = "courses",cascade = CascadeType.ALL)
    private Collection<Student> students;

10.1.10jpa单表的增删改查

• 目录

• 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.1"
             xmlns="http://xmlns.jcp.org/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
     http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
    <persistence-unit name="MyJPA" transaction-type="RESOURCE_LOCAL">
      <class>com.lxz.demo.entity.User</class>
        <properties>
            <!-- 标准配置方法，适用性高 -->
            <property name="javax.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/jdbc?useSSL=false&amp;serverTimezone=GMT"/>
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="root"/>            <!-- hibernate 的配置方法-->
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect" />
            <property name="hibernate.show_sql" value="true" />
            <property name="hibernate.hbm2ddl.auto" value="update"/> <!--create,create-drop,update,validate  -->        </properties>
    </persistence-unit>
</persistence>

• 实体类

@Table(name = "t_user")
@Entity(name = "User")
public class User implements Serializable {
    @Id
    @GeneratedValue(strategy =GenerationType.AUTO)
    private Integer id;
    @Column(name = "name",length = 50,unique = false,insertable = true,updatable = true,table = "t_user",nullable = true)
    private String name;    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 User() {
    }    public User(Integer id, String name) {
        this.id = id;
        this.name = name;
    }    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

• UserDao类

public class UserDao {
    public boolean add(User user){
        try {
            EntityManagerFactory factory = Persistence.createEntityManagerFactory("MyJPA");
            EntityManager em = factory.createEntityManager();
            EntityTransaction transaction = em.getTransaction();
            transaction.begin();
            em.persist(user);
            transaction.commit();
            em.close();
            factory.close();return true;}catch (Exception e){
            e.printStackTrace();return false;}}    public boolean update(User user){
        try {
            EntityManagerFactory factory = Persistence.createEntityManagerFactory("MyJPA");
            EntityManager em = factory.createEntityManager();
            EntityTransaction transaction = em.getTransaction();
            transaction.begin();
            em.merge(user);
            transaction.commit();
            em.close();
            factory.close();return true;}catch (Exception e){return false;}}
    public boolean delete(Integer id){
        try {
        EntityManagerFactory factory= Persistence.createEntityManagerFactory("MyJPA");
        EntityManager em=factory.createEntityManager();
        EntityTransaction transaction=em.getTransaction();
        transaction.begin();
        User user=new User();
        user=em.find(User.class,id);
        em.remove(user);
        transaction.commit();
        em.close();
        factory.close();return true;}catch (Exception e){return false;}}
    public User findById(Integer id){
        EntityManagerFactory factory= Persistence.createEntityManagerFactory("MyJPA");
        EntityManager em=factory.createEntityManager();
        EntityTransaction transaction=em.getTransaction();
        User user=em.find(User.class,id);
        em.close();
        factory.close();return user;}
    public List<User> findAll(){
        EntityManagerFactory factory= Persistence.createEntityManagerFactory("MyJPA");
        EntityManager em=factory.createEntityManager();
        EntityTransaction transaction=em.getTransaction();
        Query query =em.createQuery("select user from User user");
        List<User> users=query.getResultList();
        em.close();
        factory.close();return users;}
}

• 测试类

public class UserDaoTest {
    public static void main(String[] args) {
        UserDao userDao=new UserDao();
        System.out.println(userDao.add(new User(null,"add")));
        System.out.println(userDao.update(new User(2,"update")));
        System.out.println(userDao.delete(9));
        System.out.println(userDao.findAll());
        System.out.println(userDao.findById(2));
    }}