hibernate

因为tinyint默认的字节就是4.在反方向生成的时候，只会记住它的类型。而不会记住它的大小。

hibernate 是面向对象的语言，可以用select * from 表 吗。。。

已经有人回答 greatdoudou

Dear在source的头部注释上写明用AbstractStandardBasicType类来替代NullableType.比如before: org.hibernate.Hibernate.BIG_DECIMAL.getName() after: BigDecimalType.INSTANCE.getName()-------------------------- from 四年后的答案.

推荐解答（1）Hibernate 　　Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序实用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。Eclipse平台下的Hibernate辅助开发工具:【Hibernate Synchronizer】【MiddlegenIDE】 　　IBATIS 　　使用ibatis 提供的ORM机制，对业务逻辑实现人员而言，面对的是纯粹的Java对象， 这一层与通过Hibernate 实现ORM 而言基本一致，而对于具体的数据操作，Hibernate 会自动生成SQL 语句，而ibatis 则要求开发者编写具体的SQL 语句。相对Hibernate等 “全自动”ORM机制而言，ibatis 以SQL开发的工作量和数据库移植性上的让步，为系统 设计提供了更大的自由空间。作为“全自动”ORM 实现的一种有益补充，ibatis 的出现显 得别具意义。[数据捕快 大数据实验室提供 ][datacaptor from aosustudio]推荐解答（2）一.共同点：1.都是O/R mapping框架，直接与数据库打交道。2.都提供方言支持不同类型数据库的访问，通过xml文件格式将数据库表与java对象连接起来。3.都可以交给spring来管理4.都是开源软件二.区别：hibernate是当前流行的O/R框架，来自于sf.net，现在已成为HBOSS的一部分。 hibernate相对较复杂，学习周期长。ibatis/mybatis 是另外一种优秀的o/r mapping框架，目前属于apache的一个子项目了。ibatis上手快，很容易学学习。三原理：hibernate对数据结构进行了很好的封装，可以实现java对象也就是POJO是数据库表之间的映射，还能根据POJO及SQL自动生成表和执行命令。程序员往往只需定义好了pojo 到数据库表的映射关系，即可通过hibernate 提供的方法完成持久层操作。程序员甚至不需要对sql 的熟练掌握， hibernate/ojb 会根据制定的存储逻辑，自动生成对应的sql 并调用jdbc 接口加以执行。而ibatis 则重点在于pojo 与sql之间的映射关系。ibatis不能让我们通过POJO生成SQL语句来执行 。具体的sql 需要程序员编写，然后通过映射配置文件，将sql所需的参数，以及返回的结果字段映射到指定pojo。四.机制使用ibatis 提供的orm机制，对业务逻辑实现人员而言，面对的是纯粹的java对象。这一层与通过hibernate 实现orm 而言基本一致，而对于具体的数据操作，hibernate会自动生成sql 语句，而ibatis 则要求开发者编写具体的sql 语句。相对hibernate而言，ibatis 以sql开发的工作量和数据库移植性上的让步，为系统设计提供了更大的自由空间。 五.系统维护或者二次开发当系统维护或者二次开发,无法对数据库结构做到控制和修改,那ibatis的灵活性将比hibernate更适合 六.海量数据 系统数据处理量巨大，性能要求极为苛刻，这往往意味着我们必须通过经过高度优化的sql语句（或存储过程）才能达到系统性能设计指标。在这种情况下ibatis会有更好的可控性和表现。 七.自动化程度 ibatis需要手写sql语句，也可以生成一部分，hibernate则基本上可以自动生成，偶尔会写一些hql。同样的需求,ibatis的工作量比 hibernate要大很多。类似的，如果涉及到数据库字段的修改，hibernate修改的地方很少，而ibatis要把那些sql mapping的地方一一修改。 八.与数据映射关系 ibatis以数据库字段一一对应映射得到的po和hibernte这种对象化映射得到的po是截然不同的，本质区别在于这种po是扁平化的，不像hibernate映射的po是可以表达立体的对象继承，聚合等等关系的，这将会直接影响到你的整个软件系统的设计思路。 九.技术支持 hibernate现在已经是主流o/r mapping框架，从文档的丰富性，产品的完善性，版本的开发速度都要强于ibatis十.实现过程查看1.hibernate配置,进行数据库连接。2.POJO与数据库映射的xml文件介绍3..得到sessionFactory我们就可以通过会话工厂操作数据库4、ibatis配置信息设置5.POJO与数据库的建立xml文件定义6.加载ibatis配置文件，给client初始化6.通过client操作数据库亲，记得采纳一下哦[数据捕快 大数据实验室提供 ][datacaptor from aosustudio]推荐解答（3）都是java的一种框架，hibernate靠的是hql语言，面向的是object,ibatis靠的是sql语言，更接近数据库，配置比hibernate灵活，也比hibernate效率高

org.springframework.orm.hibernate3.support.ClobStringType或者org.springframework.orm.hibernate3.support.BlobStringType

可以不实现的 Serializable接口可以让虚拟机知道该对象可以被网络传输 比如分布式开发就需要实现

hibernate里不能使用这样的语法

在spring中采用OracleLobHandler来处理oracle大字段（包括clob和blob），则在程序中不需要引用oracle的特殊类，从而能够保证支持代码支持多数据库。在Spring的主配置文件xx.xml中的配置SessionFactory的bean中配置：<bean id="nativeJdbcExtractor" class="org.springframework.jdbc.support.nativejdbc.CommonsDbcpNativeJdbcExtractor"lazy-init="true" autowire="default" dependency-check="default"/><bean id="oracleLobHandler" class="org.springframework.jdbc.support.lob.OracleLobHandler" lazy-init="true" autowire="default" dependency-check="default"><property name="nativeJdbcExtractor" ref="nativeJdbcExtractor"/></bean><bean id="sessionFactory" class="org.hibernate.cfg.SWSSessionFactoryBean" lazy-init="false" autowire="default" dependency-check="default">...<property name="lobHandler"><ref bean="oracleLobHandler"/></property>...</bean>nativeJdbcExtractor和 lobHandler 设置为 lazy-init="true"，因为 nativeJdbcExtractor需要通过运行期的反射机制获取底层的 JDBC 对象，所以需要避免在 Spring 容器启动时就实例化这两个 Bean。<注：上面的SWSSessionFactoryBean是被重写过的,继承AnnotationSessionFactoryBean>1、首先数据表中的clob类型对应java持久化类的String类型；而blob类型对应byte[]类型 2、1.定义hibernate标签时，持久化类中对应clob类型的属性的hibernate type应为org.springframework.orm.hibernate.support.ClobStringType；而对应blob类型的属性的hibernate type应为org.springframework.orm.hibernate.support.BlobByteArrayType。2.如果通过spring 注解功能配置PoJo类时，在该大字段属性的getXXX（）方法前面加上注解：public String xxx;...@Lob@Type(type="org.springframework.orm.hibernate3.support.ClobStringType")@Column(length=10000)public String getXXX (){return xxx;}

好像以前我也碰到过类似的问题，那时候好像是在插入一个空值后再update来解决的。。。比较土。。。求高人解答。

hibernate工作原理原理：1.读取并解析配置文件2.读取并解析映射信息，创建SessionFactory3.打开Sesssion4.创建事务Transation5.持久化操作6.提交事务7.关闭Session8.关闭SesstionFactory为什么要用：1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。2． Hibernate是如何延迟加载?1. Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）2. Hibernate3 提供了属性的延迟加载功能当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。3．Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系)类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many、4． 说下Hibernate的缓存机制1. 内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存2. 二级缓存：a) 应用及缓存b) 分布式缓存条件：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非 关键数据c) 第三方缓存的实现5． Hibernate的查询方式Sql、Criteria,object comptositionHql：1、 属性查询2、 参数查询、命名参数查询3、 关联查询4、 分页查询5、 统计函数6． 如何优化Hibernate？1.使用双向一对多关联，不使用单向一对多2.灵活使用单向一对多关联3.不用一对一，用多对一取代4.配置对象缓存，不使用集合缓存5.一对多集合使用Bag,多对多集合使用Set6. 继承类使用显式多态7. 表字段要少，表关联不要怕多，有二级缓存撑腰struts工作原理Struts工作机制？为什么要使用Struts？工作机制：Struts的工作流程:在web应用启动时就会加载初始化ActionServlet,ActionServlet从struts-config.xml文件中读取配置信息,把它们存放到各种配置对象当ActionServlet接收到一个客户请求时,将执行如下流程.-(1)检索和用户请求匹配的ActionMapping实例,如果不存在,就返回请求路径无效信息; -(2)如果ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中; -(3)根据配置信息决定是否需要表单验证.如果需要验证,就调用ActionForm的validate()方法; -(4)如果ActionForm的validate()方法返回null或返回一个不包含ActionMessage的ActuibErrors对象, 就表示表单验证成功; -(5)ActionServlet根据ActionMapping所包含的映射信息决定将请求转发给哪个Action,如果相应的 Action实例不存在,就先创建这个实例,然后调用Action的execute()方法; -(6)Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给 ActionForward对象指向的JSP组件; -(7)ActionForward对象指向JSP组件生成动态网页,返回给客户; 为什么要用：JSP、Servlet、JavaBean技术的出现给我们构建强大的企业应用系统提供了可能。但用这些技术构建的系统非常的繁乱，所以在此之上，我们需要一个规则、一个把这些技术组织起来的规则，这就是框架，Struts便应运而生。基于Struts开发的应用由3类组件构成：控制器组件、模型组件、视图组件8． Struts的validate框架是如何验证的？在struts配置文件中配置具体的错误提示，再在FormBean中的validate()方法具体调用。9． 说下Struts的设计模式MVC模式: web应用程序启动时就会加载并初始化ActionServler。用户提交表单时，一个配置好的ActionForm对象被创建，并被填入表单相应的数据，ActionServler根据Struts-config.xml文件配置好的设置决定是否需要表单验证，如果需要就调用ActionForm的 Validate（）验证后选择将请求发送到哪个Action，如果Action不存在，ActionServlet会先创建这个对象，然后调用 Action的execute（）方法。Execute（）从ActionForm对象中获取数据，完成业务逻辑，返回一个ActionForward对象，ActionServlet再把客户请求转发给ActionForward对象指定的jsp组件，ActionForward对象指定的jsp生成动态的网页，返回给客户。spring工作原理1.spring mvc请所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责负责对请求进行真正的处理工作。2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.3.DispatcherServlet请请求提交到目标Controller4.Controller进行业务逻辑处理后，会返回一个ModelAndView5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象6.视图对象负责渲染返回给客户端。为什么用：{AOP 让开发人员可以创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后，公共服务 （比如日志、持久性、事务等）就可以分解成方面并应用到域对象上，同时不会增加域对象的对象模型的复杂性。IOC 允许创建一个可以构造对象的应用环境，然后向这些对象传递它们的协作对象。正如单词 倒置 所表明的，IOC 就像反 过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每一个对象都是用其协作对象构造的。因此是由容器管理协作对象（collaborator）。Spring即使一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring，只要用 JavaBean 属性和配置文件加入依赖性（协作对象）。然后可以很容易地在需要时替换具有类似接口的协作对象。}Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如图 1 所示。组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：☆ 核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。☆ Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。☆ Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。☆ Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。☆ Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。☆ Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。☆ Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。Spring 框架的功能可以用在任何 J2EE 服务器中，大多数功能也适用于不受管理的环境。Spring 的核心要点是：支持不绑定到特定 J2EE 服务的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同 J2EE 环境 （Web 或 EJB）、独立应用程序、测试环境之间重用。IOC 和 AOP控制反转模式（也称作依赖性介入）的基本概念是：不创建对象，但是描述创建它们的方式。在代码中不直接与对象和服务连接，但在配置文件中描述哪一个组件需要哪一项服务。容器（在 Spring 框架中是 IOC 容器） 负责将这些联系在一起。在典型的 IOC 场景中，容器创建了所有对象，并设置必要的属性将它们连接在一起，决定什么时间调用方法。下表列出了 IOC 的一个实现模式。下面的人请勿复制

Spring+hibernate就行了。还要什么 Struts2呀

