MyBatis - 快速指南

ゞ浴缸里的玫瑰 2023-09-25 12:22 166阅读 0赞

## 米巴蒂斯 - 概述 ##

MyBatis是一个开源的、轻量级的、持久的框架。它是 **JDBC** 和**休眠的替代方法**。它自动执行 SQL 数据库与 Java、.NET 和轨道上的 Ruby 中的对象之间的映射。通过将 SQL 语句打包到 XML 配置文件中，将映射与应用程序逻辑分离。

它提取了几乎所有的 JDBC 代码，并减轻了手动设置参数和检索结果的负担。它提供了一个简单的 API 来与数据库进行交互。它还提供对自定义 SQL、存储过程和高级映射的支持。

它以前被称为**IBTIS**，由克林顿贝京于2002年创立。我的巴蒂斯3是最新版本。这是对伊巴蒂斯的彻底改造。

MyBatis与其他持久性框架之间的显着区别在于，MyBatis强调使用SQL，而其他框架（如休眠）通常使用自定义查询语言，即休眠查询语言（HQL）或企业爪哇Beans查询语言（EJB QL）。

### 米巴蒂斯设计特点 ###

我的巴蒂斯具有以下设计理念 -

*  **简单**性 - MyBatis被广泛认为是当今最简单的持久性框架之一。
 *  **快速开发** − MyBatis 尽其所能促进超快速开发。
 *  **可移植性** \- MyBatis几乎可以用于任何语言或平台，例如适用于微软.NET的Java，Ruby和C\#。
 *  **独立接口** − MyBatis 提供独立于数据库的接口和 API，可帮助应用程序的其余部分独立于任何与持久性相关的资源。
 *  **开源** − MyBatis 是免费的开源软件。

### 米巴蒂斯的优势 ###

麦巴蒂斯具有以下优势 -

*  **支持存储过程** − MyBatis 以存储过程的形式封装 SQL，以便业务逻辑可以保留在数据库之外，并且应用程序更具可移植性，更易于部署和测试。
 *  **支持内联 SQL** − 无需预编译器，您可以完全访问 SQL 的所有功能。
 *  **支持动态 SQL** − MyBatis 提供了基于参数动态构建 SQL 查询的功能。
 *  **支持 O/RM** − MyBatis 支持许多与 O/RM 工具相同的功能，例如延迟加载、联接提取、缓存、运行时代码生成和继承。

![32ea2f69373441a268a86f221e429e68.jpeg][]

我的巴蒂斯在开发面向数据库的应用程序时使用JAVA编程语言。在继续之前，请确保您了解过程和面向对象编程的基础知识 - 控制结构，数据结构和变量，类，对象等。

要详细了解 JAVA，您可以浏览我们的 [JAVA 教程][JAVA]。

## 米巴蒂斯 - 环境 ##

在开始实际的开发工作之前，您必须为 MyBatis 设置一个合适的环境。本章介绍如何为 MyBatis 设置工作环境。

### 我的巴蒂斯安装 ###

执行以下简单步骤在您的机器上安装 MyBatis -

*  从下载我的巴蒂斯下载最新版本的[我的巴蒂斯][Link 1]。
 *  从下载 MySQL [连接器下载最新版本的我的连接器][Link 2]。
 *  解压缩下载的文件以提取.jar文件并将其保存在适当的文件夹/目录中。
 *  为提取的.jar文件设置类路径变量。

### 数据库设置 ###

使用以下语法在任何MySQL数据库中创建员工表 -

mysql> DROP TABLE IF EXISTS details.student;
    CREATE TABLE  details.student(
       ID int(10) NOT NULL AUTO_INCREMENT,  
       NAME varchar(100) NOT NULL,
       BRANCH varchar(255) NOT NULL,
       PERCENTAGE int(3) NOT NULL,  
       PHONE int(10) NOT NULL,
       EMAIL varchar(255) NOT NULL,
       PRIMARY KEY ( ID )
    );

### 我的巴蒂斯日食设置 ###

如果您想使用eclips开发MyBatis应用程序，请执行以下步骤 -

![f3ca2612f5749d69ca4285daf8b74c0e.jpeg][]

<project xmlns = "http://maven.apache.org/POM/4.0.0" xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
       xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    
       <modelVersion>4.0.0</modelVersion>
       <groupId>mybatisfinalexamples</groupId>
       <artifactId>mybatisfinalexamples</artifactId>
       <version>0.0.1-SNAPSHOT</version>
      
       <build>
          <sourceDirectory>src</sourceDirectory>
    		
          <plugins>
             <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                   <source>1.8</source>
                   <target>1.8</target>
                </configuration>
             </plugin>
          </plugins>
    		
       </build>
      
       <dependencies>
    	
          <dependency>
             <groupId>org.mybatis</groupId>
             <artifactId>mybatis</artifactId>
             <version>3.3.0</version>
          </dependency>	
    	 
          <dependency>
             <groupId>mysql</groupId>
             <artifactId>mysql-connector-java</artifactId>
             <version>5.1.6</version>
          </dependency>
    		
       </dependencies>  
    	
    </project>

## MYBATIS - 配置 XML ##

在上一章中，我们已经看到了如何安装我的巴蒂斯。本章讨论如何使用 XML 文件配置我的巴蒂斯。

由于我们正在与数据库通信，因此我们必须配置数据库的详细信息。*配置 XML* 是用于基于 XML 的配置的文件。通过使用此文件，您可以配置各种元素。

以下编程是 MyBatis 配置文件的典型结构。

让我们逐一讨论配置 XML 文件的重要元素（标记）。

### 环境标记 ###

在环境元素中，我们配置在应用程序中使用的数据库的环境。在 MyBatis 中，您可以通过配置多个*环境*元素来连接到多个数据库。为了配置环境，我们提供了两个子标签，即**事务管理器**和**数据源**。

#### 事务管理器标记 ####

MyBatis 支持两个事务管理器，即 **JDBC** 和**托管**

*  如果我们使用 **JDBC** 类型的事务管理器，则应用程序负责事务管理操作，例如，提交、回滚等...
 *  如果我们使用 MANAGED 类型的事务管理器**，**则应用程序服务器负责管理连接生命周期。它通常与 Web 应用程序一起使用。

#### 数据源标记 ####

它用于配置数据库的连接属性，例如要连接的数据库的驱动程序名称、URL、用户名和密码。它有三种类型，即 −

*  **未池化** − 对于数据源类型解池，MyBatis 只需为每个数据库操作打开和关闭一个连接。它有点慢，通常用于简单的应用程序。
 *  **池化** − 对于数据源类型池化，MyBatis 将维护一个数据库连接池。而且，对于每个数据库操作，MyBatis 都会使用这些连接之一，并在操作完成后将它们返回到池中。它减少了创建新连接所需的初始连接和身份验证时间。
 *  **JNDI** − 对于数据源类型 JNDI，我的巴蒂斯将从 JNDI 数据源获取连接。

以下是在实践中使用环境标记的方法 -

### 类型别名标记 ###

我们可以使用 typeAliases，而不是在任何地方指定绝对类名，这是 Java 类型的缩写名称。假设我们在“学生.java”包中有一个名为 *tutorials\_point.com.mybatis\_examples 的*类文件，则绝对类名将为 *tutorials\_point.com.mybatis\_examples。学生。*您可以声明该类的别名，而不是每次都使用此名称来寻址该类，如下所示 -

