iber

词典结果：liberty[英][u02c8lu026abu0259ti][美][u02c8lu026abu0259rti]n.自由; 许可权; 放肆，无礼; 解放，释放; 复数：liberties易混淆单词：LibertyLIBERTY以上结果来自金山词霸例句:1.Sell not virtue to purchase wealth, nor liberty to purchase power. 不要出卖美德换取财富，也不要用自由交换权力。-----------------------------------如有疑问欢迎追问！满意请点击右上方【选为满意回答】按钮

lady liberty自由女神双语例句 1Ellis Island is a small island only a mile away form Lady Liberty.埃利斯岛是个小岛，离自由女神像只有一英里远。2Hey! Just noticed Lady Liberty"s right foot was not firmly on the pedestal.嘿！刚注意到自由女神的右脚并非稳固地踏在台座上.

自由n. 自由；许可；冒失n. (Liberty)人名；(英)利伯蒂

歌曲名:Libera Me (Requiem Op 48, Movement 6)歌手:Ledger& Kings College Choir专辑:RequiemDe profundis clamavi ad te domineDomine exaudi vocem meam de profundisDe profundis clamavi ad te domineDomine exaudi vocem meam de profundisLibera me domine de morteAre you the friend I can not seeLibera me domine de morteAre you the one who cares for meLibera me domine de morteIt"s only you can set me freeLibera me domine de morteAeternaLibera Liberahttp://music.baidu.com/song/2706445

歌曲名:Slow Down歌手:jazz liberatorz专辑:BackpackersSlow DownLove And TheftLife i need to talk to youCan you spare a minute just tell what to doI"m trying to climb this hillI can feel you pass me by like i"m standing stillThe things i gota do i"m feeling you leaving me behindAnd i know i don"t wanna go down this road aline and i"m running out timeSo slow down you"re losing meAnd i can"t see what you want me to beSo slow down cause all i know is that i can"t go as fast as you"ve got me spinning roundI"m barely hanging on,slow downLife the moments pass me byMemories that i can"t keep as hard as i may tryLife you"re so beautifulI wish it wasn"t so but i can only stay untilYou say i gotta goGod only knows when that"s gonna beWith all my might i"m trying to keep up with youNow you"re running away from mehttp://music.baidu.com/song/55656258

五一学了一个新的分析方法- CIBERSORT ，这个包其实很早就想学的，因为现在一般的单细胞文章的套路，很难不用到它，那么它能干什么呢？ 它能够推测出bulk RNA每一个样本中各类细胞的比例 。通俗易懂的来讲，就是能够 把bulk RNA当作single cell RNA来分析 。 实现把bulk RNA当作single cell RNA来分析主要是有两种算法 反卷积 和 ssgsea ，而CIBERSORT就是基于反卷积算法来做的，所以这篇着重介绍反卷积算法。 要想了解什么是反卷积，我们就要了解什么是卷积，我先show一张图，这张图就展示了卷积的过程 我想用一些比较容易懂的话来讲卷积，所以可能讲述或隐喻的不准确，望谅解！！！ 根据这张图我们可以看出 其实bulk RNAseq就像是每一个细胞的RNA-seq卷起来的乘积，所以称为卷积（图：左边（bulk）是右边（cell）的乘积运算的结果，而这个乘积运算需要细胞的表达量和一个系数表），现在我们来解释 反卷积 ： 反卷积顾名思义反过来/不卷积，对bulkRNA的反卷积就相当于对bulk RNA进行除法，我们只要给一个系数表，就可以得到细胞的RNA表达量，那么我们就可以知道bulk中有哪一些细胞类型了 。(其实没有那么简单哈，但是大致是这样的，里面涉及到算法啥的我也不知道怎么解释，主要是也不太会哈哈哈哈） 那么根据上面的解释我们可以知道假如进行bulk RNA的反卷积，我们需要什么： 1.系数表 2.bulk RNA的表达矩阵（假如你是一个生信入门的人，你一定要注意这个，表达矩阵，什么样的表达矩阵,首先是芯片还是RNA-seq，再是count？fpkm？rpkm？cpm？CIBERSORT说的很清楚，芯片或者RNA-seq都可以，参数上选择不同而已，RNA-seq数据不建议直接使用Count，应使用FPKM和TPM或DESEq2标准化后的矩阵为宜） 首先LM22-ref.txt文件是什么，这里要从免疫浸润讲起，免疫浸润可以当作肿瘤组织中全部免疫细胞的总和，而LM22就是拿来分析免疫浸润的，所以我们用excel打开来看看这个文件吧，第一列是基因名字,后面每一列是某类细胞和他们gene symbol的系数，所以这个LM22-ref.txt文件就是我们的 系数表 (关于这个表格怎么来的可以去看其他大神的文章) 这时候我们还缺我们的 bulk RNA的表达矩阵 ，所以我们要拥有一个这样的表格，把它保存为txt文件，命名为 test.txt 然后我们就可以得到这样的result 何为个性化，就是当我们在做单细胞分析的时候，自己定义了一个群或者定义了一些细胞，想看这种细胞类型在bulk中的含量该怎么办呢，我怎么得到每一种细胞类型的系数呢？其实没有那么复杂，细胞类型的系数表其实就是 AverageExpression ，所以我们可以这样来做 后面附上sig.txt用excel打开后的样子，以免大家报错 在这里我需要强调，大家不要小看给出来的txt用excel打开后的格式，因为这是报错的主要原因，一定要跟我的格式一样，为什么呢，可以看CIBERSORT.R这个函数 写在文末，假如大家真的很想了解这个算法，强烈建议去看jimmy老师的教程，我这个只做参考！！！ References: https://www.jianshu.com/p/03a7440c0960 https://cloud.tencent.com/developer/article/1622907 https://cloud.tencent.com/developer/article/1784632 https://mp.weixin.qq.com/s?__biz=MzAxMDkxODM1Ng==&mid=2247493507&idx=1&sn=e8533247aa045ce82e3a6cbb9f3b4281&scene=21#wechat_redirect https://www.jianshu.com/p/2991ef7bf993

politics 这里指政见的意思，谓语动词一般用复数形式，例如：What are your politics? 你的政见如何？

在锐捷交换机中，开启光口需要经过以下步骤：1. 连接串口或Telnet到交换机的CLI界面。2. 找到要开启光口的接口，并进入接口配置模式。例如，如果要开启GigabitEthernet 1/0/1接口，可以输入命令"interface gigabitethernet 1/0/1"。3. 输入命令"media-type fiber"，将接口模式设置为光口模式。4. 输入命令"shutdown"关闭接口。5. 输入命令"no shutdown"启用接口。完成上述操作后，交换机的光口就已经开启了。在CLI界面输入命令"show interface status"可以查看接口状态，确保光口已经正常工作。

音 乐：石川智久 歌： 野口百南花（CV：井上麻里奈） 收录曲： エンディング曲“my sweet home（Full Ver.)” 试听：http://www.qq190.com/music/139341.htm下载：http://58.61.34.206/down?cid=99ADE8AEBE9A408EEA65B176A2618D3712C34CC4&t=0&fmt=-

