hibernate复习第（一）天
首先导入jar。
这个版本是3.2.5
开发流程：
1、由Domain object ->mapping ->db （官方推荐）
2、由DB开始，使用工具生成mapping和Domain object。（常用）
3、由映射文件开始
hibernate的bean的要求：
1、有一个缺省的构造，也就是无参构造
2、有一个id属性，对应数据库的主键。（可选）
3、非final的类。对懒加载影响（可选）
mapping映射文件。模板可以从hibernate下载文件的eq文件夹下的子文件夹中找到：
<?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="cn.itcast.hibernate.domain"> <class name="User"> <id name="id" > <generator class="native"/> </id> <property name="name"/> <property name="birthday"/> </class> </hibernate-mapping>
class，对应java类，name对应类名，和package的属性组合得到类的地址
<class name="User" table="user">可以有一个table属性，对应数据库表名，不写表示默认与类名相同
<id name="id" column="id">可以有一个column属性，对应数据表中的列名，不写默认与类名相同
<generator >表示以何种方式生成主键
<property name="name" column="">属性，name对应java类的字段，column对应数据表的列名，也是可省略。如果对应的列名是唯一的的话，可以在<property 中加上unique="true"/>
注意：这里的hibernate映射文件就是用于说明java对象与哪个表中的记录相对应，以及java对象中的各个属性分别对应表中的哪一项，不同性质的属性（例如，主键和普通属性）用不同的标签来映射，如果java对象中的某个属性不需要存储在数据库中，那么在hibernate映射文件中就不需要配置这个属性。
两个问题：
关于使用表名和字段与关键字冲突的问题。
如果表名和字段与关键字啊发生冲突，解决方案有两种：
使用column和table，改表名或字段名;
如果表名或者字段名不允许更改，可以在table或者column中字段前面加上符号"`",例如：<class name="User" column="`user`">.这个符号是键盘中~对应的那个键在英文状态下的符号
hibernate.cfg.xml配置文件记不住怎么办？
这个我们一般不记，在hibernate文件夹下的etc文件夹下有一个hibernate.properties文件夹，这里所有的配置信息都可以在这里查找得到
hibernate.cfg.xml文件：模板在 etc文件夹下面可以找到：
<!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="hibernate.connection.url">jdbc:mysql://localhost:3306/demo</property> <property name="hibernate.connection.username">guodaxia</property> <property name="hibernate.connection.password">961012gz</property> <property name="hibernate.hbm2ddl.auto">create</property> <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> <property name="show_sql">true</property> <mapping resource="cn/itcast/hibernate/domain/User.hbm.xml"/> </session-factory> </hibernate-configuration>
注意：
url中直接写jdbc:mysql:///demo表示地址是本机，端口是默认端口3306
5个必填属性：
url、驱动、用户名、密码、方言（方言主要是各个数据库分页语句不一样）
hibernate.hbm2ddl.auto属性：
4个可选值：
create-drop（创建和删除，启动时创建，使用后删除，一般在测试使用）
create（创建，启动时创建，使用后不删除，再次启动前删除后再创建，一般测试使用）
update（更新）
validate（检验映射文件与表是否对应，如果不对应报错不执行更新操作）
show_sql属性：是否显示执行的sql语句
<mapping resource=""/>映射文件的路径
hibernate如何操作数据库。
/* * hibernate初始化的过程，这个过程一般只做一次 * 所以我们一般做一个工具类 */ Configuration cfg=new Configuration(); cfg.configure(); SessionFactory sf=cfg.buildSessionFactory(); Session s=sf.openSession();
首先得到Configuration对象，使用该构造hibernate会自动加载classpath下面的hibernate.properties文件;
cfg.configuration();如果存在的话，hibernate自动加载classpath下的hibernate.cfg.xml配置文件。当然也可以加参数表示映射文件的文件路径和文件名，所以如果即写了hibernate.properties又写了hibernate.cfg.xml如果有相同属性配置，后者会覆盖前者。
创建sessionFactory工厂，这个类似于JDBC的DriverManager；
通过工厂创建session，session相当于JDBC中的Connection。
说明：
既然取读的是classpath下面的内容，为什么我们的配置文件都是放在src下面呢？这是因为myeclipes编译的时候会自动将src目录下的文件编译到classpath中去。
操作数据表：使用Session接口。
因为hibernate文件初始化比较耗费资源，我们一般书写一个工具类帮助处理：
package cn.itcast.hibernate; import java.io.Serializable; import org.hibernate.HibernateException; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.Transaction; import org.hibernate.cfg.Configuration; public final class HibernateUtil { /* * 设计成为单例，或者将所有的放射设计成为静态的 */ private static SessionFactory sessionFactory; private static ThreadLocal<Session> sessionThread;/* 使用threadLocal优化连接 */ private HibernateUtil(){ } static{ Configuration cfg=new Configuration(); cfg.configure();//从classPath里面读取配置文件。如果名字不是hibernate.cfg.xml的话需要特定指出，src下的文件会自动编译到classPath中 sessionFactory=cfg.buildSessionFactory(); sessionThread=new ThreadLocal<Session>(); } public static SessionFactory getSessionFactory(){ return sessionFactory; } public static Session getSession(){ Session s=sessionThread.get(); if(s==null){ s=sessionFactory.openSession(); }else{ sessionThread.set(s); } return s; } }
java对象的几种状态：
对象状态
瞬时（transient）：数据库中没有数据与之对应，超过作用域会被JVM垃圾回收器回收，一般是new出来的与session没有关联的对象
持久（persistent）：数据库中有数据与之对应，当前与session有关联，并且相关联的session没有关闭，事务没有提交，持久对象状态发生改变，在事务提交时会影响到数据库（hibernate能检测到）；
持久化状态的时候如果你修改了该对象会自动调用update方法。
脱管：数据库中有数据与之对应，当前session与之无关联。save等操作后的java类或者查询得到的java类都是这种状态。托管状态的对象修改后只能是自己调用update方法才能对数据库进行修改。
Session对象的一些常见方法：
Transaction beginTransaction();开启事务
get(Class,Serializable)根据主键获取一条数据
load(Class,Serializable)根据主键获取一条数据.具有懒加载特性。懒加载类似new一封User子类
save(Object).保存一条数据
persist(Object).保存一条数据。
save和persist的区别是：在没有开启事务的情况下，save方法会先插入数据再回滚，而persist方法不会插入记录也就不需要回滚
update(Object):将对象更新到数据库
saveOrUpdate(Object):hibernate自动检测对象是瞬时状态还是脱管状态，然后执行insert或者update语句
merge(Object):和saveOrUpdate类似，区别在saveOrUpdate方法操作之后会改变对象的状态，变成持久状态，而merge之后还是脱管状态
Session s=HibernateUtil.getSession(); User user=new User(); user.setName("zhangSan"); user.setBirthday(new Date()); s.save(user); s.close();
上面的代码执行完之后，sql语句正常但是数据库中却没有任何记录。这是因为：
JDBC是自动提交的，但是hibernate的缺省将这个功能关闭，必须自己开启使用事务才会生效。事务的创建方式：
Transaction tx=session.beginTransaction();
如果不需要开启提交事务提交事务就可以操作数据库数据的话，注意一下你的表结构，看你的引擎
标准的操作数据库的结构：
static void addUser(User user){//比较规范的hibernate的一个写法 Session s=null; Transaction tx=null; try{ s=HibernateUtil.getSession();; tx=s.beginTransaction(); s.save(user); user.setName("new name");//这个user是持久状态 user.setBirthday(new Date()); tx.commit(); }catch(HibernateException e){ if(tx!=null) tx.rollback(); throw e; }finally{ if(s!=null) s.close(); } }
操作数据库的结构也可以写成这个样子：
static void addUser1(User user){//可以简写成为这个样子，因为hibernate接到异常会自动向外抛，如果数据库没有得到事务提交信号请求会自动回滚 Session s=null; Transaction tx=null; try{ s=HibernateUtil.getSession();; tx=s.beginTransaction(); s.save(user); tx.commit(); }finally{ if(s!=null) s.close(); } }
基本操作的一些代码：
package cn.itcast.hibernate; import java.util.Date; import org.hibernate.HibernateException; import org.hibernate.Session; import org.hibernate.Transaction; import org.junit.Test; import cn.itcast.hibernate.domain.User; public class Base { public static void main(String[] args) { /* * hibernate初始化的过程，这个过程一般只做一次 * 所以我们一般做一个工具类 */ // Configuration cfg=new Configuration(); // cfg.configure(); // SessionFactory sf=cfg.buildSessionFactory(); // Session s=sf.openSession(); Session s=HibernateUtil.getSession(); //JDBC是自动提交的，但是hibernate的缺省将这个功能关闭，必须自己开启使用事务才会生效 //如果必须要开启提交事务就可以操作数据库数据的话，注意一下你的表结构，看你的引擎 User user=new User(); user.setName("zhangSan"); user.setBirthday(new Date()); // Transaction tx=s.beginTransaction(); // s.save(user); // tx.commit(); // s.close(); // System.out.println("end"); addUser(user); System.out.println("id:"+user.getId()); // User u=getUser(user.getId()); User u=(User) s.load(User.class, user.getId()); System.out.println("name:"+u.getName()); } static void addUser(User user){//比较规范的hibernate的一个写法 Session s=null; Transaction tx=null; try{ s=HibernateUtil.getSession();; tx=s.beginTransaction(); s.save(user); // s.persist(user); user.setName("new name");//这个user是持久状态 user.setBirthday(new Date()); tx.commit(); }catch(HibernateException e){ if(tx!=null) tx.rollback(); throw e; }finally{ if(s!=null) s.close(); } } static void addUser1(User user){//可以简写成为这个样子，接到异常自动向外抛，如果数据库没有得到提交请求会自动回滚 Session s=null; Transaction tx=null; try{ s=HibernateUtil.getSession();; tx=s.beginTransaction(); s.save(user); tx.commit(); }finally{ if(s!=null) s.close(); } } @Test public void fun1(){ System.out.println(getUser(1)); } public static User getUser(int id){ Session s=null; User user=null; try{ s=HibernateUtil.getSession(); user=(User) s.get(User.class, 1); // user=(User) s.load(User.class,1);//这里会报错 }finally{ if(s!=null) s.close(); } return user; } } public static void add(Object entity){ Session s=null; Transaction tx=null; try{ s=getSession(); tx=s.beginTransaction(); s.save(entity); tx.commit(); }catch(HibernateException e){ tx.rollback(); throw e; }finally{ if(s!=null) s.close(); } } public static void delete(Object entity){ Session s=null; Transaction tx=null; try{ s=getSession(); tx=s.beginTransaction(); s.delete(entity); tx.commit(); }catch(HibernateException e){ tx.rollback(); throw e; }finally{ if(s!=null) s.close(); } } public static void update(Object entity){ Session s=null; Transaction tx=null; try{ s=getSession(); tx=s.beginTransaction(); s.update(entity); tx.commit(); }catch(HibernateException e){ tx.rollback(); throw e; }finally{ if(s!=null) s.close(); } } public static Object get(Class clazz,Serializable id){ Session s=null; try{ s=getSession(); return s.get(clazz, id); }catch(HibernateException e){ throw e; }finally{ if(s!=null) s.close(); } } public static Object load(Class clazz,Serializable id){ Session s=null; try{ s=getSession(); return s.load(clazz, id); }catch(HibernateException e){ throw e; }finally{ if(s!=null) s.close(); } }
关于load()和get()的区别：
两者都是根据类的字节码文件和ID得到一条数据。区别在于：
第一点是：没有记录的情况下，load会抛出异常，get会返回空，一般采用的load方法。
第二点是：get只返回实体对象实例。而load返回的是代理类实体对象实例。
第三点是：get方法只能使用一级缓存。而load可以使用一级和二级缓存。
第四点是：都是通过id得到单个对象的方法。
第五点：load方法具有懒加载的特性，不是立即操作数据库，而是返回一个代理对象，在操作该对象的属性的时候才操作数据库将信息填入。
关于save()和persist()的区别：
在不开启事务的情况下，save方法会先插入数据再回滚，而persist方法不会插入记录
update、saveOrUpdate、merge的区别见我的其他博客：
http://www.cnblogs.com/aigeileshei/p/5796788.html
前面学习了增删改和根据id进行查询。但是查询语句往往比较复杂，hibernate提供了两种方式进行数据库表的查询操作：HQL和Criteria
HQL：
面向对象的查询语言，与SQL不同，HQL中的对象名是区分大小写的（除了JAVA类和属性其他部分不区分大小写）；HQL中查的是对象而不是表，而且支持多态；
HQL主要通过Query来操作，Query的创建方式：
Query q=session.createQuery(hql);
Query的主要方法：
list():将query对象中的结果集变成list集合
uniqueResult():将query对象中的结果集变成一个Object对象，当结果集中对象数>1的时候会报异常
setXxx()和getXxx()方法，类似于pstmt的getXxx和setXxx
setFirstResult(number);//设置query查询的结果从第多少条记录开始
setMaxResults(number);//查询的结果多少条。使用上面的和这个方法可以进行分页，而且不限制数据库。这个分页应该是根据方言hibernate封装的
HQL语句中占位符与命名参数的使用：
hql语句中占位符的使用：
String hql="from User as user where user.name=?"; Query query=s.createQuery(hql); query.setString(0,name);
这里注意，下标是从0开始的。
命名参数的使用：
单纯的占位符使用不是很方便，因为每一个?与数据都需要一一对应。hibernate提供了命名参数。
String hql="from User as user where user.name=:n"; Query query=s.createQuery(hql); query.setString("n"name);
同一个命名参数可以多次使用
命名参数在hql中=:命名参数名。格式注意正确。
将命名参数设置进Query中们可以使用后Map结合如果参数过多的话，这样比较简便一些：
static void qr(){ Session s=HibernateUtil.getSession(); String hql="from User where name=:name and age>:bj and (age-:bj)>0"; Query query=s.createQuery(hql); Map <String,Object> params=new HashMap<String,Object>(); params.put("name", "guodaxia"); params.put("bj",12); query.setProperties(params); List<User> users=query.list(); }
hql查询的简单例子：
package cn.itcast.hibernate; import java.util.Date; import java.util.Iterator; import java.util.List; import org.hibernate.Query; import org.hibernate.Session; import cn.itcast.hibernate.domain.User; public class QueryTest { public static void main(String[] args) { User user=new User(); user.setBirthday(new Date()); user.setName("name"); HibernateUtil.add(user); System.out.println(query("name")); } static User query(String name){ Session s=null; try{ s=HibernateUtil.getSession(); // String hql="from User as user where user.name=?"; String hql="from User as user where user.name=:n"; Query query=s.createQuery(hql); // query.setString(0, name);//下标从0开始 query.setString("n", name); //设置结果集的范围，可用来分页 query.setFirstResult(200); query.setMaxResults(10); List<User> list=query.list();//executeQuery() User user=(User) query.uniqueResult(); // for(Iterator<User> it=list.iterator();it.hasNext();){ // User user=it.next(); // list.add(user); //// System.out.println(user); // } // return list.get(0); return user; }finally{ if(s!=null) s.close(); } } }
Criteria（条件查询）：
是一种比hql更加面向对象的一种方式。
创建方式：
Criteria crit=session.createCriteria(User.class);
条件查询关于条件的添加与query不一样，在处理结果集方面与query基本一致。
简单属性条件如：
criteria.add(Restrictions.eq(propertyName,value)),
criteria.add(Restrictions.eqProperty(propertyName,otherPropertyName))
Restrictions对象中封装了许多条件查询的增加条件的方法。可以配合API使用
Criteria查询的小例子：
package cn.itcast.hibernate; import java.util.Date; import java.util.List; import org.hibernate.Criteria; import org.hibernate.Session; import org.hibernate.criterion.Restrictions; import cn.itcast.hibernate.domain.User; public class Cri { public static void main(String[] args) { cri("name"); } static void cri(String name){ Session s=null; try{ s=HibernateUtil.getSession(); Criteria c=s.createCriteria(User.class);//条件查询，很面向对象的方式。这个接口相当于一个容器 c.add(Restrictions.eq("name", name));//添加约束条件 c.add(Restrictions.lt("birthday", new Date())); c.setFirstResult(0); c.setMaxResults(10); List<User> list=c.list(); User u=(User)c.uniqueResult(); System.out.println(u); for(User user:list){ System.out.println(user.getName()); } }finally{ if(s!=null) s.close(); } } }
