文档章节

Video-No.02 尚硅谷_Hibernate4视频教程

蓝汀华韶
 蓝汀华韶
发布于 2015/07/11 12:46
字数 5041
阅读 259
收藏 0

1、Ecplise hibernate插件安装:

    下载zip格式的Eclipse插件,(http://sourceforge.net/projects/jboss/files/JBossTools/JBossTools4.1.x/hibernatetools-Update-4.1.1.Final_2013-12-08_01-06-33-B605.zip) 

    Eclipse-》Help-》Install New Software.. -》add..-》Archive 选择刚才下载的hibernate插件

2、Hibernate开发步骤

    1)创建hibernate配置文件(hibernate.cfg.xml):配置数据库相关配置信息和hibernate相关初始化配置信息

<?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="connection.username">root</property>
    	<property name="connection.password">root</property>
    	<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
    	<property name="connection.url"><![CDATA[jdbc:mysql://127.0.0.1:3306/atguigu_hibernate?useUnicode=true&characterEncoding=utf8]]></property>
   
   	<!-- hibernate基本配置信息  -->
   		
   	<!-- hibernate数据库方言 -->
   	<property name="dialect">org.hibernate.dialect.MySQLInnoDBDialect</property>
   		
   	<!-- 执行操作时,是否在后台打印SQL语句 -->
   	<property name="show_sql">true</property>
   		
   	<!-- 是否对SQL语句进行格式化 -->
   	<property name="format_sql">true</property>
   		
   	<!-- 指定自动生成数据表的策略 -->
   	<!-- 
   		create: 会根据*.hbm,xml文件生成新的数据表,每次都会删除上一次的数据表重新生成表
   		create-drop:会根据*.hbm,xml文件生成新的数据表,但是每次sessionFactory关闭都会删除表
   		update:最常用的值,会根据*.hbm,xml文件生成新的数据表,如果*.hbm,xml所定义的表结构与数据库中表结果不同,hibernate将更新数据表结构,但不会删除已有的行和列
   		validate:会和数据库中的表进行比较,如果*.hbm,xml配置文件中的列在数据库中不存在,则抛出异常
   	-->
   	<property name="hbm2ddl.auto">update</property>
   		
   	<!-- 设置 Hibernate 的事务隔离级别 -->
   	<property name="connection.isolation">2</property>
   		
   	<!-- 删除对象后, 使其 OID 置为 null -->
   	<property name="use_identifier_rollback">true</property>
   		
       <!-- 配置 C3P0 数据源 -->
    	<property name="hibernate.c3p0.max_size">10</property>
    	<property name="hibernate.c3p0.min_size">5</property>
    	<property name="c3p0.acquire_increment">2</property>
    	
    	<property name="c3p0.idle_test_period">2000</property>
    	<property name="c3p0.timeout">2000</property>
    	
    	<property name="c3p0.max_statements">10</property>
    	
    	<!-- 设定 JDBC 的 Statement 读取数据的时候每次从数据库中取出的记录条数 -->
    	<property name="hibernate.jdbc.fetch_size">100</property>
    	
    	<!-- 设定对数据库进行批量删除,批量更新和批量插入的时候的批次大小 -->
    	<property name="jdbc.batch_size">30</property>
   		
   	<!-- 指定关联的map映射 -->
   	<mapping resource="com/shma/hibernate/entity/User.hbm.xml"/>
   	<mapping resource="com/shma/hibernate/entity/Worker.hbm.xml"/>	
    </session-factory>
    
</hibernate-configuration>

    2)创建持久化层实体类

package com.shma.hibernate.entity;

import java.sql.Blob;
import java.util.Date;

public class User {

	private Integer id;
	private String name;
	private Integer age;
	private Date date;
	
	private String oldContent;
	private Blob image;
	
	private String desc;
	
	public User() {
		super();
	}
	
	public User(String name, Integer age, Date date) {
		super();
		this.name = name;
		this.age = age;
		this.date = date;
	}
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public Date getDate() {
		return date;
	}
	public void setDate(Date date) {
		this.date = date;
	}

	public String getDesc() {
		return desc;
	}

	public void setDesc(String desc) {
		this.desc = desc;
	}

	public String getOldContent() {
		return oldContent;
	}

	public void setOldContent(String oldContent) {
		this.oldContent = oldContent;
	}

	public Blob getImage() {
		return image;
	}

	public void setImage(Blob image) {
		this.image = image;
	}
}

package com.shma.hibernate.entity;

public class Worker {

	private int id;
	private String name;
	
	private Pay pay;

	public int getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Pay getPay() {
		return pay;
	}

	public void setPay(Pay pay) {
		this.pay = pay;
	}
}

package com.shma.hibernate.entity;

public class Pay {

	private double monthPay;
	private double yearPay;
	private int yearDay;
	
	private Worker worker;
	
	public double getMonthPay() {
		return monthPay;
	}
	public void setMonthPay(double monthPay) {
		this.monthPay = monthPay;
	}
	public double getYearPay() {
		return yearPay;
	}
	public void setYearPay(double yearPay) {
		this.yearPay = yearPay;
	}
	public int getYearDay() {
		return yearDay;
	}
	public void setYearDay(int yearDay) {
		this.yearDay = yearDay;
	}
	public Worker getWorker() {
		return worker;
	}
	public void setWorker(Worker worker) {
		this.worker = worker;
	}
	
	
}

    3)创建对象-关系映射文件

