一篇文章带你掌握主流数据库框架——MyBatis

MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。

在之前的文章中我们学习了MYSQL和JDBC，但是这些东西远远不足以支持我们书写JavaWeb相关的内容

在学习MyBatis前，请先学习Java，Mysql，JDBC，Maven内容

MyBatis学前须知

首先我们先简单介绍一下MyBatis：

  • Mybats是一款优秀的持久层框架，用于简化JDBC开发
  • MyBatis本是Apache的一个开源项目iBatis，2010年由apache software foundation 迁移到了google code，并改名为MyBatis
  • 官网：MyBatis中文网

我们再来介绍一下JavaEE概念：

  • JavaEE三层架构：表现层，业务层，持久层
  • 表现层：负责接收客户端请求，向客户端响应结果
  • 业务层：它负责业务逻辑处理
  • 持久层：负责将数据保存到数据库的那一层代码

最后我们了解一下框架：

  • 框架是一个半成品软件，是一套可重用的，通用的软件基础代码模型
  • 在框架的基础上构建软件编写更加有效，规范，通用，可扩展

MyBatis产生背景

我们在前面提到MyBatis的产生是为了简化JDBC开发

那么我们就先来介绍一下JDBC的缺点：

我们通过一段代码进行解析：

  1. package com.itheima.jdbc;
  3. import org.junit.Test;
  5. import java.sql.*;
  6. import java.util.Date;
  8.     @Test
  9.     public void testPreparedStatement2() throws  Exception {
  11.         // 前置链接操作
  12.         String url = "jdbc:mysql:///db1?useSSL=false&useServerPrepStmts=true";
  13.         String username = "root";
  14.         String password = "1234";
  15.         Connection conn = DriverManager.getConnection(url, username, password);
  17.         // 接收用户输入 用户名和密码
  18.         String name = "zhangsan";
  19.         String pwd = "' or '1' = '1";
  21.         // 定义sql
  22.         String sql = "select * from tb_user where username = ? and password = ?";
  24.         // 获取pstmt对象
  25.         PreparedStatement pstmt = conn.prepareStatement(sql);
  27.         Thread.sleep(10000);
  28.         // 设置？的值
  29.         pstmt.setString(1,name);
  30.         pstmt.setString(2,pwd);
  31.         ResultSet rs = null;
  32.                 // 执行sql
  33.         rs = pstmt.executeQuery();
  35.         // 设置？的值
  36.         pstmt.setString(1,"aaa");
  37.         pstmt.setString(2,"bbb");
  39.         // 执行sql
  40.         rs = pstmt.executeQuery();
  42.         // 判断登录是否成功
  43.         if(rs.next()){
  44.             System.out.println("登录成功~");
  45.         }else{
  46.             System.out.println("登录失败~");
  47.         }
  49.         //7. 释放资源
  50.         rs.close();
  51.         pstmt.close();
  52.         conn.close();
  53.     }
  54. }

在上述代码中，我们可以注意到：

  1. /*
  2. 硬编码概念： 代码展现形式固定，如果有所更改需要手动修改代码
  3. 硬编码动作：注册驱动，获得链接，SQL语句
  4. */
  6. 		// 前置链接操作
  7.         String url = "jdbc:mysql:///db1?useSSL=false&useServerPrepStmts=true";
  8.         String username = "root";
  9.         String password = "1234";
  10.         Connection conn = DriverManager.getConnection(url, username, password);
  12.         // 接收用户输入 用户名和密码
  13.         String name = "zhangsan";
  14.         String pwd = "' or '1' = '1";
  16. /*
  17. 操作繁琐：大量代码堆叠
  18. 操作繁琐动作：手动设置参数，手动封装结果
  19. */
  21. 		// 获取pstmt对象
  22.         PreparedStatement pstmt = conn.prepareStatement(sql);
  24.         Thread.sleep(10000);
  25.         // 设置？的值
  26.         pstmt.setString(1,name);
  27.         pstmt.setString(2,pwd);
  28.         ResultSet rs = null;
  29.                 // 执行sql
  30.         rs = pstmt.executeQuery();
  32.         // 设置？的值
  33.         pstmt.setString(1,"aaa");
  34.         pstmt.setString(2,"bbb");
  36.         // 执行sql
  37.         rs = pstmt.executeQuery();

因而为了解决JDBC的这些缺点，MyBatis应运而生！

MyBatis解决思想：

  • 硬编码 -> 配置文件

    • 注册驱动，获得连接：在mybatis-config.xml设置其连接池信息
    • SQL语句：设置专门的Mapper接口和Mapper.xml设置其信息
  • 操作繁琐 - > 自动完成
    • 采用SqlSession对象的各类方法直接封装

MyBatis免除了几乎所有的JDBC代码以及设置参数和获得结果集的工作

MyBatis快速入门

我们将以一个案例进行MyBatis的快速入门(资源来自B站黑马程序员老陈的JavaWeb课程)