SQL注入是一种代码注入技术，用于攻击数据驱动的应用，恶意的SQL语句被插入到执行的实体字段中（例如，为了转储数据库内容给攻击者）。[摘自] SQL injection - WikipediaSQL注入，大家都不陌生，是一种常见的攻击方式。攻击者在界面的表单信息或URL上输入一些奇怪的SQL片段（例如“or ‘1"="1"”这样的语句），有可能入侵参数检验不足的应用程序。所以，在我们的应用中需要做一些工作，来防备这样的攻击方式。在一些安全性要求很高的应用中（比如银行软件），经常使用将SQL语句全部替换为存储过程这样的方式，来防止SQL注入。这当然是一种很安全的方式，但我们平时开发中，可能不需要这种死板的方式。MyBatis框架作为一款半自动化的持久层框架，其SQL语句都要我们自己手动编写，这个时候当然需要防止SQL注入。其实，MyBatis的SQL是一个具有“输入+输出”的功能，类似于函数的结构，如下：<select id="getBlogById" resultType="Blog" parameterType=”int”>SELECT id,title,author,contentFROM blogWHERE id=#{id}</select>这里，parameterType表示了输入的参数类型，resultType表示了输出的参数类型。回应上文，如果我们想防止SQL注入，理所当然地要在输入参数上下功夫。上面代码中黄色高亮即输入参数在SQL中拼接的部分，传入参数后，打印出执行的SQL语句，会看到SQL是这样的：SELECT id,title,author,content FROM blog WHERE id = ?不管输入什么参数，打印出的SQL都是这样的。这是因为MyBatis启用了预编译功能，在SQL执行前，会先将上面的SQL发送给数据库进行编译；执行时，直接使用编译好的SQL，替换占位符“?”就可以了。因为SQL注入只能对编译过程起作用，所以这样的方式就很好地避免了SQL注入的问题。【底层实现原理】MyBatis是如何做到SQL预编译的呢？其实在框架底层，是JDBC中的PreparedStatement类在起作用，PreparedStatement是我们很熟悉的Statement的子类，它的对象包含了编译好的SQL语句。这种“准备好”的方式不仅能提高安全性，而且在多次执行同一个SQL时，能够提高效率。原因是SQL已编译好，再次执行时无需再编译。话说回来，是否我们使用MyBatis就一定可以防止SQL注入呢？当然不是，请看下面的代码：<select id="getBlogById" resultType="Blog" parameterType=”int”>SELECT id,title,author,contentFROM blogWHERE id=${id}</select>仔细观察，内联参数的格式由“#{xxx}”变为了“${xxx}”。如果我们给参数“id”赋值为“3”，将SQL打印出来是这样的：SELECT id,title,author,content FROM blog WHERE id = 3（上面的对比示例是我自己添加的，为了与前面的示例形成鲜明的对比。）<select id="orderBlog" resultType="Blog" parameterType=”map”>SELECT id,title,author,contentFROM blogORDER BY ${orderParam}</select>仔细观察，内联参数的格式由“#{xxx}”变为了“${xxx}”。如果我们给参数“orderParam”赋值为“id”，将SQL打印出来是这样的：SELECT id,title,author,content FROM blog ORDER BY id显然，这样是无法阻止SQL注入的。在MyBatis中，“${xxx}”这样格式的参数会直接参与SQL编译，从而不能避免注入攻击。但涉及到动态表名和列名时，只能使用“${xxx}”这样的参数格式。所以，这样的参数需要我们在代码中手工进行处理来防止注入。【结论】在编写MyBatis的映射语句时，尽量采用“#{xxx}”这样的格式。若不得不使用“${xxx}”这样的参数，要手工地做好过滤工作，来防止SQL注入攻击。#{}：相当于JDBC中的PreparedStatement${}：是输出变量的值简单说，#{}是经过预编译的，是安全的；${}是未经过预编译的，仅仅是取变量的值，是非安全的，存在SQL注入。如果我们order by语句后用了${}，那么不做任何处理的时候是存在SQL注入危险的。你说怎么防止，那我只能悲惨的告诉你，你得手动处理过滤一下输入的内容。如判断一下输入的参数的长度是否正常（注入语句一般很长），更精确的过滤则可以查询一下输入的参数是否在预期的参数集合中。Face your past without regret. Handle your present with confidence.Prepare for future without fear. keep the faith and drop the fear. 面对过去无怨无悔，把握现在充满信心，备战未来无所畏惧。保持信念，克服恐惧！一点一滴的积累，一点一滴的沉淀，学技术需要不断的积淀！

所有这三个方法，也就是save()、saveOrUpdate()和persist()都是用于将对象保存到数据库中的方法，但其中有些细微的差别。例如，save()只能INSERT记录，但是saveOrUpdate()可以进行记录的INSERT和UPDATE。还有，save()的返回值是一个Serializable对象，而persist()方法返回值为void。save与saveOrUpdate的区别save通过INSERT语句将对象保存到数据库，产生一个新的ID，将数据插入到数据库，并返回一个Serializable对象。saveOrUpdate能根据对象是否已存在，而执行插入或更新。显然saveOrUpdate更加灵活，但它需要额外判断对象是否已存在。save与persist的区别返回类型不同：save返回Serializable对象，而persist返回voidID赋值时机不同：二者同样用于将transient实例持久化，但persist不保证ID值立即赋给持久化实例，可能会在flush的时候给ID赋值。transaction外的行为不同：如果在transaction之外调用，persist保证会立即执行INSERT语句；而save则不保证（save返回一个identifier，如果必须执行INSERT来获取该identifier，则就会立即执行INSERT，而不论是在transaction之内或之外）使用场景：由于上述第三点区别，persist方法适用于被扩展的Session上下文的长期运行的会话中（useful in long-running conversations with an extended Session context）；而save则不适用。

struts2 负责WEB层的 交互， hibernate 负责跟数据库操作， spring 是用来管理 struts2 很hibernate的。。 MVC 是一个模式。。。

SSH（Struts，Spring，Hibernate）是一种常用的Web开发的框架组合，其中Spring作为Ioc容器负责组装，Struts作为前端框架负责展示层逻辑（MVC），Hibernate负责数据的持久化。这三者都是开源框架，也是各自领域中有代表性的框架，三者结合起来是一种最佳实践。而REST是一个C/S（包含B/S）的 软件的架构模式，前端的C（或B）应该以什么样的方式，特别是在HTTP协议上通讯时，和后端的S打交道，形成清晰、容易理解的的交互。由于基于HTTP协议，因此服务端的程序通常跑在Web服务器上，但不一定是以Web方式展现的应用程序。使用SSH框架时，可以依循REST架构模式，以使软件有良好的架构。但是REST不限于 Web开发，特别是在网络服务的API方面，REST已经成为一种事实的标准，可以和Web Service协议栈一争高下。

楼上说的，挺好，Spring，说的通俗一点，或用的多的，就是对象管理器。有需要用对象的地方，直接向Spring去要就可以了，不用New一个出来

第一步：在beans.xml中配置：<bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory" /></bean><!-- enable the configuration of transactional behavior based on annotations --><tx:annotation-driven transaction-manager="txManager"/>第二步：什么方法上需要事务管理，就在该方法的service层上添加注解 @Transactional@Transactionalpublic void save(){tuserdao.save();}第三步：创建session 只能为getCurrentSession（）Session session = sessionfactory.getCurrentSession();全文beans.xml如下：<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xmlns:tx="http://www.springframework.org/schema/tx"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-2.5.xsdhttp://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-2.5.xsd"><context:annotation-config/> <!-- Spring中annotation必须填写 --><bean name="u" class="edu.zust.dao.impl.TuserDAOImpl"><!-- 下面一行与<context:annotation-config/>后在TuserDAOImpl中写Resource等同 --><!--<property name="sessionfactory" ref="sessionFactory" /> --></bean><bean id="userService" class="edu.zust.service.tuserService"><property name="tuserdao" ref="u" /></bean><!--利用Spring配备数据库的连接数据源--><bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"><property name="locations"><value>classpath:jdbc.properties</value></property></bean><bean id="dataSource" destroy-method="close"class="org.apache.commons.dbcp.BasicDataSource"><property name="driverClassName" value="${jdbc.driverClassName}"/><property name="url" value="${jdbc.url}"/><property name="username" value="${jdbc.username}"/><property name="password" value="${jdbc.password}"/></bean><!-- Spring整合hibernate给hibernate创建单例sessionFactory，并且利用Spring关联数据库 --><bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean"><property name="dataSource" ref="dataSource"/> <!-- 让Spring给这个sessionFactory关联上数据库 --><property name="annotatedClasses"> <!-- 告诉hibernate哪些类被注解了 --><list><value>edu.zust.model.Tuser</value></list></property><property name="hibernateProperties"> <!-- 指明hibernate配置属性 --><props><prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop><prop key="hibernate.show_sql">true</prop><prop key="hibernate.format_sql">true</prop></props></property></bean><!-声明hibernate事务管理--><bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory" /></bean><!-- enable the configuration of transactional behavior based on annotations --><!--指明是用annotation方式--><tx:annotation-driven transaction-manager="txManager"/></beans>

错误是什么？user = list.get(0);