<?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.shma.hibernate.entity">
	<!-- 
		class:
		1)dynamic-insert:默认为false,如果设置为true,则表示保存一个insert时,动态生成sql语句,仅保存字段不能为空的值
		2)dynamic-update:默认为false,如果设置为true,则表示更新一个update时,动态生成sql语句,仅更新修改的字段值
	 	3)select-before-update:在执行update之前,是否执行一次查询,默认为false
	 -->
    <class name="User" table="USER" select-before-update="true" dynamic-insert="true">
        <!-- 
      		id:
      		unsaved-value:表示持久化对象的oid如果为该属性值20,则认为是一个临时对象,执行保存操作
      		type:可以为java类型,也可以设置为hibernate类型
      		class:设置持久化类设置唯一标识符方式
      			increment:由hibernate先执行查询max,再+1,并发下不安全
      			identity:底层数据库自增,底层数据库必须设置为自增,适用于mysql、sqlserver
      			sequence:底层数据库提供序列生成唯一标识符,如oracle
      			hilo:hibernate生成组件,在数据库创建一张表,读取并修改该表保存自增
      			native:常用,自动识别使用identity、sequence、hilo
         -->
        <id name="id" type="java.lang.Integer" unsaved-value="20">
            <column name="ID"  />
            <generator class="native" />
        </id>
        <!-- 
        	property:
        		1) access:制定hibernate默认属性访问策略,默认为property,调用getter和setter方法,若设置为field,则通过反射访问
        		2) unique:设置属性唯一值
        		3) index:设置索引
        		4) length: 设置字段长度
        		5) scale: 当字段为double或float类型时,指定小数点后保留位数
        		6) formula: 派生属性,sql表达式,用()括起来
         -->
        <property name="name" type="java.lang.String" 
        		access="property" unique="true" index="user_index" length="20">
            <column name="NAME" />
        </property>
        <property name="age" type="java.lang.Integer" index="user_index">
            <column name="AGE" />
        </property>
        <!-- 
        	在 Java 中, 代表时间和日期的类型包括: java.util.Date 和 java.util.Calendar. 
        	此外, 在 JDBC API 中还提供了 3 个扩展了 java.util.Date 类的子类: java.sql.Date, java.sql.Time 和 java.sql.Timestamp, 这三个类分别和标准 SQL 类型中的 DATE, TIME 和 TIMESTAMP 类型对                应在标准 SQL 中, DATE 类型表示日期, TIME 类型表示时间, TIMESTAMP 类型表示时间戳, 同时包含日期和时间信息
         -->
        <property name="date" type="timestamp">
            <column name="DATE" />
        </property>
        <property name="desc" formula="(select concat(name,',',date) from user t where t.id = id)"></property>
    	<!-- 映射大对象 -->
    	<property name="oldContent">
    		<column name="OLD_CONTENT" sql-type="text"></column>
    	</property>
    	
    	<!-- 
    	mysql数据库不支持
    	<property name="realContent">
    		<column name="real_Content" sql-type="clob"></column>
    	</property>
    	 -->
    	
    	<property name="image">
    		<column name="image" sql-type="blob"></column>
    	</property>
    </class>
</hibernate-mapping>

    4)通过Hibernate API编程访问操作数据库代码

package com.shma.hibernate.entity;

import java.sql.Date;
import java.text.ParseException;
import java.text.SimpleDateFormat;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.Test;

public class UserTest {

