`
kylinsoong
  • 浏览: 240723 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

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。。本来还想再分析分析,但是周末了,不想再多呆在公司……

  • 大小: 2.1 KB
  • 大小: 5.2 KB
分享到:
评论
39 楼 feilian09 2014-03-20  
查询 select hibernate jdbc 那个效率快
38 楼 yhailj 2010-08-21  
为这个问题自己也一直挺郁闷的, 出现这种问题只能怪自己 jdbc 没有写好!

有 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的太多了


... ...
可能你说的是Win3.x 吧...
35 楼 freish 2010-08-21  
hibernate底层还是jdbc

你这jdbc代码写的太没效率了
34 楼 carlkkx 2010-08-21  
就像Windows和DOS操作系统的关系。
_______________________
晕倒,Windows和Dos是这种关系?
33 楼 beeke 2010-08-21  
你们真是闲得蛋疼啊(我也是)
hibernate内部也是执行JDBC
就好像汽车对车轮说:我跑得比你快
真无聊啊...
32 楼 pujia12345 2010-08-21  
现在鼠辈横行啊!
殊不知: 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代码
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只执行了一次提交
29 楼 kylinsoong 2010-08-21  
笑我痴狂 写道
首先得说jdbc肯定比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 你看看 你写的代码
 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 你看看 你写的代码
 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 你看看 你写的代码
 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台服务器。

看看哪个快哦~
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的开启和关闭以及事务的开启提交全部放入其中,我想他们两个的效率比较就比较公平了!说到底,还是写代码的问题!
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的开启和关闭以及事务的开启提交全部放入其中,我想他们两个的效率比较就比较公平了!说到底,还是写代码的问题!

相关推荐

    本人理解hibernate 与 JDBC 的最本质区别

    标题中的“本人理解hibernate 与 JDBC 的最本质区别”揭示了我们即将探讨的核心主题:Hibernate 和 JDBC 在处理数据库操作时的不同之处。 Hibernate 是一个对象关系映射(ORM)框架,而 JDBC(Java Database ...

    Spring对Hibernate及JDBC提供的支持

    本文将深入探讨Spring如何为Hibernate和JDBC提供支持,帮助开发者更高效地进行数据访问操作。 首先,Spring对Hibernate的支持体现在其集成层面。通过Spring,我们可以将Hibernate的SessionFactory和Session对象的...

    JDBC与Hibernate的比较

    本文将详细探讨两种常见的Java数据库访问方式:JDBC(Java Database Connectivity)与Hibernate,并从多个维度进行对比分析。 #### 一、简介 **JDBC**(Java Database Connectivity)是一种用于执行SQL语句的Java ...

    Jdbc 和hibernate

    标题 "Jdbc 和hibernate" 提到的两个主要概念是Java数据库连接(JDBC)和Hibernate,它们都是Java开发中用于与关系型数据库交互的重要技术。本文将深入探讨这两个技术,以及它们之间的区别和联系。 JDBC是Java平台...

    分别使用Hibernate和JDBC操作数据库

    本话题将详细探讨两种常见的Java技术:Hibernate和JDBC,用于实现这一目标。 **JDBC(Java Database Connectivity)** 是Java平台上的标准API,它允许Java应用程序连接到各种类型的数据库。JDBC提供了连接数据库、...

    hibernate和jdbc测试

    对于性能测试,可以比较使用JDBC和Hibernate执行相同任务的时间消耗,评估哪种方式更高效。同时,要关注内存使用情况,因为ORM框架可能会增加内存开销。 在进行测试时,使用单元测试框架,如JUnit,可以帮助自动化...

    hibernate+jdbc版课设 新闻发布系统

    在这个项目中,我们主要探讨的是如何利用Hibernate框架结合JDBC技术来构建一个新闻发布系统。Hibernate是一个强大的对象关系映射(ORM)框架,它允许开发者用面向对象的方式来操作数据库,极大地简化了数据库操作。...

    hibernate + shardingjdbc +springboot 结合做的demo

    在这个示例中,我们将探讨如何将Hibernate ORM框架、ShardingSphere的ShardingJDBC模块与Spring Boot整合,构建一个高效的分布式数据库应用。这样的组合允许我们利用Hibernate的强大ORM能力,同时通过ShardingJDBC...

    oracle分别使用jdbc和hibernate的例子

    本文将深入探讨如何使用JDBC和Hibernate来操作Oracle数据库,同时结合提供的标签"源码"和"工具",我们将讨论它们的实现细节和优势。 首先,JDBC是Java语言的标准API,它允许Java应用程序与各种类型的数据库进行通信...

    hibernate-batch-size-test:Hibernate hibernate.jdbc.batch_size 测试

    当设置`hibernate.jdbc.batch_size`时,Hibernate会将多个保存操作组合成一个批次,然后一次性提交到数据库,减少了数据库交互的次数,从而提升了整体性能。在MySQL这样的关系型数据库中,JDBC驱动程序支持批处理,...

    在JDBC,hibernate中实现分页

    本文将深入探讨如何在Java开发环境中使用Hibernate框架以及JDBC结合SQL Server 2005来实现数据分页功能。 #### Hibernate中的分页实现 在Hibernate框架中实现分页功能相对较为简单。通过`Query`对象提供的方法即可...

    JPA JDBC hibernate mybatis对比

    综合来看,JDBC适用于对性能要求极高的场景,而JPA和Hibernate更适合快速开发,它们通过ORM降低了开发难度,但在性能上有所牺牲。MyBatis则提供了一个折中的方案,它保持了开发的灵活性,同时也具备一定的性能优势。...

    Java-Hibernate-JDBC.rar_Author_ Author

    2. **性能**:在执行大量简单的读写操作时,JDBC可能比Hibernate更快,因为JDBC避免了ORM的额外开销。但在复杂查询和大数据量处理中,Hibernate的缓存机制和批处理能力可以提高性能。 3. **灵活性**:JDBC允许直接...

    Hibernate性能优化研究.pdf

    本文旨在通过对Hibernate的深入研究,探讨影响其性能的各种因素,并提出相应的优化策略。 #### 二、O/R Mapping及Hibernate简介 ##### 2.1 O/R Mapping O/R Mapping是一种编程技术,用于在关系数据库和对象之间...

    hibernate-性能优化

    【描述】:在使用 Hibernate 进行数据库操作时,性能问题时常出现,但通过适当的调整和优化,我们可以显著提高 Hibernate 的执行效率,甚至达到接近或超过直接使用 JDBC 的效果。本文将探讨几个关键的优化策略。 ...

    hibernate性能:性能、规模、风险 初评

    本文将探讨Hibernate在不同场景下的性能特点、应用规模及潜在的风险,并尝试分析这些问题背后的原因。 #### 二、Hibernate性能特点 1. **缓存机制**:Hibernate内置了一套完整的缓存体系,包括一级缓存、二级缓存...

    Hibernate缓存机制探讨.doc

    然而,直接使用 JDBC 访问数据库存在一定的性能开销。为了提升性能,Hibernate 引入了缓存机制。缓存是一种位于应用程序和物理数据之间的重要组件,旨在减少对物理数据的直接访问频率,从而提高应用系统的整体性能。...

    Hibernate 参数配置详解

    本文档将深入探讨 Hibernate 的核心配置参数及其功能,帮助开发者更好地理解并利用这些配置项以优化应用性能。 #### 二、Hibernate JDBC 和连接(connection)属性 ##### 1. SQL 方言 (Dialect) - **名称**:`...

    JDBC和hibernate事务的详解

    本讲解将深入探讨JDBC(Java Database Connectivity)和Hibernate两种不同的技术在处理事务时的方法和特点。 ### 1. JDBC事务 JDBC是Java中用于与各种数据库交互的标准接口。在JDBC中,事务管理主要通过以下步骤...

    Hibernate 性能优化

    然而,对于初次接触 Hibernate 的开发者来说,可能会遇到性能方面的问题,尤其是在与传统的 JDBC 方式相比时。这些问题如果不加以解决,很容易影响到项目的整体进度。本文将详细介绍如何优化 Hibernate 的性能,并...

Global site tag (gtag.js) - Google Analytics