session.createQuery("需要执行的hql"); 这种是用hiberante hql语句如果你要用 sql 那你就只能或得connection连接 用jdbc写了

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

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

是的。always free.semper 副词alwaysliber 形容词free

我喜欢tom的~~

　　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

Publisher/Subscriber　英 　 　 美 　 　n.出版者/订阅者Publisher/Subscriber的用法和样例：例句Are sometimes useful for distinguishing the point-to-point and publish subscribe approaches.有时对于区别点对点方式和发布订阅方式而言很有用。Implementation of Topic based publish subscribe design pattern using Socket programming and proprietary messaging protocol.实现主题的设计模式出版订阅使用套接字编程及专有通讯协议。

vibration英 [vau026au02c8breu026au0283n] 美 [vau026au02c8breu0283u0259n] n.震动; 摆动; 感受; （偏离平衡位置的）一次性往复振动I am sure I can feel a vibration through the soles of my feet. 我敢肯定我能感到脚底下有震动。

Ohhhhh　　Let"sgo,sheismyLatinGirl　　一起走吧，她是我的拉丁女孩　　She"smyLatinGirl　　她是我的拉丁女孩　　Iwasonthebeach,yeah,Iwasonvacation　　当时我正在沙滩，对，我正在度假　　Iwasdoingnothing,Iwasjustsittingpatient　　我正在无聊中，我耐心的坐着　　Thenyouwalkedbyyoucaughtmyeye　　然后你从我身边走过，你吸引了我　　Isaidwho"sthisgirl?　　我说这是哪个女孩？　　She"slookingsuperfly　　她看起来好酷好漂亮　　HeyMissbeautiful,I"veneverseenyoubefore　　嘿！美丽女士，我从来没遇到过你　　AndIwouldliketobetheoneshowyouIamcoolatall　　我很乐意为你成为一个能展示全能的人　　Heylittlemama,whatyougotonya?　　嘿！小女士，你是否已经得到了你想要的东西？　　Lookingsogood　　你看起来很漂亮　　AndIjustwanttotelephoneya　　而我只想能得到你的电话号码　　She"smylatingirl　　她是我的拉丁女孩　　Ohhh　　噢~~~　　Prettyladydon"tyouthinkit"scrazy　　漂亮女士，你不认为这样很疯狂吗？　　She"smylatingirl　　她是我的拉丁女孩　　Ohhhh　　噢~~~　　Shetriestofightit　　她尝试与自己的思想作斗争　　Butsheknowsshelikesit　　但她清楚自己喜欢这种感觉　　She"smylatingirl　　她是我的拉丁女孩　　Ooohhh　　她是我的拉丁女孩　　Sowannasee…　　很想再看她一眼　　Thenshe"slookingatme　　而她正看着我　　She"smylatingirl　　她是我的拉丁女孩　　Yeahyeahyeah　　HeyMissbeautiful　　嘿！美丽女士　　I"veneverseenyoubefore　　我从来没遇到过你　　AndIwouldliketobetheoneshowyouIamcoolatall　　我很乐意为你成为一个能展示全能的人　　Heylittlemama，Whatyougotonya?　　嘿！小女士，你是否已经得到了你想要的东西？　　Lookingsogood,andIjustwanttotelephoneya　　而我只想能得到你的电话号码　　She"smylatingirl　　她是我的拉丁女孩　　Ooohhhh　　噢~~~　　Prettyladydon"tyouthinkit"scrazy　　漂亮女士，你不认为这样很疯狂吗？　　She"smylatingirl　　她是我的拉丁女孩　　Ooohhh　　噢~~~　　Shetriestofightit　　她尝试与自己的思想作斗争　　Butsheknowsshelikesit　　但她清楚自己喜欢这种感觉　　She"smylatingirl　　她是我的拉丁女孩　　Ooohhhh　　噢~~~　　Sowannasee…　　很想再看她一眼　　Thenshe"slookingatme　　而她正看着我　　She"smylatingirl　　她是我的拉丁女孩　　Yeahyeahyeah　　She"smylatingirl　　她是我的拉丁女孩　　Ooohhh　　噢~~~　　Prettyladydon"tyouthinkit"scrazy　　漂亮女士，你不认为这样很疯狂吗？　　She"smylatingirl　　她是我的拉丁女孩　　Ooohhh　　噢~~~　　Shetriestofightit　　她尝试与自己的思想作斗争　　Butsheknowsshelikesit　　但她清楚自己喜欢这种感觉　　She"smylatingirl　　她是我的拉丁女孩　　Oooohhh　　噢~~~　　Sowannasee…　　很想再看她一眼　　Thenshe"slookingatme　　而她正看着我　　She"smylatingirl　　她是我的拉丁女孩　　Yeahyeahyeah

在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]

