`

多对多映射

阅读更多

多对多映射表现为在两个表之外产生一个中间表,其主键为两个表的外键.

如下:

Person与Event为多对多关联.除了产生person,event表外,还会产生person_event表.

映射文件:

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.lwf.hibernate.many2many">
	<class name="Event" table="EVENTS">
		<id name="id" column="Event_ID">
			<generator class="native"/>
		</id>
		<property name="title"/>
		<property name="date" type="timestamp" column="Event_Date"/>
		<set name="participants" table="Person_Event" inverse="true">
			<key column="Event_ID"/>
			<many-to-many column="Person_id" class="Person"></many-to-many>
		</set>
	</class>
	
	<class name="Person" >
		<id name="id" column="Person_ID">
			<generator class="native"/>
		</id>
		<property name="name"/>
		<property name="age"/>
		<set name="events" table="Person_Event" >
			<key column="Person_id"/>
			<many-to-many column="Event_ID" class="Event"/>
		</set>
		<set name="emailAddress" table="Person_Email_Addr" >
			<key column="Person_id"/>
			<element type="string" column="Emai_Addr"/>
		</set>
		
	
	</class>
</hibernate-mapping>

 

 

POJO

package com.lwf.hibernate.many2many;

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

public class Person {

	private long id;
	private String name;
	private int age;
	private Set events = new HashSet();
	private Set emailAddress = new HashSet();
	
	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 int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Set getEvents() {
		return events;
	}
	public void setEvents(Set events) {
		this.events = events;
	}
	public Set getEmailAddress(){
		return emailAddress;
	}
	public void setEmailAddress(Set emailAddress){
		this.emailAddress = emailAddress;
	}
}

 

package com.lwf.hibernate.many2many;

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

public class Event {

	private long id;
	private String title;
	private Date date;
	private Set participants = new HashSet();
	
	public Event(){}

	public long getId() {
		return id;
	}

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

	public String getTitle() {
		return title;
	}

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

	public Date getDate() {
		return date;
	}

	public void setDate(Date date) {
		this.date = date;
	}

	public Set getParticipants() {
		return participants;
	}

	public void setParticipants(Set participants) {
		this.participants = participants;
	}
}

 

 

测试类:

package com.lwf.hibernate.many2many;

import java.util.Date;
import java.util.Iterator;
import java.util.Set;

import org.hibernate.Session;

import com.lwf.hibernate.util.HibernateUtil;
import com.lwf.hibernate.util.MapUtil;

public class Many2ManyTest {

	public static void main(String[] args) {
//		addPerson();
//		addEvent();
//		addPersonToEvent(1L,1L);
		//addEmaiAddrToPerson(1L,"zhang@126.com");
//		save();
		load();
	}
	
	public static void load(){
		MapUtil map = new MapUtil();
		map.begin();
		Session session = map.getSession();
		Person aPerson = (Person)session.load(Person.class, 1L);
		System.out.println(aPerson.getName());
		Set events = aPerson.getEvents();
		for (Iterator iterator = events.iterator(); iterator.hasNext();) {
			Event event = (Event) iterator.next();
			System.out.println(event.getTitle());
			System.out.println(event.getDate());
			
		}
		
		
		map.commit();
		map.close();
	}

	public static void addEmaiAddrToPerson(Long personId,String emailAddr){
		Session session = HibernateUtil.getSession();
		session.beginTransaction();
		Person aPerson = (Person)session.load(Person.class, personId);
		aPerson.getEmailAddress().add(emailAddr);
		
		HibernateUtil.commit(session);
		
	}
	public static void addPersonToEvent(Long personId, Long eventId){
		Session session = HibernateUtil.getSession();
		session.beginTransaction();
		Person aPerson = (Person)session.load(Person.class, personId);
		Event anEvent = (Event)session.load(Event.class, eventId);
		aPerson.getEvents().add(anEvent);
		
		HibernateUtil.commit(session);
	}
	
	public static void addPerson(){
		Session session = HibernateUtil.getSession();
		session.beginTransaction();
		Person person = new Person();
		person.setName("li");
		person.setAge(16);
		session.save(person);
	
		HibernateUtil.commit(session);
	}
	
	public static void addEvent(){
		Session session = HibernateUtil.getSession();
		session.beginTransaction();
		Event event = new Event();
		event.setTitle("event_title2");
		event.setDate(new Date());
		session.save(event);
	
		HibernateUtil.commit(session);
	}
	
	public static void save(){
		MapUtil map = new MapUtil();
		map.begin();
		Person person = new Person();
		person.setName("person1");
		person.setAge(22);
		
		Event event = new Event();
		event.setTitle("title1");
		event.setDate(new Date());
		map.save(event);
		
		Event event1 = new Event();
		event1.setTitle("title2");
		event1.setDate(new Date());
		map.save(event1);
	
		person.getEvents().add(event);
		person.getEvents().add(event1);
		
		map.save(person);
		
		map.commit();
		map.close();
	}
}

 

分享到:
评论

相关推荐

    hibernate单向多对多映射(XML版)

    本主题聚焦于"hibernate单向多对多映射",特别是在XML配置文件中的实现。在这个过程中,我们将探讨多对多关系的原理,以及如何在Hibernate中通过XML配置文件来定义这种关系。 首先,我们需要理解多对多关系的概念。...

    hibernate 映射关系学习入门 多对多实体映射

    本教程将带你入门Hibernate的多对多实体映射,帮助你理解如何通过源码来实现这种复杂的关系映射。 一、Hibernate概述 Hibernate是一个对象关系映射(ORM)框架,它允许我们将Java对象(实体)与数据库表进行映射,...

    Hibernate多对多映射

    在Java的持久化框架Hibernate中,多对多(Many-to-Many)映射是一种常见的关系数据库模型,用于处理两个实体之间复杂的关系。本实例将详细阐述如何在Hibernate中实现多对多映射,并通过源代码和测试程序进行实战演示...

    hibernate常用一对一、一对多、多对一、多对多映射关系真实例子(华南银行项目)

    博文链接:https://davexin.iteye.com/blog/102726

    Hibernate之关联关系映射(一对多和多对一映射,多对多映射).docx

    本文将深入探讨Hibernate中的一对多、多对一以及多对多映射。 1. 一对多与多对一映射: 在现实世界中,许多关系表现为一对多或多对一的形式。例如,一个老师可以教授多个学生,而一个学生只能被一个老师教导;同样...

    浪曦_EJB3.0实例教程_多对多映射

    **EJB 3.0 实例教程:多对多映射** 在企业级Java应用开发中,Entity Bean(实体Bean)是核心组件之一,用于持久化业务数据。EJB 3.0是Java EE 5规范的一部分,它极大地简化了Bean的使用,包括对关系数据库的映射。...

    hibernate单向多对多映射(注解版)

    在Java的持久化框架Hibernate中,单向多对多映射是一种常见的关系映射方式,尤其在处理数据库中两个实体间复杂关联时显得尤为重要。在注解版的Hibernate中,我们不再需要传统的XML配置文件,而是直接在实体类上使用...

    ibatis 一对多 多对多完整映射

    本文将深入探讨如何在iBATIS中实现一对多和多对多的关系映射,并提供相关的源码分析和工具使用技巧。 **一对多关系映射** 在数据库设计中,一对多关系是指一个父记录可以与多个子记录关联,例如,一个用户可以有多...

    80端口映射软件【多对多映射】

    只映射80端,端口映射原理为多对多,通过指定映射列表映射

    80端口映射软件1.03版【多对多映射】

    只映射80端,端口映射原理为多对多,通过指定映射列表映射。 支持IIS映射(IIS必须使用非80端口)

    10 映射-- 多对多(老师与学生)

    本文将深入探讨“多对多”映射这一主题,结合老师与学生的实例,来解析其在实际应用中的实现和重要性。 “多对多”映射指的是两个实体之间存在多个关联,每个实体都可以与其他实体有多个关联。在我们的例子中,一个...

    Mybatis多对多关联映射源码

    在Mybatis中,多对多关联映射是处理复杂数据关系的一种重要机制。它允许我们将一个实体类与多个同类或不同类的实体类之间建立起关联关系。Mybatis通过配置XML映射文件或注解来实现这种关系的映射。下面我们将深入...

    hibernate 多对一映射关联配置

    在Java的持久化框架Hibernate中,多对一(Many-to-One)映射是一种常见的关联关系。这种关系表示在一个实体类中可以引用另一个实体类的多个实例,而在被引用的实体类中,每个实例只被一个引用实体类实例引用。本文将...

    hibernate 双向 多对对,一对多,一对一 映射的 集合

    本主题将深入探讨双向多对多、一对多和一对一映射的概念及其在集合中的应用。 首先,我们来看双向多对多映射。在数据库设计中,两个实体之间可能存在多对多的关系,例如学生和课程,每个学生可以选修多门课程,每门...

    Execl映射表轻松搞定多对多账户映射.docx

    总结来说,Excel的映射表结合VLOOKUP函数,提供了一种有效管理多对多账户映射关系的方法,使得IT管理员或数据分析师能更便捷地处理复杂的数据关联问题。通过熟练掌握这种方法,可以大大提高工作效率,减少人为错误。

    自己做的一个jpa多对多映射的一个例子

    刚学完了hibernate和ejb,自己又自学了下jpa,看了黎活明老师的视频,自己做了个多对多的例子,希望可以对你学习有所帮助,有心人可以联系我QQ770256061!

Global site tag (gtag.js) - Google Analytics