Mybatis 学习笔记总结 (一)

xupengboo

已于 2022-02-12 17:15:53 修改

阅读量2.1k

点赞数 1

分类专栏： Java 文章标签： java intellij-idea mybatis ssm

于 2022-02-07 00:13:33 首次发布

本文链接：https://blog.csdn.net/IT_Holmes/article/details/122753692

版权

Java 专栏收录该内容

61 篇文章 123 订阅

订阅专栏

1. Mybatis

1.1 Mybatis 官方定义

官方给的定义：

MyBatis 是一款优秀的持久层框架。
它支持自定义 SQL、存储过程以及高级映射。
MyBatis 免除了几乎所有的 JDBC 代码以及设置参数(db.property文件)和获取结果集(ResultSet结果集)的工作。
MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

1.2 Mybatis 历史和获取安装

Mybatis的历史？

Mybatis本是apache的一个开源项目iBatis(现在，我们导入包很多包也是iBatis的名字。) ，后来由阿帕奇转到了谷歌，才改名为Mybatis，之后又迁移到了Github上面。

如何获得Mybatis？

maven仓库获取。
Github获取。

一般我们直接maven获取就行。

1.3 Dao层

Dao层(Data access Object)也就是持久层。

我们的内存一般就是断电即失。

而jdbc数据库，io持久化。持久化就是将程序数据在持久状态和瞬时状态转化的过程。

1.4 为什么需要Mybatis？

在这里插入图片描述

2. Mybatis 准备工作

2.1 错误注意事项(重点！)

Mybatis的错误注意点：

Type interface com.itholmes.dao.UserDao is not known to the MapperRegistry. 这个错误就是因为我们设置的Mapper.xml没有在Mybatis-config.xml中进行配置注册。

Maven的常见的错误：

在Mybatis配置中，遇到的类似下图的错误：
原因就是我们设定的xml等配置文件，这些配置文件在maven中，默认是设定在了resources文件中。如果将xml配置文件放到了java结构下，maven测试导入的时候就没办法引入了。

Maven的机制就是约定优于配置。

也就是说我们在resources的其他结构写配置文件，可能无法导出或者生效！不过，这里是有解决办法的！

解决办法就是在pom.xml文件中来进行引入就可：

<!--在build中配置resources，从而也可以将其他结构下的xml配置文件也会被导入，让其生效！-->
<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
        </resource>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
        </resource>
    </resources>
</build>

配置好之后，再运行就没问题了，也能在target中看到配置文件的导入。
在这里插入图片描述

2.2 Mybatis的使用

第一步：导包导依赖。

mysql驱动包和mybatis包的依赖。

在这里插入图片描述

第二步：编写mybatis的核心配置文件，mybatis-config.xml文件。

配合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">

<!--mybatis的核心配置文件-->
<configuration>
    <!--
    	环境，可以设定多个，不同场景用不同的环境。
		
		想用那个环境直接设置default属性就行。
    -->
    <environments default="development">
        <environment id="development">
            <!--事务管理器-->
            <transactionManager type="JDBC"/>
            <!--dataSource是数据源，平时我们遇到的数据源有dbcp，c3p0，德鲁伊等等。-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <!--
                    useSSL=true: 安全
                    连接。
                    &amp; 在xml需要转义，转义后的内容就是 & 符号。
                    useUnicode=true: 使用Unicode编码，设置中文。
                    characterEncoding=UTF-8: 字符集。
                    serverTimezone=Asia/Shanghai：设置时区。
                -->
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=Asia/Shanghai"/>
                <property name="username" value="root"/>
                <property name="password" value="0818"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

第三步：封装mybatis工具类，负责生产SqlSession。

这里有个工厂过程：

SqlSessionFactoryBuilder  => SqlSessionFactory => SqlSession

封装mybatis工具类MybatisUtils 类：

package com.itholmes.utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

public class MybatisUtils {

    private static String resource = null;
    private static InputStream inputStream = null;
    private static SqlSessionFactory sqlSessionFactory = null;

    static {
        try {

            //使用Mybatis的第一步骤：获取sqlSessionFactory对象
            resource = "mybatis-config.xml";
            inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static SqlSession getSqlSession(){
        /*
        *   获取到了SqlSessionFactory，我们可以从中获得 SqlSession 的实例。
        *   SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。
        * */
        SqlSession sqlSession = sqlSessionFactory.openSession();
        return sqlSession;
    }

}

第四步：编写代码。

首先，设定一个pojo层的实体类，对应数据库内容的User类：

package com.itholmes.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;
    }
}

