mybatis连接池和多表操作实现分析3

最新推荐文章于 2023-08-30 08:51:42 发布
最新推荐文章于 2023-08-30 08:51:42 发布
阅读量169 收藏
点赞数
分类专栏： Mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35426012/article/details/105972044
版权

mybatis连接池实现分析

mybatis数据源分类
 <!-- 配置连接数据库的信息：用的是数据源(连接池) -->
            <dataSource type="POOLED">
                <property name="driver"     value="${jdbc.driver}"/>
                <property name="url"        value="${jdbc.url}"/>
                <property name="username"   value="${jdbc.username}"/>
                <property name="password"   value="${jdbc.password}"/>
            </dataSource>
  • 可以看出 Mybatis 将它自己的数据源分为三类：
    • type=”POOLED”：MyBatis 会创建 PooledDataSource 实例(使用连接池的数据源,创建新连接的时候使用的就是UnpooledDataSource）
    • type=”UNPOOLED” ： MyBatis 会创建UnpooledDataSource 实例POOLED (不使用连接池的数据源，有连接就创建一个新连接)
    • JNDI 使用 JNDI 实现的数据源
      如下图
      在这里插入图片描述
PooledDataSource分析

mybatis连接池源码逻辑在PooledDataSource类中的popConnection
方法
代码如下

// 从连接池中获取连接
  private PooledConnection popConnection(String username, String password) throws SQLException {
    // 等待的个数
    boolean countedWait = false;
    // PooledConnection 对象
    PooledConnection conn = null;
    long t = System.currentTimeMillis();
    // 无效的连接个数
    int localBadConnectionCount = 0;

    while (conn == null) {
      synchronized (state) {
        // 检测是否还有空闲的连接
        if (!state.idleConnections.isEmpty()) {
          // 连接池中还有空闲的连接，则直接获取连接返回
          conn = state.idleConnections.remove(0);
        } else {
          // 连接池中已经没有空闲连接了
          if (state.activeConnections.size() < poolMaximumActiveConnections) {
            // 活跃的连接数没有达到最大值，则创建一个新的数据库连接
            conn = new PooledConnection(dataSource.getConnection(), this);
          } else {
            // 如果活跃的连接数已经达到允许的最大值了，则不能创建新的数据库连接
            // 获取最先创建的那个活跃的连接
            PooledConnection oldestActiveConnection = state.activeConnections.get(0);
            long longestCheckoutTime = oldestActiveConnection.getCheckoutTime();
            // 检测该连接是否超时
            if (longestCheckoutTime > poolMaximumCheckoutTime) {
              // 如果该连接超时，则进行相应的统计
              state.claimedOverdueConnectionCount++;
              state.accumulatedCheckoutTimeOfOverdueConnections += longestCheckoutTime;
              state.accumulatedCheckoutTime += longestCheckoutTime;
              // 将超时连接移出 activeConnections 集合
              state.activeConnections.remove(oldestActiveConnection);
              if (!oldestActiveConnection.getRealConnection().getAutoCommit()) {
                  // 如果超时未提交，则自动回滚
                  oldestActiveConnection.getRealConnection().rollback();
              }
              // 创建新的 PooledConnection 对象，但是真正的数据库连接并没有创建
              conn = new PooledConnection(oldestActiveConnection.getRealConnection(), this);
              conn.setCreatedTimestamp(oldestActiveConnection.getCreatedTimestamp());
              conn.setLastUsedTimestamp(oldestActiveConnection.getLastUsedTimestamp());
              // 设置该超时的连接为无效
              oldestActiveConnection.invalidate();
            } else {
               // 如果无空闲连接，无法创建新的连接且无超时连接，则只能阻塞等待
              // Must wait
              try {
                if (!countedWait) {
                  state.hadToWaitCount++; // 等待次数
                  countedWait = true;
                }
                long wt = System.currentTimeMillis();
                // 阻塞等待
                state.wait(poolTimeToWait);
                state.accumulatedWaitTime += System.currentTimeMillis() - wt;
              } catch (InterruptedException e) {
                break;
              }
            }
          }
        }
        // 已经获取到连接
        if (conn != null) {
          if (conn.isValid()) {
            // 如果连连接有效，事务未提交则回滚
            if (!conn.getRealConnection().getAutoCommit()) {
              conn.getRealConnection().rollback();
            }
            // 设置 PooledConnection 相关属性
            conn.setConnectionTypeCode(assembleConnectionTypeCode(dataSource.getUrl(), username, password));
            conn.setCheckoutTimestamp(System.currentTimeMillis());
            conn.setLastUsedTimestamp(System.currentTimeMillis());
            // 把连接加入到活跃集合中去
            state.activeConnections.add(conn);
            state.requestCount++;
            state.accumulatedRequestTime += System.currentTimeMillis() - t;
          } else {
            // 无效连接
            state.badConnectionCount++;
            localBadConnectionCount++;
            conn = null;
          }
        }
      }
    }
    return conn;
  }

代码分析如下图
在这里插入图片描述
图片分析如下：

  1. 判断连接池是否还有空闲的连接

    1. 如果连接池中还有空闲的连接，则直接获取连接返回

    2. 如果没有则判断活跃的连接数有没有达到最大值

      3.1 如果没有则创建一个新的数据库连接，如果新建的连接无效则抛出异常，有效则放进连接池中

      3.2 如果有的话不能创建连接了这时候则获取最先创建的那个活跃的连接判断该连接是否超时，
      3.2.1. 如果超时则移出连接后继续3.1步骤（创建新连接）
      3.2.2. 如果无空闲连接，无法创建新的连接且无超时连接，则只能阻塞等

Mybatis的动态SQL语句

我们根据实体类的不同取值，使用不同的 SQL 语句来进行查询。比如在 id 如果不为空时可以根据 id 查询，如果 username 不同空时还要加入用户名作为条件。这种情况在我们的多条件组合查询中经常会碰到

  1. 动态 SQL 之 if 标签
    IUserDao.java
    List<User> findByUser(User user);

IUserDao.xml

    <select id="findByUser" resultType="org.example.User" parameterType="org.example.User">
        select * from user where 1=1
        <if test="username!=null and username != '' ">
            and username like #{username}
        </if>
        <if test="address != null">
             and address like #{address}
        </if>

    </select>

或者用where标签代替where 1=1

 	<select id="findByUser" resultType="org.example.User" parameterType="org.example.User">
        select * from user
        <where>
            <if test="username!=null and username != '' ">
                and username like #{username}
            </if>
            <if test="address != null">
                and address like #{address}
            </if>
        </where>
    </select>

注意：标签的 test 属性中写的是对象的属性名，如果是包装类的对象要使用 OGNL 表达式的写法。
另外要注意 where 1=1 的作用

测试

 @Test
    public void testFindByUser()throws Exception {
        User userTemp=new User();
        userTemp.setUsername("%王%");
        userTemp.setAddress("%燕%");
        //6.使用代理对象执行查询所有方法
        List<User> users= iUserDao.findByUser(userTemp);
        for (User user:users){
            System.out.println(user);
        }

    }
  1. 动态 SQL 之foreach 标签

查询条件QueryVo .java

package org.example;

import java.io.Serializable;
import java.util.List;

public class QueryVo implements Serializable {
    private List<Integer> ids;

    public List<Integer> getIds() {
        return ids;
    }

    public void setIds(List<Integer> ids) {
        this.ids = ids;
    }


}

IUserDao.java

List<User> findInIds(QueryVo vo);

持久层 Dao 映射配置IUserDao.xml

    <!-- 抽取重复的sql语句-->
    <sql id="defaultSql">
        select * from user
    </sql>

    <select id="findInIds" resultType="org.example.User" parameterType="org.example.QueryVo">
    <!-- select * from user where id in (x,x,x,x); -->
        <include refid="defaultSql"></include>
        <where>
           <foreach collection="ids" open="id in(" close=")" item="uid" separator=",">
               #{uid}
           </foreach>
        </where>
    </select>
    SQL 语句：
    select 字段 from user where id in (?)
    <foreach>标签用于遍历集合，它的属性：
    collection:代表要遍历的集合元素，注意编写时不要写#{}
    open:代表语句的开始部分
    close:代表结束部分
    item:代表遍历集合的每个元素，生成的变量名
    sperator:代表分隔符

测试

public void testFindInIds()throws Exception {
        QueryVo queryVo=new QueryVo();
        List<Integer> ids=new ArrayList<Integer>();
        ids.add(45);
        ids.add(46);
        ids.add(48);
        queryVo.setIds(ids);
        //6.使用代理对象执行查询所有方法
        List<User> users= iUserDao.findInIds(queryVo);
        for (User user:users){
            System.out.println(user);
        }

    }

Mybatis的多表查询

1对1查询

查询所有账户信息，关联查询下单用户信息

方式一：
定义Account实体类

package org.example;

import java.io.Serializable;

public class Account implements Serializable {
    private Integer id;
    private Integer uid;
    private Double money;
    //从表实体应该包含一个主表实体的对象引用
    private User myUser;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getUid() {
        return uid;
    }

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    public User getMyUser() {
        return myUser;
    }

    public void setMyUser(User myUser) {
        this.myUser = myUser;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", uid=" + uid +
                ", money=" + money +
                ", username=" + myUser.getUsername() +
                ", address=" + myUser.getAddress() +
                '}';
    }
}

定义接口IAccountDao.java

package dao;

import org.example.Account;
import org.example.AccountUser;

import java.util.List;

public interface IAccountDao {
    //List<AccountUser> findAll();
    List<Account> findAllAccount();
}

定义 AccountDao.xml 文件中的查询配置信息
因为我配置了别名所以在AccountDao.xml 不需要写全限定类名

    <!-- 建立对应关系 -->
    <resultMap type="Account" id="accountMap">
        <id column="aid" property="id"/>
        <result column="uid" property="uid"/>
        <result column="money" property="money"/>
        <!-- 它是用于指定从表方的引用实体属性的 property是Account实体类型中对应的属性 -->
        <association property="myUser" javaType="User">
            <id column="id" property="id"/>
            <result column="username" property="username"/>
            <result column="sex" property="sex"/>
            <result column="birthday" property="birthday"/>
            <result column="address" property="address"/>
        </association>
    </resultMap>

    <!-- 配置查询所有操作-->
    <select id="findAllAccount" resultMap="accountMap">
        select u.*,a.id as aid,a.uid,a.money from account a,user u where a.uid =u.id;
    </select>

测试类

@Test
    public void testFindAllAccount()throws Exception {
        List<Account> accountUsers=iAccountDao.findAllAccount();
        for (Account accountUser:accountUsers){
            System.out.println(accountUser);
        }

    }

方式二：
定义一个实体类AccountUser来对应你需要查询的两张表需要的字段

package org.example;

import java.io.Serializable;

public class AccountUser extends Account implements Serializable {
    private String username;
    private String address;

    public String getUsername() {
        return username;
    }

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

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return super.toString() + "AccountUser{" +
                "username='" + username + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

修改接口方法

public interface IAccountDao {
    List<AccountUser> findAll();
   
}

重新定义 AccountDao.xml 文件

<!-- 配置查询所有操作-->
    <select id="findAll" resultType="AccountUser">
        select a.*,u.username,u.address from account a,user u where a.uid =u.id;
    </select>

测试

 @Test
    public void testFindAll()throws Exception {
        List<AccountUser> accountUsers=iAccountDao.findAll();
        for (AccountUser accountUser:accountUsers){
            System.out.println(accountUser);
        }
    }
1对多查询

查询所有用户信息及用户关联的账户信息

 User 类 加入 List<Account>
 package org.example;

import java.io.Serializable;
import java.util.Date;
import java.util.List;

public class User implements Serializable {
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
    private List<Account> accounts;

    public List<Account> getAccounts() {
        return accounts;
    }

    public void setAccounts(List<Account> accounts) {
        this.accounts = accounts;
    }



    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

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

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", birthday=" + birthday +
                ", sex='" + sex + '\'' +
                ", address='" + address + '\'' +
                '}';
    }

}

用户持久层 Dao 接口 中加入查询方法

public interface IUserDao {
    /**
     * 查询所有用户
     */
    List<User> findAll();
}

用户持久层 Dao 映射文件 配置

collection
部分定义了用户关联的账户信息。表示关联查询结果集
property="accList" ：
关联查询的结果集存储在 User 对象的上哪个属性。
ofType="account" ：
指定关联查询的结果集中的对象类型即List中的对象类型。此处可以使用别名，也可以使用全限定名

 <resultMap type="User" id="userMap">
        <id column="id" property="id"></id>
        <result column="username" property="username"/>
        <result column="address" property="address"/>
        <result column="sex" property="sex"/>
        <result column="birthday" property="birthday"/>
        <!-- collection 是用于建立一对多中集合属性的对应关系
        ofType 用于指定集合元素的数据类型
        -->
        <collection property="accounts" ofType="account">
            <id column="aid" property="id"/>
            <result column="uid" property="uid"/>
            <result column="money" property="money"/>
        </collection>
    </resultMap>

    <!-- 配置查询所有操作 -->
    <select id="findAll" resultMap="userMap">
        select u.*,a.id as aid ,a.uid,a.money from user u left outer join account
        a on u.id =a.uid
    </select>

测试方法

@Test
    public void testFindAll()throws Exception {
        List<User> users=iUserDao.findAll();
       for (User user:users){
           System.out.println("-------每个用户的信息---------");
           System.out.println(user);
           System.out.println(user.getAccounts());

       }

    }
Mybatis 多 表查询之 多 对多

编写角色实体类Role

package org.example;

import java.io.Serializable;
import java.util.List;

public class Role implements Serializable {

    private Integer roleId;
    private String roleName;
    private String roleDesc;

    //多对多的关系映射：一个角色可以赋予多个用户
    private List<User> users;

    public Integer getRoleId() {
        return roleId;
    }

    public void setRoleId(Integer roleId) {
        this.roleId = roleId;
    }

    public String getRoleName() {
        return roleName;
    }

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }

    public List<User> getUsers() {
        return users;
    }

    public void setUsers(List<User> users) {
        this.users = users;
    }

    public String getRoleDesc() {
        return roleDesc;
    }

    public void setRoleDesc(String roleDesc) {
        this.roleDesc = roleDesc;
    }

    @Override
    public String toString() {
        return "Role{" +
                "roleId=" + roleId +
                ", roleName='" + roleName + '\'' +
                ", roleDesc='" + roleDesc + '\'' +
                '}';
    }

}

