Selepas mempelajari kod sumber MyBatis dalam satu minggu, saya mendapat ringkasan 10,000 perkataan

Seperti yang kita semua tahu, MyBatisMyBatis是对JDBC进行封装而成的产品，所以，聊MyBatis源码之前我们得先了解JDBC。

JDCB

JDBC案例：

public class JdbcDemo {
    public static final String URL = "jdbc:mysql://localhost:3306/mblog";
    public static final String USER = "root";
    public static final String PASSWORD = "123456";

    public static void main(String[] args) throws Exception { 
        Class.forName("com.mysql.jdbc.Driver"); 
        Connection conn = DriverManager.getConnection(URL, USER, PASSWORD); 
        Statement stmt = conn.createStatement(); 
        ResultSet rs = stmt.executeQuery("SELECT id, name, age FROM m_user where id =1"); 
        while(rs.next()){
            System.out.println("name: "+rs.getString("name")+" 年龄："+rs.getInt("age"));
        }
    }
}

说明：

数据库驱动：

Class.forName("com.mysql.jdbc.Driver");

获取连接:

Connection conn = DriverManager.getConnection(URL, USER, PASSWORD);

创建Statement或者PreparedStatementYa

JDBC🎜 ialah produk yang terkandung, jadi sebelum bercakap tentang kod sumber MyBatis, kita mesti memahaminya terlebih dahulu🎜JDBC🎜. 🎜🎜

🎜JDCB🎜 🎜

kes JDBC: 🎜

Statement stmt = conn.createStatement();

Penerangan: 🎜

Pemacu pangkalan data: 🎜

ResultSet rs = stmt.executeQuery("SELECT id, name, age FROM m_user where id =1");

Dapatkan pautan:🎜

System.out.println("name: "+rs.getString("name")+" 年龄："+rs.getInt("age"));

BuatPenyataatau PreparedStatementObjek: 🎜

Statement stmt = conn.createStatement();

执行sql数据库查询：

ResultSet rs = stmt.executeQuery("SELECT id, name, age FROM m_user where id =1");

解析结果集：

System.out.println("name: "+rs.getString("name")+" 年龄："+rs.getInt("age"));

在使用的时候，业务处理完成后记得关闭相关资源

使用过JDCB的朋友都知道，JDBC如果用到我们项目中基本上都会存在以下几个问题：

传统JDBC的问题

• 创建数据库的连接存在大量的硬编码,
• 执行statement时存在硬编码.
• 频繁的开启和关闭数据库连接,会严重影响数据库的性能,浪费数据库的资源.
• 存在大量的重复性编码

针对上面这些问题，于是一大堆持久化框架应运而生。

持久化框

做持久层的框架有很多，有orm系和utils系列。

• orm系列的代表有： hibernate，eclipseLink，topLink；
orm系列的代表有：hibernate，eclipseLink，topLink；

utils系列的代表有：MyBatis，dbUtils，jdbcTemplate等；

下面对于这些框架做个简单概述：

至于 jpa，它只是一个规范标准，并非具体框架，不等同于 spring-data-jpa；同时 spring-data-jpa 也不是 jpa 的具体实现，它只是 jpa 规范标准的进一步封装。hibernate 是 jpa 最为常见的实现框架，当然其他还有 eclipseLink，topLink。

MyBatis 的特点是在对 SQL 优化时，复杂 SQL 的优化可控性高，框架内部调用层次简单，除了部分可以自动生成代码，还会有很多 SQL 需要自行编码。 spring-data-jpa(hibernate) 的特点是在开发过程中，脱离 SQL 编码开发，当然也支持本地SQL来查询，框架内部调用层次复杂。 以上就可以根据实际的业务进度和业务支撑情况做出选择了。

其实可以在一个项目在同时支持 MyBatis 和 spring-data-jpa，复杂SQL走 mybatis，常用SQL走 spring-data-jpa。

鉴于前实际开发中使用数量，我们选择MyBatis

utils系列的代表有：MyBatis，dbUtils，jdbcTemplate等；

下面对于这些框架做个简单概述：🎜

至于 jpa, 它 只 是 一 个 规范 标准, 并 非 框架 框架 不等 同于 同于 同于 同于 同于 同于 同于 同于 同于 同于 同于 同于 同于jpa；同时 spring-data-jpa 也不是 jpa 的具体实现，它只是 jpa 规范标准的进一步封装。hibernate 昀人 jpa当然其他还有 eclipseLink，topLink。🎜

