【深入理解MyBatis】- 02Mybatis连接池pool讲解和简要实现

最新推荐文章于 2023-07-15 22:22:57 发布
最新推荐文章于 2023-07-15 22:22:57 发布
阅读量689 收藏 1
点赞数
分类专栏： 深入理解MyBatis
随意转载。
本文链接：https://blog.csdn.net/dengjili/article/details/107052435
版权

连接池概念

  • 空闲连接队列与活跃队列
    在这里插入图片描述

  • 获取connection，空闲连接队列与活跃队列均为空时
    在这里插入图片描述

  • 获取connection，空闲连接队列不为空
    在这里插入图片描述

  • 获取connection，活跃连接队列已经满了
    在这里插入图片描述

  • 关闭connection，空闲连接队列还有空间
    在这里插入图片描述

  • 关闭connection，空闲连接队列没有空间，直接关闭
    在这里插入图片描述

  • 未显示关闭connection处理，超时概念
    在这里插入图片描述

  • 未显示关闭connection处理，当Client获取连接
    在这里插入图片描述

连接池PooledDataSource伪代码

Mybatis连接池代码参考org.apache.ibatis.datasource.pooled.PooledDataSource, 主要方法包括获取连接popConnection方法, 释放连接popConnection方法，这里给出伪代码思路，先明白连接池的工作原理，后面我再给出一个简要版的连接池。

// 获取连接
popConnection() {
	Connection connection = null;
	while (	connection == null) {
		1. 池中空闲连接队列是否为空，否（Pool has available connection）
			1.1 直接从空闲连接队列中获取连接connection
		2. 池中空闲连接队列是否为空，是（Pool does not have available connection）
			2.1 判断正在使用队列长度是否大于允许使用的最大连接数，否
				2.1.1 创建新的Connection对象
			2.2 判断正在使用队列长度是否大于允许使用的最大连接数，是
				// 无法再创建新的连接，尝试回收历史(旧)使用的连接对象
				// 为什么可以回收正在使用的连接数对象呢？
				// 因为Client在使用connection以后，未显示调用close方法，导致connection状态显示为正在使用，实际上已经是空闲状态	
				// 如何使用界限来区分哪一些应该回收呢？定义了poolMaximumCheckoutTime字段，意义为超时时间
				// 从获取连接开始计算时间，到回收时，计算这段时间是否大于超时时间，如果大于，将这个连接对象回收
				
				2.2.1 判断旧连接对象的使用时间是否大于超时时间，是
					2.2.1.1  回收旧连接对象，从可用连接队列remove
				
				2.2.2 判断旧连接对象的使用时间是否大于超时时间，否
					// Must wait
					2.2.2.1 执行wait逻辑，睡眠xxx时间，除非提前唤醒（有新的connection归还）
				
		3. 若获取到的connection不为空，判断connection是否可用（ping to server and check the connection is valid or not）
			3.1 connection是否， 是
				3.1.1 初始化连接，并重新放置可用连接队列
			3.2 connection是否， 否
				3.2.1 connection == null，重新获取
				
	}

	4. 若connection为空，抛出SQLException异常，获取连接对象connection失败

	5. 返回connection
}

// 释放连接
pushConnection(Connection connection) {
	1. 从可用连接队列remove归还的连接connection
	2. 判断归还的连接connection是否可用，是
		2.1 判断空闲队列是否已经满了，否
			2.1.1 将归还的连接connection添加到空闲队列中
			2.1.2 并执行线程notifyAll，可能有的线程正在等着用连接呢
		2.2 判断空闲队列是否已经满了，是
			2.2.1 将归还的连接connection关闭
	3. 判断归还的连接connection是否可用，否
		3.1 忽略，可以不用看
}

非连接池实现

为了同Mybatis连接池代码保持一致，这里先实现非连接池实现，这里使用的JDK8

先对接口DataSource实现一些不需要的方法，保留抽象方法public Connection getConnection() throws SQLException与public Connection getConnection(String username, String password) throws SQLException即可

public abstract class SourceImplWrapper implements DataSource {
	
	@Override
	public PrintWriter getLogWriter() throws SQLException {
		 return DriverManager.getLogWriter();
	}

	@Override
	public int getLoginTimeout() throws SQLException {
		return DriverManager.getLoginTimeout();
	}

	@Override
	public Logger getParentLogger() throws SQLFeatureNotSupportedException {
		return Logger.getGlobal();
	}

