Hibernate中一對一，一對多，多對多的寫法

阿新 • • 發佈：2019-02-09

hibernate中各類對應的bean類寫法

1、一對一的情況

假設我們用Address類和User類做一對一的對應
User類

package com.telek.model;

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

import javax.annotation.Generated;
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;



@Entity
@Table(name="user")//如果表明和物件名不一致 則需要單獨加上該註解
public class User implements java.io.Serializable 
{

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    @Column(name="username")
    private String username;
    @Column(name="password")
    private String password;
    //fetch代表資料的抓取策略lazy就是指用到了該屬性才會去查詢（eager剛好相反）
    @OneToOne(cascade = {CascadeType.ALL},fetch = FetchType.LAZY )
    private 
 Address address=new Address();

    public User(){}
    public User(String username,String password){
        this.username = username;
        this.password = password;
    }

    @return the address
    public Address getAddress() {
        return address;
    }

    @param address the address to set
    public void setAddress(Address address) {
        this.address = address;
    }
    public int getId() {
        return id;
    }
    public void setId(int 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;
    }
}

Address類

package com.telek.model;

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

@Entity
@Table(name="address")
public class Address {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String address;

    @OneToOne(optional= false,fetch = FetchType.EAGER)//cascade = CascadeType.ALL,
    @JoinColumn(name="uid")
    private User user;


    public int getId() {
        return id;
    }

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

    public String getAddress() {
        return address;
    }

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

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

}

1、一對多的情況

假設我們用Address類和User類做一對一的對應
Address類

package com.telek.model;

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

@Entity
@Table(name="address")
public class Address {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String address;

    @ManyToOne(optional= false,fetch = FetchType.EAGER)//cascade = CascadeType.ALL,
    @JoinColumn(name="uid")
    private User user;


    public int getId() {
        return id;
    }

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

    public String getAddress() {
        return address;
    }

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

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

}

User類

package com.telek.model;

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

import javax.annotation.Generated;
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;



@Entity
@Table(name="user")//如果表明和物件名不一致 則需要單獨加上該註解
public class User implements java.io.Serializable{

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    @Column(name="username")
    private String username;
    @Column(name="password")
    private String password;
    //fetch代表資料的抓取策略lazy就是指用到了該屬性才會去查詢（eager剛好相反）
    @OneToMany(cascade = {CascadeType.ALL},mappedBy="user",fetch = FetchType.LAZY )
    private Set<Address> address = new HashSet<Address>();

    public User(){}
    public User(String username,String password){
        this.username = username;
        this.password = password;
    }

    public Set<Address> getAddress() {
        return address;
    }
    public void setAddress(Set<Address> address) {
        this.address = address;
    }
    public int getId() {
        return id;
    }
    public void setId(int 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;
    }
}

最後，附上一對多情況中Dao包類的測試方法

public void OnetoMore(){//一對多配置
        Session session = sessionFactory.openSession();
        User user = new User();
        user.setUsername("wjw");
        user.setPassword("wlf");

        Address add1 =  new Address();
        add1.setAddress("浙江");
        Address add2 =  new Address();
        add2.setAddress("北京");

        add1.setUser(user);//在多的一方告訴hibernate我這個物件屬於誰
        add2.setUser(user);
        user.getAddress().add(add1);//在少的一端告訴hibernate我可以新增誰進來
        user.getAddress().add(add2);

        session.beginTransaction();
        session.save(user);
        session.close();
    }

3、多對多的情況

假設我們用Tag類和Topic類作為演示
Tag類

package com.telek.model;
// Generated 2016-3-4 9:16:37 by Hibernate Tools 4.3.1.Final


import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import static javax.persistence.GenerationType.IDENTITY;

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

import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.OneToMany;
import javax.persistence.Table;

/**
 * Tag generated by hbm2java
 */
@Entity
@Table(name="tag"
    ,catalog="springdemo"
)
public class Tag  implements java.io.Serializable {


     private Integer tagid;
     private String tag;
     private Set<Topic> topic=new HashSet<Topic>();

    public Tag() {
    }

    public Tag(String tag) {
       this.tag = tag;
    }

     @Id @GeneratedValue(strategy=IDENTITY)


    @Column(name="tagid", unique=true, nullable=false)
    public Integer getTagid() {
        return this.tagid;
    }

    public void setTagid(Integer tagid) {
        this.tagid = tagid;
    }


    @Column(name="tag")
    public String getTag() {
        return this.tag;
    }

    public void setTag(String tag) {
        this.tag = tag;
    }

    /**
     * @return the topic
     */
    @ManyToMany(cascade = {CascadeType.ALL},mappedBy="tag",fetch = FetchType.LAZY )
    public Set<Topic> getTopic() {
        return topic;
    }

