hibernate-001

package com.hibernate.domain;

import java.util.Date;

public class User {
	
	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 Date getBirthday() {
		return birthday;
	}
	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}
	private int id;
	private String name;
	private Date birthday;
}

 

<?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.hibernate.domain">

	<class name="User" table="user">
		<id name="id">
			<generator class="native" />
		</id>
		<property name="name"/>
		<property name="birthday"/>
	</class>
</hibernate-mapping>

 

<!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="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="connection.url">jdbc:mysql:///hibernate</property>
		<property name="connection.username">root</property>
		<property name="connection.password">789+</property>
		
		<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
		
		<property name="connection.password">789+</property>
		<property name="hbm2ddl.auto">create</property>

		<!--  
		<class-cache class="com.hibernate.domain.User" usage="read-only"/>
		-->
		<mapping resource="com/hibernate/domain/User.hbm.xml"/>
	</session-factory>
</hibernate-configuration>

 

package com.utils;

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

public final class HibernateUtil {
	private static SessionFactory sessionFactory;
	private HibernateUtil(){
		
	}
	
	public static SessionFactory getSessionFactory() {
		return sessionFactory;
	}

	static{
		Configuration cfg = new Configuration();
		cfg.configure();
		sessionFactory = cfg.buildSessionFactory();
	}
	
	public static Session getSession(){
		return sessionFactory.openSession();
	}
}

 

package com.hibernate;

import java.util.Date;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.hibernate.domain.User;
import com.utils.HibernateUtil;

public class Base {
	public static void main(String[] args) {
		User user = new User();
		user.setBirthday(new Date());
		user.setName("Eric");
		
		addUser(user);
		System.out.println("id"+user.getId());
	}
	
	static void addUser(User user){
		Session s = null;
		Transaction tx = null;
		try{
			s = HibernateUtil.getSession();
			tx = s.beginTransaction();
			s.save(user);
			tx.commit();
		}catch (HibernateException e) {
			if(tx != null){
				tx.rollback();
			}
			throw e;
		}finally{
			if(s != null){
				s.close();
			}
		}
	}
}

  

评论

5 楼 csdn_zuoqiang 2010-08-01  

Session的几个主要方法
1.save,persist保存数据，persist在事务外不会产生insert语句。
2.delete,删除对象
3.update,更新对象，如果数据库中没有记录，会出现异常。
4.get,根据ID查，会立刻访问数据库。
5.Load，根据ID查，(返回的是代理，不会立即访问数据库)。
6.saveOrUpdate,merge(根据ID和version的值来确定是save或update),调用merge你的对象还是托管的。
7.lock(把对象变成持久对象，但不会同步对象的状态)。

4 楼 csdn_zuoqiang 2010-07-31  

hibernate的三种状态区别：
1：瞬时态
   与session无关，与数据库无关；
2：持久态
   处于session容器中，在数据库中有记录；
3：脱管态
   脱离session容器管理，在数据库中有记录。

瞬时态 调用save()方法——》持久态  调用commit(),close()方法 ——》脱管态

要更新数据库中的数据，对脱管态的数据调用update()方法。

3 楼 csdn_zuoqiang 2010-07-31  

所有的Hibernate应用中都会访问Hibernate的5个核心接口。hibernate中的几个核心接口如下:

Configuration接口：配置Hibernate,根启动Hibernate，创建SessionFactory对象。
SessionFactory接口：初始化Hibernate，充当数据存储源的代理，创建Session对象。

Session接口：负责保存、更新、删除、加载和查询对象。

Transaction：管理事务。

Query和Criteria接口：执行数据库查询。



详细的介绍hibernate中的几个核心接口:

1.SessionFactory接口

一个SessionFactory实例对应一个数据存储源，应用从SessionFactory中获得Session实例。SessionFactory有以下特点：

它是线程安全的，这意味着它的同一个实例可以被应用的多个线程共享。

它是重量级的，这意味着不能随意创建或销毁它的实例。如果应用只访问一个数据库，只需要创建一个SessionFactory实例，在应用初始化的时候创建该实例。如果应用同时访问多个数据库，则需要为每个数据库创建一个单独的SessionFactory实例。

之所以称SessionFactory是重量级的，是因为它需要一个很大的缓存，用来存放预定义的SQL语句以能映射元数据等。用户还可以为SesionFactory配置一个缓存插件，这个缓存插件被称为Hibernate的第二级缓存。，该缓存用来存放被工作单元读过的数据，将来其他工作单元可能会重用这些数据，因此这个缓存中的数据能够被所有工作单元共享。一个工作单元通常对应一个数据库事务。

2.Configuration接口

Configuration对象用于配置并且启动Hibernate。Hibernate应用通过Configuration实例来指定对象-关系映射文件的位置或者动态配置Hibernate的属性，然后创建SessionFactory实例。

3.Query和Criteria接口

Query和Criteria接口是Hibernate的查询接口，用于向数据库查询对象，以及控制执行查询的过程。Query实例包装了一个HQL查询语句，HQL查询语句和SQL查询语句有些相似，但HQL查询语句是面向对象的，它引用类句及类的属性句，而不是表句及表的字段句。Criteria接口完全封装了基于字符串的查询语句，比Query接口更加面向对象，Criteria接口擅长执行动态查询。Session接口的find()方法也具有数据查询功能，但它只是执行一些简单的HQL查询语句的快捷方法，它的功能远没有Query接口强大。