### 映射器标记 ###

映射器 XML 文件是重要的文件，其中包含映射的 SQL 语句。映射器的元素用于在 MyBatis 的配置文件中配置这些映射器 xml 文件的位置（此元素包含四个属性，即资源、url、类和名称）。

例如，映射器 xml 文件的名称为***学生.xml***它驻留在名为 **mybatis** 的包中，然后您可以配置映射器标记，如下所示。

*  属性**资源**指向 XML 文件的类路径。
 *  属性 **url** 指向 xml 文件的完全限定路径。
 *  我们可以使用映射器接口而不是 xml 文件，属性**类**指向映射器接口的类路径。
 *  属性**名称**指向映射器接口的包名称。在本章提供的示例中，我们使用 resource 属性指定了映射器 XML 的类路径。

除此之外，还可以在 [MyBatis 文档][MyBatis]的配置文件中使用其他元素。有关完整的详细信息，请参阅我的巴蒂斯文档。

### 我的巴蒂斯与我的SQL数据库 ###

MySQL是当今最流行的开源数据库系统之一。让我们创建一个**.xml**配置文件来连接到 mysql 数据库。下面给出的示例是MySQL数据库的数据源属性（驱动程序名称，网址，用户名和密码） -

<table> 
 <tbody> 
  <tr> 
   <th>Sr.No。</th> 
   <th>属性名称</th> 
   <th>价值</th> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td>司机</td> 
   <td>com.mysql.jdbc.Driver</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>网址</td> 
   <td>jdbc：mysql：//localhost：3306/详细信息（假设数据库是“详细信息”）</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>用户名</td> 
   <td>根</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>密码</td> 
   <td>密码</td> 
  </tr> 
 </tbody> 
</table>

我们使用 JDBC 类型的事务管理器，这意味着我们必须在应用程序中执行手动提交和回滚等操作。

我们使用数据类型为 UNPOOLED，这意味着将为每个数据库操作创建新连接。因此，建议在数据库操作完成后手动关闭连接。

### SqlMapConfig.xml ###

下面给出的是本教程中使用的示例的 XML 配置。将下面给出的内容复制到文本文件中，并将其另存为 **sqlMap配置.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>
    		
       <environments default = "development">
          <environment id = "development">
             <transactionManager type = "JDBC"/> 
    			
             <dataSource type = "POOLED">
                <property name = "driver" value = "com.mysql.jdbc.Driver"/>
                <property name = "url" value = "jdbc:mysql://localhost:3306/details"/>
                <property name = "username" value = "root"/>
                <property name = "password" value = "password"/>
             </dataSource>   
             
          </environment>
       </environments>
    	
       <mappers>
          <mapper resource = "mybatis/Student.xml"/>
       </mappers>
       
    </configuration>

## 米巴蒂斯 - 映射器 XML ##

在上一章中，我们已经了解了如何使用 XML 文件配置我的巴蒂斯。本章讨论映射器 XML 文件及其提供的各种映射 SQL 语句。

在继续映射语句之前，假设 MYSQL 数据库中存在名为**“学生**”的下表 −

+----+-------+--------+------------+-----------+---------------+
    | ID |  NAME | BRANCH | PERCENTAGE |   PHONE   |     EMAIL     |
    +----+-------+--------+------------+-----------+---------------+
    |  1 | Shyam |   it   |     80     | 954788457 | mail@mail.com |
    +----+-------+--------+------------+-----------+---------------+

还假设POJO类也存在，相对于上表，名为**“学生**”，如下所示 -

public class Student {
       private int id;
       private String name;
       private String branch;
       private int percentage;
       private int phone;
       private String email;
       
       //Setters and getters   
    }

### 映射语句 ###

映射器 XML 是 MyBatis 中的一个重要文件，其中包含一组语句来配置各种 SQL 语句，如选择、插入、更新和删除。这些语句称为**映射语句**或**映射 SQL 语句**。

*  所有语句都具有唯一的 ID。要执行这些语句中的任何一个，您只需将适当的id传递给Java应用程序中的方法。（这在后面的章节中会清楚地讨论）。
 *  映射器 XML 文件可防止在应用程序中重复编写 SQL 语句的负担。与 JDBC 相比，几乎 95% 的代码是使用 MyBatis 中的映射器 XML 文件减少的。
 *  所有这些映射的 SQL 语句都驻留在名为**<映射器>**的元素中。此元素包含一个名为**“命名空间”的属性**。

<mapper namespace = "Student">
       //mapped statements and result maps
    <mapper>

下面将讨论所有映射的 SQL 语句以及示例。

#### 插入 ####

在 MyBatis 中，要将值插入到表中，我们必须配置插入映射查询。MyBatis为插入映射器提供了各种属性，但主要使用id和参数类型。

**id** 是用于标识插入语句的唯一标识符。另一方面，**parametertype** 是将传递到语句中的参数的类名或别名。下面给出的是插入映射查询的示例 -