MyBatis 的特点是在对 SQL 优化时， SQL的优化可控性高，框架内部调用层次简单，除了部分可以自动生成代码，还会爱行码。 spring-data-jpa(hibernate) 的特点是在开发过程中，脱离 SQL 编码开发，当然也支持本地SQL来查询，小為逢小為杂。 以上就可以根据实际的业务进度和业务支撑情况做出选择了。🎜

其实可以在一个项目在同时支持 MyBatis 和 spring-data-jpa，复杂SQL走 mybatis，常用SQL走 spring-data-jpa。器" style="padding-top: 8px;padding-bottom: 8px;line-height: 26px;margin-top: 1px;margin-bottom="1px;">鉴于前实际开发中使用数量，我滬逩 gaya kod saiz fon: 14px; padding: 2px 4px; jejari sempadan: 4px; jidar-kanan: 2px; jidar-kiri: 2px; warna latar belakang: rgba(27, 31, 35, 0.05); keluarga fon: "Pengendali Mono", Consolas, Monaco, Menlo, monospace;word-break: break-all;color: rgb(239, 112, 96);">MyBatis 进行分析。🎜

mybatis

Rakan yang baru dalam pembangunan mungkin tidak mengenali pendahulu MyBatis Sebelum 2010, mereka tidak menghantar MyBatis, dipanggil ibatis. MyBatis ，叫ibatis。

MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs

MyBatis ialah lapisan A berterusan yang sangat baik rangka kerja yang menyokong SQL tersuai, prosedur tersimpan dan pemetaan lanjutan. MyBatis mengelakkan hampir semua kod JDBC dan tetapan manual parameter dan mendapatkan semula set hasil. MyBatis boleh menggunakan XML atau anotasi mudah untuk Konfigurasikan dan petakan maklumat asli, gabungkan antara muka dengan Java POJO(Objek Java Biasa Biasa, objek Java biasa) dipetakan ke dalam rekod dalam pangkalan data. 🎜<h4 data-tool="mdnice编辑器" style="margin-top: 30px;margin-bottom: 15px;font-weight: bold;font-size: 18px;"> <span style="display: none;"></span>特点<span style="display: none;"></span> </h4> <ul class="list-paddingleft-2" data-tool="mdnice编辑器" style="margin-top: 8px;margin-bottom: 8px;padding-left: 25px;"> <li><section style="margin-top: 5px;margin-bottom: 5px;line-height: 26px;color: rgb(1, 1, 1);">简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件易于学习，易于使用，通过文档和源代码，可以比较完全的掌握它的设计思路和实现。</section></li> <li><section style="margin-top: 5px;margin-bottom: 5px;line-height: 26px;color: rgb(1, 1, 1);">灵活：MyBatis 不会对应用程序或者数据库的现有设计强加任何影响。 sql写在xml里，便于统一管理和优化。通过sql语句可以满足操作数据库的所有需求。</section></li> <li><section style="margin-top: 5px;margin-bottom: 5px;line-height: 26px;color: rgb(1, 1, 1);">解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。</section></li> <li><section style="margin-top: 5px;margin-bottom: 5px;line-height: 26px;color: rgb(1, 1, 1);">提供映射标签，支持对象与数据库的orm字段关系映射</section></li> <li><section style="margin-top: 5px;margin-bottom: 5px;line-height: 26px;color: rgb(1, 1, 1);">提供对象关系映射标签，支持对象关系组建维护</section></li> <li><section style="margin-top: 5px;margin-bottom: 5px;line-height: 26px;color: rgb(1, 1, 1);">提供xml标签，支持编写动态sql。</section></li> </ul> <h4 data-tool="mdnice编辑器" style="margin-top: 30px;margin-bottom: 15px;font-weight: bold;font-size: 18px;"> <span style="display: none;"></span>案例<span style="display: none;"></span> </h4> <p data-tool="mdnice编辑器" style="padding-top: 8px;padding-bottom: 8px;line-height: 26px;margin-top: 1px;margin-bottom: 1px;">需要来源两个jar包：<code style='font-size: 14px;padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;background-color: rgba(27, 31, 35, 0.05);font-family: "Operator Mono", Consolas, Monaco, Menlo, monospace;word-break: break-all;color: rgb(239, 112, 96);'>MyBatis的jar包和MySQL数据库连接jar包。

