Mybatis基础学习笔记

MyBatis

环境：

• JDk1.8
• Mysql 5.7
• mavan 3.6.1
• IDEA

0、xml的基础内容

<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper>

</mapper>

1、简介

1.1、 什么是MyBatis

• MyBatis 是一款优秀的持久层框架
• 它支持自定义 SQL、存储过程以及高级映射。
• MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。
• MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。
• MyBatis 本是apache的一个开源项目iBatis2010年这个项目由apache software foundation 迁移到了[google code](https://baike.baidu.com/item/google code/2346604)，并且改名为MyBatis 。
• 2013年11月迁移到Github。

如何获得Mybatis？

• maven仓库

  <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
  <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.4</version>
  </dependency>
  

1.2、持久化

数据持久化

• 持久化就是将程序的数据在持久状态和瞬时状态转化的过程
• 内存：断电即失
• 数据库jdbc，io文件持久化

为什么需要持久化：

• 有一些对象不能让他丢掉
• 内存太贵了

1.3、持久层

Dao层，Service层，Controller层…

• 完成持久化工作的代码块
• 层界限十分明显

1.4、为什么需要MyBatis？

• 帮助程序猿将数据存入数据库中

• 方便

• 传统的JDBC代码太复杂了。简化。框架。自动化

• 不用Mabatis也可以。更容易上手。技术没有高低之分

• 优点：

  • 简单易学
  • 灵活
  • 解除sql与程序代码的耦合
  • 提供映射标签，支持对象与数据库的orm字段关系映射
  • 提供对象关系映射标签，支持对象关系组建维护
  • 提供xml标签，支持编写动态sql。 [2]

  最重要的一点：使用的人多！

2、第一个Mabatis程序

思路：搭建环境–>导入Mybatis–>编写代码–>测试

2.1、搭建环境

搭建数据库

新建项目

1.新建一个普通的maven项目

2.删除src目录

3.导入maven依赖

<!--导入依赖-->
    <dependencies>
<!--mysql依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.24</version>
        </dependency>
<!--mybatis-->
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.4</version>
        </dependency>
<!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

2.2、创建一个模块

• 编写mybatis的核心配置文件

  <?xml version="1.0" encoding="utf-8" ?>
  <!DOCTYPE configuration
          PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
          "http://mybatis.org/dtd/mybatis-3-config.dtd">
  <configuration>
      <environments default="development">
          <environment id="development">
              <transactionManager type="JDBC">
                  <property name="..." value="..."/>
              </transactionManager>
              <dataSource type="POOLED">
                  <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                  <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                  <property name="username" value="root"/>
                  <property name="password" value="123456"/>
              </dataSource>
          </environment>
      </environments>
  
      <mappers>
          <mapper resource="com/chen/dao/UserMapper.xml"></mapper>
      </mappers>
  </configuration>
  

• 编写mybatis工具类

  //sqlSessionFactory -->sqlSession
  public class MybatisUtils {
      private static SqlSessionFactory sqlSessionFactory;
      static {
      try{
          //获取Mybatis第一步：获取sqlsession对像
          String resource = "org/mybatis/example/mybatis-config.xml";
          InputStream inputStream = Resources.getResourceAsStream(resource);
          sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
      }catch(IOException e){
          e.printStackTrace();
      }
      }
  
   public static SqlSession getSqlSession(){
          SqlSession sqlSession = sqlSessionFactory.openSession();
          return sqlSession;
   }
  }
  

2.3、编写代码

• 实体类

  package com.chen.pojo;
  
  //实现类
  public class User {
      private int id;
      private String name;
      private String pwd;
  
      public User() {
      }
  
      public User(int id,String name,String pwd) {
          this.id = id;
          this.name=name;
          this.pwd=pwd;
      }
  
      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 String getPwd() {
          return pwd;
      }
  
      public void setPwd(String pwd) {
          this.pwd = pwd;
      }
  
      @Override
      public String toString() {
          return "User{" +
                  "id=" + id +
                  ", name='" + name + '\'' +
                  ", pwd='" + pwd + '\'' +
                  '}';
      }
  }
  
  

• Dao接口

  public interface UserDao {
      List<User> getUserList();
  }
  

• 接口实现类由原来的UseDaoImpl转变为一个Mapper配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.chen.dao.UserDao">
    <select id="getUserList" resultType="com.chen.pojo.User">
    select * from mybatis.user where id = #{id}
  </select>
</mapper>

2.4、测试

注意点：

org.apache.ibatis.binding.BindingException: Type interface com.chen.dao.UserDao is not known to the MapperRegistry.

MapperRegistry是什么？

核心配置文件中注册mappers

• junit测试

  public class UserDaoTest {    @Test    public void test(){        //第一步：获得Sqlsession对象        SqlSession sqlSession = MybatisUtils.getSqlSession();        //方式一：getMapper        UserDao userDao = sqlSession.getMapper(UserDao.class);        List<User> userList = userDao.getUserList();        for (User user : userList) {            System.out.println(user);        }        sqlSession.close();    }}
  

  你们可能能会遇到的问题：

  1.配置文件没有注册

  2.绑定接口错误

  3.方法名不对

  4.返回类型不对

  5.Maven导出资源问题

3、CRUD

1、namespace

namespace中的包名要和Dao/mapper接口的包名一致！

2、select

选择，查询语句：

• id：就是对应的namespace中的方法名；
• resultType：Sql语句执行的返回值！
• paremeterType：参数类型！

1.编写接口

//根据Id查询用户    User getUserById(int id);

2.编写对应的mapper中的sql语句

<select id="getUserById" parameterType="int" resultType="com.chen.pojo.User">    select * from user where id = #{id}    </select>

3.测试

@Test    public void getUserById(){        //第一步：获得Sqlsession对象        SqlSession sqlSession = MybatisUtils.getSqlSession();        //getMapper方式        UserMapper mapper = sqlSession.getMapper(UserMapper.class);        User userById = mapper.getUserById(1);        System.out.println(userById);        //关闭sqlsession        sqlSession.close();    }

3、insert

<insert id="addUser" parameterType="com.chen.pojo.User">        insert into user (id, name, pwd) value (#{id},#{name},#{pwd});    </insert>

4、update

<update id="updateUser" parameterType="com.chen.pojo.User">        update user set name =#{name},pwd=#{pwd} where id=#{id}    </update>

5、delete

   <delete id="deleteUser" parameterType="int">        delete from user where id=#{id}   </delete>

注意点：

• 增删改需要提交事务！

6、分析错误：

• 便签不要匹配错
• resource绑定mapper，需要使用路径！
• 程序配置文件必须符合规范
• NullPointerException，没有注册到资源
• 输出的xml文件中存在中文乱码问题！
• maven资源没有导出问题！

7、万能的map

假设，我们的实体类，或者数据库中的表，字段或者参数过多，我们应当考虑使用Map！

 //万能的Map    int addUser2(Map<String,Object> map);

<insert id="addUser2" parameterType="map">        insert into user (id, name, pwd) value (#{userid},#{username},#{password});    </insert>

 @Test    public void addUser2(){        SqlSession sqlSession = MybatisUtils.getSqlSession();        //getMapper方式        UserMapper mapper = sqlSession.getMapper(UserMapper.class);        Map<String, Object> map = new HashMap<String, Object>();        map.put("userid",5);        map.put("username","孙七");        map.put("password","555555");        mapper.addUser2(map);        sqlSession.commit();        sqlSession.close();    }

Map传递参数，直接在sql中取出key即可！【parameterType=”map“】

对象传递参数，直接在sql中去兑现的属性即可！【parameterType=”Object“】

只有一个基本类型参数的情况下，可以直接在sql中取到！

多个参数用Map，或者注解！

8、思考题

模糊查询怎么写？

1.Java代码执行的时候，传递通配符% %

List<User> user = mapper.getUserLike("%孙%");

2.在sql拼接中使用通配符！

select * from user where name like "%"#{value}"%"

4、配置解析

1、核心配置文件

• mybatis-config.xml
• MyBatis的配置文件包含了会深深影响Mybatis行为的设置和属性信息

configuration（配置）properties（属性）settings（设置）typeAliases（类型别名）typeHandlers（类型处理器）objectFactory（对象工厂）plugins（插件）environments（环境配置）environment（环境变量）transactionManager（事务管理器）dataSource（数据源）databaseIdProvider（数据库厂商标识）mappers（映射器）

2、环境配置（environments）

MyBatis 可以配置成适应多种环境

不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。

学会使用配置多套运行环境！

Mybatis默认的事务管理器就是JDB，连接池：POOLED

3、属性（properties）

我们可以通过properties属性来实现引用配置文件

这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置。【db.properties】

driver=com.mysql.cj.jdbc.Driverurl=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8username=rootpassword=123456

在核心配置文件中映入

<properties resource="db.properties"></properties>

• 可以直接引入外部文件
• 可以在其中增加一些属性配置
• 如果两个文件有同一个字段，优先使用外部配置文件的！

4、类型别名（typeAliases）

• 类型别名是为 Java 类型设置一个短的名字

• 存在的意义仅在于用来减少类完全限定名的冗余

  <!--可以给实体类起别名-->    <properties resource="db.properties"></properties>
  

  也可以指定一个包名，Mabatis会在包名下面搜索需要的Java Bean，比如：

  扫描实体类的包，他的默认别名就为这个类的类名，首字母小写！

  <typeAliases>        <package name="com.chen.pojo"/></typeAliases>
  

在实体类比较少的时候，使用第一种方式

如果实体类是否多，建议使用第二种。

第一种可以DIY别名，第二种则不行，如果非要改，需要在实体类上增加注解

@Alias("user")public class User {}

基本类型的别名

别名	映射的类型_byte	byte_long	long_short	short_int	int_integer	int_double	double_float	float_boolean	booleanstring	Stringbyte	Bytelong	Longshort	Shortint	Integerinteger	Integerdouble	Doublefloat	Floatboolean	Booleandate	Datedecimal	BigDecimalbigdecimal	BigDecimalobject	Objectmap	Maphashmap	HashMaplist	Listarraylist	ArrayListcollection	Collectioniterator	Iterator

5、设置（settings）

这是Mybatis中极为重要的调整设置。他们会改变Mybatis的运行时行为。

设置名	          描述	                               有效值	                    默认值cacheEnabled  |	全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。 |	true | false	|   truelazyLoadingEnabled	| 延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。| 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。  |	 true | false	  falselogImpl	 |  指定 MyBatis 所用日志的具体实现，未指定时将自动查找。	  |   SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING	   |     未设置

6、其他配置

• typeHandlers（类型处理器）
• objectFactory（对象工厂）
• plugins（插件）

7、映射器（mappers）

MapperRegistry：注册绑定我们的Mapper文件：

方式一：

<!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册！-->    <mappers>        <mapper resource="com/chen/dao/UserMapper.xml"></mapper>    </mappers>

方式二：使用class文件绑定注册

<!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册！-->    <mappers>        <mapper class="com.chen.dao.UserMapper"></mapper>    </mappers>

注意点：

• 接口和他的Mapper配置文件不行同名
• 接口和他的Mapper配置文件必须在同一个包下！

方式三：使用扫描包进行注入绑定

<!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册！-->    <mappers>        <package name="com.chen.dao"    </mappers>

注意点：

• 接口和他的Mapper配置文件不行同名
• 接口和他的Mapper配置文件必须在同一个包下！

8、作用域（Scope）和生命周期

作用域和生命周期类别是至关重要的，因为错误的使用会导致非常严重的并发问题。

SqlSessionFactoryBuilder：

• 一旦创建了 SqlSessionFactory，就不再需要它了
• 局部变量

SqlSessionFactory：

• 说白了就是可以想像为：数据库连接池
• SqlSessionFactory一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例
• 因此 SqlSessionFactory 的最佳作用域是应用作用域
• 最简单的就是使用单例模式或者静态单例模式

SqlSession

• 连接到连接池的一个请求
• SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域
• 用完之后需要立即关闭，否则资源被占用

5、解决属性名和字段名不一致的问题

1、问题

数据库中的字段

新建一个项目，拷贝之前的，测试实体类字段不一致的情况

测试出现问题

select * from user where id = #{id}类型处理器select id,name,pwd from user where id = #{id}

解决方法：

起别名

<select id="getUserById" parameterType="int" resultType="User">    select id,name,pwd as password from user where id = #{id}    </select>

2、resultMap

结果集映射

id name pwdid name password

<!--结果集映射--><resultMap id="UserMap" type="User"><!--column数据库中的字段，property实体类中的属性-->    <result column="id" property="id"></result>    <result column="name" property="name"></result>    <result column="pwd" property="password"></result></resultMap>    <select id="getUserById" resultMap="UserMap">    select * from user where id = #{id}    </select>

• resultMap` 元素是 MyBatis 中最重要最强大的元素

• ResultMap的设计思想是，对于简单的语句根本不需要配置显式的结果映射，而对于复杂一点的语句只需要描述他们的关系就行了。

• ResultMap最优秀的地方在于，虽然你已经对他相当了解了，但是根本就不需要显式地用到他们。

• 如果世界总是这么简单就好了。

6、日志

6.1、日志工厂

如果一个数据库操作，出现了异常，我们需要排错。日志就是最好的帮手！

曾经：sout、debug

现在：日志工厂！

• SLF4J
• LOG4J 【掌握】
• LOG4J2
• JDK_LOGGING
• COMMONS_LOGGING
• STDOUT_LOGGING 【掌握】
• NO_LOGGING

在Mybatis中具体使用那一个日志实现，在设置中设定！

STDOUT_LOGGING标准日志输出

在mybatis核心配置中，配置我们的日志！

 <settings>        <setting name="logImpl" value="STDOUT_LOGGING"/>    </settings>

6.2、Log4j

什么是Log4j？

• Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件
• 我们也可以控制每一条日志的输出格式；
• 通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。
• 通过一个配置文件来灵活地进行配置，而不需要修改应用的代码

1.先导入log4j的包

<!-- https://mvnrepository.com/artifact/log4j/log4j -->    <dependency>        <groupId>log4j</groupId>        <artifactId>log4j</artifactId>        <version>1.2.17</version>    </dependency>

2.log4j.porperties

#将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码log4j.rootLogger=DEBUG,console,file#控制台输出的相关设置log4j.appender.console = org.apache.log4j.ConsoleAppenderlog4j.appender.console.Target = System.outlog4j.appender.console.Threshold=DEBUGlog4j.appender.console.layout = org.apache.log4j.PatternLayoutlog4j.appender.console.layout.ConversionPattern=【%c】-%m%n#文件输出的相关设置log4j.appender.file = org.apache.log4j.RollingFileAppenderlog4j.appender.file.File=./log/kuang.loglog4j.appender.file.MaxFileSize=10mblog4j.appender.file.Threshold=DEBUGlog4j.appender.file.layout=org.apache.log4j.PatternLayoutlog4j.appender.file.layout.ConversionPattern=【%p】【%d{yy-MM-dd}】【%c】%m%n#日志输出级别log4j.logger.org.mybatis=DEBUGlog4j.logger.java.sql=DEBUGlog4j.logger.java.sql.Statement=DEBUGlog4j.logger.java.sql.ResultSet=DEBUGlog4j.logger.java.sql.PreparedStatement=DEBUG

3.配置log4j为日志的实现

<settings>     <setting name="logImpl" value="LOG4J"/></settings>

4.Log4j的使用！直接测试运行刚才的查询

简单使用

1.在要使用Log4j的类中，导入包import org.apache.log4j.Logger;

2.日志对象，参数为当前类的class

static Logger logger = Logger.getLogger(UserDaoTest.class);

3.日志级别

7、分页

思考：为什么分页？

• 减少数据冗余

7.1、使用Limit分页

语法:Select * from user limit startIndex,pageSize;Select * from user limit 3; #[0,n]

使用Mybatis实现分页,核心Sql

1.接口

//分页    List<User> getUserByLimit(Map<String,Integer> map);2.Mapper.xml​```xml<!--分页-->    <select id="getUserByLimit" parameterType="map" resultType="user">        select * from user limit #{startIndex},#{pageSize}    </select>

3.测试

@Test    public void getUserByLimit(){        SqlSession sqlSession = MybatisUtils.getSqlSession();        UserMapper mapper = sqlSession.getMapper(UserMapper.class);        HashMap<String, Integer> map = new HashMap<>();        map.put("startIndex",1);        map.put("pageSize",2);        List<User> userByLimit = mapper.getUserByLimit(map);        for (User user : userByLimit) {            System.out.println(user);        }        sqlSession.close();    }

7.2、RowBounds分页

不再使用SQL实现分页

1.接口

List<User> getUserByRowBounds();

2.mapper.xml

<select id="getUserByRowBounds"  resultMap="UserMap">        select * from user    </select>

3.测试

 @Test    public void getUserByRowBounds(){        SqlSession sqlSession = MybatisUtils.getSqlSession();        //Rowbounds实现        RowBounds rowBounds = new RowBounds(1, 2);                //通过Java代码层面实现分页        List<User> userList = sqlSession.selectList("com.chen.dao.UserMapper.getUserByRowBounds",null,rowBounds);        for (User user : userList) {            System.out.println(user);        }        sqlSession.close();    }

7.3、分页插件

8、使用注解开发

8.1、面向接口编程

8.2、使用注解开发

1.注解在接口上实现

@Select("select * from user")    List<User> getUsers();

2.需要在核心配置文件中绑定接口！

<mappers>        <mapper class="com.chen.dao.UserMapper"></mapper>    </mappers>

3.测试

本质：反射机制实现

底层：动态代理！

Mybatis详细的执行流程！

8.3、CRUD

我们可以在工具栏创建的时候实现自动提交事务！

public static SqlSession getSqlSession(){        return sqlSessionFactory.openSession(true);}

编写接口，增加注解

@Select("select * from user")    List<User> getUsers();//方法存在多个参数，所有的参数前面必须加上@Param（" "）注解    @Select("select * from user where id = #{id}")    User getUserByID(@Param("id") int id);    @Insert("insert into user (id,name,pwd) values (#{id},#{name},#{password})")    int addUser(User user);    @Update("update user set name = #{name},pwd=#{password} where id=#{id}")    int updateUser(User user);    @Delete("delete from user where id=#{id}")    int deleteUser(@Param("id")int id);

测试类

【注意：我们必须要将接口绑定到我们的核心配置文件中！】

关于@Param()注解

• 基本类型的参数或者String类型，需要加上
• 引用类型不需要加
• 如果只有一个基本类型的话，可以忽略，但是建议大家都加上！
• 我们在SQL中引用的就是我们这里的@Param()中设定的属性名！

#{} ${}的区别

#方式能够很大程度防止sql注入；$方式无法防止Sql注入。
KaTeX parse error: Expected 'EOF', got '#' at position 28: …象，例如传入表名。 一般能用#̲的就别用。MyBatis排序时使用order by 动态参数时需要注意，用$而不是#。

9、Lombok

Project LombokProject Lombok is a java library that automatically plugs into your editor and build tools, spicing up your java.Never write another getter or equals method again, with one annotation your class has a fully featured builder, Automate your logging variables, and much more.

• java library
• plugs
• build tools
• with one annotation your class

使用步骤：

1.在IDEA中安装Lombok插件！

2.在项目中导入Lombok的jar包

<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->    <dependency>        <groupId>org.projectlombok</groupId>        <artifactId>lombok</artifactId>        <version>1.18.20</version>    </dependency>

3.在实体类上加注解即可！

@Date@AllArgsConstructor@NoArgsConstructor

@Getter and @Setter@FieldNameConstants@ToString@EqualsAndHashCode@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog@Data@Builder@SuperBuilder@Singular@Delegate@Value@Accessors@Wither@With@SneakyThrows

@Date:无参构造，get、set、tostring、hashcode、equals@AllArgsConstructor@NoArgsConstructor@EqualsAndHashCode@ToString@Getter

10、多对一处理

sql：

CREATE TABLE `teacher` (  `id` INT(10) NOT NULL,  `name` VARCHAR(30) DEFAULT NULL,  PRIMARY KEY (`id`)) ENGINE=INNODB DEFAULT CHARSET=utf8INSERT INTO teacher(`id`, `name`) VALUES (1, '秦老师'); CREATE TABLE `student` (  `id` INT(10) NOT NULL,  `name` VARCHAR(30) DEFAULT NULL,  `tid` INT(10) DEFAULT NULL,  PRIMARY KEY (`id`),  KEY `fktid` (`tid`),  CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)) ENGINE=INNODB DEFAULT CHARSET=utf8INSERT INTO `student` (`id`, `name`, `tid`) VALUES (1, '小明', 1); INSERT INTO `student` (`id`, `name`, `tid`) VALUES (2, '小红', 1); INSERT INTO `student` (`id`, `name`, `tid`) VALUES (3, '小张', 1); INSERT INTO `student` (`id`, `name`, `tid`) VALUES (4, '小李', 1); INSERT INTO `student` (`id`, `name`, `tid`) VALUES (5, '小王', 1);

测试环境搭建

1.导入Lombok

2.新建实体类Teacher，Student

3.建立Mapper接口

4.建立Mapper.XML文件

5.在核心配置文件中绑定注册我们的Mapper接口或者文件！【方式很多，随心选】

6.测试查询是否能够成功！

按照查询嵌套处理【子查询】

按照结果嵌套处理

回顾MySql多对一查询方式：

• 子查询
• 联表查询

11、一对多处理

比如：一个老师拥有多个学生！

对于老师而言，就是一对多的关系！

测试环境搭建

1.环境搭建，和刚才的一样

实体类

@Datapublic class Student {    private int id;    private String name;    private int tid;}

@Datapublic class Teacher {    private int id;    private String name;    //一个老师拥有多个学生    private List<Student> students;}

按照结果嵌套处理

按照查询嵌套处理【子查询】

小结

1.关联-association【多对一】

2.集合-collection【一对多】

3.javaType & ofType

1.JavaType 用来指定实体类中属性的类型

2.ofType 用来指定映射到List或者集合中的pojo类型，泛型中的约束类型！

注意点：

• 保证SQL的可读性，尽量保证通俗易懂
• 注意一对多和多对一中，属性名和字段的问题！
• 如果问题不好排查错误，可以使用日志，建议使用Log4j

面试高频：

• Mysql引擎
• InnoDB底层原理
• 索引
• 索引优化！

12、动态SQL

什么是动态SQL：动态SQL就是指根据不同的条件生产不同的SQL语句

利用动态 SQL，可以彻底摆脱这种痛苦。

动态SQL元素和JSTL 或基于类似 XML的文本处理器相似。在 MyBatis 之前的版本中，有很多元素需要花时间了解。MyBatis 3 大大精简了元素种类，现在只需要学习原来一半元素便可。Mybatis采用功能强大的基于OGNL的表达式来淘汰其他大部分元素。ifchoose (when, otherwise)trim (where, set)foreach

搭建环境

CREATE TABLE `blog`(`id` VARCHAR(50) NOT NULL COMMENT 博客id,`title` VARCHAR(100) NOT NULL COMMENT 博客标题,`author` VARCHAR(30) NOT NULL COMMENT 博客作者,`create_time` DATETIME NOT NULL COMMENT 创建时间,`views` INT(30) NOT NULL COMMENT 浏览量)ENGINE=INNODB DEFAULT CHARSET=utf8

创建一个基础工程

1.导包

2.编写配置文件

3.编写实体类

@Datapublic class Blog {    private int id;    private String title;    private String author;    private Date createTime;    private  int views;}

4.编写实体类对应Mapper接口和Mapper.xml文件

IF

<select id="queryBlogIF" parameterType="map" resultType="com.chen.pojo.Blog">                select * from blog where 1=1                <if test="title != null">                    and title = #{title}                </if>                <if test="author != null">                    and author = #{author}                </if></select>

choose (when, otherwise)

<select id="queryBlogChoose" parameterType="map" resultType="com.chen.pojo.Blog">                select * from blog where                    <choose>                        <when test="title != null">                            and title = #{title}                        </when>                        <when test="author != null">                            and author = #{author}                        </when>                        <otherwise>                            views = #{views}                        </otherwise>                    </choose></select>

trim (where, set)

<select id="queryBlogIF" parameterType="map" resultType="com.chen.pojo.Blog">     select * from blog      <where>          <if test="title != null">               and title = #{title}          </if>          <if test="author != null">               and author = #{author}          </if>    </where>            </select>

<update id="updateById" parameterType="map">                update blog                <set>                        <if test="title != null">                                title = #{title},                        </if>                        <if test="author != null">                                author = #{author},                        </if>                </set>                where id=#{id}        </update>

<trim prefix="" prefixOverrides="" suffix="" suffixOverrides=""></trim>

所谓的动态SQL，本质还是SQL语句，只要我们可以在SQL层面，去执行一个逻辑代码

Foreach

<select id="BlogForEach" parameterType="map" resultType="com.chen.pojo.Blog">                select * from blog                <where>                        <foreach collection="ids" item="id" open="(" close=")" separator="or">                               id = #{id}                        </foreach>                </where>        </select>

 @Test    public void queryBlogIF(){        SqlSession sqlSession = MybatisUtils.getSqlSession();        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);        HashMap map = new HashMap();        ArrayList<Integer> ids = new ArrayList();        ids.add(1);        ids.add(2);        map.put("ids",ids);        List<Blog> blogs = mapper.BlogForEach(map);        for (Blog blog : blogs) {            System.out.println(blog);        }        sqlSession.close();    }

SQL片段

有的时候，我们可能会将一些功能部分抽取出来，方便服用！

1.使用SQL标签抽取公共的部分

<sql id="if-title-author">                <if test="title != null">                        and title = #{title}                </if>                <if test="author != null">                        and author = #{author}                </if>        </sql>

2.在需要使用的地方使用include标签引用即可

<select id="queryBlogIF" parameterType="map" resultType="com.chen.pojo.Blog">                select * from blog                <where>                        <include refid="if-title-author"></include>                </where>        </select>

注意事项：

• 最好基于单表来定义SQL片段
• 不要存在where标签

动态SQL就是在拼接SQL语句，我们只要保证SQL的正确性，按照SQL的格式，去排列组合就可以了

13、缓存