hibernate一对多双向关联-mysql

最新推荐文章于 2019-06-08 22:42:11 发布

原创最新推荐文章于 2019-06-08 22:42:11 发布 · 1.5k 阅读

1 ·

CC 4.0 BY-SA版权

文章发表1周内为内容优化高峰期，后续会根据认知迭代继续做完善补充。

文章标签：

#hibernate #双向 #一对多 #注解

hibernate 专栏收录该内容

31 篇文章

订阅专栏

本文介绍Hibernate框架中一对多双向关联的实现方式，包括实体类定义、配置文件设置及测试方法。通过示例代码详细解释如何避免生成中间表并设置外键。

hibernate一对多双向关联

import java.io.Serializable;
import java.util.List;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

/*一对多，双向
 * C是一
 * D是多
 * C中设置joincolumn
 * D中设置mappedby
 * 只有一个注解的话，在这个注解下加@Joincolumn，这个会在从表中增加字段
 * ·mappedy存在则不存在中间表，只有双向的时候涉及，搭配@Joincolumn，这两个字段在不同的表中
 * （1）ManyToOne（多对一）单向：不产生中间表，但可以用@Joincolumn（name="  "）来指定生成外键的名字，外键在多的一方表中产生！
 * （2）OneToMany（一对多）单向：会产生中间表，此时可以用@onetoMany @Joincolumn（name=" "）避免产生中间表，并且指定了外键的名字（别看@joincolumn在一中写着，但它存在在多的那个表中）
 * （3）OneToMany ,ManyToOne 双向（两个注解一起用的）：如果不在@OneToMany中加mappedy属性就会产生中间表，此时通常在@ManyToOne的注解下再添上注解@Joincolumn(name=" ")来指定外键的名字(说明：多的一方为关系维护端，关系维护端负责外键记录的更新，关系被维护端没有权利更新外键记录)！
 * */

@Table(name="CT")
@Entity(name="CT")
@SuppressWarnings("serial")
public class C implements Serializable {
	private String cn;
	private List<D> Lc;
	/**
	 * @return the cn
	 */
	@Id
	@Column(name="CN",unique=true,length=32)
	public String getCn() {
		return cn;
	}
	/**
	 * @param cn the cn to set
	 */
	public void setCn(String cn) {
		this.cn = cn;
	}
	/**
	 * @return the lc
	 */
	@OneToMany(cascade=CascadeType.ALL,fetch=FetchType.LAZY,mappedBy="c")
	public List<D> getLc() {
		return Lc;
	}
	/**
	 * @param lc the lc to set
	 */
	public void setLc(List<D> lc) {
		Lc = lc;
	}
	
	

}

import java.io.Serializable;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Table(name="DT")
@Entity(name="DT")
@SuppressWarnings("serial")
public class D implements Serializable {

	private String dn;
	private C c;
	/**
	 * @return the dn
	 */
	@Id
	@Column(name="DN",unique=true,length=32)
	public String getDn() {
		return dn;
	}
	/**
	 * @param dn the dn to set
	 */
	public void setDn(String dn) {
		this.dn = dn;
	}
	/**
	 * @return the c
	 */
	@ManyToOne(cascade=CascadeType.ALL,fetch=FetchType.EAGER,targetEntity=C.class)
	@JoinColumn(name="cid")   //如果没有这个系统会默认分配一个名字
	public C getC() {
		return c;
	}
	/**
	 * @param c the c to set
	 */
	public void setC(C c) {
		this.c = c;
	}
	
	
	
}

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>

<session-factory>

<property name="connection.driver_class">
com.mysql.jdbc.Driver
</property>

<property name="connection.url">
jdbc:mysql://localhost:3306/test
</property>

<property name="connection.username">用户名</property>

<property name="connection.password">密码</property>

<property name="dialect">
org.hibernate.dialect.MySQLDialect
</property>

<property name="show_sql">true</property>
<property name="format_sql">true</property>
<property name="hbm2ddl.auto">update</property>
<mapping class="hibernate.onetomany.C" />
<mapping class="hibernate.onetomany.D" />

</session-factory>

</hibernate-configuration>

测试方法

/*一对多双向关联*/
	@Test
	public void testOneToManyDouble(){
		HIbernateUtil hbu=new HIbernateUtil();
		Session s=hbu.getSession();
		s.beginTransaction();
		
		C c=new C();
		D d1=new D();
		D d2=new D();
		d1.setDn("d1");
		d2.setDn("d2");
		
		d1.setC(c);
		d2.setC(c);
		
		c.setCn("c");
		List li=new ArrayList();
		li.add(d1);
		li.add(d2);
		
		c.setLc(li);
		s.save(c);
		
		s.getTransaction().commit();
		s.close();
	}