kylinsoong
- 浏览: 235848 次
- 性别:
- 来自: 北京
-
文章分类
最新评论
-
akka_li：
学习了！但是为什么后续的没有了？！
EJB4：RMI和RMI-IIOP -
springaop_springmvc：
apache lucene开源框架demo使用实例教程源代码下 ...
Lucene学习笔记（一）Lucene入门实例 -
qepipnu：
求solr 客户端 jar包
Solr学习笔记（三）Solr客户端开发实例 -
zhangbc：
是这问题，赞！
Oracle Start Up 2 Oracle 框架构件、启动、解决一个问题 -
feilian09：
查询 select hibernate jdbc 那个效率快
Hibernate，JDBC性能探讨
今天原打算研究一下Hibernate 1+N问题，却发现了一个Really Amazing的效率问题，问题如下，希望大牛可以解释一下：
1、简单描述一下测试中表结构（我用Mysql数据库），表结构如下图
表名为Corporation，三个字段id、name、type，对应Mysql中表结构截图：
2、如下代码，简单调运JDBC测试插入10000条数据花费时间
public class DB {
public static Connection getConn() {
Connection conn = null;
try {
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/hibernate?user=root&password=root");
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
return conn;
}
public static Statement getStmt(Connection conn) {
Statement stmt = null;
try {
if(conn != null) {
stmt = conn.createStatement();
}
} catch (SQLException e) {
e.printStackTrace();
}
return stmt;
}
public static void main(String[] args) throws SQLException {
Statement stmt = getStmt(getConn());
Date start = new Date();
for(int i = 0 ; i < 10000 ; i ++) {
String sql = "insert into corporation(name,type) value('Tibco','IT')";
stmt.executeUpdate(sql);
}
System.out.println("Total spent " + (new Date().getTime() - start.getTime()));
}
}
运行时间如下
Total spent 249531
这个时间我觉得是比较合理的执行一条SQL花费25毫秒左右，之前有关效率方面的测试和这个结果差不多
3. 下面给出Hibernate中测试时间的代码，先给出Hibernate配置代码
3.1 Corporation对应的Annotation配置类
@Entity
public class Corporation {
private int id;
private String name;
private String type;
@Id
@GeneratedValue
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
}
3.2 hibernate.cfg.xml配置信息
<hibernate-configuration>
<session-factory>
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="connection.url">jdbc:mysql://localhost/hibernate</property>
<property name="connection.username">root</property>
<property name="connection.password">root</property>
<property name="connection.pool_size">1</property>
<property name="current_session_context_class">thread</property>
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
<property name="show_sql">true</property>
<property name="format_sql">true</property>
<property name="hbm2ddl.auto">update</property>
<mapping class="com.kylin.test.Corporation"/>
</session-factory>
</hibernate-configuration>
3.3给出测试代码
package com.kylin.test;
import java.util.Date;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
public class AllTest {
private static SessionFactory sessionFactory;
@BeforeClass
public static void beforeClass(){
sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();
}
@AfterClass
public static void afterClass() {
sessionFactory.close();
}
@Test
public void testExportTable() {
new SchemaExport(new AnnotationConfiguration().configure()).create(true, true);
}
@Test
public void saveCorporation() {
Date start = new Date();
Session session = sessionFactory.getCurrentSession();
session.beginTransaction();
for(int i = 0 ; i < 10000 ; i ++) {
Corporation c = new Corporation();
c.setName("Tibco");
c.setType("IT");
session.save(c);
}
session.getTransaction().commit();
System.out.println("Total spent " + (new Date().getTime() - start.getTime()));
}
}
如上saveCorporation()方法就是Hibernate想数据库中插入10000条数据的部分，这个结果确实令我吃惊，如下
Total spent 8781
我测试了多次这个时间都是8700毫秒左右，所以这个时间应该准确。
249531 / 8781 = 28.41，28倍，的确是28倍
4、分析一下
之前比较过Cassandra（分布式数据库）与Mysql的存储效率差别时发现关系数据库存储的SQL操作效率相当低，而Hibernate解决的是可以面向对象的操作关系数据库，所以我个人一直以为，Hibernate操作数据库的效率一定更低，但结果却恰恰相反，而且与我的之前的理解相差很大，所以我可以肯定的是Hibernate在数据操作效率上也有一定的技巧，大家谁知道可以说说。
PS。。本来还想再分析分析，但是周末了，不想再多呆在公司……
分享到：
评论
39 楼
feilian09
2014-03-20
查询 select hibernate jdbc 那个效率快
38 楼
yhailj
2010-08-21
为这个问题自己也一直挺郁闷的, 出现这种问题只能怪自己 jdbc 没有写好!
有 jdbc 方面经验的帮忙看下我这个 blog:
http://yhailj.iteye.com/admin/blogs/619890
有 jdbc 方面经验的帮忙看下我这个 blog:
http://yhailj.iteye.com/admin/blogs/619890
37 楼
wenshao
2010-08-21
完全不可理喻的对比，单个插入和批量插入的对比。
就如同，堵车的时候，我走路比汽车快。
这个案例有意义么？
要不是无聊，要不就是无耻
就如同，堵车的时候，我走路比汽车快。
这个案例有意义么？
要不是无聊，要不就是无耻
36 楼
JE帐号
2010-08-21
pujia12345 写道
现在鼠辈横行啊！
殊不知： Hibernate也是封装的JDBC。就像Windows和DOS操作系统的关系。
现在只知SSH不知Java\Servlet的太多了
殊不知： Hibernate也是封装的JDBC。就像Windows和DOS操作系统的关系。
现在只知SSH不知Java\Servlet的太多了
... ...
可能你说的是Win3.x 吧...
35 楼
freish
2010-08-21
hibernate底层还是jdbc
你这jdbc代码写的太没效率了
你这jdbc代码写的太没效率了
34 楼
carlkkx
2010-08-21
就像Windows和DOS操作系统的关系。
_______________________
晕倒，Windows和Dos是这种关系？
_______________________
晕倒，Windows和Dos是这种关系？
33 楼
beeke
2010-08-21
你们真是闲得蛋疼啊(我也是)
hibernate内部也是执行JDBC
就好像汽车对车轮说：我跑得比你快
真无聊啊...
hibernate内部也是执行JDBC
就好像汽车对车轮说：我跑得比你快
真无聊啊...
32 楼
pujia12345
2010-08-21
现在鼠辈横行啊！
殊不知： Hibernate也是封装的JDBC。就像Windows和DOS操作系统的关系。
现在只知SSH不知Java\Servlet的太多了
殊不知： Hibernate也是封装的JDBC。就像Windows和DOS操作系统的关系。
现在只知SSH不知Java\Servlet的太多了
31 楼
peterwei
2010-08-21
今天闲得蛋疼，新自试了一遍。哈哈
不知你在什么配置情况下操作。因为结果是4分多钟。对于此结论很是惊奇，因为以前做过数据同步的东西，于是马上亲自验证，数据库和测试参数和你的都一样。
先说结果：我的测试最慢的只用了2.6秒。Statement最慢，PrepareStaement快了5秒钟，Batch和PrepareStatement并没有实质性的提高，只是一小点(这个倒是让我奇怪)。从一万到十万数据量都做过测试，但变化不大。我一直认为Batch会提高不少数量级的，可是结果让我失望，也不知哪写得不对，大家可以评点一下代码。
直接pringln 10000的一些对比数据：
清空表
普通的Statement插入数据:
插入数据量：10000
<运行时间: 2.656 秒>
运行时间：2656 毫秒
2.656
================================
清空表
通过PrepareStatement插入数据:
插入数据量：10000
<运行时间: 2.156 秒>
运行时间：2156 毫秒
2.156
================================
清空表
用批处理插入数据:
批量更新成功 10000 条记录!
<运行时间: 2.078 秒>
运行时间：2078 毫秒
2.078
================================
代码如下：
Java代码
不知你在什么配置情况下操作。因为结果是4分多钟。对于此结论很是惊奇，因为以前做过数据同步的东西，于是马上亲自验证，数据库和测试参数和你的都一样。
先说结果：我的测试最慢的只用了2.6秒。Statement最慢，PrepareStaement快了5秒钟，Batch和PrepareStatement并没有实质性的提高，只是一小点(这个倒是让我奇怪)。从一万到十万数据量都做过测试，但变化不大。我一直认为Batch会提高不少数量级的，可是结果让我失望，也不知哪写得不对，大家可以评点一下代码。
直接pringln 10000的一些对比数据：
清空表
普通的Statement插入数据:
插入数据量：10000
<运行时间: 2.656 秒>
运行时间：2656 毫秒
2.656
================================
清空表
通过PrepareStatement插入数据:
插入数据量：10000
<运行时间: 2.156 秒>
运行时间：2156 毫秒
2.156
================================
清空表
用批处理插入数据:
批量更新成功 10000 条记录!
<运行时间: 2.078 秒>
运行时间：2078 毫秒
2.078
================================
代码如下：
Java代码
package test;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;
import com.fastbo.util.Clock;
import com.fastbo.util.ConnectionFactory;
import com.fastbo.util.DbUtil;
/**
* Description: Jdbc相关性能测试,batch处理，PrepareStatement，Statement等。
*
* <p>
* Mysql数据库：表结构为简单的id,name(varchar:255),type(varchar:255)字段，id自增
* </p>
*
* @author Peter Wei Email: <a href="mailto:weigbo@163.com">weigbo@163.com </a>
*
* @version 1.0 2010-8-21
*/
public class JdbcTest {
/**
* 测试数据量
*/
public static int TEST_NUM = 10000;
/**
* 批处理大小
*/
public static int BATCH_SIZE = 300;
/**
* 清空数据表
*
* @param con
*/
public static void clear(Connection con) {
PreparedStatement ps = null;
StringBuffer buff = new StringBuffer();
try {
buff.append("truncate table bobo");
ps = con.prepareStatement(buff.toString());
ps.executeUpdate();
System.out.println("清空表");
} catch (SQLException e) {
e.printStackTrace();
} finally {
DbUtil.close(ps);
}
}
/**
* 普通的Statement插入数据
*
* @param con
*/
public static int add(Connection con) {
Statement stmt = null;
int num = 0;
String sql = "insert into bobo(name,type) values('Peter Wei','test')";
try {
stmt = con.createStatement();
for (int i = 0; i < TEST_NUM; i++) {
num += stmt.executeUpdate(sql);
}
System.out.println("插入数据量：" + num);
} catch (SQLException e) {
e.printStackTrace();
} finally {
DbUtil.close(stmt);
}
return num;
}
/**
* 用PrepareStatement插入数据
*
* @param con
*/
public static void addByPrepareStatement(Connection con) {
PreparedStatement ps = null;
StringBuffer buff = new StringBuffer();
int num = 0;
try {
buff.append("insert into bobo(name,type)");
buff.append(" values(?,?)");
ps = con.prepareStatement(buff.toString());
for (int i = 0; i < TEST_NUM; i++) {
int index = 1;
ps.setString(index++, "Peter Wei");
ps.setString(index++, "test");
num += ps.executeUpdate();
}
System.out.println("插入数据量：" + num);
} catch (SQLException e) {
e.printStackTrace();
} finally {
DbUtil.close(ps);
}
}
/**
* 用批处理插入数据
*
* @param con
*/
public static void addByBatch(Connection con) {
PreparedStatement ps = null;
StringBuffer buff = new StringBuffer();
int sum = 0;
int[] num = null;
try {
buff.append("insert into bobo(name,type) values(?,?)");
con.setAutoCommit(false);
ps = con.prepareStatement(buff.toString());
for (int i = 0; i < TEST_NUM; i++) {
int index = 1;
ps.setString(index++, "Peter Wei");
ps.setString(index++, "test");
ps.addBatch();
if (i != 0 && i % BATCH_SIZE == 0) {
num = ps.executeBatch();
sum += num.length;
con.commit();
// System.out.println("batch:" + i);
}
}
num = ps.executeBatch();
sum += num.length;
con.commit();
con.setAutoCommit(true);
System.out.println("批量更新成功 " + sum + " 条记录!");
} catch (SQLException e) {
e.printStackTrace();
} finally {
DbUtil.close(ps);
}
}
public static void main(String[] args) {
Connection con = ConnectionFactory.getConnection();
clear(con);
Clock c = new Clock();
// 普通的Statement插入数据
System.out.println("普通的Statement插入数据:");
c.start();
add(con);
c.stop();
System.out.println(c.toString());
c.readMilli();
System.out.println(c.read());
System.out.println("================================");
clear(con);
// 通过PrepareStatement插入数据
System.out.println("通过PrepareStatement插入数据:");
c = new Clock();
c.start();
addByPrepareStatement(con);
c.stop();
System.out.println(c.toString());
c.readMilli();
System.out.println(c.read());
System.out.println("================================");
clear(con);
// 用批处理插入数据
System.out.println("用批处理插入数据:");
c = new Clock();
c.start();
addByBatch(con);
c.stop();
System.out.println(c.toString());
c.readMilli();
System.out.println(c.read());
System.out.println("================================");
}
}
30 楼
niuniuliu
2010-08-21
你的jDBC肯定是自动提交事务了
可能每插入一条就提交一次
而hibernate只执行了一次提交
可能每插入一条就提交一次
而hibernate只执行了一次提交
29 楼
kylinsoong
2010-08-21
笑我痴狂 写道
首先得说jdbc肯定比hibernate快
这里楼主的程序写的不好，如果把jdbc改成batch提交 我想时间应该就很短了
现在来具体分析下：
jdbc测试：
没insert一条记录 就跟数据库打交道一次 ，这里一共连接了1000次数据库 光是连接数据库的时间就已经很长了
hibernate测试：
在这个过程中session保存对象时 ，是放在了session中 ，此时还没有真正的持久化到数据库，
在最后执行commit的时候，才真正的持久化到数据库 ，所以这1000个对象在同一时候被持久化到数据库中
在效率上来说 可想而知了
简单的说就是一桶水 ，执行jdbc的时候，每一次取一小瓢放到缸里
hibernate执行时，直接把一桶水倒到缸里 ，这样的测试当然是hibernate快了
小弟不才 哈哈哈哈哈哈哈哈哈
这里楼主的程序写的不好，如果把jdbc改成batch提交 我想时间应该就很短了
现在来具体分析下：
jdbc测试：
没insert一条记录 就跟数据库打交道一次 ，这里一共连接了1000次数据库 光是连接数据库的时间就已经很长了
hibernate测试：
for（int i=0；i<1000；i++）｛
。。。。
session.save（） ；
｝
在这个过程中session保存对象时 ，是放在了session中 ，此时还没有真正的持久化到数据库，
在最后执行commit的时候，才真正的持久化到数据库 ，所以这1000个对象在同一时候被持久化到数据库中
在效率上来说 可想而知了
简单的说就是一桶水 ，执行jdbc的时候，每一次取一小瓢放到缸里
hibernate执行时，直接把一桶水倒到缸里 ，这样的测试当然是hibernate快了
小弟不才 哈哈哈哈哈哈哈哈哈
这个解释相当详细，学习了，我知道昨天的错误出在哪儿了
28 楼
kylinsoong
2010-08-21
sswh 写道
chrislee1982 写道
JDBC绝对比hibernate快，毋庸置疑！
zhuyan_zy 写道
此贴体现了框架存在的意义之一
这个例子恰恰说明，hibernate一定比蹩脚程序员写的JDBC代码快！！
大家批评让我觉得相当惭愧，刚毕业没有什么经验，闹了个大笑话，大家就当娱乐一下，问题正如这位大哥所讲是JDBC代码写的有问题，修给一下
public static void main(String[] args) throws SQLException {
Connection conn = getConn();
conn.setAutoCommit(false);
Date start = new Date();
String sql = "insert into corporation(name,type) value(?,?)";
PreparedStatement prest = conn.prepareStatement(sql);
for(int x = 0; x < 10000; x++){
prest.setString(1, "Tibco");
prest.setString(2, "IT");
prest.addBatch();
}
prest.executeBatch();
conn.commit();
conn.setAutoCommit(true);
System.out.println("Total spent " + (new Date().getTime() - start.getTime()));
}
这样运行结果是1600毫秒左右，相比较Hibernate的8700毫秒，JDBC还是快的多。
27 楼
sswh
2010-08-21
chrislee1982 写道
JDBC绝对比hibernate快，毋庸置疑！
zhuyan_zy 写道
此贴体现了框架存在的意义之一
这个例子恰恰说明，hibernate一定比蹩脚程序员写的JDBC代码快！！
26 楼
redish
2010-08-21
感觉楼主还是做个公平的测试，个人觉得你没能比Hibernate更好的应用JDBC才是关键。
25 楼
yangyw
2010-08-21
kimmking 写道
3923075 写道
lz 你看看 你写的代码
1.for 循环有80%的时间都在 IO上..真正执行你sql 的时间很短
2.我们都知道 尽量不要再循环中新建类.
改成这样 试试
for(int i = 0 ; i < 10000 ; i ++) {
String sql = "insert into corporation(name,type) value('Tibco','IT')";
stmt.executeUpdate(sql);
}
1.for 循环有80%的时间都在 IO上..真正执行你sql 的时间很短
2.我们都知道 尽量不要再循环中新建类.
改成这样 试试
Statement stmt = conn.createStatement();
StringBuffer sb=new StringBuffer();
for(int i = 0 ; i < 10000 ; i ++)
{
sb.append("insert into corporation(name,type) value('Tibco','IT')");
}
stmt.addBatch(sb.toString());
stmt.executeBatch();
我估计这个超过mysql运行的最大长度了。
不太明白，为啥不用PreparedStatement的批量提交？
String sql = "insert into corporation(name,type) value(?,?)";
PreparedStatement prest = conn.prepareStatement(sql);
for(int x = 0; x < size; x++){
prest.setString(1, "Tibco");
prest.setString(2, "IT");
prest.addBatch();
}
prest.executeBatch();
24 楼
kimmking
2010-08-21
3923075 写道
lz 你看看 你写的代码
1.for 循环有80%的时间都在 IO上..真正执行你sql 的时间很短
2.我们都知道 尽量不要再循环中新建类.
改成这样 试试
for(int i = 0 ; i < 10000 ; i ++) {
String sql = "insert into corporation(name,type) value('Tibco','IT')";
stmt.executeUpdate(sql);
}
1.for 循环有80%的时间都在 IO上..真正执行你sql 的时间很短
2.我们都知道 尽量不要再循环中新建类.
改成这样 试试
Statement stmt = conn.createStatement();
StringBuffer sb=new StringBuffer();
for(int i = 0 ; i < 10000 ; i ++)
{
sb.append("insert into corporation(name,type) value('Tibco','IT')");
}
stmt.addBatch(sb.toString());
stmt.executeBatch();
我估计这个超过mysql运行的最大长度了。
23 楼
3923075
2010-08-21
lz 你看看 你写的代码
1.for 循环有80%的时间都在 IO上..真正执行你sql 的时间很短
2.我们都知道 尽量不要再循环中新建类.
改成这样 试试
for(int i = 0 ; i < 10000 ; i ++) {
String sql = "insert into corporation(name,type) value('Tibco','IT')";
stmt.executeUpdate(sql);
}
1.for 循环有80%的时间都在 IO上..真正执行你sql 的时间很短
2.我们都知道 尽量不要再循环中新建类.
改成这样 试试
Statement stmt = conn.createStatement();
StringBuffer sb=new StringBuffer();
for(int i = 0 ; i < 10000 ; i ++)
{
sb.append("insert into corporation(name,type) value('Tibco','IT')");
}
stmt.addBatch(sb.toString());
stmt.executeBatch();
22 楼
treblesoftware
2010-08-21
JDBC架构的系统，1台服务器
HIBERNATE架构的系统，4台服务器。
看看哪个快哦~
HIBERNATE架构的系统，4台服务器。
看看哪个快哦~
21 楼
田智伟
2010-08-21
个人的看法还是在
for(int i = 0 ; i < 10000 ; i ++) {
String sql = "insert into corporation(name,type) value('Tibco','IT')";
stmt.executeUpdate(sql);
}
与hibernate的transction提交的问题上！如果在hibernate的for循环中将session的开启和关闭以及事务的开启提交全部放入其中，我想他们两个的效率比较就比较公平了！说到底，还是写代码的问题！
for(int i = 0 ; i < 10000 ; i ++) {
String sql = "insert into corporation(name,type) value('Tibco','IT')";
stmt.executeUpdate(sql);
}
与hibernate的transction提交的问题上！如果在hibernate的for循环中将session的开启和关闭以及事务的开启提交全部放入其中，我想他们两个的效率比较就比较公平了！说到底，还是写代码的问题！
20 楼
田智伟
2010-08-21
个人的看法还是在
for(int i = 0 ; i < 10000 ; i ++) {
String sql = "insert into corporation(name,type) value('Tibco','IT')";
stmt.executeUpdate(sql);
}
与hibernate的transction提交的问题上！如果在hibernate的for循环中将session的开启和关闭以及事务的开启提交全部放入其中，我想他们两个的效率比较就比较公平了！说到底，还是写代码的问题！
for(int i = 0 ; i < 10000 ; i ++) {
String sql = "insert into corporation(name,type) value('Tibco','IT')";
stmt.executeUpdate(sql);
}
与hibernate的transction提交的问题上！如果在hibernate的for循环中将session的开启和关闭以及事务的开启提交全部放入其中，我想他们两个的效率比较就比较公平了！说到底，还是写代码的问题！
发表评论
-
Oracle - Add Exist Validation Before Create Table
2011-11-07 13:49 1399Usually we need to check the ta ... -
JMX Architecture & "Hello Word" the JMX way
2011-10-25 20:07 1744JMX Architecture Overview: JMX ... -
Jboss-eap-5.1 Messaging
2011-08-02 21:50 2391This section I will concertate ... -
Jboss-eap-5.1 starting up note
2011-07-26 22:46 2539Jboss enterprise platform 5 hav ... -
EJB Security & JAAS Demo
2011-05-21 19:39 1571PROLOGUE: When deploying ... -
JBoss LoginInitialContext Factory Implementation
2011-05-15 16:05 1464Jboss has a series of imp ... -
Jboss Reference Exception Gallery
2011-04-27 14:08 28451. Unable to locate a login con ... -
Hibernate Annotation 的一个问题，给点意见
2011-03-10 12:43 22问题：org.hibernate.annotations. ... -
大家说说BBC的网站用的是什么技术做的
2011-02-22 05:01 1390最近在英国出差，发现这里的一些网站做的相当有特色，有些网站不是 ... -
Hibernate OneToMany 单向和双向配置对数据存取性能的比较
2011-02-08 17:06 22401. 开篇说明：今天是春 ... -
对Hibernate属性（CascadeType、JoinColumn、JoinTable、ForeignKey等）的研究
2010-12-26 15:45 16601本文列出几个“EJB 学习阶段总结：JBoss下发布一个Toy ... -
EJB 学习阶段总结：JBoss下发布一个Toy企业应用
2010-12-25 12:11 2545解释题目：为什 ... -
EJB7: Message Driven Bean
2010-12-21 22:42 2092在企业系统中需要使用 ... -
EJB6: EntityBean例子
2010-11-26 14:48 1438本例子描述向EJB容器（JBoss）部署http: ... -
JPA dev: 几个问题总结（续）
2010-11-25 18:02 23972. 如何由PoJo类生成数据库中的表 首先可以根据实体间关 ... -
JPA dev: 几个问题总结
2010-11-25 16:56 3349最近工作中遇到几个与JPA相关的问题，本文通过一个例子总结一下 ... -
JAXB学习
2010-11-24 22:35 01 什么是JAXB？ JAXB全称Java Ar ... -
EJB5: JPA扩展-J2SE环境下使用EntityManager
2010-11-10 19:07 2636好久没有写博客了，最近比较忙，今天抽时间写点，最近 ... -
EJB4：RMI和RMI-IIOP
2010-11-02 21:14 4061计划提纲：引入→RMI概念→RMI HelloWorld程序→ ... -
EJB3: JBOSS 企业版、JBOSS服务器构架、EJB2.0 HelloWrold实例
2010-10-26 22:43 6411本文的研究基于jboss-eap- ...
相关推荐
kingbaseV8 hibernate jdbc 驱动
中取出的记录条数，一般设置为30、50、100.Oracle数据库的JDBC驱动默认的Fetch Size=15，设置Fetch Size设置为：30、50，性能会有明显提升，如果继续增大，超出100，性能提升不明显，反而会消耗内存。 即在...
JDBC与Hibernate在性能上相比，JDBC灵活性有优势。而Hibernate在易学性，易用性上有些优势。当用到很多复杂的多表联查和复杂的数据库操作时，JDBC有优势。 相同点： ◆两者都是JAVA的数据库操作中间件。 ◆两者对于...
struts+hibernate+jdbc双表查询
jdbc和hibernate的区别jdbc和hibernate的区别jdbc和hibernate的区别jdbc和hibernate的区别jdbc和hibernate的区别jdbc和hibernate的区别jdbc和hibernate的区别jdbc和hibernate的区别jdbc和hibernate的区别jdbc和...
两个项目，一个项目是基于spring jdbc实现的分布式事务，一个是基于spring hibernate的分布式事务，hibernate项目里的applicationContext2.xml是基于mysql和mssql， applicationContext3.xml基于两个mssql， ...
简介Hibernate和JDBC， 并比较二者的关联于区别
Hibernate提升性能Hibernate提升性能Hibernate提升性能Hibernate提升性能
使用hibernate连接数据库时必须用到的两个jar包，commons-dbcp-1.2.2.jar，jta.jar
Hibernate与JDBC对于数据库的性能操作对比事例，配置，更多信息资源
比较了Hibernate和JDBC的性能和实用场景。
分别使用Hibernate和JDBC操作数据库
hibernate所需包：hibernate3，依赖包，JDBC
JDBC与Hibernate的比较JDBC与Hibernate的比较
Hibernate链接access数据是所需的jdbc驱动包
的效率低于直接JDBC存取，然而，在经过比较好的性能优化之后，Hibernate的性能还是让人相当满意的， 特别是应用二级缓存之后，甚至可以获得比较不使用缓存的JDBC更好的性能，下面介绍一些通常的 Hibernate的优化策略...
学完hibernate后，写的一些总结，便于记忆
类似hibernate的jdbc简单封装，说不定大家用的上。。
hibernate和jdbc测试
Hibernate性能优化Hibernate性能优化Hibernate性能优化Hibernate性能优化Hibernate性能优化