MyBatis——概述

MyBatis 是一个开源、轻量级的持久化框架。它是JDBC和Hibernate的替代品。它可以自动化 SQL 数据库和 Java、.NET 和 Ruby on Rails 中的对象之间的映射。通过将 SQL 语句打包在 XML 配置文件中，映射与应用程序逻辑分离。

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

它的前身是IBATIS，由 Clinton Begin 于 2002 年创立。MyBatis 3 是最新版本。这是对 IBATIS 的彻底改造。

MyBatis 与其他持久化框架的显着区别在于 MyBatis 强调使用 SQL，而其他框架如 Hibernate 通常使用自定义查询语言，即 Hibernate 查询语言（HQL）或 Enterprise JavaBeans 查询语言（EJB QL）。

MYBATIS 设计特点

MyBatis 具有以下设计理念 –

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

MyBatis 的优势

MYBATIS 提供以下优势 –

• Supports stored procedures − MyBatis 将 SQL 以存储过程的形式封装起来，这样业务逻辑就可以远离数据库，应用程序更便携，更容易部署和测试。
• 支持内联 SQL – 无需预编译器，您可以完全访问 SQL 的所有功能。
• 支持动态 SQL – MyBatis 提供了基于参数动态构建 SQL 查询的功能。
• Supports O/RM – MyBatis 支持许多与 O/RM 工具相同的功能，例如延迟加载、连接获取、缓存、运行时代码生成和继承。

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

要详细了解 JAVA，您可以阅读我们的JAVA 教程。

MYBATIS – 环境

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

MyBatis 安装

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

• 从下载 MYBATIS下载最新版本的 MyBatis 。
• 从下载 MySQL 连接器下载最新版本的 mysqlconnector 。
• 解压缩下载的文件以提取 .jar 文件并将它们保存在适当的文件夹/目录中。
• 为提取的 .jar 文件适当地设置 CLASSPATH 变量。

数据库设置

使用以下语法在任何 MySQL 数据库中创建 EMPLOYEE 表 –

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 )
);

MyBatis Eclipse 设置

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

<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

在上一章中，我们已经了解了如何安装 MyBatis。本章讨论如何使用 XML 文件配置 MyBatis。

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

下面的编程是一个典型的 MyBatis 配置文件结构。

<configuration>

   <typeAliases>
      <typeAlias alias = "class_alias_Name" type = "absolute_clas_Name"/>
   </typeAliases>
		
   <environments default = "default_environment _name">
      <environment id = "environment_id">
         <transactionManager type = "JDBC/MANAGED"/>  
			
            <dataSource type = "UNPOOLED/POOLED/JNDI">
               <property name = "driver" value = "database_driver_class_name"/>
               <property name = "url" value = "database_url"/>
               <property name = "username" value = "database_user_name"/>
               <property name = "password" value = "database_password"/>
            </dataSource>        
				
      </environment>
   </environments>
	
   <mappers>
      <mapper resource = "path of the configuration XML file"/>
   </mappers>
   
</configuration>

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

环境标签

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

事务管理器标签

MyBatis 支持JDBC和MANAGED两种事务管理器

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

数据源标签

用于配置数据库的连接属性，如我们要连接的数据库的driver-name、url、user-name和password。它分为三种类型 –

• UNPOOLED – 对于数据源类型 UNPOOLED，MyBatis 只是为每个数据库操作打开和关闭连接。它有点慢，通常用于简单的应用程序。
• POOLED – 对于数据源类型 POOLED，MyBatis 将维护一个数据库连接池。并且，对于每个数据库操作，MyBatis 使用其中一个连接，并在操作完成后将它们返回到池中。它减少了创建新连接所需的初始连接和身份验证时间。
• JNDI – 对于数据源类型 JNDI，MyBatis 将从 JNDI 数据源获取连接。

以下是如何在实践中使用环境标签 –

<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>

typeAliases 标签