我们以步骤形式逐步进行:

  1. 准备数据库数据

  1. 创建模块,导入坐标(这里采用Maven创建项目,在项目自动生成的pom.xml中导入模块坐标即可)
  1. <!--
  2. 我们使用mybatis,导入mybatis坐标
  3. 我们使用mysql,导入mysql坐标
  4. 我们需要进行单元测试,导入junit坐标
  5. 我们需要日志,查看错误信息,导入日志坐标(注意:需要导入logback.xml包,可在网络查询)
  6. ->
  8. <dependencies>
  9.         <!--mybatis 依赖-->
  10.         <dependency>
  11.             <groupId>org.mybatis</groupId>
  12.             <artifactId>mybatis</artifactId>
  13.             <version>3.5.5</version>
  14.         </dependency>
  16.         <!--mysql 驱动-->
  17.         <dependency>
  18.             <groupId>mysql</groupId>
  19.             <artifactId>mysql-connector-java</artifactId>
  20.             <version>5.1.46</version>
  21.         </dependency>
  23.         <!--junit 单元测试-->
  24.         <dependency>
  25.             <groupId>junit</groupId>
  26.             <artifactId>junit</artifactId>
  27.             <version>4.13</version>
  28.             <scope>test</scope>
  29.         </dependency>
  31.         <!-- 添加slf4j日志api -->
  32.         <dependency>
  33.             <groupId>org.slf4j</groupId>
  34.             <artifactId>slf4j-api</artifactId>
  35.             <version>1.7.20</version>
  36.         </dependency>
  37.         <!-- 添加logback-classic依赖 -->
  38.         <dependency>
  39.             <groupId>ch.qos.logback</groupId>
  40.             <artifactId>logback-classic</artifactId>
  41.             <version>1.2.3</version>
  42.         </dependency>
  43.         <!-- 添加logback-core依赖 -->
  44.         <dependency>
  45.             <groupId>ch.qos.logback</groupId>
  46.             <artifactId>logback-core</artifactId>
  47.             <version>1.2.3</version>
  48.         </dependency>
  50.     </dependencies>
  1. 编写MyBatis核心配置文件(替换连接信息,解决硬编码问题)
  1. <!--
  2. 创建mybatis-config.xml,
  3. 写入下列信息(MyBatis官网可查找)
  5. <?xml version="1.0" encoding="UTF-8" ?>
  6. <!DOCTYPE configuration
  7.   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  8.   "http://mybatis.org/dtd/mybatis-3-config.dtd">
  9. <configuration>
  10.   <environments default="development">
  11.     <environment id="development">
  12.       <transactionManager type="JDBC"/>
  13.       <dataSource type="POOLED">
  14.         <property name="driver" value="${driver}"/>
  15.         <property name="url" value="${url}"/>
  16.         <property name="username" value="${username}"/>
  17.         <property name="password" value="${password}"/>
  18.       </dataSource>
  19.     </environment>
  20.   </environments>
  21.   <mappers>
  22.     <mapper resource="org/mybatis/example/BlogMapper.xml"/>
  23.   </mappers>
  24. </configuration>
  26. 然后我们需要对上述信息进行修改,使其完成连接数据库的问题
  27. -->
  29. <?xml version="1.0" encoding="UTF-8" ?>
  30. <!DOCTYPE configuration
  31.   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  32.   "http://mybatis.org/dtd/mybatis-3-config.dtd">
  33. <configuration>
  34.   <environments default="development">
  35.     <environment id="development">
  36.       <transactionManager type="JDBC"/>
  37.         <!--注意:这里dataSource表示数据库连接--->
  38.       <dataSource type="POOLED">
  39.           <!--
  40. 			我们需要修改下述信息
  41. 			driver:固定com.mysql.jdbc.Driver
  42. 			url:jdbc:mysql:/// + 数据库名称 + ?useSSL=false
  43. 			username:数据库账号
  44. 			password:数据库密码
  45. 			-->
  46.         <property name="driver" value="com.mysql.jdbc.Driver"/>
  47.         <property name="url" value="jdbc:mysql:///mybatis?useSSL=false"/>
  48.         <property name="username" value="root"/>
  49.         <property name="password" value="123456"/>
  50.       </dataSource>
  51.     </environment>
  52.   </environments>
  53.     <!--这里mapper表示映射地址:我们所需要的Mapper.xml,在后续我们会在Mapper.xml中书写SQL语句-->
  54.   <mappers>
  55.     <mapper resource="com/itheima/mapper/UserMapper.xml"/>
  56.   </mappers>
  57. </configuration>
  1. 创建SQL映射文件(统一管理sql语句,解决硬编码问题)
  1. <!--
  2. 同样自己创建Mapper.xml文档,这里注意在前面加上前缀,如果你是Usr用户的数据库操作,命名为UserMapper.xml便于区分
  3. 导入下述代码(同样,在Mybatis官网可以找到)
  5. <?xml version="1.0" encoding="UTF-8" ?>
  6. <!DOCTYPE mapper
  7.   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  8.   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  9. <mapper namespace="org.mybatis.example.BlogMapper">
  10.   <select id="selectBlog" resultType="Blog">
  11.     select * from Blog where id = #{id}
  12.   </select>
  13. </mapper>
  15. 在创建完成后,不要忘记回到上一步,把mapper的resource地址改为该文档所在地址
  17. -->
  19. <?xml version="1.0" encoding="UTF-8" ?>
  20. <!DOCTYPE mapper
  21.   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  22.   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  23. <!--
  24. namespace:名称空间,在后续需要与Mapper接口名称一致保证互联(这里暂时设置为test)
  25. id:查找方法的唯一表示
  26. resultType:返回类型
  27. 在<select></select>中间书写语句即可
  29. 后续会继续介绍
  30. -->
  31. <mapper namespace="test">
  32.   <select id="selectAll" resultType="User">
  33.     select * from Blog where id = #{id}
  34.   </select>
  35. </mapper>
  1. 1 定义POJO类(与数据库信息完全相同的类)
  1. // 注意:数据为private,书写get和set方法以及toString方法
  3. package com.itheima.pojo;
  5. // alt + 鼠标左键 整列编辑
  6. public class User {
  8.     private Integer id;
  9.     private String username;
  10.     private String password;
  11.     private String gender;
  12.     private String addr;
  14.     public Integer getId() {
  15.         return id;
  16.     }
  18.     public void setId(Integer id) {
  19.         this.id = id;
  20.     }
  22.     public String getUsername() {
  23.         return username;
  24.     }
  26.     public void setUsername(String username) {
  27.         this.username = username;
  28.     }
  30.     public String getPassword() {
  31.         return password;
  32.     }
  34.     public void setPassword(String password) {
  35.         this.password = password;
  36.     }
  38.     public String getGender() {
  39.         return gender;
  40.     }
  42.     public void setGender(String gender) {
  43.         this.gender = gender;
  44.     }
  46.     public String getAddr() {
  47.         return addr;
  48.     }
  50.     public void setAddr(String addr) {
  51.         this.addr = addr;
  52.     }
  54.     @Override
  55.     public String toString() {
  56.         return "User{" +
  57.                 "id=" + id +
  58.                 ", username='" + username + '\'' +
  59.                 ", password='" + password + '\'' +
  60.                 ", gender='" + gender + '\'' +
  61.                 ", addr='" + addr + '\'' +
  62.                 '}';
  63.     }
  64. }
  1. 2 主代码展示
  1. // 创建主代码
  3. package com.itheima;
  5. import com.itheima.pojo.User;
  6. import org.apache.ibatis.io.Resources;
  7. import org.apache.ibatis.session.SqlSession;
  8. import org.apache.ibatis.session.SqlSessionFactory;
  9. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  11. import java.io.IOException;
  12. import java.io.InputStream;
  13. import java.util.List;
  15. /**
  16.  * Mybatis 快速入门代码
  17.  */
  18. public class MyBatisDemo {
  20.     public static void main(String[] args) throws IOException {
  22.         //1. 加载mybatis的核心配置文件，获取 SqlSessionFactory(官网下载)
  24.         /*
  25.         下述为官网下载,我们只需要修改第一行的mybatis-config.xml地址即可
  26.         String resource = "org/mybatis/example/mybatis-config.xml";
  27. 		InputStream inputStream = Resources.getResourceAsStream(resource);
  28. 		SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  29.         */
  31.         String resource = "mybatis-config.xml";
  32.         InputStream inputStream = Resources.getResourceAsStream(resource);
  33.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  35.         //2. 获取SqlSession对象，用它来执行sql(sqlSessionFactory方法)
  36.         SqlSession sqlSession = sqlSessionFactory.openSession();
  38.         //3. 执行sql(这里的test.selectList是我们的UserMapper.xml中所设置的名称空间.id)
  39.         List<User> users = sqlSession.selectList("test.selectAll");
  40.         System.out.println(users);
  42.         //4. 释放资源
  43.         sqlSession.close();
  45.     }
  46. }

