Hibernate (超详细一对一，一对多，多对一，多对多)

（一对一，双向关联）对应关系：一个人对应一个地址

整体路径结构

Person类


public class Person implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	
	private Integer personid;
	private String personname;
	
	//一对一单向关联one2one single 
	private Address address;

}

Address 类



public class Address implements Serializable{
	private static final long serialVersionUID = 1L;
	
	private Integer addressid;
	private String addressname;

	//一对一反向关联
	private Person person;
	//get 和 set方法省略	
	
}

Address.hbm.xml

<?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>
	<class name="com.lanou.bookstroe.domain.Address" table="T_Address">
		<id name="addressid" column="t_addressid" type="java.lang.Integer" />
		<property name="addressname" column="t_addressname" type="java.lang.String"/>
		
		<!-- 一对一对的反向关联 -->
		<one-to-one name="person" property-ref="address" cascade="all"/>
	</class>
</hibernate-mapping>

Person.hbm.xml

<?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>
	<class name="com.lanou.bookstroe.domain.Person" table="T_PERSON">
		<id name="personid" column="t_personid" type="java.lang.Integer" />
		<property name="personname" column="t_personname" type="java.lang.String"/>
		
		<!-- 一(Person)对一(Address)单向关联 
			name,当前JAVABEAN里面的属性，column是这个属性对应的那个表的主键
			 cascade="all",所有的CRUD都会关联
		-->
	<many-to-one unique="true" name="address" column="t_addressid" cascade="all"></many-to-one>
	</class>
</hibernate-mapping>

hibernate.cfg.xml

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
	<session-factory>
		
		<!-- 数据库连接 -->
		<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
		<property name="connection.driver_class">com.mysql.jdbc.Driver</property>

		<!-- JDBC URL -->
		<property name="connection.url">jdbc:mysql://localhost/test?characterEncoding=utf-8</property>

		<!-- 数据库用户名 -->
		<property name="connection.username">root</property>

		<!-- 数据库密码 -->
		<property name="connection.password">123456</property>
		
		<!-- SQL dialect 数据库方言 -->
		<property name="dialect">org.hibernate.dialect.MySQLDialect</property>

		<!-- Echo all executed SQL to stdout -->
		<property name="show_sql">true</property>

		<!-- Drop and re-create the database schema on startup,create无条件创建表/update没有表的时候创建 -->
		<property name="hbm2ddl.auto">update</property>

		<mapping resource="com/lanou/bookstroe/config/Person.hbm.xml" />
		<mapping resource="com/lanou/bookstroe/config/Address.hbm.xml" />
	</session-factory>
</hibernate-configuration>

Test

package com.lanou.bookstroe.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

import com.lanou.bookstroe.domain.Address;
import com.lanou.bookstroe.domain.Person;



public class Test {
	public static void main(String[] args) {
		Configuration configuration = new Configuration().configure("com/lanou/bookstroe/config/hibernate.cfg.xml");
		SessionFactory sessionFactory = configuration.buildSessionFactory();
		Session session = sessionFactory.openSession();
		
		Address address = new Address();
		address.setAddressid(25);
		address.setAddressname("武汉2");
		
		
		Person person = new Person();
		person.setPersonid(10086);
		person.setPersonname("张三2");
		person.setAddress(address);
//		
//		address.setPerson(person);
		
//		session.save(address);
		session.save(person);//只添加人Person对象，但由于关联的作用（Cascade）,所以Address也会被插入
		
		session.beginTransaction().commit();

		//测试一对一关联(查询Person，测试是不是能够关联查询出Address)
//		Person person = (Person)session.get(Person.class, 10086);
//		System.out.println(person.getPersonname());
//		
//		//从关联里面得到Address
//		System.out.println(person.getAddress().getAddressname());
		

//		Address address = (Address)session.get(Address.class, 25);
//		System.out.println(address.getAddressname());
//		System.out.println(address.getPerson().getPersonname());
	}
}

一对多，多对一

Person类

//一个人
public class Person implements Serializable {
	private static final long serialVersionUID = 1L;
	
	private Integer personid;
	private String personname;
	
	//多Person对一Address关联
	private Address address;
	//get、set方法省略
	
}