<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>x.x.x</version>
</dependency>
<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <version>8.0.16</version>
</dependency>

创建一个表t_user(数据库也是肯定要自己创建的哈)

 CREATE TABLE `t_user` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `name` varchar(255) DEFAULT NULL,
      `age` int(11) DEFAULT NULL,
      PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

插入一条数据：

INSERT INTO `t_user` VALUES ('1', 'tian', '19', '1');

创建该数据库表的实体类：

public class User {
    private Integer id;
    private String name;
    private Integer age;
    //set get
}

创建mapper配置文件：UserMapper.xml

<?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="com.tian.mapper.UserMapper">
    <select id="selectUserById" resultType="com.tian.domain.User">
        select * from t_user where id = #{id}
    </select>
</mapper>

创建mapper接口：UserMapper.java

import com.tian.domain.User;

public interface UserMapper {
    User selectUserById(Integer id);
}

MyBatis 整体配置文件：

<?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>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mblog?useUnicode=true&amp;characterEncoding=utf8&amp;autoReconnect=true&amp;useSSL=false&amp;serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="mappers/UserMapper.xml"/>
    </mappers>
</configuration>

上面这些就是我们使用MyBatis基本开发代码。

下面我们来写一个测试类：

import com.tian.domain.User;
import com.tian.mapper.UserMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

public class MybatisApplication {

    public static void main(String[] args) {
        String resource = "mybatis-config.xml";
        InputStream inputStream = null;
        SqlSession sqlSession =null;
        try {
            //读取配置文件
            inputStream = Resources.getResourceAsStream(resource);
            //创建SqlSession工厂
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            //创建sql操作会话
            sqlSession = sqlSessionFactory.openSession();
            UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
            //获取数据并解析成User对象
            User user = userMapper.selectUserById(1);
            //输出
            System.out.println(user);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            //关闭相关资源
            try {
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            sqlSession.close();
        }
    }

}

测试结果：

User{id=1, name='tian', age=19}

如上面的代码所示，SqlSession是MyBatis中提供的与数据库交互的接口，SqlSession实例通过工厂模式创建。

为了创建SqlSession对象，首先需要创建SqlSessionFactory对象，而SqlSessionFactory对象的创建依赖于SqlSessionFactoryBuilder类，该类提供了一系列重载的build()方法，我们需要以主配置文件的输入流作为参数调用SqlSessionFactoryBuilder对象的bulid()方法，该方法返回一个SqlSessionFactory对象。

有了SqlSessionFactory对象之后，调用SqlSessionFactory

对象的openSession()方法即可获取一个与数据库廞掫 gaya ="font-size: 14px; padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;background-color: rgba(27, 31, 35, 0.05);font-family: "Operator Mono", Consolas, Monaco, Menlo, monospace;word-break: break-all;color: rgb(239, 112, 96);">SqlSession实例。SqlSessionFactory对象之后，调用SqlSessionFactory对象的openSession()方法即可获取一个与数据库建立连接的SqlSession实例。

前面我们定义了UserMapper接口，这里需要调用SqlSession的getMapper()方法创建一个动态代理对象，然后调用UserMapper代理实例的方法即可完成与数据库的交互。

针对上面这个案例，我们来梳理一下MyBatis

前面我们定义了 style ="font-size: 14px; padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;background-color: rgba(27, 31, 35, 0.05);font-family: "Operator Mono", Consolas, Monaco, Menlo, monospace;word-break: break-all;color: rgb(239, 112, 96);">UserMapper接口，这里需要调用SqlSession的getMapper()方法创建一个动态代理对象，然后调用Pengguna Pengguna代理实例的方法即可完成与数据库的交麜亓的交麓的交亓的交亓。案例，我们来梳理一下MyBatis的整体执行流程 和 核心 组件 。

mybatis 核心 组件

mybatis 执行 流程

🎜

Konfigurasi

digunakan untuk menerangkan Maklumat konfigurasi utama MyBatis. Apabila komponen lain perlu mendapatkan maklumat konfigurasi, mereka boleh terus melalui Konfigurasi pemerolehan objek. Selain itu, MyBatis akan menggunakan maklumat konfigurasi Mapper, jenis alias, TypeHandler dan seterusnya didaftarkan pada Konfigurasi komponen, apabila komponen lain memerlukan maklumat ini, mereka juga boleh menggunakan Konfigurasi objek. MyBatis的主配置信息，其他组件需要获取配置信息时，直接通过Configuration对象获取。除此之外，MyBatis在应用启动时，将Mapper配置信息、类型别名、TypeHandler等注册到Configuration组件中，其他组件需要这些信息时，也可以从Configuration对象中获取。

MappedStatement

MappedStatement用于描述Mapper中的SQL配置信息，是对Mapper XML配置文件中b5d5a6a8d1a81baf21ea188537c0af35等标签或者@Select/@Update等注解配置信息的封装。

SqlSession

SqlSession是MyBatis提供的面向用户的API，表示和数据库交互时的会话对象，用于完成数据库的增删改查功能。SqlSession

🎜🎜MappedStatement🎜🎜🎜🎜MappedStatement digunakan untuk menerangkan maklumat konfigurasi SQL dalam Mapper Ia adalah sepasang XML MapperDalam fail konfigurasic9c6f6b1eb851a89e2fe4148a32bc03d dan teg lain atau @Select/@Update dan enkapsulasi maklumat konfigurasi anotasi lain. 🎜🎜🎜🎜SqlSession🎜🎜🎜🎜SqlSession ialah API berorientasikan pengguna yang disediakan oleh MyBatis, yang mewakili objek sesi apabila berinteraksi dengan pangkalan data, dan digunakan untuk melengkapkan penambahan, pemadaman, pengubahsuaian dan fungsi pertanyaan pangkalan data. SqlSession ialah penampilan komponen Pelaksana, tujuannya adalah Menyediakan antara muka operasi pangkalan data yang mudah difahami dan digunakan. 🎜

Pelaksana

Executor Ia adalah pelaksana SQL MyBatis Semua operasi penambahan, pemadaman, pengubahsuaian dan pertanyaan pangkalan data dalam MyBatis dilengkapkan oleh komponen Pelaksana. . , 31, 35, 0.05);font-family: "Operator Mono", Consolas, Monaco, Menlo, monospace;word-break: break-all;color: rgb(239, 112, 96);">StatementHandlerMerangkumkan pasanganPernyataan JDBC operasi objek , seperti menetapkan parameter untuk objek Pernyataan, memanggil kaedah yang disediakan oleh antara muka Pernyataan untuk berinteraksi dengan pangkalan data, dsb. Executor是MyBatis的SQL执行器，MyBatis中对数据库所有的增删改查操作都是由Executor组件完成的。