	@Override
	public void setLogWriter(PrintWriter printWriter) throws SQLException {
		DriverManager.setLogWriter(printWriter);
	}

	@Override
	public void setLoginTimeout(int loginTimeout) throws SQLException {
		DriverManager.setLoginTimeout(loginTimeout);
	}

	@Override
	public boolean isWrapperFor(Class<?> arg0) throws SQLException {
		return false;
	}

	@Override
	public <T> T unwrap(Class<T> arg0) throws SQLException {
		return null;
	}
}

非连接池实现代码，也就是我们平时使用到的JDBC方式，这个是重写后的版本，简写的很多细节，不过可运行

public class UnpooledSourceImpl extends SourceImplWrapper {
	
	private static Map<String, Boolean> registeredDrivers = new ConcurrentHashMap<>();

	static {
		Enumeration<Driver> drivers = DriverManager.getDrivers();
	    while (drivers.hasMoreElements()) {
	        Driver driver = drivers.nextElement();
	    	registeredDrivers.put(driver.getClass().getName(), true);
	    }
	}
	  
	private String driver;
	private String url;
	private String username;
	private String password;
	
	public UnpooledSourceImpl(String driver, String url, String username, String password) {
		this.driver = driver;
		this.url = url;
		this.username = username;
		this.password = password;
	}

	@Override
	public Connection getConnection() throws SQLException {
		return getConnection(username, password);
	}

	@Override
	public Connection getConnection(String username, String password) throws SQLException {
		 return doGetConnection(username, password);
	}

	private Connection doGetConnection(String username, String password) throws SQLException {
		initializeDriver();
		Connection connection = DriverManager.getConnection(url, username, password);
	    return connection;
	}

	private synchronized void initializeDriver() throws SQLException {
		if (!registeredDrivers.containsKey(driver)) {
			try {
				Class.forName(driver);
				registeredDrivers.put(driver, true);
			} catch (Exception e) {
				throw new SQLException("Error setting driver on UnpooledDataSource. Cause: " + e);
			}
		}
	}
}

测试类

public class App {
    public static void main( String[] args ) throws Exception {
    	String driver = "com.mysql.jdbc.Driver";
    	String url = "jdbc:mysql://localhost:3306/test?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true";
    	String username = "root";
    	String password = "root";
    	
    	// 1. 使用数据源
    	DataSource dataSource = new UnpooledSourceImpl(driver, url, username, password);
    	Connection connection = dataSource.getConnection();
    	// 3. Statement用以运行SQL语句。下面是一个插入（INSERT）的例子
		Statement stmt = connection.createStatement();
		stmt.executeUpdate("INSERT INTO MyTable( name ) VALUES ( 'my name' ) ");
		// 4. 查询（SELECT）的结果存放于结果集（ResultSet）中，可以按照顺序依次访问
		ResultSet rs = stmt.executeQuery("SELECT * FROM MyTable");
		while (rs.next()) {
			int numColumns = rs.getMetaData().getColumnCount();
			for (int i = 1; i <= numColumns; i++) {
				// 与大部分Java API中下标的使用方法不同，字段的下标从1开始
				// 当然，还有其他很多的方式（ResultSet.getXXX()）获取数据
				System.out.println("COLUMN " + i + " = " + rs.getObject(i));
			}
		}
		rs.close();
		stmt.close();
    }
}

连接池实现

Mybatis连接池代码复用了非连接池实现，下面将展示简要的连接池实现，保持了连接池的核心代码，删除了一些细节处理，这里主要是学习连接池思想

PooledSourceImpl连接池

public class PooledSourceImpl extends SourceImplWrapper {

	private UnpooledDataSource dataSource;

	protected final List<ConnectionProxy> idleConnections = new ArrayList<>();
	protected final List<ConnectionProxy> activeConnections = new ArrayList<>();
	
	protected int timeoutMillis = 20000;
	protected int poolMaximumIdleSize = 5;
	protected int poolMaximumActiveSize = 10;

	public PooledSourceImpl(String driver, String url, String username, String password) {
		dataSource = new UnpooledDataSource(driver, url, username, password);
	}

	@Override
	public Connection getConnection() throws SQLException {
		return popConnection().getProxyConnection();
	}

	@Override
	public Connection getConnection(String username, String password) throws SQLException {
		return dataSource.getConnection(username, password);
	}