在这里插入图片描述

设定一个Dao层的接口：

package com.itholmes.dao;

import com.itholmes.pojo.User;

import java.util.List;

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

设定接口实现类：

一般我们平时使用jdbc操作，都是直接写一个UserDaoImpl.java文件，写一堆操作数据库的代码获取结果集啥的。但是在这里我们可以使用一个Mapper.xml配置文件，来替代这些操作。

写一个UserMapper.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">
<!--namespace：绑定一个对应的Dao/Mapper接口。-->
<mapper namespace="com.itholmes.dao.UserDao">
    <!--
        select查询语句
        id属性就是我们要重写的方法的名字，对应namespace绑定的接口。

        resultType:返回一个类型。
        resultMap:返回多个类型。
    -->
    <select id="getUserList" resultType="com.itholmes.pojo.User">
        select * from mybatis.user
    </select>
</mapper>

第五步：编写测试。

package com.itholmes.dao;

import com.itholmes.pojo.User;
import com.itholmes.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.jupiter.api.Test;

import java.util.List;

public class UserDaoTest {
    @Test
    public void test(){

        //通过我们设定的工具类来获取sqlSession。
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        /*
            方式一：使用getMapper来获取实现类（常用！！！最新推荐的）
        */
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        List<User> userList = mapper.getUserList();

        /*
            方式二：使用getMapper来获取实现类(不常用但是要知道！)

            如果返回的是一个结果：sqlSession.selectOne。
            如果返回的是一个list：sqlSession.selectList。
            如果返回的是一个map：sqlSession.selectMap。
            ... 等等都是与返回值类型对应出来的。
        */
        List<User> userList2 = sqlSession.selectList("com.itholmes.dao.UserDao.getUserList");

        System.out.println("userList:");

        for (User user : userList) {
            System.out.println(user);
        }

        System.out.println("userList2:");

        for (User user : userList2) {
            System.out.println(user);
        }

        //关闭sqlSession
        sqlSession.close();
    }
}

总结，创建一个mybatis的基础工程步骤：

1.导包。
2.编写配置文件。
3.编写实体类。
4.编写实体类对应Mapper接口和Mapper.xml文件。

2.3 Mybatis的注意事项

命名空间：
在这里插入图片描述

一定使用全限定名：
在这里插入图片描述

三者的关系和注意事项：
在这里插入图片描述

3. Mybatis 的 CRUD实现

接下来的操作配置都在我们自己设定的Mapper.xml中进行！

3.1 namespace

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

在这里插入图片描述

3.2 select 查询

选择，查询语句：

id属性：对应的namespace中的方法名。
resultType属性：Sql语句执行的返回值！
对应的还有个resultMap，区别就是resultType返回一个类型，resultMap返回多个类型。
parameterType属性：设置参数类型。

UserMapper.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="com.itholmes.dao.UserMapper">

    <select id="getUserList" resultType="com.itholmes.pojo.User" >
        select * from mybatis.user
    </select>

    <!--
        parameterType属性：定义参数类型。
        #{id} ，拿到对应方法中参数名为id的参数。
    -->
    <select id="getUserById" resultType="com.itholmes.pojo.User" parameterType="int">
        select * from mybatis.user where id = #{id}
    </select>

</mapper>

UserMapper.java接口：

package com.itholmes.dao;

import com.itholmes.pojo.User;

import java.util.List;

public interface UserMapper {
    //查询全部用户
    List<User> getUserList();
    //根据ID查询用户
    User getUserById(int id);
}

测试类：

package com.itholmes.dao;

import com.itholmes.pojo.User;
import com.itholmes.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.jupiter.api.Test;

import java.util.List;

public class UserDaoTest {

    @Test
    public void getUserById(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User userById = mapper.getUserById(1);
        System.out.println(userById);
        sqlSession.close();
    }
}

3.3 增删改语句

需要注意的是Mybatis的增删改需要手动提交事务！jdbc都是自动提交事务的。