	@Test
	public void test() {
		//1) 创建一个SessionFactory对象
		SessionFactory sessionFactory = null;
		
		//创建Configuration配置对象,加载hibernate基本配置文件和关系对象映射文件
		Configuration configuration = new Configuration().configure();
		
		//弃用
//		sessionFactory = configuration.buildSessionFactory();
		
		//创建ServiceRegistry服务注册对象,hibernate任何配置和服务都需要在这个对象中注册后才可以使用
		ServiceRegistry serviceRegistry = new ServiceRegistryBuilder()
											.applySettings(configuration.getProperties())
											.buildServiceRegistry();
		
		try {
			sessionFactory = configuration.buildSessionFactory(serviceRegistry);
		} catch (Exception e) {
			e.printStackTrace();
		}

		
		//2) 创建一个Session对象
		Session session = sessionFactory.openSession();
		
		//3) 开启事务
		Transaction transaction = session.beginTransaction();
		
		//4) 执行相关操作
		User user = null;
		try {
			user = new User("马韶华", 23, new Date(new SimpleDateFormat("yyyy-MM-dd").parse("1989-11-10").getTime()));
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		session.save(user);
		
		//5) 提交事务
		transaction.commit();
		
		//6) 关闭Session对象
		session.close();
		
		//7) 关闭SessionFactroy对象
		sessionFactory.close();
	}

}

3、Session

    1)session接口是hibernate向引用程序提供的操作数据库的最主要的接口,提供了基本的增删改和加载java对象的操作;

    2)session具有一个缓存,被称之为hibernate一级缓存;位于缓存中的对象称之为持久化对象;

package com.shma.hibernate.entity;

import java.util.Date;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class UserTest {
	
	private SessionFactory sessionFactory = null;
	private Session session = null;
	private Transaction transaction = null;
	
	@Before
	public void init() {
		Configuration configuration = new Configuration().configure();
		ServiceRegistry serviceRegistry = 
						new ServiceRegistryBuilder().applySettings(configuration.getProperties())
													.buildServiceRegistry();
		sessionFactory = configuration.buildSessionFactory(serviceRegistry);
		session = sessionFactory.openSession();
		transaction = session.beginTransaction();
	}
	
	/**
	 * clear(): 清理缓存
	 */
	@Test
	public void clear() {
		User user = (User) session.get(User.class, 1);
		System.out.println(user);
		User user2 = (User) session.get(User.class, 1);
		System.out.println(user2);
		session.clear();
		
		User user3 = (User) session.get(User.class, 1);
		System.out.println(user3);
	}
	
	/**
	 * reflesh():会强制发送 SELECT 语句, 以使 Session 缓存中对象的状态和数据表中对应的记录保持一致!使数据库中的记录同步到session缓存中
	 */
	@Test
	public void reflesh() {
		
		User user = (User) session.get(User.class, 1);
		System.out.println(user);
		session.refresh(user);
		System.out.println(user);
	}
	
	/**
	 * flush(): 使session缓存中的数据同步到数据库中,为了保存一致,可能会发送对应的SQL语句操作
	 * 
	 * flush()被调用的契机:
	 * 	1) 手动调用session.flush()方法
	 * 	2) 在Transaction对象提交事务之前,会先调用session对象的flush()方法,在提交事务
	 * 	3) 执行HQL或者QBC查询时,如果缓存中持久化对象属性发生变化,则会先flush()一次,以保证查询出来的是最新的数据
	 * 	4) 如果持久化对象主键采用native生成OID(记录的 ID 是由底层数据库使用自增的方式生成),在调用save()方法时,先发生insert()语句,以创建主键id,保证save()方法后主键id是存在的
	 */
	@Test
	public void testSessionFlush() {
//		User user = (User) session.get(User.class, 1);
//		user.setAge(27);
//		user.setName("齐娇娇");
//		
//		session.flush(); //将session缓存中的数据同步到数据库中,执行update方法,但是数据库值没有修改,没有commit
//		System.out.println(user);
		
//		User user = (User) session.get(User.class, 1);
//		
//		//执行HQL或者QBC查询时,如果缓存中持久化对象属性发生变化,则会先flush()一次,以保证查询出来的是最新的数据
//		User user2 = (User) session.createCriteria(User.class).uniqueResult();
//		
//		System.out.println(user == user2);
		
		
		User user3 = new User("孙威", 28, new Date());
		session.save(user3);

	}

	/**
	 * 验证session缓存
	 */
	@Test
	public void testSessionCache() {
		User user = (User) session.get(User.class, 1);
		System.out.println(user);
		
		User user2 = (User) session.get(User.class, 1); //从session缓存中获取,没有查询数据库
		System.out.println(user2);
		
		System.out.println(user == user2);
	}
	
	@After
	public void destory() {
		transaction.commit();
		session.close();
		sessionFactory.close();
	}

}

