MyBatis的简介和核心的组件（映射器、执行器、SqlSession及其工厂）

已于 2023-03-05 10:56:49 修改
阅读量1k 收藏 5
点赞数
分类专栏： # SSM 文章标签： mybatis java mysql
于 2022-09-18 19:32:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuandfeng/article/details/126921826
版权

Java知识点总结：想看的可以从这里进入

目录

1、简介

1.1、原始JDBC

在以前我们都是使用原始的JDBC，但是这种连接会造成创建、释放频繁造成系统资源的浪费从而影响性能，当sql变化时需要去改变Java代码，不符合开闭的原则，在查询时要手动将结果集封装到实体，插入时手动的提取实体到占位符，增加了代码量。

  • 导入相关的 jar 包 或者依赖；
  • 加载驱动，获取Connection
  • 准备SQL语句，获取执行sql语句的Statement对象；
  • 通过Statement对象执行SQL，返回结果到ResultSet对象；
  • 使用ResultSet读取数据，然后通过代码转化为具体的对象；
  • 释放资源
public List<User> selectAllUser(){
 	//原始的JDBC手动创建连接
    Connection conn = null;
    PreparedStatement ps = null;
    ResultSet rs = null;
    try {
        Class.forName("com.mysql.cj.jdbc.Driver");
        String url = "jdbc:mysql://localhost:3306/库名?useUnicode=true&amp&characterEncoding=utf-8&serverTimezone=Asia/Shanghai";
        String root = "root";
        String password = "密码";
        conn = DriverManager.getConnection(url,root,password);
        ps = conn.prepareStatement("select * from `user`");
        rs = ps.executeQuery();
        List<User> list = new ArrayList<>();
        while (rs.next()){
            //获取数据
            User user = new User();
            user.setId(rs.getInt("id"));
            user.setUsername(rs.getString("username"));
            user.setPassword(rs.getString("password"));
            //添加到集合中
            list.add(user);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }finally {
        try {
            conn.close();
            ps.close();
            rs.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }   
}

1.2、SpringJDBC

SpringJDBC是对原始JDBC做了封装，它将原始的JDBC的步骤做了封装，我们只需要完成相关配置，就可以直接连接数据库，在操作中只需要关注JdbcTemplate 对象即可。

<!--导入数据文件database.properties -->
<context:property-placeholder location="classpath:database.properties"/>
<!--配置德鲁伊数据库连接池 -->
<!-- 配置druid 连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
    <property name="driverClassName" value="${jdbc.driver}"/>
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
    <!--初始连接数-->
    <property name="initialSize" value="${jdbc.initialSize}"/>
    <!--最小空闲连接数-->
    <property name="minIdle" value="${jdbc.minIdle}"/>
    <!--最大活动连接数-->
    <property name="maxActive" value="${jdbc.maxActive}"/>
    <!--最大等待时间-->
    <property name="maxWait" value="${jdbc.maxWait}"/>
</bean>
<!--jdbcTemplate连接数据库-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"/>
</bean>

@Resource
private JdbcTemplate jdbcTemplate;
@Test
public void jdbcTest(){
    String sql = "select * from `user`";
    List<User> users = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class));
    users.forEach(System.out::println);
}

1.3、MyBatis

原始的JDBC操作繁琐，每次执行SQL时每次都需要获取：Connection、PreparedStatement、ResultSet 这些数据库资源，然后就需要大量的try、catch、finally语句捕捉异常、关闭数据库资源。而SpringJDBC虽然对JDBC做了封装，大大的简化了操作流程，但是它的操作还是直接在业务层面的，这样会导致耦合性较强，且有sql注入的危险。所以就产生了第三方的框架，比如MyBatis。官网

MyBatis 是 apache的一个开源项目iBatis，2010年6月这个项目由Apache Software Foundation迁移到了Google Code后，正式更名为MyBatis。代码于2013年11月迁移到Github。