<insert id = "insert" parameterType = "Student">
       INSERT INTO STUDENT1 (NAME, BRANCH, PERCENTAGE, PHONE, EMAIL ) 
       VALUES (#{name}, #{branch}, #{percentage}, #{phone}, #{email});    
    </insert>

在给定的示例中，我们使用类型为“学生（类）”的参数。班级学生是 POJO 班级，它表示以姓名、分支、百分比、电话和电子邮件作为参数的学生记录。

您可以使用 Java API 调用“插入”映射查询，如下所示 −

//Assume session is an SqlSession object.  
    session.insert("Student.insert", student);

#### 更新 ####

要使用 MyBatis 更新现有记录的值，请配置映射的查询更新。更新映射查询的属性与插入映射查询的属性相同。以下是更新映射查询的示例 −

<update id = "update" parameterType = "Student">
       UPDATE STUDENT SET EMAIL = #{email}, NAME = #{name}, BRANCH = #{branch}, PERCENTAGE = #{percentage}, PHONE = #{phone} WHERE ID = #{id};
    </update>

要调用更新查询，请实例化 Student 类，设置表示需要更新的列的变量的值，并将此对象作为参数传递给 **update（）** 方法。您可以使用 Java API 调用更新映射查询，如下所示 −

//Assume session is an SqlSession object.  
    session.update("Student.update",student);

#### 删除 ####

要使用 MyBatis 删除现有记录的值，请配置映射的查询“删除”。“删除”映射查询的属性与插入和更新映射查询的属性相同。以下是删除映射查询的示例 −

<delete id = "deleteById" parameterType = "int">
       DELETE from STUDENT WHERE ID = #{id};
    </delete>

您可以使用 MyBatis Java API 提供的 **SqlSession** 接口的删除方法来调用删除映射查询，如下所示 −

//Assume session is an SqlSession object.  
    session.delete("Student.deleteById", 18);

#### 选择 ####

为了检索数据，请使用“选择”映射器语句。以下是选择映射查询以检索表中的所有记录的示例 −

<select id = "getAll" resultMap = "result">
       SELECT * FROM STUDENT; 
    </select>

您可以使用 **selectList（）** 方法检索选择查询返回的数据。此方法以 List 的形式返回所选记录的数据，如下所示 −

List<Student> list = session.selectList("Student.getAll");

#### 结果地图 ####

它是MyBatis中最重要和最强大的元素。SQL 选择语句的结果将映射到 Java 对象（字节/便笺）。定义结果映射后，我们可以从多个 SELECT 语句中引用这些映射。以下是结果地图查询的示例;它将选择查询的结果映射到学生类 -

<resultMap id = "result" type = "Student">
       <result property = "id" column = "ID"/>
       <result property = "name" column = "NAME"/>
       <result property = "branch" column = "BRANCH"/>
       <result property = "percentage" column = "PERCENTAGE"/>
       <result property = "phone" column = "PHONE"/>
       <result property = "email" column = "EMAIL"/>
    </resultMap>
    
    <select id = "getAll" resultMap = "result">
       SELECT * FROM STUDENT; 
    </select>
    
    <select id = "getById" parameterType = "int" resultMap = "result">
       SELECT * FROM STUDENT WHERE ID = #{id};
    </select>

**注意** − 如果表的属性和*列*名相同，则不一定要写入 resultMap 的列属性。

## 米巴蒂斯 - 创建操作 ##

要使用 MyBATIS 执行任何创建、读取、更新和删除 （CRUD） 操作，您需要创建与该表对应的普通旧 Java 对象 （POJO） 类。此类描述将“建模”数据库表行的对象。

POJO 类将实现执行所需操作所需的所有方法。

在MySQL数据库中创建学生表，如下所示 -

mysql> CREATE TABLE details.student(
       ->   ID int(10) NOT NULL AUTO_INCREMENT,
       ->   NAME varchar(100) NOT NULL,
       ->   BRANCH varchar(255) NOT NULL,
       ->   PERCENTAGE int(3) NOT NULL,
       ->   PHONE int(11) NOT NULL,
       ->   EMAIL varchar(255) NOT NULL,
       ->   PRIMARY KEY (`ID`)
       -> 
    );
    Query OK, 0 rows affected (0.37 sec)

### 学生普约班 ###

在学生.java文件中将学生班级创建为

public class Student {
       private int id;
       private String name;
       private String branch;
       private int percentage;
       private int phone;
       private String email;
    
       public Student(String name, String branch, int percentage, int phone, String email) {
          super();
          this.name = name;
          this.branch = branch;
          this.percentage = percentage;
          this.phone = phone;
          this.email = email;
       }
       
    }

您可以定义方法来设置表中的各个字段。下一章介绍如何获取各个字段的值。

### 学生.xml文件 ###

要使用 MyBatis 定义 SQL 映射语句，我们将使用**<插入>** 标记。在此标记定义中，我们将定义一个**“id”。**此外，“id”将用于.java插入文件中，用于对数据库执行 SQL INSERT 查询。创建学生.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 = "Student">
    
       <insert id = "insert" parameterType = "Student">
          INSERT INTO STUDENT (NAME, BRANCH, PERCENTAGE, PHONE, EMAIL ) VALUES (#{name}, #{branch}, #{percentage}, #{phone}, #{email});
    			
          <selectKey keyProperty = "id" resultType = "int" order = "AFTER">
             select last_insert_id() as id
          </selectKey>   
    			
       </insert>
        	
    </mapper>

在这里，**parameteType** − 可以根据需要将值作为*字符串、整数、浮点数、双精度*或任何类*对象*。在此示例中，我们将学生对象作为参数传递，同时调用 **SqlSession** 类的*插入*方法。

如果数据库表使用标识、AUTO\_INCREMENT或串行列，或者已定义序列/生成器，则可以使用<插入>语句中的<**选择密钥****>** 元素来使用或返回该数据库生成的值。

### mybatis插入.java文件 ###

此文件将具有应用程序级逻辑，用于在 Student 表中插入记录。创建并保存**.java文件，**如下所示 −

### 编译和执行 ###

以下是编译和运行.java插入文件的步骤。在继续编译和执行之前，请确保已正确设置路径和类路径。

*  创建学生.xml如上所示。
 *  创建 sqlMap配置.xml如本教程的[“我的教程 - 配置 XML”][- _ XML]一章所示。
 *  创建学生.java如上所示并编译它。
 *  创建.java并编译它，如上所示。
 *  执行我的巴蒂斯插入二进制文件以运行程序。

您将获得以下结果，并将在 STUDENT 表中创建一条记录。

$java mybatisInsert
    Record Inserted Successfully

如果您检查学生表，它应该显示以下结果 -

## 米巴蒂斯 - 读取操作 ##

我们在上一章中讨论了如何使用 MyBatis 通过执行 CREATE 操作将值插入到学生表中。本章介绍如何使用 MyBatis 读取表中的数据。

我们在MySQL中有以下学生表 -

CREATE TABLE details.student(
       ID int(10) NOT NULL AUTO_INCREMENT,
       NAME varchar(100) NOT NULL,
       BRANCH varchar(255) NOT NULL,
       PERCENTAGE int(3) NOT NULL,
       PHONE int(11) NOT NULL,
       EMAIL varchar(255) NOT NULL,
       PRIMARY KEY (`ID`)
    );

假设，此表有两条记录为 −

+----+----------+--------+------------+-----------+--------------------+
    | ID |  NAME    | BRANCH | PERCENTAGE |   PHONE   |      EMAIL         |
    +----+----------+--------+------------+-----------+--------------------+
    | 1  | Mohammad |   It   |     80     | 984803322 | Mohammad@gmail.com |
    | 2  | shyam    |   It   |     75     | 984800000 | shyam@gmail.com    |
    +----+----------+--------+------------+-----------+--------------------+

### 学生普约班 ###

要执行读取操作，我们将“学生.java”中的“学生”类修改为 −

### 学生.xml文件 ###

要使用 MyBatis 定义 SQL 映射语句，我们将在学生.xml文件中添加**<选择**> 标记，在此标记定义中，我们将定义一个**“id”，该 id“**将在 mybatisRead.java 文件中用于对数据库执行 SQL SELECT 查询。在读取记录时，我们可以一次获取所有记录，也可以使用 where 子句获取特定记录。在下面给出的 XML 中，您可以观察这两个查询。

要检索特定记录，我们需要一个唯一键来表示该记录。因此，我们还定义了“学生”类型的结果映射“id”（唯一键），以使用“学生类”变量映射选择查询的结果。

### mybatisRead\_ALL.java文件 ###

此文件具有应用程序级逻辑，用于从 Student 表中读取所有记录。创建并保存**mybatisRead\_ALL.java**文件，如下所示 −

import java.io.IOException;
    import java.io.Reader;
    import java.util.List;
    
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    
    public class mybatisRead_ALL { 
    
       public static void main(String args[]) throws IOException{
    
          Reader reader = Resources.getResourceAsReader("SqlMapConfig.xml");
          SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);		
          SqlSession session = sqlSessionFactory.openSession();
          
          //select contact all contacts		
          List<Student> student = session.selectList("Student.getAll");
              
          for(Student st : student ){    	  
             System.out.println(st.getId());
             System.out.println(st.getName());
             System.out.println(st.getBranch());
             System.out.println(st.getPercentage());         
             System.out.println(st.getEmail());        
             System.out.println(st.getPhone());   
          }  
    		
          System.out.println("Records Read Successfully ");          
          session.commit();   
          session.close();			
       }
    }

### 编译和执行 ###

以下是编译和运行mybatisRead\_ALL文件的步骤。在继续编译和执行之前，请确保已正确设置路径和类路径。

*  创建学生.xml如上所示。
 *  创建学生.java如上所示并编译它。
 *  如上所述创建mybatisRead\_ALL.java并编译它。
 *  执行mybatisRead\_ALL二进制文件以运行该程序。

您将获得学生表的所有记录 -

++++++++++++++ details of the student who's id is  :1 +++++++++++++++++++
    1
    Mohammad
    It
    80
    Mohammad@gmail.com
    984803322
    ++++++++++++++ details of the student who's id is  :2
    +++++++++++++++++++
    2
    shyam
    It
    75
    shyam@gmail.com
    984800000
    Records Read Successfully

### 读取特定记录 ###

复制并保存以下程序，名称**为 mybatisRead\_byID** −

import java.io.IOException;
    import java.io.Reader;
    
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    
    public class mybatisRead_byID { 
    
       public static void main(String args[]) throws IOException{
          
          int i = 1;
          Reader reader = Resources.getResourceAsReader("SqlMapConfig.xml");
          SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);		
          SqlSession session = sqlSessionFactory.openSession();      
    	  
          //select a particular student  by  id	
          Student student = (Student) session.selectOne("Student.getById", 2); 
    	  
          //Print the student details
          System.out.println(student.getId());
          System.out.println(student.getName());
          System.out.println(student.getBranch());
          System.out.println(student.getPercentage());      
          System.out.println(student.getEmail());      
          System.out.println(student.getPhone());
    		
          session.commit();
          session.close();
    			
       }
       
    }