UserMapper.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">
<!--namespace：绑定一个对应的Dao/Mapper接口。-->
<mapper namespace="com.itholmes.dao.UserMapper">

    <!--
        select查询语句
        id属性就是我们要重写的方法的名字，对应namespace绑定的接口。

        resultType:返回一个类型。
        resultMap:返回多个类型。
    -->
    <select id="getUserList" resultType="com.itholmes.pojo.User" >
        select * from mybatis.user;
    </select>
    <!--
        select查询语句(有参数)：
        parameterType属性：定义参数类型。
        #{id} ，拿到对应方法中参数名为id的参数。
    -->
    <select id="getUserById" resultType="com.itholmes.pojo.User" parameterType="int">
        select * from mybatis.user where id = #{id};
    </select>

    <!--
        insert插入语句:
            对象中的属性，可以直接取出来。
    -->
    <insert id="addUser" parameterType="com.itholmes.pojo.User">
        insert into mybatis.user (`id`,`name` ,`pwd`) values (#{id},#{name},#{pwd});
    </insert>
    <!--
        更新语句:
    -->
    <update id="updateUser" parameterType="com.itholmes.pojo.User">
        update mybatis.user set `name`=#{name},`pwd`=#{pwd} where id = #{id};
    </update>
    <!--
        删除语句：
    -->
    <delete id="deleteUser" parameterType="int">
        delete from mybatis.user where id = #{id};
    </delete>
</mapper>

UserMapper.java接口文件：

package com.itholmes.dao;

import com.itholmes.pojo.User;

import java.util.List;

public interface UserMapper {
    //查询全部用户
    List<User> getUserList();
    //根据ID查询用户
    User getUserById(int id);
    //插入用户
    int addUser(User user);
    //修改用户
    int updateUser(User user);
    //删除用户
    int deleteUser(int id);
}

UserDaoTest测试文件：

package com.itholmes.dao;

import com.itholmes.pojo.User;
import com.itholmes.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.jupiter.api.Test;

import java.util.List;

public class UserDaoTest {
    @Test
    public void test(){

        //通过我们设定的工具类来获取sqlSession。
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        /*
            方式一：使用getMapper来获取实现类（常用！！！最新推荐的）
        */
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = mapper.getUserList();

        /*
            方式二：使用getMapper来获取实现类(不常用但是要知道！)

            如果返回的是一个结果：sqlSession.selectOne。
            如果返回的是一个list：sqlSession.selectList。
            如果返回的是一个map：sqlSession.selectMap。
            ... 等等都是与返回值类型对应出来的。
        */
        List<User> userList2 = sqlSession.selectList("com.itholmes.dao.UserMapper.getUserList");

        System.out.println("userList:");

        for (User user : userList) {
            System.out.println(user);
        }

        System.out.println("userList2:");

        for (User user : userList2) {
            System.out.println(user);
        }

        //关闭sqlSession
        sqlSession.close();
    }

    @Test
    public void getUserById(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User userById = mapper.getUserById(1);
        System.out.println(userById);
        sqlSession.close();
    }

    //Mybatis的增删改需要提交事物！！平时写的jdbc都是自动提交事务的。
    //mybatis的插入操作
    @Test
    public void addUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int i = mapper.addUser(new User(4, "白衣", "0000"));
        if (i>0){
            System.out.println("插入成功！");
            //注意需要提交事务
            sqlSession.commit();
        }else{
            System.out.println("插入失败！");
        }

        sqlSession.close();
    }

    //Mybatis的更新操作
    @Test
    public void updateUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int i = mapper.updateUser(new User(1, "诸葛亮", "123456"));
        if (i>0){
            System.out.println("更新成功");
            sqlSession.commit();
        }else {
            System.out.println("更新失败");
        }
        sqlSession.close();
    }

    //Mybatis的删除操作
    @Test
    public void deleteUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int i = mapper.deleteUser(1);
        if (i>0){
            System.out.println("删除成功");
            sqlSession.commit();
        }else {
            System.out.println("删除失败");
        }
        sqlSession.close();
    }
}

4. Map和模糊查询

4.1 万能Map

假设，我们的实体类或者数据库中的表，字段或者参数过多，我们应当考虑使用Map来作为参数类型进行操作。