它是一种半自动的对象关系映射（ORM）框架，它在Java对象和数据库的表之间建立映射关系(类对应表，属性对应字段)，内部封装了JDBC相关操作，所以不用再去关注注册驱动、获取连接、执行 SQL、释放资源等操作，极大简化了持久层开发工作。其中SQL语句需要我们自己编写，虽然相对于自动的映射框架来说，增加了不少代码量，但是它有较高的灵活性，可以根据需要，自由地对SQL进行定制。

什么是ORM？即Object Relation Mapping，对象关系映射。对象指的是Java对象，关系指的是数据库中的关系模型，对象关系映射，指的就是在Java对象和数据库的关系模型之间建立一种对应关系，就是数据库的表对应Java类，数据库字段对应Java属性，数据的一条数据对应Java一个对象。

全自动的ORM不需要编写SQL语句，只需要定义好映射关系，就可以直接进行CRUD操作了。而半自动的ORM，需要手动编写SQL语句。虽然这种半自动的ORM在操作上会麻烦很多，但是相对的它也更加灵活，可以根据需要，自由地对SQL进行定制。

MyBatis 是通过 XML 或注解配置Statement对象，并通过Java对象和 Statement中的SQL进行映射生成最终执行的SQL语句，最后由MyBatis框架执行SQL并将结果映射成Java对象并返回。

在MyBatis 中有三个基本要素：

  • 核心组件（核心的类和接口）
  • MyBatis核心配置文件（mybatis-config.xml）
  • SQL映射器（mapper.xml）

MyBatis还有一种增强的工具版本 Mybatis-Plus，它是在Mybatis的基础上做了一些增强，在不改变MyBatis的基础上，简化了开发。

Mybatis的使用过程：

  • 添加mybatis的依赖

    <!--mysql8依赖-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.25</version>
</dependency>
<!--mybatis依赖 -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.7</version>
</dependency>
<!-- junit的依赖，测试 -->
<dependency>
  <groupId>org.junit.jupiter</groupId>
  <artifactId>junit-jupiter-api</artifactId>
  <version>5.9.1</version>
  <scope>test</scope>
</dependency>
<!-- log4j 日志-->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.20.0</version>
</dependency>

  • MyBatis 默认使用 log4j 输出日志信息，所以可以配置日志文件 log4j.properties

    ### 设置日志级别和输出位置 ###
log4j.rootLogger=DEBUG,console,logFile
log4j.additivity.org.apache=true

# 输出到控制台(console)
log4j.appender.console=org.apache.log4j.ConsoleAppender
# 输出级别最低为DEBUG
log4j.appender.console.Threshold=DEBUG		
# 表示所有消息都会被立即输出
log4j.appender.console.ImmediateFlush=true
#输出日志到控制台的方式
log4j.appender.console.Target= System.out
# 灵活布局输出日志
log4j.appender.console.layout=org.apache.log4j.PatternLayout
#设定以怎样的格式显示消息。
log4j.appender.console.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%t] [%c] [%p] -%m%n

  • 创建mybatis-config.xml配置文件

  • 编写，加载映射文件mapper.xml

  • 加载配置文件，创建SqlSessionFactory工厂，获取SqlSession

  • 调用mapper映射文件中的SQL语句来执行CRUD操作

  • 返回结果集的映射

2、核心组件

2.1、组件介绍

mybatis的核心组件主要有4部分

  • SqlSessionFactoryBuilder（构造器）：它的作用仅仅用来生成 SqlSessionFactory，创建成功后就失去作用，所以用在生成 SqlSessionFactory 的方法中作为局部变量使用，用完即可回收。

    它通过内部的build(InputStream inputStream, String environment, Properties properties) 创建SqlSessionFactory，使用流读取配置文件。

  • SqlSessionFactory：相当于数据库的连接池，主要是用 openSession() 创建SqlSession接口，所以需要存在MyBatis的整个应用中。一般是创建一个单例模式，生命周期等同MyBatis的生命周期

  • SqlSession：相当于Connection对象，用于业务请求，用完关闭。存在于一次业务请求中，处理完请求后使用close方法关闭。

  • SQL Mapper（映射器）：Mapper是通过SqlSession获取的，所以Mapper的生命周期小于SqlSession，它相当于一个请求中的业务处理。