### 编译和执行 ###

以下是编译和运行mybatisRead\_byID文件的步骤。在继续编译和执行之前，请确保已正确设置路径和类路径。

*  创建学生.xml如上所示。
 *  创建 sqlMap配置.xml如本教程的[“我的教程 - 配置 XML”][- _ XML]一章所示。
 *  创建学生.java如上所示并编译它。
 *  如上所述创建mybatisRead\_byID.java并编译它。
 *  执行mybatisRead\_byID二进制文件以运行该程序。

您将获得以下结果，并且将从 Student 表中读取一条记录，如下所示 ：

2
    shyam
    It
    75
    shyam@gmail.com
    984800000

## 米巴蒂斯 - 更新操作 ##

在上一章中，我们讨论了如何使用 MyBatis 对表执行读取操作。本章说明如何使用它更新表中的记录。

我们在MySQL中有以下学生表 -

假设此表有两条记录，如下所示 −

mysql> select * from STUDENT;
    +----+----------+--------+------------+-----------+--------------------+
    | ID |   NAME   | BRANCH | PERCENTAGE |   PHONE   |      EMAIL         |
    +----+----------+--------+------------+-----------+--------------------+
    | 1  | Mohammad |   It   |     80     | 984803322 | Mohammad@gmail.com |
    | 2  | shyam    |   It   |     75     | 984800000 | shyam@gmail.com    |
    +----+----------+--------+------------+-----------+--------------------+

### 学生普约班 ###

要执行更新操作，您需要将学生.java文件修改为 −

public class Student {
    
       private int id;
       private String name;
       private String branch;
       private int percentage;
       private int phone;
       private String email;
    
       public Student(int id, String name,  String branch, int percentage, int phone, String email) {
          super();
          this.id = id;
          this.name = name;
          this.setBranch(branch);
          this.setPercentage(percentage);
          this.phone = phone;
          this.email = email;
       }
    	
       public Student() {}
    
       public int getId() {
          return id;
       }
    	
       public void setId(int id) {
          this.id = id;
       }
    	
       public String getName() {
          return name;
       }
    	
       public void setName(String name) {
          this.name = name;
       }
    	
       public int getPhone() {
          return phone;
       }
    	
       public void setPhone(int phone) {
          this.phone = phone;
       }
    	
       public String getEmail() {
          return email;
       }
    	
       public void setEmail(String email) {
          this.email = email;
       }
    
       public String getBranch() {
          return branch;
       }
    
       public void setBranch(String branch) {
          this.branch = branch;
       }
    
       public int getPercentage() {
          return percentage;
       }
    
       public void setPercentage(int percentage) {
          this.percentage = percentage;
       }
    	
       public String toString(){
          StringBuilder sb = new StringBuilder();
    		
          sb.append("Id = ").append(id).append(" - ");
          sb.append("Name = ").append(name).append(" - ");
          sb.append("Branch = ").append(branch).append(" - ");
          sb.append("Percentage = ").append(percentage).append(" - ");
          sb.append("Phone = ").append(phone).append(" - ");
          sb.append("Email = ").append(email);
    		
          return sb.toString();
       }
    	
    }

### 学生.xml文件 ###

要使用 MyBatis 定义 SQL 映射语句，我们将在学生**中添加<更新>** 标记.xml在此标记定义中，我们将定义一个**“id”**，该 id“将在 mybatisUpdate.java文件中用于对数据库执行 SQL UPDATE 查询。

<?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 = "Student">	
       <resultMap id = "result" type = "Student">
          <result property = "id" column = "ID"/>
          <result property = "name" column = "NAME"/>
          <result property = "branch" column = "BRANCH"/>
          <result property = "percentage" column = "PERCENTAGE"/>
          <result property = "phone" column = "PHONE"/>
          <result property = "email" column = "EMAIL"/>
       </resultMap>
        
       <select id = "getById" parameterType = "int" resultMap = "result">
          SELECT * FROM STUDENT WHERE ID = #{id};
       </select>
      	
       <update id = "update" parameterType = "Student">
          UPDATE STUDENT SET NAME = #{name}, 
             BRANCH = #{branch}, 
             PERCENTAGE = #{percentage}, 
             PHONE = #{phone}, 
             EMAIL = #{email} 
          WHERE ID = #{id};
       </update>
        	
    </mapper>

### mybatis更新.java文件 ###

此文件具有应用程序级逻辑，用于将记录更新到 Student 表中 −

import java.io.IOException;
    import java.io.Reader;
    
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    
    public class mybatisUpdate { 
    
       public static void main(String args[]) throws IOException{
          
          Reader reader = Resources.getResourceAsReader("SqlMapConfig.xml");
          SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);		
          SqlSession session = sqlSessionFactory.openSession();
          
          //select a particular student using id		
          Student student = (Student) session.selectOne("Student.getById", 1);
          System.out.println("Current details of the student are" );
          System.out.println(student.toString());  
          
          //Set new values to the mail and phone number of the student
          student.setEmail("mohamad123@yahoo.com");
          student.setPhone(90000000);
          
          //Update the student record
          session.update("Student.update",student);
          System.out.println("Record updated successfully");   
          session.commit();   
          session.close();	  
    	  
          //verifying the record 
          Student std = (Student) session.selectOne("Student.getById", 1);
          System.out.println("Details of the student after update operation" );
          System.out.println(std.toString());   
          session.commit();   
          session.close();
    			
       }
    }

### 编译和运行 ###

以下是编译和运行我的生日更新.java的步骤。在继续编译和执行之前，请确保已正确设置路径和类路径。

*  创建学生.xml如上所示。
 *  创建 sqlMap配置.xml如本教程的[“我的教程 - 配置 XML”][- _ XML]一章所示。
 *  创建学生.java如上所示并编译它。
 *  创建 mybatis更新.java如上所示并编译它。
 *  执行 mybatis更新二进制文件以运行该程序。

