狂神说Mybatis笔记

原创

已于 2022-02-28 10:09:28 修改 · 493 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#mybatis

于 2021-08-26 14:25:05 首次发布

一. 资料来源

mybatis B站视频链接
b站视频链接，点击跳转
 Mybatis的官网

二. 大概分了如下模块：

狂神说Mybatis01：第一个程序
狂神说Mybatis02：CRUD操作及配置解析
狂神说Mybatis03：ResultMap及分页
狂神说Mybatis04：使用注解开发
狂神说Mybatis05：一对多和多对一处理
狂神说Mybatis06：动态SQL
狂神说Mybatis07：缓存

三.正式开始学习

（一）Mybatis学前理解

环境搭建

jdk 8 +
MySQL 5.7.19
maven-3.6.1
IDEA
学习前需要掌握：
JDBC
MySQL
Java 基础
Maven
Junit

什么是Mybatis

MyBatis 是一款优秀的持久层框架
MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集的过程
MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的实体类【Plain Old Java Objects,普通的 Java对象】映射成数据库中的记录。
MyBatis 本是apache的一个开源项目ibatis, 2010年这个项目由apache 迁移到了google code，并且改名为MyBatis 。
2013年11月迁移到Github .
Mybatis官方文档 : http://www.mybatis.org/mybatis-3/zh/index.html
GitHub : https://github.com/mybatis/mybatis-3

持久化
持久化是将程序数据在持久状态和瞬时状态间转换的机制。

即把数据（如内存中的对象）保存到可永久保存的存储设备中（如磁盘）。持久化的主要应用是将内存中的对象存储在数据库中，或者存储在磁盘文件中、XML数据文件中等等。
JDBC就是一种持久化机制。文件IO也是一种持久化机制。
在生活中 : 将鲜肉冷藏，吃的时候再解冻的方法也是。将水果做成罐头的方法也是。

为什么需要持久化服务呢？那是由于内存本身的缺陷引起的

内存断电后数据会丢失，但有一些对象是无论如何都不能丢失的，比如银行账号等，遗憾的是，人们还无法保证内存永不掉电。
内存过于昂贵，与硬盘、光盘等外存相比，内存的价格要高2~3个数量级，而且维持成本也高，至少需要一直供电吧。所以即使对象不需要永

持久层
什么是持久层？

完成持久化工作的代码块 . ----> dao层【DAO (Data Access Object) 数据访问对象】
大多数情况下特别是企业级应用，数据持久化往往也就意味着将内存中的数据保存到磁盘上加以固化，而持久化的实现过程则大多通过各种关系数据库来完成。
不过这里有一个字需要特别强调，也就是所谓的“层”。对于应用系统而言，数据持久功能大多是必不可少的组成部分。也就是说，我们的系统中，已经天然的具备了“持久层”概念？也许是，但也许实际情况并非如此。之所以要独立出一个“持久层”的概念,而不是“持久模块”，“持久单元”，也就意味着，我们的系统架构中，应该有一个相对独立的逻辑层面，专注于数据持久化逻辑的实现.
与系统其他部分相对而言，这个层面应该具有一个较为清晰和严格的逻辑边界。【说白了就是用来操作数据库存在的！】

为什么需要持久层

Mybatis就是帮助程序猿将数据存入数据库中 , 和从数据库中取数据 .
传统的jdbc操作 , 有很多重复代码块 .比如 : 数据取出时的封装 , 数据库的建立连接等等… , 通过框架可以减少重复代码,提高开发效率 .
MyBatis 是一个半自动化的ORM框架 (Object Relationship Mapping) -->对象关系映射
所有的事情，不用Mybatis依旧可以做到，只是用了它，所有实现会更加简单！技术没有高低之分，只有使用这个技术的人有高低之别

MyBatis的优点

简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件就可以了，易于学习，易于使用，通过文档和源代码，可以比较完全的掌握它的设计思路和实现。
灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。sql写在xml里，便于统一管理和优化。通过sql语句可以满足操作数据库的所有需求。
解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。
提供xml标签，支持编写动态sql。
…
最重要的一点，使用的人多！公司需要！

（二）Mybatis第一个程序

1. 搭建试验环境

创建数据库和表等

create database `mybatis`;

use mybatis;