2.2、SqlSessionFactory

SqlSessionFactory是 Mybatis的核心组件，每个MyBatis都是以一个SqlSessionFactory实例为中心，而它的作用就是生产SqlSession。

使用MyBatis需要配置 SqlSessionFactory 对象，通常使用 SqlSessionFactoryBuilder 的 build() 方法，SqlSessionFactory作为一个工厂接口，唯一的作用就是用来创建SqlSession的，所以我们一般会用单例模式来处理它。而一般选用通过XML配置的方式来生成 SqlSessionFactory。

  • 创建database.properties文件

    jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/库名?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true
jdbc.username=root
jdbc.password=密码

  • 创建一个映射器文件

    <?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接口 -->
<mapper namespace="com.yu.mybatis.mapper.UserMapper">
      <!--数据库字段和Java属性之间的映射关系 -->
      <resultMap id="BaseResultMap" type="com.yu.mybatis.entity.User">
            <id column="user_id" jdbcType="INTEGER" property="userId" />
            <result column="username" jdbcType="VARCHAR" property="username" />
            <result column="password" jdbcType="VARCHAR" property="password" />
            <result column="deleted" jdbcType="BIT" property="deleted" />
      </resultMap>
    <!--数据库的字段名字 -->
      <sql id="Base_Column_List">
        	user_id, username, `password`, deleted
      </sql>
    <!--根据id获取数据 -->
      <select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
            select 
            <include refid="Base_Column_List" />
            from `user`
            where user_id = #{userId,jdbcType=INTEGER}
      </select>
</mapper>

  • XML配置数据库连接

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

<configuration>
	<!--指定外部 properties 文件-->
    <properties resource="database.properties"/>

    <!--配置数据库连接，可以配置多种环境，默认使用的环境（比如：default="development"） -->
    <environments default="development">
        <environment id="development">
            <!--事务管理器的配置（比如：type="JDBC"）。
              JDBC – 这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来管理事务作用域。
              MANAGED – 这个配置几乎没做什么。它从不提交或回滚一个连接，而是让容器来管理事务的整个生命周期
            -->
            <transactionManager type="JDBC"/>
            <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>
        </environment>
    </environments>

    <!--指定映射器XML文件的路径-->
    <mappers>
        <mapper resource="mapping/UserMapper.xml"/>
    </mappers>