StatementHandler

StatementHandler封装了对JDBC Statement对象的操作，比如为Statement对象设置参数，调用Statement接口提供的方法与数据库交互，等等。

ParameterHandler

当MyBatis框架使用的Statement类型为CallableStatement和PreparedStatement时，ParameterHandler用于为Statement对象参数占位符设置值。

ResultSetHandler

ResultSetHandler

🎜🎜ParameterHandler🎜🎜🎜🎜ApabilaMyBatis kod>Jenis Pernyataan yang digunakan oleh rangka kerja ialah <code style="font-size: 14px;padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;background-color: rgba( 27, 31, 35, 0.05);font-family: " operator mono consolas monaco menlo monospace break-all rgb>CallableStatement code> dan<code style="font-size: 14px;padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;background-color: rgba(27, 31, 35, 0.05 ); font-family: " operator mono consolas monaco menlo monospace break-all rgb>PreparedStatement, ParameterHandler digunakan untuk menetapkan nilai untuk pemegang tempat parameter objek Pernyataan . 🎜🎜🎜🎜ResultSetHandler🎜🎜🎜🎜ResultSetHandler Merangkumkan operasi objek ResultSet dalam JDBC Apabila melaksanakan pernyataan SELECT jenis SQL, ResultSetHandler digunakan untuk menukar hasil pertanyaan kepada objek Java. 🎜

TypeHandler