你会得到以下结果。您最初可以看到特定记录的详细信息，该记录将在 STUDENT 表中更新，稍后，您还可以看到更新的记录。

Current details of the student are
    Id = 1 - Name = Mohammad - Branch = It - Percentage = 80 - Phone = 984802233 - Email = mohammad@gmail.com
    Record updated successfully
    Details of the student after update operation
    Id = 1 - Name = Mohammad - Branch = It - Percentage = 80 - Phone = 90000000 - Email = mohamad123@yahoo.com

如果您检查学生表，它应该显示以下结果 -

mysql> select * from student;
    +----+----------+--------+------------+-----------+----------------------+
    | ID |  NAME    | BRANCH | PERCENTAGE |  PHONE    |       EMAIL          |
    +----+----------+--------+------------+-----------+----------------------+
    | 1  | Mohammad |  It    |     80     |  90000000 | mohamad123@yahoo.com |
    | 2  | shyam    |  It    |     75     | 984800000 | shyam@gmail.com      |
    +----+----------+--------+------------+-----------+----------------------+
    2 rows in set (0.00 sec)

## 米巴蒂斯 - 删除操作 ##

本章介绍如何使用 MyBatis 从表中删除记录。

我们在MySQL中有以下学生表 -

假设，此表有两条记录为 −

mysql> select * from STUDENT;
    +----+----------+--------+------------+-----------+----------------------+
    | ID |  NAME    | BRANCH | PERCENTAGE |  PHONE    |       EMAIL          |
    +----+----------+--------+------------+-----------+----------------------+
    | 1  | Mohammad |   It   |     80     | 900000000 | mohamad123@yahoo.com |
    | 2  | shyam    |   It   |     75     | 984800000 | shyam@gmail.com      |
    +----+----------+--------+------------+-----------+----------------------+
    2 rows in set (0.00 sec)

### 学生普乔班 ###

要执行删除操作，您无需修改学生.java文件。让我们保持上一章中的样子。

public class Student {
    
       private int id;
       private String name;
       private String branch;
       private int percentage;
       private int phone;
       private String email;
    
       public Student(int id, String name, String branch, int percentage, int phone, String email) {
          super();
          this.id = id;
          this.name = name;
          this.setBranch(branch);
          this.setPercentage(percentage);
          this.phone = phone;
          this.email = email;
       }
    	
       public Student() {}
    
       public int getId() {
          return id;
       }
    	
       public void setId(int id) {
          this.id = id;
       }
    	
       public String getName() {
          return name;
       }
    	
       public void setName(String name) {
          this.name = name;
       }
    	
       public int getPhone() {
          return phone;
       }
    	
       public void setPhone(int phone) {
          this.phone = phone;
       }
    	
       public String getEmail() {
          return email;
       }
    	
       public void setEmail(String email) {
          this.email = email;
       }
    
       public String getBranch() {
          return branch;
       }
    
       public void setBranch(String branch) {
          this.branch = branch;
       }
    
       public int getPercentage() {
          return percentage;
       }
    
       public void setPercentage(int percentage) {
          this.percentage = percentage;
       }
    	
       public String toString(){
          StringBuilder sb = new StringBuilder();
    		
          sb.append("Id = ").append(id).append(" - ");
          sb.append("Name = ").append(name).append(" - ");
          sb.append("Branch = ").append(branch).append(" - ");
          sb.append("Percentage = ").append(percentage).append(" - ");
          sb.append("Phone = ").append(phone).append(" - ");
          sb.append("Email = ").append(email);
    		
          return sb.toString();
       }
    	
    }

### 学生.xml文件 ###

要使用 MyBatis 定义 SQL 映射语句，我们将在学生**.xml中使用<删除**> 标记，在此标记定义中，我们将定义一个“id”，该 id“将用于 mybatisDelete.java 文件中，用于对数据库执行 SQL DELETE 查询。

### 我的巴蒂斯删除.java文件 ###

此文件具有应用程序级逻辑，用于从 Student 表中删除记录 −

### 编译和运行 ###

以下是编译和运行我的删除.java的步骤。在继续编译和执行之前，请确保已正确设置路径和类路径。

*  创建学生.xml如上所示。
 *  创建 sqlMap配置.xml如本教程的[“我的教程 - 配置 XML”][- _ XML]一章所示。
 *  创建学生.java如上所示并编译它。
 *  创建我的巴蒂斯删除.java如上所示并编译它。
 *  执行 mybatis删除二进制文件以运行该程序。

您将获得以下结果，并且 ID = 1 的记录将从学生中删除。

Records Read Successfully

如果您检查学生表，它应该显示以下结果 -

## 米巴蒂斯 - 注释 ##

在前面的章节中，我们已经看到了如何使用 MyBatis 执行凝乳操作。在那里，我们使用映射器XML文件来存储映射的SQL语句，并使用配置XML文件来配置MyBatis。

为了映射 SQL 语句，我的巴蒂斯还提供了注释。因此，本章讨论如何使用 MyBatis 注释。

在使用注释时，我们可以使用Java映射器接口来映射和执行SQL查询，而不是配置XML文件。

假设，我们在MySQL中有以下员工表 -

假设此表有两条记录为 −

mysql> select * from STUDENT;
    +----+----------+--------+------------+-----------+--------------------+
    | ID |  NAME    | BRANCH | PERCENTAGE |   PHONE   |      EMAIL         |
    +----+----------+--------+------------+-----------+--------------------+
    |  1 | Mohammad |   It   |    80      | 984803322 | Mohammad@gmail.com |
    |  2 | Shyam    |   It   |    75      | 984800000 | shyam@gmail.com    |
    +----+----------+--------+------------+-----------+--------------------+

### 学生普约班 ###

POJO 类将实现执行所需操作所需的所有方法。

在学生.java文件中将学生班级创建为 −

public class Student {
       private int id;
       private String name;
       private String branch;
       private int percentage;
       private int phone;
       private String email;
    
       public Student(int id, String name, String branch, int percentage, int phone, String email) {
          super();
          this.id = id;
          this.name = name;
          this.branch = branch;
          this.percentage = percentage;
          this.phone = phone;
          this.email = email;
       }
    	
       public Student() {}
    
       public int getId() {
          return id;
       }
    	
       public void setId(int id) {
          this.id = id;
       }
    	
       public String getName() {
          return name;
       }
    	
       public void setName(String name) {
          this.name = name;
       }
    	
       public int getPhone() {
          return phone;
       }
    	
       public void setPhone(int phone) {
          this.phone = phone;
       }
    	
       public String getEmail() {
          return email;
       }
    	
       public void setEmail(String email) {
          this.email = email;
       }
    
       public String getBranch() {
          return branch;
       }
    
       public void setBranch(String branch) {
          this.branch = branch;
       }
    
       public int getPercentage() {
          return percentage;
       }
    
       public void setPercentage(int percentage) {
          this.percentage = percentage;
       }	
      
    }

### Student\_mapper.java ###

这是一个文件，其中包含映射器接口，我们在其中使用注释而不是 XML 标记来声明映射的语句。对于几乎所有基于 XML 的映射器元素，MyBatis 都提供了注释。以下名为 Student\_mapper.java 的文件包含一个映射器接口。在此文件中，您可以看到用于对学生表执行 CURD 操作的注释。