4、持久化对象状态

    1)站在持久化的角度上,hibernate将对象分为四种状态:

         持久化状态:存在session缓存中,存在数据库记录中,存在OID

            临时状态:不存在session缓存中,不存在数据库记录中,不存在OID    

            游离状态:存在OID,不存在session缓存中,可能存在数据库记录中,一般情况下游离对象是由持久化对象转变而来

            删除状态:存在OID,但是数据库中不存在对应的记录,不存在数据库中,不存在session缓存中

package com.shma.hibernate.entity;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.Date;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.jdbc.Work;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class UserTest2 {
	
	private SessionFactory sessionFactory = null;
	private Session session = null;
	private Transaction transaction = null;
	
	/**
	 * 调用存储过程
	 */
	@Test
	public void testDoWork() {
		session.doWork(new Work() {
			
			@Override
			public void execute(Connection conn) throws SQLException {
				//调用存储过程
			}
		});
	}
	
	/**
	 * evict():从缓存中移除指定的持久化对象
	 */
	@Test
	public void testEvict() {
		User user = (User) session.get(User.class, 8);
		User user2 = (User) session.get(User.class, 9);
		
		user.setName("nihao");
		user2.setName("haha");
		
		session.evict(user);
	
	}
	
	/**
	 * delete: 执行删除操作. 只要 OID 和数据表中一条记录对应, 就会准备执行 delete 操作
	 * 若 OID 在数据表中没有对应的记录, 则抛出异常
	 * 
	 * 可以通过设置 hibernate 配置文件 hibernate.use_identifier_rollback 为 true,
	 * 使删除对象后, 把其 OID 置为  null
	 */
	@Test
	public void testDelete() {
//		User user = new User();
//		user.setId(1);
//		session.delete(user); 
		
		User user = (User) session.get(User.class, 3);
		session.delete(user);
		
		System.out.println(user);
	}
	
	/**
	 * saveOrUpdate:
	 * 	包含了save和update方法,当对象处于游离状态时,则执行save操作,当对象处于持久化状态时,则执行update操作
	 * 判断是否为临时状态:
	 * 	1、Java对象的OID为null
	 * 	2、如果OID在数据库表记录中不存在,则会抛出异常,
	 * 	      除非映射文件中<id>设置了unsaved-value属性,并且java对象中的oid值与设置的unsaved-value值一致
	 */
	@Test
	public void testSaveOrUpdate() {
//		User user = new User("王二", 22, new Date());
//		
//		//user处于游离状态,执行save
//		session.saveOrUpdate(user);
//		
//		// 执行save操作后user转变为持久化对象
//		user.setAge(45);
//		user.setName("王五");
//		
//		session.saveOrUpdate(user);
		
		User user2 = new User("aidai", 10, new Date());
		user2.setId(999);
		session.saveOrUpdate(user2);
	}
	
	/**
	 * update():
	 * 	1) 若更新一个持久化对象,不需要显示调用update方法,因为在调用Transaction的commit方法
	 * 	   时,会调用session的flush()方法
	 * 	
	 * 	2) 若更新一个游离对象,需要显示的调用update方法,把一个游离对象转换为持久化对象
	 * 
	 * 	需要注意的地方:
	 * 	1、无论要更新的游离对象和数据库表中的记录是否一致(持久化对象会先检查,不一致才执行update),都会调用update
	 * 	       操作,如何能让 update方法不再盲目的出发 update 语句呢 ? 在 .hbm.xml 文件的 class 节点设置
	 *    select-before-update=true (默认为 false). 这个属性的含义是在每次update之前先查询一遍数
	 *    据库,如果有修改在执行update,但通常不需要设置该属性. 
	 *    
	 *  2、若数据表中没有对应的记录, 但还调用了 update 方法, 会抛出异常
	 *  
	 * 	3、当 update() 方法关联一个游离对象时, 
	 *    如果在 Session 的缓存中已经存在相同 OID 的持久化对象, 会抛出异常. 因为在 Session 缓存中
	 * 	      不能有两个 OID 相同的对象!
	*/
	@Test
	public void testUpdate() {
		
		// 持久化对象,不需要显示调用update方法
		User user = (User) session.get(User.class, 1);
//		user.setName("齐娇娇");
		
//		session.update(user);
		
//		session.clear();
		
		// 游离状态,必须显示调用update方法
//		user.setName("马韶华");
//		session.update(user);
		
		User user2 = (User) session.get(User.class, 1);
		session.update(user); //session 中已经存在user2
	}
	
	@Before
	public void init() {
		Configuration configuration = new Configuration().configure();
		ServiceRegistry serviceRegistry = 
						new ServiceRegistryBuilder().applySettings(configuration.getProperties())
													.buildServiceRegistry();
		sessionFactory = configuration.buildSessionFactory(serviceRegistry);
		session = sessionFactory.openSession();
		transaction = session.beginTransaction();
	}
	
	/**
	 * 1) 执行get()方法:立即执行查询操作加载对象,get为立即检索
	 *    执行load()方法:如不使用该对象,则不会执行查询操作,而是返回一个代理对象,load为延迟检索
	 * 2) 当使用load延时检索时,如果session关闭,可能会抛出LazyInitializationException异常
	 * 3) 如果查询的oid数据库没有对应的数据记录,并且session也没有关闭
	 * 	  	get方法返回null
	 * 	  	load方法如果不使用实体对象属性,加载不会抛出异常,使用的时候会抛出异常
	 * 		
	 */
	@Test
	public void testLoad() {
		User user = (User) session.load(User.class, 10);
		System.out.println(user.getClass().getName());
		
//		session.close();
		System.out.println(user);
	}
	
	/**
	 * get/load:根据一个oid,从数据库中加载一个持久化对象到session缓存中
	 */
	@Test
	public void testGet() {
		User user = (User) session.get(User.class, 10);
		System.out.println(user.getClass().getName());
//		session.close();
		System.out.println(user);
	}
	
	/**
	 * persist(): 和save方法一样保存记录到持久化对象
	 * 和save()方法区别:当对一个OID不为null的对象执行save时,会把对象以一个新oid保存到数据库中,而persist则会抛出异常
	 */
	@Test
	public void testPersist() {
		User user = new User();
		user.setAge(20);
		user.setDate(new Date());
		user.setName("zhangsan");
		user.setId(10); // 抛出异常
		
		session.persist(user);
	}
	
	/**
	 * save():用于将临时对象转换为持久化对象,插入记录
	 * 执行步骤:1) 使一个临时对象保存到session缓存中,转换为持久化对象
	 * 		 2) 为持久化对象生成唯一的UID
	 * 		 3) 执行一条insert语句:在flush缓存时
	 * 		 4) 在save之前的设置id是无效的
	 * 		 5) 在save之后的设置id是不能被修改的,修改会抛出异常
	 */
	@Test
	public void testSave() {
		
		User user = new User();
		user.setAge(20);
		user.setDate(new Date());
		user.setName("zhangsan");
//		user.setId(10); // 设置id是无效的
		
		session.save(user);
		
		System.out.println(user);
		
		user.setId(10); //save()后修改id,抛出异常
	}
	
	@After
	public void destory() {
		transaction.commit();
		session.close();
		sessionFactory.close();
	}
	
	   @Test
	public void testWorker() {
		Worker worker = new Worker();
		Pay pay = new Pay();
		pay.setMonthPay(13000.23d);
		pay.setYearDay(5);
		pay.setYearPay(153422.12344d);
		
		worker.setName("马韶华");
		worker.setPay(pay);
		
		session.save(worker);
	}

}