至此,我们已经了解了MyBatis的整体创建流程

在下面我们会以上述入门为标准,进行各种流程上的简化开发

解决SQL语句警告问题(IDEA正式版)

我们在Mapper.xml中书写sql语句时,可能会出现sql表名显示红色(报错)现象

产生原因:IDEA和数据库没有建立连接,不识别表信息

解决方法:在IDEA中配置MYSQL数据库连接

解决优点:代码不再报错,显示所有SQL语句以及表列的补全信息

解决方法:

  1. 在Database中打开加号,逐步打开Data Source,MYSQL
  2. 打开页面后,填写USer,Password即可

Mapper代理开发

我们在入门代码中创建了Mapper.xml,并在其中书写代码

我们在主项目的代码中包含有以下这段:

  1. List<User> users = sqlSession.selectList("test.selectAll");

但test.selectAll属于硬编码阶段,且书写方式麻烦

因而产生了Mapper代理开发,同样我们采用案例的形式逐步书写:

  1. 定义与SQL映射文件同名的Mapper接口,并将该接口与SQL映射文件放置在同一目录级别下(IDEA2022版已解决这个问题)

  1. 设置SQL映射文件的namespace属性为Mapper接口全限定名(接口与xml文件产生连接)
  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  6. <!--
  7.     namespace:名称空间
  8. -->
  10. <mapper namespace="com.itheima.mapper.UserMapper">
  12.     <!--statement-->
  13.     <select id="selectAll" resultType="user">
  14.         select *
  15.         from tb_user;
  16.     </select>
  17. </mapper>
  1. 在Mapper接口中定义方法,方法名就是SQL映射文件中sql语句的id,并保持参数类型和返回值类型一致
  1. package com.itheima.mapper;
  3. import com.itheima.pojo.User;
  4. import org.apache.ibatis.annotations.Param;
  5. import org.apache.ibatis.annotations.Select;
  7. import java.util.Collection;
  8. import java.util.List;
  9. import java.util.Map;
  10. import java.util.Set;
  12. public interface UserMapper {
  14.     List<User> selectAll();
  16. }
  1. 主代码展示:
  1. package com.itheima;
  3. import com.itheima.mapper.UserMapper;
  4. import com.itheima.pojo.User;
  5. import org.apache.ibatis.io.Resources;
  6. import org.apache.ibatis.session.SqlSession;
  7. import org.apache.ibatis.session.SqlSessionFactory;
  8. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  10. import java.io.IOException;
  11. import java.io.InputStream;
  12. import java.util.List;
  14. /**
  15.  * Mybatis 代理开发
  16.  */
  17. public class MyBatisDemo2 {
  19.     public static void main(String[] args) throws IOException {
  21.         //1. 加载mybatis的核心配置文件，获取 SqlSessionFactory
  22.         String resource = "mybatis-config.xml";
  23.         InputStream inputStream = Resources.getResourceAsStream(resource);
  24.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  26.         //2. 获取SqlSession对象，用它来执行sql
  27.         SqlSession sqlSession = sqlSessionFactory.openSession();
  29.         //3.1 获取UserMapper接口的代理对象
  30.         //(采用sqlSession方法获得接口类产生对象,调用对象的方法[这里方法来自xml],并根据Mapper接口设置的返回参数)
  31.         UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
  32.         List<User> users = userMapper.selectAll();
  34.         System.out.println(users);
  35.         //4. 释放资源
  36.         sqlSession.close();
  38.     }
  39. }

Mapper补充内容

在mybatis-config.xml文件中我们设置过mapper内容:

  1.     <mappers>
  2.         <!--加载sql映射文件-->
  3.        <mapper resource="com/itheima/mapper/UserMapper.xml">
  4.     </mappers>

但随着sql映射文件增多,单个书写过于麻烦,所以开发出了package方法

  1.     <mappers>
  2.         <!--加载sql映射文件-->
  3.        <!-- <mapper resource="com/itheima/mapper/UserMapper.xml"/>-->
  5.         <!--Mapper代理方式:通过包扫描的方法,将包中所对应的mapper.xml映射过来-->
  6.         <package name="com.itheima.mapper"/>
  8.     </mappers>

MyBatis核心配置文件

Mybatis核心配置文件就是我们之前写入的mybatis-config.xml文件

现在我们对MyBatis的相关内容进行分析:

  1. 标签:

    • 类型别名可为 Java 类型设置一个缩写名字。
    • 它仅用于 XML 配置，意在降低冗余的全限定类名书写。
    • 我们可以在标签内书写package标签,并设置文件夹名称,则后续内容中不需要添加该文件夹名称
  2. 标签:
    • MyBatis 可以配置成适应多种环境，这种机制有助于将 SQL 映射应用于多种数据库之中
    • 通过default设置信息来更换数据库,default的值为下述environment的id值
  3. Mapper,dataSource以及内部信息均已介绍,这里不再介绍

下面给出代码展示:

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE configuration
  3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  5. <configuration>
  7.     <typeAliases>
  8.         <package name="com.itheima.pojo"/>
  9.     </typeAliases>
  11.     <!--
  12.     environments：配置数据库连接环境信息。可以配置多个environment，通过default属性切换不同的environment
  13.     -->
  14.     <environments default="development">
  15.         <environment id="development">
  16.             <transactionManager type="JDBC"/>
  17.             <dataSource type="POOLED">
  18.                 <!--数据库连接信息-->
  19.                 <property name="driver" value="com.mysql.jdbc.Driver"/>
  20.                 <property name="url" value="jdbc:mysql:///mybatis?useSSL=false"/>
  21.                 <property name="username" value="root"/>
  22.                 <property name="password" value="123456"/>
  23.             </dataSource>
  24.         </environment>
  26.         <environment id="test">
  27.             <transactionManager type="JDBC"/>
  28.             <dataSource type="POOLED">
  29.                 <!--数据库连接信息-->
  30.                 <property name="driver" value="com.mysql.jdbc.Driver"/>
  31.                 <property name="url" value="jdbc:mysql:///mybatis?useSSL=false"/>
  32.                 <property name="username" value="root"/>
  33.                 <property name="password" value="1234"/>
  34.             </dataSource>
  35.         </environment>
  36.     </environments>
  37.     <mappers>
  38.         <!--加载sql映射文件-->
  39.        <!-- <mapper resource="com/itheima/mapper/UserMapper.xml"/>-->
  41.         <!--Mapper代理方式-->
  42.         <package name="com.itheima.mapper"/>
  44.     </mappers>
  46. </configuration>

MyBatis进阶内容(增删改查)

在下述内容中,我们会通过一个案例进行MyBatis的增删改查并且补充相应知识点

