SpringData JPA 多表关联操作 （四）

最新推荐文章于 2023-02-06 10:12:32 发布
最新推荐文章于 2023-02-06 10:12:32 发布
阅读量1.2k 收藏 7
点赞数 2
分类专栏： SpringData springboot 文章标签： 数据库 hibernate sql spring boot 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50909707/article/details/126985973
版权

目录

一、一对一关联

1、实体类

 2、数据操作层

3、测试

二、一对多

1、实体类

2、数据操作层

3、测试

三、多对一

1、实体类

2、数据操作层

3、测试

四、多对多

1、实体类

2、数据操作层

3、测试

本章节在案例（二）的基础上进行

一、一对一关联

1、实体类

主表：

package com.dragonwu.entity;


import javax.persistence.CascadeType;
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.OneToOne;
import javax.persistence.Table;

/**
 * @author DragonWu
 * @date 2022-09-20 11:17
 **/
@Entity //作为hibernate的实体类
@Table(name="tb_customer")//映射的表名
public class Customer {

    /**
     * @Id 主键声明
     * @GeneratedValue: 配置主键的生成策略
     *      strategy
     *          GenerationType.IDENTITY: 自增，mysql
     *              *底层数据库必须支持自动增长
     *          GenerationType.SEQUENCE: 序列oracle
     *              *底层数据库必须支持序列
     *          GenerationType.TABLE: jpa提供的一种机制，通过一张数据库表的形式帮助我们完成主键
     *          GenerationType.AUTO: 由程序自动地帮助我们选择主键生成策略
     * @Cloumn 配置属性和表字段的映射关系
     *      name: 数据库表中字段的名称
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="id",length = 20)
    private Long id;

    @Column(name="cus_name",columnDefinition = "varchar(32) default null comment '客户名'")
    private String name;//客户名

    @Column(name="cus_address",length = 200)
    private String address;//客户地址

    //单向关联 一对一
    /**
     * cascade 设置关联操作
     *  ALL 所有持久化操作
     *  PERSIST  只有插入才会执行关联操作
     *  MERGE   只有修改才会执行关联操作
     *  REMOVE   只有删除才会执行关联操作
     *
     *  fetch 设置是否懒加载
     *  默认 EAGER 立即加载
     *      LAZY 懒加载（直到用到对象才会进行查询，因为不是所有的关联对象，都需要用到）
     *
     *  orphanRemoval 关联移除 （通常在修改的时候会用到）
     *      一旦吧关联的数据设置null,或者修改为其他的关联数据，
     *      如果想删除关联数据，就可以设置true
     *
     *  optional 用来限制关联对象不能为null
     *      默认为true  可以为null
     *      false 不能为null
     */
    @OneToOne(cascade = CascadeType.ALL,fetch = FetchType.LAZY,orphanRemoval = true,optional = true)
    //设置外键字段名
    @JoinColumn(name="account_id")
    private Account account;

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public Account getAccount() {
        return account;
    }

    public void setAccount(Account account) {
        this.account = account;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", address='" + address + '\'' +
                ", account=" + account +
                '}';
    }
}

从表：

package com.dragonwu.entity;

import lombok.Data;

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

/**
 * @author DragonWu
 * @date 2022-09-23 10:28
 **/
@Entity
@Table(name = "tb_account")
@Data
public class Account {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(length = 32)
    private String username;

    @Column(length = 32)
    private String password;

    public Long getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

这里的重点就是配置外键属性：

 2、数据操作层

package com.dragonwu.repositories;

import com.dragonwu.entity.Customer;
import org.springframework.data.repository.CrudRepository;

/**
 * @author DragonWu
 * @date 2022-09-21 10:33
 **/
public interface CustomerRepository extends CrudRepository<Customer,Long>{

}

3、测试

package com.dragonwu;

import com.dragonwu.entity.Account;
import com.dragonwu.entity.Customer;
import com.dragonwu.repositories.CustomerRepository;
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 org.springframework.transaction.annotation.Transactional;

import java.util.Optional;

/**
 * @author DragonWu
 * @date 2022-09-23 10:39
 **/
@SpringBootTest(classes = App.class)
@RunWith(SpringRunner.class)
public class OneToOneTest {

