mybatis的默认数据源

最新推荐文章于 2024-11-27 22:06:37 发布
最新推荐文章于 2024-11-27 22:06:37 发布
阅读量1k 收藏
点赞数
文章标签： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/yiyilil/article/details/115409628
版权
本文详细探讨了Mybatis框架中默认数据源的工作原理、配置方式及其在实际应用中的优势与限制。通过实例解析，阐述了如何选择和配置适合项目需求的数据源，帮助开发者优化数据库连接管理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

//
// mybatis的数据源
//

package org.apache.ibatis.datasource.pooled;

import java.io.PrintWriter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
import java.util.logging.Logger;
import javax.sql.DataSource;
import org.apache.ibatis.datasource.unpooled.UnpooledDataSource;
import org.apache.ibatis.logging.Log;
import org.apache.ibatis.logging.LogFactory;


public class PooledDataSource implements DataSource {
    private static final Log log = LogFactory.getLog(PooledDataSource.class);
    private final PoolState state = new PoolState(this);
    private final UnpooledDataSource dataSource;
    //连接池最大连接数
    protected int poolMaximumActiveConnections = 10;
    //连接池最大闲置连接数
    protected int poolMaximumIdleConnections = 5;
    //连接池最大检测时间
    protected int poolMaximumCheckoutTime = 20000;
    //连接池等待时间
    protected int poolTimeToWait = 20000;
    
    protected int poolMaximumLocalBadConnectionTolerance = 3;
    
    protected String poolPingQuery = "NO PING QUERY SET";
    
    protected boolean poolPingEnabled;
    
    protected int poolPingConnectionsNotUsedFor;
    
    private int expectedConnectionTypeCode;
//构造方法
    public PooledDataSource() {
        this.dataSource = new UnpooledDataSource();
    }

    public PooledDataSource(UnpooledDataSource dataSource) {
        this.dataSource = dataSource;
    }

    public PooledDataSource(String driver, String url, String username, String password) {
        this.dataSource = new UnpooledDataSource(driver, url, username, password);
        this.expectedConnectionTypeCode = this.assembleConnectionTypeCode(this.dataSource.getUrl(), this.dataSource.getUsername(), this.dataSource.getPassword());
    }

    public PooledDataSource(String driver, String url, Properties driverProperties) {
        this.dataSource = new UnpooledDataSource(driver, url, driverProperties);
        this.expectedConnectionTypeCode = this.assembleConnectionTypeCode(this.dataSource.getUrl(), this.dataSource.getUsername(), this.dataSource.getPassword());
    }

    public PooledDataSource(ClassLoader driverClassLoader, String driver, String url, String username, String password) {
        this.dataSource = new UnpooledDataSource(driverClassLoader, driver, url, username, password);
        this.expectedConnectionTypeCode = this.assembleConnectionTypeCode(this.dataSource.getUrl(), this.dataSource.getUsername(), this.dataSource.getPassword());
    }

    public PooledDataSource(ClassLoader driverClassLoader, String driver, String url, Properties driverProperties) {
        this.dataSource = new UnpooledDataSource(driverClassLoader, driver, url, driverProperties);
        this.expectedConnectionTypeCode = this.assembleConnectionTypeCode(this.dataSource.getUrl(), this.dataSource.getUsername(), this.dataSource.getPassword());
    }

//获取连接
    public Connection getConnection() throws SQLException {
        return this.popConnection(this.dataSource.getUsername(), this.dataSource.getPassword()).getProxyConnection();
    }

    public Connection getConnection(String username, String password) throws SQLException {
        return this.popConnection(username, password).getProxyConnection();
    }

    public void setLoginTimeout(int loginTimeout) {
        DriverManager.setLoginTimeout(loginTimeout);
    }

    public int getLoginTimeout() {
        return DriverManager.getLoginTimeout();
    }

    public void setLogWriter(PrintWriter logWriter) {
        DriverManager.setLogWriter(logWriter);
    }

    public PrintWriter getLogWriter() {
        return DriverManager.getLogWriter();
    }

    public void setDriver(String driver) {
        this.dataSource.setDriver(driver);
        this.forceCloseAll();
    }

    public void setUrl(String url) {
        this.dataSource.setUrl(url);
        this.forceCloseAll();
    }

    public void setUsername(String username) {
        this.dataSource.setUsername(username);
        this.forceCloseAll();
    }