TypeHandler Ia ialah pemproses jenis dalam MyBatis, digunakan untuk mengendalikan pemetaan antara jenis Java dan jenis JDBC. Fungsinya ditunjukkan terutamanya dalam keupayaan untuk memanggil PreparedStatement atau <code style="font-size: 14px;padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;background-color: rgba(27, 31, 35, 0.05);font-family: " operator mono consolas monaco menlo monospace break-all rgb>CallableStatement objek sepadan setXXX() menetapkan nilai; untuk objek Pernyataan. Dan boleh memanggil getXXX() Dapatkan hasil pelaksanaan SQL. TypeHandler是MyBatis中的类型处理器，用于处理Java类型与JDBC类型之间的映射。它的作用主要体现在能够根据Java类型调用PreparedStatement或CallableStatement对象对应的setXXX()方法为Statement对象设置值，而且能够根据Java类型调用ResultSet对象对应的getXXX()获取SQL执行结果。

使用JDBC API

Gunakan JDBC APIMembangunkan aplikasi, Satu aspek yang lebih rumit ialah mengendalikan penukaran antara jenis JDBC dan jenis Java. Dua situasi yang melibatkan penukaran jenis Java dan JDBC adalah seperti berikut: 🎜

• PreparedStatement objek ialah pemegang tempat parameter Apabila menetapkan nilai simbol, anda perlu memanggil PreparedStatement antara muka Satu siri setXXX() kod> Kaedah, tukar jenis Java kepada jenis JDBC yang sepadan dan tetapkan nilai kepada ruang letak parameter.
PreparedStatement对象为参数占位符设置值时，需要调用PreparedStatement接口中提供的一系列的setXXX()方法，将Java类型转换为对应的JDBC类型并为参数占位符赋值。
• 执行SQL语句获取ResultSet对象后，需要调用ResultSet对象的getXXX()方法获取字段值，此时会将JDBC类型转换为Java类型。

MyBatis提供的TypeHandler及与Java类型和JDBC类型之间的对应关系：

小结

我们使用到了SqlSession组件，它是用户层面的API。实际上SqlSession是Executor组件的外观，目的是为用户提供更友好的数据库操作接口，这是设计模式中外观模式的典型应用。

真正执行SQL操作的是Executor组件，Executor可以理解为SQL执行器，它会使用StatementHandler

Laksanakan pernyataan SQL untuk mendapatkan ResultSet objek, anda perlu memanggil getXXX() memperoleh nilai medan, dan pada masa ini jenis JDBC akan ditukar kepada jenis Java.

MyBatis Disediakan TypeHandler dan jenis Java dan JDBC Correspondence antara jenis : 🎜

🎜 figure>

Ringkasan

Kami menggunakan SqlSession komponen, yang merupakan API peringkat pengguna. SebenarnyaSqlSession ialah penampilan komponen Executor . Tujuannya adalah untuk menyediakan pengguna dengan antara muka operasi pangkalan data yang lebih mesra, yang merupakan aplikasi tipikal corak penampilan dalam corak reka bentuk. 🎜

Melaksanakan SQL The operasi ialah komponen Pelaksana boleh difahami sebagai pelaksana SQL Ia akan menggunakan StatementHandler komponen beroperasi pada objek Penyata JDBC. 🎜

Apabila jenis Penyata ialah CallableStatement dan PreparedStatement

, parameter akan diduduki oleh ParameterHandler tugasan watak komponen. ParameterHandler komponen akan mencari yang sepadan mengikut jenis Java TypeHandler objek, TypeHandler akan lulus; object -size: 14px; padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;background-color: rgba(27, 31, 35, 0.05);font-family: " Operator Mono ", Consolas, Monaco, Menlo, monospace; word-break: break-all; color: rgb(239, 112, 96);">setXXX() kaedah (seperti kaedah setString()) ialah dalam nilai tetapan pemegang tempat Parameter objek Pernyataan. CallableStatement和PreparedStatement时，会通过ParameterHandler组件为参数占位符赋值。ParameterHandler组件中会根据Java类型找到对应的TypeHandler对象，TypeHandler中会通过Statement对象提供的setXXX()方法（例如setString()方法）为Statement对象中的参数占位符设置值。

StatementHandler组件使用JDBC中的Statement对象与数据库完成交互后，当SQL语句类型为SELECT时，MyBatis通过ResultSetHandler

StatementHandler komponen menggunakan Statement dalam JDBC After objek melengkapkan interaksi dengan pangkalan data, apabila jenis pernyataan SQL ialah SELECT, MyBatis melepasi ResultSetHandler komponen memperoleh objek ResultSet daripada objek Statement, dan kemudian menukar objek ResultSet kepada objek Java.

Advanced Skills