import java.util.List;
    
    import org.apache.ibatis.annotations.*;
    
    public interface Student_mapper {
    	
       final String getAll = "SELECT * FROM STUDENT"; 
       final String getById = "SELECT * FROM STUDENT WHERE ID = #{id}";
       final String deleteById = "DELETE from STUDENT WHERE ID = #{id}";
       final String insert = "INSERT INTO STUDENT (NAME, BRANCH, PERCENTAGE, PHONE, EMAIL ) VALUES (#{name}, #{branch}, #{percentage}, #{phone}, #{email})";
       final String update = "UPDATE STUDENT SET EMAIL = #{email}, NAME = #{name}, BRANCH = #{branch}, PERCENTAGE = #{percentage}, PHONE = #{phone} WHERE ID = #{id}";
       
       @Select(getAll)
       @Results(value = {
          @Result(property = "id", column = "ID"),
          @Result(property = "name", column = "NAME"),
          @Result(property = "branch", column = "BRANCH"),
          @Result(property = "percentage", column = "PERCENTAGE"),       
          @Result(property = "phone", column = "PHONE"),
          @Result(property = "email", column = "EMAIL")
       })
       
       List getAll();
      
       @Select(getById)
       @Results(value = {
          @Result(property = "id", column = "ID"),
          @Result(property = "name", column = "NAME"),
          @Result(property = "branch", column = "BRANCH"),
          @Result(property = "percentage", column = "PERCENTAGE"),       
          @Result(property = "phone", column = "PHONE"),
          @Result(property = "email", column = "EMAIL")
       })
       
       Student getById(int id);
    
       @Update(update)
       void update(Student student);
    
       @Delete(deleteById)
       void delete(int id);
      
       @Insert(insert)
       @Options(useGeneratedKeys = true, keyProperty = "id")
       void insert(Student student);
    }

### Annotations\_Example.java文件 ###

此文件将具有应用程序级逻辑，用于在 Student 表中插入记录。创建并保存**.java文件，**如下所示 −

import java.io.IOException;
    import java.io.Reader;
    
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    
    public class Annotations_Example { 
    
       public static void main(String args[]) throws IOException{
          
          Reader reader = Resources.getResourceAsReader("SqlMapConfig.xml");
          SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);		
          SqlSession session = sqlSessionFactory.openSession();
          session.getConfiguration().addMapper(Student_mapper.class);
          
          Student_mapper mapper = session.getMapper(Student_mapper.class);      
          
          //Create a new student object
          Student student = new Student();
          
          //Set the values      
          student.setName("zara");
          student.setBranch("EEE");
          student.setEmail("zara@gmail.com");
          student.setPercentage(90));
          student.setPhone(123412341);
                
          //Insert student data   
          mapper.insert(student);
          System.out.println("record inserted successfully");
          session.commit();
          session.close();
    			
       }
       
    }

### 编译和执行 ###

以下是编译和运行Annotations\_Example.java文件的步骤。在继续编译和执行之前，请确保已正确设置路径和类路径。

*  创建Student\_mapper.java文件，如上所示并编译它。
 *  创建 sqlMap配置.xml如本教程的[“我的教程 - 配置 XML”][- _ XML]一章所示。
 *  创建学生.java如上所示并编译它。
 *  如上所述创建Annotations\_Example.java并编译它。
 *  执行Annotations\_Example二进制文件以运行该程序。

您将获得以下结果，并将在 STUDENT 表中创建一条记录。

$java Annotations_Example
    Record Inserted Successfully

如果您检查学生表，它应该显示以下结果 -

mysql> select * from student;
    +----+----------+--------+------------+-----------+----------------------+
    | ID | NAME     | BRANCH | PERCENTAGE |   PHONE   |        EMAIL         |
    +----+----------+--------+------------+-----------+----------------------+
    |  1 | Mohammad |  It    |     80     | 900000000 | mohamad123@yahoo.com |
    |  2 | Shyam    |  It    |     75     | 984800000 | shyam@gmail.com      |
    |  3 | Zara     |  EEE   |     90     | 123412341 | zara@gmail.com       |
    +----+----------+--------+------------+-----------+----------------------+
    3 rows in set (0.08 sec)

同样，我们可以使用注释执行更新，删除和读取操作，方法是将Annotations\_Example.java的内容替换为下面提到的相应代码段 -

#### 更新 ####

public static void main(String args[]) throws IOException{
          
       Reader reader = Resources.getResourceAsReader("SqlMapConfig.xml");
       SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);		
       SqlSession session = sqlSessionFactory.openSession();   
       session.getConfiguration().addMapper(Student_mapper.class);
       Student_mapper mapper = session.getMapper(Student_mapper.class); 
          
       //select a particular student using id		
       Student student = mapper.getById(2);
       System.out.println("Current details of the student are "+student.toString());  
          
       //Set new values to the mail and phone number of the student
       student.setEmail("Shyam123@yahoo.com");
       student.setPhone(984802233);
          
       //Update the student record
       mapper.update(student);
       System.out.println("Record updated successfully");   
       session.commit();   
       session.close();
    
    }

#### 读 ####

public static void main(String args[]) throws IOException{
          
       Reader reader = Resources.getResourceAsReader("SqlMapConfig.xml");
       SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);		
       SqlSession session = sqlSessionFactory.openSession();
       session.getConfiguration().addMapper(Student_mapper.class);      
       Student_mapper mapper = session.getMapper(Student_mapper.class);
          
       //Get the student details
       Student student = mapper.getById(2);
       System.out.println(student.getBranch());
       System.out.println(student.getEmail());
       System.out.println(student.getId());
       System.out.println(student.getName());
       System.out.println(student.getPercentage());
       System.out.println(student.getPhone());      
       session.commit();
       session.close();
    			
    }

#### 删除 ####

## 米巴蒂斯 - 储存程序 ##

您可以使用“我的巴蒂斯”调用存储过程。首先，让我们了解如何在MySQL中创建存储过程。

我们在MySQL中有以下员工表 -

让我们在MySQL数据库中创建以下存储过程 -

DELIMITER //
       DROP PROCEDURE IF EXISTS details.read_recordById //
       CREATE PROCEDURE details.read_recordById (IN emp_id INT)
    	
       BEGIN 
          SELECT * FROM STUDENT WHERE ID = emp_id; 
       END// 
    	
    DELIMITER ;

假设名为“学生”的表有两条记录为 −

mysql> select * from STUDENT;
    +----+----------+--------+------------+-----------+----------------------+
    | ID |   NAME   | BRANCH | PERCENTAGE |  PHONE    |       EMAIL          |
    +----+----------+--------+------------+-----------+----------------------+
    |  1 | Mohammad |  It    |     80     | 900000000 | mohamad123@yahoo.com |
    |  2 | Shyam    |  It    |     75     | 984800000 | shyam@gmail.com      |
    +----+----------+--------+------------+-----------+----------------------+
    2 rows in set (0.00 sec)

### 学生普乔班 ###

若要使用存储过程，不需要修改学生.java文件。让我们保持上一章中的样子。

public class Student {
    
       private int id;
       private String name;
       private String branch;
       private int percentage;
       private int phone;
       private String email;
    
       public Student(int id, String name, String branch, int percentage, int phone, String email) {
          super();
          this.id = id;
          this.name = name;
          this.setBranch(branch);
          this.setPercentage(percentage);
          this.phone = phone;
          this.email = email;
       }
    	
       public Student() {}
    
