`

Hibernate之第3解之-hibernate_hibernate_many2one_1

阅读更多

多对一映射简例:

1.我使用学生和地址的关系来做示例:
student[s_id,s_name,s_addr]
address[a_id,city]
2.建立数据库表:

create table address(
		a_id	int(10)	auto_increment	primary key,
		city	varchar(16)
)engine=MyISAM CHARACTER SET=utf8;
	
create table student(
		s_id	int(10)	auto_increment	primary key,
		s_name	varchar(20)	not null,
		s_addr	int(10),
		foreign key (s_addr) references address(a_id)
)engine=MyISAM CHARACTER SET=utf8;

 3.jar包:和数据库映射:

/hibernate_many2one_1/lib/antlr-2.7.6.jar
/hibernate_many2one_1/lib/commons-collections-3.1.jar
/hibernate_many2one_1/lib/dom4j-1.6.1.jar
/hibernate_many2one_1/lib/hibernate-jpa-2.0-api-1.0.0.Final.jar
/hibernate_many2one_1/lib/hibernate3.jar
/hibernate_many2one_1/lib/javassist-3.12.0.GA.jar
/hibernate_many2one_1/lib/jta-1.1.jar
/hibernate_many2one_1/lib/junit-4.9b1.jar
/hibernate_many2one_1/lib/mysql6.jar
/hibernate_many2one_1/lib/slf4j-api-1.6.1.jar
/hibernate_many2one_1/lib/slf4j-simple-1.6.1.jar

hibernate.cfg.xml

<!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/hnie?useUnicode=true&amp;characterEncoding=UTF-8</property>
		<property name="connection.username">root</property>
		<property name="connection.password">1234</property>
		<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
		<property name="show_sql">true</property>

		<mapping resource="model/Student.hbm.xml"/>
		<mapping resource="model/Address.hbm.xml"/>
	</session-factory>
</hibernate-configuration>

 

4.model层:Address和Student

(1)Address.java

package model;

public class Address {
	private int id;
	private String city;

	public int getId() {
		return id;
	}
	private void setId(int id) {
		this.id = id;
	}
	public String getCity() {
		return city;
	}
	public void setCity(String city) {
		this.city = city;
	}
}

 (-1)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 package="model">
	<class name="Address" table="address" lazy="false">
		<id name="id" type="integer" column="a_id">
            <generator class="identity"/>
		</id>
		<property name="city" type="string" column="city"/>
	</class>
</hibernate-mapping>

(2)Student.java

package model;

public class Student {
	private int stuId;
	private String stuName;
	private Address address;

	public int getStuId() {
		return stuId;
	}
	private void setStuId(int stuId) {
		this.stuId = stuId;
	}
	public String getStuName() {
		return stuName;
	}
	public void setStuName(String stuName) {
		this.stuName = stuName;
	}
	public Address getAddress() {
		return address;
	}
	public void setAddress(Address address) {
		this.address = address;
	}
}

 (-2)Student.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 package="model">
	<class name="Student" table="student" lazy="false">
		<id name="stuId" type="integer" column="s_id">
            <generator class="identity"/>
		</id>
		<property name="stuName" type="string" column="s_name" />
		<many-to-one name="address" class="Address" column="s_addr" not-null="true" cascade="save-update"/>
	</class>
</hibernate-mapping>

  5.获取Session的工具类:

     HibernateUtil.java

package util;

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

public class HibernateUtil {
	private static final SessionFactory sessionFactory=buildSessionFactory();
	/**	init sessionFactory	*/
	private static SessionFactory buildSessionFactory() {
		SessionFactory sessionFactory=null;
		try{
			sessionFactory=new Configuration().configure().buildSessionFactory();
		}catch(Throwable te){
			System.err.println("init sessionFactory Error:"+te);
			te.printStackTrace();
		}
		return sessionFactory;
	} 
	/**	get session	*/
	public static Session getSession(){
		Session session=sessionFactory.openSession();
		return session;
	}
}

 6.dao层:AddressDao.java和StudentDao.java

    1).AddressDao操作address表:

package dao;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Restrictions;
import util.HibernateUtil;
import model.Address;

public class AddressDao {
	/**	增加地址记录; */
	public void addAddress(Address addr){
		Session session=HibernateUtil.getSession();
		Transaction tx=null;
		try{
			tx=session.beginTransaction();
			session.save(addr);
			tx.commit();
		}catch(HibernateException he){
			tx.rollback();
			he.printStackTrace();
		}finally{
			session.close();
		}
	}
	/**	使用id查询一条记录;	 */
	public Address getById(int aid){
		Session session=HibernateUtil.getSession();
		Transaction tx=null;
		Address addr=null;
		try{
			tx=session.beginTransaction();
			addr=(Address)session.load(Address.class,new Integer(aid));
//			addr=(Address)session.get(Address.class,new Integer(aid));
			tx.commit();
		}catch(HibernateException he){
			tx.rollback();
			he.printStackTrace();
		}finally{
			session.close();
		}
		return addr;
	}
	/**	使用属性列查询所有匹配某个值的记录;	 */
	public List<Address> getByField(String fld,String value){
		List<Address> list=null;
		Session session=HibernateUtil.getSession();
		Transaction tx=null;
		try{
			tx=session.beginTransaction();
			Query q=session.createQuery("from Address a where a."+fld+"=?");
			q.setParameter(0, value);
			list=q.list();
			tx.commit();
		}catch(HibernateException he){
			tx.rollback();
			he.printStackTrace();
		}finally{
			session.close();
		}
		return list;
	}
	/**	更新一条记录;	 */
	public void updateAddress(int id,String city){
		Session session=HibernateUtil.getSession();
		Transaction tran=null;
		try{
			tran=session.beginTransaction();
			Address addr=(Address)session.load(Address.class,new Integer(id));
			addr.setCity(city);
			session.flush();
			tran.commit();
		}catch(HibernateException he){
			tran.rollback();
			he.printStackTrace();
		}finally{
			session.close();
		}
	}
	/**	使用like通配符删除指定列 */
	public void deleteAddress(String fld,String val){
		Session session=HibernateUtil.getSession();
		Transaction tx=null;
		try {
			tx=session.beginTransaction();
			/*	1.Criteria查询;	*/
			Criteria criter=session.createCriteria(Address.class).add(Restrictions.like(fld,"%"+val+"%"));
			Iterator<Address> it=criter.list().iterator();
			/*	2.Query查询	
			Query q=session.createQuery("from Address as s where s.? like ?");
			q.setParameter(0, fld);	
			q.setParameter(1, "%"+val+"%");	
			Iterator<Address> it=q.list().iterator();	*/
			/*	3.Native sql查询	表名和表中的列名而不是实体类的类名和属性名了
			SQLQuery sqlq=session.createSQLQuery("SELECT * FROM address WHERE ? like ?").addEntity(Address.class);
			sqlq.setParameter(0,fld);
			sqlq.setParameter(1, "%"+val+"%");
			Iterator<Address> it=sqlq.list().iterator();	*/
			while(it.hasNext()){
				session.delete(it.next());
			}
			tx.commit();
		} catch (HibernateException he) {
			tx.rollback();
			he.printStackTrace();
		} finally {
			session.close();
		}
	}
}

     2).StudentDao操作student表

package dao;

import java.util.Iterator;
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Restrictions;
import util.HibernateUtil;
import model.Student;

public class StudentDao {
	/**	存入一条记录;	 */
	public void addStudent(Student stu){
		Session session=HibernateUtil.getSession();
		Transaction tx=null;
		try{
			tx=session.beginTransaction();
			session.save(stu);
			tx.commit();
		}catch(HibernateException he){
			tx.rollback();
			he.printStackTrace();
		}finally{
			session.close();
		}
	}
	/**	根据id查询学生一条;	 */
	public Student getStudentById(int sid){
		Session session=HibernateUtil.getSession();
		Transaction tx=null;
		Student stu=null;
		try{
			tx=session.beginTransaction();
//			stu=(Student)session.load(Student.class,new Integer(sid));
			stu=(Student)session.get(Student.class,new Integer(sid));
			tx.commit();
		}catch(HibernateException he){
			tx.rollback();
			he.printStackTrace();
		}finally{
			session.close();
		}
		return stu;
	}
	/**	查询所有学生;	 */
	public List<Student> getAll(){
		List<Student> list=null;
		Session session=HibernateUtil.getSession();
		Transaction tx=null;
		try{
			tx=session.beginTransaction();
			list=session.createQuery("from Student as a").list();
			tx.commit();
		}catch(HibernateException he){
			tx.rollback();
			he.printStackTrace();
		}finally{
			session.close();
		}
		return list;
	}
	/**	根据指定属性查询学生;	 */
	public List<Student> getByField(String fld,String val){
		List<Student> list=null;
		Session session=HibernateUtil.getSession();
		Transaction tx=null;
		try{
			tx=session.beginTransaction();
			Query q=session.createQuery("from Student s where s."+fld+"=?");
			q.setParameter(0,val);
			list=q.list();
			tx.commit();
		}catch(HibernateException he){
			tx.rollback();
			he.printStackTrace();
		}finally{
			session.close();
		}
		return list;
	}
	/**	修改 stuName	 */
	public void updateName(String oldName,String newName){
		Session session=HibernateUtil.getSession();
		Transaction tx=null;
		try{
			tx=session.beginTransaction();
			/* 1.hibernate3新update */
			Query q=session.createQuery("update Student set stuName=? where stuName=?");
			q.setParameter(0, newName);
			q.setParameter(1, oldName);
			q.executeUpdate();
			/* 2.查询删除! 
			Query q=session.createQuery("from Student s where s.stuName= ?");
			q.setParameter(0, oldName);
			Iterator<Student> it=q.list().iterator();
			while(it.hasNext()){
				Student s=it.next();
				s.setStuName(newName);
				session.update(s);
			}	*/
			tx.commit();
		}catch(HibernateException he){
			tx.rollback();
			he.printStackTrace();
		}finally{
			session.close();
		}
	}
	/**	删除指定列为指定值的记录;	 */
	public void deleteStudent(String fld,String val){
		Session session=HibernateUtil.getSession();
		Transaction tx=null;
		try {
			tx=session.beginTransaction();
			/*	4.hibernate3支持删除实体	
			Query q=session.createQuery("delete Student where "+fld+"=?");
			q.setParameter(0, val);
			q.executeUpdate();	*/
			/*	1.Criteria查询;	
			Criteria criter=session.createCriteria(Student.class).add(Restrictions.eq(fld,val));
			Iterator<Student> it=criter.list().iterator();	*/
			/*	2.Query查询	*/
			Query q=session.createQuery("from Student as s where s."+fld+" = ?");
			q.setParameter(0, val);	
			Iterator<Student> it=q.list().iterator();	
			/*	3.Native sql查询	表名和表中的列名而不是实体类的类名和属性名了	
			SQLQuery sqlq=session.createSQLQuery("delete FROM student WHERE "+fld+" = '"+val+"';").addEntity(Student.class);
			sqlq.executeUpdate();	*/
			while(it.hasNext()){
				Student s=it.next();
				session.delete(s);
			}
			tx.commit();
		} catch (HibernateException he) {
			tx.rollback();
			he.printStackTrace();
		} finally {
			session.close();
		}
	}
}

 7.业务层:

    1)AddressManager.java

package service;

import java.util.List;

import dao.AddressDao;
import model.Address;

public class AddressManager {
	AddressDao dao=new AddressDao();
	
	/**	增加地址记录; */
	public void save(Address addr){
		dao.addAddress(addr);
	}
	/**	使用id查询一条记录;*/
	public Address getById(int id){
		return dao.getById(id);
	}
	/** 使用属性列查询所有匹配某个值的记录; */
	public List<Address> getByField(String fld,String val){
		return dao.getByField(fld, val);
	}
	/**更新一条记录;*/
	public void update(int id,String city){
		dao.updateAddress(id,city);
	}
	/**使用like通配符删除指定列*/
	public void deleteWithLike(String fld,String val){
		dao.deleteAddress(fld, val);
	}
}

     2)StudentManager.java

package service;

import java.util.List;
import dao.StudentDao;
import model.Student;

public class StudentManager {
	StudentDao dao=new StudentDao();
	/**	存入一个学生实体; */
	public void save(Student stu){
		dao.addStudent(stu);
	}
	/**	根据id查询学生一条; */
	public Student getById(int id){
		return dao.getStudentById(id);
	}
	/** 根据指定属性查询学生;	 */
	public List<Student> getByField(String fld,String val){
		return dao.getByField(fld, val);
	}
	/** 修改 stuName */
	public void update(String oldName,String newName){
		dao.updateName(oldName, newName);
	}
	/** 删除指定列为指定值的记录; */
	public void deleteByField(String fld,String val){
		dao.deleteStudent(fld, val);
	}
	/** 查询所有学生; */
	public List<Student> getAll(){
		return dao.getAll();
	}
}

 8.Junit4测试:

    1)测试业务类AddressManager

package service;

import java.util.List;

import model.Address;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class AddressManagerTest {
	AddressManager man;
	@Before public void init(){
		man=new AddressManager();
	}
	@After public void close(){
		man=null;
	}
	
	/** 增加地址记录; */
	@Test public void testSave() {
		Address addr=new Address();
		addr.setCity("天津");
		man.save(addr);
	}
	/** 使用id查询一条记录; */
	@Test public void testGetById() {
		Address addr=man.getById(3);
		System.out.println(addr.getCity());
	}
	/** 使用属性列查询所有匹配某个值的记录; */
	@Test public void testGetByField() {
		List<Address> list=man.getByField("city","南京");
		for(Address ad:list){
			System.out.println(ad.getId()+"="+ad.getCity());
		}
	}
	/** 更新一条记录; */
	@Test public void testUpdate() {
		man.update(10,"金陵");
	}
	/** 使用like通配符删除指定列 */
	@Test public void testDeleteWithLike() {
		man.deleteWithLike("city","京");
	}
}

    2)测试业务类StudentManager

package service;

import java.util.Iterator;
import java.util.List;
import model.Address;
import model.Student;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class StudentManagerTest {
	StudentManager manager;
	AddressManager aman;
	@Before	public void init(){
		manager=new StudentManager();
		aman=new AddressManager();
	}
	@After public void close(){
		manager=null;
		aman=null;
	}
	
	/** 测试存储一个学生 */
	@Test public void testSave(){
		Student s=new Student();
		String ct="上海";
		List<Address> list=aman.getByField("city",ct);
		Address addr=null;
		if(list.size()<1){
			addr=new Address();
			addr.setCity("上海");
			s.setAddress(addr);
		}else{
			addr=list.get(0);
			s.setAddress(addr);
		}
		s.setStuName("彬彬");
		manager.save(s);
	}
	/** 根据id查询学生一条; */
	@Test public void testGetById() {
		Student s=manager.getById(20);
		System.out.println(s.getStuName()+s.getAddress().getCity());
	}
	/** 根据指定属性查询学生;	 */
	@Test public void testGetByField() {
		Iterator<Student> it=manager.getByField("stuName","彬").iterator();
		while(it.hasNext()){
			Student student=it.next();
			System.out.println(student.getStuId()+"-"+student.getStuName()+"-"+student.getAddress().getCity());
		}
	}
	/**  查询所有学生; */
	@Test public void testGetAll() {
		Iterator<Student> it=manager.getAll().iterator();
		while(it.hasNext()){
			Student s=it.next();
			System.out.println("id:"+s.getStuId()+"-"+"sname:"+s.getStuName()+"-"+"addr:"+s.getAddress().getCity());
		}
	}
	/** 删除指定列为指定值的记录; */
	@Test public void testDeleteByField() {
		manager.deleteByField("stuName", "彬");
	}
	/**  修改 stuName  */
	@Test public void testReplaceName() {
		manager.update("彬彬","彬");
	}
}

 9.over!

在javaeye做笔记可真不错!

 

分享到:
评论

相关推荐

    Hibernate one-to-many / many-to-one关系映射

    "Hibernate one-to-many / many-to-one关系映射"是两个基本的关系类型,用于表示实体间的关联。在这个主题中,我们将深入探讨这两种关系映射的原理、配置和实际应用。 一、一对一(one-to-one)与一对多(one-to-...

    (4)Hibernate中的many-to-one和one-to-many关系

    1. many-to-one关系 many-to-one关系表示在一个实体类中,一个实例可以与另一个实体类的多个实例相关联。例如,在一个学生和班级的关系中,一个班级可以有多个学生,但一个学生只能属于一个班级。在Hibernate中,...

    hibernate many-to-many级联保存,级联更新,级联删除

    在Java的持久化框架Hibernate中,Many-to-Many关系是一种常见的数据库表之间的关联方式,它表示一个实体可以与多个其他实体进行关联,反之亦然。本文将深入探讨如何在Hibernate中处理Many-to-Many关系的级联保存、...

    Many-To-Many_Element.rar_hibernate 多对多

    在Java的持久化框架Hibernate中,集合映射是将数据库中的表关系映射到对象模型的重要部分。在现实世界的数据模型中,很多情况下存在多对多(Many-to-Many)的关系,例如学生与课程的关系,用户与角色的关系等。本...

    hibernate学习5之one-to-many双向关联.docx

    `&lt;set&gt;`标签里的`&lt;one-to-many&gt;`子标签指定了与之关联的类。 在XML映射文件中,`Student.hbm.xml`包含了`&lt;many-to-one&gt;`元素,表示学生对象引用了一个班级对象,通过`classesid`列连接。而`Classes.hbm.xml`则使用...

    Hibernate中many-to-one关系的编写_远航的水手

    Hibernate中many-to-one关系的编写_远航的水手

    Hibernate中many-to-one关系的编写_远航的水手.htm

    Hibernate中many-to-one关系的编写_远航的水手.htm

    hibernate many-to-one(多对一)及 cascade(级联).doc

    ### Hibernate Many-to-One (多对一) 及 Cascade (级联) #### 一、Many-to-One(多对一) 在数据库设计中,实体之间的关系主要包括一对一、一对多、多对多等几种类型。而在ORM(对象关系映射)框架Hibernate中,...

    hibernate_1700_one2many_many2one_bi_crud(5)

    标题中的“hibernate_1700_one2many_many2one_bi_crud(5)”指的是一项关于Hibernate框架的教程,重点在于介绍一对多(One-to-Many)和多对一(Many-to-One)双向关联关系的创建、读取、更新和删除(CRUD)操作。...

    Hibernate集合关系映射及one-one,one-many,many-many示例(带注释)

    本程序包含: hibenate 上传图片,二进制数据,大文本,集合映射的多种关系,onetoone,ontomany,manytomany等关系详细代码示例以及注释,全部由本人测试通过,对理解hibernate配置有极大帮助。

    hibernate_many2one

    在深入探讨Hibernate中的many2one关系之前,我们首先需要理解Hibernate框架本身以及它在Java开发领域扮演的角色。Hibernate是一个开放源代码的对象关系映射(ORM)框架,它为Java应用程序提供了一种将对象模型与...

    Hibernate one-to-many-annotation

    在Hibernate中,`one-to-many`关系是常见的实体间关系之一,表示一个实体可以与多个其他实体相关联。本文将深入探讨`Hibernate one-to-many`注解的使用和实现细节。 ### 一、`@OneToMany`注解概述 `@OneToMany`...

    Hibernate-one-to-many

    本文将深入探讨Hibernate中一对多(One-to-Many)关系的处理方式,特别是通过外键映射和inverse属性的应用场景。 #### 一对多关系概念 一对多关系在数据库设计中非常常见,它指的是一个实体可以与多个其他实体关联...

    Hibernate应用例子many-to-many

    本示例将详细讲解如何在Hibernate中实现多对多(many-to-many)的关系映射。 在数据库设计中,多对多关系是指两个实体之间存在多个关联,比如学生和课程的关系,一个学生可以选修多门课程,一门课程也可以被多个...

    hibernate one-to-one 一对一唯一外键关联映射_单向 and 双向

    在Hibernate中,一对一唯一外键关联映射可以通过 `&lt;many-to-one&gt;` 标签来配置。例如,以下是Person实体与IdCard实体的一对一唯一外键关联映射配置: ```xml &lt;class name="Person" table="person2" &gt; &lt;many...

    Hibernate Tutorial 04 (Many-to-one and One-to-one Association

    为了使用 `publisher` 属性,我们需要在 `Book` 类的 Hibernate 映射文件中添加 `&lt;many-to-one&gt;` 映射。这将在 `BOOK` 表中添加一个名为 `PUBLISHER_ID` 的列,并存储关联出版商的 ID。 ```xml &lt;!-- 其他属性的...

    hibernate中one2many映射

    在Java的持久化框架Hibernate中,One-to-Many映射是一种常见的关系映射方式,它表示一个实体(比如一个用户)可以与多个其他实体(比如用户的订单)进行关联。在这个场景下,"用户"是一方,称为"One","订单"是另...

    Hibernate Mapping Many-to-One 实例 内附源代码及附件下载

    本实例将详细讲解如何在Hibernate中实现Many-to-One关系映射,这是一种常见的数据库关联,表示一个实体可以与多个其他实体相关联。 在Many-to-One关系中,通常一个实体(如部门)可以有多个相关实体(如员工),而...

    hibernate one_to_many

    在Java持久化框架Hibernate中,`one_to_many`映射是一种常见的关系模型,它表示一个实体(类)可以与多个其他实体(类)关联。在这个关系中,一个实体(通常是"one"端)对应多个实体实例("many"端)。在数据库中,...

Global site tag (gtag.js) - Google Analytics