	private ConnectionProxy popConnection() throws SQLException {
		ConnectionProxy connectionProxy = null;
		while (connectionProxy == null) {
			synchronized (dataSource) {
				if (!idleConnections.isEmpty()) {
					connectionProxy = idleConnections.remove(0);
				} else {
					if (activeConnections.size() < poolMaximumActiveSize) {
						connectionProxy = new ConnectionProxy(dataSource.getConnection(), this);
						activeConnections.add(connectionProxy);
					} else {
						// Cannot create new connection，尝试从超时connection，尝试回收使用
						ConnectionProxy connection = activeConnections.get(0);
						long useTimestamp = connection.getUseTimestamp();
						// 超时
						if (useTimestamp > timeoutMillis) {
							connectionProxy = connection;
							activeConnections.remove(connection);
							activeConnections.add(connectionProxy);
						} else {
							// Must wait, 等待时间到期，或者主动close释放connection
							//long wt = System.currentTimeMillis();
							try {
								dataSource.wait(5000);
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
							// System.out.println("Waiting as long as " + (System.currentTimeMillis() - wt) + " milliseconds for connection.");
						}
					}
				}
			}
		}
		connectionProxy.setUseTimestamp(System.currentTimeMillis());
		return connectionProxy;
	}

	protected void pushConnection(ConnectionProxy connection) throws SQLException {
		synchronized (dataSource) {
			if (idleConnections.size() < poolMaximumIdleSize) {
				idleConnections.add(connection);
				activeConnections.remove(connection);
				
				dataSource.notifyAll();
			} else {
				connection.getRealConnection().close();
			}
		}
	}
	
	public void printStatus() {
		synchronized (dataSource) {
			StringBuilder builder = new StringBuilder();
			builder.append("\n ---STATUS-----------------------------------------------------");
			builder.append("\n activeConnections              ").append(activeConnections.size());
			builder.append("\n idleConnections                ").append(idleConnections.size());
			builder.append("\n===============================================================");
			System.out.println(builder);
		}
	}

}

返回的代理对象，需要特殊处理关闭连接connection，调用close

public class ConnectionProxy implements InvocationHandler {
	
	private final PooledSourceImpl dataSource;
	private final Connection realConnection;
	private final Connection proxyConnection;
	
	private long useTimestamp; 
	
	public ConnectionProxy(Connection connection, PooledSourceImpl dataSource) {
		this.dataSource = dataSource;
		this.realConnection = connection;
		this.proxyConnection = (Connection) Proxy.newProxyInstance(Connection.class.getClassLoader(), new Class<?>[] { Connection.class }, this);
	}

	public Connection getRealConnection() {
		return realConnection;
	}

	public Connection getProxyConnection() {
		return proxyConnection;
	}
	
	public long getUseTimestamp() {
		return System.currentTimeMillis() - useTimestamp;
	}

	public void setUseTimestamp(long useTimestamp) {
		this.useTimestamp = useTimestamp;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		if ("close".equals(method.getName())) {
			dataSource.pushConnection(this);
			return null;
		} else {
			return method.invoke(realConnection, args);
		}
	}
}

测试类

public class App3 {