4.Session接口

Session接口是Hibernate应用使用最广泛的接口。Session也被称为持久化管理器，它提供了和持久化相关的操作，如添加、更新、删除、加载和查询对象。

Session有以下特点：
不是线程安全的，因此在设计软件架构时，应该避免多个线程共享同一个Session实例。
Session实例是轻量级的，所谓轻量级，是指它的创建和销毁不需要消耗太多的资源。这意味着在程序中可以经常创建和销毁Session对象，例如为每个客户请示分配单独的Session实例，或者为每个工作单元分配单独的Session实例。
Session有一个缓存，被称为Hibernate的第一级缓存，它存放被当前工作单元加载的对象。每个Session实例都有自己的缓存，这个Sesion实例的缓存只能被当前工作单元访问。

5.Transaction接口

Transaction接口是Hibernate的数据库事务接口，它对底层的事务接口做了封装，底层事务接口包括：

JDBC API、JTA(Java Transaction API)、CORBA(Common Object Requet Broker Architecture)API

Hibernate应用可通过一致的Transaction接口来声明事务边界，这有助于应用在不同的环境容器中移植。尽管应用也可以绕过Transaction接口，直接访问底层的事务接口，这种方法不值得推荐，因为它不利于应用在不同的环境移植。

要想学好hibernate，肯定要熟练的掌握这些核心接口的用法。

2 楼 csdn_zuoqiang 2010-07-31  

Hibernate中get和load方法的区别：

1. 对于Hibernate get方法，Hibernate会确认一下该id对应的数据是否存在，首先在session缓存中查找，然后在二级缓存中查找，还没有就查询数据库，数据 库中没有就返回null。这个相对比较简单，也没有太大的争议。主要要说明的一点就是在这个版本中get方法也会查找二级缓存！

2. Hibernate load方法加载实体对象的时候，根据映射文件上类级别的lazy属性的配置(默认为true)，分情况讨论：

(1)若为true,则首先在Session缓存中查找，看看该id对应的对象是否存在，不存在则使用延迟加载，返回实体的代理类对象(该代理类为 实体类的子类，由CGLIB动态生成)。等到具体使用该对象(除获取OID以外)的时候，再查询二级缓存和数据库，若仍没发现符合条件的记录，则会抛出一 个ObjectNotFoundException。

(2)若为false,就跟Hibernate get方法查找顺序一样，只是最终若没发现符合条件的记录，则会抛出一个ObjectNotFoundException。

这里get和load有两个重要区别:

如果未能发现符合条件的记录，Hibernate get方法返回null，而load方法会抛出一个ObjectNotFoundException。
load方法可返回没有加载实体数据的代 理类实例，而get方法永远返回有实体数据的对象。(对于load和get方法返回类型：好多书中都说：“get方法永远只返回实体类”，实际上并不正 确，get方法如果在session缓存中找到了该id对应的对象，如果刚好该对象前面是被代理过的，如被load方法使用过，或者被其他关联对象延迟加 载过，那么返回的还是原先的代理对象，而不是实体类对象，如果该代理对象还没有加载实体数据（就是id以外的其他属性数据），那么它会查询二级缓存或者数 据库来加载数据，但是返回的还是代理对象，只不过已经加载了实体数据。)
总之对于get和load的根本区别，一句话，hibernate对于 load方法认为该数据在数据库中一定存在，可以放心的使用代理来延迟加载，如果在使用过程中发现了问题，只能抛异常；而对于get方 法，hibernate一定要获取到真实的数据，否则返回null。

1 楼 csdn_zuoqiang 2010-07-31  

save 与 persist 的区别：（没开启事务的时候体现出）
1：在都没有开启事务的时候save方法，
static void addUser(User user){
Session s = null;
Transaction tx = null;
try{
s = HibernateUtil.getSession();
//tx = s.beginTransaction();
s.save(user);
//tx.commit();
}catch (HibernateException e) {
if(tx != null){
tx.rollback();
}
throw e;
}finally{
if(s != null){
s.close();
}
}
}
产生
Hibernate: insert into user (name, birthday) values (?, ?)
id1
Hibernate: select user0_.id as id0_0_, user0_.name as name0_0_, user0_.birthday as birthday0_0_ from user user0_ where user0_.id=?
name:Eric
有sql语句，但是数据库中没有数据，因为没有事务提交，导致回滚删除记录。

1：在都没有开启事务的时候persist方法，
static void addUser(User user){
Session s = null;
Transaction tx = null;
try{
s = HibernateUtil.getSession();
//tx = s.beginTransaction();
//s.save(user);
s.persist(user);
//tx.commit();
}catch (HibernateException e) {
if(tx != null){
tx.rollback();
}
throw e;
}finally{
if(s != null){
s.close();
}
}
}
产生
id0
Hibernate: select user0_.id as id0_0_, user0_.name as name0_0_, user0_.birthday as birthday0_0_ from user user0_ where user0_.id=?
Exception in thread "main" java.lang.NullPointerException
at com.hibernate.Base.main(Base.java:21)
不能往数据库中插入数据。