    public void setPassword(String password) {
        this.dataSource.setPassword(password);
        this.forceCloseAll();
    }

    public void setDefaultAutoCommit(boolean defaultAutoCommit) {
        this.dataSource.setAutoCommit(defaultAutoCommit);
        this.forceCloseAll();
    }

    public void setDefaultTransactionIsolationLevel(Integer defaultTransactionIsolationLevel) {
        this.dataSource.setDefaultTransactionIsolationLevel(defaultTransactionIsolationLevel);
        this.forceCloseAll();
    }

    public void setDriverProperties(Properties driverProps) {
        this.dataSource.setDriverProperties(driverProps);
        this.forceCloseAll();
    }

    public void setDefaultNetworkTimeout(Integer milliseconds) {
        this.dataSource.setDefaultNetworkTimeout(milliseconds);
        this.forceCloseAll();
    }

    public void setPoolMaximumActiveConnections(int poolMaximumActiveConnections) {
        this.poolMaximumActiveConnections = poolMaximumActiveConnections;
        this.forceCloseAll();
    }

    public void setPoolMaximumIdleConnections(int poolMaximumIdleConnections) {
        this.poolMaximumIdleConnections = poolMaximumIdleConnections;
        this.forceCloseAll();
    }

    public void setPoolMaximumLocalBadConnectionTolerance(int poolMaximumLocalBadConnectionTolerance) {
        this.poolMaximumLocalBadConnectionTolerance = poolMaximumLocalBadConnectionTolerance;
    }

    public void setPoolMaximumCheckoutTime(int poolMaximumCheckoutTime) {
        this.poolMaximumCheckoutTime = poolMaximumCheckoutTime;
        this.forceCloseAll();
    }

    public void setPoolTimeToWait(int poolTimeToWait) {
        this.poolTimeToWait = poolTimeToWait;
        this.forceCloseAll();
    }

    public void setPoolPingQuery(String poolPingQuery) {
        this.poolPingQuery = poolPingQuery;
        this.forceCloseAll();
    }

    public void setPoolPingEnabled(boolean poolPingEnabled) {
        this.poolPingEnabled = poolPingEnabled;
        this.forceCloseAll();
    }

    public void setPoolPingConnectionsNotUsedFor(int milliseconds) {
        this.poolPingConnectionsNotUsedFor = milliseconds;
        this.forceCloseAll();
    }

    public String getDriver() {
        return this.dataSource.getDriver();
    }

    public String getUrl() {
        return this.dataSource.getUrl();
    }

    public String getUsername() {
        return this.dataSource.getUsername();
    }

    public String getPassword() {
        return this.dataSource.getPassword();
    }

    public boolean isAutoCommit() {
        return this.dataSource.isAutoCommit();
    }

    public Integer getDefaultTransactionIsolationLevel() {
        return this.dataSource.getDefaultTransactionIsolationLevel();
    }

    public Properties getDriverProperties() {
        return this.dataSource.getDriverProperties();
    }

    public Integer getDefaultNetworkTimeout() {
        return this.dataSource.getDefaultNetworkTimeout();
    }

    public int getPoolMaximumActiveConnections() {
        return this.poolMaximumActiveConnections;
    }

    public int getPoolMaximumIdleConnections() {
        return this.poolMaximumIdleConnections;
    }

    public int getPoolMaximumLocalBadConnectionTolerance() {
        return this.poolMaximumLocalBadConnectionTolerance;
    }

    public int getPoolMaximumCheckoutTime() {
        return this.poolMaximumCheckoutTime;
    }

    public int getPoolTimeToWait() {
        return this.poolTimeToWait;
    }

    public String getPoolPingQuery() {
        return this.poolPingQuery;
    }

    public boolean isPoolPingEnabled() {
        return this.poolPingEnabled;
    }

