学步园

1.最近学习了hibernate映射和关联关系的内容，个人认为是非常重要的因此花了2天的时间学习了一下，以下会给出具体的实例。

2.首先我们需要知道利用hibernate来执行增删改查，这是最基本的操作（包括带分页的查询），以下是代码：

，这其中HibernateUtils是封装了一些每次测试都需要用到的模板代码，QueryResult类是封装了分页的信息，User是持久化类等等

   ①首先的工作就是导入jar包一系列操作。

   ②第二步我们首先需要创建一个实体类User，提供setter和getter方法，为了方便测试重写下tostring方法。

package com.icss.hibernate;

public class User {
	
	
	private Integer id;
	private String name;
	private int age;
	
	
	
	
	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
	}

	
	
	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 int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	
    
}

③写出user类对应的hbm文件

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

    <class name="User" table="USERS">

        <id name="id" type="java.lang.Integer">
            <column name="USER_ID" />
            <generator class="native" />
        </id>
        
        <property name="name" type="java.lang.String">
            <column name="USER_NAME" />
        </property>
        
         <property name="age" type="int">
            <column name="USER_AGE" />
        </property>
		
		

    </class>
</hibernate-mapping>

④配置一下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="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
		<property name="connection.url">jdbc:mysql:///321</property>
		<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="connection.username">root</property>
		<property name="hibernate.connection.password">123</property>

		<!-- 其他配置 -->
		<property name="hibernate.show_sql">true</property>
		<property name="hibernate.format_sql">true</property>
		<!-- 
			create：先删除，再创建
			update：如果表不存在就创建，不一样就更新，一样就什么都不做。
			create-drop：初始化时创建表，SessionFactory执行close()时删除表。
			validate：验证表结构是否一致，如果不一致，就抛异常。
		 -->
		<property name="hbm2ddl.auto">update</property>
	
	
		<!-- 导入映射文件 
		<mapping resource="cn/itcast/a_helloworld/User.hbm.xml"/>
		-->
		<mapping resource="com/icss/hibernate/set/User.hbm.xml"/>
		<mapping resource="com/icss/hibernate/map/Department.hbm.xml"/>
		<mapping resource="com/icss/hibernate/map/Employee.hbm.xml"/>
		<mapping resource="com/icss/hibernate/manytomany/Student.hbm.xml"/>
		<mapping resource="com/icss/hibernate/manytomany/Teacher.hbm.xml"/>
	
	
	
	</session-factory>
</hibernate-configuration>

⑤编写HibernateUtils，这里是为了封装一些代码防止在DAO‘代码中很多重复的代码出现（因为凡是涉及到数据库操作就必须有sessionFactory和session和Transcation）：

这里使用了一个static代码块是因为配置文件只需要执行一次sessionFactory只需要创建一次就可以了（关于static的使用见我上一个博文）

package com.icss.hibernate;

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

public class HibernateUtils {
   
	private static SessionFactory sessionFactory;
	
	static {
		
		sessionFactory=new Configuration()
		                .configure()
		                .buildSessionFactory();
	}
	
	public static SessionFactory getSessionFactory(){
		return sessionFactory;
		
		
	}
	
	public static Session getSession(){
		
		return sessionFactory.openSession();
		
	}

	
}

⑥编写UserDao类其中主要是增删改查方法的实现包括带分页的查询所有：

这个类编写的时候需要注意每个方法的返回值，注意异常的捕获和事务的操作，其中的删除操作是必须先获取到然后在根据id来删除的，其次findAll方法是获取所有记录返回的是一个list集合，最后一个方法需要进行分页处理，所有必须设置2个参数firstResult（代表的是索引），以及maxResult（代表的是一页显示多少条记录），最后会详细说明。这里用到的是HQL语句跟SQL不一样，这里的From后面跟的是对象实体类而不是表。

package com.icss.hibernate;

import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;

public class UserDao {

	public void save(User user){
		Session session=HibernateUtils.getSession();
		Transaction transaction=null;
		try {
			 transaction=session.beginTransaction();
			session.save(user);
			transaction.commit();
			
		} catch (RuntimeException e) {
			transaction.rollback();
			throw e;
		}finally{
			session.close();
		}
		
	}
	
	
	public void update(User user){
		
		Session session=HibernateUtils.getSession();
		Transaction transaction=null;
		try {
			 transaction=session.beginTransaction();
			
			 
			session.update(user);
			transaction.commit();
			
		} catch (RuntimeException e) {
			transaction.rollback();
			throw e;
		}finally{
			session.close();
		}
		
		
	}
	
	
	public void delete(int id){
		
		Session session=HibernateUtils.getSession();
		Transaction transaction=null;
		try {
			 transaction=session.beginTransaction();
         User user=    (User) session.get(User.class, id);
         session.delete(user);
			 transaction.commit();
			
			
		} catch (RuntimeException e) {
			transaction.rollback();
			throw e;
		}finally{
			session.close();
		}
	}
	
	
	public User getById(int id){
		Session session=HibernateUtils.getSession();
		Transaction transaction=null;
		try {
			 transaction=session.beginTransaction();
             User  user= (User) session.get(User.class, 1);
			 transaction.commit();
			 return user;
			
		} catch (RuntimeException e) {
			transaction.rollback();
			throw e;
		}finally{
			session.close();
		}
		
		
	}
	
	
	@SuppressWarnings("unchecked")
	public List<User> findAll(){
		
		Session session=HibernateUtils.getSession();
		Transaction transaction=null;
		try {
			 transaction=session.beginTransaction();
          List<User> list=   session.createQuery("FROM User").list();
             
			 transaction.commit();
			 return list;
			
		} catch (RuntimeException e) {
			transaction.rollback();
			throw e;
		}finally{
			session.close();
		}
		
		
		
	}
	