       public int getId() {
          return id;
       }
    	
       public void setId(int id) {
          this.id = id;
       }
    	
       public String getName() {
          return name;
       }
    	
       public void setName(String name) {
          this.name = name;
       }
    	
       public int getPhone() {
          return phone;
       }
    	
       public void setPhone(int phone) {
          this.phone = phone;
       }
    	
       public String getEmail() {
          return email;
       }
    	
       public void setEmail(String email) {
          this.email = email;
       }
    
       public String getBranch() {
          return branch;
       }
    
       public void setBranch(String branch) {
          this.branch = branch;
       }
    
       public int getPercentage() {
          return percentage;
       }
    
       public void setPercentage(int percentage) {
          this.percentage = percentage;
       }
    	
       public String toString(){
          StringBuilder sb = new StringBuilder();
    		
          sb.append("Id = ").append(id).append(" - ");
          sb.append("Name = ").append(name).append(" - ");
          sb.append("Branch = ").append(branch).append(" - ");
          sb.append("Percentage = ").append(percentage).append(" - ");
          sb.append("Phone = ").append(phone).append(" - ");
          sb.append("Email = ").append(email);
    		
          return sb.toString();
       }
    	
    }

### 学生.xml文件 ###

与IBTIS不同，MyBatis中没有**<过程>**标签。为了映射过程的结果，我们创建了一个名为 Student 的结果映射，并调用名为“read\_recordById”的存储过程。我们定义了一个带有 id callById 的选择标记，并在应用程序中使用相同的 id 来调用该过程。

<?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 = "Student">	
    		
       <resultMap id = "result" type = "Student">
          <result property = "id" column = "ID"/>
          <result property = "name" column = "NAME"/>
          <result property = "branch" column = "BRANCH"/>
          <result property = "percentage" column = "PERCENTAGE"/>
          <result property = "phone" column = "PHONE"/>
          <result property = "email" column = "EMAIL"/>
       </resultMap>   
       
       <select id = "callById" resultMap = "result" parameterType = "Student" statementType = "CALLABLE">
          {call read_record_byid(#{id, jdbcType = INTEGER, mode = IN})}
       </select>   
        	
    </mapper>

### mybatisSP.java 文件 ###

此文件具有应用程序级逻辑，可使用 ResultMap 从“员工”表中读取员工的姓名 −

import java.io.IOException;
    import java.io.Reader;
    
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    
    public class getRecords { 
    
       public static void main(String args[]) throws IOException{
          
          Reader reader = Resources.getResourceAsReader("SqlMapConfig.xml");
          SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);		
          SqlSession session = sqlSessionFactory.openSession();
          
          //select a particular student  by  id	
          Student student = (Student) session.selectOne("Student.callById", 3);
          
          //Print the student details
          System.out.println("Details of the student are:: ");
          System.out.println("Id :"+student.getId());
          System.out.println("Name :"+student.getName());
          System.out.println("Branch :"+student.getBranch());
          System.out.println("Percentage :"+student.getPercentage());      
          System.out.println("Email :"+student.getEmail());      
          System.out.println("Phone :"+student.getPhone());
          session.commit();
          session.close();
    			
       }
       
    }

### 编译和运行 ###

以下是编译和运行获取记录程序的步骤。在继续编译和执行之前，请确保已正确设置路径和类路径。

*  创建学生.xml如上所示。
 *  创建学生.java如上所示并编译它。
 *  创建 getRecords.java如上所示并编译它。
 *  执行 getRecords 二进制文件以运行程序。

您将获得以下结果 −

Details of the student are:: 
    Id :2
    Name :Shyam
    Branch :It
    Percentage :75
    Email :shyam@gmail.com
    Phone :984800000

## MYBATIS - 动态 SQL ##

动态SQL是我的巴蒂斯的一个非常强大的功能。它使程序员能够基于方案动态构建查询。例如，如果要根据 MyBatis 中学生的姓名搜索学生数据库，则必须使用动态 SQL 编写查询。

MyBatis使用功能强大的动态SQL语言，可以在任何映射的SQL语句中使用。以下是 MyBatis 提供的基于 OGNL 的动态 SQL 表达式。

*  如果
 *  选择（当，否则）
 *  修剪（其中，设置）
 *  前期

### 如果语句 ###

在动态 SQL 中，最常见的做法是有条件地包含 where 子句的一部分。例如 −

<select id = "getRecByName" parameterType = "Student" resultType = "Student">
    
       SELECT * FROM STUDENT		 
       <if test = "name != null">
          WHERE name LIKE #{name}
       </if> 
    </select>

此语句提供可选的文本搜索类型的功能。如果未传入任何名称，则将返回所有活动记录。但是，如果您确实传入了一个名称，它将查找具有给定**类似**条件的名称。

您可以将多个 **if** 条件包含为 −

<select id = "getRecByName_Id" parameterType = "Student" resultType = "Student">
    
       SELECT * FROM STUDENT		 
       <if test = "name != null">
          WHERE name LIKE #{name}
       </if>
    
       <if test = "id != null">
          AND id LIKE #{id}
       </if> 
    </select>

### 选择、何时和其他语句 ###

MyBatis 提供了一个**选择**元素，它类似于 Java 的 switch 语句。在众多选项中仅选择一种情况会有所帮助。

以下示例将仅按名称（如果提供了名称）进行搜索，如果未给出名称，则仅按 id -

<select id = "getRecByName_Id_phone" parameterType = "Student" resultType = "Student">
       SELECT * FROM Student WHERE id != 0
    	
       <choose>
          <when test = "name != null">
             AND name LIKE #{name}
          </when> 
    
          <when test = "phone != null">
             AND phone LIKE #{phone}
          </when>
       </choose>
    	
    </select>

### 位置声明 ###

看看我们前面的示例，看看如果不满足任何条件会发生什么。你最终会得到一个看起来像这样的SQL -

SELECT * FROM Student
    WHERE

这将失败，但MyBatis有一个简单的解决方案，只需一个简单的更改，一切正常 -

<select id = "getName_Id_phone" parameterType = "Student" resultType = "Student">
       SELECT * FROM STUDENT
    	
       <where>
          <if test = "id != null">
             id = #{id}
          </if>
    
          <if test = "name != null">
             AND name LIKE #{name}
          </if>
       </where>
    		
    </select>

仅当包含的标记返回任何内容时，**where** 元素才会插入 *WHERE*。此外，如果该内容以 *AND* 或 *OR 开头，*则它知道将其删除。

### 前言 ###

foreach 元素允许您指定一个集合，并声明可在元素正文中使用的项和索引变量。

它还允许您指定开始和结束字符串，并添加分隔符以在迭代之间放置。您可以按如下方式构建 **IN** 条件 −

<select id = "selectPostIn" resultType = "domain.blog.Post">
       SELECT *
       FROM POST P
       WHERE ID in
    	
       <foreach item = "item" index = "index" collection = "list"
          open = "(" separator = "," close = ")">
          #{item}
       </foreach>
    	
    </select>

### 动态 SQL 示例 ###

如果使用动态 SQL，则这是一个示例。考虑一下，我们在MySQL中有以下学生表 -

假设此表有两条记录作为 −

mysql> select * from student;
    +----+----------+--------+------------+-----------+----------------------+
    | ID |   NAME   | BRANCH | PERCENTAGE |   PHONE   |        EMAIL         |
    +----+----------+--------+------------+-----------+----------------------+
    |  1 | Mohammad |   It   |     80     | 900000000 | mohamad123@yahoo.com |
    |  2 | Shyam    |   It   |     75     | 984800000 | shyam@gmail.com      |
    +----+----------+--------+------------+-----------+----------------------+
    2 rows in set (0.00 sec)

### 学生普约班 ###

要执行读取操作，让我们在“学生.java”中设置一个学生类，如下所示 ：

public class Student {
       private int id;
       private String name;
       private String branch;
       private int percentage;
       private int phone;
       private String email;
    
       public Student(int id, String name,  String branch, int percentage, int phone, String email) {
          super();
          this.id = id;
          this.name = name;
          this.branch = branch;
          this.percentage = percentage;
          this.phone = phone;
          this.email = email;
       }
    	
       public Student() {}
    
       public int getId() {
          return id;
       }
    	
       public void setId(int id) {
          this.id = id;
       }
    	
       public String getName() {
          return name;
       }
    	
       public void setName(String name) {
          this.name = name;
       }
    	
       public int getPhone() {
          return phone;
       }
    	
       public void setPhone(int phone) {
          this.phone = phone;
       }
    	
       public String getEmail() {
          return email;
       }
    	
       public void setEmail(String email) {
          this.email = email;
       }
    
       public String getBranch() {
          return branch;
       }
    
       public void setBranch(String branch) {
          this.branch = branch;
       }
    
       public int getPercentage() {
          return percentage;
       }
    
       public void setPercentage(int percentage) {
          this.percentage = percentage;
       }	
      
    }

### 学生.xml文件 ###

此文件包含名为“学生”的结果映射，以映射 SELECT 查询的结果。我们将定义一个“id”，它将在.java中用于对数据库执行动态SQL SELECT查询。

<?xml version = "1.0" encoding = "UTF-8"?>
    
    &l;t!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    	
    <mapper namespace = "Student">	
    
       <resultMap id = "result" type = "Student">
          <result property = "id" column = "ID"/>
          <result property = "name" column = "NAME"/>
          <result property = "branch" column = "BRANCH"/>
          <result property = "percentage" column = "PERCENTAGE"/>
          <result property = "phone" column = "PHONE"/>
          <result property = "email" column = "EMAIL"/>
       </resultMap>	     
    
       <select id = "getRecByName" parameterType = "Student" resultType = "Student">
          SELECT * FROM STUDENT		 
    		
          <if test = "name != null">
             WHERE name LIKE #{name}
          </if>
    		
       </select>
    	
    </mapper>

### 获取记录按名称.java文件 ###

此文件具有应用程序级逻辑，用于从 Student 表中读取条件记录 −

import java.io.IOException;
    import java.io.Reader;
    import java.util.List;
    
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    
    public class GetRecordByName { 
    
       public static void main(String args[]) throws IOException{
    	   
          String req_name = "Mohammad";
          Reader reader = Resources.getResourceAsReader("SqlMapConfig.xml");
          SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);		
          SqlSession session = sqlSessionFactory.openSession();
          Student stud = new Student();
          stud.setName(req_name);
          
          //select contact all contacts		
          //List<Student> student = session.selectList("getRecByName",stud);
          
          stud.setId(1);
          List<Student> student = session.selectList("getRecByName_Id",stud);
              
          for(Student st : student ){    	  
        	   	  
             System.out.println("++++++++++++++details of the student named Mohammad are "+"+++++++++++++++++++" );
        	  
             System.out.println("Id :  "+st.getId());
             System.out.println("Name :  "+st.getName());
             System.out.println("Branch :  "+st.getBranch());
             System.out.println("Percentage :  "+st.getPercentage());         
             System.out.println("Email :  "+st.getEmail());        
             System.out.println("Phone :  "+st.getPhone());    	  
        	 
          }     
          
          System.out.println("Records Read Successfully ");          
          session.commit();   
          session.close();			
       }
    }