@overriide :限定重写父类方法，该注解只能用于方法。@deprecated:用于表示某个程序元素（类，方法）已过时。@SupperessWarnings:抑制编译器警告。@Autowired是根据类型进行自动装配的。在上面的例子中，如果当Spring上下文中存在不止一个UserDao类型@Qualifier配合@Autowired来解决这些问题。 @Resource的作用相当于@Autowired，只不过@Autowired按byType自动注入，而@Resource默认按byName自动注入罢了。@Resource有两个属性是比较重要的，分别是name和type，Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。所以如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既不指定name也不指定type属性，这时将通过反射机制使用byName自动注入策略。@PostConstruct（JSR-250） 在方法上加上注解@PostConstruct，这个方法就会在Bean初始化之后被Spring容器执行（注：Bean初始化包括，实例化Bean，并装配Bean的属性（依赖注入））。 它的一个典型的应用场景是，当你需要往Bean里注入一个其父类中定义的属性，而你又无法复写父类的属性或属性的setter方法时.@PreDestroy（JSR-250） 在方法上加上注解@PreDestroy，这个方法就会在Bean初始化之后被Spring容器执行。由于我们当前还没有需要用到它的场景，这里不不去演示。其用法同@PostConstruct。.使用@Scope来定义Bean的作用范围 在使用XML定义Bean时，我们可能还需要通过bean的scope属性来定义一个Bean的作用范围，我们同样可以通过@Scope注解来完成这项工这些都应该是spring注解方式 看看是不是你要的 如果是 你就按照spring注解方式去百度上再搜搜 还有很多答案

对于模糊查询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语句的书写方法。● 查询时所使用的查询方法。● 对象关联时所使用的抓取策略。

对象关系映射

第一章 Hibernate与MyBatisHibernate 是当前最流行的O/R mapping框架，它出身于sf.net，现在已经成为Jboss的一部分。 Mybatis 是另外一种优秀的O/R mapping框架。目前属于apache的一个子项目。MyBatis 参考资料官网：http://www.mybatis.org/core/zh/index.html Hibernate参考资料： http://docs.jboss.org/hibernate/core/3.6/reference/zh-CN/html_single/1.1 Hibernate 简介Hibernate对数据库结构提供了较为完整的封装，Hibernate的O/R Mapping实现了POJO 和数据库表之间的映射，以及SQL 的自动生成和执行。程序员往往只需定义好了POJO 到数据库表的映射关系，即可通过Hibernate 提供的方法完成持久层操作。程序员甚至不需要对SQL 的熟练掌握， Hibernate/OJB 会根据制定的存储逻辑，自动生成对应的SQL 并调用JDBC 接口加以执行。1.2 MyBatis简介iBATIS 的着力点，则在于POJO 与SQL之间的映射关系。然后通过映射配置文件，将SQL所需的参数，以及返回的结果字段映射到指定POJO。 相对Hibernate“O/R”而言，iBATIS 是一种“Sql Mapping”的ORM实现。第二章 开发对比开发速度Hibernate的真正掌握要比Mybatis来得难些。Mybatis框架相对简单很容易上手，但也相对简陋些。个人觉得要用好Mybatis还是首先要先理解好Hibernate。开发社区Hibernate 与Mybatis都是流行的持久层开发框架，但Hibernate开发社区相对多热闹些，支持的工具也多，更新也快，当前最高版本4.1.8。而Mybatis相对平静，工具较少，当前最高版本3.2。开发工作量Hibernate和MyBatis都有相应的代码生成工具。可以生成简单基本的DAO层方法。针对高级查询，Mybatis需要手动编写SQL语句，以及ResultMap。而Hibernate有良好的映射机制，开发者无需关心SQL的生成与结果映射，可以更专注于业务流程。第三章 系统调优对比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语句都是依赖所用的数据库的，所以不同数据库类型的支持不好。第四章 对象管理与抓取策略对象管理Hibernate 是完整的对象/关系映射解决方案，它提供了对象状态管理（state management）的功能，使开发者不再需要理会底层数据库系统的细节。也就是说，相对于常见的 JDBC/SQL 持久层方案中需要管理 SQL 语句，Hibernate采用了更自然的面向对象的视角来持久化 Java 应用中的数据。换句话说，使用 Hibernate 的开发者应该总是关注对象的状态（state），不必考虑 SQL 语句的执行。这部分细节已经由 Hibernate 掌管妥当，只有开发者在进行系统性能调优的时候才需要进行了解。而MyBatis在这一块没有文档说明，用户需要对对象自己进行详细的管理。抓取策略Hibernate对实体关联对象的抓取有着良好的机制。对于每一个关联关系都可以详细地设置是否延迟加载，并且提供关联抓取、查询抓取、子查询抓取、批量抓取四种模式。 它是详细配置和处理的。而Mybatis的延迟加载是全局配置的。第五章 缓存机制对比Hibernate缓存Hibernate一级缓存是Session缓存，利用好一级缓存就需要对Session的生命周期进行管理好。建议在一个Action操作中使用一个Session。一级缓存需要对Session进行严格管理。Hibernate二级缓存是SessionFactory级的缓存。 SessionFactory的缓存分为内置缓存和外置缓存。内置缓存中存放的是SessionFactory对象的一些集合属性包含的数据(映射元素据及预定SQL语句等),对于应用程序来说,它是只读的。外置缓存中存放的是数据库数据的副本,其作用和一级缓存类似.二级缓存除了以内存作为存储介质外,还可以选用硬盘等外部存储设备。二级缓存称为进程级缓存或SessionFactory级缓存，它可以被所有session共享，它的生命周期伴随着SessionFactory的生命周期存在和消亡。MyBatis缓存MyBatis 包含一个非常强大的查询缓存特性,它可以非常方便地配置和定制。MyBatis 3 中的缓存实现的很多改进都已经实现了,使得它更加强大而且易于配置。默认情况下是没有开启缓存的,除了局部的 session 缓存,可以增强变现而且处理循环 依赖也是必须的。要开启二级缓存,你需要在你的 SQL 映射文件中添加一行: <cache/>字面上看就是这样。这个简单语句的效果如下:映射语句文件中的所有 select 语句将会被缓存。映射语句文件中的所有 insert,update 和 delete 语句会刷新缓存。缓存会使用 Least Recently Used(LRU,最近最少使用的)算法来收回。根据时间表(比如 no Flush Interval,没有刷新间隔), 缓存不会以任何时间顺序 来刷新。缓存会存储列表集合或对象(无论查询方法返回什么)的 1024 个引用。缓存会被视为是 read/write(可读/可写)的缓存,意味着对象检索不是共享的,而 且可以安全地被调用者修改,而不干扰其他调用者或线程所做的潜在修改。所有的这些属性都可以通过缓存元素的属性来修改。比如: <cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/>这个更高级的配置创建了一个 FIFO 缓存,并每隔 60 秒刷新,存数结果对象或列表的 512 个引用,而且返回的对象被认为是只读的,因此在不同线程中的调用者之间修改它们会 导致冲突。可用的收回策略有, 默认的是 LRU:LRU – 最近最少使用的:移除最长时间不被使用的对象。FIFO – 先进先出:按对象进入缓存的顺序来移除它们。SOFT – 软引用:移除基于垃圾回收器状态和软引用规则的对象。WEAK – 弱引用:更积极地移除基于垃圾收集器状态和弱引用规则的对象。flushInterval(刷新间隔)可以被设置为任意的正整数,而且它们代表一个合理的毫秒 形式的时间段。默认情况是不设置,也就是没有刷新间隔,缓存仅仅调用语句时刷新。size(引用数目)可以被设置为任意正整数,要记住你缓存的对象数目和你运行环境的 可用内存资源数目。默认值是1024。readOnly(只读)属性可以被设置为 true 或 false。只读的缓存会给所有调用者返回缓 存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。可读写的缓存 会返回缓存对象的拷贝(通过序列化) 。这会慢一些,但是安全,因此默认是 false。相同点Hibernate和Mybatis的二级缓存除了采用系统默认的缓存机制外，都可以通过实现你自己的缓存或为其他第三方缓存方案，创建适配器来完全覆盖缓存行为。不同点Hibernate的二级缓存配置在SessionFactory生成的配置文件中进行详细配置，然后再在具体的表-对象映射中配置是那种缓存。MyBatis的二级缓存配置都是在每个具体的表-对象映射中进行详细配置，这样针对不同的表可以自定义不同的缓存机制。并且Mybatis可以在命名空间中共享相同的缓存配置和实例，通过Cache-ref来实现。两者比较因为Hibernate对查询对象有着良好的管理机制，用户无需关心SQL。所以在使用二级缓存时如果出现脏数据，系统会报出错误并提示。而MyBatis在这一方面，使用二级缓存时需要特别小心。如果不能完全确定数据更新操作的波及范围，避免Cache的盲目使用。否则，脏数据的出现会给系统的正常运行带来很大的隐患。第六章 Hibernate与Mybatis对比总结两者相同点Hibernate与MyBatis都可以是通过SessionFactoryBuider由XML配置文件生成SessionFactory，然后由SessionFactory 生成Session，最后由Session来开启执行事务和SQL语句。其中SessionFactoryBuider，SessionFactory，Session的生命周期都是差不多的。Hibernate和MyBatis都支持JDBC和JTA事务处理。Mybatis优势MyBatis可以进行更为细致的SQL优化，可以减少查询字段。MyBatis容易掌握，而Hibernate门槛较高。Hibernate优势Hibernate的DAO层开发比MyBatis简单，Mybatis需要维护SQL和结果映射。Hibernate对对象的维护和缓存要比MyBatis好，对增删改查的对象的维护要方便。Hibernate数据库移植性很好，MyBatis的数据库移植性不好，不同的数据库需要写不同SQL。Hibernate有更好的二级缓存机制，可以使用第三方缓存。MyBatis本身提供的缓存机制不佳。他人总结Hibernate功能强大，数据库无关性好，O/R映射能力强，如果你对Hibernate相当精通，而且对Hibernate进行了适当的封装，那么你的项目整个持久层代码会相当简单，需要写的代码很少，开发速度很快，非常爽。 Hibernate的缺点就是学习门槛不低，要精通门槛更高，而且怎么设计O/R映射，在性能和对象模型之间如何权衡取得平衡，以及怎样用好Hibernate方面需要你的经验和能力都很强才行。 iBATIS入门简单，即学即用，提供了数据库查询的自动对象绑定功能，而且延续了很好的SQL使用经验，对于没有那么高的对象模型要求的项目来说，相当完美。 iBATIS的缺点就是框架还是比较简陋，功能尚有缺失，虽然简化了数据绑定代码，但是整个底层数据库查询实际还是要自己写的，工作量也比较大，而且不太容易适应快速数据库修改。

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

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语言不同而产生一直困难的问题。起到解耦的作用。

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