    /**
     * @param topic the topic to set
     */
    public void setTopic(Set<Topic> topic) {
        this.topic = topic;
    }
}

Topic類

package com.telek.model;
// Generated 2016-3-4 9:16:37 by Hibernate Tools 4.3.1.Final


import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import static javax.persistence.GenerationType.IDENTITY;

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

import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

/**
 * Topic generated by hbm2java
 */
@Entity
@Table(name="topic"
    ,catalog="springdemo"
)
public class Topic  implements java.io.Serializable {


     private Integer topicid;
     private String title;
     private String context;
     private Set<Tag> tag = new HashSet<Tag>();

    public Topic() {
    }

    public Topic(String title, String context) {
       this.title = title;
       this.context = context;
    }

     @Id @GeneratedValue(strategy=IDENTITY)


    @Column(name="topicid", unique=true, nullable=false)
    public Integer getTopicid() {
        return this.topicid;
    }

    public void setTopicid(Integer topicid) {
        this.topicid = topicid;
    }


    @Column(name="title")
    public String getTitle() {
        return this.title;
    }

    public void setTitle(String title) {
        this.title = title;
    }


    @Column(name="context")
    public String getContext() {
        return this.context;
    }

    public void setContext(String context) {
        this.context = context;
    }

    /**
     * @return the tag
     */
    @ManyToMany(cascade = {CascadeType.ALL})
    @JoinTable(name="topicandtag",joinColumns=@JoinColumn(name="topicid"),inverseJoinColumns=@JoinColumn(name="tagid"))
    public Set<Tag> getTag() {
        return tag;
    }

    /**
     * @param tag the tag to set
     */
    public void setTag(Set<Tag> tag) {
        this.tag = tag;
    }
}

最後在Dao裡面寫一個方法作為演示

public void ManyToMany(){
        Session session = sessionFactory.openSession();
        Topic topic = new Topic();
        topic.setTitle(("大保健"));
        topic.setContext("來玩來玩");
        Topic topic2 = new Topic();
        topic2.setTitle(("大保健"));
        topic2.setContext("來玩來玩呀");
        Tag tag1 = new Tag();tag1.setTag("服務");
        Tag tag2 = new Tag();tag2.setTag("保健");

        Set<Tag> tags = new HashSet<Tag>();
        tags.add(tag1);tags.add(tag2);
        topic.setTag(tags);

        Set<Topic> topics = new HashSet<Topic>();
        topics.add(topic);
        topics.add(topic2);
        tag1.setTopic(topics);
        tag2.setTopic(topics);

        session.beginTransaction();
        session.save(topic);
        session.getTransaction().commit();
        session.close();
}

發現關係表和Tag表和Topic表都插入資料為正常
最後，附上資料庫表的情況
這裡寫圖片描述
另外，如果在topic和tag兩邊都加上

@ManyToMany(cascade = {CascadeType.ALL})
@JoinTable(name="topicandtag",joinColumns=@JoinColumn(name="tagid"),inverseJoinColumns=@JoinColumn(name="topicid"))

即可以不用兩邊set關係，只用一邊關聯就可以兩邊都存入資料庫

Hibernate中一對一，一對多，多對多的寫法

hibernate中各類對應的bean類寫法 1、一對一的情況假設我們用Address類和User類做一對一的對應 User類 package com.telek.model; import java.util.HashSet; import jav

hibernate中關聯關係一對多對映雙向，級聯刪除，inverse屬性解析