### 编译和运行 ###

以下是编译和运行上述软件的步骤。在继续编译和执行之前，请确保已正确设置路径和类路径。

*  创建学生.xml如上所示。
 *  创建学生.java如上所示并编译它。
 *  创建“按名称”进行.java并编译它。
 *  执行“按名称”二进制文件以运行程序。

您将获得以下结果，并从 Student 表中读取一条记录。

++++++++++++++details of the student named Mohammad are +++++++++++++++++++
    Id :  1
    Name :  Mohammad
    Branch :  It
    Percentage :  80
    Email :  mohamad123@yahoo.com
    Phone :  90000000
    Records Read Successfully

## 米巴蒂斯 - 冬眠 ##

我的巴蒂斯和冬眠之间有很大的区别。鉴于其特定领域，这两种技术都运行良好。建议在以下情况下使用我的巴蒂斯 -

*  你想创建自己的SQL，你愿意维护它们。
 *  您的环境由关系数据模型驱动。
 *  您必须处理现有和复杂的架构。

如果环境由对象模型驱动并且需要自动生成 SQL，请使用休眠。

### 我的巴蒂斯和冬眠之间的区别 ###

休眠和 MyBatis 都是业界可用的开源对象关系映射 （ORM） 工具。这些工具的使用取决于您使用它们的上下文。

下表突出显示了 MyBatis 和休眠之间的差异 −

<table> 
 <tbody> 
  <tr> 
   <th>我的巴蒂斯</th> 
   <th>冬眠</th> 
  </tr> 
  <tr> 
   <td>它更简单。它采用更小的封装尺寸。</td> 
   <td>休眠会为您生成 SQL，这意味着您不必花时间生成 SQL。</td> 
  </tr> 
  <tr> 
   <td>它非常灵活，提供更快的开发时间。</td> 
   <td>它具有高度可扩展性，提供了更高级的缓存。</td> 
  </tr> 
  <tr> 
   <td>它使用 SQL，这可能依赖于数据库。</td> 
   <td>它使用相对独立于数据库的HQL。将数据库更改为休眠更容易。</td> 
  </tr> 
  <tr> 
   <td>它将 JDBC API 中的结果集映射到您的 POJO 对象，因此您不必关心表结构。</td> 
   <td>休眠将 Java POJO 对象映射到数据库表。</td> 
  </tr> 
  <tr> 
   <td>在我的巴蒂斯中使用存储过程非常容易。</td> 
   <td>在休眠中使用存储过程有点困难。</td> 
  </tr> 
 </tbody> 
</table>

休眠和MyBatis都与SPRING框架兼容，因此选择其中之一应该不是问题。

[32ea2f69373441a268a86f221e429e68.jpeg]: https://img-blog.csdnimg.cn/img_convert/32ea2f69373441a268a86f221e429e68.jpeg
[JAVA]: https://www.tutorialspoint.com/java/index.htm
[Link 1]: http://www.java2s.com/Code/Jar/m/Downloadmybatis302jar.htm
[Link 2]: http://dev.mysql.com/downloads/connector/j/
[f3ca2612f5749d69ca4285daf8b74c0e.jpeg]: https://img-blog.csdnimg.cn/img_convert/f3ca2612f5749d69ca4285daf8b74c0e.jpeg
[MyBatis]: https://mybatis.github.io/mybatis-3/configuration.html
[- _ XML]: https://www.tutorialspoint.com/mybatis/mybatis_configuration_xml.htm