Hibernate 是一个开放源代码的对象关系映射框架，它对 JDBC 进行了轻量级的对象封装，使 Java 程序员可以随心所欲的使用对象编程思维来操纵数据库。它不仅提供了从 Java 类到数据表之间的映射，也提供了数据查询和恢复机制。相对于使用 JDBC 和 SQL 来手工操作数据库，Hibernate 可以大大减少操作数据库的工作量。 另外 Hibernate 可以利用代理模式来简化载入类的过程，这将大大减少利用 Hibernate QL 从数据库提取数据的代码的编写量，从而节约开发时间和开发成本 Hibernate 可以和多种Web 服务器或者应用服务器良好集成，如今已经支持几乎所有的流行的数据库服务器。

hibernate [hi·ber·nate || "hau026abu0259(r)neu026at]v. 过冬, 避寒, 冬眠hibernate也是一个JAVA语言的ORM框架。与Mybatis一样的是，编码复杂度都是O(n),也就是说每操作一个DB的表，就要写一次dao。一个十分钟即可学会的ORM框架--Bee , 编码复杂度是O(1). (想想数据结构中时间复杂度，空间从O(n)提升到O(1)对性能的影响有多大）。https://blog.csdn.net/abckingaa/article/details/81176524

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的JaveEE架构中取代CMP，完成数据持久化的重任。扩展资料：发展历程2004年，整个Java社区开始从实体bean向Hibernate转移，特别是在Rod Johnson的著作《Expert One-on-One J2EE Development without EJB》出版后，由于这本书以扎实的理论、充分的论据和详实的论述否定了EJB，提出了轻量级敏捷开发理念之后，以Hibernate和Spring为代表的轻量级开源框架开始成为Java世界的主流和事实标准。在2004年Sun领导的J2EE5.0标准制定当中的持久化框架标准正式以Hibernate为蓝本。2006年，J2EE5.0标准正式发布以后，持久化框架标准Java Persistent API（简称JPA）基本上是参考Hibernate实现的，而Hibernate在3.2版本开始，已经完全兼容JPA标准。参考资料来源：百度百科-开放源代码参考资料来源：百度百科-Hibernate

hibernate 英["hau026abu0259neu026at]美[u02c8hau026abu025au02ccnet]vi. （某些动物）冬眠，蛰伏第三人称单数:hibernates;过去分词:hibernated;现在分词:hibernati...[例句]To cope , many species have learned to hibernate.为了应对严寒，很多物种学会了冬眠。

一种工具好与不好，主要方面应该体现在是否实用，是否易用，好多人说hibernate怎么怎么好用，是，这个不能否定，毕竟hibernate都出了这么多年了，该优化的早优化了，但是，正如有人说的，hibernate慢，而且难优化，而且使用不好有问题，这就是他最大的垃圾地方，楼主可以想一想，hibernate提出的什么面向对象操作数据库，这本身就是一个谎言，oracle，db2这些主流数据库本省就是关系数据库，为什么非要用面向对象思维去考虑他，弄不好就容易让人思维错乱。不是谁没有那个思维，也不是谁不懂那个东西，二是学会hibernate，要想学好，跟另学一门语言的难度没什么区别，他只是一个工具，这么难，有意义吗？我以前没用过其他的orm框架，也觉着hibernate好，但是当你用过好的简单的、容易上手的框架，如ibatis，你就会发现hibernate就是绕弯子走路，脱裤子放屁，真没啥用~~

说说我们的选择吧原因有： 1. 我们是做平台的，客户要求多种多样，我们是需要支持多个数据库的，Hibernate可以比较容易屏蔽数据库的差异； 2. Hibernate采用面向对象的方式来写SQL，也就是HQL和Criteria,在数据库和Dao之间多了一层，数据库的改动可以通过映射关系屏蔽部分影响。 3. 因为我们是要不断的增加功能，偶然要做做系统重构，快速快发尤其重要，Hibernate的代码量和改动量都要比其他框架来的少，起码经过我们的封装已经使得用起来是很简单了。 4. 对于性能有影响的地方和很难用Hibernate表达的地方我们会采用JdbcTemplate，或者采用View封装一次再map到Hibernate，采用Hibernate也不排斥其他持久层框架的存在。 5. 尽量少用One to many, Many to one等功能，可能这里不太OO，但是代码明了,不容易出问题。 6. 我们暂时还没有遇到几千万的数据量那么大的客户，要做到那么大数据量的时候也可以从数据库，系统，网络各个方面来优化。系统推到重来也不是什么问题。 7.Hibernate的一级缓存对于长Transaction的业务复杂的代码反而有好处，见上面的某些分析。 8. 采用缓存和静态页面可以消除部分性能影响，或者采用数据库特有功能，不过取消Hibernate的二级缓存，采用Spring的缓存或者自己搞缓存。 9. 文档多，容易解决问题，也是JPA标准的重要参考。 Hibernate不好的地方： 1. 多占内存，因为他需要把domain对应的configuration都load到内存里面去，多用内存是正常的，但是出现OutofMemerey肯定不是Hibernate的问题了，一般应用内存还是够的。 2. 性能问题。Hibernate或者Ibatis也好，最终都是通过反射把ResultSet变为对应的Domain Object,跟了一下Hibernate的内部代码，好像是用Method.invoke来调用get 和set方法的，用了Cglib或者动态代理方式，这个方式肯定是要比直接调用get和set方法要慢的。在JDK不断优化的今天，这个差距应该会缩小。 但是Ibatais应该也是通过这个方式来做，没有看过不太肯定。Hibernate多了一个将HQL或者Domain Object转化为SQL的过程，这个过程也会消耗一些性能，例如字符串拼接，记录Domain Object的关系等。 经过以上分析，可能Hibernate会给我带来一定的性能损失，但是我可以通过其他办法来弥补，内存就更不是问题了。但是他确实带来了比较好的地方，因此我们会继续用Hibernate。 所以说Hibernate适合做企业级应用，对于那种内存和性能要求都很高或者本来就用Ibatis的情况，其实可以选择Ibatias或者JdbcTemplate的。就性能而言， JdbcTemplate > Ibatis < Hibernate 除了缓存的作用外只说DB操作，纯JDBC是最快的，因为那样没有任何负担，但是代码搞得很难看，你会这么选择吗？

　　Hibernate批量处理其实从性能上考虑 它是很不可取的 浪费了很大的内存 从它的机制上讲 Hibernate它是先把符合条件的数据查出来 放到内存当中 然后再进行操作 实际使用下来性能非常不理想 在笔者的实际使用中采用下面的第三种优化方案的数据是 条数据插入数据库 主流台式机的配置 需要约 分钟 呵呵 晕倒 　　总结下来有三种来处理以解决性能问题 　　 绕过Hibernate API 直接通过 JDBC API 来做 这个方法性能上是比较好的 也是最快的 　　 运用存储过程 　　 还是用Hibernate API 来进行常规的批量处理 可以也有变 变就变在 我们可以在查找出一定的量的时候 及时的将这些数据做完操作就 　　删掉 session flush（） session evict（XX对象集） 这样也可以挽救一点性能损失 这个 一定的量 要就要根据实际情况做定量参考了 一般为 左右 但效果仍然不理想 　　 绕过Hibernate API 直接通过 JDBC API 来做 这个方法性能上是比较好的 也是最快的 （实例为 更新操作） 　　Transaction tx=session beginTransaction（） //注意用的是hibernate事务处理边界 　　Connection conn=nnection（） 　　PreparedStatement stmt=conn preparedStatement（ update CUSTOMER as C set C sarlary=c sarlary+ where c sarlary> ） 　　stmt excuteUpdate（） 　　mit（） //注意用的是hibernate事务处理边界 　　这小程序中 采用的是直接调用JDBC 的API 来访问数据库 效率很高 避免了Hibernate 先查询出来加载到内存 再进行操作引发的性能问题 　　 　　 运用存储过程 但这种方式考虑到易植和程序部署的方便性 不建议使用 （实例为 更新操作） 　　如果底层数据库（如Oracle）支持存储过程 也可以通过存储过程来执行批量更新 存储过程直接在数据库中运行 速度更加快 在Oracle数 　　据库中可以定义一个名为batchUpdateCustomer（）的存储过程 代码如下 　　代码内容create or replace procedure batchUpdateCustomer（p_age in number） as begin update CUSTOMERS set AGE=AGE+ where AGE>p_age end 　　以上存储过程有一个参数p_age 代表客户的年龄 应用程序可按照以下方式调用存储过程 　　代码内容 　　tx = session beginTransaction（） 　　Connection con=nnection（） 　　String procedure = {call batchUpdateCustomer（？） } 　　CallableStatement cstmt = con prepareCall（procedure） 　　cstmt setInt（ ） //把年龄参数设为 　　cstmt executeUpdate（） 　　mit（） 　　从上面程序看出 应用程序也必须绕过Hibernate API 直接通过JDBC API来调用存储过程 　　 还是用Hibernate API 来进行常规的批量处理 可以也有变 变就变在 我们可以在查找出一定的量的时候 及时的将这些数据做完操作就 　　删掉 session flush（） session evict（XX对象集） 这样也可以挽救一点性能损失 这个 一定的量 要就要根据实际情况做定量参考了…… 　　（实例为 保存操作） 　　业务逻辑为 我们要想数据库插入 条数据 　　tx=session beginTransaction（） 　　for（int i= i< i++） 　　{ 　　Customer custom=new Customer（） 　　custom setName（ user +i） 　　session save（custom） 　　if（i% == ） // 以每 个数据作为一个处理单元 也就是我上面说的 一定的量 这个量是要酌情考虑的 　　{ 　　session flush（） 　　session clear（） 　　} 　　} 　　这样可以把系统维持在一个稳定的范围…… 　　在项目的开发过程之中 由于项目需求 我们常常需要把大批量的数据插入到数据库 数量级有万级 十万级 百万级 甚至千万级别的 如此数量级别的数据用Hibernate做插入操作 就可能会发生异常 常见的异常是OutOfMemoryError（内存溢出异常） 　　首先 我们简单来回顾一下Hibernate插入操作的机制 Hibernate要对它内部缓存进行维护 当我们执行插入操作时 就会把要操作的对象全部放到自身的内部缓存来进行管理 　　谈到Hibernate的缓存 Hibernate有内部缓存与二级缓存之说 由于Hibernate对这两种缓存有着不同的管理机制 对于二级缓存 我们可以对它的大小进行相关配置 而对于内部缓存 Hibernate就采取了 放任自流 的态度了 对它的容量并没有限制 现在症结找到了 我们做海量数据插入的时候 生成这么多的对象就会被纳入内部缓存（内部缓存是在内存中做缓存的） 这样你的系统内存就会一点一点的被蚕食 如果最后系统被挤 炸 了 也就在情理之中了 　　我们想想如何较好的处理这个问题呢？有的开发条件又必须使用Hibernate来处理 当然有的项目比较灵活 可以去寻求其他的方法 　　笔者在这里推荐两种方法 （ ） 优化Hibernate 程序上采用分段插入及时清除缓存的方法 　　（ ） 绕过Hibernate API 直接通过 JDBC API 来做批量插入 这个方法性能上是最 好的 也是最快的 　　对于上述中的方法 其基本是思路为 优化Hibernate 在配置文件中设置hibernate jdbc batch_size参数 来指定每次提交SQL的数量 程序上采用分段插入及时清除缓存的方法（Session实现了异步write behind 它允许Hibernate显式地写操作的批处理） 也就是每插入一定量的数据后及时的把它们从内部缓存中清除掉 释放占用的内存 　　设置hibernate jdbc batch_size参数 可参考如下配置 　　<hibernate configuration> <session factory>…… 　　<property name= hibernate jdbc batch_size > </property>…… 　　<session factory> <hibernate configuration> 　　配置hibernate jdbc batch_size参数的原因就是尽量少读数据库 hibernate jdbc batch_size参数值越大 读数据库的次数越少 速度越快 从上面的配置可以看出 Hibernate是等到程序积累到了 个SQL之后再批量提交 　　笔者也在想 hibernate jdbc batch_size参数值也可能不是设置得越大越好 从性能角度上讲还有待商榷 这要考虑实际情况 酌情设置 一般情形设置 就可以满足需求了 　　程序实现方面 笔者以插入 条数据为例子 如 　　Session session=HibernateUtil currentSession（） 　　Transatcion tx=session beginTransaction（） 　　for（int i= i< i++） 　　{ 　　Student st=new Student（） 　　st setName（ feifei ） 　　session save（st） 　　if（i% == ） //以每 个数据作为一个处理单元 　　{ 　　session flush（） //保持与数据库数据的同步 　　session clear（） //清除内部缓存的全部数据 及时释放出占用的内存 　　} 　　} 　　mit（） 　　…… 　　在一定的数据规模下 这种做法可以把系统内存资源维持在一个相对稳定的范围 　　注意 前面提到二级缓存 笔者在这里有必要再提一下 如果启用了二级缓存 从机制上讲Hibernate为了维护二级缓存 我们在做插入 更新 删除操作时 Hibernate都会往二级缓存充入相应的数据 性能上就会有很大损失 所以笔者建议在批处理情况下禁用二级缓存 　　对于方法 采用传统的JDBC的批处理 使用JDBC API来处理 　　些方法请参照java 批处理自执行SQL 　　看看上面的代码 是不是总觉得有不妥的地方？对 没发现么！这还是JDBC的传统编程 没有一点Hibernate味道 　　可以对以上的代码修改成下面这样 　　Transaction tx=session beginTransaction（） //使用Hibernate事务处理 　　边界Connection conn=nnection（） 　　PrepareStatement stmt=conn prepareStatement（ insert into T_STUDENT（name） values（？） ） 　　for（int j= j++ j< ）{ 　　for（int i= i++ j< ） 　　{ 　　stmt setString（ feifei ） 　　} 　　} 　　stmt executeUpdate（） 　　mit（） //使用 Hibernate事务处理边界 　　…… 　　这样改动就很有Hibernate的味道了 笔者经过测试 采用JDBC API来做批量处理 性能上比使用Hibernate API要高将近 倍 性能上JDBC 占优这是无疑的 　　 批量更新与删除 　　Hibernate 中 对于批量更新操作 Hibernate是将符合要求的数据查出来 然后再做更新操作 批量删除也是这样 先把符合条件的数据查出来 然后再做删除操作 　　这样有两个大缺点 （ ） 占用大量的内存 　　（ ） 处理海量数据的时候 执行update/delete语句就是海量了 而且一条update/delete语句只能操作一个对象 这样频繁的操作数据库 性能低下应该是可想而知的了 　　Hibernate 发布后 对批量更新/删除操作引入了bulk update/delete 其原理就是通过一条HQL语句完成批量更新/删除操作 很类似JDBC的批量更新/删除操作 在性能上 比Hibernate 的批量更新/删除有很大的提升 　　Transaction tx=session beginSession（） 　　String HQL= delete STUDENT 　　Query query=session createQuery（HQL） 　　int size=query executeUpdate（） 　　mit（） 　　…… 　　控制台输出了也就一条删除语句Hibernate delete from T_STUDENT 语句执行少了 性能上也与使用JDBC相差无几 是一个提升性能很好的方法 当然为了有更好的性能 笔者建议批量更新与删除操作还是使用JDBC 方法以及基本的知识点与上面的批量插入方法 基本相同 这里就不在冗述 　　笔者这里再提供一个方法 就是从数据库端来考虑提升性能 在Hibernate程序端调用存储过程 存储过程在数据库端运行 速度更快 以批量更新为例 给出参考代码 　　首先在数据库端建立名为batchUpdateStudent存储过程 　　create or replace produre batchUpdateStudent（a in number） as 　　begin 　　update STUDENT set AGE=AGE+ where AGE>a 　　end 　　调用代码如下 　　Transaction tx=session beginSession（） 　　Connection conn=nnection（） 　　String pd= ……{call batchUpdateStudent（？）} 　　CallableStatement cstmt=conn PrepareCall（pd） 　　cstmt setInt（ ） //把年龄这个参数设为 　　mit（） 　　观察上面的代码 也是绕过Hibernate API 使用 JDBC API来调用存储过程 使用的还是Hibernate的事务边界 存储过程无疑是提高批量处理性能的一个好方法 直接运行与数据库端 某种程度上讲把批处理的压力转接给了数据库 　　 三 编后语 　　本文探讨了Hibernate的批处理操作 出发点都是在提高性能上考虑了 也只是提供了提升性能的一个小方面 lishixinzhi/Article/program/Java/ky/201311/28885

　　一 批量修改和删除 　　在Hibernate 中 如果需要对任何数据进行修改和删除操作 都需要先执行查询操作 在得到要修改或者删除的数据后 再对该数据进行相应的操作处理 在数据量少的情况下采用这种处理方式没有问题 但需要处理大量数据的时候就可能存在以下的问题 　　占用大量的内存 　　需要多次执行update/delete语句 而每次执行只能处理一条数据 　　以上两个问题的出现会严重影响系统的性能 因此 在Hibernate 中引入了用于批量更新或者删除数据的HQL语句 这样 开发人员就可以一次更新或者删除多条记录 而不用每次都一个一个地修改或者删除记录了 　　如果要删除所有的User对象(也就是User对象所对应表中的记录) 则可以直接使用下面的HQL语句 　　delete User 　　而在执行这个HQL语句时 需要调用Query对象的executeUpdate()方法 具体的实例如下所示 　　String HQL= delete User ; 　　Query query=session createQuery(HQL); 　　int size=query executeUpdate(); 　　采用这种方式进行数据的修改和删除时与直接使用JDBC的方式在性能上相差无几 是推荐使用的正确方法 　　如果不能采用HQL语句进行大量数据的修改 也就是说只能使用取出再修改的方式时 也会遇到批量插入时的内存溢出问题 所以也要采用上面所提供的处理方法来进行类似的处理 　　二 使用SQL执行批量操作 　　在进行批量插入 修改和删除操作时 直接使用JDBC来执行原生态的SQL语句无疑会获得最佳的性能 这是因为在处理的过程中省略或者简化了以下处理内容 　　● HQL语句到SQL语句的转换 　　● Java对象的初始化 　　● Java对象的缓存处理 　　但是在直接使用JDBC执行SQL语句时 有一个最重要的问题就是要处理缓存中的Java对象 因为通过这种底层方式对数据的修改将不能通知缓存去进行相应的更新操作 以保证缓存中的对象与数据库中的数据是一致的 　　三 提升数据库查询的性能 　　数据库查询性能的提升也是涉及到开发中的各个阶段 在开发中选用正确的查询方法无疑是最基础也最简单的 　　 SQL语句的优化 　　使用正确的SQL语句可以在很大程度上提高系统的查询性能 获得同样数据而采用不同方式的SQL语句在性能上的差距可能是十分巨大的 　　由于Hibernate是对JDBC的封装 SQL语句的产生都是动态由Hibernate自动完成的 Hibernate产生SQL语句的方式有两种 一种是通过开发人员编写的HQL语句来生成 另一种是依据开发人员对关联对象的访问来自动生成相应的SQL语句 　　至于使用什么样的SQL语句可以获得更好的性能要依据数据库的结构以及所要获取数据的具体情况来进行处理 在确定了所要执行的SQL语句后 可以通过以下三个方面来影响Hibernate所生成的SQL语句 　　HQL语句的书写方法 　　查询时所使用的查询方法 　　对象关联时所使用的抓取策略 　　 使用正确的查询方法 　　在前面已经介绍过 执行数据查询功能的基本方法有两种 一种是得到单个持久化对象的get()方法和load()方法 另一种是Query对象的list()方法和iterator()方法 在开发中应该依据不同的情况选用正确的方法 　　get()方法和load()方法的区别在于对二级缓存的使用上 load()方法会使用二级缓存 而get()方法在一级缓存没有找到的情况下会直接查询数据库 不会去二级缓存中查找 在使用中 对使用了二级缓存的对象进行查询时最好使用load()方法 以充分利用二级缓存来提高检索的效率 　　list()方法和iterator()方法之间的区别可以从以下几个方面来进行比较 　　执行的查询不同 　　list()方法在执行时 是直接运行查询结果所需要的查询语句 而iterator()方法则是先执行得到对象ID的查询 然后再根据每个ID值去取得所要查询的对象 因此 对于list()方式的查询通常只会执行一个SQL语句 而对于iterator()方法的查询则可能需要执行N+ 条SQL语句(N为结果集中的记录数) 　　iterator()方法只是可能执行N+ 条数据 具体执行SQL语句的数量取决于缓存的情况以及对结果集的访问情况 　　缓存的使用 　　list()方法只能使用二级缓存中的查询缓存 而无法使用二级缓存对单个对象的缓存(但是会把查询出的对象放入二级缓存中) 所以 除非重复执行相同的查询操作 否则无法利用缓存的机制来提高查询的效率 　　iterator()方法则可以充分利用二级缓存 在根据ID检索对象的时候会首先到缓存中查找 只有在找不到的情况下才会执行相应的查询语句 所以 缓存中对象的存在与否会影响到SQL语句的执行数量 　　对于结果集的处理方法不同 　　list()方法会一次获得所有的结果集对象 而且它会依据查询的结果初始化所有的结果集对象 这在结果集非常大的时候必然会占据非常多的内存 甚至会造成内存溢出情况的发生 　　iterator()方法在执行时不会一次初始化所有的对象 而是根据对结果集的访问情况来初始化对象 因此在访问中可以控制缓存中对象的数量 以避免占用过多缓存 导致内存溢出情况的发生 使用iterator()方法的另外一个好处是 如果只需要结果集中的部分记录 那么没有被用到的结果对象根本不会被初始化 所以 对结果集的访问情况也是调用iterator()方法时执行数据库SQL语句多少的一个因素 　　所以 在使用Query对象执行数据查询时应该从以上几个方面去考虑使用何种方法来执行数据库的查询操作 　　四 使用正确的抓取策略 　　所谓抓取策略(fetching strategy)是指当应用程序需要利用关联关系进行对象获取的时候 Hibernate获取关联对象的策略 抓取策略可以在O/R映射的元数据中声明 也可以在特定的HQL或条件查询中声明 　　Hibernate 定义了以下几种抓取策略 　　连接抓取(Join fetching) 　　连接抓取是指Hibernate在获得关联对象时会在SELECT语句中使用外连接的方式来获得关联对象 　　查询抓取(Select fetching) 　　查询抓取是指Hibernate通过另外一条SELECT语句来抓取当前对象的关联对象的方式 这也是通过外键的方式来执行数据库的查询 与连接抓取的区别在于 通常情况下这个SELECT语句不是立即执行的 而是在访问到关联对象的时候才会执行 　　子查询抓取(Subselect fetching) 　　子查询抓取也是指Hibernate通过另外一条SELECT语句来抓取当前对象的关联对象的方式 与查询抓取的区别在于它所采用的SELECT语句的方式为子查询 而不是通过外连接 　　批量抓取(Batch fetching) 　　批量抓取是对查询抓取的优化 它会依据主键或者外键的列表来通过单条SELECT语句实现管理对象的批量抓取 　　以上介绍的是Hibernate 所提供的抓取策略 也就是抓取关联对象的手段 为了提升系统的性能 在抓取关联对象的时机上 还有以下一些选择 　　立即抓取(Immediate fetching) 　　立即抓取是指宿主对象被加载时 它所关联的对象也会被立即加载 　　延迟集合抓取(Lazy collection fetching) 　　延迟集合抓取是指在加载宿主对象时 并不立即加载它所关联的对象 而是到应用程序访问关联对象的时候才抓取关联对象 这是集合关联对象的默认行为 　　延迟代理抓取(Lazy proxy fetching) 　　延迟代理抓取是指在返回单值关联对象的情况下 并不在对其进行get操作时抓取 而是直到调用其某个方法的时候才会抓取这个对象 　　延迟属性加载(Lazy attribute fetching) 　　延迟属性加载是指在关联对象被访问的时候才进行关联对象的抓取 　　介绍了Hibernate所提供的关联对象的抓取方法和抓取时机 这两个方面的因素都会影响Hibernate的抓取行为 最重要的是要清楚这两方面的影响是不同的 不要将这两个因素混淆 在开发中要结合实际情况选用正确的抓取策略和合适的抓取时机 　　抓取时机的选择 　　在Hibernate 中 对于集合类型的关联在默认情况下会使用延迟集合加载的抓取时机 而对于返回单值类型的关联在默认情况下会使用延迟代理抓取的抓取时机 　　对于立即抓取在开发中很少被用到 因为这很可能会造成不必要的数据库操作 从而影响系统的性能 当宿主对象和关联对象总是被同时访问的时候才有可能会用到这种抓取时机 另外 使用立即连接抓取可以通过外连接来减少查询SQL语句的数量 所以 也会在某些特殊的情况下使用 　　然而 延迟加载又会面临另外一个问题 如果在Session关闭前关联对象没有被实例化 那么在访问关联对象的时候就会抛出异常 处理的方法就是在事务提交之前就完成对关联对象的访问 　　所以 在通常情况下都会使用延迟的方式来抓取关联的对象 因为每个立即抓取都会导致关联对象的立即实例化 太多的立即抓取关联会导致大量的对象被实例化 从而占用过多的内存资源 　　抓取策略的选取 　　对于抓取策略的选取将影响到抓取关联对象的方式 也就是抓取关联对象时所执行的SQL语句 这就要根据实际的业务需求 数据的数量以及数据库的结构来进行选择了 　　在这里需要注意的是 通常情况下都会在执行查询的时候针对每个查询来指定对其合适的抓取策略 指定抓取策略的方法如下所示 　　User user = (User) session createCriteria(User class) 　　 setFetchMode( permissions FetchMode JOIN) 　　 add( Restrictions idEq(userId) ) 　　 uniqueResult(); 　　五 查询性能提升小结 　　在本小节中介绍了查询性能提升的方法 关键是如何通过优化SQL语句来提升系统的查询性能 查询方法和抓取策略的影响也是通过执行查询方式和SQL语句的多少来改变系统的性能的 这些都属于开发人员所应该掌握的基本技能 避免由于开发不当而导致系统性能的低下 　　在性能调整中 除了前面介绍的执行SQL语句的因素外 对于缓存的使用也会影响系统的性能 通常来说 缓存的使用会增加系统查询的性能 而降低系统增加 修改和删除操作的性能(因为要进行缓存的同步处理) 所以 开发人员应该能够正确地使用有效的缓存来提高数据查询的性能 而要避免滥用缓存而导致的系统性能变低 在采用缓存的时候也应该注意调整自己的检索策略和查询方法 这三者配合起来才可以达到最优的性能 lishixinzhi/Article/program/Java/ky/201311/28720

简单地说就是通过让你调用一些它提供的方法操作来得知你想干什么，然后把你的操作翻译成sql语言去帮你操作数据库

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）