    public int getPoolPingConnectionsNotUsedFor() {
        return this.poolPingConnectionsNotUsedFor;
    }

//强制关闭所有连接
    public void forceCloseAll() {
        PoolState var1 = this.state;
        synchronized(this.state) {
            this.expectedConnectionTypeCode = this.assembleConnectionTypeCode(this.dataSource.getUrl(), this.dataSource.getUsername(), this.dataSource.getPassword());

            int i;
            PooledConnection conn;
            Connection realConn;
            for(i = this.state.activeConnections.size(); i > 0; --i) {
                try {
                    conn = (PooledConnection)this.state.activeConnections.remove(i - 1);
                    conn.invalidate();
                    realConn = conn.getRealConnection();
                    if (!realConn.getAutoCommit()) {
                        realConn.rollback();
                    }

                    realConn.close();
                } catch (Exception var7) {
                    ;
                }
            }

            for(i = this.state.idleConnections.size(); i > 0; --i) {
                try {
                    conn = (PooledConnection)this.state.idleConnections.remove(i - 1);
                    conn.invalidate();
                    realConn = conn.getRealConnection();
                    if (!realConn.getAutoCommit()) {
                        realConn.rollback();
                    }

                    realConn.close();
                } catch (Exception var6) {
                    ;
                }
            }
        }

        if (log.isDebugEnabled()) {
            log.debug("PooledDataSource forcefully closed/removed all connections.");
        }

    }
//获取连接池状态
    public PoolState getPoolState() {
        return this.state;
    }
//获取连接的哈希码
    private int assembleConnectionTypeCode(String url, String username, String password) {
        return ("" + url + username + password).hashCode();
    }
//归还连接池的连接
    protected void pushConnection(PooledConnection conn) throws SQLException {
        PoolState var2 = this.state;
        synchronized(this.state) {
            this.state.activeConnections.remove(conn);
            if (conn.isValid()) {
                if (this.state.idleConnections.size() < this.poolMaximumIdleConnections && conn.getConnectionTypeCode() == this.expectedConnectionTypeCode) {
                    this.state.accumulatedCheckoutTime += conn.getCheckoutTime();
                    if (!conn.getRealConnection().getAutoCommit()) {
                        conn.getRealConnection().rollback();
                    }

                    PooledConnection newConn = new PooledConnection(conn.getRealConnection(), this);
                    this.state.idleConnections.add(newConn);
                    newConn.setCreatedTimestamp(conn.getCreatedTimestamp());
                    newConn.setLastUsedTimestamp(conn.getLastUsedTimestamp());
                    conn.invalidate();
                    if (log.isDebugEnabled()) {
                        log.debug("Returned connection " + newConn.getRealHashCode() + " to pool.");
                    }

                    this.state.notifyAll();
                } else {
                    this.state.accumulatedCheckoutTime += conn.getCheckoutTime();
                    if (!conn.getRealConnection().getAutoCommit()) {
                        conn.getRealConnection().rollback();
                    }

                    conn.getRealConnection().close();
                    if (log.isDebugEnabled()) {
                        log.debug("Closed connection " + conn.getRealHashCode() + ".");
                    }

                    conn.invalidate();
                }
            } else {
                if (log.isDebugEnabled()) {
                    log.debug("A bad connection (" + conn.getRealHashCode() + ") attempted to return to the pool, discarding connection.");
                }

                ++this.state.badConnectionCount;
            }

        }
    }

//弹出一个连接
    private PooledConnection popConnection(String username, String password) throws SQLException {
        boolean countedWait = false;
        PooledConnection conn = null;
        long t = System.currentTimeMillis();
        int localBadConnectionCount = 0;

        while(conn == null) {
        //PoolState 记录了连接池状态
            PoolState var8 = this.state;
            synchronized(this.state) {
            	//闲置的连接不为空时，返回一个连接
                if (!this.state.idleConnections.isEmpty()) {
               		 //闲置连接List中移除一个记录
                    conn = (PooledConnection)this.state.idleConnections.remove(0);
                    if (log.isDebugEnabled()) {
                        log.debug("Checked out connection " + conn.getRealHashCode() + " from pool.");
                    }
                } else if (this.state.activeConnections.size() < this.poolMaximumActiveConnections) {
                //闲置连接为0但是活跃连接小于最大活跃数时，生成一个连接
                    conn = new PooledConnection(this.dataSource.getConnection(), this);
                    if (log.isDebugEnabled()) {
                        log.debug("Created connection " + conn.getRealHashCode() + ".");
                    }
                } else {
                //闲置连接为0但是活跃连接不小于最大活跃数时
                    PooledConnection oldestActiveConnection = (PooledConnection)this.state.activeConnections.get(0);
                    long longestCheckoutTime = oldestActiveConnection.getCheckoutTime();
                    if (longestCheckoutTime > (long)this.poolMaximumCheckoutTime) {
                        ++this.state.claimedOverdueConnectionCount;
                        this.state.accumulatedCheckoutTimeOfOverdueConnections += longestCheckoutTime;
                        this.state.accumulatedCheckoutTime += longestCheckoutTime;
                        this.state.activeConnections.remove(oldestActiveConnection);
                        if (!oldestActiveConnection.getRealConnection().getAutoCommit()) {
                            try {
                                oldestActiveConnection.getRealConnection().rollback();
                            } catch (SQLException var15) {
                                log.debug("Bad connection. Could not roll back");
                            }
                        }

                        conn = new PooledConnection(oldestActiveConnection.getRealConnection(), this);
                        conn.setCreatedTimestamp(oldestActiveConnection.getCreatedTimestamp());
                        conn.setLastUsedTimestamp(oldestActiveConnection.getLastUsedTimestamp());
                        oldestActiveConnection.invalidate();
                        if (log.isDebugEnabled()) {
                            log.debug("Claimed overdue connection " + conn.getRealHashCode() + ".");
                        }
                    } else {
                        try {
                            if (!countedWait) {
                                ++this.state.hadToWaitCount;
                                countedWait = true;
                            }

                            if (log.isDebugEnabled()) {
                                log.debug("Waiting as long as " + this.poolTimeToWait + " milliseconds for connection.");
                            }

                            long wt = System.currentTimeMillis();
                            this.state.wait((long)this.poolTimeToWait);
                            this.state.accumulatedWaitTime += System.currentTimeMillis() - wt;
                        } catch (InterruptedException var16) {
                            break;
                        }
                    }
                }

                if (conn != null) {
                    if (conn.isValid()) {
                        if (!conn.getRealConnection().getAutoCommit()) {
                            conn.getRealConnection().rollback();
                        }

                        conn.setConnectionTypeCode(this.assembleConnectionTypeCode(this.dataSource.getUrl(), username, password));
                        conn.setCheckoutTimestamp(System.currentTimeMillis());
                        conn.setLastUsedTimestamp(System.currentTimeMillis());
                        this.state.activeConnections.add(conn);
                        ++this.state.requestCount;
                        this.state.accumulatedRequestTime += System.currentTimeMillis() - t;
                    } else {
                        if (log.isDebugEnabled()) {
                            log.debug("A bad connection (" + conn.getRealHashCode() + ") was returned from the pool, getting another connection.");
                        }

                        ++this.state.badConnectionCount;
                        ++localBadConnectionCount;
                        conn = null;
                        if (localBadConnectionCount > this.poolMaximumIdleConnections + this.poolMaximumLocalBadConnectionTolerance) {
                            if (log.isDebugEnabled()) {
                                log.debug("PooledDataSource: Could not get a good connection to the database.");
                            }

                            throw new SQLException("PooledDataSource: Could not get a good connection to the database.");
                        }
                    }
                }
            }
        }

        if (conn == null) {
            if (log.isDebugEnabled()) {
                log.debug("PooledDataSource: Unknown severe error condition.  The connection pool returned a null connection.");
            }

            throw new SQLException("PooledDataSource: Unknown severe error condition.  The connection pool returned a null connection.");
        } else {
            return conn;
        }
    }

//ping连接？？
    protected boolean pingConnection(PooledConnection conn) {
        boolean result = true;

        try {
            result = !conn.getRealConnection().isClosed();
        } catch (SQLException var21) {
            if (log.isDebugEnabled()) {
                log.debug("Connection " + conn.getRealHashCode() + " is BAD: " + var21.getMessage());
            }

            result = false;
        }

        if (result && this.poolPingEnabled && this.poolPingConnectionsNotUsedFor >= 0 && conn.getTimeElapsedSinceLastUse() > (long)this.poolPingConnectionsNotUsedFor) {
            try {
                if (log.isDebugEnabled()) {
                    log.debug("Testing connection " + conn.getRealHashCode() + " ...");
                }

                Connection realConn = conn.getRealConnection();
                Statement statement = realConn.createStatement();
                Throwable var5 = null;

                try {
                    statement.executeQuery(this.poolPingQuery).close();
                } catch (Throwable var18) {
                    var5 = var18;
                    throw var18;
                } finally {
                    if (statement != null) {
                        if (var5 != null) {
                            try {
                                statement.close();
                            } catch (Throwable var17) {
                                var5.addSuppressed(var17);
                            }
                        } else {
                            statement.close();
                        }
                    }

                }

                if (!realConn.getAutoCommit()) {
                    realConn.rollback();
                }

                result = true;
                if (log.isDebugEnabled()) {
                    log.debug("Connection " + conn.getRealHashCode() + " is GOOD!");
                }
            } catch (Exception var20) {
                log.warn("Execution of ping query '" + this.poolPingQuery + "' failed: " + var20.getMessage());

                try {
                    conn.getRealConnection().close();
                } catch (Exception var16) {
                    ;
                }

                result = false;
                if (log.isDebugEnabled()) {
                    log.debug("Connection " + conn.getRealHashCode() + " is BAD: " + var20.getMessage());
                }
            }
        }

        return result;
    }

