老师又问我 MyBatis 了

开发 前端
MyBatis(前身是iBatis)是一个支持普通SQL查询、存储过程以及高级映射的持久层框架。

[[433479]]

GitHub:https://github.com/nateshao/ssm/tree/master/112-mybatis-hello

1. 什么是MyBatis

什么是MyBatis?

“MyBatis(前身是iBatis)是一个支持普通SQL查询、存储过程以及高级映射的持久层框架。

“MyBatis框架也被称之为ORM(Object/Relation Mapping,即对象关系映射)框架。所谓的ORM就是一种为了解决面向对象与关系型数据库中数据类型不匹配的技术,它通过描述Java对象与数据库表之间的映射关系,自动将Java应用程序中的对象持久化到关系型数据库的表中。

ORM框架的工作原理

Hibernate与MyBatis有什么区别?

Hibernate

  • Hibernate是一个全表映射的框架。
  • 通常开发者只需定义好持久化对象到数据库表的映射关系,就可以通过Hibernate提供的方法完成持久层操作。
  • 开发者并不需要熟练的掌握SQL语句的编写,Hibernate会根据制定的存储逻辑,自动的生成对应的SQL,并调用JDBC接口来执行,所以其开发效率会高于MyBatis。
  • Hibernate也存在一些缺点,例如它在多表关联时,对SQL查询的支持较差;更新数据时,需要发送所有字段;不支持存储过程;不能通过优化SQL来优化性能等。

MyBatis

MyBatis是一个半自动映射的框架。

“半自动”是相对于Hibernate全表映射而言的,MyBatis需要手动匹配提供POJO、SQL和映射关系,而Hibernate只需提供POJO和映射关系即可。

与Hibernate相比,虽然使用MyBatis手动编写SQL要比使用Hibernate的工作量大,但MyBatis可以配置动态SQL并优化SQL,可以通过配置决定SQL的映射规则,它还支持存储过程等。对于一些复杂的和需要优化性能的项目来说,显然使用MyBatis更加合适。

2. MyBatis的下载和使用

下载地址:https://github.com/mybatis/mybatis-3/releases

使用MyBatis框架非常简单,只需在应用程序中引入MyBatis的核心包和lib目录中的依赖包即可。

注意:如果底层采用的是MySQL数据库,那么还需要将MySQL数据库的驱动JAR包添加到应用程序的类路径中;如果采用其他类型的数据库,则同样需要将对应类型的数据库驱动包添加到应用程序的类路径中。

3. MyBatis的工作原理

识记!!!

4. MyBatis入门程序

在实际开发中,查询操作通常都会涉及到单条数据的精确查询,以及多条数据的模糊查询。

  • 根据客户编号查询客户信息。
  • 根据客户名模糊查询客户信息。

根据客户编号查询客户信息

MySQL数据库中,创建一个名为mybatis的数据库,在此数据库中创建一个t_customer表,同时预先插入几条数据。

  1. /* 
  2.  Navicat MySQL Data Transfer 
  3.   
  4.  Source Server         : localhost_3306 
  5.  Source Server Version : 50717 
  6.  Source Host           : localhost:3306 
  7.  Source Database       : mybatis 
  8.   
  9.  Target Server Type    : MYSQL 
  10.  Target Server Version : 50717 
  11.  File Encoding         : 65001 
  12.   
  13.  Date: 2021-10-22 22:24:17 
  14.  */ 
  15.   
  16.  SET FOREIGN_KEY_CHECKS=0; 
  17.   
  18.  -- ---------------------------- 
  19.  -- Table structure for `t_customer` 
  20.  -- ---------------------------- 
  21.  DROP TABLE IF EXISTS `t_customer`; 
  22.  CREATE TABLE `t_customer` ( 
  23.    `id` int(32) NOT NULL AUTO_INCREMENT, 
  24.    `username` varchar(50) DEFAULT NULL
  25.    `jobs` varchar(50) DEFAULT NULL
  26.    `phone` varchar(16) DEFAULT NULL
  27.    PRIMARY KEY (`id`) 
  28.  ) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8; 
  29.   
  30.  -- ---------------------------- 
  31.  -- Records of t_customer 
  32.  -- ---------------------------- 
  33.  INSERT INTO `t_customer` VALUES ('1''aaa''dada''11111111'); 
  34.  INSERT INTO `t_customer` VALUES ('2''jack''teacher''13521210112'); 
  35.  INSERT INTO `t_customer` VALUES ('3''worker''worker''13311111234'); 
  36.  INSERT INTO `t_customer` VALUES ('4''zhangsan''maiyu''10086'); 
  37.  INSERT INTO `t_customer` VALUES ('5''zhangsan''manager''13233334444'); 
  38.  INSERT INTO `t_customer` VALUES ('6''zhangsan''manager''13233334444'); 