</configuration>

  • 创建一个帮助类，读取 xml 配置文件，生成SqlSessionFactory

    public class SqlSessionUtil {
    private static SqlSessionFactory factory = null;
    static {
        try {
            InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
            factory = new SqlSessionFactoryBuilder().build(in);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static SqlSessionFactory getFactory(){
        return factory;
    }
}

2.3、SqlSession

SqlSession是MyBatis的核心接口，其有两个实现类：其中DefaultSqlSession是单线程，SqlSessionManager是多线程。

它就相当于Connection对象，代表一个连接数据库的资源，每次需要获取和关闭。它提供了面向数据库执行 SQL 命令所需的所有方法，可以通过 SqlSession 实例直接运行已映射的 SQL 语句。

//SqlSession的获取，
//通过SqlSession对象所操作的sql都必须手动提交或回滚事务
SqlSession sqlSession = SqlSessionUtil.getFactory().openSession();
//此时通过SqlSession对象所操作的sql都会自动提交
SqlSession sqlSession = SqlSessionUtil.getFactory().openSession(true);

SqlSession执行SQL的两种方式

  • 直接发送SQL给数据库，利用XML映射器

    String statement=“XML映射文件的namespace属性值(Mapper接口全限定名) + XML映射文件方法的id名（mapper接口的方法名）”
    Object parameter：插入所需的参数，通常是对象或者Map
    RowBounds rowBounds：用于分页，它的两个属性: offset指查询的当前页数; limit指当前页显示多少条数据。
    String mapKey：执查询结果会被封装成一个Map集合返回，key就是参数mapKey传入的列名，value 是封装的对象。
    ResultHandler handler：ResultHandler对象用来处理查询返回的复杂结果集，通常用于多表查询。

    public interface SqlSession extends Closeable {

  /**查询方法，查询结果只有一条数据时才使用。*/
  <T> T selectOne(String statement);
  <T> T selectOne(String statement, Object parameter);

  /**查询方法，返回执行SQL话句查询结果的泛型对象的集合。。*/
  <E> List<E> selectList(String statement);
  <E> List<E> selectList(String statement, Object parameter);
  <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds);

  /**查询方法,根据结果对象中的一个属性将结果列表转换为 Map */
  <K, V> Map<K, V> selectMap(String statement, String mapKey);
  <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey);
  <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds);

  /**Cursor 提供与 List 相同的结果，只是它使用 Iterator 懒惰地获取数据。*/
  <T> Cursor<T> selectCursor(String statement);
  <T> Cursor<T> selectCursor(String statement, Object parameter);
  <T> Cursor<T> selectCursor(String statement, Object parameter, RowBounds rowBounds);

  /**使用ResultHandler检索从语句键和参数映射的单行。 */
  void select(String statement, Object parameter, ResultHandler handler);
  void select(String statement, ResultHandler handler);
  void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler);

  /**插入方法，返回执行SQL语句所影响的行数。。*/
  int insert(String statement);
  int insert(String statement, Object parameter);

  /**执行更新语句。将返回受影响的行数 */
  int update(String statement);
  int update(String statement, Object parameter);

  /**执行删除语句。将返回受影响的行数。*/
  int delete(String statement);
  int delete(String statement, Object parameter);

  /**提交事务。 */
  void commit();
  void commit(boolean force);

  /**回滚事务 */
  void rollback();
  void rollback(boolean force);

  /**刷新批处理语句*/
  List<BatchResult> flushStatements();

  /**关闭会话 */
  @Override
  void close();

  /**清除本地会话缓存。*/
  void clearCache();

  /**检索当前配置。 */
  Configuration getConfiguration();

  /**检索映射器*/
  <T> T getMapper(Class<T> type);

  /**检索内部数据库连接 */
  Connection getConnection();
}

    image-20230304142316789

  • 获取Mapper接口，操作SQL（建议使用）

    sqlSession.getMapper(***Mapper.class);	//创建的Mapper接口

    在使用Mybatis时，会根据映射文件创建相应的mapper接口，可以用接口的方法

    public interface UserMapper {
    User selectByPrimaryKey(Integer userId);
}

    <!--对应mapper接口-->
<mapper namespace="com.yu.mybatis.mapper.UserMapper">
    <!-- id对应接口内方法名-->
  <select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
    <!--@mbg.generated-->
    select 
    <include refid="Base_Column_List" />
    from `user`
    where user_id = #{userId,jdbcType=INTEGER}
  </select>
</mapper>

    image-20230304142719906

2.4、映射器

MyBatis中最重要也是最复杂的组件，MyBatis是由一个Mapper接口，和一个XML映射文件（注解），对应以前的dao接口和一个dao实现类，它主要的作用是：

  • 描述映射规则
  • 提供SQL语句
  • 配置缓存
  • 提供动态SQL
2.4.1 接口和XML映射

在MyBatis中数据的一张表，分别对应一个实体类，一个Mapper接口、和一个XML的映射文件。

在IDEA中可以引入插件MyBatisCodeHelperPro，使用插件辅助创建所需的类。