班級和學生一對多雙向對映 Class.java package com.java1234.model; import java.util.HashSet; import java.util.Set; public class Class { private long id

Hibernate 中得查詢（hql，離線）和getHibernateTemplate()常用方法彙總

1.hql通過getHibernateTemplate() (1) 回撥介面getHibernateTemplate().execute(new HibernateCallback())方法 public User getEmailByUsername(final String userna

從陣列中找出一對元素，其和是一個給定的目標數字。假設陣列中只存在一個符合要求的數值對，返回這些數值的下標

【解題分析】對於陣列中某個下標i，如何判斷它是否屬於符合條件的兩個數字之一？最直觀的就是再次掃描數字，判斷target-array【i】是否存在於陣列中。這樣做時間複雜度O(n^2)，效率不高，原因是沒有儲存之前的處理結果，每次都在做重複的工作。儘管效率不高，但

Python中求有一對兔子，從出生後第3個月起每個月都生一對兔子，，假如兔子都不死，問每個月的兔子總數為多少？

1.兔子的規律為數列1,1,2,3,5,8,13,21... a=1 b=1 print(a) print(b) for i in range(10): a=a+b print(a) b=a+b print(b) 第一個月跟第二個月一樣

資料庫多表關聯對多對關係

資料庫多表關聯對多對關係本文章解決資料庫設計多表關聯配置問題，多對多關係！設計思路：應用場景： 1，區域表（欄位：id（城市id）、name（城市名字））表名：pms_region 2，中間表（欄位：shipping_area_id、re

android 玩轉ContentProvider之二－－實現多個ContentProvider對多張表進行操作

本人原創作品，謝絕轉載！其它地方跟一個ContentProvider操作一張表都是一樣的，唯一區別是authority，在宣告的時候要注意，因為要宣告兩個ContentProvider，所以authority也要不一樣，否則就會因為找不到對應的ContentPr

Hibernate中的一對一，一對多，多對多詳解。

1、inverse屬性：是否反轉，預設為false就是不反轉然後就是自己維護兩方的關係，true就是反轉，意思是讓對方維護關係。作用：提高開發的效率在一對多中，一的一方可以放棄維護提高效率，多的一方必須要維護，因為外來鍵在多的一方。在多對多中，維護關係理論上隨便哪方維護都行，必須要指定只有

Django中資料庫的資料關係：一對一，一對多，多對多

一對一：一對一的關係極為一個數據僅對應一個數據，用下圖的結構圖可以幫助理解：下面用程式碼實現一下，首先要建立工程專案如下：接著，我們定義模型：來到models.py檔案，建立兩個模型： from django.db import models #

Hibernate中多表設計的一對多，多對一的對映檔案的配置

一對多（客戶表與聯絡人表為例）：一對多關係中習慣性的把一方稱為主表，把多方稱為從表，外來鍵指的是從表中有一列，取值參照主表的主鍵，這一列就是外來鍵。舉例：一方為客戶，多方為聯絡人在客戶的實體類中需要配置一個set集合，包含多個聯絡人。 private Set<L

MyBatis中對映檔案和註解的關係查詢（一對一，一對多，多對多）

對映關係的查詢一對一查詢：（案例--人和卡） User實體類 package com.entity; public class User { private int uid;

JPA中對映關係詳細說明(一對多，多對一，一對一、多對多）、@JoinColumn、mappedBy說明

JPA中的對映關係 jpa中維護one to one ,one to many, many to one ,many to many 四種對映關係。在每個關係中，雙方中的一方在其表中擁有連線列。那麼一方稱為所有方(owning side) 或者關係的所有者。

mybatis的面試一對一，一對多，多對多的mapper.xml配置

分享圖片 AR 圖片 info 傳統 soc tail sso collect 使用springboot完成一對一，一對多： https://blog.csdn.net/KingBoyWorld/article/details/78966789 傳統的mapper文件中的一

記錄一次laravel 模型關聯一對一，一對多取數據

foreach style 遍歷一個用戶 use span AC each 判斷一對一是用戶表和用戶信息表一個用戶對應一個用戶信息 user 對應 userinfo user 中存入的是郵箱密碼之類的，userinfo存入的是姓名年齡之類的。在控制器中取數據

使用GreenDao建立表、關聯表（一對一，一對多，多對多）、CURD、升級資料庫等操作

應用場景：從照片中找出包含有使用者人臉的照片，並儲存該照片中的人臉特徵、使用該特徵和使用者人臉特徵對比，滿足條件，照片就儲存到該使用者表裡一、建立表 GreenDao託管地址：https://github.com/greenrobot

mybatis實現多表一對一，一對多，多對多關聯查詢

轉自：https://blog.csdn.net/m0_37787069/article/details/79247321 1、一對一關鍵字：association 作用：針對pojo物件屬性的對映 property：pojo的屬性名 &

mybatis一對一，一對多，多對多註解版

下面三個案例都需要在xml中配置對映： <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "h

訂單和訂單詳情的一對一，一對多對映

我們知道，訂單和訂單詳情是一對多的關係，所以在訂單Bean（OrderBean）中包含一個訂單詳情Bean(OrderDetailBean)的集合. 開發步驟： 1、先建好OrderDetailBean 1 package com.november.query.zuoye1; 2 3

訂單和訂單詳情的一對一，一對多映射

返回值屬性是否 inter tom goods str omap pen 我們知道，訂單和訂單詳情是一對多的關系，所以在訂單Bean（OrderBean）中包含一個訂單詳情Bean(OrderDetailBean)的集合. 開發步驟： 1、先建好OrderDetailB

flask連線mysql資料庫的一對一，一對多，多對多的處理關係。

Y18 以學生表與班級表為例，進行一對一，與一對多操作說明。簡單部署: 1、建立flask資料夾，在資料夾中建立python檔案，命名為app，其中程式碼： from flask import Flask app = Flask(__name__) 2

Hibernate中一對一，一對多，多對多的寫法

hibernate中各類對應的bean類寫法

1、一對一的情況

1、一對多的情況

3、多對多的情況

相關推薦