5、映射对象关系

    1)单向多对一

package com.shma.hibernate.entity.n21;

public class Customer {

	private int customerId;
	
	private String customerName;

	public int getCustomerId() {
		return customerId;
	}

	public void setCustomerId(int customerId) {
		this.customerId = customerId;
	}

	public String getCustomerName() {
		return customerName;
	}

	public void setCustomerName(String customerName) {
		this.customerName = customerName;
	}

	@Override
	public String toString() {
		return "Customer [customerId=" + customerId + ", customerName=" + customerName + "]";
	}

}

package com.shma.hibernate.entity.n21;

public class Order {

	private int orderId;
	
	private String orderName;
	
	private Customer customer;

	public int getOrderId() {
		return orderId;
	}

	public void setOrderId(int orderId) {
		this.orderId = orderId;
	}

	public String getOrderName() {
		return orderName;
	}

	public void setOrderName(String orderName) {
		this.orderName = orderName;
	}

	public Customer getCustomer() {
		return customer;
	}

	public void setCustomer(Customer customer) {
		this.customer = customer;
	}

	@Override
	public String toString() {
		return "Order [orderId=" + orderId + ", orderName=" + orderName + ", customer=" + customer + "]";
	}
	
}

package com.shma.hibernate.entity.n21;

import static org.junit.Assert.*;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class TestN21 {

	private SessionFactory sessionFactory = null;
	private Session session = null;
	private Transaction transaction = null;
	
	@Before
	public void init() {
		Configuration configuration = new Configuration().configure();
		ServiceRegistry serviceRegistry = 
						new ServiceRegistryBuilder().applySettings(configuration.getProperties())
													.buildServiceRegistry();
		sessionFactory = configuration.buildSessionFactory(serviceRegistry);
		session = sessionFactory.openSession();
		transaction = session.beginTransaction();
	}
	
	@After
	public void destory() {
		transaction.commit();
		session.close();
		sessionFactory.close();
	}
	
	@Test
	public void testMany2OneDel() {
//		Order order = (Order)session.get(Order.class, 2); 
//		session.delete(order);
//		
//		session.delete(order.getCustomer());
		
		//在不设定级联关系的情况下, 且 1 这一端的对象有 n 的对象在引用, 不能直接删除 1 这一端的对象
		Customer customer = (Customer) session.get(Customer.class, 2);
		session.delete(customer);
		
		
	}
	
	@Test
	public void testMany2OneUpdate() {
		Order order = (Order)session.get(Order.class, 1);
		order.setOrderName("order-112222");
		order.getCustomer().setCustomerName("AAAAAAAA");
	}
	
	@Test
	public void testMany2OneGet() {
		Order order = (Order)session.get(Order.class, 1);
		System.out.println(order);
		System.out.println(order.getCustomer().getClass());
		
		//如果session被关闭,将抛出异常
//		session.close();

		//延时加载Customer
		Customer customer = order.getCustomer();
		System.out.println(customer);
		
		System.out.println(customer.getClass());
		
	}
	
	@Test
	public void testMany2OneSave() {
//		Customer customer = new Customer();
//		customer.setCustomerName("AAA");
//		
//		Order order01 = new Order();
//		order01.setOrderName("Order-01");
//		
//		Order order02 = new Order();
//		order02.setOrderName("Order-02");
//		
//		order01.setCustomer(customer);
//		order02.setCustomer(customer);
//		
//		//先savecustomer,会saveorder,执行三次insert
//		session.save(customer);
//		session.save(order01);
//		session.save(order02);
		
		
		Customer customer = new Customer();
		customer.setCustomerName("BBB");
		
		Order order01 = new Order();
		order01.setOrderName("Order-03");
		
		Order order02 = new Order();
		order02.setOrderName("Order-04");
		
		order01.setCustomer(customer);
		order02.setCustomer(customer);
		
		//先save order,会save customer,执行三次insert,会执行2次update
		session.save(order01);
		session.save(order02);
		session.save(customer);
		
		
		
	}

}
<?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.shma.hibernate.entity.n21.Customer" table="CUSTOMERS">
        <id name="customerId" type="int">
            <column name="CUSTOMER_ID" />
            <generator class="native" />
        </id>
        <property name="customerName" type="java.lang.String">
            <column name="CUSTOMER_NAME" />
        </property>
        
    </class>