    @Autowired
    private CustomerRepository customerRepository;

    //插入
    @Test
    public void testC(){
        //初始化数据
        Account account=new Account();
        account.setUsername("DragonWu");
        account.setPassword("123456");

        Customer customer = new Customer();
        customer.setAccount(account);
        customer.setName("龘龘");

        customerRepository.save(customer);
    }
    //懒加载查询
    @Test
    //为什么懒加载要配置事务
    //当通过repository调用完查询方法，session就会立即关闭，一旦session关闭你就不能查询
    //加了事务后，就能让session直到事务方法执行完毕后才会关闭
    @Transactional(readOnly = true)
    public void testR_lazy(){
        Optional<Customer> customer = customerRepository.findById(12L);//只查询出客户表，session关闭
        System.out.println("===================");
        System.out.println(customer.get());//toString
    }

    //删除
    @Test
    public void testD(){
        customerRepository.deleteById(12L);//当开启删除同时操作从表时，外键表对应的数据也会被删除
    }

    //更新
    @Test
    public void testU(){
        Customer customer = new Customer();
        customer.setId(12L);
        customer.setName("Dragon");
        customer.setAccount(null);
        customerRepository.save(customer);
    }
}

新增运行后我们可以看到，自动生成表并插入数据如下

二、一对多

1、实体类

主表：

package com.dragonwu.entity;


import javax.persistence.CascadeType;
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.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.Table;
import java.util.List;

/**
 * @author DragonWu
 * @date 2022-09-20 11:17
 **/
@Entity //作为hibernate的实体类
@Table(name="tb_customer")//映射的表名
public class Customer {

    /**
     * @Id 主键声明
     * @GeneratedValue: 配置主键的生成策略
     *      strategy
     *          GenerationType.IDENTITY: 自增，mysql
     *              *底层数据库必须支持自动增长
     *          GenerationType.SEQUENCE: 序列oracle
     *              *底层数据库必须支持序列
     *          GenerationType.TABLE: jpa提供的一种机制，通过一张数据库表的形式帮助我们完成主键
     *          GenerationType.AUTO: 由程序自动地帮助我们选择主键生成策略
     * @Cloumn 配置属性和表字段的映射关系
     *      name: 数据库表中字段的名称
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="id",length = 20)
    private Long id;

    @Column(name="cus_name",columnDefinition = "varchar(32) default null comment '客户名'")
    private String name;//客户名

    @Column(name="cus_address",length = 200)
    private String address;//客户地址

    //单向关联 一对一
    /**
     * cascade 设置关联操作
     *  ALL 所有持久化操作
     *  PERSIST  只有插入才会执行关联操作
     *  MERGE   只有修改才会执行关联操作
     *  REMOVE   只有删除才会执行关联操作
     *
     *  fetch 设置是否懒加载
     *  默认 EAGER 立即加载
     *      LAZY 懒加载（直到用到对象才会进行查询，因为不是所有的关联对象，都需要用到）
     *
     *  orphanRemoval 关联移除 （通常在修改的时候会用到）
     *      一旦吧关联的数据设置null,或者修改为其他的关联数据，
     *      如果想删除关联数据，就可以设置true
     *
     *  optional 用来限制关联对象不能为null
     *      默认为true  可以为null
     *      false 不能为null
     */
    @OneToOne(cascade = CascadeType.ALL,fetch = FetchType.LAZY,orphanRemoval = true,optional = true)
    //设置外键字段名
    @JoinColumn(name="account_id")
    private Account account;

    //一对多
    @OneToMany(cascade = CascadeType.ALL)
    @JoinColumn(name="customer_id")
    private List<Message> messages;

    public List<Message> getMessages() {
        return messages;
    }

    public void setMessages(List<Message> messages) {
        this.messages = messages;
    }

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public Account getAccount() {
        return account;
    }

    public void setAccount(Account account) {
        this.account = account;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", address='" + address + '\'' +
                ", account=" + account +
                '}';
    }
}

从表：

package com.dragonwu.entity;

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

/**
 * @author DragonWu
 * @date 2022-09-23 17:53
 **/
@Entity
@Table(name="tb_message")
public class Message {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(length = 255)
    private String info;