image-20210716120801177 image-20210716120411230

  • 实体类：根据数据表对应的实体类会自动创建好，并生成get和det方法。

    image-20220918163654592

  • mapper：接口，编写查询所有的方法，如果映射的路径正确，点击创建，会自动在xml文件中创建好

    image-20220918163038319

  • mapping：mapper的实现类，xml形式配置。

    它的映射规则是：

    先通过 mapper namespace=“com.yu.mapper.UserMapper” 映射到对应的接口

    然后通过select、update、delete、inser这些标签的 id 属性值映射得到接口对应的方法上

    再通过 resultMap、parameterType这两个属性可以将获得的结果集，映射到对应的实体类上进行自动装配。

    <?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是相应的Mapper接口的全限定名-->
<mapper namespace="com.yu.mapper.UserMapper">

    <!--数据库的表和是实体类的映射关系，可以自己配置属性是另外一个实体的情况 -->
    <resultMap id="BaseResultMap" type="com.yu.pojo.User">
        <id column="user_id" jdbcType="INTEGER" property="userId" />
        <result column="username" jdbcType="VARCHAR" property="username" />
        <result column="password" jdbcType="VARCHAR" property="password" />
        <result column="deleted" jdbcType="BIT" property="deleted" />
    </resultMap>

    <!--数据表的字段，在本XML中可直接引用-->
    <sql id="Base_Column_List">
        user_id, username, `password`, deleted
    </sql>

    <!--和Mapper接口中的方法对应，select为查询属性， id为方法名， resultType为返回值-->
    <select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
        <!--@mbg.generated-->
        select 
        <include refid="Base_Column_List" />
        from `user`
        where user_id = #{userId,jdbcType=INTEGER}
    </select>

    <!--    插入-->
    <insert id="insert" keyColumn="user_id" keyProperty="userId" parameterType="com.yu.pojo.User" useGeneratedKeys="true">
        <!--@mbg.generated-->
        insert into `user` (username, `password`, deleted)
        values (#{username,jdbcType=VARCHAR}, #{password,jdbcType=VARCHAR}, #{deleted,jdbcType=BIT})
    </insert>

    <!--删除-->
    <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer">
        delete from `user`
        where user_id = #{userId,jdbcType=INTEGER}
    </delete>

    <!--修改-->
    <update id="updateByPrimaryKeySelective" parameterType="com.yu.pojo.User">
        update `user`
        <set>
            <if test="username != null">
                username = #{username,jdbcType=VARCHAR},
            </if>
            <if test="password != null">
                `password` = #{password,jdbcType=VARCHAR},
            </if>
            <if test="deleted != null">
                deleted = #{deleted,jdbcType=BIT},
            </if>
        </set>
        where user_id = #{userId,jdbcType=INTEGER}
    </update>
</mapper>
2.4.2 发送SQL

通过SqlSession可以获取Mapper接口，它对比SqlSession发送的SQL语句，有很高的可读性，因为SqlSession需要使用自己的方法通过SQL的id属性去匹配相应的SQL，而Mapper则是直接使用自己定义的方法。

public class SqlSessionTest {
    @Test
    public void test(){
        SqlSession sqlSession = SqlSessionUtil.getFactoryBean().openSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.selectByPrimaryKey(1);
        sqlSession.commit();
        System.out.println(user.getUsername());

    }
}

配置的日志打印的信息：

image-20220918163428829

查到了数据

image-20220918163507889

2.4.3、注解的形式

映射器中也有相应的注解来代替XML映射文件，来实现SQL语句，如果和XML同时定义，XML会覆盖掉注解.

public interface UserMapper {
    @Select("select user_id, username, `password`, deleted from `user` where user_id =#{userId}")
    User selectByPrimaryKey(Integer userId);

}

上面的这条注解语句可以代替下面这个:

<select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
    <!--@mbg.generated-->
    select 
    <include refid="Base_Column_List" />
    from `user`
    where user_id = #{userId,jdbcType=INTEGER}
</select>

虽然注解的形式要简单很多，但是很多的 sql语句的复杂性是很高的，这种复杂的sql语句放在XML文件中更适合，而且他还可能牵扯到一些动态 SQL等问题，所以还是推荐使用XML的方式。

2.5、执行器

MyBatis整体操作无非就是：连接数据库、编译生成SQL语句、执行SQL、获取数据进行封装等几个步骤，其中执行器 Executor就是用来执行SQL语句的，存在于SqlSession中。

image-20220918170024484

MyBatis有三种基本的执行器：

  1. 简单执行器SimpleExecutor：每次执行update或select都会开启一个statement对象，用完立刻关闭statement对象
  2. 可重用执行器ReuseExecutor：执行update或select前，以sql作为key查找Statement对象，存在就使用不存在就创建，用完后不关闭，放置在Map中供下一次使用。（重复使用）
  3. 批量执行器BatchExecutor：执行update（没有select，JDBC批处理不支持select），将所有sql都添加到批处理中（addBatch()），等待统一执行（executeBatch()），它缓存了多个对象，每个Statement对象都是addBatch()完毕后，等待逐一执行executeBatch()批处理。与JDBC批处理相同。
public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    executorType = executorType == null ? defaultExecutorType : executorType;
    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
    Executor executor;
    if (ExecutorType.BATCH == executorType) {
        executor = new BatchExecutor(this, transaction);
    } else if (ExecutorType.REUSE == executorType) {
        executor = new ReuseExecutor(this, transaction);
    } else {
        executor = new SimpleExecutor(this, transaction);
    }
    if (cacheEnabled) {
        executor = new CachingExecutor(executor);
    }
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
}