</hibernate-mapping>

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2015-7-18 15:21:35 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping package="com.shma.hibernate.entity.n21">
    <class name="Order" table="ORDERS">
        <id name="orderId" type="int">
            <column name="ORDER_ID" />
            <generator class="native" />
        </id>
        <property name="orderName" type="java.lang.String">
            <column name="ORDER_NAME" />
        </property>
        
        <!-- 多对一映射关系
        	name:多这一端的一那一端的属性名称
        	class:一端的类型
        	column:一那一端对应在多端的外键名称
         -->
        <many-to-one name="customer" class="Customer">
        	<column name="customer_id"></column>
        </many-to-one>
    </class>
</hibernate-mapping>

    2)双向一对多

package com.shma.hibernate.entity.n21.bath;

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

public class Customer {

	private int customerId;
	
	private String customerName;
	
	/**
	 * 1、声明集合需要使用接口,因为hibernate延迟加载,在获取集合的时候是获取到的hibernate内部集合实例
	 * 2、需要把集合进行初始化, 可以防止发生空指针异常
	 */
	private Set<Order> orders = new HashSet<>();

	public int getCustomerId() {
		return customerId;
	}

	public void setCustomerId(int customerId) {
		this.customerId = customerId;
	}

	public String getCustomerName() {
		return customerName;
	}