    public Long getId() {
        return id;
    }

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

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }

    public Message(String info) {
        this.info = info;
    }

    public Message() {
    }
}

与一对一类似，不过特殊的是从表的外键写到了主表的类里了。其他属性参考一对一。 

2、数据操作层

依然为之前数据操作层的代码

3、测试

package com.dragonwu;

import com.dragonwu.entity.Customer;
import com.dragonwu.entity.Message;
import com.dragonwu.repositories.CustomerRepository;
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 org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

/**
 * @author DragonWu
 * @date 2022-09-23 18:01
 **/
@SpringBootTest(classes = App.class)
@RunWith(SpringRunner.class)
public class OneToManyTest {

    @Autowired
    private CustomerRepository customerRepository;

    //插入
    @Test
    public void testC(){
        List<Message> messageList=new ArrayList<>();
        messageList.add(new Message("test1"));
        messageList.add(new Message("test2"));
        messageList.add(new Message("test3"));

        Customer customer = new Customer();
        customer.setName("龘龘");
        customer.setMessages(messageList);

        customerRepository.save(customer);
    }

    @Test
    @Transactional(readOnly = true)//多对多时默认为懒加载，必须要加事务
    public void testR(){
        Optional<Customer> byId = customerRepository.findById(15L);
        System.out.println("====================");
        System.out.println(byId);
    }

}

可以看到数据已经创建成功：

三、多对一

对应一对多的写法，我们写可以单独写多对一的注解来声明。

但对于性能来说，我们应该首选多对一。

1、实体类

package com.dragonwu.entity;

import javax.persistence.CascadeType;
import javax.persistence.Column;
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;

/**
 * @author DragonWu
 * @date 2022-09-23 17:53
 **/
@Entity
@Table(name="tb_message")
public class Message {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(length = 255)
    private String info;

    //多对一
    @ManyToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "customer_id")
    private Customer customer;

    public Customer getCustomer() {
        return customer;
    }

    public Message(String info, Customer customer) {
        this.info = info;
        this.customer = customer;
    }

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

    public Long getId() {
        return id;
    }

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

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }

    public Message(String info) {
        this.info = info;
    }

    public Message() {
    }
}

2、数据操作层

package com.dragonwu.repositories;

import com.dragonwu.entity.Message;
import org.springframework.data.repository.CrudRepository;

/**
 * @author DragonWu
 * @date 2022-09-23 18:37
 **/
public interface MessageRepository extends CrudRepository<Message, Long> {
}

3、测试

package com.dragonwu;

import com.dragonwu.entity.Customer;
import com.dragonwu.entity.Message;
import com.dragonwu.repositories.MessageRepository;
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.ArrayList;
import java.util.List;

/**
 * @author DragonWu
 * @date 2022-09-23 18:40
 **/
@SpringBootTest(classes = App.class)
@RunWith(SpringRunner.class)
public class ManyToOneTest {

    @Autowired
    private MessageRepository repository;

    @Test
    public void testC(){
        //一
        Customer customer = new Customer();
        customer.setName("Jack");

        //多
        List<Message> list=new ArrayList<>();
        list.add(new Message("你哈",customer));
        list.add(new Message("hello",customer));

        repository.saveAll(list);
    }
}

四、多对多

1、实体类

客户表：

package com.dragonwu.entity;


import javax.persistence.CascadeType;
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.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.Table;
import java.util.List;

/**
 * @author DragonWu
 * @date 2022-09-20 11:17
 **/
@Entity //作为hibernate的实体类
@Table(name="tb_customer")//映射的表名
public class Customer {