在开始前,我们同样准备环境:

  1. 数据库表tb_brand

  1. 实体类Brand
  1. package com.itheima.pojo;
  3. /**
  4.  * 品牌
  5.  *
  6.  * alt + 鼠标左键：整列编辑
  7.  *
  8.  * 在实体类中，基本数据类型建议使用其对应的包装类型
  9.  */
  11. public class Brand {
  12.     // id 主键
  13.     private Integer id;
  14.     // 品牌名称
  15.     private String brandName;
  16.     // 企业名称
  17.     private String companyName;
  18.     // 排序字段
  19.     private Integer ordered;
  20.     // 描述信息
  21.     private String description;
  22.     // 状态：0：禁用  1：启用
  23.     private Integer status;
  25.     public Integer getId() {
  26.         return id;
  27.     }
  29.     public void setId(Integer id) {
  30.         this.id = id;
  31.     }
  33.     public String getBrandName() {
  34.         return brandName;
  35.     }
  37.     public void setBrandName(String brandName) {
  38.         this.brandName = brandName;
  39.     }
  41.     public String getCompanyName() {
  42.         return companyName;
  43.     }
  45.     public void setCompanyName(String companyName) {
  46.         this.companyName = companyName;
  47.     }
  49.     public Integer getOrdered() {
  50.         return ordered;
  51.     }
  53.     public void setOrdered(Integer ordered) {
  54.         this.ordered = ordered;
  55.     }
  57.     public String getDescription() {
  58.         return description;
  59.     }
  61.     public void setDescription(String description) {
  62.         this.description = description;
  63.     }
  65.     public Integer getStatus() {
  66.         return status;
  67.     }
  69.     public void setStatus(Integer status) {
  70.         this.status = status;
  71.     }
  73.     @Override
  74.     public String toString() {
  75.         return "Brand{" +
  76.                 "id=" + id +
  77.                 ", brandName='" + brandName + '\'' +
  78.                 ", companyName='" + companyName + '\'' +
  79.                 ", ordered=" + ordered +
  80.                 ", description='" + description + '\'' +
  81.                 ", status=" + status +
  82.                 '}';
  83.     }
  84. }
  1. 测试用例(在test文件夹下的java文件下创建test即可)

  1. 安装MyBatisX插件(方便对应Mapper.xml和Mapper接口)

查询数据

我们将会介绍三种数据查询方法:

  • 查询所有数据
  • 根据ID查询单个数据
  • 根据条件查询数据

接下来我们逐一讲解:

查询所有数据

查询所有数据步骤:

  1. 编写接口方法:Mapper接口(参数:无 返回类型:List)
  1. package com.itheima.mapper;
  3. import com.itheima.pojo.Brand;
  4. import org.apache.ibatis.annotations.Param;
  5. import org.apache.ibatis.annotations.ResultMap;
  6. import org.apache.ibatis.annotations.Select;
  8. import java.util.List;
  9. import java.util.Map;
  11. public interface BrandMapper {
  13.     /**
  14.      * 查询所有
  15.      */
  16.     List<Brand> selectAll();
  17. }
  1. 编写SQL语句(在xml中编写)
  1.     <select id="selectAll" resultType="brand">
  2.         select *
  3.         from tb_brand;
  4.     </select>
  1. 执行方式
  1.     @Test
  2.     public void testSelectAll() throws IOException {
  3.         //1. 获取SqlSessionFactory
  4.         String resource = "mybatis-config.xml";
  5.         InputStream inputStream = Resources.getResourceAsStream(resource);
  6.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  8.         //2. 获取SqlSession对象
  9.         SqlSession sqlSession = sqlSessionFactory.openSession();
  11.         //3. 获取Mapper接口的代理对象
  12.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
  14.         //4. 执行方法
  15.         List<Brand> brands = brandMapper.selectAll();
  16.         System.out.println(brands);
  18.         //5. 释放资源
  19.         sqlSession.close();
  21.     }

但是这种方法中,我们会发现brandName和companyName并没有显示

主要原因:

  • brandName在MYSQL中定义为brand_name;companyName在MYSQL中定义为company_name

解决方法有两种:

  • 给所有名称不同的属性添加别名,使其与MYSQL属性同名
  1. <mapper namespace="com.itheima.mapper.BrandMapper">
  2. 	<select id="selectAll" resultMap="brandResultMap">
  3.         select id, brand_name as brandName, company_name as companyName, ordered, description, status
  4.         from tb_brand;
  5.     </select>
  6. </mapper>
  • 在xml中添加一段ResultMap属性(推荐!!!)
  1. <mapper namespace="com.itheima.mapper.BrandMapper">
  2. <!--
  3.         数据库表的字段名称  和  实体类的属性名称 不一样，则不能自动封装数据
  4.             * 起别名：对不一样的列名起别名，让别名和实体类的属性名一样
  5.                 * 缺点：每次查询都要定义一次别名
  6.                     * sql片段
  7.                         * 缺点：不灵活
  8.             * resultMap：
  9.                 1. 定义<resultMap>标签
  10.                 2. 在<select>标签中，使用resultMap属性替换 resultType属性
  12.     -->
  13.     <!--
  14.         id：唯一标识
  15.         type：映射的类型，支持别名
  16.     -->
  17.     <resultMap id="brandResultMap" type="brand">
  18.         <!--
  19.             id：完成主键字段的映射
  20.                 column：表的列名
  21.                 property：实体类的属性名
  22.             result：完成一般字段的映射
  23.                 column：表的列名
  24.                 property：实体类的属性名
  25.         -->
  26.         <result column="brand_name" property="brandName"/>
  27.         <result column="company_name" property="companyName"/>
  28.     </resultMap>
  30.    <select id="selectAll" resultMap="brandResultMap">
  31.         select *
  32.         from tb_brand;
  33.     </select>
  35.    <select id="selectAll" resultMap="brand">
  36.         select *
  37.         from tb_brand;
  38.     </select>
  39. </mapper>

单个查询

单个查询步骤:

  1. 编写接口方法:Mapper接口(参数:id 返回类型:Brand)
  1.     Brand selectById(int id);
  1. 编写SQL语句
  1.     <select id="selectById" resultMap="brandResultMap">
  2.         select *
  3.         from tb_brand
  4.         where id = #{id};
  5.     </select>
  1. 执行方法,测试
  1.     @Test
  2.     public void testSelectById() throws IOException {
  3.         //接收参数
  4.         int id = 1;
  6.         //1. 获取SqlSessionFactory
  7.         String resource = "mybatis-config.xml";
  8.         InputStream inputStream = Resources.getResourceAsStream(resource);
  9.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  11.         //2. 获取SqlSession对象
  12.         SqlSession sqlSession = sqlSessionFactory.openSession();
  14.         //3. 获取Mapper接口的代理对象
  15.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
  17.         //4. 执行方法
  18.         Brand brand = brandMapper.selectById(id);
  19.         System.out.println(brand);
  21.         //5. 释放资源
  22.         sqlSession.close();
  24.     }