在POJO中字符串大对象可以声明成一个java.lang.String或java.sql.Clob类型。 当程序从数据库中加载Clob类型数据时，仅仅加载了一个Clob类型的数据的逻辑指针。我们需要通过使用Clob.getCaracterStream()方法得到Clob类型的数据输入流之后才能获取大对象数据 在POJO中字符串大对象可以声明成一个java.lang.String或java.sql.Clob类型。当程序从数据库中加载Clob类型数据时，仅仅加载了一个Clob类型的数据的逻辑指针。我们需要通过使用Clob.getCaracterStream()方法得到Clob类型的数据输入流之后才能获取大对象数据。看下面具体代码package dao;import java.io.BufferedReader;import java.io.IOException;import java.io.Reader;import java.math.BigDecimal;import java.sql.Clob;import java.sql.SQLException;import org.hibernate.LobHelper;import org.hibernate.Query;import org.hibernate.Session;import org.hibernate.Transaction;import entity.Clobtable;import Factory.HibernateSessionFactory;public class ClobDao { private Session session = null; private Transaction tran = null; public ClobDao() { session = HibernateSessionFactory.getSession(); } public void saveClob(BigDecimal id,String content){ Clobtable ct = new Clobtable(); ct.setId(id); LobHelper lh = session.getLobHelper(); ct.setContent(lh.createClob(content)); tran = session.beginTransaction(); try{ session.save(ct); tran.commit(); System.out.println("插入成功！"); }catch(Exception e){ tran.rollback(); System.out.println("插入失败"); } } public void getClob(BigDecimal id){ String hql = "from Clobtable where id = ?"; Query query = session.createQuery(hql); query.setBigDecimal(0, id); Clobtable ct = (Clobtable) query.uniqueResult(); Clob clob = ct.getContent(); try { Reader reader = clob.getCharacterStream(); BufferedReader br = new BufferedReader(reader); String content = br.readLine(); System.out.println(content); } catch (SQLException e) { e.printStackTrace(); System.out.println("读取失败！"); } catch (IOException e) { System.out.println("读取失败！"); } }}

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() 前。@GeneratedValue(strategy=GenerationType,generator="") - 可选，用于定义主键生成策略。属性：Strategy - 表示主键生成策略，取值有：GenerationType.AUTO - 根据底层数据库自动选择（默认），若数据库支持自动 增 长类型，则为自动增长。GenerationType.INDENTITY - 根据数据库的Identity字段生成，支持DB2、MySQL、 MS、SQL Server、SyBase与HyperanoicSQL数据库的Identity 类型主键。GenerationType.SEQUENCE - 使用Sequence来决定主键的取值，适合Oracle、DB2等 支持Sequence的数据库，一般结合@SequenceGenerator使用。(Oracle没有自动增长类型，只能用Sequence)GenerationType.TABLE - 使用指定表来决定主键取值，结合@TableGenerator使用。如：@Id@TableGenerator(name="tab_cat_gen",allocationSize=1)@GeneratedValue(Strategy=GenerationType.Table)Generator - 表示主键生成器的名称，这个属性通常和ORM框架相关 , 例如：Hibernate 可以指定 uuid 等主键生成方式@SequenceGenerator — 注解声明了一个数据库序列。属性：name - 表示该表主键生成策略名称，它被引用在@GeneratedValue中设置的“gernerator”值中。sequenceName - 表示生成策略用到的数据库序列名称。initialValue - 表示主键初始值，默认为0.allocationSize - 每次主键值增加的大小，例如设置成1，则表示每次创建新记录后自动加1，默认为50.示例 :@Id@GeneratedValues(strategy=StrategyType.SEQUENCE)public int getPk() {return pk; } Hibernate的访问类型为field时，在字段上进行注解声；访问类型为property时，在getter方法上进行注释声明。2.2 与非主键相关注解@Version - 可以在实体bean中使用@Version注解,通过这种方式可添加对乐观锁定的支持@Basic - 用于声明属性的存取策略：@Basic(fetch=FetchType.EAGER) 即时获取（默认的存取策略）@Basic(fetch=FetchType.LAZY) 延迟获取@Temporal - 用于定义映射到数据库的时间精度：@Temporal(TemporalType=DATE) 日期@Temporal(TemporalType=TIME) 时间@Temporal(TemporalType=TIMESTAMP) 两者兼具@Column - 可将属性映射到列，使用该注解来覆盖默认值，@Column描述了数据库表中 该字段的详细定义，这对于根据 JPA 注解生成数据库表结构的工具非常有作用。属性：name - 可选，表示数据库表中该字段的名称，默认情形属性名称一致nullable -可选，表示该字段是否允许为 null，默认为trueunique - 可选，表示该字段是否是唯一标识，默认为 falselength - 可选，表示该字段的大小，仅对 String 类型的字段有效，默认值255.insertable -可选，表示在ORM框架执行插入操作时，该字段是否应出现INSETRT 语句中，默认为 trueupdateable -可选，表示在ORM 框架执行更新操作时，该字段是否应该出现在 UPDATE语句中，默认为 true.对于一经创建就不可以更改的字段，该 属性非常有用，如对于 birthday字段。columnDefinition - 可选，表示该字段在数据库中的实际类型。通常ORM框架可以根 据属性类型自动判断数据库中字段的类型，但是对于Date类型仍无法确定数据 库中字段类型究竟是 DATE,TIME还是 TIMESTAMP. 此外 ,String 的默认映射类型为VARCHAR, 如果要将 String 类型映射到特定数据库的 BLOB或 TEXT字段类型，该属性非常有用。示例 :@Column(name="BIRTH",nullable="false",columnDefinition="DATE")public String getBithday() {return birthday;}@Transient - 可选，表示该属性并非一个到数据库表的字段的映射，ORM框架将忽略该属性，如果一个属性并非数据库表的字段映射，就务必将其标示为@Transient，否则ORM 框架默认其注解为 @Basic示例 :// 根据 birth 计算出 age 属性@Transientpublic int getAge() {return getYear(new Date()) - getYear(birth);}2.3无注解属性的默认值如果属性为单一类型,则映射为@Basic，否则,如果属性对应的类型定义了@Embeddable注解,则映射为@Embedded，否则,如果属性对应的类型实现了Serializable, 则属性被映射为@Basic并在一个列中保存该对象的serialized版本，否则,如果该属性的类型为java.sql.Clob或 java.sql.Blob,则作为@Lob并映射到适当的LobType.。3.映射继承关系@Inheritance注解来定义所选择的策略. 这个注解需要在每个类层次结构(class hierarchy) 最顶端的实体类上使用4.映射实体bean的关联关系4.1关联映射的一些定义单向一对多：一方有集合属性，包含多个多方，而多方没有一方的引用。用户--->电子邮件单向多对一：多方有一方的引用，一方没有多方的引用。论文类别--->类别双向一对多：两边都有多方的引用，方便查询。班级--->学生双向多对一：两边都有多方的引用，方便查询。单向多对多：需要一个中间表来维护两个实体表。论坛--->文章单向一对一：数据唯一，数据库数据也是一对一。舰船--->水手主键相同的一对一：使用同一个主键，省掉外键关联。客户--->地址单向：关系写哪边，就由谁管理。双向：一般由多方管理。@OneToMany(mappedBy="对方") //反向配置，对方管理。4.2 关联映射的一些共有属性@OneToOne、@OneToMany、@ManyToOne、ManyToMany的共有属性：fetch - 配置加载方式。取值有Fetch.EAGER - 及时加载，多对一默认是Fetch.EAGER Fetch.LAZY - 延迟加载，一对多默认是Fetch.LAZYcascade - 设置级联方式，取值有：CascadeType.PERSIST - 保存CascadeType.REMOVE - 删除CascadeType.MERGE - 修改CascadeType.REFRESH - 刷新CascadeType.ALL - 全部targetEntity - 配置集合属性类型，如：@OneToMany(targetEntity=Book.class)@JoinColumn - 可选，用于描述一个关联的字段。@JoinColumn和@Column类似，介量描述的不是一个简单字段，而是一个关联字段，例如描述一个 @ManyToOne 的字段。属性：name - 该字段的名称，由于@JoinColumn描述的是一个关联字段，如ManyToOne, 则默认的名称由其关联的实体决定。例如，实体 Order 有一个user 属性来关联实体 User, 则 Order 的 user 属性为一个外键 ,其默认的名称为实体User的名称 + 下划线 + 实体User的主键名称4.3 一对一关联@OneToOne – 表示一个一对一的映射1.主表类A与从表类B的主键值相对应。主表：@OneToOne(cascade = CascadeType.ALL)@PrimaryKeyJoinColumnpublic B getB(){Return b;}从表：无2.主表A中有一个从表属性是B类型的b主表：@OneToOne(cascade = CascadeType.ALL)@JoinColumn(name="主表外键") //这里指定的是数据库中的外键字段。public B getB(){return b;}从表：无3.主表A中有一个从表属性是B类型的b，同时，从表B中有一个主表属性是A类型的a主表：@OneToOne(cascade = CascadeType.ALL)@JoinColumn(name="主表外键") //这里指定的是数据库中的外键字段。public B getB(){return b;}从表：@OneToOne(mappedBy = "主表类中的从表属性")public 主表类 get主表类(){return 主表对象}注意：@JoinColumn是可选的。默认值是从表变量名+"_"+从表的主键（注意，这里加的是主键。而不是主键对应的变量）。4.4 多对一关联@ManyToOne - 表示一个多对一的映射，该注解标注的属性通常是数据库表的外键。1.单向多对一：多方有一方的引用，一方没有多方的引用。在多方@ManyToOne(targetEntity=XXXX.class) //指定关联对象@JoinColumn(name="") //指定产生的外键字段名2.双向多对一：配置方式同双向一对多。示例 :// 订单 Order 和用户 User 是一个 ManyToOne 的关系// 在 Order 类中定义@ManyToOne()@JoinColumn(name="USER")public User getUser() {return user;}4.5 一对多关联@OneToMany - 描述一个一对多的关联，该属性应该为集合类型，在数据库中并没有实际字段。1.单向一对多：一方有集合属性，包含多个多方，而多方没有一方的引用。@OneToMany 默认会使用连接表做一对多关联添加@JoinColumn(name="xxx_id") 后，就会使用外键关联，而不使用连接表了。2.双向一对多1）在多方@ManyToOne@JoinColumn(name="自己的数据库外键列名")2）在一方@OneToMany(mappedBy="多端的关联属性名")@JoinColumn(name="对方的数据库外键列名")4.6 多对多关联@ManyToMany - 可选，描述一个多对多的关联。属性：targetEntity - 表示多对多关联的另一个实体类的全名，例如：package.Book.classmappedBy - 用在双向关联中，把关系的维护权翻转。1.单向多对多关联：在主控方加入@ManyToMany注解即可。2.双向多对多关联：两个实体间互相关联的属性必须标记为@ManyToMany，并相互指定targetEntity属性。有且只有一个实体的@ManyToMany注解需要指定mappedBy属性，指向targetEntity的集合属性名称。以下为使用注解的实例：我们以产品类型ProductType类和产品Product类为例，一个产品类型对应多个产品，删除产品类型将该类型下的所有产品同时删除。首先需要@OneToMany和@ManyToOne标签来设置外键约束。在一对多的关系中，一是关系维护端（owner side），多是关系被维护端（inverse side）。@OneToMany有5个属性：targetEntity，fetch，mappedBy，orphanRemoval，cascade# targetEntity （Class targetEntity() default void.class;） 属性表示默认关联的实体类型，默认为当前标注的实体类；因为一对多的实体集合时保存在集合类中，因此必须指明集合类中保存的具体类型：1）指定集合泛型的具体类型；如：public List<Product> getProducts() {...}2）指定targetEntity属性类型；如：@OneToMany(targetEntity=Product.class,...)# fetch (FetchType fetch() default LAZY;) 属性是该实体的加载方式，FetchType是枚举类型，值有两种：LAZY和EAGER。一对多，一的一方，FetchType默认是LAZY, 多的一方FetchType默认是EAGER。如果在字段中声明为Eager，那么在取得当前Bean时，同时会抓取Bean中的关联Bean值。即数据库查询多次。反之Lazy则在之后抓取提交查询。具体实验讲解：[Hibernate] - EAGER and LAZY# mappedBy (String mappedBy() default "";) 属性用于双向关联实体时使用，用在关系的维护端指定关系的被维护端，在hibernate4中与外键标签@JoinColumn冲突，同时使用会报错；如:@OneToMany(targetEntity=Product.class,mappedBy="productType",...)。#orphanRemoval （boolean orphanRemoval() default false;） 属性作用是删除孤立记录，即外键为空的类型，默认为false。该属性为true时会根据外键执行级联删除，因为当你删除productType的记录时，会使product表的记录外键被删除变为孤立记录，该属性进而将孤立记录删除掉。但hibernate实际执行的语句是先删除product表中的记录，后删除productType表中的记录。#cascade （CascadeType[] cascade() default {};） 级联属性，默认为空。该属性其实是一个值为枚举类型CascadeType的数组，在jpa的CascadeType枚举类型里面，有PERSIST（级联保存操作）,MERGE（合并(merge=save+update)）,REMOVE（级联删除操作）,REFRESH（级联刷新操作）,DETACH（级联分离操作）,ALL（所有级联操作）等6个枚举变量，其中DETACH是jpa2.0新加入的变量。这些变量的作用和他们的名字一样，可以很清楚的辨别出。这里我现在仅仅用过级联删除操作，其他的操作都仅仅是从名字和注释上猜测的，留待以后测试。上面是jpa的级联操作，但在网上很多教程中往往写到用CascadeType.DELETE_ORPHAN，该操作属于hibernate自身的级联操作，在hibernate4中已声明过时，并推荐使用orphanRemoval属性来级联删除记录。在级联删除记录时，要先用hibernate.load()方法加载持久化对象，然后才能根据外键进行级联删除。至于load()方法和get()方法有什么不同，这里有一篇博文讲的不错：hibernate session的常用方法解析注意：改变model类的时候可能需要重新建表，如果级联删除不成功可以试一下。下面开始代码，首先是productType类，要求删除type的时候要删掉该type对应的所有

关于rails大容量网站部署的性能讨论数据存放（Session or request），希望能找到平衡点！推荐群组:系统架构与架构应用更多相关推荐Hibernate很奇怪confluence这样优秀的系统都不能支持cluster。引用ClusteringConfluence does not currently support deployment in a cluster. If you deploy Confluence in a clustered environment, you should set up server affinity so that it is only deployed on a single server in the cluster.The reason for this is that Confluence was initially designed to scale vertically on a single machine, and makes a number of compromises concerning use of in-memory caches and disk access that do not translate into a clustered environment. Work is underway to produce a clusterable Confluence (under the code-name "Massive"), but we do not currently have a firm delivery date.For the time being, it may be necessary to deploy multiple Confluence servers, dividing your departments or projects amongst the servers so that the data and load are shared between them. Once Massive is a reality, we will provide tools to combine these back into a single deployment.ps：不知道这样行不行，hibernate应用只跑在一台机器上，各个群集中的网站服务器持久化操作时都通过ejb或其他rmi框架访问（在局域网）。这样hibernate就能用上二级缓存了。但是不知道这样作的性能和 分散的N台机器，分别在各自jvm空间用ibatis持久化操作的性能谁好。 有没有人做过这样的对比。有作门户网站经验的朋友来说说看！推荐链接Java开发新方式：专注UI，快速开发！