    /**
     * @Id 主键声明
     * @GeneratedValue: 配置主键的生成策略
     *      strategy
     *          GenerationType.IDENTITY: 自增，mysql
     *              *底层数据库必须支持自动增长
     *          GenerationType.SEQUENCE: 序列oracle
     *              *底层数据库必须支持序列
     *          GenerationType.TABLE: jpa提供的一种机制，通过一张数据库表的形式帮助我们完成主键
     *          GenerationType.AUTO: 由程序自动地帮助我们选择主键生成策略
     * @Cloumn 配置属性和表字段的映射关系
     *      name: 数据库表中字段的名称
     */
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="id",length = 20)
    private Long id;

    @Column(name="cus_name",columnDefinition = "varchar(32) default null comment '客户名'")
    private String name;//客户名

    @Column(name="cus_address",length = 200)
    private String address;//客户地址

    //单向关联 一对一
    /**
     * cascade 设置关联操作
     *  ALL 所有持久化操作
     *  PERSIST  只有插入才会执行关联操作
     *  MERGE   只有修改才会执行关联操作
     *  REMOVE   只有删除才会执行关联操作
     *
     *  fetch 设置是否懒加载
     *  默认 EAGER 立即加载
     *      LAZY 懒加载（直到用到对象才会进行查询，因为不是所有的关联对象，都需要用到）
     *
     *  orphanRemoval 关联移除 （通常在修改的时候会用到）
     *      一旦吧关联的数据设置null,或者修改为其他的关联数据，
     *      如果想删除关联数据，就可以设置true
     *
     *  optional 用来限制关联对象不能为null
     *      默认为true  可以为null
     *      false 不能为null
     */
    @OneToOne(cascade = CascadeType.ALL,fetch = FetchType.LAZY,orphanRemoval = true,optional = true)
    //设置外键字段名
    @JoinColumn(name="account_id")
    private Account account;

    //一对多
    @OneToMany(cascade = CascadeType.ALL)
    @JoinColumn(name="customer_id")
    private List<Message> messages;

    //单向多对多
    @ManyToMany(cascade = CascadeType.ALL)
    //中间表需要通过JoinTable来维护外键：（不设置也会自动生成）
    /*
    name 指定中间表名称
    joinColumns  设置本表的外键名称
    inverseJoinColumns   设置关联表的外键名称
     */
    @JoinTable(
            name = "tb_customer_role_relation",  //中间表的名字
            joinColumns = {@JoinColumn(name="c_id")}, //关联的外键
            inverseJoinColumns = {@JoinColumn(name = "r_id")}//关联表对应的外键
    )
    private List<Role> roles;

    public List<Role> getRoles() {
        return roles;
    }

    public void setRoles(List<Role> roles) {
        this.roles = roles;
    }

    public List<Message> getMessages() {
        return messages;
    }

    public void setMessages(List<Message> messages) {
        this.messages = messages;
    }

    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public Account getAccount() {
        return account;
    }

    public void setAccount(Account account) {
        this.account = account;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", address='" + address + '\'' +
                ", account=" + account +
                '}';
    }
}

权限表：

package com.dragonwu.entity;

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

/**
 * @author DragonWu
 * @date 2022-09-24 9:40
 **/
@Entity
@Table(name = "tb_role")
public class Role {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "role_name",length = 32)
    private String rName;

    public Role() {
    }

    public Long getId() {
        return id;
    }

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

    public String getrName() {
        return rName;
    }

    public void setrName(String rName) {
        this.rName = rName;
    }

    public Role(String rName) {
        this.rName = rName;
    }

    @Override
    public String toString() {
        return "Role{" +
                "id=" + id +
                ", rName='" + rName + '\'' +
                '}';
    }
}

2、数据操作层

依然使用之前的

3、测试

package com.dragonwu;

import com.dragonwu.entity.Customer;
import com.dragonwu.entity.Role;
import com.dragonwu.repositories.CustomerRepository;
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.annotation.Commit;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

/**
 * @author DragonWu
 * @date 2022-09-24 9:50
 **/
@SpringBootTest(classes = App.class)
@RunWith(SpringRunner.class)
public class ManyToMany {

    @Autowired
    private CustomerRepository customerRepository;

    @Test
    //保存
    public void testC() {
        List<Role> roles = new ArrayList<>();
        roles.add(new Role("超级管理员"));
        roles.add(new Role("商品管理员"));

        Customer customer = new Customer();
        customer.setName("Jack船长");
        customer.setRoles(roles);

        customerRepository.save(customer);
    }

    @Test
    @Transactional(readOnly = true)
    public void testR(){
        System.out.println(customerRepository.findById(20L));
    }

