Spring的事务管理难点剖析(7):数据连接泄漏

[b][size=large]底层连接资源的访问问题[/size][/b]

对于应用开发者来说,数据连接泄漏无疑是一个可怕的梦魇。只要你开发的应用存在数据连接泄漏的问题,应用程序最终都将因数据连接资源的耗尽而崩溃,甚至还可能引起数据库的崩溃。数据连接泄漏像一个黑洞那样让开发者避之唯恐不及。
Spring DAO对所有支持的数据访问技术框架都使用模板化技术进行了薄层的封装。只要你的程序都使用Spring DAO的模板(如JdbcTemplate、HibernateTemplate等)进行数据访问,一定不会存在数据连接泄漏的问题——这是Spring给予我们的郑重承诺!如果使用Spring DAO模板进行数据操作,我们无须关注数据连接(Connection)及其衍生品(Hibernate的Session等)的获取和释放操作,模板类已经通过其内部流程替我们完成了,且对开发者是透明的。
但是由于集成第三方产品、整合遗产代码等原因,可能需要直接访问数据源或直接获取数据连接及其衍生品。这时,如果使用不当,就可能在无意中创造出一个魔鬼般的连接泄漏问题。
我们知道:当Spring事务方法运行时,就产生一个事务上下文,该上下文在本事务执行线程中针对同一个数据源绑定了一个唯一的数据连接(或其衍生品),所有被该事务上下文传播的方法都共享这个数据连接。这个数据连接从数据源获取及返回给数据源都在Spring掌控之中,不会发生问题。如果在需要数据连接时,能够获取这个被Spring管控的数据连接,则使用者可以放心使用,无须关注连接释放的问题。
那么,如何获取这些被Spring管控的数据连接呢?Spring提供了两种方法:其一是使用数据资源获取工具类;其二是对数据源(或其衍生品如Hibernate SessionFactory)进行代理。

[b][size=large]Spring JDBC数据连接泄漏[/size][/b]