在IDEA中,创建一个名为112-mybatis-hello的maven项目,将MyBatis包、以及MySQL数据库的驱动包一同添加到项目的pom.xml下, 并发布到类路径中。

项目结构如下:

pom.xml

  1. <dependencies> 
  2.         <!-- mybatis核心包 --> 
  3.         <dependency> 
  4.             <groupId>org.mybatis</groupId> 
  5.             <artifactId>mybatis</artifactId> 
  6.             <version>3.5.1</version> 
  7.         </dependency> 
  8.         <!-- mysql驱动包 --> 
  9.         <dependency> 
  10.             <groupId>mysql</groupId> 
  11.             <artifactId>mysql-connector-java</artifactId> 
  12.             <version>5.1.47</version> 
  13.         </dependency> 
  14.         <!-- junit测试包 --> 
  15.         <dependency> 
  16.             <groupId>junit</groupId> 
  17.             <artifactId>junit</artifactId> 
  18.             <version>4.13.1</version> 
  19.             <scope>test</scope> 
  20.         </dependency> 
  21.         <dependency> 
  22.             <groupId>org.junit.jupiter</groupId> 
  23.             <artifactId>junit-jupiter-api</artifactId> 
  24.             <version>5.7.2</version> 
  25.         </dependency> 
  26.  
  27.     </dependencies> 

mybatis-config.xml

  1. <?xml version="1.0" encoding="UTF-8" ?> 
  2. <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" 
  3.     "http://mybatis.org/dtd/mybatis-3-config.dtd"
  4. <configuration> 
  5.     <!--1.配置环境 ,默认的环境id为mysql--> 
  6.     <environments default="mysql"
  7.         <!--1.2.配置id为mysql的数据库环境 --> 
  8.         <environment id="mysql"
  9.             <!-- 使用JDBC的事务管理 --> 
  10.             <transactionManager type="JDBC" /> 
  11.             <!--数据库连接池 --> 
  12.             <dataSource type="POOLED"
  13.      <property name="driver" value="com.mysql.jdbc.Driver" /> 
  14.      <property name="url"  
  15.                             value="jdbc:mysql://localhost:3306/mybatis?useSSL=false" /> 
  16.      <property name="username" value="root" /> 
  17.      <property name="password" value="123456" /> 
  18.             </dataSource> 
  19.         </environment> 
  20.     </environments> 
  21.     <!--2.配置Mapper的位置 --> 
  22.     <mappers> 
  23.   <mapper resource="mapper/CustomerMapper.xml" /> 
  24.     </mappers> 
  25. </configuration> 

 log4j.properties

  1. <?xml version="1.0" encoding="UTF-8" ?> 
  2. <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" 
  3.     "http://mybatis.org/dtd/mybatis-3-config.dtd"
  4. <configuration> 
  5.     <!--1.配置环境 ,默认的环境id为mysql--> 
  6.     <environments default="mysql"
  7.         <!--1.2.配置id为mysql的数据库环境 --> 
  8.         <environment id="mysql"
  9.             <!-- 使用JDBC的事务管理 --> 
  10.             <transactionManager type="JDBC" /> 
  11.             <!--数据库连接池 --> 
  12.             <dataSource type="POOLED"
  13.      <property name="driver" value="com.mysql.jdbc.Driver" /> 
  14.      <property name="url"  
  15.                             value="jdbc:mysql://localhost:3306/mybatis?useSSL=false" /> 
  16.      <property name="username" value="root" /> 
  17.      <property name="password" value="123456" /> 
  18.             </dataSource> 
  19.         </environment> 
  20.     </environments> 
  21.     <!--2.配置Mapper的位置 --> 
  22.     <mappers> 
  23.   <mapper resource="mapper/CustomerMapper.xml" /> 
  24.     </mappers> 
  25. </configuration> 