create table `user`(
	`id` int(20) not null ,
 `name` varchar(255) default NULL,
	`pwd` varchar(255) default NULL,
	primary key(id)
) engine=INNODB default charset=utf8;
//这个是主键：primary key(id)设置
//engine=INNODB default charset=utf8这个是设置引擎和编码的格式



insert into `user`(`id`,`name`,`pwd`) VALUES
(1,'狂神','1234'),
(2,'hello','1234'),
(3,'world','1234')

创建一个maven项目（普通的maven项目，不是以模板的形式创建）

1）创建maven项目：当做父工程
2）删除src
3）导入依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>helloMybatis</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.26</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

创建一个新模块：Mybatis-01
1）编写核心配置文件：配置mybatis-config.xml文件

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

2）创建mybatis核心配置文件
这里大概的介绍一下：以前我们是需要stament来进行读取SQL语句，
而Mybatis需要用SQLSession来进行读取：下面获取SqlSession对象（它是包含有读取SQL语句的命令）
		String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

//当然这类也就是死的，不会变化
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 SqlSessionFactory sqlSessionFactory;

    static {
        try {
            //使用Mybatis第一步，获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //获取SqlSession连接
    public static SqlSession getSession(){
        return sqlSessionFactory.openSession();
    }

}

2.开始编写代码了

有了上面的配置之后，接下来我们就开始编写代码的了：一般有如下

实体类
操作数据库的类（DAO接口）
DAO接口的实现
1）编写实体类

package cn.mldn.mybatis.bean;

public class user {
    private int id;
    private String name;
    private String pwd;

    @Override
    public String toString() {
        return "user{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", 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;
    }
}

2）编写DAO和实现
记住编写DAO的实现的Mapper.xml的namespace属性的重要性哦，千万不能出错

文件UserMapper.java
package cn.mldn.mybatis.mapper;

import cn.mldn.mybatis.bean.user;

import java.util.List;

public interface UserMapper {
    List<user> selectUser();
}


文件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="cn.mldn.mybatis.mapper.UserMapper">
    <select id="selectUser" resultType="cn.mldn.mybatis.bean.user">
        select * from user
    </select>
</mapper>

这里我们来分析一下：我们为什么创建那个核心配置文件呢？创建它来有什么用呢？
a. 其实把它创建来就是读取userMapper和userMapper.xml文件的，
b. 这两个通过一个namespace相互连接起来

3) 可以测试了吧

package cn.mldn.mybatis.mapper;

import cn.mldn.mybatis.bean.user;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import cn.mldn.mybatis.utils.mybatisUtils;

import java.util.List;

public class UserMapperTest {

    @Test
    public void test() {
        //第一步活的SqlSession
        SqlSession session = mybatisUtils.getSession();
        //执行sql
        UserMapper mapper = session.getMapper(UserMapper.class);

        //得到了这mapper就可以开始一系列的方法了
        List<user> users = mapper.getUserList();
        for (user user : users) {
            System.out.println(user);
        }

        //关闭流
        session.close();
    }
}

如果报错就看我另外专门记载报错的文章吧：具体在Mybatis入门那里得问题

到这里第一节内容就结束了，记得Mybatis的内容一定要自己动起手来

（三）Mybatis的CRUD和配置解析

1. 试验环境搭建

这次就是昨天创建的父项目，新建一个子项目，就可以了

2. 具体的标签内容

（1）. Select标签

标签介绍

select标签是Mybatis中最常用的标签之一
select语句有很多属性可以详细配置每一句SQL语句
- SQL语句的返回值类型：完整的类名或者别名（resultType）
- 传入SQL语句的参数类型：万能的Map，可以多尝试使用（ parameterType）
- 命名空间中唯一的标识符
- 接口中的方法名和映射文件中的SQL语句ID–对应
- id
- parameterType
- resultType

编写代码测试

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


<select id="selectUserById" resultType="com.kuang.pojo.User">
select * from user where id = #{id}
</select>


@Test
public void tsetSelectUserById() {
   SqlSession session = MybatisUtils.getSession();  //获取SqlSession连接
   UserMapper mapper = session.getMapper(UserMapper.class);
   User user = mapper.selectUserById(1);
   System.out.println(user);
   session.close();
}

