hibernate总结
Hibernate学习笔记
Hibernate项目的构建与配置1.在项目里倒入Hibernate所必须的Jar包(1)Hibernate框架可以使用在任何的Java项目里，并不一定是Web项目。
只需要在项目里倒入Hibernate所必须要使用的jar包就可以了。
(2)在Hibernate的官网下载hibernate-release-4.2.2.Final.zip解压，要使用Hibernate必须导入的jar包就在目录“hibernate-release-4.2.2.Final\lib\required”下。
倒入此路径下的所有jar包就可以了。
2.配置hibernate.cfg.xml文件(1)配置hibernate.cfg.xml文件可以参考“\project\etc”目录下的hibernate.cfg.xml文件与hibernate.properties文件。
(2)使用Hibernate连接MySQL的hibernate.cfg.xml配置文件如下：<hibernate-configuration><session-factory>（设置显示Hibernate产生的SQL语句）<property name="show_sql">true</property>（设置MySQL的SQL语法的方言）<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>（设置MySQL的驱动程序）<property name="hibernate.connection.driver_class">org.gjt.mm.mysql.Driver</property>（设置MySQL的数据库路径、用户名、密码）<property name="hibernate.connection.url">jdbc:mysql:///java</property><property name="ername">root</property><property name="hibernate.connection.password">lizhiwei</property>（设置当数据库要保存的表不存在时，就新建表）<property name="hibernate.hbm2ddl.auto">update</property>（设置对象与数据库表的关系映射文件）<mapping resource="vo/User.hbm.xml"/></session-factory></hibernate-configuration>(3)此配置文件一般放在项目的src目录下。
hibernate内部测试题总结
hibernate内部测试题总结在Hibernate中，关于脏检查和刷新缓存说法正确的是（ab ）。
A．当事务提交时，会发⽣脏检查B．Session的flush( )⽅法是刷新缓存的⽅法C．在执⾏Session的commit( )⽅法之前不会调⽤Session的flush( )⽅法D．编写代码时，调⽤commit( )⽅法之前要调⽤flush( )⽅法解析：在执⾏Session的commit（）⽅法之前会调⽤Session的flush（）⽅法 C错误 调⽤commit（）⽅法都不是⼿动调⽤flush（）⽅法使⽤HQL查询所有部门信息，以下正确的是（ b）。
A．from DeptB．select * from cn.jbit.demo.entity.DeptC．select Dept from cn.jbit.demo.entity.Dept dD．select d from Dept d解析：HQL查询信息没有 *关于Query接⼝的list( )和iterate( )⽅法，说法正确的是（ ad）。
A．执⾏list( )⽅法，查询所有符合条件的记录B．执⾏iterate( )⽅法，查询所有符合条件的记录C．执⾏list( )⽅法，查询出所有符合条件的主键值D．执⾏iterate ( )⽅法，查询出所有符合条件的主键值解析：list（）是查询⼿游符合条件的记录 iterate（）是查询出所有符合条件的5．在HQL中，关于Query接⼝绑定参数的⽅法，说法正确的是（ ABCD）。
A．setParameter( )⽅法⽤于绑定任意类型的参数B．setParameter( )有重载的⽅法C．setProperties( )有重载的⽅法D．setProperties( )⽅法⽤于绑定命名参数6．在Hibernate中，关于以下映射配置，说法错误的是（D）。
<hibernate-mapping><class name="cn.jbit.hibernatedemo.entity.Emp" table="EMP" schema="scott"> <id name="empNo" column="EMPNO" type="ng.Integer"><generator class="assigned"/></id><property name="salary" type="ng.Double" column="SAL"/><property name="hireDate" type="java.util.Date"/><many-to-onename="dept"column="DEPTNO"class="cn.jbit.hibernatedemo.entity.Dept"/></class></hibernate-mapping>A．此配置信息描述了cn.jbit.hibernatedemo.entity.Emp类和EMP表的映射B．描述的是scott⽤户的EMP表C．<many-to-one>标签中的name属性值dept是cn.jbit.hibernatedemo.entity.Emp类的属性名D．<many-to-one>标签中的column属性值DEPTNO是dept表的主键名解析：D选项中column属性值deptNo是emp表中的外键列7．在Hibernate映射⽂件中，关于inverse属性说法正确的是（ACD）。
Hibernate 中的HQL查询的总结(夏杰)
Hibernate 中的HQL查询的总结一．Spring+Hibernate 中1.保存一个实体getHibernateTemplate().save(user);2.根据id号从数据库中查询到一个实体Useruser=(User)getHibernateTemplate().load(User.class,fromUse rId));3.删除一个实体方法一：直接删除getHibernateTemplate().delete((Message)；方法二：嵌套一个根据id号查询到一个实体，再删除getHibernateTemplate().delete((Message)getHibernateTempla te().load(Message.class, msgId));4.查询符合添加的记录的个数，函数count(*)Object obj = getSession().createQuery("select count(*)from Message where recepUser.id="+recepUserId+" and msgType=1").uniqueResult();//表示只返回一个结果5.修改一个实体getHibernateTemplate().update(message);6.设定查询记录的起始位置和得到的记录数List<Message> list = getSession().createQuery("from Message where (fromUser.id="+userId+" or recepUser.id="+userId+") and msgType=2 order by id desc").setMaxResults(想要得到的记录数).setFirstResult(取得记录的起点).list();7. intValue()返回的结果是整数int msgCount=((Long)getSession().createQuery("select count(*) from Message where from User.id="+userId+" or recepUser.id="+userId).uniqueResult()).intValue();二．只有Hibernate 中1.保存数据/*** 保存数据** @param t传入的泛型* @return*/public boolean save(T t) {session = HibernateUtil.getSession();try {session.beginTransaction();session.save(t);session.getTransaction().commit();} catch (Exception e) {e.printStackTrace();session.getTransaction().rollback();return false;} finally {HibernateUtil.closeSession(session);}return true;}2.删除数据/*** 删除数据** @param t传入的泛型* @return*/public boolean delete(T t) {session = HibernateUtil.getSession();try {session.beginTransaction();session.delete(t);session.getTransaction().commit();} catch (Exception e) {e.printStackTrace();session.getTransaction().rollback();return false;} finally {HibernateUtil.closeSession(session);}return true;}3.修改数据/*** 修改数据** @param t传入的泛型* @return*/public boolean update(T t) {session = HibernateUtil.getSession();try {session.beginTransaction();session.update(t);session.getTransaction().commit();} catch (Exception e) {e.printStackTrace();session.getTransaction().rollback();return false;} finally {HibernateUtil.closeSession(session);}return true;}4.查询单条数据，返回查询得到的唯一的结果实体对象/*** 查询单条数据** @param hql* @return返回查询得到的唯一的结果实体对象*/public T queryFrom(String hql) {// T表示泛型对象,T泛型定义T t = null;// 引用实体对象session = HibernateUtil.getSession();try {session.beginTransaction();Query query = session.createQuery(hql);// 执行传递来的hql查询語句t = (T) query.uniqueResult();// 将查询结果转换为实体对象session.getTransaction().commit();} catch (Exception e) {e.printStackTrace();session.getTransaction().rollback();} finally {HibernateUtil.closeSession(session);}return t;// 返回查询得到的实体对象}5.通过泛型定义的查询多条语句方法/*** 通过泛型定义的查询多条语句方法** @param hql** @return 查询得到的结果集List*/public List<T> queryList(String hql) {session = HibernateUtil.getSession();List<T> list = null;try {session.beginTransaction();Query query = session.createQuery(hql);// 执行传递来的hql查询语句list = query.list();// 将查询返回的结果集转换成List集合session.getTransaction().commit();} catch (Exception e) {e.printStackTrace();session.getTransaction().rollback();} finally {HibernateUtil.closeSession(session);}return list;// 返回查询得到的集合对象}6. 返回指定条数的查询结果的方法/*** 返回指定条数的查询结果的方法** @param hql* @param showNumber所要查询的数据的结果的条数* @return返回查询得到的集合对象*/public List<T> queryTypeListNumber(String hql, int showNumber,Type type) {session = HibernateUtil.getSession();List<T> list = null;try {session.beginTransaction();Query query = session.createQuery(hql);// 执行传递来的hql查询语句// for(int i=0;i<params.length;i++){//把传递过来的参数数组遍历出来，遍历赋值给hql语句中的未知待定数据// query=query.setParameter(i, params[i]);// }query=query.setParameter(0, type);query.setMaxResults(showNumber);// 设这所要查询的数据的结果的条数list = query.list();// 将查询返回的结果集转换成List集合session.getTransaction().commit();} catch (Exception e) {e.printStackTrace();session.getTransaction().rollback();} finally {HibernateUtil.closeSession(session);}return list;// 返回查询得到的集合集合对象}7.查询所有用户信息String hql = "from User";list = session.createQuery(hql) //创建Query对象 .list();8.保存用户session.save(user);9.通过用户名和密码查询用户（参数不一定，用动态赋值）//HQL查询语句String hql = "from User u where ername=? and u.password=?";Query query = session.createQuery(hql) //创建Query对象.setParameter(0, username)//动态赋值.setParameter(1, password);//动态赋值10.判断指定用户名的用户是否存在//HQL查询语句String hql = "from User u where ername=?";Query query = session.createQuery(hql) //创建Query对象.setParameter(0, username);//动态赋值Object user = query.uniqueResult();//返回User对象//如果用户存在exist为trueif(user != null){exist = true;}11.根据id删除一条留言信息//加载指定id的留言信息Message message = (Message)session.get(Message.class, id);session.delete(message); //删除留言12.查询所有文章中都有哪些作者（Group By）hql = "select author from ArticleInfo group by author";//查询文章详细信息的hql语句List authorList = objectDao.queryListObject(hql);//执行查询request.setAttribute("authorList", authorList);13.分组查询，各部门名称和各部门的人数（Group By）hql="select u.dept,count(*) from User u group by u.dept";Query query=session.creatQuery(hql);List<Object[]> list=query.list();//object[]是数组，可以同时多个属性查询obj[o],obj[1],obj[2],,,,//for循环输出信息For(object[] obj;list){Sysout.("部门"+obj[0]);Sysout.("人数"+obj[1])}14.查询文章的回复// 文章回复内容的详细查询hql = "from ReArticleInfo where re_id=" + id + " order by id desc";//查询文章详细内容的hql语句ObjectDao<ReArticleInfo> re_objectDao = new ObjectDao<ReArticleInfo>();//实例化持久化类List<ReArticleInfo> list = null;//定义List集合15.In的条件嵌套查询（双重条件，条件在其他表中）跨表hql_article_commend = "from ArticleInfo where commend='是' and author in (select account from UserInfo where freeze='解冻')";hql_article_vistor = "from ArticleInfo where author in (select account from UserInfo where freeze='解冻') order by visit desc";16.多对一映射在user表中，通过Author对象查询userString hql="from Category c wherec.typeName='"+category.getTypeName()+"'andc.author='"+category.getAuthor().getId()+"'";。
Hibernate注解中CascadeType用法汇总
Hibernate注解中CascadeType用法汇总在Hibernate中，CascadeType注解用来配置实体之间的级联操作。
级联操作是指在对一个实体进行持久化、更新、删除等操作时，同时也对关联的其他实体进行相应的操作。
CascadeType注解常用于一对一、一对多、多对多等关联关系中。
CascadeType注解的常用取值有以下几种：1. CascadeType.ALL：表示所有的级联操作，包括持久化、更新、删除等。
2. CascadeType.PERSIST：表示级联持久化操作，即当实体被持久化时，关联的其他实体也会被持久化。
3. CascadeType.MERGE：表示级联更新操作，即当实体被更新时，关联的其他实体也会被更新。
4. CascadeType.REMOVE：表示级联删除操作，即当实体被删除时，关联的其他实体也会被删除。
5. CascadeType.REFRESH：表示级联刷新操作，即当实体被刷新时，关联的其他实体也会被刷新。
6. CascadeType.DETACH：表示级联脱管操作，即当实体脱管时，关联的其他实体也会被脱管。
7. CascadeType.ALL_DELETE_ORPHAN：表示级联删除操作，并且会删除所有孤儿实体。
下面是对CascadeType注解的使用方法进行汇总：1.一对一关联关系：```private Address address;```上述代码表示当保存、更新或删除一个实体对象时，操作对应的address实体也会被保存、更新或删除。
2.一对多关联关系：```private List<Order> orders;```上述代码表示当保存、更新或删除一个用户对象时，操作对应的所有订单对象也会被保存、更新或删除。
3.多对多关联关系：```private List<Role> roles;```上述代码表示当保存、更新或删除一个用户对象时，操作对应的所有角色对象也会被保存、更新或删除。
hibernate框架的工作原理
hibernate框架的工作原理Hibernate框架的工作原理Hibernate是一个开源的ORM(Object-Relational Mapping)框架，它将Java对象映射到关系型数据库中。
它提供了一种简单的方式来处理数据持久化，同时也提供了一些高级特性来优化性能和可维护性。
1. Hibernate框架的基本概念在开始讲解Hibernate框架的工作原理之前，需要先了解一些基本概念：Session：Session是Hibernate与数据库交互的核心接口，它代表了一个会话，可以用来执行各种数据库操作。
SessionFactory：SessionFactory是一个线程安全的对象，它用于创建Session对象。
通常情况下，应用程序只需要创建一个SessionFactory对象。
Transaction：Transaction是对数据库操作进行事务管理的接口。
在Hibernate中，所有对数据库的操作都应该在事务中进行。
Mapping文件：Mapping文件用于描述Java类与数据库表之间的映射关系。
它定义了Java类属性与数据库表字段之间的对应关系。
2. Hibernate框架的工作流程Hibernate框架主要分为两个部分：持久化层和业务逻辑层。
其中，持久化层负责将Java对象映射到数据库中，并提供数据访问接口；业务逻辑层则负责处理业务逻辑，并调用持久化层进行数据访问。
Hibernate框架的工作流程如下：2.1 创建SessionFactory对象在应用程序启动时，需要创建一个SessionFactory对象。
SessionFactory是一个线程安全的对象，通常情况下只需要创建一个即可。
2.2 创建Session对象在业务逻辑层需要进行数据访问时，需要先创建一个Session对象。
Session是Hibernate与数据库交互的核心接口，它代表了一个会话，可以用来执行各种数据库操作。
2.3 执行数据库操作在获取了Session对象之后，就可以执行各种数据库操作了。
hibernate4学习笔记
hibernate4学习笔记Hibernate4学习笔记本⼈全部以⾃学为主，在⽹上收集各种学习资料，总结归纳学习经验，现将学习路径给予⼤家分享。
此次学习的hibernate的版本是：hibernate-release-4.2.4.Final（截⽌2015年7⽉31⽇最新版），JAVA的版本是：java8.0，使⽤的开发⼯具是：Eclipse Mars Release (4.5.0)。
第⼀天：Hibernate4基础知识和HelloWorld简单编程Hibernate是⼀种半成品ORM框架，对数据库持久化操作，程序员对数据库的操作转换成对对象的操作。
ORM 采⽤元数据来描述对象-关系映射细节, 元数据通常采⽤XML 格式, 并且存放在专门的对象-关系映射⽂件中。
HelloWorld简单编程1、准备Hibernate环境（1）导⼊Hibernate的Jar包，如下：（2）导⼊Mysql驱动包，我⽤的数据库是：Mysql 5.0，数据库驱动包如下：以上所有Jar加完毕之后，需要加⼊到Eclipse⾃⾝系统⾥⾯，具体如下：以上操作完毕之后，Hibernate的环境就算搭建完毕，下⾯就可以进⼀步操作。
2、配置hibernate.cfg.xml⽂件，主要是对数据库的连接，具体如下："-//Hibernate/Hibernate Configuration DTD 3.0//EN""/doc/63fa364d5022aaea998f0fde.html /hibernate-configuration-3.0.dtd ">rootmysqlname="connection.driver_class">com.mysql.jdbc.Driver jdbc:mysql:///Test(或者：jdbc:mysql://localhost:3306/Test)name="dialect">org.hibernate.dialect.MySQLInnoDBDialecttruetrueupdate3、编写⼀个实例类News.java，具体代码如下：package com.hibernate.helloworld;import java.sql.Date;public class News {private Integer id;private String title;private Date date;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getTitle() {return title;}public void setTitle(String title) {this.title = title;}public String getAuthor() {return author;}public void setAuthor(String author) {this.author = author;}public Date getDate() {return date;}public void setDate(Date date) {this.date = date;}public News(String title, String author, Date date) { super();this.title = title;this.author = author;this.date = date;}public News(){}@Overridereturn"News [id="+ id+ ", title="+ title+ ", author="+ author + ", date=" + date + "]";}}4、创建News.hbm.xml配置映射⽂件，具体代码如下："/doc/63fa364d5022aaea998f0fde.html /hibernate-mapping-3.0.dtd">5、将映射⽂件News.hbm.xml指定到hibernate.cfg.xml配置⽂件⾥⾯，即在hibernate.cfg.xml⽂件⾥加⼊⼀⾏映射代码，具体如下：6、创建hibernate API操作测试类（Juit测试），验证hibernate的优势效果，具体代码如下：package com.hibernate.helloworld;import java.sql.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.Test;public class HibernateTest {@Testpublic void test() {//1. 创建⼀个 SessionFactory 对象SessionFactory sessionFactory=null;//1). 创建 Configuration 对象: 对应 hibernate 的基本配置信息和对象关系映射信息Configuration configuration=new Configuration().configure();//4.0 之前这样创建//sessionFactory=configuration.buildSessionFactory();//2). 4.0以后创建⼀个 ServiceRegistry 对象: hibernate 4.x 新添加的对象//hibernate 的任何配置和服务都需要在该对象中注册后才能有效.ServiceRegistry serviceRegistry=newServiceRegistryBuilder().applySettings(configuration.getProperties() ).buildServiceRegistry();sessionFactory=configuration.buildSessionFactory(serviceRegistry) ;//2. 创建⼀个 Session 对象Session session=sessionFactory.openSession();//3. 开启事务Transaction transaction=session.beginTransaction();//4. 执⾏保存操作News news = new News("Java12345", "ATGUIGU", new Date(new java.util.Date().getTime()));session.save(news);//5. 提交事务/doc/63fa364d5022aaea998f0fde.html mit();//6. 关闭 Sessionsession.close();//7. 关闭 SessionFactory 对象sessionFactory.close();}}7、测试结果如下：（1）数据库⾥⾯的结果如下：（2）Eclipse下的语句⽣成如下：以上就是简单Hibernate的测试，总结：1、不需要在数据库⾥⾯创建任何数据，由hibernate ⾃动⽣成；2、代码简单易理解，不复杂，测试数据只需要先创建以下⼏个步骤：SessionFactory-→Session-→Transaction-→session操作数据库-→提交-→关闭；3、不需要写SQL 语句，从头到尾没有写⼀条SQL语句，反⽽Hibernate帮我们⽣成SQL语句。
java学习经验Hibernate总结
Hibernate工作原理及为什么要用？一原理：1.读取并解析配置文件2.读取并解析映射信息，创建SessionFactory3.打开Sesssion4.创建事务Transaction5.持久化操作6.提交事务7.关闭Session。
8.关闭SessionFactory为什么要用：1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。
2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。
他很大程度的简化DAO层的编码工作3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。
4. hibernate的性能非常好，因为它是个轻量级框架。
映射的灵活性很出色。
它支持各种关系数据库，从一对一到多对多的各种复杂关系。
二Hibernate 的核心接口及其作用1 Configuration类：配置Hibernate启动Hibernate创建SessionFactory对象2 SessionFactory：初始化Hibernate创建Session对象线程安全—同一实例被多个线程共享重量级：代表一个数据库内部维护一个连接池2.1 openSession():总是创建新的session,需要手动close()2.2 getCurrentSession() : 必须在hibernate.cfg.xml设置session 上下文事务自动提交并且自动关闭session.从上下文环境中获得session,如果当时环境中不存就创建新的.如果环境中存在就使用环境中的,而且每次得到的都是同一个session (在session提交之前,提交之后就是新的了) 应用在一个session中有多个不同DAO操作处于一个事务时3 Session：负责保存、更新、删除、加载和查询对象轻量级－－可以经常创建或销毁3.1 Load与get方法的区别：简单理解：load是懒加载，get是立即加载.load方法当使用查出来的对象时并且session未关闭，才会向数据库发sql， get会立即向数据库发sql返回对象3.3 merge(); 合并对象更新前会先select 再更新3.4clear()清空缓存,flush()将session中的数据同步到数据库两者组合使用于批量数据处理3.4Transaction commit() rollback()JPA： java persistence API 提供了一组操作实体bean的注解和API规范SchemaExporthiberante的生成数据库表(及其他ddl)的工具类可以通过这个工具类完成一些ddl四Hibernate查询查询语言主要有:HQL 、QBC (Query By Criteria条件查询) 、 Native SQLHql：1、属性查询2、参数查询、命名参数查询3、关联查询4、分页查询5、统计函数五优化抓取策略连接抓取（Join fetching）使用 OUTER JOIN（外连接）来获得对象的关联实例或者关联集合查询抓取（Select fetching）另外发送一条 SELECT 语句抓取当前对象的关联实体或集合另外可以配置hibernate抓取数量限制批量抓取（Batch fetching）另外可以通过集合过滤来限制集合中的数据量使用session.createFilter(topic.getReplies(),queryString).list();检索策略延迟检索和立即检索（优先考虑延迟检索）N+1问题指hibernate在查询当前对象时查询相关联的对象查询一端时会查询关联的多端集合对象解决方案:延迟加载连接抓取策略二级缓存集合过滤 BatchSize限制记录数量映射建议使用双向一对多关联，不使用单向一对多灵活使用单向一对多关联不用一对一，用多对一取代配置对象缓存，不使用集合缓存一对多集合使用Bag,多对多集合使用Set继承类使用显式多态表字段要少，表关联不要怕多，有二级缓存撑腰Hibernbate缓存机制性能提升的主要手段Hibernate进行查询时总是先在缓存中进行查询,如缓存中没有所需数据才进行数据库的查询.Hibernbate缓存:一级缓存 (Session级别)二级缓存(SessionFactory级别)查询缓存 (基于二级缓存存储相同参数的sql查询结果集)一级缓存（session缓存）Session缓存可以理解为session中的一个map成员， key为OID ,value为持久化对象的引用在session关闭前，如果要获取记录，hiberntae先在session缓存中查找，找到后直接返回，缓存中没有才向数据库发送sql三种状态的区别在于:对象在内存、数据库、session缓存三者中是否有OID临时状态内存中的对象没有OID, 缓存中没有OID，数据库中也没有OID 执行new或delete()后持久化状态内存中的对象有OID, 缓存中有OID，数据库中有OIDsave() load() get() update() saveOrUpdate() Query对象返回的集合游离（脱管）状态内存中的对象有OID, 缓存中没有OID，数据库中可能有OIDflush() close()后使用session缓存涉及三个操作:1将数据放入缓存2从缓存中获取数据3缓存的数据清理4二级缓存SessionFactory级别SessionFactory级别的缓存,它允许多个Session间共享缓存一般需要使用第三方的缓存组件，如: Ehcache Oscache、JbossCache等二级缓存的工作原理:在执行各种条件查询时，如果所获得的结果集为实体对象的集合，那么就会把所有的数据对象根据OID放入到二级缓存中。
Hibernate基础知识详解
Hibernate基础知识详解<hibernate-mapping><class name="*.*.*" table="t_customer" catalog="***"><id name="id" column="c_id"><generator class="identity"/></id><property name="name" column="c_name" length="20"/><set name="orders" inverse="false" cascade="save-update"><key column="c_customer_id"/></set></class></hibernate-mapping>(1)统⼀声明包名，这样在<class>中就不需要写类的全名。
(2)关于<class>标签配置name 属性:类的全名称table 表的名称,可以省略，这时表的名称就与类名⼀致catalog 属性:数据库名称可以省略.如果省略，参考核⼼配置⽂件中 url 路径中的库名称(3)关于<id>标签,<id>是⽤于建⽴类中的属性与表中的主键映射。
name 类中的属性名称column 表中的主键名称 column 它也可以省略，这时列名就与类中属性名称⼀致length 字段长度type 属性指定类型<generator>它主要是描述主键⽣成策略。
Hibernate
a. Session.evict
将某个特定对象从内部缓存中清楚
b. Session.clear
清空内部缓存
当批量插入数据时，会引发内存溢出，这就是由于内部缓存造成的。例如：
For(int i=0; i<1000000; i++){
For(int j=0; j<1000000; j++){
session.iterate(…)方法和session.find(…)方法的区别：session.find(…)方法并不读取ClassCache，它通过查询语句直接查询出结果数据，并将结果数据put进classCache；session.iterate(…)方法返回id序列，根据id读取ClassCache，如果没有命中在去DB中查询出对应数据。
User user = new User();
user.setUserName(“gaosong”);
user.setPassword(“123”);
session.save(user);
}
}
在每次循环时，都会有一个新的对象被纳入内部缓存中，所以大批量的插入数据会导致内存溢出。解决办法有两种：a 定量清除内部缓存 b 使用JDBC进行批量导入，绕过缓存机制。
user.setLoginName("jonny");
mit();
session2 .close();
这种方式，关联前后是否做修改很重要，关联前做的修改不会被更新到数据库，
比如关联前你修改了password，关联后修改了loginname，事务提交时执行的update语句只会把loginname更新到数据库
HibernateHQL查询中对日期的查询操作总结
HibernateHQL查询中对日期的查询操作总结数据库表部分数据：SQL> select * from t_class;CLASS_IDCLASS_NAME CLASS_CREATETIME----------- ------------------------------------------------------------ --------------------------------------------------------------------------------1 班级1 22-1月 -08 03.03.52.717000 下午9 班级2 20-1月 -08 05.04.30.577000 上午18 班级3 15-3月 -08 11.08.03.204000 上午28 班级4 23-3月 -08 06.05.03.040000 下午39 班级5 24-4月 -08 01.22.50.090000 下午关键：注意类型匹配，看比较的是日期类型还是字符串类型。
//查询2008-1月-1日到2008-2月-1日建立的班级String hql = "select c.id, from MyClass c where c.createTime between ? and ?";//这里的问号要传入的是日期对象//在hql中可以使用数据库的函数,如:MySQL数据库中的date_formatSimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");List list =session.createQuery(hql).setParameter(0,format.parse("2008-01-01 00:00:00"))//此时应传入Date类型.setParameter(1,format.parse("2008-01-31 23:59:59")).list();查询2008-1月建立的班级：可以利用数据库中的函数，但要注意不同数据库的函数可能不同：例如Mysql中有date_format函数，而Oracle中则是用to_char将日期转为指定形式的字符串String hql = "select c.id, from MyClass c where to_char(c.createTime,'yyyy-MM')=?";//如果是mysql数据库，where条件应该使用date_format函数写成date_format(c.createTime,'%y-%M')=?List list = session.createQuery(hql).setParameter(0,"2008-01").list();//此时应传入字符串类型，应为to_char已将日期转为指定形式的字符串也可以使用oracle数据的函数to_date,将传入的字符串转化为指定格式的日期对象String hql = "select id,name from MyClass c where c.createTime between to_date(?,'yyyy-MM-dd HH24-mi-ss') and to_date(?,'yyyy-MM-dd HH24-mi-ss')";List list = session.createQuery(hql).setParameter(0,"2008-01-01 00:00:00").setParameter(1,"2008-01-31 23:59:59").list();注意oracle中使用to_date时有可能出现如下报错：（1）ERROR JDBCExceptionReporter:101 - ORA-01810: 格式代码出现两次这是由于输入日期模式时输入的是：yyyy-MM-dd HH24-mm-ss。
Hibernate注解用法总结
1.类级别注解@Entity 映射实体类@Table 映射数句库表@Entity(name="tableName") - 必须，注解将一个类声明为一个实体bean。
属性：name - 可选，对应数据库中的一个表。
若表名与实体类名相同，则可以省略。
@Table(name="",catalog="",schema="") - 可选，通常和@Entity配合使用，只能标注在实体的class 定义处，表示实体对应的数据库表的信息。
属性：name - 可选，表示表的名称，默认地，表名和实体名称一致，只有在不一致的情况下才需要指定表名catalog - 可选，表示Catalog名称，默认为Catalog("").schema- 可选, 表示Schema 名称, 默认为Schema("").2.属性级别注解@Id 映射生成主键@Version 定义乐观锁@Column 映射表的列@Transient 定义暂态属性2.1 与主键相关注解@Id - 必须，定义了映射到数据库表的主键的属性，一个实体只能有一个属性被映射为主键，置于getXxxx() 前。
@GeneratedV alue(strategy=GenerationType,generator="") - 可选，用于定义主键生成策略。
属性：Strategy - 表示主键生成策略，取值有：GenerationType.AUTO- 根据底层数据库自动选择（默认），若数据库支持自动增长类型，则为自动增长。
GenerationType.I NDENTITY- 根据数据库的Identity字段生成，支持DB2、MySQL、MS、SQL Server、SyBase与HyperanoicSQL数据库的Identity类型主键。
GenerationType.SEQUENCE -使用Sequence来决定主键的取值，适合Oracle、DB2等支持Sequence的数据库，一般结合@SequenceGenerator使用。
struts2+spring+hibernate三大框架环境搭建小小总结
struts2+spring+hibernate三大框架环境搭建小小总结：一、环境搭建导入各种jar包什么的就不多说了。
二、整个包结构及模式：1、src文件下，由panyname组成一个大的包结构和各项配置文件组成2、companyname下，分成两部分：A、model层B、功能层3、model层下，包含整个项目所要的数据库表名，按照功能来命名包的名称，A、功能包下包含对应的数据库表的java类，里面包含对应数据库表中所有的字段以及get，set方法B、功能包下包含对应的数据库表的hbm.xml类，里面包含对应数据库表中所有字段的定义4、功能层下，可以只有一个功能模块的一个结构，也可以有多个功能模块的包结构，再在包结构下细分到功能模块的结构A、一个完整的功能模块包下包含：action，dao，service层，1>、对应的action层包含对应功能实现的Action类；2>、对应的dao层包含对应功能实现的数据库操作类；3>、对应的service层包含对应功能实现的各service接口；5、各项配置文件：A、首先包含三个大的配置文件：applicationContext.xml，struts.xml，jdbc.propertiesB、applicationContext.xml实现依赖注入，struts.xml实现各响应功能的配置，jdbc.properties配置数据库相关属性三、页面1、所有的页面，js包都放到WebRoot目录下，2、要配置web.xml文件3、所有的jar包放到WebRoot-WEB-INF-lib包下四、功能操作1、定义好model层，配置好对应的model.hbm.xml映射文件2、将对应的model.hbm.xml映射文件映射到applicationContext.xml文件中3、页面中对应的跳转，实现action，到struts-function.xml去增加对应的Action类和方法4、将struts-function.xml映射文件映射到struts.xml映射文件中5、在功能层下建立对应的功能包，包下包含action，dao，service三个层6、根据struts-function.xml映射文件，建立对应的Action类，在类中创建对应的方法7、在service层和dao层下分别建立对应的接口层和实现接口类8、在对应的applicationContext-function.xml映射文件中将dao层方法映射到对应的service 层中9、service层中，包含iservice层和实现iservice层的service10、在service类中实现对应的iservice定义的方法，并return这个dao对象的方法，11、根据这个方法，在idao接口中创建对应的方法，在dao层的实现类中来具体实现方法的业务12、dao层实现之后，将在Action中调用对应的dao层实现的方法，然后保存结果返回到对应的界面去13、至此，简单的一个业务就实现了。
hibernate学习笔记
Hibernate 学习笔记2010年7月9日星期五1目录1.学习纲要2.学习目的3.达标标准4.名词解释5.学习时间：两天又3小时(16~19pm)2具体内容2.1学习纲要2.1.1什么是hibernate?它是连接JAVA应用程序和关系数据库的中间件它对JDBC API进行了封装，负责JAVA对象的持久化在分层的软件架构中它位于持久化层，封装了所有数据访问细节，使业务逻辑层可以专注于实现业务逻辑。
它是一种ORM映射工具，能够建立面向对象的域模型和关系数据模型之间的映射2.1.2HIBERNATE原理依赖的技术有：JAVA反射机制（在org.hibernate.property中得到较多应用，通过INVORK()方法调用POJO对象的setter,getter方法设置和获取属性的值）i.Class类ii.getMethods方法得到Method类iii.Method类iv.invoke方法用来调用被反射类的方法CGLIB（用于对持久化类进行延迟加载时生成代理类）i.以asm项目为基础，对asm的功能进行封装和扩展，实现并扩展了JAVA的反射功能，可以在运行时状态下实现JAVA接口，扩展JAVA类ii.Asm项目是一个简洁的字节码工具，能够在运行的状态下动态的修改编译完成的JAVA类JAVASSIST（同CGLIB，是另一套解决方案，可以通过修改org.hibernate.cfg.Environment.java原码进行设置）i.是一个执行字节码操作的强有力的驱动代码库。
它允许开发者在代码被JAVA虚拟机载入之前定义一个新类或者修改类的的原代码。
XML技术（DOM4J）i.用来解析XML配置文件Antlr（another tool for language recognition）i.它是一个开源的工具，利用后缀为“.g”的文件来定义语法规则ii.Hibernate提供的语法规则有iii.Hql.giv.Hql-sql.gv.Sql-gen.gvi.Hibernate通过调用这些生成的解析类完成把HQL语句转为SQL语句的工作2.1.3HIBERNATE方法的内部实现略2.1.4Hibernate能做什么？2.1.5hibernate应用在哪些方面2.1.6Hibernate关联关系1.一对多关联<many-to-one name=”customer”column=”CUSTOMER_ID”class=”mypack.Customer”lazy=”false” not-null=”true”/>此种情况下不会加载关联的临时对象。
hibernate注解简介
@Entity
@Table(name="T_MODEL_PLANE")
public class ModelPlane {
private Long id;
private String name;
@Id
@Column(name="PLANE_ID")
传统上，Hibernate的配置依赖于外部 XML 文件：数据库映射被定义为一组 XML 映射文件，并且在启动时进行加载。创建这些映射有很多方法，可以从已有数据库模式或Java类模型中自动创建，也可以手工创建。无论如何，您最终将获得大量的 Hibernate 映射文件。此外，还可以使用工具，通过javadoc样式的注释生成映射文件，尽管这样会给您的构建过程增加一个步骤。
...
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate</artifactId>
<version>3.2.1.ga</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
Hibernate学习总结
一．对象语言和操作数据库不匹配：模型不匹配（阻抗不匹配）①．可以使用JDBC手动转换；sql参数和jdbc中用对象赋值②．使用ORM（Object Relation Mapping对象关系映射）框架：hibernate 二．Hibernate安装配置①．配置文件Hibernate.cfg.xml和Hibernate.properties②．映射文件xxx.hbm.xml：对象模型和关系模型的映射三．开发流程1.由Domain Object -> mapping -> db2.有DB开始，用工具生成mapping和Domain Object3.由配置文件开始四．Domain Object限制1.默认的构造方法（必须的）2.有无意义的标示符id(主键) 可选3.非final的，对懒加载有影响可选Configuration SessionFactory Session Transaction Query CriteriaConfiguration类Configuration类负责配置并启动Hibernate，创建SessionFactory对象。
在Hibernate的启动的过程中，Configuration类的实例首先定位映射文档位置、读取配置，然后创建SessionFactory 对象。
SessionFactory接口SessionFactory接口负责初始化Hibernate。
它充当数据存储源的代理，并负责创建Session对象。
这里用到了工厂模式。
需要注意的是SessionFactory并不是轻量级的，因为一般情况下，一个项目通常只需要一个SessionFactory就够，当需要操作多个数据库时，可以为每个数据库指定一个SessionFactory。
Session接口Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流，包含了很多常见的SQL语句。
hibernate 字段类型
文章标题：深度探讨 Hibernate 字段类型：从简单到复杂的全面评估在软件开发中，使用 Hibernate 是非常常见的，它是一个基于 Java的持久化框架，用于将对象映射到数据库中。
在使用 Hibernate 进行数据库操作时，了解各种字段类型的映射以及它们的特性和用途是非常重要的。
在本文中，我们将从简单到复杂，全面评估 Hibernate 中常见的字段类型，包括字符串、数字、日期、枚举等，并深入讨论它们的映射规则和最佳实践。
1. 字符串类型在 Hibernate 中，字符串类型是最常见的字段类型之一。
它通常用来映射数据库表中的 VARCHAR、CHAR 或 TEXT 等类型的字段。
在定义字符串类型的映射时，需要考虑数据库的字符集和长度限制。
另外，还可以使用 @Column 注解来指定字段的其他属性，如是否唯一、是否可为空等。
2. 数字类型除了字符串类型，数字类型也是数据库中常见的字段类型。
在Hibernate 中，可以使用 Integer、Long、Double 等包装类来映射数据库中的整型、长整型和浮点型字段。
需要注意的是，需要根据数据库中字段的精度和范围来选择合适的 Java 包装类，并且可以使用@Column 注解来指定数字的精度和小数点位数。
3. 日期类型日期类型在数据库和 Java 中都是非常重要的数据类型。
在 Hibernate 中，可以使用 Date、Time、Timestamp 等类来映射数据库中的日期和时间字段。
需要注意的是，Hibernate 提供了丰富的日期格式化和解析工具，并且可以使用 @Temporal 注解来指定日期字段的精度，如 DATE、TIME 或 TIMESTAMP。
4. 枚举类型枚举类型在 Hibernate 中也有很好的支持。
通过 @Enumerated 注解，可以将 Java 中的枚举类型映射到数据库表中的字段，并且可以指定枚举类的映射策略。
另外，还可以使用 @Convert 注解来定制枚举类型的映射规则，将枚举值存储为数据库中的特定类型。
Hibernete基本概念
认识Hibernate一、Hibernate是一个优秀的持久化框架，了解持久化之前，先了解两种状态：1.瞬时状态：保存在内存中的程序数据，程序退出了，数据就消失了。
2.持久状态：保存在磁盘中的程序数据，程序退出了，数据依然存在。
持久化就是程序数据在瞬时状态和持久状态之间转换的一种机制。
二、hibernate是JDBC的轻量级封装，是一个独立的对象持久层框架；Hibernate可以用在任何JDBC可以使用的场合；Hibernate是一个和JDBC密切关联的框架，所以Hibernate的兼容性和JDBC驱动，和数据库都有一定的关系。
但是和使用它的Java程序，和App Server没有任何关系，也不存在兼容性问题；由于两者读取方式不一样，hibernate采用uuid.hex构造主键，性能稍慢与jdbc；特别是jdbc使用批处理的时候，显得jdbc更快，但是JVM(java虚拟机)内存也就要求大；总而言之，所有的ORM比如CMP、JDO、Hibernate都是对jdbc的封装，理论上讲ORM的性能不会高于jdbc，就像所有的高级语言性能不会高于汇编语言是一个道理。
所以，JDBC占着灵活效率高的优势，而hibernate占着易学易使用的优势。
那么hibernate与JDBC有什么区别呢：相同点：1.都是java数据库操作的中间件；2.两者对数据库对象的操作都不是线程安全的，都需要及时关闭；3.两者都可以对数据库的更新操作进行显式的事务处理；不同点：1.hibernate先检索缓存中的映射对象( 即hibernate操作的是对象)，而jdbc则是直接操作数据库，将数据直接通过SQl传送到数据库......(操作的对象不同)2.JDBC使用基于关系数据库的标准SQL(Structured Query Language)语言，hibernate使用HQL(Hibernate Query Language)语言....(使用的语言不同)3.Hibernate操作的数据是可持久化的，也就是持久化的对象属性的值，可以和数据库中保持一致，而jdbc操作数据的状态是瞬时的，变量的值无法和数据库中一致....(数据状态不同)三、ORM(Object Relational Mapping)对象关系映射完成对象数据到关系型数据映射的机制，称为：对象·关系映射，简ORM总结：Hibernate是一个优秀的对象关系映射机制，通过映射文件保存这种关系信息；在业务层以面向对象的方式编程，不需要考虑数据的保存形式。
hibernate持久化对象的三种状态及描述
hibernate持久化对象的三种状态及描述摘要：I.引言A.介绍Hibernate 持久化对象B.介绍Hibernate 持久化对象的状态II.Hibernate 持久化对象的三种状态A.临时状态(Transient)1.定义2.特点3.示例B.持久状态(Persistent)1.定义2.特点3.示例C.游离状态(Detached)1.定义2.特点3.示例III.状态转换A.临时状态转换为持久状态1.对象实例化2.添加到Session 缓存3.提交事务B.持久状态转换为游离状态1.从Session 缓存中移除2.数据库更新3.对象失去联系C.游离状态转换为持久状态1.重新关联对象和数据库记录2.添加到Session 缓存3.提交事务IV.结论A.总结Hibernate 持久化对象的状态B.强调状态转换的重要性C.展望未来Hibernate 的发展正文：Hibernate 是一种流行的Java 持久化框架，它可以将Java 对象映射到关系型数据库中。
在Hibernate 中，持久化对象有三种状态：临时状态(Transient)、持久状态(Persistent) 和游离状态(Detached)。
理解这些状态对于掌握Hibernate 的运行机制至关重要。
临时状态(Transient) 是指对象刚刚被创建，还没有与数据库建立关联。
这种状态下的对象不包含任何数据库记录，也不在Session 缓存中。
当一个对象实例化后，它处于临时状态。
持久状态(Persistent) 是指对象已经与数据库建立了关联，并且存在于Session 缓存中。
当对象被添加到Session 缓存后，它就变成了持久状态。
此时，对象的变化会被同步到数据库中。
游离状态(Detached) 是指对象与数据库的关联已经断开，但是仍然存在于内存中。
这种状态下的对象不再受Session 缓存的管理，但是它仍然保持着与数据库记录的映射关系。
当对象从Session 缓存中移除，但是还没有被提交事务时，它处于游离状态。
Hibernate 实体类 注解 大全
@Column(name="BIRTH",nullable="false",columnDefinition="DATE")
public String getBithday() {
return birthday;
}
7、@Transient
public User getUser() {
return user;
}
9、@JoinColumn
可选
@JoinColumn和@Column类似,介量描述的不是一个简单字段,而一一个关联字段,例如.描述一个@ManyToOne的字段.
name:该字段的名称.由于@JoinColumn描述的是一个关联字段,如ManyToOne,则默认的名称由其关联的实体决定.
catalog:可选,表示Catalog名称,默认为Catalog("").
schema:可选,表示Schema名称,默认为Schema("").
3、@id
必须
@id定义了映射到数据库表的主键的属性,一个实体只能有一个属性被映射为主键.置于getXxxx()前.
4、@GeneratedValue(strategy=GenerationType,generator="")
@Entity
//继承策略。另一个类继承本类，那么本类里的属性应用到另一个类中
@Inheritance(strategy = InheritanceType.JOINED )
@Table(name="INFOM_TESTRESULT")
public class TestResult extends IdEntity{}
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
1：
ORM主要解决的问题是对象--关系的映射。
一班情况下，一个持久化类和一个表对应，类的每个实例对应表中的一条记录。
2：
常用的5个核心接口介绍
(1)Configuration接口，用于配置并根启动Hibernate。
(2)SessionFactory接口，一个SessionFactory实例对应一个数据库存储源，它是线程安全的，重量级的，之所以称
它为重量级，是因为启动它要一个很大的缓存，当然，用户可以为它配置二级缓存
(3)Session接口，不是线程安全的，Session实例是轻量级的，它有一个第一级缓存
(4)Transaction接口，是Hibernate的数据库事务接口，
(5)Query和Criteria接口，它们是Hibernate的查询接口，Query实例包装了一个HQL查询词句，HQL是面象对象的，
它引用类名和类的属性，而不是表名和表的字段
3：
持久化类的默认规则
(1)对属性的操作，一这要用setXXX()和getXXX()这样的命名，如果是boolean类型，则可以用isXXX()命名
(2)最好实现java.io.Serialiizable接口，
(3)必须提供一个不带参数的，最好是public或protected的默认构造方法
4：
数据类型的映射过程是，先参照表字段类型，再比较java类型，最后由上两种来决定hibernate数据类型
5：
<property>元素的常用属性
(1)name，指定的是java类中的属性名
(2)column，与java类对应的数据库表名
(3)not null，java类的某个属性是否可为空，在应用应用层检查，即持久化前
(4)type，Hibernate中间件的过度型数据类型，
(5)access，设定对于java类属性，是用getXXX()和setXXX()方法(property)，还是直接访问(field)
(6)dynamic，设定hibernate生成sql语句的方式，在update，insert时，只对有修改过的字段进行CRUD操作
6：
我们可以自己对getXXX()和setXXX()方法加入逻辑，这是很灵活的
7：
只要在xxx.hbm.xml中映射了数据库表中的字断，就可以用HQL语句检索
8：
Session.close()---清空缓存
Session.flush()---清理缓存，对比数据库中表的记录，并执行SQL语句，但不会提交事务
mit()---清理，执行SQL，并提交事务
9：
Session.load()---当数据库表中没有该记录时，会抛出异常，并受到类级别加载设置的影响，如延迟加载
Session.get()---当库中无记录时，返回null
Session.find()---将被淘汰，也是不推荐使用的方法，用query代替
10：
<set>的inverse属性
比如在一(user)对多(book)的关联中，会有<set>配置，当设置inverse=true 时，当hibernate检查到user和book的状态都发生变化时，如执行了Book.set(User)，则仅按照book对象状态的变化来同步更新数据库，只生成一条SQL语句来执行，如果不设置inverse=true，则会多执行一次
11：
<class>和<property>默认的table和column是与name相同的，区分大小写
---------------------------------------------------------------------------------------------------------------------------
下面开始介绍各种映射策略
1：
映射自然主键表，代理主键表，复合主键表，这种映射比较简单，也比较常用
2：
映射单向一对多，和多对一关联
3：
映射双向一对多关联(也叫做双向多对一关联)
4：
怎样提高Hibernate的综合性能
(1)关联级别延迟加载首选设置为lazy=false
(2)最好用多对一单向关联，<many-to-one>可以选择lazy=false或
lazy=true
(3)在一对多关联中，<set>首选设置为lazy=true
(4)关联类属性首选设置为cascade=save-update，或cascade=all(将删除一切关联的数据)
(5)可以设置类级别和关联级别的批量延迟检索和立即检索,batch-size，可以减少和简化Hibernate生成的SQL语句条
数，以提高查询性能
(6)outer-join属性在<many-to-one>中默认为true，一般不用设置，多表outer join会严重影响数据库性能。