编写 Role 持久层 接口

package dao;

import org.example.Role;

import java.util.List;

public interface IRoleDao {
    List<Role> findAll();
}

编写映射文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="dao.IRoleDao">
    <!--定义 role 表的 ResultMap-->
    <resultMap id="roleMap" type="role">
        <id property="roleId" column="rid"></id>
        <result property="roleName" column="role_name"></result>
        <result property="roleDesc" column="role_desc"></result>
        <collection property="users" ofType="user">
            <id column="id" property="id"></id>
            <result column="username" property="username"></result>
            <result column="address" property="address"></result>
            <result column="sex" property="sex"></result>
            <result column="birthday" property="birthday"></result>
        </collection>
    </resultMap>

    <!--查询所有-->
    <select id="findAll" resultMap="roleMap">
        select u.*,r.id as rid,r.role_name,r.role_desc from role r
        left outer join user_role ur on r.id = ur.rid
        left outer join user u on u.id = ur.uid
    </select>
</mapper>

测试

@Test
    public void testFindAll()throws Exception {
        List<Role> roles=iRoleDao.findAll();
       for (Role role:roles){
           System.out.println("-------每个角色的信息---------");
           System.out.println(role);
           System.out.println(role.getUsers());
       }

    }
code_greenhand
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
druid 配置详细
qq_20336723的博客
04-19 865
1.配置文件参数信息 配置 缺省值 说明 name   配置这个属性的意义在于，如果存在多个数据源，监控的时候可以通过名字来区分开来。  如果没有配置，将会生成一个名字，格式是："DataSource-" + System.identityHashCode(this) jdbcUrl
Mybatis如何配置连接池
08-31
这样，MyBatis就能利用Druid连接池进行高效的数据库操作。配置合理的连接池参数可以显著提升应用性能，减少数据库系统的压力。同时，Druid还提供了丰富的监控统计功能，便于开发者分析和优化数据库连接使用情况。在...
MyBatis
abc98526的博客
05-01 1133
前置环境: 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-数据库连接池
weixin_61605998的博客
07-15 1531
数据库连接池是个容器，负责分配、管理数据库连接(Connection)它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个释放空闲时间超过最大空闲时间的连接，来避免因为没有释放连接而引起的数据库连接遗漏。也就是，如果某个操作占用的连接超出了预定的时间，就会自动释放连接。
MyBatis——MyBatis数据源与连接池
庄小焱
08-30 1219
博文主要介绍MyBatis数据源与连接池，更好的理解MyBatis数据源与连接池。
Mybatis_数据源与连接池详解
chuige2013的博客
11-01 1416
对于ORM框架而言，数据源的组织是一个非常重要的一部分，这直接影响到框架的性能问题。本文将通过对MyBatis框架的数据源结构进行详尽的分析，并且深入解析MyBatis的连接池。本文首先会讲述MyBatis的数据源的分类，然后会介绍数据源是如何加载和使用的。紧接着将分类介绍UNPOOLED、POOLED和JNDI类型的数据源组织；期间我们会重点讲解POOLED类型的数据源和其实现的连接池原理。以下是本章的组织结构：1）MyBatis数据源DataSource分类。
Mybatis update数据库死锁之获取数据库连接池等待
09-01
总的来说，理解数据库事务和锁机制对于排查和解决Mybatis中的死锁问题至关重要，而优化数据库连接池配置和事务管理则能有效防止连接池等待的情况。在开发过程中，保持良好的编程习惯，及时提交或回滚事务，可以避免...
Mybatis连接池、事务控制和复杂查询（基于XML配置）.zip
12-08
Mybatis是Java开发中常用的持久层框架，它简化了...通过分析这些源码，你可以深入理解Mybatis如何与连接池配合工作，如何实现事务控制，以及如何编写复杂的SQL查询。这将有助于提升你在实际项目中的数据库操作能力。
spring boot配置MySQL数据库连接、Hikari连接池和Mybatis的简单配置方法
08-27
Spring Boot 配置 MySQL 数据库连接、Hikari 连接池和 MyBatis 的简单配置方法 Spring Boot 是一个基于 Java 的框架，用于快速构建生产级别的应用程序。作为一个现代化的框架，Spring Boot 提供了许多便捷的配置...
SpringBoot+MyBatis+Druid连接池+JDBC官方驱动+ClickHouse
01-17
在这个场景中，我们关注的是一个基于SpringBoot、MyBatis和Druid连接池的项目，它利用了ClickHouse的JDBC官方驱动进行数据操作。这个组合提供了强大的数据库管理和分析能力，特别适合大数据量的实时查询和分析。下面...
Mybatis——连接池
紫罗兰与海棠的博客
12-27 2568
一、概述 在实际开发中都会使用连接池，因为连接池可以减少获取连接所消耗的时间。 队列特性：先进先出，正好可以确保拿到的连接对象就是刚刚自己创建的 二、mybatis中的连接池 配置的位置 主配置文件中的dataSoirce标签，type属性表示采用何种连接池方式 type属性的取值 POOLED 采用传统的javax.sql.DataSource规范中的连接池，mybatis中有针对规范的实现 UNPOOLED 采用传统的获取连接的方式，虽然也实现了javax.sql.DataSour
Mybatis中的连接池
weixin_30687051的博客
04-21 4752
Mybatis中DataSource的存取 MyBatis是通过工厂模式来创建数据源DataSource对象的，MyBatis定义了抽象的工厂接口:org.apache.ibatis.datasource.DataSourceFactory,通过其getDataSource()方法返回数据源DataSource。 MyBatis创建了DataSource实例后，会将其放到Config...
Mybatis中的数据源与连接池详解
热门推荐
马靖的个人技术博客
05-14 3万+
在前面的文章《Mybatis配置之配置元素详述 》中我们已经知道里面可以配置两个元素，一个是数据源及连接池的配置，一个是事务管理器的配置。在上篇文章中我们只是简单的描述了一下，从这篇文章开始，我们将分两篇博文，分别对这两个问题进行详细说明。 这篇文章我们先来了解一下数据源及连接池的配置。 （1）Mybatis中支持的数据源 在上篇文章中，我们知道Mybatis中支持三种形式数据源的配置
Mybatis原生的连接池的实现
石头视角
12-10 2495
一句话概括Mybatis的连接池：最保守的数据库连接池。        这里分析的是Mybatis3的代码，有什么问题，欢迎大家拍砖。        首先看代码树：                   datasource目录下就是连接池全部的代码，和DBCP以及C3P0比起来简直是简单到极致。        主要关注三个类 PooledConnection、Pool
常用的HikariConnectionPool数据库连接池
tan_yh的专栏
09-07 1380
package com.jiufive.backend.jdbc; import com.zaxxer.hikari.HikariDataSource; import java.beans.PropertyVetoException; import java.io.IOException; import java.io.InputStream; import java.sql.Connection; import java.sql.SQLException; import java.util.Propert
【MyBatis】基础篇(八) MyBatis中的连接池技术
不想当架构师的程序员不是好程序员
08-18 1536
MyBatis连接池技术 1. MyBatis连接池分类 在 MyBatis 的数据源 dataSource 分为以下几类: UNPOOLED 不使用连接池的数据源 POOLED 使用连接池的数据源 JNDI 使用 JNDI 实现的数据源 2. Mybatis 中数据源的配置 我们的数据源配置就是在 SqlMapConfig.xml 文件中，具体配置如下： <!-- 配置数据源（连接...
Mybatis框架（四）-- 其他配置
Pinker_Q
10-21 214
文章目录连接池配置 连接池配置 mybatis连接池提供了3种方式的配置： – 配置的位置： 主配置文件SqlMapConfig.xml中的dataSource标签，type属性就是表示采用何种连接池方式。 – type属性的取值： POOLED 采用传统的javax.sql.DataSource规范中的连接池，mybatis中有针对规范的实现 UNPOOLED 采用传统的获取连接的方式，虽然也实现Javax.sql.DataSource接口，但是并没有使用池的思想。 JNDI 采用服务器提供的JNDI
Mybatis连接池的配置与分类
weixin_41996091的博客
02-23 366
1.连接池 可以提高连接的重复使用，减少我们获取连接所消耗的连接。 2.配置的位置 主配置文件SqlMapConfig.xml中的dataSource标签，type属性就是表示采用何种连接池方式。 3.type属性的取值 POOLED 采用传统的javax.sql.DataSource规范中的连接池，mybatis中有针对规范的实现。 UNPOO...
Mybatis连接池
qq_44400723的博客
11-10 92
一·App直接向Mysql要连接 每次连接Mysql都要向其索要连接，Mysql以用户名密码加以审查，Mysql启动线程和你对接，连接在每次使用完成后摧毁，连接是非常耗时的，连接要做各种各样的检测 二·连接池 在程序启动是创建一个组件，一下子向数据库申请十几个连接，这时候程序还在启动，用户还没来，提前申请。App向组件申请连接，连接用完之后不摧毁，返回到缓存结构里。下次可以反复使用。 这种结构是连接对象缓存器（连接池）。 缓存的等级：cache->buffer->pool 容量依次增大。
mybatis连接池
最新发布
10-17
Mybatis连接池是用于管理数据库连接的工具，它可以在应用程序启动时创建一定数量的数据库连接，并在需要时将这些连接分配给应用程序。Mybatis默认使用的是JDBC连接池，但也可以使用其他第三方连接池，如C3P0、Druid...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值