UserMapper.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">
<!--namespace：绑定一个对应的Dao/Mapper接口。-->
<mapper namespace="com.itholmes.dao.UserMapper">
    <!--
        如果参数类型是map类型的，那么我们传入的参数值对应的就map的key值。
        插入语句是没有resultType属性来设置返回值的。
    -->
    <insert id="addUser2" parameterType="map">
        insert into mybatis.user (`id`,`name`,`pwd`) values (#{userid},#{username},#{password});
    </insert>
</mapper>

UserMapper接口文件：

package com.itholmes.dao;

import com.itholmes.pojo.User;

import java.util.List;
import java.util.Map;

public interface UserMapper {
    //万能map
    int addUser2(Map<String,Object> map);
}

测试类：

package com.itholmes.dao;

import com.itholmes.pojo.User;
import com.itholmes.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.jupiter.api.Test;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class UserDaoTest {

    //测试map
    @Test
    public void addUser2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        Map<String, Object> map = new HashMap<>();
        map.put("userid",6);
        map.put("username","张四");
        map.put("password","8973");

        int i = mapper.addUser2(map);
        if (i>0){
            System.out.println("map插入成功");
            sqlSession.commit();
        }else {
            System.out.println("map插入失败");
        }
        sqlSession.close();
    }
}

Map可以通过key-value的形式来操作很多不同的东西，非常方便。也就叫做了万能Map。

总结：

Map传递参数，直接在sql中取出key即可，一般我们设置Map的类型都是Map<String,Object>类型。
实体类对象传递参数，直接在sql中取实体类对象的属性即可。
只有一个基本类型参数的情况下，可以直接在sql中取到。
多个参数用Map或者注解来操作。
select语句是由resultType属性来定义返回值类型的。增删改是没有resultType属性没法设置返回值，它们的返回值默认是int。

4.2 Mybatis的模糊查询

模糊查询：
需要注意的是，我们一般会在配置文件下面直接拼接%连通符。

<?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">
<!--namespace：绑定一个对应的Dao/Mapper接口。-->
<mapper namespace="com.itholmes.dao.UserMapper">

    <!--
        模糊查询：
            需要注意的是，我们一般会在配置文件下面直接拼接%连通符。
            这样只需要传参数就可以了。
    -->
    <select id="getUserLike" parameterType="String" resultType="com.itholmes.pojo.User">
        select * from mybatis.user where `name` like "%"#{likeValue}"%";
    </select>
</mapper>

UserMapper接口类：

package com.itholmes.dao;

import com.itholmes.pojo.User;

import java.util.List;
import java.util.Map;

public interface UserMapper {
    //模糊查询
    List<User> getUserLike(String s);
}

测试类：

package com.itholmes.dao;

import com.itholmes.pojo.User;
import com.itholmes.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.jupiter.api.Test;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class UserDaoTest {
    //模糊查询
    @Test
    public void getUserLike(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        String s = "葛";
        List<User> list = mapper.getUserLike(s);
        for (User user : list) {
            System.out.println(user);
        }
        sqlSession.close();
    }
}

5. Mybatis的配置优化

这里的配置其实就是上面的mybatis-config.xml文件中配置的东西。

configuration(配置):

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

往后就一个个介绍每个标签配置的作用以及效果。

6. 环境变量(environments)

6.1 配置文件中的 environment标签

Mybatis可以使用多种环境。

**加粗样式**

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

创建SqlSessionFactory实例可以指定配置环境：(如果不指定配置环境，就是用默认的环境)
在这里插入图片描述

6.2 environment标签中的 transactionManager标签(事务管理器)

在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED]"）：

JDBC – 这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来管理事务作用域。默认是JDBC属性值。
MANAGED – 这个配置几乎没做什么。它从不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。默认情况下它会关闭连接。然而一些容器并不希望连接被关闭，因此需要将 closeConnection 属性设置为 false 来阻止默认的关闭行为。例如:

<transactionManager type="MANAGED">
  <property name="closeConnection" value="false"/>
</transactionManager>

提示：如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器，因为 Spring 模块会使用自带的管理器来覆盖前面的配置。

6.3 environment标签中的 dataSource标签(数据源)

我们平时遇到的数据源有dbcp，c3p0，druid(德鲁伊)等。

Mybatis中配置的dataSource标签元素有三种类型：

UNPOOLED– 这个数据源的实现会每次请求时打开和关闭连接。虽然有点慢，但对那些数据库连接可用性要求不高的简单应用程序来说，是一个很好的选择。简而言之，就是没有池的效果。
POOLED– 这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来，避免了创建新的连接实例时所必需的初始化和认证时间。这种处理方式很流行，能使并发 Web 应用快速响应请求。该类型就体现了池的效果，所谓的池就是用完可以回收接着用。默认使用的就是POOLED属性值。
JNDI-该类型了解，具体查看官方。

7. 属性(properties)

我们可以通过properties属性来实现引用配置文件，可动态替换的效果。

这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素来传递。就像我们之前写的db.properties文件。