	public QueryResult findAll(int firstResult ,int maxResult){
		
		Session session=HibernateUtils.getSession();
		Transaction transaction=null;
		try {
			 transaction=session.beginTransaction();
			 List<User> list=   session.createQuery("FROM User").setFirstResult(firstResult).setMaxResults(maxResult).list();
          Long count=   (Long) session.createQuery("SELECT COUNT(*) FROM User").uniqueResult();
			 transaction.commit();
			 return new QueryResult(count.intValue(), list);
			
		} catch (RuntimeException e) {
			transaction.rollback();
			throw e;
		}finally{
			session.close();
		}
		
		
	}
	
}

⑦DAO写的时候我们需要知道最后一个分页查询方法返回的是2个值，不好显示，所以我们将这2个返回值（第一个返回值是count总记录数，第二个返回list集合）封装起来然后返回，代码如下：

package com.icss.hibernate;

import java.util.List;

public class QueryResult {
	
	private int count;
	private List list;
	
	
	public QueryResult(int count, List list) {
		
		this.count = count;
		this.list = list;
	}
	public int getCount() {
		return count;
	}
	public void setCount(int count) {
		this.count = count;
	}
	public List getList() {
		return list;
	}
	public void setList(List list) {
		this.list = list;
	}
	
	

}

⑧写测试代码HibernateTest，代码如下（先new对象）：

package com.icss.hibernate;

import static org.junit.Assert.*;

import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Before;
import org.junit.Test;

public class UserDaoTest {
	
	UserDao userDao =new UserDao(); 
	

	@Test
	public void testSave() {
		User user=new User();
		user.setName("jiangweiwei");
		user.setAge(11);
		userDao.save(user);
		
	}

	@Test
	public void testUpdate() {
		User user=new User();
		user.setName("zhangsan");
		user.setAge(22);
		userDao.update(user);
	}

	@Test
	public void testDelete() {
		userDao.delete(1);
	}

	@Test
	public void testGetById() {
	  User user=	userDao.getById(1);
	  System.out.println(user);
	}

	@Test
	public void testFindAll() {
	  List<User> list =	userDao.findAll();
	  for(User user : list){
		  System.out.println(user);
	  }
	}

	@Test
	public void testFindAllIntInt() {
//	 QueryResult queryResult =	    userDao.findAll(0, 10);
	 QueryResult queryResult =	    userDao.findAll(10, 10);
//	 QueryResult queryResult =	    userDao.findAll(20, 10);
	 
	 System.out.println("总记录数"+queryResult.getCount());
	 for(User  user :(List<User>) queryResult.getList()){
		 System.out.println(user);
	 }
	 
	}

}

附录：note如下：

（这是分页的思想）
假设共有25条记录，每页显示10条，则共3页。

firstResult
maxResults
----------------------------------------
第1页 0 10
第2页 10
10
第3页 20
10

total / pageSize
total % pageSize 

Session

SQL
查询的是表和表中的字段。
不区分大小写

HQL
Hibernate Query Language
与SQL相似
查询的是对象和对象中的属性。
关键字不区分大小写，但类名与属性名区分大小写。

==========================================================

API
1，API简介。
2，Session中的方法。
3，查询：HQL与Criteria

配置：
1，主配置文件
2，映射文件
映射基础
普通属性
主键
集合属性
关联关系
一对多/多对一
多对多
一对一
继承结构

-----------------------------------
-- API简介

Configuration 配置
configure()

configure(String resource)
addResource(String resource)导入一个指定位置的映射文件
addClass(Class clazz)导入与指定类同一个包中的以类名为前缀，后缀为.hbm.xml的映射文件
buildSessionFactory()

SessionFactory Session工厂
openSession()
getCurrentSession()
close()

Session 很重要的一个对象
操作对象的方法
save(Object)
update(Object)
delete(Object)
查询的方法
createQuery(String)--> Query
createCriteria(Class)
管理事务的方法
beginTransaction() --> Transaction
getTransaction()   --> Transaction获取当前Session中关联的事务对象
其他的方法
...

Transaction 事务
commit()
rollback()

Query 查询
list()
查询一个结果集合。
uniqueResult()查询一个唯一的结果，如果没有结果，则返回null，如果结果有多个，就抛异常。
...

--------------------------------

Hibernate主配置文件

1，配置的key前面的hibernate.前缀 可以有，也可以没有。如hibernate.dialect或dialect都可以。
2，按作用可分为三类：
1，数据库信息
<property ...>
方言、JdbcUrl、驱动、用户名、密码
2，导入映射文件
<mapping ...>
3，其他配置
<property ...>
show_sql
显示生成的SQL语句
format_sql
格式化生成的SQL语句
hbm2ddl.auto
自动生成表结构
hibernate.hbm2ddl.auto
生成表结构的两种方式：
1，hbm2ddl.auto
2，使用SchemaExport工具类
注意：只能建表，不能建库

==============
主键：
如果是数字，建议使用包装类型。

identity
sequence
hilo
native
assigned
uuid
foreign
...

东西太多下一篇在写映射集合映射跟关联关系！