cri.setFetchSize(5);没见过这么用的！要是别人用了没问题那就是你的驱动不支持!

这个不需要的

sessionflush在commit之前默认都会执行他。也可以手动执行它，他主要做了两件事：1）清理缓存。2）执行SQL。session在什么情况下执行flush*默认在事务提交时*显示的调用flush*在执行查询前，如：iteratehibernate按照save(insert),update、delete顺序提交相关操作

读MSQ的blob图片出错误是经常的事啊！

好久没用过hibernate了 不过看你的问题 感觉是 你添加数据之后没有更新 categorys 这个list 如果数据确实是插入了 那么就肯定是同步问题了

第一个方法public Object get(Class clazz,Serializable id);就是根据id查对象

??这个什么东西？没有这个的吧，这个xml不是必需的。。。要hibernate.cfg.xml就足够了...有一种可能是你的这个文件是实体类的映射文件一般为 XXX.hbm.xml...有点模糊...贴那个xml的代码出来看看啊~

　　Hibernate <>的一对多和多对一操作真的很方便 如果系统采用Hibernate作为持久层 完全可以把对应的一对多和多对一逻辑关系放在Hibernate里面控制 减少数据库的负担 而且也更清晰 　　 多对一和一对多概念 　　其实这个概念上来说很简单 比如一个客户可以有多个订单 多个订单属于同一个客户 就是最基本的一对多 和多对一 数据库使用中 感觉多对一和一对多算是比较常见的逻辑关系了 　　我曾经做过一些数据库 比如某些 *** 部门的 其表单很设计的很简单粗糙 甚至连主键都没有 完全靠在事务层补全这些关系 其实通过Hibernate持久层来实现逻辑关系也是很不错的方法 下面的例子 就是数据库逻辑上基本没有定义 主要放在持久层里面 这个也主要是我对数据库操作属于半通水的原因 　　 数据库层 　　这里面有两个表单 一个CUSTOMER 客户表单 一个是ORDERS 订单表单 生成客户表单 这个是在SQLServer里面做的 其实其他都一样 因为逻辑关系在Hibernate上面 id是主键非空 其他可以为空 　　 CREATETABLE[dbo] [CUSTOMER]( 　　 [id][numeric]( )NOTNULL 　　 [name][varchar]( )NULL 　　 [age][int]NULL 　　 CONSTRAINT[PK_CUSTOMER]PRIMARYKEY） 　　订单表单 　　id为主键非空 CUSTOMER_id是对应客户主键 也非空 这里不做外键设置 　　 CREATETABLE[dbo] [ORDERS]（ 　　 [id][numeric]( )NULLPRIMARYKEY 　　 [CUSTOMER_id][numeric]( )NOTNULL 　　 [ORDER_NUMBER][varchar]( )NULL 　　 [PRICE][numeric]( )NULL 　　 ) 　　 Hibernate设定 　　HIbernate里面 一对多的对象体现 是客户有一个集合set set里面放著对应订单 而多对一体现 是订单里面有一个CUSTOMER对象 表明该订单所属的客户 其中 CUSTOMER类为 　　 publicclassCustomerimplementsjava io Serializable{ 　　 privateLongid; 　　 privateStringname; 　　 privateIntegerage; 　　 privateSetrderses=newHashSet(); 　　 　　 ｝ 　　后面的getXXX和setXXX方法就省去了 同样订单类就是 　　 publicclassOrdersimplementsjava io Serializable{ 　　 privateLongid; 　　 privateCustomercustomer; 　　 privateStringorderNumber; 　　 privateDoubleprice; 　　 　　 ｝ 　　而对应hbm文档 就是map文档如下 　　 CUSTOMER hbm xml 　　 <!DOCTYPEhibernate mappingPUBLIC //Hibernate/HibernateMappingDTD //EN 　　 mapping dtd > 　　 <! 　　 MappingfileautogeneratedbyMyEclipsePersistenceTools 　　 > 　　 <hibernate mapping> 　　 <classnameclassname= onetomany Customer table= CUSTOMER schema= dbo catalog= DBTEST > 　　 <idnameidname= id type= java lang Long > 　　 <columnnamecolumnname= id precision= scale= /> 　　 <generatorclassgeneratorclass= increment /> 　　 </id> 　　 <propertynamepropertyname= name type= java lang String > 　　 <columnnamecolumnname= name length= /> 　　 </property> 　　 <propertynamepropertyname= age type= java lang Integer > 　　 <columnnamecolumnname= age /> 　　 </property> 　　 <setnamesetname= orderses inverse= true lazy= true cascade= all > 　　 <key> 　　 <columnnamecolumnname= CUSTOMER_id precision= scale= not null= true /> 　　 </key> 　　 <one to manyclassone to manyclass= onetomany Orders /> 　　 </set> 　　 </class> 　　 </hibernate mapping> 　　这个里面 其他都很简答了 其中<generatorclass= increment />表示主键值自动增加 这个主要针对字符串对应的 主要体现多对以的是 　　 <setnamesetname= orderses inverse= true lazy= true cascade= all > 　　 <key> 　　 <columnnamecolumnname= CUSTOMER_id precision= scale= not null= true /> 　　 </key> 　　 <one to manyclassone to manyclass= onetomany Orders /> 　　 </set> 　　其中 set表示 对应集合 fetch和lazy主要是用来级联查询的 而cascade和inverse主要是用来级联插入和修改的 这几个主要包括对集合的控制 <one to manyclass= onetomany Orders />表示对应类 即set里面包含的类 而key主要是用于确定set里面对应表单列 　　 ORDERS的hbm 　　 <?xmlversionxmlversion= encoding= utf ?> 　　 <!DOCTYPEhibernate mappingPUBLIC //Hibernate/HibernateMappingDTD //EN 　　 mapping dtd > 　　 <! 　　 MappingfileautogeneratedbyMyEclipsePersistenceTools 　　 > 　　 <hibernate mapping> 　　 <classcatalogclasscatalog= DBTEST name= onetomany Orders schema= dbo table= ORDERS > 　　 <idnameidname= id type= java lang Long > 　　 <columnnamecolumnname= id precision= scale= /> 　　 <generatorclassgeneratorclass= increment /> 　　 </id> 　　 <many to oneclas *** any to oneclass= onetomany Customer fetch= select name= customer > 　　 <columnnamecolumnname= CUSTOMER_id precision= scale= /> 　　 </many to one> 　　 <propertygeneratedpropertygenerated= never lazy= false name= orderNumber type= java lang String > 　　 <columnlengthcolumnlength= name= ORDER_NUMBER /> 　　 </property> 　　 <propertygeneratedpropertygenerated= never lazy= false name= price type= java lang Double > 　　 <columnnamecolumnname= PRICE precision= scale= /> 　　 </property> 　　 </class> 　　 </hibernate mapping> 　　 <many to oneclas *** any to oneclass= onetomany Customer fetch= select name= customer > 　　 <columnnamecolumnname= CUSTOMER_id precision= scale= /> 　　 </many to one> 　　表示CUSTOMER熟悉对应的类 和其作为key的列名 上面这些都可以在MyEclipse里面自动生成 另外注意的一点是 在生成的DAO里面 涉及表单操作的save()和delete()方法 必须要事件提交 数据库才有反映 可以就该Hibernate xml 或者用下面这样代码来实现 　　 Sessionse=getSession(); 　　 Transactiontx=se beginTransaction(); 　　 se delete(persistentInstance); 　　 //se save(instance); 　　mit(); 　　 验证效果 　　 新增用户 　　如果新增一个用户 该用户里面包含有两个表单 那么 由于持久层已经实现了逻辑关系 只要用户类里面的set包含了表单 则表单可以自动增加 实现代码 　　 CustomerDAOcd=newCustomerDAO(); 　　 Customerxd=newCustomer( 王小虎 null); 　　 Ordersord =newOrders(); 　　 ord setCustomer(xd); 　　 ord setOrderNumber( 王小虎的买单 ); 　　 Ordersord =newOrders(); 　　 ord setCustomer(xd); 　　 ord setOrderNumber( 王小虎的买单 ); 　　 Setrderses=newHashSet(); 　　 orderses add(ord ); 　　 orderses add(ord ); 　　 xd setOrderses(orderses); 　　 cd save(xd); 　　代码里面 加入一个王小虎用户 两个订单 通过setOrderses加入 只使用cd save这一个对持久层操作 完成后查询 　　 王小虎 　　 ================================= 　　 王小虎的买单 　　 王小虎的买单 　　显示 CUSTOMER里面加入了王小虎 ORDERS里面也加入他的订单 　　 删除操作 　　 List<Customer>csList=cd findByProperty( name 王小虎 ); 　　 for(Customercs:csList){ 　　 cd delete(cs); 　　 } 　　这个很简单了 通过其中findByProperty( name 王小虎 );对应SQL为deletefromtableCUSTOMERwherename= 王小虎 ;删除了王小虎 而ORDERS里面 王小虎对应的表单也同时被删除 　　 小小总结 lishixinzhi/Article/program/Java/ky/201311/28543

在ssh的hibernate中写上这个方法 public List findTop(){log.debug("finding all Bulletin instances");try {String queryString = "select top 10 from Bulletin order by Bulletin_Time desc";return getHibernateTemplate().find(queryString);} catch (RuntimeException re) {log.error("find all failed", re);throw re;}}from Bulletin order by Bulletin_Time desc直接这么写的话可以执行但是换成上面的语句就org.springframework.orm.hibernate3.HibernateQueryException: unexpected token: 10 near line 1, column 12 [select top 10 from com.volunteer.yy.vo.Bulletin order by Bulletin_Time desc]; nested exception is org.hibernate.hql.ast.QuerySyntaxException: unexpected token: 10 near line 1, column 12 [select top 10 from com.volunteer.yy.vo.Bulletin order by Bulletin_Time desc]Caused by: org.hibernate.hql.ast.QuerySyntaxException: unexpected token: 10 near line 1, column 12 [select top 10 from com.volunteer.yy.vo.Bulletin order by Bulletin_Time desc]

对于模糊查询T-SQL有四个通配符%：包含0个或多个字符_:匹配指定；[]:指定范围[^]:排除范围对于稍复杂点的关键词搜索（比如新闻），常用的办法是在数据库中添加一个keyword字段，来配合通配符进行模糊查询或分类查询或热门关键字查询。关于复杂点的模糊查询，更好的方法是不用这些通配符来实现，而是通过js来实现（例如输入时产生搜索提示），或其他方法来作，思路是尽量少的对数据库进行操作。

看hibernate.cfg.xml的配置文件，或者看jar包

因为人都怕帮助别人自己却受到亏损

很透彻了

1、开发对比开发速度Hibernate的真正掌握要比Mybatis来得难些。Mybatis框架相对简单很容易上手，但也相对简陋些。个人觉得要用好Mybatis还是首先要先理解好Hibernate。开发社区Hibernate 与Mybatis都是流行的持久层开发框架，但Hibernate开发社区相对多热闹些，支持的工具也多，更新也快，当前最高版本4.1.8。而Mybatis相对平静，工具较少，当前最高版本3.2。开发工作量Hibernate和MyBatis都有相应的代码生成工具。可以生成简单基本的DAO层方法。针对高级查询，Mybatis需要手动编写SQL语句，以及ResultMap。而Hibernate有良好的映射机制，开发者无需关心SQL的生成与结果映射，可以更专注于业务流程。2、系统调优对比Hibernate的调优方案制定合理的缓存策略；尽量使用延迟加载特性；采用合理的Session管理机制；使用批量抓取，设定合理的批处理参数（batch_size）;进行合理的O/R映射设计Mybatis调优方案MyBatis在Session方面和Hibernate的Session生命周期是一致的，同样需要合理的Session管理机制。MyBatis同样具有二级缓存机制。 MyBatis可以进行详细的SQL优化设计。SQL优化方面Hibernate的查询会将表中的所有字段查询出来，这一点会有性能消耗。Hibernate也可以自己写SQL来指定需要查询的字段，但这样就破坏了Hibernate开发的简洁性。而Mybatis的SQL是手动编写的，所以可以按需求指定查询的字段。Hibernate HQL语句的调优需要将SQL打印出来，而Hibernate的SQL被很多人嫌弃因为太丑了。MyBatis的SQL是自己手动写的所以调整方便。但Hibernate具有自己的日志统计。Mybatis本身不带日志统计，使用Log4j进行日志记录。扩展性方面Hibernate与具体数据库的关联只需在XML文件中配置即可，所有的HQL语句与具体使用的数据库无关，移植性很好。MyBatis项目中所有的SQL语句都是依赖所用的数据库的，所以不同数据库类型的支持不好。3、对象管理与抓取策略对象管理Hibernate 是完整的对象/关系映射解决方案，它提供了对象状态管理（state management）的功能，使开发者不再需要理会底层数据库系统的细节。也就是说，相对于常见的 JDBC/SQL 持久层方案中需要管理 SQL 语句，Hibernate采用了更自然的面向对象的视角来持久化 Java 应用中的数据。换句话说，使用 Hibernate 的开发者应该总是关注对象的状态（state），不必考虑 SQL 语句的执行。这部分细节已经由 Hibernate 掌管妥当，只有开发者在进行系统性能调优的时候才需要进行了解。而MyBatis在这一块没有文档说明，用户需要对对象自己进行详细的管理。抓取策略Hibernate对实体关联对象的抓取有着良好的机制。对于每一个关联关系都可以详细地设置是否延迟加载，并且提供关联抓取、查询抓取、子查询抓取、批量抓取四种模式。 它是详细配置和处理的。而Mybatis的延迟加载是全局配置的。4、缓存机制对比Hibernate缓存Hibernate一级缓存是Session缓存，利用好一级缓存就需要对Session的生命周期进行管理好。建议在一个Action操作中使用一个Session。一级缓存需要对Session进行严格管理。Hibernate二级缓存是SessionFactory级的缓存。 SessionFactory的缓存分为内置缓存和外置缓存。内置缓存中存放的是SessionFactory对象的一些集合属性包含的数据(映射元素据及预定SQL语句等),对于应用程序来说,它是只读的。外置缓存中存放的是数据库数据的副本,其作用和一级缓存类似.二级缓存除了以内存作为存储介质外,还可以选用硬盘等外部存储设备。二级缓存称为进程级缓存或SessionFactory级缓存，它可以被所有session共享，它的生命周期伴随着SessionFactory的生命周期存在和消亡。5、优势对比Mybatis优势MyBatis可以进行更为细致的SQL优化，可以减少查询字段。MyBatis容易掌握，而Hibernate门槛较高。Hibernate优势Hibernate的DAO层开发比MyBatis简单，Mybatis需要维护SQL和结果映射。Hibernate对对象的维护和缓存要比MyBatis好，对增删改查的对象的维护要方便。Hibernate数据库移植性很好，MyBatis的数据库移植性不好，不同的数据库需要写不同SQL。Hibernate有更好的二级缓存机制，可以使用第三方缓存。MyBatis本身提供的缓存机制不佳。

大小写,变量第一个字母要大写 ,跟踪看一下set的时候值过去了么？？

查看Hibernate的版本，首先要找到Hibernate的jar包，然后右击，以压缩文件打开，找到META-INF文件夹，打开这个文件夹找到MANIFEST.MF文件，打开里面就有Hibernate的版本信息了！

1、内存消耗：采用JDBC的无疑是最省内存的，Hibernate的次之 2、运行效率：如果JDBC的代码写的非常优化，那么JDBC架构运行效率最高，但是实际项目中，这一点几乎做不到，这需要程序员非常精通JDBC，运用Batch语句，调整PreapredStatement的Batch Size和Fetch Size等参数，以及在必要的情况下采用结果集cache等等。而一般情况下程序员是做不到这一点的。因此Hibernate架构表现出最快的运行效率。3、开发效率：在大的项目，特别是持久层关系映射很复杂的情况下，Hibernate效率高的惊人，JDBC次之

数据库查询性能的提升也是涉及到开发中的各个阶段，在开发中选用正确的查询方法无疑是最基础也最简单的。使用正确的SQL语句可以在很大程度上提高系统的查询性能。获得同样数据而采用不同方式的SQL语句在性能上的差距可能是十分巨大的。由于Hibernate是对JDBC的封装，SQL语句的产生都是动态由Hibernate自动完成的。Hibernate产生SQL语句的方式有两种：一种是通过开发人员编写的HQL语句来生成，另一种是依据开发人员对关联对象的访问来自动生成相应的SQL语句。至于使用什么样的SQL语句可以获得更好的性能要依据数据库的结构以及所要获取数据的具体情况来进行处理。在确定了所要执行的SQL语句后，可以通过以下三个方面来影响Hibernate所生成的SQL语句：● HQL语句的书写方法。● 查询时所使用的查询方法。● 对象关联时所使用的抓取策略。

对象关系映射

这个你百度一下，好多的。

sql 面向数据库表查询hql 面向对象查询hql ： from 后面跟的 类名＋类对象 where 后 用 对象的属性做条件sql： from 后面跟的是表名 where 后 用表中字段做条件查询在Hibernate中使用查询时，一般使用Hql查询语句。HQL（Hibernate Query Language），即Hibernate的查询语言跟SQL非常相像。不过HQL与SQL的最根本的区别，就是它是面向对象的。

要关闭hibernate的日志，首先要把hibernate.show_sql设置为false;然后设置log4j.properties。# Control logging for other open source packageslog4j.logger.com.opensymphony.oscache=ERRORlog4j.logger.net.sf.navigator=ERRORlog4j.logger.net.sf.acegisecurity=WARNlog4j.logger.net.sf.acegisecurity.intercept.event.LoggerListener=WARNlog4j.logger.org.apache.commons=ERRORlog4j.logger.org.apache.struts=WARNlog4j.logger.org.displaytag=ERRORlog4j.logger.org.springframework=WARNlog4j.logger.com.ibatis.db=WARNlog4j.logger.org.apache.velocity=WARN# Don"t show debug logs for WebTestlog4j.logger.com.canoo.webtest=WARN# All hibernate log output of "info" level or higher goes to stdout.# For more verbose logging, change the "info" to "debug" on the last line.log4j.logger.org.hibernate.ps.PreparedStatementCache=WARNlog4j.logger.org.hibernate=WARN# Changing the log level to DEBUG will result in Hibernate generated# SQL to be logged.log4j.logger.org.hibernate.SQL=ERROR# Changing the log level to DEBUG will result in the PreparedStatement# bound variable values to be logged.log4j.logger.org.hibernate.type=ERROR

<class name="Address"> <id name="id" column="addressId"> <generator class="native"/> </id> <one-to-one name="person" property-ref="address"/></class>U00100023U0010006dU0010003fU0010003f U001000ccU00100022U0010001fU00100013U00100015U00100022U00100083 U001000e6U00100021U00100083 U0010006e

1：瞬时/临时(Transient) - 由new操作符创建，且尚未与Hibernate Session 关联的对象被认定为瞬时的。瞬时对象不会被持久化到数据库中，也不会被赋予持久化标识(identifier)。 如果瞬时对象在程序中没有被引用，它会被垃圾回收器销毁。 2：持久(Persistent) - 持久的实例在数据库中有对应的记录，并拥有一个持久化标识。 持久的实例可能是刚被保存的，或刚被加载的，无论哪一种，按定义，它存在于相关联的Session作用范围内。 Hibernate会检测到处于持久状态的对象的任何改动，在当前操作单元执行完毕时将对象数据与数据库同步。开发者不需要手动执行UPDATE。3：脱管/游离(Detached) - 与持久对象关联的Session被关闭后，对象就变为脱管的。 对脱管对象的引用依然有效，对象可继续被修改。脱管对象如果重新关联到某个新的Session上， 会再次转变为持久的，在脱管期间的改动将被持久化到数据库。

there were many big round

　　学习 Hibernate 源码一　　1. 下载 hibernate 源码，并构建起 eclipse 项目　　（ 1 ） hibernate 的源代码采用 git 管理，安装 git 客户端以后，通过点击 github.com/hibernate/hibernate-orm 页面右侧的“ Clone in Desktop ”可启动客户端将代码 clone 到本地。当然也可以直接使用　　git clone git://github.com/hibernate/hibernate-orm.git　　命令下载代码。　　下载完毕后，打开根目录下的 readme 文件，可以看到详细的把源代码构建为不同 IDE 项目的说明；以及其他的一些信息。　　对应文档的网站链接：　　community.jboss.org/wiki/BuildingHibernateORM4x5x　　构建 IDE 部分：　　Eclipse　　To create the Eclipse project files you can run　　After changes to the dependencies you need to clean the project files and recreate them:　　./gradlew cleanEclipse eclipse　　See also Contributing to Hibernate using Eclipse　　Idea　　To create the Idea project files you can run　　./gradlew idea　　After changes to the dependencies you need to clean the project files and recreate them:　　./gradlew cleanIdea idea　　此处的 gradle 是 hibernate 所使用的自动构建工具，官网地址为：　　.gradle.org/　　下载地址为： .gradle.org/downloads ，选择一个版本进行下载　　此处是 Hibernate 团队阐述其从 Maven 迁移到 Gradle 的原因： community.jboss.org/wiki/GradleWhy　　至于 grable ，有时间会深入学习一下，感兴趣的同学可以看看这位博主的博客：　　.blogjava.net/wldandan/archive/2012/06/26/381532.html　　言归正传，下载 grable 后，解压，我将其解压到了 C 盘根目录，解压完毕的 grable 所在目录为： C:gradle-1.7 ，将其子目录 C:gradle-1.7in 目录加入系统的 Path 变量　　编译代码为 eclipse 项目：　　（ 1 ）进入 hibernate 源码的根目录：　　cd C:UsersAdministratorDocumentsGitHubhibernate-orm　　（ 2 ）执行 gradlew.bat eclipse　　接着会自动下载项目所需要的依赖项，具体输出如下：　　C:UsersAdministratorDocumentsGitHubhibernate-orm >gradlew.bat eclipse　　Creating properties on demand (a.k.a. dynamic properties) has been deprecated and is scheduled to be removed in Gradle 2.0. Please read gradle.org/docs/current/dsl/org.gradle.api.plugins.ExtraPropertiesExtension.html for information on　　Deprecated dynamic property: "exportPackageVersion" on "project ":documentation"", value: "4.3.0".　　Deprecated dynamic property "exportPackageVersion" created in multiple locations.　　FAILURE: Build failed with an exception.　　* Where:　　Build file "C:UsersAdministratorDocumentsGitHubhibernate-ormuild.gradle" line: 85　　* What went wrong:　　A problem occurred evaluating root project "hibernate-orm".　　> org/hibernate/build/gradle/publish/auth/maven/AuthenticationManager : Unsupported major.minor version 51.0　　* Try:　　Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get more log output.　　此时我去查看我的环境变量， JAVA_HOME 指向的是 64 位的 JDK6 ，将其指向 32 位 JDK7 后再次执行　　gradlew.bat eclipse　　发现此时 gradlew 又去下载了其他的依赖包，查看 hibernate-rom 目录下的 libraries.gradle 文件，可以看到 hibernate 的依赖包。　　重新编译过程中还是报错了，具体错误：　　:hibernate-core:compileJava　　警告 : [options] 未与 -source 1.6 一起设置引导类路径　　C:UsersAdministratorDocumentsGitHubhibernate-ormhibernate-coresrcmainjavaorghibernateannotationsLoader.java:38: 错误 : 编码 GBK 的不可映射字符　　* @author L 锟絪 zl 锟 ?Benke　　^　　C:UsersAdministratorDocumentsGitHubhibernate-ormhibernate-coresrcmainjavaorghibernateannotationsResultCheckStyle.java:29: 错误 : 编码 GBK 的不可映射字符　　* @author L 锟絪 zl 锟 ?Benke　　^　　C:UsersAdministratorDocumentsGitHubhibernate-ormhibernate-coresrcmainjavaorghibernateannotationsSQLDelete.java:37: 错误 : 编码 GBK 的不可映射字符　　* @author L 锟絪 zl 锟 ?Benke　　^　　C:UsersAdministratorDocumentsGitHubhibernate-ormhibernate-coresrcmainjavaorghibernateannotationsSQLDeleteAll.java:37: 错误 : 编码 GBK 的不可映射字符　　* @author L 锟絪 zl 锟 ?Benke　　^　　C:UsersAdministratorDocumentsGitHubhibernate-ormhibernate-coresrcmainjavaorghibernateannotationsSQLInsert.java:37: 错误 : 编码 GBK 的不可映射字符　　* @author L 锟絪 zl 锟 ?Benke　　^　　C:UsersAdministratorDocumentsGitHubhibernate-ormhibernate-coresrcmainjavaorghibernateannotationsSQLUpdate.java:37: 错误 : 编码 GBK 的不可映射字符　　* @author L 锟絪 zl 锟 ?Benke　　^　　注 : 某些输入文件使用或覆盖了已过时的 API 。　　注 : 有关详细信息 , 请使用 -Xlint:deprecation 重新编译。　　注 : 某些输入文件使用了未经检查或不安全的操作。　　注 : 有关详细信息 , 请使用 -Xlint:unchecked 重新编译。　　1 个警告　　google 了一下，貌似是区域语言设置的问题，需要修改为“英语（英国）”，但编译并没用中断，接着编译。我将控制面板中的区域语言设置修改后，继续观察，看其是否还会报同样的错误。　　最终还是失败了：　　:hibernate-entitymanager:compileJava　　警告 : [options] 未与 -source 1.6 一起设置引导类路径　　C:UsersAdministratorDocumentsGitHubhibernate-ormhibernate-entitymanagersrcmainjavaorghibernatejpaAvailableSettings.java:290: 错误 : 编码 GBK 的不可映射字符　　* contains 钬淐 REATE SCHEMA 钬 ?commands. If this property is not supplied (or is explicitly {@code false}), the　　^　　注 : 某些输入文件使用或覆盖了已过时的 API 。　　注 : 有关详细信息 , 请使用 -Xlint:deprecation 重新编译。　　注 : 某些输入文件使用了未经检查或不安全的操作。　　注 : 有关详细信息 , 请使用 -Xlint:unchecked 重新编译。

对于一个项目来讲，dao设计的一个原则就是可以比较方便的替换orm的具体实现。比如我可以替换Hibernate为ibatis而不需要改变我的业务代码。 这是不是说只是在dao的实现阶段，才会考虑到Hibernate？2，在我学过的所有框架中，Hibernate是比较难以掌握的一个。而且从论坛上提问的情况可以看出来，很多人对Hibernate的理解差不多跟我同样的水平。针对一个项目而言，如果项目组内没有Hibernate专家，还是不要使用Hibernate的为好，而成为Hibernate方面的专家是一件非常困难的事情。是不是很多人在为了使用Hibernate而使用Hibernate？而不是针对项目组的实际情况呢？ 5，我曾经在没有使用过ibatis的时候，仅仅通过看同事的代码就能使用ibatis，而且使用起来得心应手。但是我现在专门学习Hibernate超过五十个小时，我觉得我还是不能熟练的掌握Hibernate，这是为什么？（如果Hibernate这么复杂，我们可以因为他复杂而不去使用他吗？Hibernate有什么理由去说服我们为了学习他而花那么多时间？） 1.为了减少拼sql的工作，这点ibatis也可以解决。 2.可以实现二级缓存，这点ibatis里的cache不知道能做到多少，介于两种框架对数据库的要求和建模方式，cache的效果应该是hibernate强于ibatis。 3.hibernate可以跨主流数据库，这点是ibatis比不了的。 hibernate比ibatis复杂很多，数据库建模要保持多外键，少冗余才能保证对大限度利用缓存。虽然你设计成少外键多冗余的方式hibernate也能实现，但是总觉得不利于缓存。 因为hibernate的复杂，如果项目里没有一个特别了解的人，项目一定会在关键问题上堵死，所以一定要小心选用。不懂的话，不要冒险，为了项目着想。 1:dao一般式屏蔽底层数据库的差异吧 2:hibernate 不熟悉的话，建议还是不要用。如果实在想试试身手，对于一些表的关系不是很复杂的项目可以考虑下。个人比较倾向spring JdbcTemplate 1 开发快，公司看重，码奴标配。 2 可以基于领域驱动，不需要去过分关注烦人的数据库。 3 优化得当，性能不同凡响。（不得当也是不同凡响）缺点：1 学习曲线高（回头看看还真不低）

去百度百科看看

couldnotinstantiateRegionFactory不能实例化

肯定可以使用集群。问题也肯定有，毕竟它用的缓存那么多。像OSCache就支持集群。

1、按正常来看，这个配置是没问题的。2、我做过java+sqlserver2000和java+sqlserver2005的开发，它们的配置是不一样的，尤其是在驱动类方面。3、依然报错，在没有实例测试的情况下，我建议你换两个参数： a、jdbc.driver=net.sourceforge.jtds.jdbc.Driver b、hibernate.dialect=org.hibernate.dialect.SQLServerDialect c、jdbc的驱动jar包换成jtds-1.x.jar试下，jtds-1.2.jar可以作为首选。祝你好运。

有三种方式，不过不是楼上说的那三种。1.HQL查询2.QBC查询3.本地SQL查询

1.Hibernate 常见异常net.sf.hibernate.MappingException 当出现net.sf.hibernate.MappingException: Error reading resource:…异常时一般是因为映射文件出现错误。 当出现net.sf.hibernate.MappingException: Resource: … not found是因为XML配置文件没找到所致，有可能是放置目录不正确，或者没将其加入hibernate.cfg.xml中。2. net.sf.hibernate.PropertyNotFoundException 当出现net.sf.hibernate.PropertyNotFoundException: Could not find a setter for propertyname in class …时，原因一般是因为XML映射文件中的属性与对应的Java类中的属性的getter或setter方法不一致。3. org.hibernate.id.IdentifierGenerationException 当出现org.hibernate.id.IdentifierGenerationException: ids for this class must be manually assigned before calling save():异常时，一般是因为<id>元素配置不正确，<id>元素缺少其子元素<generator></generator>的配置引起。 解决方案：<id>元素映射了相应数据库表的主键字段，对其子元素<generator >,其中class的取值可以为increment、identity、sequence、hilo、native……等，更多的可参考hibernate参考文档，一般取其值为native 。

第一种:1.在需要禁用懒加载的映射文件中显示的加入lazy = "false"这个方法大大的降低了程序的运行效率,如果访问量小还是可以的第二种:2.在web.xml中配置<filter><filter-name>openSessionInViewFilter</filter-name><filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class></filter><filter-mapping><filter-name>openSessionInViewFilter</filter-name><url-pattern>/*</url-pattern></filter-mapping>这是一个一劳永逸解决懒加载问题的办法.使用spring的openSessionInViewFilter.openSessionInViewFilter,改过滤器在view渲染时始终开启session,一劳永逸解决hibernate的懒加载问题,该过滤器必须配置在struts2过滤器之前,如果访问增大性能会降低不推荐使用(性能问题)第三种:3.强行在service层面是初始化代理对象.就是在获取对象之后,强行去加载对象中属性集合(推荐)例如:public Department getDepartmentWithChildren(Integer id){Department s = DepartmentDao.getEntity(id);//强行初始化pages和questions集合for(Student stu : s.getStudents()){stu.getClasses.size();}return s; }

hibernate 是一个数据持久层的框架,只管 怎么去访问及操作数据库的数据.spring 是一个更加强大的框架,是为J2EE 应用程序开发提供集成的框架,体现在其简单性、可测试性和松耦合上,同时对面向切面编程也有支撑的.再简单打个比方,hibernate 是 仓库的仓储管理人员,负责货物的仓储管理.spring 就是 管理层的核心领导,负责协调调度,以保障企业的良好运作.

Hibernate查询所有数据的操作方式有三种。1、Query（1）使用该方法查询时，不需要编写sql语句，但是需要编写hql（Hibernate Query Language）语句，该语句是Hibernate查询语言。（2）hql语言操作的是实体类和实体类的属性，比如查询所有数据的hql语句为：from 实体类名称。（3）使用方法：首先创建Query对象，然后调用该对象的List方法返回数据集合。@Testpublic void test11(){SessionFactory sessionFactory = null;Session session = null;Transaction tx = null;try {sessionFactory = HibernateUtils.getFactory();session = sessionFactory.getCurrentSession();tx = session.beginTransaction();/*** 使用session对象的createQuery方法创建Query对象。* 参数为hql语句* 使用QUERY对象的list方法获取数据集合*/Query query =session.createQuery("from UserEntity");List<UserEntity> list = query.list();//使用forEach遍历集合for (UserEntity userEntity : list) {System.out.println(userEntity);}tx.commit();} catch (Exception e) {tx.rollback();}finally{sessionFactory.close();}}2、criteria（1）使用该对象不需要写hql语句，只需要指定实体类。（2）使用方法：首先创建criteria对象，然后调用list返回数据集合。@Testpublic void test12(){SessionFactory sessionFactory = null;Session session = null;Transaction tx = null;try {sessionFactory = HibernateUtils.getFactory();session = sessionFactory.getCurrentSession();tx = session.beginTransaction();/*** 使用session对象的createCriteria方法创建criteria对象。* 使用criteria对象的list方法获取数据集合*/Criteria criteria =session.createCriteria(UserEntity.class);List<UserEntity> list = criteria.list();//使用forEach遍历集合for (UserEntity userEntity : list) {System.out.println(userEntity);}tx.commit();} catch (Exception e) {tx.rollback();}finally{sessionFactory.close();}}3、SQLQuery（1）使用该对象，需要写底层的SQL语句。（2）实现方法：首先创建该对象，然后调用list。@Testpublic void test13(){SessionFactory sessionFactory = null;Session session = null;Transaction tx = null;try {sessionFactory = HibernateUtils.getFactory();session = sessionFactory.getCurrentSession();tx = session.beginTransaction();/*** 使用session对象的createSQLQuery方法创建SQLQuery对象。* 使用qQLQuery对象的list方法获取数据集合,集合里面不是对象，而是数组*/SQLQuery qQLQuery =session.createSQLQuery("select * from t_user");List<Object[]> list = qQLQuery.list();//使用forEach遍历集合for (Object[] objects : list) {System.out.println(Arrays.toString(objects));}tx.commit();} catch (Exception e) {tx.rollback();}finally{sessionFactory.close();}}（3）数组转换成对象@Test public void test13(){ SessionFactory sessionFactory = null; Session session = null; Transaction tx = null; try { sessionFactory = HibernateUtils.getFactory(); session = sessionFactory.getCurrentSession(); tx = session.beginTransaction(); /** * 使用session对象的createSQLQuery方法创建SQLQuery对象。 * 使用qQLQuery对象的list方法获取数据集合,集合里面不是对象，而是数组 */ SQLQuery qQLQuery =session.createSQLQuery("select * from t_user");//将数组装载进实体中 qQLQuery.addEntity(UserEntity.class); List<UserEntity > list = qQLQuery.list(); //使用forEach遍历集合 for (UserEntity userEntity : list) { System.out.println(userEntity); } tx.commit(); } catch (Exception e) { tx.rollback(); }finally{ sessionFactory.close(); } }

　　Hibernate和Mybatis都是orm对象关系映射框架，都是用于将数据持久化的框架技术。　　Hiberante较深度的封装了jdbc，对开发者写sql的能力要求的不是那么的高，只要通过hql语句操作对象即可完成对数据持久化的操作了。　　另外hibernate可移植性好，如一个项目开始使用的是mysql数据库，但是随着业务的发展，现mysql数据库已经无法满足当前的绣球了，现在决定使用Oracle数据库，虽然sql标准定义的数据库间的sql语句差距不大，但是不同的数据库sql标准还是有差距的，那么手动修改起来会存在很大的困难，使用hibernate只需改变一下数据库方言即可搞定。用hibernate框架，数据库的移植变的非常方便。　　但是hibernate也存在着诸多的不足，比如在实际开发过程中会生成很多不必要的sql语句耗费程序资源，优化起来也不是很方便，且对存储过程支持的也不够太强大。但是针对于hibernate它也提供了一些优化策略，比如说懒加载、缓存、策略模式等都是针对于它的优化方案。　　Mybatis 也是对jdbc的封装，但是封装的没有hibernate那么深，可以再配置文件中写sql语句，可以根据需求定制sql语句，数据优化起来较hibernate容易很多。　　Mybatis要求程序员写sql的能力要相对使用hibernate的开发人员要高的多，且可移植性也不是很好。

hibernate的特点 : 解决了直接用JDBC操作数据库的烦琐操作。屏蔽了各种数据库的实现细节。 JDBC执行效率会比Hibernate高些。Hibernate和Mybatis它们的编码复杂度为O(n)，也就是说每操作一个DB的表，就要写一次dao。一个十分钟即可学会的ORM框架--Bee , 编码复杂度是O(1)，不用重复编写代码。1) 编码复杂度C(n)=O(n)，即会随实体的增长，编码量呈线性增长。当n较大时，会增加许多工作量。2) 需要写很多的判断字段是否为空（null) ，是否是空字符串的语句；工作重复，乏味。3）实体Javabean与DB表的map映射文件太多；或者，实体Javabean文件注解用得太泛滥，太多注解难以记忆，增加开发人员负担。4) Hibernate的概念太复杂，学习成本高，更新会先查询再更新，n+1问题。一个十分钟即可学会的ORM框架--Bee , 编码复杂度是O(1). 编码复杂度是O(1)，就是说ORM框架只写一次就行了，没必要写n次。(想想数据结构中时间复杂度，空间复杂度从O(n)提升到O(1)对性能的影响有多大）。

我学了一点SSH知识，以下回答是我个人观点。仅供参考。这三个东西我感觉貌似没有启动这一说。它们是框架。一般来说，如果把它们集成了。那牵扯到它们内容的部分，可能会因为配置或者其它的不正确而产生错误，或者失效。我认为它们并不像tomcat需要启动这一说法。不过貌似程序运行前它们需要初始化。如果你问的是初始化完成，那这个我就不大清楚了。以上回答，仅供参考。

缓存的介质一般是内存，所以读写速度很快。但如果缓存中存放的数据量非常大时，也会用硬盘作为缓存介质。缓存的实现不仅仅要考虑存储的介质，还要考虑到管理缓存的并发访问和缓存数据的生命周期。Hibernate的缓存包括Session的缓存和SessionFactory的缓存，其中SessionFactory的缓存又可以分为两类：内置缓存和外置缓存。Session的缓存是内置的，不能被卸载，也被称为Hibernate的第一级缓存。SessionFactory的内置缓存和Session的缓存在实现方式上比较相似，前者是SessionFactory对象的一些集合属性包含的数据，后者是指Session的一些集合属性包含的数据。SessionFactory的内置缓存中存放了映射元数据和预定义SQL语句，映射元数据是映射文件中数据的拷贝，而预定义SQL语句是在Hibernate初始化阶段根据映射元数据推导出来，SessionFactory的内置缓存是只读的，应用程序不能修改缓存中的映射元数据和预定义SQL语句，因此SessionFactory不需要进行内置缓存与映射文件的同步。SessionFactory的外置缓存是一个可配置的插件。在默认情况下，SessionFactory不会启用这个插件。外置缓存的数据是数据库数据的拷贝，外置缓存的介质可以是内存或者硬盘。SessionFactory的外置缓存也被称为Hibernate的第二级缓存。Hibernate的这两级缓存都位于持久化层，存放的都是数据库数据的拷贝，为了理解二者的区别，需要深入理解持久化层的缓存的两个特性：缓存的范围和缓存的并发访问策略。

一、Hibernate是JDBC的轻量级的对象封装，它是一个独立的对象持久层框架，和App Server，和EJB没有什么必然的联系。Hibernate可以用在任何JDBC可以使用的场合，例如Java应用程序的数据库访问代码，DAO接口的实现类，甚至可以是BMP里面的访问数据库的代码。从这个意义上来说，Hibernate和EB不是一个范畴的东西，也不存在非此即彼的关系。 二、Hibernate是一个和JDBC密切关联的框架，所以Hibernate的兼容性和JDBC驱动，和数据库都有一定的关系，但是和使用它的Java程序，和App Server没有任何关系，也不存在兼容性问题。 三、Hibernate不能用来直接和Entity Bean做对比，只有放在整个J2EE项目的框架中才能比较。并且即使是放在软件整体框架中来看，Hibernate也是做为JDBC的替代者出现的，而不是Entity Bean的替代者出现的，让我再列一次我已经列n次的框架结构： 传统的架构： 1) Session Bean <-> Entity Bean <-> DB 为了解决性能障碍的替代架构： 2) Session Bean <-> DAO <-> JDBC <-> DB 使用Hibernate来提高上面架构的开发效率的架构： 3) Session Bean <-> DAO <-> Hibernate <-> DB 就上面3个架构来分析： 1、内存消耗：采用JDBC的架构2无疑是最省内存的，Hibernate的架构3次之，EB的架构1最差。 2、运行效率：如果JDBC的代码写的非常优化，那么JDBC架构运行效率最高，但是实际项目中，这一点几乎做不到，这需要程序员非常精通JDBC，运用Batch语句，调整PreapredStatement的Batch Size和Fetch Size等参数，以及在必要的情况下采用结果集cache等等。而一般情况下程序员是做不到这一点的。因此Hibernate架构表现出最快的运行效率。EB的架构效率会差的很远。 3、开发效率：在有JBuilder的支持下以及简单的项目，EB架构开发效率最高，JDBC次之，Hibernate最差。但是在大的项目，特别是持久层关系映射很复杂的情况下，Hibernate效率高的惊人，JDBC次之，而EB架构很可能会失败。 4、分布式，安全检查，集群，负载均衡的支持 由于有SB做为Facade，3个架构没有区别。 四、EB和Hibernate学习难度在哪里？ EB的难度在哪里？不在复杂的XML配置文件上，而在于EB运用稍微不慎，就有严重的性能障碍。所以难在你需要学习很多EJB设计模式来避开性能问题，需要学习App Server和EB的配置来优化EB的运行效率。做EB的开发工作，程序员的大部分精力都被放到了EB的性能问题上了，反而没有更多的精力关注本身就主要投入精力去考虑的对象持久层的设计上来。 全国计算机等级考试 备考资料 计算机一级考试 计算机二级考试 计算机三级考试 计算机四级考试 Hibernate难在哪里？不在Hibernate本身的复杂，实际上Hibernate非常的简单，难在Hibernate太灵活了。 当你用EB来实现持久层的时候，你会发现EB实在是太笨拙了，笨拙到你根本没有什么可以选择的余地，所以你根本就不用花费精力去设计方案，去平衡方案的好坏，去费脑筋考虑选择哪个方案，因为只有唯一的方案摆在你面前，你只能这么做，没得选择。 Hibernate相反，它太灵活了，相同的问题，你至少可以设计出十几种方案来解决，所以特别的犯难，究竟用这个，还是用那个呢？这些方案之间到底有什么区别呢？他们的运行原理有什么不同？运行效率哪个比较好？光是主键生成，就有七八种方案供你选择，你为难不为难？集合属性可以用Set，可以用List，还可以用Bag，到底哪个效率高，你为难不为难？查询可以用iterator，可以用list，哪个好，有什么区别？你为难不为难？复合主键你可以直接在hbm里面配置，也可以自定义CustomerType，哪种比较好些？你为难不为难？对于一个表，你可以选择单一映射一个对象，也可以映射成父子对象，还可以映射成两个1:1的对象，在什么情况下用哪种方案比较好，你为难不为难？ 这个列表可以一直开列下去，直到你不想再看下去为止。当你面前摆着无数的眼花缭乱的方案的时候，你会觉得幸福呢？还是悲哀呢？如果你是一个负责的程序员，那么你一定会仔细研究每种方案的区别，每种方案的效率，每种方案的适用场合，你会觉得你已经陷入进去拔不出来了。如果是用EB，你第一秒种就已经做出了决定，根本没得选择，比如说集合属性，你只能用Collection，如果是Hibernate，你会在Bag，List和Set之间来回犹豫不决，甚至搞不清楚的话，程序都没有办法写。 Hibernate本身封装的非常轻量级，所以理论上来说Hibernate的稳定性应该非常接近JDBC驱动的稳定性。但是这里面有一个变数，就是Hibernate采用cglib库来动态生成PO的字节码，这个cglib是我所不熟悉的，而在重负载，大容量的情况下，JVM内存里面会有非常频繁的PO字节码生成的过程，我不知道该过程是否会对Hibernate的稳定性造成一定的影响。 前面我提到过用Hibernate对SAPDB一次插入10万条记录导致SAPDB挂掉的故障，如果用JDBC，插入10万条不会挂掉，会在插入20万条的时候挂掉，这还可以是数据库的问题。 另有一次，我在Weblogic7.0上，用Weblogic的连接池连接Oracle8i做大容量，密集请求的访问测试，用10个并发，1000次请求，每次查询1万条去测试，结果发现Hibernate到是很稳定，但是连接池挂掉了。但同样的数据量，用JDBC却没有问题。当然上到更高的负载，JDBC迟早也会把连接池挂掉，但是好像表现出来的是Hibernate对数据库的“破坏能力”比JDBC要强一些，我搞不清楚这究竟是怎么回事，按道理来说，Hibernate和JDBC不应该表现出不同的结果来，不过我的机器配置也比较低，也有可能是硬件配置造成的。 这需要一个很好的环境来做测试，找出原因。至少需要一个硬件很好的机器安装像Oracle这样的中负载数据库。另一台机器也要很好的配置运行测试程序，避免硬件问题。JDBC驱动本身也要很稳定，然后分别直接连接数据库，和在App Server上面运行测试，找出JDBC和Hibernate挂掉连接池和数据库的临界值，记录JVM内存使用和CPU占用，分析出原因，究竟是因为Hibernate在这方面有缺陷，还是没有缺陷。 Singleton模式的SessionFactory就行了，把它配置到App Server的CLASSPATH下面去，这样在EJB，在Servlet/JSP都可以使用了。