创建一个db.properties文件：

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
username=root
password=0818

在核心配置文件(mybatis-config.xml文件)中引入我们的db.properties文件：

mybatis的核心xml配置文件是有顺序规定的！

mybatis-config.xml文件的properties配置如下：

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

<!--mybatis的核心配置文件-->
<configuration>

    <!--引入外部配置文件,当然我们也可以直接在这里定义设置就可。-->
    <properties resource="db.properties">
        <property name="username" value="root"/>
        <property name="password" value="0818"/>
    </properties>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!--这里的属性可以在properties引入的外部配置文件中提取信息出来。-->
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <!--每一个Mapper.xml都需要在Mybatis核心配置文件中注册！-->
    <mappers>
        <mapper resource="com/itholmes/dao/UserMapper.xml"/>
    </mappers>
</configuration>

注意事项：如果在propertes标签和db.properties文件中，同时设置了相同的字段，优先使用外部配置文件的，也就是db.properties文件。

8. 类型别名(typeAliases)

类型别名可为 Java 类型设置一个缩写名字。它仅用于 XML 配置，意在降低冗余的全限定类名书写。例如：

同样，设置类型别名也是需要按照mybatis配置文件的顺序的！

下面的注释内容要记住！

<!--
    typeAliases标签：
        1. typeAlias标签：可以给实体类起别名。
            type属性:指定具体的类。
            alias属性:起别名。
        2. package标签：可以指定包名，MyBatis 会在包名下面搜索需要的 Java Bean
            package的name属性指定的包，mybatis会扫描这个包中的类，它的默认别名就是这个类的类名，首字母小写。
            如果对应的类上面有@Alias("xxx")指定的注解值时，那么就是用该注解定义的名字。
-->
<typeAliases>
    <typeAlias type="com.itholmes.pojo.User" alias="User"/>
    <!--<package name="com.itholmes.pojo"/>-->
</typeAliases>

@Alias(“xxx”)注解如下：
在这里插入图片描述

还有一些内建别名：

在这里插入图片描述
这里没截全，可以去官方网站查看。

9. settings(设置)

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

setting设置的内容有很多，需要记住的有：
在这里插入图片描述

全部的setting配置：

<settings>
  <setting name="cacheEnabled" value="true"/>
  <setting name="lazyLoadingEnabled" value="true"/>
  <setting name="multipleResultSetsEnabled" value="true"/>
  <setting name="useColumnLabel" value="true"/>
  <setting name="useGeneratedKeys" value="false"/>
  <setting name="autoMappingBehavior" value="PARTIAL"/>
  <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
  <setting name="defaultExecutorType" value="SIMPLE"/>
  <setting name="defaultStatementTimeout" value="25"/>
  <setting name="defaultFetchSize" value="100"/>
  <setting name="safeRowBoundsEnabled" value="false"/>
  <setting name="mapUnderscoreToCamelCase" value="false"/>
  <setting name="localCacheScope" value="SESSION"/>
  <setting name="jdbcTypeForNull" value="OTHER"/>
  <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>

10. 映射器(mappers)

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

在mybatis的核心配置文件中进行注册的方式有多种：

方式一：使用相对于类路径的资源引用(resource)[推荐使用]：

<!-- 使用相对于类路径的资源引用 -->
<mappers>
    <mapper resource="com/itholmes/dao/UserMapper.xml"/>
</mappers>

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

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

但是方式二有两个注意点！一个是接口和它的Mapper配置文件必须同名。再者就是接口和它的Mapper配置文件必须在同一给包下。
在这里插入图片描述

方式三：使用扫描包进行注入绑定。和方式二一样必须要注意是否同名，是否在同一个目录下！

<mappers>
    <package name="com.itholmes.dao"/>
</mappers>

xupengboo

关注

1
点赞
踩
13

收藏

觉得还不错? 一键收藏
打赏
0
评论
Mybatis 学习笔记总结 (一)

1. Mybatis1.1 Mybatis 官方定义1.2 Mybatis 历史和获取安装1.3 Dao层1.4 为什么需要Mybatis？2. Mybatis 准备工作2.1 错误注意事项(重点！)2.2 Mybatis的使用2.3 Mybatis的注意事项3. Mybatis 的 CRUD实现3.1 namespace3.2 select 查询3.3 增删改语句4. Map和模糊查询4.1 万能Map4.2 Mybatis的模糊查询5. Mybatis的配置优化
复制链接

扫一扫