    public static Connection unwrapConnection(Connection conn) {
        if (Proxy.isProxyClass(conn.getClass())) {
            InvocationHandler handler = Proxy.getInvocationHandler(conn);
            if (handler instanceof PooledConnection) {
                return ((PooledConnection)handler).getRealConnection();
            }
        }

        return conn;
    }

//实现资源清理工作：关闭连接池，垃圾回收（不可靠的）
    protected void finalize() throws Throwable {
        this.forceCloseAll();
        super.finalize();
    }

    public <T> T unwrap(Class<T> iface) throws SQLException {
        throw new SQLException(this.getClass().getName() + " is not a wrapper.");
    }

    public boolean isWrapperFor(Class<?> iface) {
        return false;
    }

    public Logger getParentLogger() {
        return Logger.getLogger("global");
    }
}
撷星河
关注
MyBatis多数据源配置及动态切换——搭建多个数据源并动态切换
AI天才研究院
07-29 3925
随着互联网的蓬勃发展，网站的用户量和访问量越来越大，单个数据库已经无法承受如此巨大的访问量，而更好的解决方案是将数据分布到多个数据库服务器上，并通过读写分离的方式提高数据库负载能力和提升整体性能。为了实现这一目标，目前最流行的一种方式是使用读写分离的数据库架构模式。在这种架构模式下，应用层的数据请求会路由到主库或从库，由主库对数据进行写操作（INSERT、UPDATE等）后，同步给从库，保证主库中的数据的一致性。相比于单个数据库服务器，采用读写分离的架构模式最大的优点就是增加了灵活性。
mybatis 源码系列(五) 数据源DataSource
八一菜刀的专栏
05-17 1526
更多mybatis 源码系列文章可关注我的博客,点击前往 在第四章节中,我们分析里数据库驱动Driver的加载方式,其中有提到mybatis的数据源，我们都知道,Java中的SQL规范java.sql.DataSource是一个接口,而我们在生产环境中一般都是基于数据库的连接池技术来获取数据库连接以操作数据库的. 通常为我们所知的主流数据源主要有：druid、c3p0、dbcp,HikariC...
mybatis默认的数据源连接池（PooledDataSource和UnPooledDataSource）
巡山小妖008
06-28 3431
一般情况下我们操作数据库都是通过connection，但是频繁创建和删除connection会严重影响效率，因此在这种情况下我们一般会用到连接池，因为项目中用到的是mybatis，所以了解一下mybatis的默认的数据库连接池（大多数情况下我们会使用Durid连接池） 代码路径： 很明显看到datasource目录下有pooled和unpooled两个目录，分别是使用到了连接池和没有用到 ...
MyBatis数据源
web开发
07-18 273
dataSource 元素使用基本的 JDBC 数据源接口来配置 JDBC 连接对象的资源。 有三种内建的数据源类型（type）： 1、UNPOOLED – 这个数据源的实现是每次被请求时简单打开和关闭连接。它有一点慢,这是对简单应用程序的一个很好的选择,因为它不需要及时的可用连接。不同的数据库对这个的表现也是不一样的,所以对某些数据库来说配置数据源并不重要,这个配置也是闲置的。UNPOOLE...
[Mybatis]-[基础支持层]-数据源信息-数据源详解
保持敏感！保持学习！
10-20 268
该系列文章针对 Mybatis 3.5.1 版本 在上一篇文章中，谈到了<environment>标签解析会构建Environment对象，Environment对象中有两个关键属性对象：TransactionFactory和DataSource。 本章重点来讲解一下DataSource相关实现类 一、回顾 首先来回顾一下XMLConfigBuilder中构建DataSource的相关代码，如下图： 通过读取配置文件<dataSource t...
java was datasource_mybatis默认的数据源连接池（PooledDataSource和UnPooledDataSource）
weixin_35087326的博客
02-20 387
public classPooledDataSource implements DataSource {private static final Log log = LogFactory.getLog(PooledDataSource.class);//PollState 充当锁对象，这个对象中也有例如 空闲连接集合，活跃链接集合，请求的数量，等一些变量private final PoolSta...
mybatis内置数据源
11-15 451
在jdbc中，我们可以通过DriverManager的getConnection方法来获取数据库连接，但是这种方式会去查找相应的驱动，然后与数据库地址建立真实的连接，因此比较耗时。如果在应用中存在大量的连接数据库操作，那么这种方式的效率将会非常低下。为了解决这个问题，数据源的技术应运而生，所谓...
Spring Boot + Mybatis多数据源和动态数据源配置方法
08-28
总结来说，Spring Boot结合Mybatis的多数据源配置涉及禁用默认数据源、配置多个数据源、创建对应的SqlSessionFactory，以及在必要时实现动态数据源切换。这样的配置能灵活地处理复杂的企业级应用中与多个数据库交互...
springboot + mybatis 多数据源demo
12-10
Spring Boot结合MyBatis框架提供了一种优雅的方式来处理多数据源的配置和切换，以满足不同业务需求。本文将深入探讨如何使用Spring Boot与MyBatis实现多数据源的示例。 1. **Spring Boot简介** Spring Boot是...
1、SpringBoo中Mybatis多数据源动态切换
最新发布
advent86的专栏
11-27 2068
Springboot,，数据源动态切换，mybatis动态创建数据源及动态切换数据源
mybatis数据源
zxs123csdn的博客
10-18 397
一:JNDI:(Java Naming and Directory) 1,由一个初始的命名上下文(context)及其下的任意数目的子上下文组成 2,JNDI名称空间是分层次的,与很多文件系统的目录/文件结构类似 3,初始上下文与文件系统的根类似,子上下文与子目录类似 4,JNDI层次的根是初始化上下文 5,在初始化上下文下有很多子上下文,其中之一就是jdbc 6,jdbc是子上下文保
Mybatis数据源配置
fangfengzhen115的专栏
01-06 630
Mybatis数据源配置
MyBatis配置数据源的两种方式
热门推荐
siwuxie095's blog
10-31 1万+
---------------------siwuxie095                            MyBatis 配置数据源的两种方式       1、配置方式一：配置数据库连接信息到核心配置文件中    在 mybatis-config.xml 中添加如下内容：     version="1.0"
Mybatis深入：数据源概念介绍
Leon_Jinhai_Sun的博客
08-07 376
Mybatis深入：数据源概念介绍
mybatis配置mysql连接数_springBoot配置mybatis链接数据库
weixin_42449339的博客
01-27 1799
springBoot配置mybatis链接数据库添加pom包,修改 pom.xml 文件org.mybatis.generatormybatis-generator-core1.3.5org.mybatis.spring.bootmybatis-spring-boot-starter1.3.2mysqlmysql-connector-java修改配置文件application.yml#启动端口se...
Mybatis-数据库连接池
weixin_61605998的博客
07-15 2111
数据库连接池是个容器，负责分配、管理数据库连接(Connection)它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个释放空闲时间超过最大空闲时间的连接，来避免因为没有释放连接而引起的数据库连接遗漏。也就是，如果某个操作占用的连接超出了预定的时间，就会自动释放连接。
Mybatis-Plus源码解析之MybatisPlusAutoConfiguration(二)
于琦海
12-12 2366
mybatis-plus源码解析MybatisPlusAutoConfiguration
MyBatis
abc98526的博客
05-01 1182
前置环境: JDK18 8.0.27 maven 3.8.5 IDEA 1，简介 1.1，什么是MyBatis MyBatis 是一款优秀的持久层框架 它支持自定义 SQL、存储过程以及高级映射。 MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。 MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。 MyBatis本是.
MyBatis---连接池
jlihan的博客
11-26 698
1.总结每次使用数据库的数据都需要自己连接和销毁连接，这样是比较消耗时间，资源的。直接从连接池获取连接，不使用了再归还到连接池中，节省创建连接与释放，性能消耗。连接池中的连接起到复用的作用，提升程序性能。2.连接池（池参数，如果不指定，有默认值）初始大小：10个最小空闲连接数：3个增量：一次创建的最小单位（5个）最大连接数：20ge最大的等待时间：1000毫秒3.4个参数：任何的开源的连接池，4大参数都需要自己来设置用户名：root密码：rootDataSource。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值