我们可以使用 typeAliases，一种 Java 类型的较短名称，而不是在任何地方都指定绝对类名。假设，我们在名为tutorials_point.com.mybatis_examples的包中的 Student.java 文件中有一个 Student 类，那么绝对类名将是tutorials_point.com.mybatis_examples.Student。您可以声明该类的别名，而不是每次都使用这个名称来寻址该类，如下所示 –

<typeAliases>
   <typeAlias alias = "Student" type = "mybatis.Student"/>
</typeAliases>

映射器标签

Mapper XML 文件是重要的文件，其中包含映射的 SQL 语句。Mapper的元素用于配置这些mapper xml文件在MyBatis的配置文件中的位置（该元素包含resources、url、class、name四个属性）。

例如，mapper xml 文件的名称是Student.xml，它位于名为mybatis的包中，那么您可以配置 mapper 标签，如下所示。

<mappers>
   <mapper resource = "mybatis/Student.xml"/>
</mappers>

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

除了这些，MyBatis 文档的配置文件中还可以使用其他元素。有关完整的详细信息，请参阅 MyBatis 文档。

MyBatis 与 MySQL 数据库

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

Sr.No.	Property Name	value
1	driver	com.mysql.jdbc.Driver
2	url	jdbc:mysql://localhost:3306/details (assume database is “details” )
3	username	root
4	password	password

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

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

SqlMapConfig.xml

下面给出了本教程中使用的示例的 XML 配置。将下面给出的内容复制到一个文本文件中，并将其保存为SqlMapConfig.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>

MYBATIS – 映射器 XML

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

在继续映射语句之前，假设以下名为Student的表存在于 MYSQL 数据库中 –

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

还假设 POJO 类也存在名为Student的上表，如下所示 –

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

映射语句

Mapper XML是MyBatis中的一个重要文件，它包含了一组语句来配置select、insert、update、delete等各种SQL语句。这些语句称为映射语句或映射 SQL 语句。

• 所有语句都有唯一的 id。要执行这些语句中的任何一个，您只需将适当的 id 传递给 Java 应用程序中的方法。（这将在后面的章节中清楚地讨论）。
• mapper XML 文件可以避免在应用程序中重复编写 SQL 语句的负担。与 JDBC 相比，在 MyBatis 中使用 Mapper XML 文件减少了几乎 95% 的代码。
• 所有这些映射的 SQL 语句都驻留在名为<mapper>的元素中。该元素包含一个名为‘namespace’的属性。

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

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

插入

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

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

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

在给定的示例中，我们使用 Student（类）类型的参数。student类是一个POJO类，表示以name、branch、percentage、phone、email为参数的Student记录。

您可以使用 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接口的 delete 方法调用删除映射查询，如下所示 –

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

选择

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

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

您可以使用方法selectList()检索选择查询返回的数据。此方法以列表的形式返回所选记录的数据，如下所示 –

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

结果地图

它是 MyBatis 中最重要和最强大的元素。SQL SELECT 语句的结果映射到 Java 对象（bean/POJO）。一旦定义了结果映射，我们就可以从几个 SELECT 语句中引用它们。下面是结果Map查询的例子；它将选择查询的结果映射到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 = "getAll" resultMap = "result">
   SELECT * FROM STUDENT; 
</select>

<select id = "getById" parameterType = "int" resultMap = "result">
   SELECT * FROM STUDENT WHERE ID = #{id};
</select>

注意-如果表的属性和列名相同，则不必编写 resultMap 的列属性。

MYBATIS——创建操作

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

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

在 MySQL 数据库中创建 STUDENT 表，如下所示 –

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)

Student POJO Class

在 STUDENT.java 文件中创建一个 STUDENT 类

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;
   }
   
}

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

Student.xml 文件

要使用 MyBatis 定义 SQL 映射语句，我们将使用<insert>标记。在这个标签定义中，我们将定义一个“id”。此外，“id”将在 mybatisInsert.java 文件中用于在数据库上执行 SQL INSERT 查询。创建 student.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 – 可以根据要求将值作为字符串、int、float、double或任何类对象。在本例中，我们将 Student 对象作为参数传递，同时调用SqlSession类的insert方法。

