JPA多表映射

最新推荐文章于 2024-03-03 03:45:00 发布
最新推荐文章于 2024-03-03 03:45:00 发布
阅读量382 收藏
点赞数
分类专栏： 学习记录 文章标签： jpa hibernate object
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Afu1021/article/details/119007239
版权

JPA多表映射

一、单向多对一表映射

1.1、什么是单向一对多

就是多个学生有一个老师

1.2、使用JPA实现单向一对多

在学生类加一个老师对象，然后给老师对象

生成get,set方法加上@OneToMany ,@JoinColumn

1.3、@OneToMany,@JoinColumn

@OneToMany 表示一对多

@JoinColumn 设置外键名

package com.kuang.pojo;

import javax.persistence.*;

@Entity
@Table(name = "JPA_TEACHER")
public class Teacher {
    private Integer id;
    private Integer age;
    private String teachCourse;
    private String name;

    @Id
    @GeneratedValue
    public Integer getId() {
        return id;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Column(name = "TEACHER_COURSE")
    public String getTeachCourse() {
        return teachCourse;
    }

    public void setTeachCourse(String teachCourse) {
        this.teachCourse = teachCourse;
    }

    public String getName() {
        return name;
    }

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

package com.kuang.pojo;

import javax.persistence.*;

@Entity
@Table(name = "JPA_STUDENT")
public class Student {
    private Integer id;
    private String lastName;
    private Boolean sex;
    private Integer age;
    private Teacher teacher;


    @JoinColumn(name = "TEACHER_ID")
    @ManyToOne(fetch = FetchType.LAZY)
    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    @Id
    @GeneratedValue
    public Integer getId() {
        return id;
    }

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

    @Column(name = "LAST_NAME")
    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public Boolean getSex() {
        return sex;
    }

    public void setSex(Boolean sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

持久化对象，

@Test
public void testManyToOne(){

    Student student = new Student();
    student.setAge(12);
    student.setLastName("smallYellow");
    student.setSex(true);

    Student student1 = new Student();
    student1.setAge(18);
    student1.setLastName("smallGreen");
    student1.setSex(true);

    Teacher teacher = new Teacher();
    teacher.setAge(18);
    teacher.setTeachCourse("chinese");
    teacher.setName("ma");

    student.setTeacher(teacher);
    student1.setTeacher(teacher);

    entityManager.persist(teacher);
    entityManager.persist(student);
    entityManager.persist(student1);
}

@Test
public void ManyToOne(){
    Student student = entityManager.find(Student.class, 1);

    System.out.println(student.getLastName());

    System.out.println("-------------");
    System.out.println(student.getTeacher().getName());
}

二、单向一对多映射

2.1、什么是单向多对一

就是一个老师有多个学生

2.2、使用JPA实现单向一对多

在学生类加一个老师对象，然后给老师对象

生成get,set方法加上@OneToMany ,@JoinColumn

2.3、@OneToMany,@JoinColumn

@OneToMany 表示一对多

@JoinColumn name 设置外键名

2.4、cascade属性： 指定级联操作的行为(可多选)

1、CascadeType.PERSIST 级联新增（又称级联保存）：
获取A对象里也同时也重新获取最新的B时的对象。即会重新查询数据库里的最新数据，并且，只有A类新增时，会级联B对象新增。若B对象在数据库存（跟新）在则抛异常（让B变为持久态），对应EntityManager的presist方法,调用JPA规范中的persist()，不适用于Hibernate的save()方法

2、 CascadeType.MERGE 级联合并（又称级联更新）
指A类新增或者变化，会级联B对象（新增或者变化） ，对应EntityManager的merge方法，调用JPA规范中merge()时，不适用于Hibernate的update()方法

3、CascadeType.REMOVE 级联删除
只有A类删除时，会级联删除B类,即在设置的那一端进行删除时，另一端才会级联删除，对应EntityManager的remove方法，调用JPA规范中的remove()时，适用于Hibernate的delete()方法

4、CascadeType.REFRESH 级联刷新
获取order（一或多）对象里也同时也重新获取最新的items（多）的对象，对应EntityManager的refresh(object)，调用JPA规范中的refresh()时，适用于Hibernate的flush()方法

5、CascadeType.ALL
包含所有持久化方法

student 类

package com.kuang.pojo;

import javax.persistence.*;

@Entity
@Table(name = "JPA_STUDENT")
public class Student {
    private Integer id;
    private String lastName;
    private Boolean sex;
    private Integer age;
//    private Teacher teacher;
//
//
//    @JoinColumn(name = "TEACHER_ID")
//    @ManyToOne(fetch = FetchType.LAZY)
//    public Teacher getTeacher() {
//        return teacher;
//    }
//
//    public void setTeacher(Teacher teacher) {
//        this.teacher = teacher;
//    }

    @Id
    @GeneratedValue
    public Integer getId() {
        return id;
    }

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

    @Column(name = "LAST_NAME")
    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public Boolean getSex() {
        return sex;
    }

    public void setSex(Boolean sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

teacher类

package com.kuang.pojo;

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

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

    @OneToMany(cascade = {CascadeType.REMOVE})
    @JoinColumn(name = "Teacher_ID")
    public Set<Student> getStudents() {
        return students;
    }

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

    @Id
    @GeneratedValue
    public Integer getId() {
        return id;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Column(name = "TEACHER_COURSE")

    public String getTeachCourse() {
        return teachCourse;
    }

    public void setTeachCourse(String teachCourse) {
        this.teachCourse = teachCourse;
    }

    public String getName() {
        return name;
    }

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

持久化

package com.kuang.test;

import com.kuang.pojo.Student;
import com.kuang.pojo.Teacher;
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 TestOneToMany {
    private EntityManagerFactory entityManagerFactory;
    private EntityManager entityManager;
    private EntityTransaction transaction;

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

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

    @Test
    public void testPersistence() {
        Teacher teacher = new Teacher();
        teacher.setName("smailBlank");
        teacher.setTeachCourse("math");
        teacher.setAge(18);


        Student student = new Student();
        student.setSex(false);
        student.setLastName("BB");
        student.setAge(17);

        Student student1 = new Student();
        student1.setSex(true);
        student1.setLastName("cc");
        student1.setAge(37);
        teacher.getStudents().add(student);
        teacher.getStudents().add(student1);

        entityManager.persist(teacher);
        entityManager.persist(student);
        entityManager.persist(student1);

    }

    @Test
    public void testFind(){
        Teacher teacher = entityManager.find(Teacher.class, 1);

        System.out.println(teacher.getName());

        System.out.println(teacher.getStudents().size());
    }
}

三、双向一对多

3.1、什么是双向向一对多

就是一个老师有多个学生，对应的多个学生都有一个老师

3.2、使用JPA实现单向一对多

在学生类加一个老师对象，然后给老师对象加多个学生

生成get,set方法加上@OneToMany ,@JoinColumn ，@ManyToOne

3.3、@OneToMany,@JoinColumn

@OneToMany 表示一对多

@JoinColumn name 设置外键名

学生类

package com.kuang.pojo;

import javax.persistence.*;

@Entity
@Table(name = "JPA_STUDENT")
public class Student {
    private Integer id;
    private String lastName;
    private Boolean sex;
    private Integer age;
    private Teacher teacher;


    @JoinColumn(name = "TEACHER_ID")
    @ManyToOne(fetch = FetchType.LAZY)
    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    @Id
    @GeneratedValue
    public Integer getId() {
        return id;
    }

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

    @Column(name = "LAST_NAME")
    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public Boolean getSex() {
        return sex;
    }

    public void setSex(Boolean sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

老师类

package com.kuang.pojo;

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

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

    @OneToMany(cascade = {CascadeType.REMOVE},mappedBy = "teacher")
//    @JoinColumn(name = "Teacher_ID")
    public Set<Student> getStudents() {
        return students;
    }

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

    @Id
    @GeneratedValue
    public Integer getId() {
        return id;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Column(name = "TEACHER_COURSE")

    public String getTeachCourse() {
        return teachCourse;
    }

    public void setTeachCourse(String teachCourse) {
        this.teachCourse = teachCourse;
    }

    public String getName() {
        return name;
    }

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

测试

package com.kuang.test;

import com.kuang.pojo.Student;
import com.kuang.pojo.Teacher;
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 TestOneToManyAndManyToOne {

    private EntityManagerFactory entityManagerFactory;
    private EntityManager entityManager;
    private EntityTransaction transaction;

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

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

    @Test
    public void test(){
        Teacher teacher = new Teacher();
        teacher.setName("smailBlank");
        teacher.setTeachCourse("math");
        teacher.setAge(18);


        Student student = new Student();
        student.setSex(false);
        student.setLastName("BB");
        student.setAge(17);

        Student student1 = new Student();
        student1.setSex(true);
        student1.setLastName("cc");
        student1.setAge(37);
        teacher.getStudents().add(student);
        teacher.getStudents().add(student1);

        entityManager.persist(teacher);
        entityManager.persist(student);
        entityManager.persist(student1);
    }
}

四、双向一对一

4.1、什么是双向向一对一

就是一个班级有一个班长，一个班长都有一个班级

4.2、使用JPA实现单向一对多

在班级类加一个班长对象，然后给班长对象加班级对象

生成get,set方法加上@OneToOne ,@JoinColumn ，@OneToOne

4.3、@OneToOne,@JoinColumn

@OneToOne 表示一对一

@JoinColumn name 设置外键名

4.4、注意事项

双向映射需要加@mappedBy()给那个不需要维护双向关系

班级类

package com.kuang.pojo;

import javax.persistence.*;

@Entity
@Table(name = "JPA_CLASS")
public class _Class {
    private Integer id;
    private String name;
    private int grade;
    private ClassMonitor classMonitor;

    @Id
    @GeneratedValue
    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 int getGrade() {
        return grade;
    }

    public void setGrade(int grade) {
        this.grade = grade;
    }

    @OneToOne(mappedBy = "_class")
    public ClassMonitor getClassMonitor() {
        return classMonitor;
    }

    public void setClassMonitor(ClassMonitor classMonitor) {
        this.classMonitor = classMonitor;
    }
}

班长类

package com.kuang.pojo;

import javax.persistence.*;

@Entity
@Table(name = "JPA_CLASS_MONITOR")
public class ClassMonitor {
    private Integer id;
    private String name;
    private Integer age;
    private _Class _class;

    @Id
    @GeneratedValue
    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 Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @OneToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "CLASS_ID",unique = true)
    public _Class get_class() {
        return _class;
    }

    public void set_class(_Class _class) {
        this._class = _class;
    }
}

测试

package com.kuang.test;


import com.kuang.pojo.ClassMonitor;
import com.kuang.pojo._Class;
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 TestOneToOne {

    private EntityManagerFactory entityManagerFactory;
    private EntityManager entityManager;
    private EntityTransaction transaction;

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

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

    @Test
    public void testFInd(){
        _Class aClass = entityManager.find(_Class.class, 1);
        System.out.println(aClass.getName());
        System.out.println(aClass.getClassMonitor().getName());
    }

    @Test
    public void testPersistence(){
        _Class aClass = new _Class();
        aClass.setGrade(3);
        aClass.setName("C-AA");
        _Class aClass1 = new _Class();
        aClass.setGrade(1);
        aClass.setName("C-BB");

        ClassMonitor classMonitor = new ClassMonitor();
        classMonitor.setAge(12);
        classMonitor.setName("m-aa");

        ClassMonitor classMonitor1 = new ClassMonitor();
        classMonitor1.setAge(18);
        classMonitor1.setName("m-BB");

        aClass.setClassMonitor(classMonitor);





        classMonitor.set_class(aClass);


;

        entityManager.persist(aClass);

        entityManager.persist(classMonitor);

    }

}

五、双向多对多

4.1、什么是双向向多对多

就是一个班级有一个班长，一个班长都有一个班级

4.2、使用JPA实现单向多对多

在班级类加一个班长对象，然后给班长对象加班级对象

生成get,set方法加上@ManyToMany ,@JoinTable

4.3、@ManyToMany,@JoinColumn

@OneToOne 表示一对一

@JoinTable name 设置之间表

/**
 * 使用@ManyTOMany 注解映射多对多关联关系
 * 使用 @JOin Table 来映射中间表
 * 1、name  指向中间表的名字
 * 2、joinColumn 映射当前的所在的表的中间表的外键
 * 2.1 name 指定外键列的列名
 * 2.2 referencedCOlumnName 指定列关联当前表的那一列
 * 2.3 inverseJoinColumns 映射关联的类所在中间表的外键
 * 3.inve
 */

4.4、注意事项

双向映射需要加@mappedBy()给那个对象不需要维护双向关系

物品类

package com.kuang.pojo;

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

@Entity
@Table(name = "JPA_ITEM")
public class Item {
    private Integer id;
    private String name;
    private Set<Category> categories=new HashSet<>();

    @Id
    @GeneratedValue
    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 = "items")
    public Set<Category> getCategories() {
        return categories;
    }

    public void setCategories(Set<Category> categories) {
        this.categories = categories;
    }
}

种类

package com.kuang.pojo;

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

@Entity
@Table(name = "JPA_CATEGERY")
public class Category {
    private Integer id;
    private String name;
    private Set<Item> items=new HashSet<>();

    @Id
    @GeneratedValue
    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;
    }


    @JoinTable(name = "JPA_ITEMS_CATEGORY",
             joinColumns = {@JoinColumn(name = "ITEM_ID",referencedColumnName = "ID")}
             ,inverseJoinColumns = {@JoinColumn(name = "CATEGORY",referencedColumnName = "ID")})
    @ManyToMany
    public Set<Item> getItems() {
        return items;
    }

    public void setItems(Set<Item> items) {
        this.items = items;
    }
}

package com.kuang.test;

import com.kuang.pojo.Category;
import com.kuang.pojo.Item;
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 TestManyToMany {
    private EntityManagerFactory entityManagerFactory;
    private EntityManager entityManager;
    private EntityTransaction transaction;

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

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

    @Test
    public void find(){
        Category category = entityManager.find(Category.class, 1);

        System.out.println(category.getName());

        System.out.println(category.getItems().size());



    }

    @Test
    public void persitence(){
        Category category = new Category();
        category.setName("苹果");

        Category category1 = new Category();
        category1.setName("小米");

        Item item = new Item();
        item.setName("ipone10");

        Item item1 = new Item();
        item1.setName("Mi11x");

        category.getItems().add(item);
        category.getItems().add(item1);

        category1.getItems().add(item);
        category1.getItems().add(item1);

        item.getCategories().add(category);
        item.getCategories().add(category1);

        item1.getCategories().add(category);
        item1.getCategories().add(category1);

        entityManager.persist(item);
        entityManager.persist(item1);
        entityManager.persist(category);
        entityManager.persist(category1);
    }
}
阿福66
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
jpa的实体映射关系7种
02-23
单向一对一 双向一对一 单向一对多 双向一对多 双向多对一 单向多对多 双向多对多
Spring data jpa怎么配置一个实体类映射两张数据库表
热门推荐
ytzzh0726的博客
04-08 1万+
今天写一个Spring boot集成Spring data jpa实现一些简单功能的技术验证项目，其中一个Model类Wel映射了“T_PM_WELL”表，但有一个属性"sname"需要映射到第二张表“T_PM_NODE”上，开始时用@Formula注解来实现，但运行时总是会报错，百度了很久也没解决，后来下了jpa的文档，发现了"@SecondaryTable"注解正适合我的场景下使用，而@For
【Mybatis】多表映射 第二期
最新发布
Orion
03-03 1357
mybatis-config.xml 全局设置 settingsetting属性属性含义可选值默认值指定 MyBatis 应如何自动映射列到字段或属性。NONE 表示关闭自动映射；PARTIAL 只会自动映射没有定义嵌套结果映射的字段。FULL 会自动映射任何复杂的结果集（无论是否嵌套）。PARTIAL--开启resultMap自动映射--> < setting name = " autoMappingBehavior " value = " FULL " />
2、可能是目前最好理解的spring-data-jpa对象关联多表查询+分页
yandype的博客
06-13 1305
1、确定两个表之间的关系 1.1、r_menu 菜单表 关系：菜单表和报表是一对多关系 1.2、r_report 报表 关系：报表和菜单表是多对一关系 2、配置出实体类和数据库表的关系映射 2.1、菜单表对象实体： packagecom.tc.report.dataobject; importjavax.persistence.Entity; importja...
JPA单向一对多实体映射
qq_35627316的博客
02-20 181
1、建表 # one的一方，种类表 create table t_category ( id varchar(64) not null primary key, name varchar(50) null ) charset = utf8; # many的一方， 水果表 create table t_fruit ( id v...
Spring JPA 实现多个类对应一张表（组件式）
ZJKJTL的博客
04-28 335
由于数据库以数据为维度进行存储，由于设计不合理或其他原因，转换为业务逻辑时需要将该表映射为两个类。
@DiscriminatorColumn @DiscriminatorValue注解，jpa多个entity对应一张表
xiaowanziwuha的专栏
01-02 1517
Table Columns: id, product_name, type, entity1,entity2 以type字段为区别,@DiscriminatorValue(name="baseType") baseType对应BaseEntity, 保存或查询时type="baseType". Entity1和Entity2和保存或查询时type="entity1Type"和type="en...
JPA单向多对多实体映射
qq_35627316的博客
02-20 164
知识点梳理： a、注解配置时使用@JoinTable配置中间表，joinColumns配置当前类对应的主键ID，inverseJoinColumn反向配置对应的表主键ID b、建表时，中间表配置双主键、双外键 1、建表 # 单向多对多 create table sys_role( id varchar(64) primary key ,name varchar(50)...
jpa 跨表_在JPA中将多个表映射到单个实体
weixin_31095703的博客
01-14 139
我正在尝试学习JPA / Hibernate，我在这个领域真的很绿 . 我倾向于在不了解API的情况下转向并尝试一些事情 . 所以我决定创建一个从多个表中检索信息的简单实体，这可以通过JPA轻松实现 . 这背后的原因是，如果假设，涉及的表每个都有几百列，我们只需要检索很少的数据，我们只需要关注检索而不是插入/更新/删除，我会假设最好只检索整个实体(特别是如果需要返回多行)，然后将它们连接到其他实体...
Jpa实体映射
qq_43054241的博客
09-27 236
首先分析实体间关联关系 1:@OneToOne 2:@OneToMany @ManyToOne 3:@ManyToMany 实体之间进行关联的时候 只能One端操作Many端 代码层面则是cascade = CascadeType.All 只能写在One端 One端删除，修改可以影响到Many端。反过来不行。 一、@OneToOne关系映射 一个人有一个地址，就是一对一关系。其中peo...
JPA-4 映射关联关系
04-08
映射单向多对一、单向一对多、双向一对一、双向多对一和双向多对多关联关系的具体实现
JPA一对一，一对多，多对多关系映射
05-14
JPA一对一，一对多，多对多关系映射，面向对象领域
第二部分、JPA操作多表映射.rar
03-05
Spring MVC全注解实战开发大型商业ERP项目 是java web 开发学习的较好参照，本源码说明共八部分，为持续更新中。本次为第二部分。
使用jpa映射关联和继承
05-06
使用jpa映射关联和继承
Spring Data JPA中的一对多表的操作（3）
weixin_42030357的博客
06-29 519
级联操作：指操作一个对象同时操作它的关联对象 在实际开发中，级联删除请慎用！(在一对多的情况下) 多表操作中的一对多： 1.对于数据库中表的建立 外键在《多》的一方进行建立 /*创建客户表*/ CREATE TABLE cst_customer ( ... PRIMARY KEY (`cust_id`) } /*创建联系人表*/ CREATE TABLE cst_linkman ( ... ...
hibernate中两个实体类与同一张数据表进行映射后出现的问题解决
dmm1982的专栏
04-11 4540
        最近项目中遇到了一个子系统需要整合到它的父系统的问题，由于父系统和子系统的工程比较庞大 ，涉及到的class也是相当的多。最后不得已将其中比较关键的class对应的数据表进行了统一。那么就需要两个实体类映射到同一张数据表中。这两个实体类之间进行了继承（sobject   extends  fobject）。本以为这样就万事大吉了，可是没想到，在对其模块进行检索的时候问题出现了，其中
Spring Boot 入门系列（二十八） JPA 的实体映射关系，一对一，一对多，多对多关系映射！...
章为忠的专栏
09-15 2463
前面讲了Spring Boot 使用 JPA，实现JPA的增、删、改、查的功能，同时也介绍了JPA的一些查询，自定义SQL查询等使用。JPA使用非常简单，功能非常强大的ORM框架，无需任何数据访问层和sql语句即可实现完整的数据操作方法。但是，之前都是介绍的单表的增删改查等操作，多表多实体的数据操作怎么实现呢？接下来聊一聊JPA 的一对一，一对多，多对一，多对多等实体映射关系。 一、常用注解...
多表操作，实现数据的映射
m0_71026716的博客
08-17 738
多表操作
springjpa 不做映射注解
07-27
对于Spring JPA，如果不使用任何映射注解，默认情况下，它会按照约定进行实体类与数据库表之间的映射。这意味着实体类的名称将与数据库表的名称对应，实体类的属性将与数据库表的列名对应。 然而，如果你想自定义...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值