CustomerMapper.xml

  1. <?xml version="1.0" encoding="UTF-8"?> 
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
  3.     "http://mybatis.org/dtd/mybatis-3-mapper.dtd"
  4. <!-- namespace表示命名空间 --> 
  5. <mapper namespace="com.nateshao.mapper.CustomerMapper"
  6.     <!--根据客户编号获取客户信息 --> 
  7.  <select id="findCustomerById" parameterType="Integer" 
  8.   resultType="com.nateshao.po.Customer"
  9.   select * from t_customer where id = #{id} 
  10.  </select
  11.   
  12.  <!--根据客户名模糊查询客户信息列表--> 
  13.  <select id="findCustomerByName" parameterType="String" 
  14.      resultType="com.nateshao.po.Customer"
  15.      <!-- select * from t_customer where username like '%${value}%' --> 
  16.      select * from t_customer where username like concat('%',#{value},'%'
  17.  </select
  18.   
  19.  <!-- 添加客户信息 --> 
  20.  <insert id="addCustomer" parameterType="com.nateshao.po.Customer"
  21.      insert into t_customer(username,jobs,phone) 
  22.      values(#{username},#{jobs},#{phone}) 
  23.  </insert
  24.   
  25.  <!-- 更新客户信息 --> 
  26.  <update id="updateCustomer" parameterType="com.nateshao.po.Customer"
  27.      update t_customer set 
  28.      username=#{username},jobs=#{jobs},phone=#{phone} 
  29.      where id=#{id} 
  30.  </update
  31.   
  32.  <!-- 删除客户信息 --> 
  33.  <delete id="deleteCustomer" parameterType="Integer"
  34.      delete from t_customer where id=#{id} 
  35.  </delete
  36. </mapper> 

 Customer.java

  1. package com.nateshao.po; 
  2.  
  3. /** 
  4.  * @date Created by 邵桐杰 on 2021/10/22 22:37 
  5.  * @微信公众号 程序员千羽 
  6.  * @个人网站 www.nateshao.cn 
  7.  * @博客 https://nateshao.gitee.io 
  8.  * @GitHub https://github.com/nateshao 
  9.  * @Gitee https://gitee.com/nateshao 
  10.  * Description: 
  11.  */ 
  12. public class Customer { 
  13.     private Integer id; 
  14.     private String username; 
  15.     private String jobs; 
  16.     private String phone; 
  17.  
  18.     @Override 
  19.     public String toString() { 
  20.         return "Customer{" + 
  21.                 "id=" + id + 
  22.                 ", username='" + username + '\'' + 
  23.                 ", jobs='" + jobs + '\'' + 
  24.                 ", phone='" + phone + '\'' + 
  25.                 '}'
  26.     } 
  27.  
  28.     public Integer getId() { 
  29.         return id; 
  30.     } 
  31.  
  32.     public void setId(Integer id) { 
  33.         this.id = id; 
  34.     } 
  35.  
  36.     public String getUsername() { 
  37.         return username; 
  38.     } 
  39.  
  40.     public void setUsername(String username) { 
  41.         this.username = username; 
  42.     } 
  43.  
  44.     public String getJobs() { 
  45.         return jobs; 
  46.     } 
  47.  
  48.     public void setJobs(String jobs) { 
  49.         this.jobs = jobs; 
  50.     } 
  51.  
  52.     public String getPhone() { 
  53.         return phone; 
  54.     } 
  55.  
  56.     public void setPhone(String phone) { 
  57.         this.phone = phone; 
  58.     } 

MyBatisTest.java

  1. package com.nateshao.test; 
  2.  
  3. import com.nateshao.po.Customer; 
  4. import org.apache.ibatis.io.Resources; 
  5. import org.apache.ibatis.session.SqlSession; 
  6. import org.apache.ibatis.session.SqlSessionFactory; 
  7. import org.apache.ibatis.session.SqlSessionFactoryBuilder; 
  8. import org.junit.jupiter.api.Test; 
  9. import java.io.InputStream; 
  10. import java.util.List; 
  11.  
  12. /** 
  13.  * @date Created by 邵桐杰 on 2021/10/22 22:41 
  14.  * @微信公众号 程序员千羽 
  15.  * @个人网站 www.nateshao.cn 
  16.  * @博客 https://nateshao.gitee.io 
  17.  * @GitHub https://github.com/nateshao 
  18.  * @Gitee https://gitee.com/nateshao 
  19.  * Description: Mybatis 测试 CRUD 
  20.  */ 
  21.  
  22. public class MybatisTest { 
  23.  
  24.     /** 
  25.      * 根据客户编号查询客户信息 
  26.      * 
  27.      * @throws Exception 
  28.      */ 
  29.     @Test 
  30.     public void findCustomerByIdTest() throws Exception { 
  31.         // 1、读取配置文件 
  32.         String resource = "mybatis-config.xml"
  33.         InputStream inputStream = 
  34.                 Resources.getResourceAsStream(resource); 
  35.         // 2、根据配置文件构建SqlSessionFactory 
  36.         SqlSessionFactory sqlSessionFactory = 
  37.                 new SqlSessionFactoryBuilder().build(inputStream); 
  38.         // 3、通过SqlSessionFactory创建SqlSession 
  39.         SqlSession sqlSession = sqlSessionFactory.openSession(); 
  40.         // 4、SqlSession执行映射文件中定义的SQL,并返回映射结果 
  41.         Customer customer = sqlSession.selectOne("com.nateshao.mapper" 
  42.                 + ".CustomerMapper.findCustomerById", 1); 
  43.         // 打印输出结果 
  44.         System.out.println(customer.toString()); 
  45.         // 5、关闭SqlSession 
  46.         sqlSession.close(); 
  47.     } 
  48.  
  49.     /** 
  50.      * 根据用户名称来模糊查询用户信息列表 
  51.      * 
  52.      * @throws Exception 
  53.      */ 
  54.     @Test 
  55.     public void findCustomerByNameTest() throws Exception { 
  56.         // 1、读取配置文件 
  57.         String resource = "mybatis-config.xml"
  58.         InputStream inputStream = Resources.getResourceAsStream(resource); 
  59.         // 2、根据配置文件构建SqlSessionFactory 
  60.         SqlSessionFactory sqlSessionFactory = 
  61.                 new SqlSessionFactoryBuilder().build(inputStream); 
  62.         // 3、通过SqlSessionFactory创建SqlSession 
  63.         SqlSession sqlSession = sqlSessionFactory.openSession(); 
  64.         // 4、SqlSession执行映射文件中定义的SQL,并返回映射结果 
  65.         List<Customer> customers = sqlSession.selectList("com.nateshao.mapper" 
  66.                 + ".CustomerMapper.findCustomerByName""j"); 
  67.         for (Customer customer : customers) { 
  68.             //打印输出结果集 
  69.             System.out.println(customer); 
  70.         } 
  71.         // 5、关闭SqlSession 
  72.         sqlSession.close(); 
  73.     } 
  74.  
  75.     /** 
  76.      * 添加客户 
  77.      * 
  78.      * @throws Exception 
  79.      */ 
  80.     @Test 
  81.     public void addCustomerTest() throws Exception { 
  82.         // 1、读取配置文件 
  83.         String resource = "mybatis-config.xml"
  84.         InputStream inputStream = Resources.getResourceAsStream(resource); 
  85.         // 2、根据配置文件构建SqlSessionFactory 
  86.         SqlSessionFactory sqlSessionFactory = 
  87.                 new SqlSessionFactoryBuilder().build(inputStream); 
  88.         // 3、通过SqlSessionFactory创建SqlSession 
  89.         SqlSession sqlSession = sqlSessionFactory.openSession(); 
  90.         // 4、SqlSession执行添加操作 
  91.         // 4.1创建Customer对象,并向对象中添加数据 
  92.         Customer customer = new Customer(); 
  93.         customer.setUsername("rose"); 
  94.         customer.setJobs("student"); 
  95.         customer.setPhone("13333533092"); 
  96.         // 4.2执行SqlSession的插入方法,返回的是SQL语句影响的行数 
  97.         int rows = sqlSession.insert("com.nateshao.mapper" 
  98.                 + ".CustomerMapper.addCustomer", customer); 
  99.         // 4.3通过返回结果判断插入操作是否执行成功 
  100.         if (rows > 0) { 
  101.             System.out.println("您成功插入了" + rows + "条数据!"); 
  102.         } else { 
  103.             System.out.println("执行插入操作失败!!!"); 
  104.         } 
  105.         // 4.4提交事务 
  106.         sqlSession.commit(); 
  107.         // 5、关闭SqlSession 
  108.         sqlSession.close(); 
  109.     } 
  110.  
  111.     /** 
  112.      * 更新客户 
  113.      * 
  114.      * @throws Exception 
  115.      */ 
  116.     @Test 
  117.     public void updateCustomerTest() throws Exception { 
  118.         // 1、读取配置文件 
  119.         String resource = "mybatis-config.xml"
  120.         InputStream inputStream = Resources.getResourceAsStream(resource); 
  121.         // 2、根据配置文件构建SqlSessionFactory 
  122.         SqlSessionFactory sqlSessionFactory = 
  123.                 new SqlSessionFactoryBuilder().build(inputStream); 
  124.         // 3、通过SqlSessionFactory创建SqlSession 
  125.         SqlSession sqlSession = sqlSessionFactory.openSession(); 
  126.         // 4、SqlSession执行更新操作 
  127.         // 4.1创建Customer对象,对对象中的数据进行模拟更新 
  128.         Customer customer = new Customer(); 
  129.         customer.setId(4); 
  130.         customer.setUsername("rose"); 
  131.         customer.setJobs("programmer"); 
  132.         customer.setPhone("13311111111"); 
  133.         // 4.2执行SqlSession的更新方法,返回的是SQL语句影响的行数 
  134.         int rows = sqlSession.update("com.nateshao.mapper" 
  135.                 + ".CustomerMapper.updateCustomer", customer); 
  136.         // 4.3通过返回结果判断更新操作是否执行成功 
  137.         if (rows > 0) { 
  138.             System.out.println("您成功修改了" + rows + "条数据!"); 
  139.         } else { 
  140.             System.out.println("执行修改操作失败!!!"); 
  141.         } 
  142.         // 4.4提交事务 
  143.         sqlSession.commit(); 
  144.         // 5、关闭SqlSession 
  145.         sqlSession.close(); 
  146.     } 
  147.  
  148.     /** 
  149.      * 删除客户 
  150.      * 
  151.      * @throws Exception 
  152.      */ 
  153.     @Test 
  154.     public void deleteCustomerTest() throws Exception { 
  155.         // 1、读取配置文件 
  156.         String resource = "mybatis-config.xml"
  157.         InputStream inputStream = Resources.getResourceAsStream(resource); 
  158.         // 2、根据配置文件构建SqlSessionFactory 
  159.         SqlSessionFactory sqlSessionFactory = 
  160.                 new SqlSessionFactoryBuilder().build(inputStream); 
  161.         // 3、通过SqlSessionFactory创建SqlSession 
  162.         SqlSession sqlSession = sqlSessionFactory.openSession(); 
  163.         // 4、SqlSession执行删除操作 
  164.         // 4.1执行SqlSession的删除方法,返回的是SQL语句影响的行数 
  165.         int rows = sqlSession.delete("com.nateshao.mapper" 
  166.                 + ".CustomerMapper.deleteCustomer", 4); 
  167.         // 4.2通过返回结果判断删除操作是否执行成功 
  168.         if (rows > 0) { 
  169.             System.out.println("您成功删除了" + rows + "条数据!"); 
  170.         } else { 
  171.             System.out.println("执行删除操作失败!!!"); 
  172.         } 
  173.         // 4.3提交事务 
  174.         sqlSession.commit(); 
  175.         // 5、关闭SqlSession 
  176.         sqlSession.close(); 
  177.     } 

总结

读取配置文件

根据配置文件构建SqlSessionFactory

通过SqlSessionFactory创建SqlSession

使用SqlSession对象操作数据库

关闭SqlSession

责任编辑:武晓燕 来源: 程序员千羽
相关推荐

2021-10-30 18:56:12

Spring工作框架

2023-07-18 19:11:21

配置信令系统

2021-09-09 18:12:22

内存分段式网络

2018-09-28 05:25:53

TopK算法代码

2020-12-11 09:24:19

Elasticsear存储数据

2020-04-22 11:19:07

贪心算法动态规划

2018-10-28 22:37:00

计数排序排序面试

2018-11-01 13:49:23

桶排序排序面试

2017-12-28 10:44:08

JavaScript浏览器网页

2020-09-24 14:40:55

Python 开发编程语言

2014-07-23 10:19:02

小米4

2022-12-07 07:35:20

B站裁员隐情

2023-03-10 08:24:27

OOMdump线程

2023-10-30 22:23:12

Cacherkube版本

2021-07-22 07:50:47

删库系统数据

2020-03-31 16:02:23

戴尔

2022-10-17 10:13:58

谷歌云游戏

2019-05-27 08:09:43

WiFi无线信道上网

2021-04-06 06:23:18

MVCC并发事务

2020-08-26 08:18:39

数据索引查询
点赞
收藏

51CTO技术栈公众号