如果您的数据库表使用 IDENTITY、AUTO_INCREMENT 或 SERIAL 列，或者您定义了 SEQUENCE/GENERATOR，则可以在<insert>语句中使用<selectKey>元素来使用或返回该数据库生成的值。

mybatisInsert.java 文件

该文件将具有应用程序级逻辑以在 Student 表中插入记录。创建并保存mybatisInsert.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 mybatisInsert { 

   public static void main(String args[]) throws IOException{
      
      Reader reader = Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);		
      SqlSession session = sqlSessionFactory.openSession();
      
      //Create a new student object
      Student student = new Student("Mohammad","It", 80, 984803322, "Mohammad@gmail.com" ); 
            
      //Insert student data      
      session.insert("Student.insert", student);
      System.out.println("record inserted successfully");
      session.commit();
      session.close();
			
   }
   
}

编译和执行

下面是编译和运行 mybatisInsert.java 文件的步骤。在继续编译和执行之前，请确保您已正确设置 PATH 和 CLASSPATH。

• 如上所示创建 Student.xml。
• 如本教程的MYBATIS – 配置 XML一章所示创建 SqlMapConfig.xml 。
• 如上所示创建Student.java并编译它。
• 如上图创建mybatisInsert.java并编译。
• 执行 mybatisInsert 二进制文件来运行程序。

您会得到以下结果，并且会在 STUDENT 表中创建一条记录。

$java mybatisInsert
Record Inserted Successfully

如果您检查 STUDENT 表，它应该显示以下结果 –

mysql> select * from student;
+----+----------+--------+------------+-----------+--------------------+
| ID |   NAME   | BRANCH | PERCENTAGE |   PHONE   |       EMAIL        |
+----+----------+--------+------------+-----------+--------------------+
|  1 | Mohammad |   It   |     80     | 984803322 | Mohammad@gmail.com |
+----+----------+--------+------------+-----------+--------------------+
1 row in set (0.00 sec)

MYBATIS – 读操作

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

我们在 MySQL 中有以下 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(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    |
+----+----------+--------+------------+-----------+--------------------+

Student POJO类

为了执行读取操作，我们将 Student.java 中的 Student 类修改为 –

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 String getName() {
      return name;
   }
	
   public int getPhone() {
      return phone;
   }
	
   public String getEmail() {
      return email;
   }
   
   public String getBranch() {
      return branch;
   }

   public int getPercentage() {
      return percentage;
   }	
	
}

Student.xml 文件

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

要检索特定记录，我们需要一个唯一键来表示该记录。因此，我们还定义了Student类型的resultmap“id”（唯一键），将select查询的结果映射到Student类的变量上。

<?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"/>	    
   </resultMap>
	
   <select id = "getAll" resultMap = "result">
      SELECT * FROM STUDENT; 
   </select>
    
   <select id = "getById" parameterType = "int" resultMap = "result">
      SELECT * FROM STUDENT WHERE ID = #{id};
   </select>
    	
</mapper>

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文件的步骤。在继续编译和执行之前，请确保您已正确设置 PATH 和 CLASSPATH。

• 如上所示创建 Student.xml。
• 如上所示创建Student.java并编译它。
• 如上图创建mybatisRead_ALL.java并编译。
• 执行 mybatisRead_ALL binary 来运行程序。

你会得到Student表的所有记录 –

++++++++++++++ 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 文件的步骤。在继续编译和执行之前，请确保您已正确设置 PATH 和 CLASSPATH。

• 如上所示创建 Student.xml。
• 如本教程的MYBATIS – 配置 XML一章所示创建 SqlMapConfig.xml 。
• 如上所示创建Student.java并编译它。
• 如上所示创建mybatisRead_byID.java并编译。
• 执行 mybatisRead_byID binary 来运行程序。

您将得到以下结果，并且将从 Student 表中读取一条记录为 –

2
shyam
It
75
shyam@gmail.com
984800000

MYBATIS – 更新操作

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