知识点讲解:

  • {}:会将其替换为 ? 放置SQL注入

  • ${}:拼接sql,会存在SQL注入问题
  • 使用时机:
    • 参数传递:#{}
    • 表名或列名不固定的情况下:${}

条件查询

这里我们介绍多条件查询:

  1. 编写接口方法:Mapper接口(参数:所有查询条件 返回结果:List)
  1.     /**
  2.      * 条件查询
  3.      *  * 参数接收
  4.      *      1. 散装参数：如果方法中有多个参数，需要使用@Param("SQL参数占位符名称")
  5.      *      2. 对象参数:对象的属性名称要和参数占位符名称一致
  6.      *      3. map集合参数
  7.      *
  8.      */
  10.     List<Brand> selectByCondition(@Param("status") int status, @Param("companyName") String companyName, @Param("brandName") String brandName);
  12.     List<Brand> selectByCondition(Brand brand);
  14.     List<Brand> selectByCondition(Map map);
  1. 编写SQL语句:
  1.     <!--
  2.         条件查询:
  3. 		这里#{}中的元素和Param所书写的属性相同;
  4. 		如果是Brand,则与Brand的属性相同;
  5. 		如果是Map,则与Map集合的键相同即可
  6.     -->
  7.     <select id="selectByCondition" resultMap="brandResultMap">
  8.          select *
  9.          from tb_brand
  10.          where status = #{status}
  11.            and company_name like #{companyName}
  12.            and brand_name like #{brandName}
  13.      </select>
  1. 执行方法,测试:
  1.     @Test
  2.     public void testSelectByCondition() throws IOException {
  3.         //接收参数
  4.         int status = 1;
  5.         String companyName = "华为";
  6.         String brandName = "华为";
  8.         // 处理参数
  9.         companyName = "%" + companyName + "%";
  10.         brandName = "%" + brandName + "%";
  12.         //封装对象
  13.        /* Brand brand = new Brand();
  14.         brand.setStatus(status);
  15.         brand.setCompanyName(companyName);
  16.         brand.setBrandName(brandName);*/
  18.         Map map = new HashMap();
  19.         // map.put("status" , status);
  20.         map.put("companyName", companyName);
  21.         // map.put("brandName" , brandName);
  23.         //1. 获取SqlSessionFactory
  24.         String resource = "mybatis-config.xml";
  25.         InputStream inputStream = Resources.getResourceAsStream(resource);
  26.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  28.         //2. 获取SqlSession对象
  29.         SqlSession sqlSession = sqlSessionFactory.openSession();
  31.         //3. 获取Mapper接口的代理对象
  32.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
  34.         //4. 执行方法
  36.         //List<Brand> brands = brandMapper.selectByCondition(status, companyName, brandName);
  37. //        List<Brand> brands = brandMapper.selectByCondition(brand);
  38.         List<Brand> brands = brandMapper.selectByCondition(map);
  39.         System.out.println(brands);
  41.         //5. 释放资源
  42.         sqlSession.close();
  44.     }

动态查询

动态查询概念:

  • 在所有的查询条件中,用户可能并不会全部查询,可能只有挑选条件查询
  • 这时如果以之前的代码,会导致导入值为null而导致查询错误

动态SQL语句:

  • if语句
  1. <!--
  2. if标签:整体框架
  3. test:判断条件
  4.   <if test="title != null">
  5. 		sql语句内容
  6.   </if>
  7. -->
  9. <select id="findActiveBlogWithTitleLike"
  10.      resultType="Blog">
  11.   SELECT * FROM BLOG
  12.   WHERE state = ‘ACTIVE’
  13.   <if test="title != null">
  14.     AND title like #{title}
  15.   </if>
  16. </select>
  • where语句
  1.     <!--
  2.         动态条件查询
  3.             * if: 条件判断
  4.                 * test：逻辑表达式
  5.             * 问题：
  6.                 * 恒等式
  7.                 * <where> 替换 where 关键字
  8.     -->
  10. <!--这里的where会根据实际情况,自行添加and或者删除and-->
  11. 	<select id="selectByCondition" resultMap="brandResultMap">
  12.         select *
  13.         from tb_brand
  14.         /* where 1 = 1*/
  15.         <where>
  17.             <if test="status != null">
  18.                 and status = #{status}
  19.             </if>
  20.             <if test="companyName != null and companyName != '' ">
  21.                 and company_name like #{companyName}
  22.             </if>
  23.             <if test="brandName != null and brandName != '' ">
  24.                 and brand_name like #{brandName}
  25.             </if>
  27.         </where>
  • choose语句
  1. <!--
  3. <choose> <!--相当于switch-->
  4. <when test="status != null"> <!--相当于case-->
  6. -->
  8. <select id="findActiveBlogLike"
  9.      resultType="Blog">
  10.   SELECT * FROM BLOG WHERE state = ‘ACTIVE’
  11.   <choose>
  12.     <when test="title != null">
  13.       AND title like #{title}
  14.     </when>
  15.     <when test="author != null and author.name != null">
  16.       AND author_name like #{author.name}
  17.     </when>
  18.     <otherwise>
  19.       AND featured = 1
  20.     </otherwise>
  21.   </choose>
  22. </select>