　　Hibernate JPA依赖的JAR包：　　1、Hibernate核心包(8个文件)　　hibernate-distribution-3.3.1.GA　　hibernate3.jar　　libytecodecglibhibernate-cglib-repack-2.1_3..jar　　lib equired*.jar　　2、Hibernate注解包(3个文件)　　hibernate-annotations-3.4.0.GA　　hibernate-annotations.jar　　libejb3-persistence.jar　　hibernate-commons-annotations.jar　　3、Hibernate针对JPA的实现包(3个文件)　　hibernate-entitymanager-3.4.0.GA　　hibernate-entitymanager.jar　　lib estlog4j.jar　　slf4j-log4j12.jar

主要是两类，1）一个总体用的hibernate.cfg.xml，比如设置数据库用户名、密码、常量、映射文件位置等等信息的地方，这个文件整个hibernate项目只用一个就可；2）每个实体映射都有一个***.hbm.xml文件，即实体映射文件，里面写的是数据库和实体类的映射配置，包含关系映射或继承映射等等；比如Student.java实体类就用Student.hbm.xml这个映射文件；所以一个hibernate项目往往有多个配置文件。不过这些配置也可以以注解(Annotation)形式写在实体类里面。hibernate支持标准的JPA标准注解。

事务配置的问题；报错信息里面写的很清楚了；看下你DAO的事务是怎么控制的；贴出代码；比较合理的实践是在你的SERVICE控制事务；而不是在DAO层；解决这个问题应该不难。