我们在 MySQL 中有以下 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(11) NOT NULL,
   EMAIL varchar(255) NOT NULL,
   PRIMARY KEY (`ID`)
);

假设这张表有两条记录如下 –

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    |
+----+----------+--------+------------+-----------+--------------------+

Student POJO类

要执行更新操作，您需要将 Student.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();
   }
	
}

Student.xml 文件

要使用 MyBatis 定义 SQL 映射语句，我们将在 Student.xml 中添加<update>标签，在此标签定义中，我们将定义一个“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>

mybatisUpdate.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();
			
   }
}

编译运行

下面是编译运行mybatisUpdate.java的步骤。在继续编译和执行之前，请确保您已正确设置 PATH 和 CLASSPATH。

• 如上所示创建 Student.xml。
• 如本教程的MYBATIS – 配置 XML一章所示创建 SqlMapConfig.xml 。
• 如上所示创建Student.java并编译它。
• 如上所示创建mybatisUpdate.java并编译它。
• 执行 mybatisUpdate 二进制文件来运行程序。

你会得到以下结果。您最初可以看到特定记录的详细信息，该记录将在 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

如果您检查 STUDENT 表，它应该显示以下结果 –

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 – 删除操作

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

我们在 MySQL 中有以下 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(11) NOT NULL,
   EMAIL varchar(255) NOT NULL,
   PRIMARY KEY (`ID`)
);

假设，该表有两条记录为 –

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)

Student POJO类

要执行删除操作，您不需要修改 Student.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();
   }
	
}

Student.xml 文件

要使用 MyBatis 定义 SQL 映射语句，我们将在 Student.xml 中使用<delete>标签，在此标签定义中，我们将定义一个“id”，它将在 mybatisDelete.java 文件中用于对数据库执行 SQL DELETE 查询。

<?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"/>	    
   </resultMap>
	
   <delete id = "deleteById" parameterType = "int">
      DELETE from STUDENT WHERE ID = #{id};
   </delete>
    	
</mapper>

MyBatisDelete.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 mybatisDelete { 

   public static void main(String args[]) throws IOException{
      
      Reader reader = Resources.getResourceAsReader("SqlMapConfig.xml");
      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);		
      SqlSession session = sqlSessionFactory.openSession(); 
	  
      //Delete operation
      session.delete("Student.deleteById", 2);     
      session.commit();
      session.close();      
      System.out.println("Record deleted successfully");
			
   }
   
}

编译运行

下面是编译运行mybatisDelete.java的步骤。确保在继续编译和执行之前已正确设置 PATH 和 CLASSPATH。

• 如上所示创建 Student.xml。
• 如本教程的MYBATIS – 配置 XML一章所示创建 SqlMapConfig.xml 。
• 如上所示创建Student.java并编译它。
• 如上所示创建mybatisDelete.java并编译。
• 执行 mybatisDelete binary 运行程序。

您将得到以下结果，ID = 1 的记录将从 STUDENT 中删除。

Records Read Successfully

如果您检查 STUDENT 表，它应该显示以下结果 –

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

MYBATIS – 注释

在前面的章节中，我们已经看到了如何使用 MyBatis 执行 curd 操作。我们使用一个 Mapper XML 文件来存储映射的 SQL 语句和一个配置 XML 文件来配置 MyBatis。

为了映射 SQL 语句，MyBatis 还提供了注解。所以，本章讨论如何使用 MyBatis 注解。

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

假设，我们在 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)

假设该表有两条记录为 –

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    |
+----+----------+--------+------------+-----------+--------------------+

Student POJO类

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

在 Student.java 文件中创建一个 Student 类：

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 的文件包含一个映射器接口。在此文件中，您可以看到对 STUDENT 表执行 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 表中插入记录。创建并保存mybatisInsert.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 文件的步骤。在继续编译和执行之前，请确保您已正确设置 PATH 和 CLASSPATH。

• 如上所示创建 Student_mapper.java 文件并编译它。
• 如本教程的MYBATIS – 配置 XML一章所示创建 SqlMapConfig.xml 。
• 如上所示创建Student.java并编译它。
• 如上所示创建 Annotations_Example.java 并编译它。
• 执行 Annotations_Example 二进制文件以运行程序。