我们根据两个案例来解释上述语法:

  • 多条件查询语句:
  1. 编写接口方法:Mapper接口(参数:Brand 返回类型:List)
  1. List<Brand> selectByCondition(Brand brand);
  1. 编写SQL语句:
  1.     <!--
  2.         动态条件查询
  3.             * if: 条件判断
  4.                 * test：逻辑表达式
  5.             * 问题：
  6.                 * 恒等式
  7.                 * <where> 替换 where 关键字
  8.     -->
  9.     <select id="selectByCondition" resultMap="brandResultMap">
  10.         select *
  11.         from tb_brand
  12.         /* where 1 = 1*/
  13.         <!--这里使用where,防止无条件或者and位置错误-->
  14.         <where>
  16.             <if test="status != null">
  17.                 and status = #{status}
  18.             </if>
  19.             <if test="companyName != null and companyName != '' ">
  20.                 and company_name like #{companyName}
  21.             </if>
  22.             <if test="brandName != null and brandName != '' ">
  23.                 and brand_name like #{brandName}
  24.             </if>
  26.         </where>
  28.     </select>
  1. 执行方法,测试:
  1.     @Test
  2.     public void testSelectByCondition() throws IOException {
  3.         //接收参数
  4.         int status = 1;
  5.         String companyName = "华为";
  6.         String brandName = "华为";
  8.         // 处理参数
  9.         companyName = "%" + companyName + "%";
  10.         brandName = "%" + brandName + "%";
  12.         //封装对象
  13.         Brand brand = new Brand();
  14.         brand.setStatus(status);
  15.         brand.setCompanyName(companyName);
  16.         brand.setBrandName(brandName);
  18.         //1. 获取SqlSessionFactory
  19.         String resource = "mybatis-config.xml";
  20.         InputStream inputStream = Resources.getResourceAsStream(resource);
  21.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  23.         //2. 获取SqlSession对象
  24.         SqlSession sqlSession = sqlSessionFactory.openSession();
  26.         //3. 获取Mapper接口的代理对象
  27.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
  29.         //4. 执行方法
  30. 		List<Brand> brands = brandMapper.selectByCondition(brand);
  31.         System.out.println(brands);
  33.         //5. 释放资源
  34.         sqlSession.close();
  36.     }
  • 单条件动态查询:
  1. 编写接口方法:Mapper接口(参数:Brand 返回类型:List)
  1. List<Brand> selectByConditionSingle(Brand brand);
  1. 编写SQL语句:
  1.     <select id="selectByConditionSingle" resultMap="brandResultMap">
  2.         select *
  3.         from tb_brand
  4.         <!--这里使用where防止无条件出现导致错误-->
  5.         <where>
  6.             <choose><!--相当于switch-->
  7.                 <when test="status != null"><!--相当于case-->
  8.                     status = #{status}
  9.                 </when>
  10.                 <when test="companyName != null and companyName != '' "><!--相当于case-->
  11.                     company_name like #{companyName}
  12.                 </when>
  13.                 <when test="brandName != null and brandName != ''"><!--相当于case-->
  14.                     brand_name like #{brandName}
  15.                 </when>
  17.             </choose>
  18.         </where>
  19.     </select>
  1. 执行方法,测试:
  1.     @Test
  2.     public void testSelectByConditionSingle() throws IOException {
  3.         //接收参数
  4.         int status = 1;
  5.         String companyName = "华为";
  6.         String brandName = "华为";
  8.         // 处理参数
  9.         companyName = "%" + companyName + "%";
  10.         brandName = "%" + brandName + "%";
  12.         //封装对象
  13.         Brand brand = new Brand();
  14.         //brand.setStatus(status);
  15.         brand.setCompanyName(companyName);
  16.         //brand.setBrandName(brandName);
  18.         //1. 获取SqlSessionFactory
  19.         String resource = "mybatis-config.xml";
  20.         InputStream inputStream = Resources.getResourceAsStream(resource);
  21.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  23.         //2. 获取SqlSession对象
  24.         SqlSession sqlSession = sqlSessionFactory.openSession();
  26.         //3. 获取Mapper接口的代理对象
  27.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
  29.         //4. 执行方法
  31.         List<Brand> brands = brandMapper.selectByConditionSingle(brand);
  32.         System.out.println(brands);
  34.         //5. 释放资源
  35.         sqlSession.close();
  37.     }

添加数据

在这小节我们会讲到添加功能并附带返回主键:

添加功能