	public void setCustomerName(String customerName) {
		this.customerName = customerName;
	}

	public Set<Order> getOrders() {
		return orders;
	}

	public void setOrders(Set<Order> orders) {
		this.orders = orders;
	}

}

package com.shma.hibernate.entity.n21.bath;

public class Order {

	private int orderId;
	
	private String orderName;
	
	private Customer customer;

	public int getOrderId() {
		return orderId;
	}

	public void setOrderId(int orderId) {
		this.orderId = orderId;
	}

	public String getOrderName() {
		return orderName;
	}

	public void setOrderName(String orderName) {
		this.orderName = orderName;
	}

	public Customer getCustomer() {
		return customer;
	}

	public void setCustomer(Customer customer) {
		this.customer = customer;
	}

	@Override
	public String toString() {
		return "Order [orderId=" + orderId + ", orderName=" + orderName + ", customer=" + customer + "]";
	}
	
}

package com.shma.hibernate.entity.n21.bath;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class Test12N {

	private SessionFactory sessionFactory = null;
	private Session session = null;
	private Transaction transaction = null;
	
	@Before
	public void init() {
		Configuration configuration = new Configuration().configure();
		ServiceRegistry serviceRegistry = 
						new ServiceRegistryBuilder().applySettings(configuration.getProperties())
													.buildServiceRegistry();
		sessionFactory = configuration.buildSessionFactory(serviceRegistry);
		session = sessionFactory.openSession();
		transaction = session.beginTransaction();
	}
	
	@After
	public void destory() {
		transaction.commit();
		session.close();
		sessionFactory.close();
	}
	
	@Test
	public void testOne2ManyDel() {
		//在不设定级联关系的情况下, 且 1 这一端的对象有 n 的对象在引用, 不能直接删除 1 这一端的对象
		Customer customer = (Customer) session.get(Customer.class, 1);
		session.delete(customer.getOrders().iterator().next());
	}
	
	@Test
	public void testOne2ManyUpdate() {
		
		Customer customer = (Customer) session.get(Customer.class, 1);
		customer.setCustomerName("CCCCCC");
		
		Customer customer2 = (Customer) session.get(Customer.class, 2);
		customer.getOrders().iterator().next().setCustomer(customer2);
		
	}
	
	@Test
	public void testOne2ManyGet() {
		Customer customer = (Customer) session.get(Customer.class, 1);
		System.out.println(customer.getCustomerName());
		//延时加载
		//返回的多的一端的集合时 Hibernate 内置的集合类型. 
		//该类型具有延迟加载和存放代理对象的功能.
		System.out.println(customer.getOrders().getClass());
		
		//3. 可能会抛出 LazyInitializationException 异常 
//		session.close();
		
		System.out.println(customer.getOrders().iterator().next().getOrderName());
		//再需要使用集合中元素的时候进行初始化. 
	}
	
	@Test
	public void testOne2ManySave() {
		
//		Customer customer = new Customer();
//		customer.setCustomerName("AAA");
//		
//		Order order01 = new Order();
//		order01.setOrderName("Order-01");
//		
//		Order order02 = new Order();
//		order02.setOrderName("Order-02");
//		
//		order01.setCustomer(customer);
//		order02.setCustomer(customer);
//		
//		customer.getOrders().add(order01);
//		customer.getOrders().add(order02);
//		
//		//先savecustomer,会saveorder,执行三次insert
//		session.save(customer);
//		session.save(order01);
//		session.save(order02);
		
		
		Customer customer = new Customer();
		customer.setCustomerName("BBB");
		
		Order order01 = new Order();
		order01.setOrderName("Order-03");
		
		Order order02 = new Order();
		order02.setOrderName("Order-04");
		
		order01.setCustomer(customer);
		order02.setCustomer(customer);
		
		customer.getOrders().add(order01);
		customer.getOrders().add(order02);
		
		//先save order,会save customer,执行三次insert,会执行2次update
		session.save(order01);
		session.save(order02);
		session.save(customer);
		
		
		
	}

}
<?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.shma.hibernate.entity.n21.bath">
    <class name="Customer" table="CUSTOMERS">
        <id name="customerId" type="int">
            <column name="CUSTOMER_ID" />
            <generator class="native" />
        </id>
        <property name="customerName" type="java.lang.String">
            <column name="CUSTOMER_NAME" />
        </property>
        
        <!--
        	1对多映射关系那个属性集合
        	set:映射集合为set类型
        	table:set中集合类型的所对应的表名,需要与多对一中的表名一致
        	inverse:指定由哪一方来维护关联关系. 通常设置为 true, 以指定由多的一端来维护关联关系
        	cascade:级联操作,save-update级联保存并修改关联,delete:级联删除
        	order-by:排序,字段是数据库里面的字段类型
        	name:1的集合属性名称
         -->
        <set name="orders" table="ORDERS" inverse="true" order-by="order_name desc">
			<!-- 执行多的表中的外键列的名字 -->
			<key column="CUSTOMER_ID"></key>
			<!-- 指定映射类型 -->
			<one-to-many class="Order"/>       
        </set>
    </class>