以前没怎么用过mybatis，只知道与hibernate一样是个orm数据库框架。随着使用熟练度的增加，发现它与hibernate区别是非常大的，结合至今为止的经验，总结出以下几点：1. hibernate是全自动，而mybatis是半自动。hibernate完全可以通过对象关系模型实现对数据库的操作，拥有完整的JavaBean对象与数据库的映射结构来自动生成sql。而mybatis仅有基本的字段映射，对象数据以及对象实际关系仍然需要通过手写sql来实现和管理。2. hibernate数据库移植性远大于mybatis。hibernate通过它强大的映射结构和hql语言，大大降低了对象与数据库（oracle、mysql等）的耦合性，而mybatis由于需要手写sql，因此与数据库的耦合性直接取决于程序员写sql的方法，如果sql不具通用性而用了很多某数据库特性的sql语句的话，移植性也会随之降低很多，成本很高。3. hibernate拥有完整的日志系统，mybatis则欠缺一些。hibernate日志系统非常健全，涉及广泛，包括：sql记录、关系异常、优化警告、缓存提示、脏数据警告等；而mybatis则除了基本记录功能外，功能薄弱很多。4. mybatis相比hibernate需要关心很多细节hibernate配置要比mybatis复杂的多，学习成本也比mybatis高。但也正因为mybatis使用简单，才导致它要比hibernate关心很多技术细节。mybatis由于不用考虑很多细节，开发模式上与传统jdbc区别很小，因此很容易上手并开发项目，但忽略细节会导致项目前期bug较多，因而开发出相对稳定的软件很慢，而开发出软件却很快。hibernate则正好与之相反。但是如果使用hibernate很熟练的话，实际上开发效率丝毫不差于甚至超越mybatis。5. sql直接优化上，mybatis要比hibernate方便很多由于mybatis的sql都是写在xml里，因此优化sql比hibernate方便很多。而hibernate的sql很多都是自动生成的，无法直接维护sql；虽有hql，但功能还是不及sql强大，见到报表等变态需求时，hql也歇菜，也就是说hql是有局限的；hibernate虽然也支持原生sql，但开发模式上却与orm不同，需要转换思维，因此使用上不是非常方便。总之写sql的灵活度上hibernate不及mybatis。总结：mybatis：小巧、方便、高效、简单、直接、半自动hibernate：强大、方便、高效、复杂、绕弯子、全自动mybatis：1. 入门简单，即学即用，提供了数据库查询的自动对象绑定功能，而且延续了很好的SQL使用经验，对于没有那么高的对象模型要求的项目来说，相当完美。2. 可以进行更为细致的SQL优化，可以减少查询字段。3. 缺点就是框架还是比较简陋，功能尚有缺失，虽然简化了数据绑定代码，但是整个底层数据库查询实际还是要自己写的，工作量也比较大，而且不太容易适应快速数据库修改。4. 二级缓存机制不佳。hibernate：1. 功能强大，数据库无关性好，O/R映射能力强，如果你对Hibernate相当精通，而且对Hibernate进行了适当的封装，那么你的项目整个持久层代码会相当简单，需要写的代码很少，开发速度很快，非常爽。2. 有更好的二级缓存机制，可以使用第三方缓存。3. 缺点就是学习门槛不低，要精通门槛更高，而且怎么设计O/R映射，在性能和对象模型之间如何权衡取得平衡，以及怎样用好Hibernate方面需要你的经验和能力都很强才行。举个形象的比喻：mybatis：机械工具，使用方便，拿来就用，但工作还是要自己来作，不过工具是活的，怎么使由我决定。ufeffufeffhibernate：智能机器人，但研发它（学习、熟练度）的成本很高，工作都可以摆脱他了，但仅限于它能做的事。ufeffufeff