添加功能步骤:

  1. 编写接口方法:Mapper接口(参数:Brand 返回类型:void )
  1. void add(Brand brand);
  1. 编写MYSQL语句:
  1. <!--
  3. useGeneratedKeys:对于支持自动生成记录主键的数据库，如：MySQL，SQL Server，此时设置useGeneratedKeys参数值为true，在执行添加记录之后可以获取到数据库自动生成的主键ID。
  5. keyProperty:后面跟数据库中自动增长的列名,这时该属性值就会反馈在Java代码中
  7. -->
  8. <insert id="add" useGeneratedKeys="true" keyProperty="id">
  9.         insert into tb_brand (brand_name, company_name, ordered, description, status)
  10.         values (#{brandName}, #{companyName}, #{ordered}, #{description}, #{status});
  11.     </insert>
  1. 代码调试,测试:
  1.     @Test
  2.     public void testAdd() throws IOException {
  3.         //接收参数
  4.         int status = 1;
  5.         String companyName = "波导手机";
  6.         String brandName = "波导";
  7.         String description = "手机中的战斗机";
  8.         int ordered = 100;
  10.         //封装对象
  11.         Brand brand = new Brand();
  12.         brand.setStatus(status);
  13.         brand.setCompanyName(companyName);
  14.         brand.setBrandName(brandName);
  15.         brand.setDescription(description);
  16.         brand.setOrdered(ordered);
  18.         //1. 获取SqlSessionFactory
  19.         String resource = "mybatis-config.xml";
  20.         InputStream inputStream = Resources.getResourceAsStream(resource);
  21.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  23.         //2. 获取SqlSession对象
  24.         SqlSession sqlSession = sqlSessionFactory.openSession();
  25.         // 这里openSession的参数未设置时为手动提交信息,设置true后为自动提交事务
  26.         //SqlSession sqlSession = sqlSessionFactory.openSession(true);
  28.         //3. 获取Mapper接口的代理对象
  29.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
  31.         //4. 执行方法(这里就可以对brand的id进行提取,并输出)
  33.         brandMapper.add(brand);
  34.         Integer id = brand.getId();
  35.         System.out.println(id);
  37.         // 执行add后并未立刻执行,我们需要提交事务才能反馈到数据库中
  38.         sqlSession.commit();
  40.         //5. 释放资源
  41.         sqlSession.close();
  43.     }

修改数据

该小节中我们会介绍两种修改方法:

  • 全字段修改
  • 单字段修改

我们会在下述内容中一一讲解:

全字段修改

  1. 编写接口方法:Mapper接口(参数:所有数据 返回类型:int(修改行)或void)
  1. int update(Brand brand);
  1. 编写MYSQL语句:
  1.     <update id="update">
  2.         update tb_brand
  3.         set	brand_name = #{brandName},
  4.             company_name = #{companyName},
  5.             ordered = #{ordered},
  6.             description = #{description},
  7.             status = #{status}
  8.         where id = #{id};
  9.     </update>
  1. 执行方法,测试:
  1.     @Test
  2.     public void testUpdate() throws IOException {
  3.         //接收参数
  4.         int status = 0;
  5.         String companyName = "波导手机";
  6.         String brandName = "波导";
  7.         String description = "波导手机,手机中的战斗机";
  8.         int ordered = 200;
  9.         int id = 6;
  11.         //封装对象
  12.         Brand brand = new Brand();
  13.         brand.setStatus(status);
  14.         brand.setCompanyName(companyName);
  15.         brand.setBrandName(brandName);
  16.         brand.setDescription(description);
  17.         brand.setOrdered(ordered);
  18.         brand.setId(id);
  20.         //1. 获取SqlSessionFactory
  21.         String resource = "mybatis-config.xml";
  22.         InputStream inputStream = Resources.getResourceAsStream(resource);
  23.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  25.         //2. 获取SqlSession对象
  26.         SqlSession sqlSession = sqlSessionFactory.openSession();
  27.         //SqlSession sqlSession = sqlSessionFactory.openSession(true);
  29.         //3. 获取Mapper接口的代理对象
  30.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
  32.         //4. 执行方法
  33.         int count = brandMapper.update(brand);
  34.         System.out.println(count);
  35.         //提交事务
  36.         sqlSession.commit();
  38.         //5. 释放资源
  39.         sqlSession.close();
  41.     }

单字段修改

  1. 编写接口方法:Mapper接口(参数:所有数据 返回类型:int(修改行)或void)
  1. int update(Brand brand);
  1. 编写MYSQL语句:
  1.     <update id="update">
  2.         update tb_brand
  3.         <set>
  4.             <if test="brandName != null and brandName != ''">
  5.                 brand_name = #{brandName},
  6.             </if>
  7.             <if test="companyName != null and companyName != ''">
  8.                 company_name = #{companyName},
  9.             </if>
  10.             <if test="ordered != null">
  11.                 ordered = #{ordered},
  12.             </if>
  13.             <if test="description != null and description != ''">
  14.                 description = #{description},
  15.             </if>
  16.             <if test="status != null">
  17.                 status = #{status}
  18.             </if>
  19.         </set>
  20.         where id = #{id};
  21.     </update>
  1. 执行方法,测试:
  1.     @Test
  2.     public void testUpdate() throws IOException {
  3.         //接收参数
  4.         int status = 0;
  5.         String companyName = "波导手机";
  6.         String brandName = "波导";
  7.         String description = "波导手机,手机中的战斗机";
  8.         int ordered = 200;
  9.         int id = 6;
  11.         //封装对象
  12.         Brand brand = new Brand();
  13.         brand.setStatus(status);
  14. //        brand.setCompanyName(companyName);
  15. //        brand.setBrandName(brandName);
  16. //        brand.setDescription(description);
  17. //        brand.setOrdered(ordered);
  18.         brand.setId(id);
  20.         //1. 获取SqlSessionFactory
  21.         String resource = "mybatis-config.xml";
  22.         InputStream inputStream = Resources.getResourceAsStream(resource);
  23.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  25.         //2. 获取SqlSession对象
  26.         SqlSession sqlSession = sqlSessionFactory.openSession();
  27.         //SqlSession sqlSession = sqlSessionFactory.openSession(true);
  29.         //3. 获取Mapper接口的代理对象
  30.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
  32.         //4. 执行方法
  34.         int count = brandMapper.update(brand);
  35.         System.out.println(count);
  36.         //提交事务
  37.         sqlSession.commit();
  39.         //5. 释放资源
  40.         sqlSession.close();
  42.     }

删除功能

这节介绍删除功能的两种形式:

  • 单个删除
  • 多个删除

我们将会在下面一一讲解:

单个删除

  1. 编写接口方法:Mapper接口(参数:id 返回类型:void)
  1. void deleteById(int id);
  1. 编写MYSQL:
  1.     <delete id="deleteById">
  2.         delete from tb_brand where id = #{id};
  3.     </delete>
  1. 代码执行,测试:
  1.     @Test
  2.     public void testDeleteById() throws IOException {
  3.         //接收参数
  5.         int id = 6;
  7.         //1. 获取SqlSessionFactory
  8.         String resource = "mybatis-config.xml";
  9.         InputStream inputStream = Resources.getResourceAsStream(resource);
  10.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  12.         //2. 获取SqlSession对象
  13.         SqlSession sqlSession = sqlSessionFactory.openSession();
  14.         //SqlSession sqlSession = sqlSessionFactory.openSession(true);
  16.         //3. 获取Mapper接口的代理对象
  17.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
  19.         //4. 执行方法
  21.         brandMapper.deleteById(id);
  23.         //提交事务
  24.         sqlSession.commit();
  26.         //5. 释放资源
  27.         sqlSession.close();
  29.     }

多个删除

  1. 编写接口方法:Mapper接口(参数:int[] id 返回类型:void)
  1. void deleteByIds(int[] ids);
  1. 编写MYSQL代码:
  1.     <!--
  2.         mybatis会将数组参数，封装为一个Map集合。
  3.             * 默认：array = 数组
  4.             * 使用@Param注解改变map集合的默认key的名称
  5.     -->
  7.     <!--
  8.     foreach:类似于for强化语句
  9.     collection:集合/数组
  10.     item:数组中的单个值
  11.     separator:分割符
  12.     open:开始处添加符号
  13.     close:结尾处添加符合
  14.     -->
  16.     <delete id="deleteByIds">
  17.         delete from tb_brand where id
  18.         in
  19.         <!--这部分整合出来类似于:(id1,id2,id3....)-->
  20.             <foreach collection="array" item="id" separator="," open="(" close=")">
  21.                 #{id}
  22.             </foreach>
  23.              ;
  24.     </delete>
  1. 代码运行,测试:
  1.     @Test
  2.     public void testDeleteByIds() throws IOException {
  3.         //接收参数
  5.         int[] ids = {5,7,8};
  7.         //1. 获取SqlSessionFactory
  8.         String resource = "mybatis-config.xml";
  9.         InputStream inputStream = Resources.getResourceAsStream(resource);
  10.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  12.         //2. 获取SqlSession对象
  13.         SqlSession sqlSession = sqlSessionFactory.openSession();
  14.         //SqlSession sqlSession = sqlSessionFactory.openSession(true);
  16.         //3. 获取Mapper接口的代理对象
  17.         BrandMapper brandMapper = sqlSession.getMapper(BrandMapper.class);
  19.         //4. 执行方法
  21.         brandMapper.deleteByIds(ids);
  23.         //提交事务
  24.         sqlSession.commit();
  26.         //5. 释放资源
  27.         sqlSession.close();
  29.     }

参数传递

MyBatis接口方法中可以接收各种各样的参数,MyBatis底层对这些参数有着不同的封装处理方法

我们在下面一一介绍:

多参数传递

在接口多参数传递中会把所有参数转移为Map集合

会转化为两种Map集合:

  • arg集合,下标从0开始: arg[0]

  • Param集合,下标从1开始: Param[1]

我们在xml中也可以直接使用arg或param来直接表示(但不推荐,因为不能直观得到信息)

我们所推荐的做法是使用@Param注解:

  • 在参数前加上注解@Param("")

  • 注意:这里使用Param注解实际上是对Param集合的键进行修改,也就是说你的Param集合将不再能够使用

单参数传递

常见的单参数传递分为六种:

  1. POJO类型: 直接使用, 属性名 和 参数占位符 名称一致即可

  2. Map集合: 直接使用,键名 和 参数占位符 名称一致即可

  3. Collection: 封装为Map集合

    • map.put("arg0",collection集合);
    • map.put("collection",collection集合);

  4. List: 封装为Map集合

    • map.put("arg0",List集合);
    • map.put("collection",List集合);
    • map.put("list",List集合);

  5. Array:封装为Map

    • map.put("arg0",数组);
    • map.put("array",数组);

  6. 其他类型:直接使用

注解开发

我们先来介绍注解开发的格式:

  • 注解开发写在Mapper接口的方法中
  1. // 相当于节省了xml的一步,直接在接口中定义方法
  3. @Select("select * from tb_user where id = #{id}")
  4. List<Brand> selectAll();

当然,注解的方法也分为四种:

  • @Select
  • @Insert
  • @Update
  • @Delete

注解的优缺点:

  • 优点 : 注解完成简单功能,方便快捷
  • 缺点 : 注解会导致Java代码繁琐,在接口中书写大量Java和MYSQL代码导致可读性变差

使用注解来映射简单语句会使代码显得更加简洁，但对于稍微复杂一点的语句，Java 注解不仅力不从心，还会让你本就复杂的 SQL 语句更加混乱不堪。 因此，如果你需要做一些很复杂的操作，最好用 XML 来映射语句。

选择何种方式来配置映射，以及认为是否应该要统一映射语句定义的形式，完全取决于你和你的团队。 换句话说，永远不要拘泥于一种方式，你可以很轻松的在基于注解和 XML 的语句映射方式间自由移植和切换。

结束语

好的,关于MyBatis的内容就介绍到这里,希望能为你带来帮助!

附录

该文章属于学习内容，具体参考B站黑马程序员陈老师的JavaWeb课程

这里附上链接：01-MyBatis简介_哔哩哔哩_bilibili

一篇文章带你掌握主流数据库框架——MyBatis的更多相关文章

  1. 一篇文章带你掌握主流基础框架——Spring

    一篇文章带你掌握主流基础框架--Spring 这篇文章中我们将会介绍Spring的框架以及本体内容,包括核心容器,注解开发,AOP以及事务等内容 那么简单说明一下Spring的必要性: Spring技 ...

  2. 一篇文章带你掌握主流办公框架——SpringBoot

    一篇文章带你掌握主流办公框架--SpringBoot 在之前的文章中我们已经学习了SSM的全部内容以及相关整合 SSM是Spring的产品,主要用来简化开发,但我们现在所介绍的这款框架--Spring ...

  3. 一篇文章带你掌握主流服务层框架——SpringMVC

    一篇文章带你掌握主流服务层框架--SpringMVC 在之前的文章中我们已经学习了Spring的基本内容,SpringMVC隶属于Spring的一部分内容 但由于SpringMVC完全针对于服务层使用 ...

  4. 一篇文章带你了解NoSql数据库——Redis简单入门

    一篇文章带你了解NoSql数据库--Redis简单入门 Redis是一个基于内存的key-value结构数据库 我们会利用其内存存储速度快,读写性能高的特点去完成企业中的一些热门数据的储存信息 在本篇 ...

  5. 一篇文章带你掌握MyBatis简化框架——MyBatisPlus

    一篇文章带你掌握MyBatis简化框架--MyBatisPlus 我们在前面的文章中已经学习了目前开发所需的主流框架 类似于我们所学习的SpringBoot框架用于简化Spring开发,我们的国人大大 ...

  6. 一篇文章带你了解网页框架——Vue简单入门

    一篇文章带你了解网页框架--Vue简单入门 这篇文章将会介绍我们前端入门级别的框架--Vue的简单使用 如果你以后想从事后端程序员,又想要稍微了解前端框架知识,那么这篇文章或许可以给你带来帮助 温馨提 ...

  7. MYSQL（基本篇）——一篇文章带你走进MYSQL的奇妙世界

    MYSQL(基本篇)--一篇文章带你走进MYSQL的奇妙世界 MYSQL算是我们程序员必不可少的一份求职工具了 无论在什么岗位,我们都可以看到应聘要求上所书写的"精通MYSQL等数据库及优化 ...

  8. 一篇文章带你了解服务器操作系统——Linux简单入门

    一篇文章带你了解服务器操作系统--Linux简单入门 Linux作为服务器的常用操作系统,身为工作人员自然是要有所了解的 在本篇中我们会简单介绍Linux的特点,安装,相关指令使用以及内部程序的安装等 ...

  9. MYSQL（进阶篇）——一篇文章带你深入掌握MYSQL

    MYSQL(进阶篇)--一篇文章带你深入掌握MYSQL 我们在上篇文章中已经学习了MYSQL的基本语法和概念 在这篇文章中我们将讲解底层结构和一些新的语法帮助你更好的运用MYSQL 温馨提醒:该文章大 ...

随机推荐

  1. UiPath文本操作Set Text的介绍和使用

    一.Set Text的介绍 向输入框/文本框写入文本的一种操作 二.Set Text在UiPath中的使用 1.打开设计器,在设计库中新建一个Sequence,为序列命名及设置Sequence存放的路 ...

  2. JQuery select与radio的取值与赋值

    radio 取:$("input[name='NAME']:checked").val(); 赋:$("input[name='NAME'][value='指定值']&q ...

  3. 7 个有趣的 Python 实战项目，超级适合练手

    关于Python,有一句名言:不要重复造轮子. 但是问题有三个: 1.你不知道已经有哪些轮子已经造好了,哪个适合你用.有名有姓的的著名轮子就400多个,更别说没名没姓自己在制造中的轮子. 2.确实没重 ...

  4. 解决github.com 的响应时间过长以及hosts配置不能保存的问题

    github.com 的响应时间过长 1 获取github可以使用的DNS域名 DNS查询 选择TTL值最小的 2 修改hosts配置 打开之后在最后加上如下内容,保存即可 3 出现hosts不能保存 ...

  5. 腾讯云原生数据库TDSQL-C入选信通院《云原生产品目录》

    近日,中国信通院.云计算开源产业联盟正式对外发布<云原生产品目录>,腾讯云原生数据库TDSQL-C凭借其超强性能.极致效率的弹性伸缩和完善的产品化解决方案体系,成功入围目录. 全球数字经济 ...

  6. go-zero微服务实战系列（十、分布式事务如何实现）

    在分布式应用场景中,分布式事务问题是不可回避的,在目前流行的微服务场景下更是如此.比如在我们的商城系统中,下单操作涉及创建订单和库存扣减操作两个操作,而订单服务和商品服务是两个独立的微服务,因为每个微 ...

  7. System.Web.Mvc 找到的程序集清单定义与程序集引用不匹配

    System.IO.FileLoadException: 未能加载文件或程序集"System.Web.Mvc, Version=5.0.0.0, Culture=neutral, Publi ...

  8. 修改 hosts

    不会牛逼操作 -1. 位置.格式 所有系统都差不多,都是 啥啥/etc/hosts 这样的 . 具体去查即可 . 格式: ip + 域名 域名不能含有通配符 hosts 可以绕过 dns 解析,直接访 ...

  9. .Net 5.0快速上手 Redis

    1. Redis的安装地址: https://files.cnblogs.com/files/lbjlbj/Redis3.7z   2.开启服务: 找到redis目录 打开cmd 输入redis-se ...

  10. Linux使用netstat查看网络状态

    查看本机的网络状态.使用netstat查看网络状态.显示系统端口使用情况.UDP类型的端口.TCP类型的端口.只显示所有监听端口.只显示所有监听tcp端口. 命令使用举例 命令 说明 netstat ...