您会得到以下结果，并且会在 STUDENT 表中创建一条记录。

$java Annotations_Example
Record Inserted Successfully

如果您检查 STUDENT 表，它应该显示以下结果 –

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();
			
}

删除

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);
   mapper.delete(2);
   System.out.println("record deleted successfully");
   session.commit();
   session.close();            
			
}

MYBATIS – 存储过程

您可以使用 MyBatis 调用存储过程。首先，让我们了解如何在 MySQL 中创建存储过程。

我们在 MySQL 中有以下 EMPLOYEE 表 –

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`)
);

让我们在 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 ;

假设名为 STUDENT 的表有两条记录：

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)

Student POJO类

要使用存储过程，您不需要修改 Student.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();
   }
	
}

Student.xml 文件

与 IBATIS 不同，MyBatis 中没有<procedure>标签。为了映射过程的结果，我们创建了一个名为 Student 的结果映射并调用名为 read_recordById 的存储过程。我们定义了一个id为callById的select标签，我们在应用程序中使用相同的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 从 Employee 表中读取员工姓名 –

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();
			
   }
   
}

编译运行

以下是编译和运行 getRecords 程序的步骤。在继续编译和执行之前，请确保您已正确设置 PATH 和 CLASSPATH。

• 如上所示创建 Student.xml。
• 如上所示创建Student.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 的一个非常强大的特性。它使程序员能够根据场景动态构建查询。例如，如果你想在 MyBatis 中根据Student姓名搜索Student数据库，你必须使用动态 SQL 编写查询。

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

• 如果
• 选择（何时，否则）
• 修剪（在哪里，设置）
• foreach

if 语句

在动态 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>

choose、when 和 else 语句

MyBatis 提供了一个choose元素，类似于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>

where 语句

看看我们之前的例子，看看如果不满足任何条件会发生什么。你最终会得到一个看起来像这样的 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 语句

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 中有以下 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(11) NOT NULL,
   EMAIL varchar(255) NOT NULL,
   PRIMARY KEY (`ID`)
);
Query OK, 0 rows affected (0.37 sec)

假设该表有两条记录：

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)

Student POJO类

要执行读取操作，让我们在 Student.java 中有一个 Student 类：

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.xml 文件

该文件包含名为 Student 的结果映射，用于映射 SELECT 查询的结果。我们将定义一个“id”，它将在 mybatisRead.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>

GetRecordByName.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();			
   }
}

编译运行

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

• 如上所示创建 Student.xml。
• 如上所示创建Student.java并编译它。
• 如上所示创建 GetRecordByName.java 并编译它。
• 执行 GetRecordByName 二进制文件以运行该程序。

您会得到以下结果，并且会从 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 

MYBATIS – Hibernate

MyBatis 和 Hibernate 有很大的不同。鉴于它们的特定领域，这两种技术都运行良好。建议使用 MyBatis –

• 您想要创建自己的 SQL，并且愿意维护它们。
• 您的环境由关系数据模型驱动。
• 您必须处理现有的复杂模式。

使用 Hibernate，如果环境是由对象模型驱动的，需要自动生成 SQL。

MyBatis 和 Hibernate 的区别

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

下表突出了 MyBatis 和 Hibernate 之间的区别 –

MyBatis	Hibernate
它更简单。它的封装尺寸要小得多。	Hibernate 为您生成 SQL，这意味着您不必花时间生成 SQL。
它很灵活，提供更快的开发时间。	它具有高度可扩展性，提供更高级的缓存。
它使用可能依赖于数据库的 SQL。	它使用HQL，它相对独立于数据库。将 db 更改为 Hibernate 更容易。
它将 ResultSet 从 JDBC API 映射到您的 POJO 对象，因此您不必关心表结构。	Hibernate 将您的 Java POJO 对象映射到数据库表。
在 MyBatis 中使用存储过程非常容易。	在 Hibernate 中使用存储过程有点困难。

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