2.6、mybatis流程

image-20220717165229940
  1. 读取MyBatis的核心配置文件：读取配置数据库的连接、属性、类别名、映射器等信息。
  2. 加载映射文件：Mapping.xml映射文件，用来配置操作数据库的SQL语句，可以通过xml和注解获取
  3. 构造会话工厂获取SqlSessionFactory：通过SqlSessionFactoryBuilder对象构建
  4. 创建会话对象SqlSession：包含了执行SQL的一些方法
  5. Executor执行器：mybatis的核心，用来SQL语句的生成和查询缓存的维护
  6. Statement对象：对SQL语句的封装，一个对象对应XML文件中的一个sql语句标签。
  7. 输入参数映射：传递参数，进行预编译处理
  8. 封装结果集：将SQL语句产生的数据进行封装
辰 羽
关注
专栏目录
（二）MyBatis核心组件（配图详解＆代码实现）
青衣煮茶
07-27 4万+
MyBatis的核心组件分为4个部分 SqlSessionFactoryBuilder（构造器）：根据xml或java代码生成SqlSessionFactory。 SqlSessionFactory（工厂接口）：使用它生成Sqlsession，工厂模式下生成。 Sqlsession（会话）：可以发送SQL执行返回结果和获取Mapping的接口。在大多数开发中，我们使用My...
mybatis框架——核心组件及其作用
weixin_38851693的博客
11-15 730
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u013045868/article/details/60467107 引言 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&...
MyBatis核心组件
qq_16500963的博客
10-15 259
Mybatis分层框架图MyBatis的执行流程及核心组件如下图所示。了解了MyBatis的核心组件后，我们再来了解一下使用MyBatis操作数据库的过程。实际上SqlSession是Executor组件的外观，目的是为用户提供更友好的数据库操作接口，这是设计模式中外观模式的典型应用。真正执行SQL操作的是Executor组件，Executor可以理解为SQL执行器，它会使用StatementHandler组件对JDBC的Statement对象进行操作。
【MyBatis】四大组件Executor、StatementHandler、ParameterHandler、ResultSetHandler 详解
最新发布
binqian的专栏
09-21 259
上次我们在说mybatis 的 plugin 功能的时候，提到了其可作用于myBatis 的四大组件，也放了一个基础的模型图，但是对于这四大组件更具体的功能和原理：却没有进一步说明，今天就来完成这项工作Statement 是Java JDBC API中定义的一个接口，位于java.sql 包下，是一种执行静态SQL语句的对象，可以用于执行SQL语句的查询、更新、插入和删除等操作。我们可以看其上的官方注释：produces用于执行静态SQL语句并返回其生成的结果的对象。
啥也不是
weixin_39694434的博客
01-16 430
图片出自 mybatis是通过XML配置的方来定制化 SQL、存储过程以及高级映射等。所以首先他要解析相关mapper配置文件并将解析相互来的的结果放在Configuration类中。个人认为主要的一些放在如下(类名.方法)： SqlSessionFactoryBuilder.build() 参数是配置文件(这个配置是mybatis的配置不是我们开发经常要写sql文件配置)的InputStrea...
Mybatis核心组件
升仔聊编程的博客
01-26 500
Mybatis组件
MyBatis(三)------MyBatis的核心组件
一切有为法，如梦亦如幻，如露亦如电，应作如是观。
05-03 2239
1、持久层的概念和MyBatis的特点 持久层可以将业务数据存储到磁盘，具备长期存储能力，只要磁盘不损坏，或断电，或其他情况下，重新开启系统任然可以读取这些数据。一般执行持久任务的都是数据库系统，持久层可以使用巨大的磁盘空间，也比较廉价，缺点就是比较慢。当然慢是针对内存而言的，在一般的系统中运行是不存在问题的，比如内存管理系统，但是在互联网的秒杀场景下，每秒都需要执行成千上万次数据操作，慢是不能承受的，极有可能宕机，这种情况下考虑使用Redis(NoSQL)处理它。 Java互联网应用通过MyBat..
mybatis配置数据源、别名,映射器,执行数据库的查询, 带一个参数及多个参数的查询,新增等
03-28
映射器是MyBatis的核心组件，它负责定义SQL语句和结果映射。在`mybatis-config.xml`中，我们需要添加`mapper`元素来指定映射文件的位置： ```xml ``` 在`UserMapper.xml`中，我们可以编写SQL查询，例如： ```...
Mybatis核心组件简介
CYH_progress的博客
12-17 342
核心组件 一、核心组件和作用 1、SqlSessionFactoryBuilder（构造器） ​ 它会根据配置或者代码来生成 SqlSessionFactory，采用的是分步构建的 Builder 模式。 2、SqlSessionFactory（工厂接口） ​ 依靠它来生成 SqlSession，使用的是工厂模式。 3、SqlSession（会话） ​ 一个既可以发送 SQL 执行返回结果，也可以获取 Mapper 的接口。在现有的技术中，一般我们会让其在业务逻辑代码中“消失”，而使用的是 MyBat
SpringBoot+MyBatis+SqlSession
04-24
在IT行业中，SpringBoot、MyBatis和SqlSession是三个非常关键的技术组件，它们共同构建了一个高效、便捷的Web应用程序开发环境。让我们深入探讨一下这三个技术及其在项目中的结合使用。 首先，SpringBoot是由...
MyBatis SQL映射器框架的Java.zip
05-23
MyBatis是一个强大的Java持久层框架，它将SQL与Java代码分离，使...在`MyBatis SQL映射器框架的Java.zip`中，你可能能找到关于如何设置和使用MyBatis的示例代码和详细文档，这对于学习和理解MyBatis的使用非常有帮助。
mybatis核心组件
愿世界和平
05-08 945
0. maven坐标 org.mybatis mybatis 3.3.0 1. sqlsessionfactorybuilder (构造器) 通过配置信息或代码来生成sqlsessionfactory 2. sqlSessionFactory 工厂接口,来生成sqlSession(会话) 3. sqlSession  负责发送sql和返回结果. 并且读取m
Mybatis的核心组件
啦啦啦啊摘月亮 的博客
08-21 656
总述 Mybatis的核心组件分为四个部分，分别是： SqlSessionFactoryBuilder：构造器，它会根据配置或代码来生成SqlSessionFactory，采用的是分布构建的Builder模式。 SqlSessionFactory：工厂接口，依靠它来生成SqlSession，使用的是工厂模式。 SqlSession：会话，一个既可以发送SQL执行返回结果，也可以获取Mapp...
MyBatis 的核心组件有哪些？
luoluoal的博客
06-26 1518
2. SqlSession：SqlSession 是 MyBatis 的核心组件之一，它是 Session（会话）级别的缓存，用于与数据库进行交互。5. Executor：Executor 是 MyBatis 中的核心组件之一，它主要负责查询语句的执行和结果的返回。以上这些组件相互配合，实现了 MyBatis 框架的核心功能，为开发者提供了便捷、高效的数据库操作方式，避免了手写 SQL 语句和 JDBC 操作的繁琐。以上是 MyBatis 中动态 SQL 的常见用法，可以根据具体情况进行灵活运用。
MyBatis的核心组件
sunflower_sunuo的博客
06-20 737
近期在学习《深入浅出MyBatis技术原理与实战》，做了一些整理。 MyBatis的核心组件 SqlSessionFactoryBuilder（构造器）:会根据配置信息或者代码来生成SqlSessionFactory（工厂接口） SqlSessionFactory：依靠工厂来生成SqlSession（会话）。 创建SqlSessionFactory的两种模式： 1.xml配置方式（优点：...
Mybatis四大核心组件
Joker小兮的博客
04-11 2183
Mybatis四大核心组件分为以下4个部分 SqlSessionFactoryBuilder（构造器）：根据配置来构造SqlSessionFactory。配置方式有2种：xml和java config，使用的设计模式是建造者(Builder)模式 SqlSessionFactory（工厂接口）：用于生产SqlSession的工厂，使用的设计模式是工厂(Factory)模式 SqlSession（会话）：包含了执行SQL的所有的方法 Mapper（会话）：完成Java与SQL语句之间的映射，也就是我们平时说
Mybatis源码分析（十三）Mybatis的四大组件
长安不及十里的博客
03-04 1526
前面我们基本的流程都已经介绍完毕，下面我们来梳理一下前面的知识，加深自己的理解，以及重复记忆下面我们以代码和原理的方式来解读这些组件，首先我们来介绍Mybatis中重要组件执行器Executor。
Mybatis的核心组件是什么？
CZ-001的博客
08-31 2384
MyBatis是一个基于Java的持久层框架，所谓的持久层框架就是专门用来将数据进行持久化的框架，也就是说将数据存储到数据库中的框架。 学习并掌握Mybatis，首先就要了解Mybatis的核心组件。下面，我们一起来了解一下Mybatis四大核心组件： SqlSessionFactoryBuilder SqlSessionFactory SqlSession SQL Mapper 01 SqlSessionFactoryBuilder 作为Mybatis的核心组件之一，它直接翻译为中文是SQL会话工厂建
MyBatis核心组件以及其作用域、生命周期
Happy_lifer的博客
01-14 1000
这里 SQL 返回的列名 id 和 note 是可以和之前定义的 POJO 的属性对应起来的，而表里的列 role_name 通过 SQL 别名的改写，使其成为 roleName，也是和 POJO 对应起来的，所以此时 MyBatis 就可以把 SQL 查询的结果通过自动映射的功能映射成为一个 POJO。映射器是一些绑定映射语句的接口。映射器接口的实例是从 SqlSession 中获得的，将 SQL 查询到的结果映射为一个 POJO，或者将 POJO 的数据插入到数据库中，并定义一些关于缓存等的重要内容。
MyBatis持久层框架：映射器的范围与生命周期解析
在MyBatis框架中，映射器实例是关键组件，它们负责绑定映射语句并执行数据库操作。映射器接口的实例可通过SqlSession获取，其生命周期与SqlSession相同。在给定的代码示例中，`SqlSession session = ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

辰 羽

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值