</hibernate-mapping>

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2015-7-18 15:21:35 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping package="com.shma.hibernate.entity.n21.bath">
    <class name="Order" table="ORDERS">
        <id name="orderId" type="int">
            <column name="ORDER_ID" />
            <generator class="native" />
        </id>
        <property name="orderName" type="java.lang.String">
            <column name="ORDER_NAME" />
        </property>
        
        <!-- 多对一映射关系
        	name:多这一端的一那一端的属性名称
        	class:一端的类型
        	column:一那一端对应在多端的外键名称
         -->
        <many-to-one name="customer" class="Customer">
        	<column name="customer_id"></column>
        </many-to-one>
    </class>
</hibernate-mapping>


© 著作权归作者所有

共有 人打赏支持
蓝汀华韶
粉丝 36
博文 77
码字总数 80082
作品 0
海淀
程序员
私信 提问
【视频分享】尚硅谷Java视频教程_RBAC权限实战视频教程

        本视频讲授RBAC权限模型的设计、以及在项目中的应用 。 1. 使用Maven进行项目构建 。 2. 页面设计采用响应式前端框架BootStrap 。 3. 采用多种方式展现用户数据:树形结构(z...

后端编程嘟
2018/05/24
0
0
Java 框架起步

简单的开场白:把我开发 Java Web 框架过程中想说的话,给说出来。先介绍下作者的背景,本人最先比较熟悉 JS,先是接触过 ASP(VBS)、ASP(用 JScript 编写,花时间不少)、ASP.net(不算太...

sp42
2009/09/13
0
0
如果你想学习Java,那么就来看这篇文章

一、前言 我是从大二开始学习的Java,当时的目标是Java Web开发,当时并不想考研,所以当时的学习是以就业为主,现在我大三了,学习Java Web开发已经一年了,因为种种原因,决定要考研,所以...

Jivanmoon
2018/08/27
0
0
史上最简单的Hibernate4视频教程(附源码和笔记)

Hibernate4是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合...

2846613430
2016/04/08
1K
0
Java8-Stream-练习

这一篇用来记录对前面学习的Lambda和Stream的综合训练 练习题取值尚硅谷教学视频,因为中文的博大精深,有一些题理解不一样,求出来的结果也不一样,只求达到复习和提高知识掌握度,下面直接...

特拉仔
2018/02/26
0
0

没有更多内容

加载失败,请刷新页面

加载更多

Android 通知Notify

MainActivity { private NotificationManager manager; onCreate() { manager = (NotificationManager)getSystemService(Context.NOTIFICATION_SERVICE); } public void btnNotify(View view......

Coding缘
32分钟前
1
0
Android 人脸识别SDK开发

目前我们的应用内使用了 ArcFace 的人脸检测功能,其他的我们并不了解,所以这里就和大家分享一下我们的集成过程和一些使用心得 集成 ArcFace FD 的集成过程非常简单 在 ArcFace FD 的文档上...

是哇兴哥棒棒哒
33分钟前
1
0
《市场营销》的读后感作文3000字

《市场营销》的读后感作文3000字: 大家好,这是我领读《市场营销》教材的第一篇读书笔记(不了解此事的朋友请阅读和小马宋一起读《市场营销》)。我们这一周阅读的是《市场营销》(以我手里...

原创小博客
38分钟前
3
0
js判断input输入保留正整数和两位小数实现方法

// 均价 checkKeydown(value, e){ this.registerForm.averagePrice = this.changeNumber2(value) }, // 预算 changsoldBudget(value) { this.registerFo......

五个半柠檬
39分钟前
4
0
Kafka+Flink 实现准实时异常检测系统

1.背景介绍 异常检测可以定义为“基于行动者(人或机器)的行为是否正常作出决策”,这项技术可以应用于非常多的行业中,比如金融场景中做交易检测、贷款检测;工业场景中做生产线预警;安防...

架构师springboot
45分钟前
3
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部