    /**
     * 注意加上
     * @Transactional
     * 若为单元测试还需加上@Commit注解
     *
     * 多对多其实不适合删除，因为经常出现数据可能会引用另一端
     * 此时删除就会出现异常
     * 要删除需要保证数据没有其他关联
     */
    @Test
    @Transactional
    @Commit
    public void testD(){
        Optional<Customer> byId = customerRepository.findById(18L);
        customerRepository.delete(byId.get());
    }
}
Dragon Wu
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringDataJPA实例
07-19
《你真的了解Jpa吗？》案例代码，内有SpringBootJPA的入门例子，包括增删改查一级实体关联关系处理。
SpringBoot Data JPA 关联表查询的方法
08-27
主要介绍了SpringBoot Data JPA 关联表查询的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring Data JPA的优点和难点.pdf
12-05
1. 开发效率极⾼： 2. 成熟的语法结构： 3. 与Spring全家桶结合紧密： 4. 成熟的框架和架构 常⻅的SQL性能问题，如何优雅处理? 2. 错综复杂的关联关系如何应对？ 3. 万恶的LazyException本质是什么？ 4. ⾼并发⾼性能要求的API服务要⽤JPA吗？
Spring Data JPA 实现多表关联查询的示例代码
08-27
多表查询在spring data jpa中有两种实现方式，第一种是利用hibernate的级联查询来实现，第二种是创建一个结果集的接口来接收连表查询后的结果，这里介绍第二种方式，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring Data Jpa – 获得实体类部分字段（单表或多表）
01-19
一、单表查询的一个字段、一条数据 @Query(value = select username from user,nativeQuery = true) // 注意返回值用String类型接收，也可以使用Object String findOneUserName(); 二、单表查询的一个字段、多条数据 @Query(value = select distinct username from user,nativeQuery = true) // 注意返回值用String类型接收，也可以使用Object List findAllUserName(); 三、多表查询的多个字段、一条数
Spring Data JPA多表操作(5)
weixin_39248420的博客
12-01 710
Spring Data JPA多表操作(5) 数据库中多表之间的关系 多对多 一对多 一对一 数据库设计示例 实体示例 客户：指的是一家公司，我们记为A。 联系人：指的是A公司中的员工。 在不考虑兼职的情况下，公司和员工的关系即为一对多。 表设计示例 实体类关系设计 客户（公司）类（一） @Entity//表示当前类是一个实体类 @Table(name="cst_custom...
import javax.persistence.Entity；报错，手动添加包
qq_45793102的博客
03-19 1840
1.下载包 import javax.persistence.Entity;导入报错，是因为缺少了一个ejb3-persistence.jar包 所以要下载一个包  http://pan.baidu.com/s/1jGmklMm 2.添加包 以Idea为例 1.打开 File -> Project Structure （Ctrl + Shift + Alt + ...
JPA的多表关联
qq_36750461的博客
10-08 700
前言：JPA的多表查询分为，一对一，一对多，多对多，这之间又可分为单向和双向，本篇文章写了两种方式，一对一和多对一（双向） 数据库结构人员表（id（主键），zhiyeid（职业表的外键），name（姓名））。职业表（id（主键），gongzuo（职业）） 每个人员有一个职业，每个职业有多个人员 1.一对一 人员实体类： package cn.wiztek.wiztekDemo.enti...
import javax.persistence.Entity;报错，手动添加包
羞羞滴小朋友
04-03 4129
1.下载包 import javax.persistence.Entity;导入报错，是因为缺少了一个ejb3-persistence.jar包 所以要下载一个包http://pan.baidu.com/s/1jGmklMm 2.添加包 以Idea为例 1.打开 File -> Project Structure （Ctrl + Shift + Alt + S） 2.先择添加...
import javax.persistence.Entity; 与import org.hibernate.annotations.Entity; 在Spring注解中
li153069252的专栏
06-12 1005
今天犯了一个错误。 在写实体类的时候@Entity注解Myeclipse将自动导为import org.hibernate.annotations.Entity;  结果在测试的时候一直报这个实体类not Mapping  ，我就纠结了， 1、 com.xxx.model 我写了， 2、Spring注解我也打开了 3、HQL语句是实体类名称不是表名 结果到处询问，一
SpringData Jpa（三）：多表关联的操作
菜鸡也有大佬梦
11-26 5170
多表操作 在实际开发中，数据库的表难免会有相互的关联关系，在操作表的时候就有可能会涉及到多张表的操作。 而在这种实现了ORM思想的框架中（如 JPA），可以通过操作实体类就实现对数据库表的操作。 配置实体之间的关联关系 第一步：首先确定两张表之间的关系 第二步：在实体类中描述出两个实体的关系 第三步：配置出实体类和数据库表的关系映射（重点） 一对一关系 通过唯一的外键关联 1.数据准备：...
Spring Data JPA实现多表的关联查询
pan_junbiao的博客
04-05 1万+
1、Spring Data JPA关系映射 对象关系映射（Object relational mapping）是指通过将对象状态映射到数据库列，来开发和维护对象和关系数据库之间的关系。它能够轻松处理（执行）各种数据库操作，如插入、更新、删除等。 关系映射的注解： 注解 说明 @JoinColumn 指定一个实体组织或实体集合。用在“多对一”和“一对多”的关联中。 @One...
JPA中的多对多
qq_42836176的博客
12-05 1766
4.1 示例分析 我们采用的示例为用户和角色。 用户：指的是咱们班的每一个同学。 角色：指的是咱们班同学的身份信息。 比如A同学，它是我的学生，其中有个身份就是学生，还是家里的孩子，那么他还有个身份是子女。 同时B同学，它也具有学生和子女的身份。 那么任何一个同学都可能具有多个身份。同时学生这个身份可以被多个同学所具有。 所以我们说，用户和角色之间的关系是多对多。 4.2 表关系建立 多对多的表关...
【Spring Data JPA 系列】07、多表关联操作
BASK2311的博客
02-06 568
方便我们的开发，导入lombok！
import javax.persistence.Entity;
热门推荐
07-20 2万+
 import javax.persistence.Entity;导入报错，是因为缺少了一个jar包