	public static void main(String[] args) throws Exception {
		
		String driver = "com.mysql.jdbc.Driver";
    	String url = "jdbc:mysql://localhost:3306/test?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true";
    	String username = "root";
    	String password = "root";
    	
    	// 1. 使用数据源
    	PooledSourceImpl dataSource = new PooledSourceImpl(driver, url, username, password);
    	
    	new Thread(() -> {
			for (int j = 0; j < 100; j++) {
				try {
					Thread.sleep(1000);
				} catch (Exception e) {
					e.printStackTrace();
				}
				dataSource.printStatus();
			}
		}).start();
    	
		for (int i = 0; i < 20; i++) {
			new Thread(() -> {
				for (int j = 0; j < 10; j++) {
					try {
						Connection connection = dataSource.getConnection();
						System.out.println(connection.hashCode());
						Thread.sleep(new Random().nextInt(1000));
						connection.close();
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
			}).start();
		}
	}

}

连接池总结

Mybatis连接池pool设计，十分简单清晰
在这里插入图片描述
完整代码例子

  1. 执行命令从github上面拉取代码：git clone git@github.com:dengjili/mybatis-3-mybatis-3.4.6.git
  2. 相关代码目录src/test/java priv.mybatis.example02.datasource
dengjili
关注
专栏目录
Mybatis连接池
08-16 194
Mybatis连接池 我们在实际开发中都会使用连接池。 因为它可以减少我们获取连接所耗费的时间。 其实，连接池就像一个容器，把连接都初始化出来，然后，放到一个容器里。接下来，我们就从这个容器里取连接，取一个，用一个。 连接池： Mybatis连接池： 三种配置方式： 配置的位置： 主配置文件SqlMapConfig.xml中的dataSource标签，type属性就是表示使用何种连接池方式。 type属性的取值： POOLED 采用传统的javax.sql.DataSource规范中的连
SpringBoot+mybatis+druid+log42实现打印sql日志
图图不糊涂的博客
02-25 4988
我的SpringBoot版本为: 2.1.10.RELEASE 首先在pom文件里面添加jar包，添加了log42，druid，mysql的jar包 <!--log4j2--> <dependency> <groupId>org.springframework.boot</groupId&g...
mybatis的连接池
2301_78008478的博客
05-22 2096
框架而言，数据源的组织是一个非常重要的一部分，这直接影响到框架的性能问题。在底层就相当于和数据库建立的通信连接，在建立通信连接的过程，消耗了这么多的时间，而往往。可以不释放掉资源，而是将它放到内存中，当下次需要操作数据库时，可以直接从内存中取出。的数据源的分类，然后会介绍数据源是如何加载和使用的。计算它的校验时间，如果校验时间大于连接池规定的最大校验时间，则认。好，我们将上述的想法实现，首先定义一个简易连接池。一个线程安全的简易连接池实现，此连接池是单例的。对象创建一个代理对象，代理对象所有的方法都是调。
Mybatis——连接池
紫罗兰与海棠的博客
12-27 2592
一、概述 在实际开发中都会使用连接池，因为连接池可以减少获取连接所消耗的时间。 队列特性：先进先出，正好可以确保拿到的连接对象就是刚刚自己创建的 二、mybatis中的连接池 配置的位置 主配置文件中的dataSoirce标签，type属性表示采用何种连接池方式 type属性的取值 POOLED 采用传统的javax.sql.DataSource规范中的连接池，mybatis中有针对规范的实现 UNPOOLED 采用传统的获取连接的方式，虽然也实现了javax.sql.DataSour
Mybatis 连接池
weixin_44270855的博客
08-05 237
Mybatis的连接池技术 根据已有的知识，我们知道： 连接池就是用于存储连接的一个容器，它可以减少我们获取连接所消耗的时间； 容器其实就是一个集合对象，该集合必须是线程安全的，不能两个线程拿到同一个连接； 该集合还必须实现队列的特性：先进先出。 Mybatis 中也有连接池技术，但它采用的是自己的连接池技术。 1. Mybatis连接池的分类 在 Mybatis 的 主配置文件SqlMapConfig.xml 文件中，通过<dataSource type="xxx">来实现 Mybatis
Mybatis的连接池
weixin_34194379的博客
08-14 953
先总结一个原则：mytatis的连接池最大值poolMaximumActiveConnections尽量跟服务器的并发访问量持平以至于大于并发访问量。 原因：在org.apache.ibatis.datasource.pooled.PooledDataSource中，popConnection函数（获取连接）会锁住一个PoolState对象，push...
配置Spring Boot与MyBatis的连接池
# 1. 介绍Spring Boot和MyBatis - 1.1 什么是Spring Boot？ - 1.2 什么是MyBatis？...我们还会探讨连接池的工作原理，帮助你更好地理解为什么连接池在Spring Boot与MyBatis的配置中是至关重要的。接下来让我们一起深入
Spring+SpringMVC+MyBatis框架的整合+注解
thinkhi9999的博客
08-24 2311
标准主流现在编程方式都是采用MVC综合设计模式，MVC本身不属于设计模式的一种，它描述的是一种结构，最终目的达到解耦，解耦说的意思是你更改某一层代码，不会影响我其它层代码，如果你会像Spring这样的框架，你会了解面向接口编程，表示层调用控制层，控制层调用业务层，业务层调用数据访问层。如果不使用任何框架，而单纯使用Servlet和JDBC技术，甚至只用JSP技术，同样可以实现JAVAWEB的项目开发，但这样的项目具体工作码量大，代码之间的耦合性极强，如果需要调整某一功能 ，出于连锁反应，可能要修改所有的源代
Springboot+Mybatis+Druid多数据源配置
STIll_ly的博客
12-23 1180
1. 新建Springboot项目 根据实际填写 依赖根据实际需要自行选择（此处可不选，接下载可以自己在pom文件中添加）： 选择项目路径，然后点击完成 配置项目结构： 将配置文件该成yml后缀名，看个人习惯，可不改呦 新建controller,mapper等目录，结构如下： 启动成功 2. 配置多数据源 添加Druid依赖： <!-- Druid连接池 -->...
mybatis源码学习之org.apache.ibatis.datasource.jndi包
DemoTransfer
06-26 1620
文章内容和参考博文来源： 1 mybatis源码jar包–package org.apache.ibatis.datasource.jndi; 2 http://blog.csdn.net/reliveit/article/details/45136297 3 http://www.cnblogs.com/V1haoge/p/6675700.html 4 Spring 实战(第
Mybatis-数据库连接池
最新发布
weixin_61605998的博客
07-15 1871
数据库连接池是个容器，负责分配、管理数据库连接(Connection)它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个释放空闲时间超过最大空闲时间的连接，来避免因为没有释放连接而引起的数据库连接遗漏。也就是，如果某个操作占用的连接超出了预定的时间，就会自动释放连接。
druid 配置详细
qq_20336723的博客
04-19 880
1.配置文件参数信息 配置 缺省值 说明 name   配置这个属性的意义在于，如果存在多个数据源，监控的时候可以通过名字来区分开来。  如果没有配置，将会生成一个名字，格式是："DataSource-" + System.identityHashCode(this) jdbcUrl
mybatis连接池
weixin_43919497的博客
02-25 586
1、Mybatis 连接池的分类 Mybatis 将它自己的数据源分为三类： UNPOOLED 不使用连接池的数据源 POOLED 使用连接池的数据源 JNDI 使用 JNDI 实现的数据源 2、Mybatis 中数据源的配置 我们的数据源配置就是在 SqlMapConfig.xml 文件中，具体配置如下： <!-- 配置数据源（连接池）信息 --> <dataSource type="POOLED"> <property name="driver" value="${
mybatis pooled数据连接池
happy_ducks的博客
10-20 144
连接池—Mybatis
小高同学
04-19 2258
Mybatis中采用的自己的连接池技术，在Mybatis的SqlMapConfig.xml配置文件中，通过来实现Mybatis中连接池的配置 一、Mybatis连接池的分类 在Mybatis中我们将他的数据源dateSource分为以下几类 可以看出Mybatis将他自己的数据源分为三类： UNpooled: 不适用连接池的数据源 Pooled： 使用连接池的数据源 JNDI： 使用JND...
MyBatis连接池
qq_45126061的博客
09-08 213
MyBatis中的连接池 MyBatis连接池提供了三种方式的配置： 配置的位置： 主配置文件SqlMapConfig.xml中的dataSource标签，type属性就是采用何种连接池方式 type属性的取值: POOLED 采用传统的javax.sql.DataSource规范中的连接池，MyBatis中有针对规范的实现 UNPOOLED 采用传统的获取连接的方式，虽然也实现Javax.sql.DataSource接口，但是并没有使用池的思想。 JNDI 采用服务器提供的JNDI技术实现，来获取Da
Mybatis中的连接池
weixin_45724872的博客
10-09 2432
连接池概述： 我们在实际开发中都会使用连接池。 因为它可以减少我们获取连接所消耗的时间。 必须是线程安全的,不能让多个线程拿到同一连接 连接池就是一个存储连接的容器,而这个容器是一般采取先进先出的集合实现的 Mybatis中的连接池 配置的位置： 主配置文件SqlMapConfig.xml中的dataSource标签，type属性就是表示采用何种连接池方式。 mybatis连接池提供了3种方式的配置： type属性的取值： POOLED 采用传统的javax.sql.DataSource规范中的连接池，m
阶段3 1.Mybatis_07.Mybatis的连接池及事务_3 mybatis连接池的分类
weixin_30566063的博客
08-07 161
2、mybatis中的连接池 mybatis连接池提供了3种方式的配置： 配置的位置： 主配置文件SqlMapConfig.xml中的dataSource标签，type属性就是表示采用何种连接池方式。 type属性的取值： POOLED 采用传统的javax.sql.Da...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值