Address 类

public class Address implements Serializable{
	private static final long serialVersionUID = 1L;
	
	private Integer addressid;
	private String addressname;

	//一对多关联
	private Set<Person> persons;
	//set 和get方法省略
	
	
}

hibernate.cfg.xml 同上

Address.hbm.xml

<?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>
	<class name="com.lanou.hibernateorm.domain.Address" table="T_Address">
		<id name="addressid" column="t_addressid" type="java.lang.Integer" />
		<property name="addressname" column="t_addressname" type="java.lang.String"/>
		
		<!--
			一对多反向关联 
			inverse="true",反转(由对方来维护两关系)＝是的
		-->
		<set name="persons" inverse="true" cascade="all">
			<key column="t_addressid"/><!-- 当前对象表的主键 -->
			<one-to-many class="com.lanou.hibernateorm.domain.Person"/>
		</set>
	</class>
</hibernate-mapping>

Person.hbm.xml

<?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>
	<class name="com.lanou.hibernateorm.domain.Person" table="T_PERSON">
		<id name="personid" column="t_personid" type="java.lang.Integer" />
		<property name="personname" column="t_personname" type="java.lang.String"/>
		
		<!-- 多对一关联 -->
		<many-to-one name="address" column="t_addressid" cascade="all"/>
	</class>
</hibernate-mapping>

Test

package com.lanou.hibernateorm.test;


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

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

import com.lanou.hibernateorm.domain.Address;
import com.lanou.hibernateorm.domain.Person;

public class Test {
	public static void main(String[] args) {
		Configuration configuration = new Configuration().configure();
		
		SessionFactory sessionFactory = configuration.buildSessionFactory();
		
		Session session = sessionFactory.openSession();
		
		//测试多对一关联，从多去关联一
//		Person person1 = new Person();
//		person1.setPersonid(111);
//		person1.setPersonname("名字111");
//		
//		Person person2 = new Person();
//		person2.setPersonid(222);
//		person2.setPersonname("名字222");
//		
//		Person person3 = new Person();
//		person3.setPersonid(333);
//		person3.setPersonname("名字333");
//		
//		Address address = new Address();
//		address.setAddressid(100);
//		address.setAddressname("武汉100");
		
//		person1.setAddress(address);
//		person2.setAddress(address);
//		person3.setAddress(address);
//
//		//只能保存多的一方Person
//		session.save(person1);
//		session.save(person2);
//		session.save(person3);
//		
//		session.beginTransaction().commit();
		
		
		//测试一对多关联，从一去关联多
//		Person person1 = new Person();
//		person1.setPersonid(444);
//		person1.setPersonname("名字444");
//		
//		Person person2 = new Person();
//		person2.setPersonid(555);
//		person2.setPersonname("名字555");
//		
//		Person person3 = new Person();
//		person3.setPersonid(666);
//		person3.setPersonname("名字666");
//		
//		Address address = new Address();
//		address.setAddressid(200);
//		address.setAddressname("武汉200");
//		
//		//三个PERSON都装了三个属性
//		person1.setAddress(address);
//		person2.setAddress(address);
//		person3.setAddress(address);
//		
//		
//		//一个Address还差一个set属性
//		Set<Person> persons = new HashSet<Person>();
//		persons.add(person1);
//		persons.add(person2);
//		persons.add(person3);
//		
//		address.setPersons(persons);
//		
//		//保存address
//		session.save(address);
//		
//		session.beginTransaction().commit();
		
		
		//一关联多查询(查询ADDRESS)
		Address address = (Address)session.get(Address.class, 200);
		System.out.println(address.getAddressname());
		
		//关联多的一方
		Iterator<Person> it = address.getPersons().iterator();
		while(it.hasNext()) {
			Person person = it.next();
			System.out.println(person.getPersonname());
		}
	}
}

多对多

Address

public class Address implements Serializable{
	private static final long serialVersionUID = 1L;
	
	private Integer addressid;
	private String addressname;

	//多对多关联
	private Set<Person> persons;
    
    //get 和 set方法省略

Person

public class Person implements Serializable {
	private static final long serialVersionUID = 1L;
	