spring和hibernate有什么区别？分别都是干什么的？ hibernate 是一个数据持久层的框架,只管 怎么去访问及操作数据库的数据. spring 是一个更加强大的框架,是为J2EE 应用程序开发提供集成的框架,体现在其简单性、可测试性和松耦合上,同时对面向切面编程也有支撑的. 再简单打个比方, hibernate 是 仓库的仓储管理人员,负责货物的仓储管理. spring 就是 管理层的核心领导,负责协调调度,以保障企业的良好运作. 以下机构分别都是干什么的？有什么区别？ 不同部门的纪律检查委员会是负责处理违犯党的纪律的情况下，以调查和处理党的领导干部和监督在公安机关负责调查违反纪律警方人员，该检察院国家法律监督，主要是负责国家工作有关的犯罪，及时发现和处理与犯罪审查逮捕和审查起诉职责，廉政公署（ICAC）调查违反的法律和纪律的官员， *** 机构的各级负责接受的请愿信访局，并协调处理的投诉。 ado 和 odbc有什么区别，分别是干什么的？ 界面在VC里面做，需要建立exe工程，使用ado或者odbc建立都行，这两者是连接数据库的两种不同方法，ODBC(Open Database Connectivity，开放数据库互连)是微软公司开放服务结构(WOSA，Windows Open Services Architecture)中有关数据库的一个组成部分，它建立了一组规范，并提供了一组对数据库访问的标准API（应用程序编程接口）。这些API利用SQL来完成其大部分任务。ODBC本身也提供了对SQL语言的支持，用户可以直接将SQL语句送给ODBC。 ADO (ActiveX Data Objects) 是一个用于存取数据源的COM组件。它提供了编程语言和统一数据访问方式OLE DB的一个中间层。允许开发人员编写访问数据的代码而不用关心数据库是如何实现的，而只用关心到数据库的连接。访问数据库的时候，关于SQL的知识不是必要的，但是特定数据库支持的SQL命令仍可以通过ADO中的命令对象来执行。 各自连接数据库和执行sql的方式有点不同，但都可以实现操作数据库。 cobol中batch和online有什么区别?都是干什么的? batch:指的是非人工操作，由计算机自动执行cobol编译好的可执行文件，类似于计划任务：到了 特定时间自动执行。执行时间一般在夜间。周期有，日次，周次，月次之分。 online：指的是人工操作。一般是操作由带有画面的程序，直接操作画面上的各个控件。进而操作数据库等等。 java web start和tomcat有什么区别？分别是干什么的？ java web start 是种技术,和tomcat没有什么关系,你可以百度下 tomcat是web容器,和asp中的iis一样 bank中的clerk和cashier分别是干什么的?有什么区别? clerk银行职员，普通员工 cashier收款员（商场等） 口袋怪兽龙牙和龙鳞有什么区别都是干什么的 龙牙不是能加龙系攻击，而是提升龙系招式威力10%，你去流星瀑布，有一个龙系训练师，不断变换场景，多与他打几次，他就会出宝宝龙，他的宝宝龙身上100%有龙牙，小偷即可。另，不嫌麻烦的话，在四大天王山洞入口处池塘，用高杆钓鱼，能钓到哈克龙，5%几率携带龙牙。野生的宝宝龙只有龙鳞啊。 龙鳞原是海刺龙进化道具，386里用水之石代替了，所以没用，卖了吧。