Spring Data JPA 之 实体之间关联关系
曾小二的博客
06-03 1528
实体与实体之间的关联关系⼀共分为四种，分别为 OneToOne、OneToMany、ManyToOne 和 ManyToMany；⽽实体之间的关联关系⼜分为双向的和单向的。实体之间的关联关系是在 JPA 使⽤中最容易发⽣问题的地⽅，接下来我将⼀⼀揭晓并解释。我们先看⼀下 OneToOne，即⼀对⼀的关联关系。@OneToOne ⼀般表示对象之间⼀对⼀的关联关系，它可以放在 field 上⾯，也可以放在 get/set ⽅法上⾯。其中 JPA 协议有规定，如果是配置双向关联，维护关联关系的是拥有外键的⼀⽅，⽽
Springboot整合JPA 多表关联操作 @Query
默默不代表沉默
10-14 7864
如果还没使用过JPA的可以去先看我这篇：https://blog.csdn.net/qq_35387940/article/details/102541311 这篇文章里我所采取的是使用Map来 替代 关联的接口，网上很多都是为了关联A B两个表，选择新建A&B这个interface去实现关联获取查询出来的数据。还有就是涉及主外键那种，需要在实体类上面使用@ManyToOne/@Many...
JPA数据关联
sinat_27674731的博客
03-21 681
JPA数据关联一对一数据关联一对多数据关联多对多数据关联 JPA不仅可以实现单表实体映射，也可以实现数据关联技术。常见的有：一对一关联、一对多关联、多对多关联。利用关联技术可以实现级联数据操作，简化代码编写。 项目源码地址： https://gitee.com/tirklee/leaspring 实例中所用工具类 package com.xiyue.leaspring.util; import javax.persistence.EntityManager; import javax.persisten
hibernate笔记
ljj2312的专栏
06-18 438
Hibernate在建立sessionFactory时使用单例模式： 马士兵的hibernate课堂笔记： 对象的三种状态： 一对一主键关联：
SpringData JPA多表关联插入
最新发布
05-09
在 Spring Data JPA 中，多表关联插入可以通过实体类之间的关联来实现。以下是一个简单的示例： 假设我们有两个实体类 `User` 和 `Order`，它们之间是多对一的关系，一个用户可以有多个订单。 ```java @Entity @...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值