	private Integer personid;
	private String personname;	
	//多对多关联
	private Set<Address> addresses;
    //get 和set方法省略

Address.hbm.xml

<?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>
	<class name="com.lanou.hibernateorm.domain.Address" table="T_Address">
		<id name="addressid" column="t_addressid" type="java.lang.Integer" />
		<property name="addressname" column="t_addressname" type="java.lang.String"/>
		
		<!-- 多对多关联 
		 inverse="true",在少的一方里面写-->
		<set name="persons" table="t_personaddress" inverse="true" cascade="all">
			<key column="t_addressid" />
			<many-to-many class="com.lanou.hibernateorm.domain.Person" column="t_personid"/>
		</set>
	</class>
</hibernate-mapping>

Person.hbm.xml

<?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>
	<class name="com.lanou.hibernateorm.domain.Person" table="T_PERSON">
		<id name="personid" column="t_personid" type="java.lang.Integer" />
		<property name="personname" column="t_personname" type="java.lang.String"/>
		
		<!-- 多对多关联
			table是第三方连接表的名字
		 -->
		<set name="addresses" table="t_personaddress"  cascade="all">
			<key column="t_personid"/>
			<many-to-many class="com.lanou.hibernateorm.domain.Address" column="t_addressid"/>
		</set>
	</class>
</hibernate-mapping>

hibernate.cfg.xml 同上

Test

package com.lanou.hibernateorm.test;


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

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.engine.query.ParameterParser;

import com.lanou.hibernateorm.domain.Address;
import com.lanou.hibernateorm.domain.Person;

public class Test {
	public static void main(String[] args) {
		Configuration configuration = new Configuration().configure();
		
		SessionFactory sessionFactory = configuration.buildSessionFactory();
		
		Session session = sessionFactory.openSession();
		
		//测试多对多关联，从Person去关联Address
//		Person person1 = new Person();
//		person1.setPersonid(111);
//		person1.setPersonname("名字111");
//		
//		Person person2 = new Person();
//		person2.setPersonid(222);
//		person2.setPersonname("名字222");
//		
//		Person person3 = new Person();
//		person3.setPersonid(333);
//		person3.setPersonname("名字333");
//		
//		Address address1 = new Address();
//		address1.setAddressid(100);
//		address1.setAddressname("武汉100");
//		
//		Address address2 = new Address();
//		address2.setAddressid(200);
//		address2.setAddressname("武汉200");
//		
//		Address address3 = new Address();
//		address3.setAddressid(300);
//		address3.setAddressname("武汉300");
//		
//		//先将三个address的第三个属性set装起来
//		Set<Person> persons = new HashSet<Person>();
//		persons.add(person1);
//		persons.add(person2);
//		persons.add(person3);
//		
//		address1.setPersons(persons);
//		address2.setPersons(persons);
//		address3.setPersons(persons);
//		
//		//再将三个person的第三个属性set装起来
//		Set<Address> addresses = new HashSet<Address>();
//		addresses.add(address1);
//		addresses.add(address2);
//		addresses.add(address3);
//		
//		person1.setAddresses(addresses);
//		person2.setAddresses(addresses);
//		person3.setAddresses(addresses);
//		
//
//		//保存Person
//		session.save(person1);
//		session.save(person2);
//		session.save(person3);
//		
//		session.beginTransaction().commit();
		
		
		
		//多关联多查询(查询Person找Address)
//		Person person = (Person)session.get(Person.class, 111);
//		
//		System.out.println(person.getPersonname());
//		
//		//关联表的查询（LAZY）
//		Set<Address> addresses = person.getAddresses();
//		Iterator<Address> it = addresses.iterator();
//		while(it.hasNext()) {
//			Address address = it.next();
//			System.out.println(address.getAddressname());
//		}
		
		//多关联多查询(查询Address找Person)
		Address address = (Address)session.get(Address.class, 100);
		
		System.out.println(address.getAddressname());
		
		//关联表的查询（LAZY）
		Set<Person> persons = address.getPersons();
		Iterator<Person> it = persons.iterator();
		
		while(it.hasNext()) {
			Person person = it.next();
			System.out.println(person.getPersonname());
		}
	}
}

Hibernate (超详细一对一，一对多，多对一，多对多)

猜你喜欢