Design Patterns Reka bentuk corak digunakan secara meluas dalam mybatis.Corak kilang

• Mod Penghias
• Corak Rantaian Tanggungjawab
• ....
Caching
Dalam aplikasi web, caching ialah komponen penting. Biasanya kami menggunakan perisian tengah caching seperti Redis atau memcached untuk memintas sejumlah besar permintaan kepada pangkalan data dan mengurangkan tekanan pada pangkalan data. Sebagai komponen penting, MyBatis secara semula jadi juga menyediakan sokongan yang sepadan secara dalaman. Dengan menambahkan fungsi caching pada peringkat rangka kerja, tekanan pada pangkalan data boleh dikurangkan dan kelajuan pertanyaan boleh dipertingkatkan pada masa yang sama Ia boleh dikatakan bahawa ia membunuh dua burung dengan satu batu.
• Struktur cache MyBatis terdiri daripada
  Kedua-dua tahap cache ialah kelas pelaksanaan menggunakan antara muka Cache. Oleh itu, dalam bab berikut, saya mula-mula akan memperkenalkan anda kepada kod sumber beberapa kelas pelaksanaan Cache, dan kemudian menganalisis pelaksanaan cache peringkat pertama dan peringkat kedua.
• Penggunaan cache peringkat pertama dan cache peringkat kedua MyBatis: Cache peringkat pertama MyBatis ialah cache peringkat SqlSession, yang didayakan secara lalai dan tidak boleh dimatikan cache peringkat kedua perlu dihidupkan dengan tetapan nilai parameter cacheEnabled dalam fail konfigurasi utama MyBatis.

  Cache peringkat pertama dilaksanakan dalam Pelaksana. Komponen MyBatis' Executor mempunyai 3 pelaksanaan yang berbeza, iaitu SimpleExecutor code>, <code style="font-size: 14px;padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;background-color: rgba(27, 31, 35, 0.05 );font-family: " operator mono consolas monaco menlo monospace break-all rgb>ReuseExecutor dan BatchExecutor. Semua kelas ini mewarisi daripada , 0.05);font-family: "Operator Mono", Consolas, Monaco, Menlo, monospace;word-break: break-all;color: rgb(239, 112, 96);">BaseExecutor code>, dalam BaseExecutor Dalam kaedah query() kelas, hasil pertanyaan pertama kali diperoleh daripada cache Jika keputusan tidak boleh diperolehi, keputusan diambil daripada pangkalan data, dan kemudian keputusan pertanyaan dicache. Cache peringkat kedua MyBatis dilaksanakan melalui mod penghias Apabila cache peringkat kedua didayakan melalui parameter cacheEnabled, rangka kerja MyBatis akan menggunakan CachingExecutor untuk SimpleExecutor, ReuseExecutoratau BatchExecutor dihias. Apabila operasi pertanyaan dilakukan, hasil pertanyaan dicache dan apabila operasi kemas kini dilakukan, cache kedua dikemas kini. Bab ini akhirnya memperkenalkan MyBatisCara mengintegrasikan Redis sebagai cache Tahap 2. SimpleExecutor、ReuseExecutor和BatchExecutor。这些类都继承自BaseExecutor，在BaseExecutor类的query()方法中，首先从缓存中获取查询结果，如果获取不到，则从数据库中查询结果，然后将查询结果缓存起来。而MyBatis的二级缓存则是通过装饰器模式实现的，当通过cacheEnabled参数开启了二级缓存，MyBatis框架会使用CachingExecutor对SimpleExecutor、ReuseExecutor或者BatchExecutor进行装饰，当执行查询操作时，对查询结果进行缓存，执行更新操作时则更新二级缓存。本章最后介绍了MyBatis如何整合Redis作为二级缓存。

  除此之外，MyBatis还支持Ehcache、OSCache

  Selain itu, MyBatis juga menyokong Ehcache code> 、<code style="font-size: 14px;padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;background-color: rgba(27, 31, 35, 0.05 ); font-family: " operator mono consolas monaco menlo monospace break-all rgb>OSCache, dsb., ciri ini Bukan biasa digunakan.

  Plug-in

  Kebanyakan rangka kerja menyokong pemalam Pengguna boleh melanjutkan fungsi mereka dengan menulis pemalam, dan Mybatis tidak terkecuali.

  MyBatis menyediakan mekanisme lanjutan yang boleh mengubah tingkah laku pelaksanaan SQL apabila melaksanakan Mapper. Mekanisme sambungan ini dilaksanakan melalui pemintas, dan pemintas yang ditentukan pengguna juga dipanggil pemalam MyBatis. 🎜

  Rangka kerja MyBatis menyokong pemintasan Executor、ParameterHandler、ResultSetHandler、StatementHandlerempat kaedah komponen. Kuasai prinsip pelaksanaan pemalam MyBatis, dan kemudian laksanakan pemalam pertanyaan paging dan pemalam statistik SQL yang perlahan Apabila fungsi yang kita perlukan tidak dapat dipenuhi oleh rangka kerja MyBatis, kita boleh mempertimbangkan untuk melaksanakannya melalui palam tersuai -dalam.

  Pelaksanaan klasik: PageHelper.

  Log

  MyBatis menyediakan pelaksanaan yang sepadan antara muka Log untuk rangka kerja pengelogan yang berbeza Kelas pelaksanaan antara muka Log ditunjukkan dalam rajah di bawah. Seperti yang dapat dilihat dari kelas pelaksanaan, MyBatis menyokong 7 pelaksanaan log yang berbeza, seperti berikut.

  

  Berikut ialah penjelasan ringkas tentang beberapa yang biasa digunakan:

  • Pengelogan Apache Commons: Gunakan JCL untuk mengeluarkan log.
  • Log4j 2: Gunakan rangka kerja Log4j 2 untuk memasukkan log.
  • Java Util Logging: Gunakan modul pengelogan terbina dalam JDK untuk mengeluarkan log.
  • Log4j: Gunakan rangka kerja Log4j untuk mengeluarkan log.
  • Tiada Pembalakan: Tiada log dikeluarkan.
  • SLF4J: Gunakan fasad log SLF4J untuk mengeluarkan log.
  • Stdout: Log keluaran ke peranti output standard (seperti konsol).

  Turutan MyBatis mencari rangka kerja log ialah

  SLF4J→JCL→Log4j2→Log4j→JUL→Tiada Pengelogan.

  Jika tiada rangka kerja pengelogan di bawah Classpath, kelas pelaksanaan log NoLoggingImpl digunakan, iaitu tiada log dikeluarkan.

  Dynamic SQL binding

  Dynamic SQL merujuk kepada fakta bahawa keadaan khusus tidak boleh diramalkan terlebih dahulu, dan pernyataan SQL perlu dijana secara dinamik mengikut situasi khusus semasa runtime.

  Terdapat teg SQL dinamik yang kaya dalam MyBatis, seperti: de56068390baba878665225fbcf338c6, 1c5edfc69b6b73b0aed10ff54eceb505Tunggu. 196185dae55b7edbe154a5051db664a7、f3bf5eff46860b27119c8dd4e92f1e57、7c3646f85db7ce074bf2e07d38d2c6e1、800a174bf160103126f2a6097b3e44a4等。

  在MyBatis源码中有个SqlSource对象会作为MappedStatement对象的属性保存在MappedStatement对象中。执行Mapper时，会根据传入的参数信息调用SqlSource对象的getBoundSql()方法获取BoundSql对象，这个过程就完成了将SqlNode对象转换为SQL语句的过程。

  比如：，#{}

  Dalam kod sumber MyBatis, terdapat objek SqlSource yang akan disimpan dalam objek MappedStatement sebagai sifat objek MappedStatement. Apabila Mapper dilaksanakan, kaedah getBoundSql() objek SqlSource dipanggil berdasarkan maklumat parameter masuk untuk mendapatkan objek BoundSql Proses ini melengkapkan proses menukar objek SqlNode kepada pernyataan SQL.

  Contohnya:, #{} Pemegang tempat akaun akan digantikan dengan "?", dan kemudian kaedah setXXX() objek PreparedStatement dalam JDBC dipanggil untuk menetapkan nilai untuk pemegang tempat parameter dan pemegang tempat ${} akan diganti terus dengan teks parameter yang diluluskan kandungan. Ringkasan

Artikel ini adalah pengalaman keseluruhan analisis kod sumber MyBatis, saya harap ia akan membantu anda. 🎜🎜🎜

Atas ialah kandungan terperinci Selepas mempelajari kod sumber MyBatis dalam satu minggu, saya mendapat ringkasan 10,000 perkataan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!