如果我们从数据源直接获取连接,且在使用完成后不主动归还给数据源(调用Connection#close()),则将造成数据连接泄漏的问题。
package com.baobaotao.connleak;
…
@Service("jdbcUserService")
public class JdbcUserService {
@Autowired
private JdbcTemplate jdbcTemplate;

@Transactional
public void logon(String userName) {
try {

//①直接从数据源获取连接,后续程序没有显式释放该连接
Connection conn = jdbcTemplate.getDataSource().getConnection();
String sql = "UPDATE t_user SET last_logon_time=? WHERE user_name =?";
jdbcTemplate.update(sql, System.currentTimeMillis(), userName);

//②模拟程序代码的执行时间
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
}
}

JdbcUserService通过Spring AOP事务增强的配置,让所有public方法都工作在事务环境中,即让logon()和updateLastLogonTime()方法拥有事务功能。在logon()方法内部,我们在①处通过调用jdbcTemplate.getDataSource().getConnection()显式获取一个连接,这个连接不是logon()方法事务上下文线程绑定的连接,所以如果开发者没有手工释放这个连接(显式调用Connection#close()方法),则这个连接将永久被占用(处于active状态),造成连接泄漏!下面,我们编写模拟运行的代码,查看方法执行对数据连接的实际占用情况:
package com.baobaotao.connleak;
…
@Service("jdbcUserService")
public class JdbcUserService {
…
//①以异步线程的方式执行JdbcUserService#logon()方法,以模拟多线程的环境
public static void asynchrLogon(JdbcUserService userService, String userName) {
UserServiceRunner runner = new UserServiceRunner(userService, userName);
runner.start();
}
private static class UserServiceRunner extends Thread {
private JdbcUserService userService;
private String userName;
public UserServiceRunner(JdbcUserService userService, String userName) {
this.userService = userService;
this.userName = userName;
}
public void run() {
userService.logon(userName);
}
}

//②让主执行线程睡眠一段指定的时间
public static void sleep(long time) {
try {
Thread.sleep(time);
} catch (InterruptedException e) {
e.printStackTrace();
}
}

//③汇报数据源的连接占用情况
public static void reportConn(BasicDataSource basicDataSource) {
System.out.println("连接数[active:idle]-[" +
basicDataSource.getNumActive()+":"+basicDataSource.getNumIdle()+"]");
}

public static void main(String[] args) {
ApplicationContext ctx =
new ClassPathXmlApplicationContext("com/baobaotao/connleak/applicatonContext.xml");
JdbcUserService userService = (JdbcUserService) ctx.getBean("jdbcUserService");

BasicDataSource basicDataSource = (BasicDataSource) ctx.getBean("dataSource");

//④汇报数据源初始连接占用情况
JdbcUserService.reportConn(basicDataSource);

JdbcUserService.asynchrLogon(userService, "tom");//启动一个异常线程A
JdbcUserService.sleep(500);

//⑤此时线程A正在执行JdbcUserService#logon()方法
JdbcUserService.reportConn(basicDataSource);

JdbcUserService.sleep(2000);

//⑥此时线程A所执行的JdbcUserService#logon()方法已经执行完毕
JdbcUserService.reportConn(basicDataSource);

JdbcUserService.asynchrLogon(userService, "john");//启动一个异常线程B
JdbcUserService.sleep(500);

//⑦此时线程B正在执行JdbcUserService#logon()方法
JdbcUserService.reportConn(basicDataSource);

JdbcUserService.sleep(2000);

//⑧此时线程A和B都已完成JdbcUserService#logon()方法的执行
JdbcUserService.reportConn(basicDataSource);

}


在JdbcUserService中添加一个可异步执行logon()方法的asynchrLogon()方法,我们通过异步执行logon()以及让主线程睡眠的方式模拟多线程环境下的执行场景。在不同的执行点,通过reportConn()方法汇报数据源连接的占用情况。
通过Spring事务声明,对JdbcUserServie的logon()方法进行事务增强,配置代码如下所示:
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
…
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
<context:component-scan base-package="com.baobaotao.connleak"/>
<context:property-placeholder location="classpath:jdbc.properties"/>
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close"
p:driverClassName="${jdbc.driverClassName}"
p:url="${jdbc.url}"
p:username="${jdbc.username}"
p:password="${jdbc.password}"/>

<bean id="jdbcTemplate"
class="org.springframework.jdbc.core.JdbcTemplate"
p:dataSource-ref="dataSource"/>

<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
p:dataSource-ref="dataSource"/>

<!--①启用注解驱动的事务增强-->
<tx:annotation-driven/>
</beans>

然后,运行JdbcUserServie,在控制台将观察到如下的输出信息:
[quote]连接数[active:idle]-[0:0]
连接数[active:idle]-[2:0]
连接数[active:idle]-[1:1]
连接数[active:idle]-[3:0]
连接数[active:idle]-[2:1][/quote]
我们通过表10-3对数据源连接的占用和泄漏情况进行描述。
[table]
|时间 |执行线程1| 执行线程2 |数据源连接|
| | | | active |idle| leak|
|T0|未启动 |未启动 |0| 0| 0 |
|T1|正在执行方法 |未启动 |2| 0| 0 |
|T2|执行完毕 |未启动 |1| 1| 1 |
|T3|执行完毕 |正式执行方法 |3| 0| 1 |
|T4|执行完毕 |执行完毕 |2| 1| 2 |
[/table]
可见在执行线程1执行完毕后,只释放了一个数据连接,还有一个数据连接处于active状态,说明泄漏了一个连接。相似的,执行线程2执行完毕后,也泄漏了一个连接:原因是直接通过数据源获取连接(jdbcTemplate.getDataSource().getConnection())而没有显式释放。

[b][size=large]通过DataSourceUtils获取数据连接[/size][/b]

Spring提供了一个能从当前事务上下文中获取绑定的数据连接的工具类,那就是DataSourceUtils。Spring强调必须使用DataSourceUtils工具类获取数据连接,Spring的JdbcTemplate内部也是通过DataSourceUtils来获取连接的。 DataSourceUtils提供了若干获取和释放数据连接的静态方法,说明如下:

[list]
[*] static Connection doGetConnection(DataSource dataSource):首先尝试从事务上下文中获取连接,失败后再从数据源获取连接;
[*]static Connection getConnection(DataSource dataSource):和doGetConnection方法的功能一样,实际上,它内部就是调用doGetConnection方法获取连接的;
[*]static void doReleaseConnection(Connection con, DataSource dataSource):释放连接,放回到连接池中;
[*]static void releaseConnection(Connection con, DataSource dataSource):和doRelease Connection方法的功能一样,实际上,它内部就是调用doReleaseConnection方法获取连接的。
[/list]

来看一下DataSourceUtils从数据源获取连接的关键代码:

public abstract class DataSourceUtils {
…
public static Connection doGetConnection(DataSource dataSource) throws SQLException {
Assert.notNull(dataSource, "No DataSource specified");

//①首先尝试从事务同步管理器中获取数据连接
ConnectionHolder conHolder =
(ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
if (conHolder != null && (conHolder.hasConnection() ||
conHolder.isSynchronizedWithTransaction())) {
conHolder.requested();
if (!conHolder.hasConnection()) {
logger.debug("Fetching resumed JDBC Connection from DataSource");
conHolder.setConnection(dataSource.getConnection());
}
return conHolder.getConnection();
}

//②如果获取不到连接,则直接从数据源中获取连接
Connection con = dataSource.getConnection();

//③如果拥有事务上下文,则将连接绑定到事务上下文中
if (TransactionSynchronizationManager.isSynchronizationActive()) {
ConnectionHolder holderToUse = conHolder;
if (holderToUse == null) {
holderToUse = new ConnectionHolder(con);
}
else {holderToUse.setConnection(con);}
holderToUse.requested();
TransactionSynchronizationManager.registerSynchronization(
new ConnectionSynchronization(holderToUse, dataSource));
holderToUse.setSynchronizedWithTransaction(true);
if (holderToUse != conHolder) {
TransactionSynchronizationManager.bindResource(
dataSource, holderToUse);
}
}
return con;
}
…
}


它首先查看当前是否存在事务管理上下文,并尝试从事务管理上下文获取连接,如果获取失败,直接从数据源中获取连接。在获取连接后,如果当前拥有事务上下文,则将连接绑定到事务上下文中。
我们在JdbcUserService中,使用DataSourceUtils.getConnection()替换直接从数据源中获取连接的代码:
package com.baobaotao.connleak;
…
@Service("jdbcUserService")
public class JdbcUserService {
@Autowired
private JdbcTemplate jdbcTemplate;

@Transactional
public void logon(String userName) {
try {
//①使用DataSourceUtils获取数据连接
Connection conn =
DataSourceUtils.getConnection(jdbcTemplate.getDataSource());
//Connection conn = jdbcTemplate.getDataSource().getConnection();

String sql = "UPDATE t_user SET last_logon_time=? WHERE user_name =?";
jdbcTemplate.update(sql, System.currentTimeMillis(), userName);
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
}
}


重新运行代码,得到如下的执行结果:

[quote]连接数[active:idle]-[0:0]
连接数[active:idle]-[1:0]
连接数[active:idle]-[0:1]
连接数[active:idle]-[1:0]
连接数[active:idle]-[0:1][/quote]

对照上一节的输出日志,我们可以看到已经没有连接泄漏的现象了。一个执行线程在运行JdbcUserService#logon()方法时,只占用一个连接,而且方法执行完毕后,该连接马上释放。这说明通过DataSourceUtils.getConnection()方法确实获取了方法所在事务上下文绑定的那个连接,而不是像原来那样从数据源中获取一个新的连接。

[b][size=large]通过DataSourceUtils获取数据连接[/size][/b]

是否使用DataSourceUtils获取数据连接就可以高枕无忧了呢?理想很美好,但现实很残酷:如果DataSourceUtils在没有事务上下文的方法中使用getConnection()获取连接,依然会造成数据连接泄漏!
保持上面的代码不变,将上面Spring配置文件中①处的Spring AOP事务增强配置的代码注释掉,重新运行代码清单10-23的代码,将得到如下的输出日志:

[quote]连接数[active:idle]-[0:0]
连接数[active:idle]-[1:1]
连接数[active:idle]-[1:1]
连接数[active:idle]-[2:1]
连接数[active:idle]-[2:1][/quote]

我们通过下表对数据源连接的占用和泄漏情况进行描述。
仔细对上表的执行过程,我们发现在T1时,有事务上下文时的active为2,idle为0,而此时由于没有事务管理,则active为1而idle也为1。这说明有事务上下文时,需要等到整个事务方法(即logon())返回后,事务上下文绑定的连接才被释放。但在没有事务上下文时,logon()调用JdbcTemplate执行完数据操作后,马上就释放连接。

[table]
|时间 |执行线程1| 执行线程2 |数据源连接|
| | | | active |idle| leak|
|T0| 未启动 |未启动 |0| 0| 0|
|T1| 正在执行方法 |未启动 |1| 1| 0|
|T2| 执行完毕 |未启动 |1| 1| 1|
|T3| 执行完毕 |正式执行方法 |2| 1| 1|
|T4| 执行完毕 |执行完毕 |2| 1| 2|
[/table]

在T2执行线程完成logon()方法的调用后,有一个连接没有被释放(active),所以发生了连接泄漏。到T4时,两个执行线程都完成了logon()方法的调用,但是出现了两个未释放的连接。
要堵上这个连接泄漏的漏洞,需要对logon()方法进行如下的改造:
package com.baobaotao.connleak;
…
@Service("jdbcUserService")
public class JdbcUserService {
@Autowired
private JdbcTemplate jdbcTemplate;

@Transactional
public void logon(String userName) {
try {
Connection conn =
DataSourceUtils.getConnection(jdbcTemplate.getDataSource());
String sql = "UPDATE t_user SET last_logon_time=? WHERE user_name =?";
jdbcTemplate.update(sql, System.currentTimeMillis(), userName);
Thread.sleep(1000);
//①
} catch (Exception e) {
e.printStackTrace();
}finally {

//②显式使用DataSourceUtils释放连接
DataSourceUtils.releaseConnection(conn,jdbcTemplate.getDataSource());
}
}
}

在②处显式调用DataSourceUtils.releaseConnection()方法释放获取的连接。特别需要指出的是:一定不能在①处释放连接!因为如果logon()在获取连接后,①处代码前这段代码执行时发生异常,则①处释放连接的动作将得不到执行。这将是一个非常具有隐蔽性的连接泄漏的隐患点。

[b][size=large]JdbcTemplate如何做到对连接泄漏的免疫[/size][/b]

分析JdbcTemplate的代码,我们可以清楚地看到它开放的每个数据操作方法,首先都使用DataSourceUtils获取连接,在方法返回之前使用DataSourceUtils释放连接。
来看一下JdbcTemplate最核心的一个数据操作方法execute():
public <T> T execute(StatementCallback<T> action) throws DataAccessException {

//①首先根据DataSourceUtils获取数据连接
Connection con = DataSourceUtils.getConnection(getDataSource());
Statement stmt = null;
try {
Connection conToUse = con;
…
handleWarnings(stmt);
return result;
}
catch (SQLException ex) {
JdbcUtils.closeStatement(stmt);
stmt = null;

//②发生异常时,使用DataSourceUtils释放数据连接
DataSourceUtils.releaseConnection(con, getDataSource());
con = null;
throw getExceptionTranslator().translate(
"StatementCallback", getSql(action), ex);
}
finally {
JdbcUtils.closeStatement(stmt);

//③最后再使用DataSourceUtils释放数据连接
DataSourceUtils.releaseConnection(con, getDataSource());
}
}


在①处通过DataSourceUtils.getConnection()获取连接,在②和③处通过DataSourceUtils.releaseConnection()释放连接。所有JdbcTemplate开放的数据访问API最终都是直接或间接由execute(StatementCallback<T> action)方法执行数据访问操作的,因此这个方法代表了JdbcTemplate数据操作的最终实现方式。
正是因为JdbcTemplate严谨的获取连接及释放连接的模式化流程保证了JdbcTemplate对数据连接泄漏问题的免疫性。所以,如有可能尽量使用JdbcTemplate、HibernateTemplate等这些模板进行数据访问操作,避免直接获取数据连接的操作。

[b][size=large]使用TransactionAwareDataSourceProxy[/size][/b]


如果不得已要显式获取数据连接,除了使用DataSourceUtils获取事务上下文绑定的连接外,还可以通过TransactionAwareDataSourceProxy对数据源进行代理。数据源对象被代理后就具有了事务上下文感知的能力,通过代理数据源的getConnection()方法获取连接和使用DataSourceUtils.getConnection()获取连接的效果是一样的。
下面是使用TransactionAwareDataSourceProxy对数据源进行代理的配置:

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
…
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
<context:component-scan base-package="com.baobaotao.connleak"/>
<context:property-placeholder location="classpath:jdbc.properties"/>

<!--①未被代理的数据源 -->
<bean id="originDataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close"
p:driverClassName="${jdbc.driverClassName}"
p:url="${jdbc.url}"
p:username="${jdbc.username}"
p:password="${jdbc.password}"/>

<!--②对数据源进行代码,使数据源具体事务上下文感知性 -->
<bean id="dataSource"
class="org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy"
p:targetDataSource-ref="originDataSource" />

<bean id="jdbcTemplate"
class="org.springframework.jdbc.core.JdbcTemplate"
p:dataSource-ref="dataSource"/>

<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
p:dataSource-ref="dataSource"/>
<tx:annotation-driven/>
</beans>


对数据源进行代理后,我们就可以通过数据源代理对象的getConnection()获取事务上下文中绑定的数据连接了。因此,如果数据源已经进行了 TransactionAwareDataSourceProxy的代理,而且方法存在事务上下文,那么代码清单10-19的代码也不会生产连接泄漏的问题。

[b][size=large]其他数据访问技术的等价类[/size][/b]

理解了Spring JDBC的数据连接泄漏问题,其中的道理可以平滑地推广到其他框架中去。Spring为每个数据访问技术框架都提供了一个获取事务上下文绑定的数据连接(或其衍生品)的工具类和数据源(或其衍生品)的代理类。
表10-5列出了不同数据访问技术对应DataSourceUtils的等价类。
表10-5 不同数据访问框架DataSourceUtils的等价类
[table]
|数据访问技术框架 |连接(或衍生品)获取工具类 |
|Spring JDBC |org.springframework.jdbc.datasource.DataSourceUtils |
|Hibernate |org.springframework.orm.hibernate3.SessionFactoryUtils |
|iBatis |org.springframework.jdbc.datasource.DataSourceUtils |
|JPA |org.springframework.orm.jpa.EntityManagerFactoryUtils |
|JDO |org.springframework.orm.jdo.PersistenceManagerFactoryUtils|
[/table]

表10-6列出了不同数据访问技术框架下TransactionAwareDataSourceProxy的等价类。
表10-6 不同数据访问框架TransactionAwareDataSourceProxy的等价类
[table]
|数据访问技术框架| 连接(或衍生品)获取工具类 |
|Spring JDBC | org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy |
|Hibernate | org.springframework.orm.hibernate3.LocalSessionFactoryBean |
|iBatis | org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy |
|JPA | 无 |
|JDO | org.springframework.orm.jdo.TransactionAwarePersistenceManagerFactoryProxy |
[/table]

[b][color=red]注:以上内容摘自《Spring 4.x企业应用开发实战》[/color][/b]
经纬度转换为UTM坐标 UTM(通用横向墨卡托投影): 是一种以米为单位的坐标系统,用于地图和GPS导航。将地球划分为60个纵向的区域。每个区域宽6度,从赤道开始往南北两级方向划分。每个区域都有一个特定的字母。 阅读详情

相关推荐

群晖Web Station实战:从零搭建个人静态导航站

本文详细介绍了如何利用群晖NAS自带的Web Station套件,从零开始搭建个人静态导航站。通过安装Web Station、上传静态网站源码、配置网页服务与网络门户等步骤,无需代码基础即可实现内网访问。文章还分享了文件权限设置、个性化定制及常见问题排查等实用技巧,帮助用户高效管理个人常用网址,充分挖掘NAS的服务器潜能。

tea88的博客 1332

数据库底层连接

package com.wen;import java.sql.*;/** * Title: 数据库底层连接 * Description: * Copyright:    Copyright (c) 2004 * Company: * @author  explorer * @version 1.0 */public class Linkdb {  String strDriver = "

Explorerwen--Javahome 2769

稳定双共轭梯度法BiCGSTAB流程

稳定双共轭梯度法BiCGSTAB流程

abner361的博客 1155

thread 泄露问题

解决了一个隐蔽的内存泄漏——pthread_create后没有pthread_join导致内存持续增长 昨天解决了一个隐蔽的内存泄漏问题,原因是pthread_create后的僵死线程没有释放导致的内存持续增长。 现象是这样的:短时间内程序运行正常,但跑了12小时左右,用top查看其内存占用居然高达2G,于是马上意识到有内存泄漏。 最先想到的是malloc/free、new/

小青年儿 1198

Qt Installer Framework4.6.1的最基础使用1(win10+离线安装包 )

因工作需要,win程序发布后,打包成一可执行exe文件,且兼容win7系统笔者记录了一些关键要点,供有需要的小伙伴使用。

aggs1990的专栏 905

envi5.3处理高分二号影像数据详细过程记录

全文根据此篇文章进行数据处理: tm影像辐射定标_高分二号影像数据预处理及裁剪过程 其他参考: 学习笔记---遥感影像辐射定标与大气校正 利用ENVI自带全球DEM数据计算区域平均高程 高分二号数据处理流程(有高分二号的数据信息) GF2有多光谱和全色两个数据,MSS是多光谱的,PAN是全色的,多光谱的分辨率低,全色的高,需要把这两个数据融合,融合之前需要做定标等处理,获取经纬度。 一、多光谱影像处理 1. 辐射定标 以这个为例: 其他路径\2022.4.2...

ligous的博客 5万+

Spring 事务管理高级应用难点剖析: 第 3 部分

陈 雄华, 系统架构师陈雄华,2002 年毕业于厦门大学计算机与信息工程学院,获硕士学位。拥有 10 多年的 Java 开发、设计、架构的经验。技术研发之余,常将经验所得行诸于文字,作者是国内多个著名技术网站的专栏作者,在各大技术网站、报刊杂志发表过数十篇技术文章,广受读者好评。于 2005 年出版《精通 JBuilder 2005》,于 2007 年出版《精通 Spring 2.

Roka的专栏 864

超详细的YOLOv8安装与测试指南:让计算机视觉任务变得简单

python3+、Anaconda3或Miniconda3 Ultralytics提供了多种安装方法,包括pip、conda和Docker。通过pip包安装最新稳定版的YOLOv8,或者克隆Ultralytics GitHub仓库以获取最新版本。Docker可用于在隔离容器中执行包,避免本地安装。 最简单直接的方式就是直接使用pip方法直接安装。 也可以直接从GitHub仓库安装包。如果你想要最新的开发版本,这可能会很有用。确保你的系统上安装了Git命令行工具

CDBmax的博客 1万+

Spring是如何保证同一事务获取同一个Connection的?使用Spring的事务同步机制解决:数据库刚插入的记录却查询不到的问题【享学Spring】

前言 关于Spring的事务,我前面用了大量的篇幅从应用层面、原理层面都进行了比较全方位的一个讲解。但是因为它过于重要,所以本文继续做补充:Spring事务的同步机制 Spring事务同步机制?我猜测很多小伙伴从来没听过有这么一说法,毕竟它在平时开发中你可能很少遇到(如果你没怎么考虑过系统性能的话)。 让我记录本文的动力是由于我在开发自己测试过程中遇到这样一个诡异异常: java.sql.SQLE...

架构师:通透,才能写出好代码! 1万+

实战篇(一):从零构建领域知识图谱——基于Protege的本体建模与知识表示

本文详细介绍了如何从零构建领域知识图谱,重点讲解了基于Protege的本体建模与知识表示方法。通过游戏和电影领域的实战案例,展示了类层次结构设计、属性关系定义、推理验证等关键步骤,帮助读者掌握知识图谱构建的核心技术。

weixin_42613501的博客 482

YOLO + SubspaceAD:一张良品图,检出所有未知缺陷

当YOLO遇上子空间建模,工业质检正迎来从“见多识广”到“举一反三”的质变时刻。

①答疑群聊服务;②YOLO大模型知识问答系统;③计算机视觉论文生成智能体; 501

Spring事务管理与数据库隔离级别的关系(Spring+mysql)

之前写过一篇文章《数据库隔离级别(mysql+Spring)与性能分析 》,里面很多问题写的不是很专业,也不是很有逻辑性,现在重新整理一下,希望对大家有帮助。 这部分通过两天时间反复的做实验总算是理清了其中的关系,其中有些部分可能略有偏差,但是相信大家仔细读的话会对对这部分的理解带来很大的帮助。 先来总体说一下我对这个问题的理解,用一句话概括:数据库是可以控制事务的传播和隔离级别的,Spr...

各研发管理 666

第47节:cesium 热力图效果(含源码+视频)

cesium 热力图效果

qq_29384639的博客 1676

Druid 连接池泄漏全面剖析

在我们的生产环境中,最初发现系统频繁出现"断开的管道"(Broken Pipe)错误。随着时间推移,这类错误出现的频率越来越高,最终导致大量数据库操作被拒绝。 我们在搜索引擎发现,对于Druid连接MySQL出现断开的管道可能有如下原因:在排除网络连接问题和数据库配置问题之后,我们决定调整Druid连接池配置。我们的druid连接池初始参数配置如下 在配置之前,需要先了解keepAlive、testWhileIdle这两个参数的含义和适用场景。keepAlive 机制工作原理:适用场景:主动保活场景性能优化

u011518365的博客 2128

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

Spring事务管理高级应用难点剖析

Spring 事务管理高级应用难点剖析: 第 1 部分 Spring 的事务管理是被使用得最多的功能之一,虽然 Spring 事务管理已经帮助程序员将要做的事情减到了最小。但在实际开发中,如果使用不当,依然会造成数据连接泄漏等问题。本系列以实际应用中所碰到的各种复杂的场景为着眼点,对这些应...

chengjuqiang2059的博客 138

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

Spring 事务管理高级应用难点剖析

陈 雄华, 系统架构师 简介: Spring 的事务管理是被使用得最多的功能之一,虽然 Spring 事务管理已经帮助程序员将要做的事情减到了最小。但在实际开发中,如果使用不当,依然会造成数据连接泄漏等问题。本系列以实际应用中所碰到的各种复杂的场景为着眼点,对这些应用的难点进行深度的剖析。 查看本系列更多内容 发布日期: 2010 年 3 月 19 日  级别:

novelly的专栏 1027

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

Spring 事务管理高级应用难点剖

Spring 事务管理高级应用难点剖      Spring 事务管理高级应用难点剖析: 第 1 部分 Spring 的事务管理是被使用得最多的功能之一,虽然 Spring 事务管理已经帮助程序员将要做的事情减到了最小。但在实际开发中,如果使用不当,依然会造成数据连接泄漏等问题。本系列以实际应用中所碰到的各种复杂的场景为着眼点,对这些应用的难点进行深度的剖析。      Spring...

ZXCVBNM645的博客 205

Spring事务管理高级应用难点剖析III

概述   对于应用开发者来说,数据连接泄漏无疑是一个可怕的梦魇。如果存在数据连接泄漏问题,应用程序将因数据连接资源的耗尽而崩溃,甚至还可能引起数据库的崩溃。数据连接泄漏像黑洞一样让开发者避之唯恐不及。   Spring DAO 对所有支持的数据访问技术框架都使用模板化技术进行了薄层的封装。只要您的程序都使用 Spring DAO 模板(如 JdbcTemplate、HibernateTempl...

挨踢路漫漫,上下而求索 232

Spring 事务管理高级应用难点剖析--转

第 1 部分 http://www.ibm.com/search/csass/search/?q=%E4%BA%8B%E5%8A%A1&sn=dw&lang=zh&cc=CN&en=utf&hpp=20&dws=cndw&lo=zh 概述 Spring 最成功,最吸引人的地方莫过于轻量级的声明式事务管理,仅此一点,它就宣告了重...

191

Spring Boot数据库连接超时排查:从环境敏感型缺陷到连接泄漏根治

在分布式系统和微服务架构中,数据库连接管理是保障应用稳定性的核心技术环节。其核心原理在于连接池机制,它通过复用预先建立的数据库连接来避免频繁创建销毁的开销,从而提升性能。连接池的技术价值在于有效管理稀缺的数据库连接资源,控制并发访问,是构建高可用、高性能应用的基础设施。典型的应用场景包括高并发Web服务、后台数据处理任务等。然而,不当的配置或代码缺陷,如连接泄漏,会导致连接池资源耗尽,引发间歇性的“数据库连接超时”问题,这类问题常表现为“观察者效应”——即难以稳定复现,给排查带来巨大挑战。本文将以Sprin

weixin_34161032的博客 358

Spring 事务管理高级应用难点剖析3

Spring 事务管理高级应用难点剖析: 第 3 部分 陈 雄华, 系统架构师 陈雄华,2002 年毕业于厦门大学计算机与信息工程学院,获硕士学位。拥有 10 多年的 Java 开发、设计、架构的经验。技术研发之余,常将经验所得行诸于文字,作者是国内多个著名技术网站的专栏作者,在各大技术网站、报刊杂志发表过数十篇技术文章,广受读者好评。于 2005 年出版《精通 JBuilder

figoren的专栏 720

Spring事务管理--高级应用难点剖析: 第 3 部分

转摘至:https://www.ibm.com/developerworks/cn/java/j-lo-spring-ts3/ 本文是“Spring 事务管理高级应用难点剖析”系列文章的第 3 部分,作者将继续深入剖析在实际 Spring 事务管理应用中容易遇见的一些难点,包括在使用 Spring JDBC 时如果直接获取 Connection,哪些情况会造成数据连接的泄漏与如何应对,以

szzt_lingpeng的专栏 619
上一篇: Spring的事务管理难点剖析(6):特殊方法成漏网之鱼
下一篇: Spring带给我们什么
quickselect
博客等级 码龄20年 1粉丝 58原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值