课堂练习：根据密码和名字查询用户

 	思路一：直接在方法中传递参数
 1. 直接在方法中传递参数1、在接口方法的参数前加 @Param属性
 2、Sql语句编写的时候，直接取@Param中设置的值即可，不需要单独设置参数类型
 3.代码：
 //通过密码和名字查询用户
 User selectUserByNP(@Param("username") String username,@Param("pwd") String pwd);

 /*
 <select id="selectUserByNP" resultType="com.kuang.pojo.User">
 		select * from user where name = #{username} and pwd = #{pwd}
 </select>
 */

 思路2.使用万能的Map
 1.在接口的方法中，参数直接传递Map
 User selectUserByNP2(Map<String,Object> map);
 2. 编写Sql语句的时候，需要传递参数的类型，参数类型为Map
 <select id="selectUserByNP2" parameterType="map" resultType="com.kuang.pojo.User">
 		select * from user where name = #{username} and pwd = #{pwd}
 </select>
 3. 在使用方法的时候，Map的key为SQL中取的值即可，没有顺序要求！
 Map<String, Object> map = new HashMap<String, Object>();
 map.put("username","小明");
 map.put("pwd","123456");
 User user = mapper.selectUserByNP2(map);

总结：总结：如果参数有两个，我们可以考虑直接使用Map实现，如果参数比较少，直接传递参数即可

（2）insert标签，这里一定要记得事务的问题哦

我们一般使用insert标签进行插入操作，它的配置和Select标签差不多
增加一个用户

在UserMapper接口中添加对应的方法
Integer addUser（user user）；

编写Sql语句

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

测试

@Test
public void testUpdateUser() {
   SqlSession session = MybatisUtils.getSession();
   UserMapper mapper = session.getMapper(UserMapper.class);
   User user = mapper.selectUserById(1);
   user.setPwd("asdfgh");
   int i = mapper.updateUser(user);
   System.out.println(i);
   session.commit(); //提交事务,重点!不写的话不会提交到数据库
   session.close();
}

（3）delete标签

根据id删除一个用户

编写接口方法
Integer delete（Integer id；
编写对应的配置文件SQL

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

测试

@Test
public void testDeleteUser() {
   SqlSession session = MybatisUtils.getSession();
   UserMapper mapper = session.getMapper(UserMapper.class);
   int i = mapper.deleteUser(5);
   System.out.println(i);
   session.commit(); //提交事务,重点!不写的话不会提交到数据库
   session.close();
}

这里来小结一下

所有的增删改操作都需要提交事务！
接口所有的普通参数，尽量都写上@Param参数，尤其是多个参数时，必须写上！
有时候根据业务的需求，可以考虑使用map传递参数！
为了规范操作，在SQL的配置文件中，我们尽量将Parameter参数和resultType都写上！

（4）update修改用户的信息

编写接口方法
//修改一个用户
int updateUser(User user);
编写对应的配置文件SQL

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

测试

@Test
public void testUpdateUser() {
   SqlSession session = MybatisUtils.getSession();
   UserMapper mapper = session.getMapper(UserMapper.class);
   User user = mapper.selectUserById(1);
   user.setPwd("asdfgh");
   int i = mapper.updateUser(user);
   System.out.println(i);
   session.commit(); //提交事务,重点!不写的话不会提交到数据库
   session.close();
}

（5）like的配置

第一种：在在java代码中天街SQL通配符

string weldcardname = "%smi%"
List<name> names = mapper.selectLike(wildcardname)
<select id="selectLike">
	select * from foo where bar like#{value}
</select>

第二种：在Sql语句拼接通配符，会引起SQL注入
这种有助于：在业务的时候防止注入

string wildcardname="smi"
List<name> names = mapper.selectlike(wildcardname)
<select id="selectlike">
	select * from foo where bar like "%"#{value}"%"
</select>

（6）万能的map用法

在接口方法中，参数直接传递map

public interface userMapper {

    user selectUser(Map<String, Object> map);

    user selectUser1(String username);
}

然后再到我们的mapper文件中进行编写

<mapper namespace="cn.mldn.mybatis2.mapper.userMapper">

    <select id="selectUser" parameterType="map" resultType="cn.mldn.mybatis2.bean.user">
        select * from user where name = {#username} and pwd = {#pwd}
    </select>

    <select id="selectUser1" parameterType="String" resultType="cn.mldn.mybatis2.bean.user">
        select * from user where name = {