hibernate相当于封住了一次jdbc,使hibernate不用考虑你是用的什么数据库，他的HQL语句都可以根据你不同数据库的方言编译成相对应的数据库sql语句，这是hibernate的一大优势，但是因为他的HQL语句都要经过编译才能成对应数据库可以执行的语句，所以用它做持久层他比ibatis稍慢。

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。Session:在计算机中，尤其是在网络应用中，称为"会话控制"。Session 对象存储特定用户会话所需的属性及配置信息。这样，当用户在应用程序的 Web 页之间跳转时，存储在 Session 对象中的变量将不会丢失，而是在整个用户会话中一直存在下去。当用户请求来自应用程序的 Web 页时，如果该用户还没有会话，则 Web 服务器将自动创建一个 Session 对象。当会话过期或被放弃后，服务器将终止该会话。Session 对象最常见的一个用法就是存储用户的首选项。例如，如果用户指明不喜欢查看图形，就可以将该信息存储在 Session 对象中。有关使用 Session 对象的详细信息，请参阅"ASP 应用程序"部分的"管理会话"。注意 会话状态仅在支持 cookie 的浏览器中保留。HIBERNATE是 自然水公司SESSION 是从自然水公司到你家里的管道。要用水，你必须先造一个管道。如果延迟加载的话，记得把水龙头开着。

Gavin对于做事情的执着始于十一岁时，他最早的软件开发成果毁于极其糟糕、不稳定的Commodore 64磁带驱动。Gavin King曾在Monash大学攻读数学，2003年9月，Gavin King加入了JBoss，全面领导hibernate的开发，并给客户提供最好的服务和培训。目前，Gavin King在红帽公司负责JBoss Hibernate 和基于CMP 引擎的新Hibernate项目的开发。

hql & criteria

LZ还是用JPA的注释吧，比XML方便多了。

Hibernate中Session是数据库的一个连接,一个session就是一个连接，相当于jdbc。connection。平时的session是用户的会话，记录用户的信息

hibernate的特点 : 解决了直接用JDBC操作数据库的烦琐操作。屏蔽了各种数据库的实现细节。Hibernate和Mybatis它们的编码复杂度为O(n)，也就是说每操作一个DB的表，就要写一次dao。1) 编码复杂度C(n)=O(n)，即会随实体的增长，编码量呈线性增长。当n较大时，会增加许多工作量。2) 需要写很多的判断字段是否为空（null) ，是否是空字符串的语句；工作重复，乏味。3）实体Javabean与DB表的map映射文件太多；或者，实体Javabean文件注解用得太泛滥，太多注解难以记忆，增加开发人员负担。4) Hibernate的概念太复杂，学习成本高，更新会先查询再更新，n+1问题。一个十分钟即可学会的ORM框架--Bee , 编码复杂度是O(1). 编码复杂度是O(1)，就是说ORM框架只写一次就行了，没必要写n次。(想想数据结构中时间复杂度，空间复杂度从O(n)提升到O(1)对性能的影响有多大）。

1.Hibernate的优缺点： 优点：1、程序更加面向对象； 2、提高了生产率； 3、方便移植（修改配置文件）； 4、无侵入性。 缺点： 1、效率比JDBC略差； 2、不适合批量操作。2.Hibernate有四种查询方案： 1、get,load方法，根据id查找对象 2、HQL--hibernate query language（查询对象：Query) 3、Criteria--标准查询语言（查询对象：Criteria，查询条件：Criterion） 4、通过sql来查（查询对象：SQLQuery）

1、jdbc的缺点1、代码太繁琐了2、不是面向对象的数据库操作3、资源关闭的代码也很繁琐，每次都得打开、关闭4、没有做到数据缓存5、移植性比较差优点：因为是最低层的操作，所以效率比较高2、hibernate1、代码比较精简了2、是面向对象的数据库操作3、只需要关闭一个对象就可以了session4、数据缓存 一级缓存 二级缓存 查询缓存5、移植性比较好缺点：1、程序员不能控制sql语句的生成hibernate中有一个hql2、如果一个项目对sql语句的优化要求特别高，不适合用hibernate3、如果一张表的数据量特别大，不适合用hibernate

1.Hibernate的优缺点：x0dx0a 优点：1、程序更加面向对象；x0dx0a 2、提高了生产率；x0dx0a 3、方便移植（修改配置文件）；x0dx0a 4、无侵入性。x0dx0a 缺点：x0dx0a 1、效率比JDBC略差；x0dx0a 2、不适合批量操作。x0dx0ax0dx0a2.Hibernate有四种查询方案：x0dx0a 1、get,load方法，根据id查找对象x0dx0a 2、HQL--hibernate query language（查询对象：Query)x0dx0a 3、Criteria--标准查询语言（查询对象：Criteria，查询条件：Criterion）x0dx0a 4、通过sql来查（查询对象：SQLQuery）

另外 hibernate 有自己的 hql所以 它解决了了 各个数据库之间 sql语言不同而产生一直困难的问题。起到解耦的作用。

呵呵，是啊，一楼的回答最可爱:-)