1.MyBatis入门

最新推荐文章于 2022-05-25 16:45:18 发布

发条鹏

最新推荐文章于 2022-05-25 16:45:18 发布

阅读量128

点赞数

分类专栏： SSM 文章标签： ssm

原文链接：https://www.bilibili.com/video/BV1mE411X7yp?from=search&seid=1902362468821684956&spm_id_from=333.337.0.0

版权

SSM 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

mybatis框架

文章目录

mybatis框架

索引

第一天：mybatis入门

mybatis的概述
mybatis的环境搭建
mybatis入门案例
自定义mybatis框架（主要的目的是为了让大家了解mybatis中执行细节）

第二天：mybatis基本使用

mybatis的单表crud操作
mybatis的参数和返回值
mybatis的dao编写
mybatis配置的细节
几个标签的使用

第三天：mybatis的深入和多表

mybatis的连接池
mybatis的事务控制及设计的方法
mybatis的多表查询
一对多（多对一）
多对多

第四天：mybatis的缓存和注解开发

mybatis中的加载时机（查询的时机）
mybatis中的一级缓存和二级缓存
mybatis的注解开发
单表CRUD
多表查询

1. 什么是框架？

它是我们软件开发中的一套解决方案，不同的框架解决的是不同的问题。

使用框架的好处：框架封装了很多的细节，使开发者可以使用极简的方式实现功能。大大提高开发效率。

2. 三层架构

表现层：是用于展示数据的

业务层：是处理业务需求

持久层：是和数据库交互的

3. 持久层技术解决方案

3.1 JDBC技术：

Connection
PreparedStatement
ResultSet

3.2 Spring的JdbcTemplate：

Spring中对jdbc的简单封装

3.3 Apache的DBUtils：

它和Spring的JdbcTemplate很像，也是对Jdbc的简单封装

以上这些都不是框架
JDBC是规范
Spring的JdbcTemplate和Apache的DBUtils都只是工具类

4. mybatis的概述

mybatis是一个持久层框架，用java编写的。
它封装了jdbc操作的很多细节，使开发者只需要关注sql语句本身，而无需关注注册驱动，创建连接等繁杂过程
它使用了ORM思想实现了结果集的封装。

ORM：
	Object Relational Mappging 对象关系映射
	简单的说：
		就是把数据库表和实体类及实体类的属性对应起来
		让我们可以操作实体类就实现操作数据库表。

		user			User
		id				userId
		user_name		userName
		
今天我们需要做到
	实体类中的属性和数据库表的字段名称保持一致。
		user			User
		id				id
		user_name		user_name

5. mybatis的入门

5.1 mybatis的环境搭建

第一步：创建maven工程并导入依赖（坐标）

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/log4j/log4j -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>

第二步：创建实体类和dao的接口


/**
 * 创建实体类
 */
public class User implements Serializable {
    
    //确保数据库表的列名和实体类字段名一致
    private Integer id;
    private String username;
    private Date birthday;
    private char sex;
    private String address;

    //生成set get 方法、生成toString
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", birthday=" + birthday +
                ", sex=" + sex +
                ", address='" + address + '\'' +
                '}';
    }
}

/**
 * 在Dao中 创建持久层接口
 */
public interface IUserMapper {
    
    /**
     * 1. 查询所有用户  返回多条数据，用List集合
     */
    List<User> findAll();
}

第三步：创建Mybatis的主配置文件

创建 Config 表头文件 SqlMapConifg.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">
<!--mybatis 的主配置文件-->
<configuration>
    <!--配置环境-->
    <environments default="mysql">
        <!--配置mysql的环境-->
        <environment id="mysql">
            <!--配置事务的类型-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置数据源（连接池）-->
            <dataSource type="POOLED">
                <!--配置连接数据库的4个基本信息-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/ssm_hema"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <!--指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件-->
    <mappers>
        #此处注意分隔符为斜杠
        <mapper resource="com/itheima/dao/IUserDao.xmml"/>
    </mappers>
</configuration>

第四步：创建映射配置文件
mapper表头文件：IUserMapper.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属性进行关联-->
<mapper namespace="cn.kgc.dao.IUserMapper">
    
    <!--id为mapper类中对应方法名，resultType为定义的接收类型，一般为对应实体类-->
    <select id="findAll" resultType="cn.kgc.pojo.User">
        SELECT * FROM user
    </select>
    
</mapper>

第五步：创建测试类

    public static void main(String[] args) throws  Exception {
        //1.读取配置文件
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        SqlSessionFactory build = sqlSessionFactoryBuilder.build(in);
        //3.根据工厂创建出SqlSession对象
        SqlSession sqlSession = build.openSession();
        //4.根据对象创建Dao层接口的代理对象
        IUserMapper mapper = sqlSession.getMapper(IUserMapper.class);
        //5.代理对象执行方法
        List<User> all = mapper.findAll();
        for (User user : all) {
            System.out.println(user);
        }
        //6.释放资源
        sqlSession.close();
        in.close();
    }
}

5.2 环境搭建的注意事项：

创建IUserDao.xml 和 IUserDao.java时名称是为了和我们之前的知识保持一致。在Mybatis中它把持久层的操作接口名称和映射文件也叫做：Mapper.所以：IUserDao 和 IUserMapper是一样的
在idea中创建目录的时候，它和包是不一样的
包在创建时：com.itheima.dao它是三级结构
目录在创建时：com.itheima.dao是一级目录
mybatis的映射配置文件位置必须和dao接口的包结构相同
映射配置文件的mapper标签namespace属性的取值必须是dao接口的全限定类名
映射配置文件的操作配置（select等），id属性的取值必须是dao接口的方法名
```
 ==当我们遵从了第三，四，五点之后，我们在开发中就无须再写dao的实现类。==
```
mybatis的入门案例
第一步：读取配置文件
第二步：创建SqlSessionFactory工厂
第三步：创建SqlSession
第四步：创建Dao接口的代理对象
第五步：执行dao中的方法
第六步：释放资源
```
 注意事项：
 	不要忘记在映射配置中告知mybatis要封装到哪个实体类中
 	配置的方式：指定实体类的全限定类名
```
明确：
我们在实际开发中，都是越简便越好，所以都是采用不写dao实现类的方式。
不管使用XML还是注解配置。
但是Mybatis它是支持写dao实现类的。

5.3 mybatis基于注解的入门案例：

把Dao层映射配置文件删除 “IUserMapper.xml”，在dao接口的方法上使用@Select注解，并且指定SQL语句

public interface IUserMapper {

    @Select ("SELECT * FROM user")
    List<User> findAll();
    
}

同时需要在SqlMapConfig.xml中的mapper配置时，使用class属性指定dao接口的全限定类名。

    <mappers>
        // 1. 指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件
      <mapper resource="cn/itheima/dao/IUserMapper.xml"/>
        // 2. 用注解来配置时，此处使用class属性指定被注释的dao全限定类名
        <mapper class="cn.itheima.dao.IUserMapper"/>
    </mappers>

注意：使用映射配置文件时用斜杠分包；使用注解配置时用点分包

5.4 mybatis基于Dao实现类：

有pojo实体类

有dao层接口以及dao层实现类impl sqlSession执行查询所用方法时指向映射配置文件以及执行的方法名

public class IUserMapperImpl implements IUserMapper {

    private SqlSessionFactory factory;

    //覆盖默认构造函数，避免无法传值
    public IUserMapperImpl(SqlSessionFactory factory) {
        this.factory = factory;
    }

    public List<User> findAll() {
        //1.使用工厂创建SqlSession对象
        SqlSession sqlSession = factory.openSession();
        //2.使用sqlSession执行查询所用方法  指向映射配置文件以及执行的方法名
        List<User> users = sqlSession.selectList("com.itheima.dao.IUserMapper.findAll");
        sqlSession.close();
        //3. 返回查询结果
        return users;
    }
}

有dao层的映射文件、在MyBatis配置文件中写出Dao层映射配置文件的位置

在测试类中不需要再创建Dao层接口的代理对象，直接new impl实现类执行方法

public class MyBaitsTest {
    public static void main(String[] args) throws Exception {
        //读取配置文件
        InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        //创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        SqlSessionFactory build = sqlSessionFactoryBuilder.build(inputStream);
        //使用工厂创建Dao层接口对象
        IUserMapper iUserMapper = new IUserMapperImpl(build);
        //对象执行方法
        List<User> all = iUserMapper.findAll();
        for (User user : all) {
            System.out.println(user);
        }
        // 关闭
        inputStream.close();
    }
}

5.5 MyBatis启动类分析

在这里插入图片描述

    public static void main(String[] args) throws  Exception {
        //1.读取配置文件  
        	绝对路径：项目实际运行时可能不存在该路径； 
            相对路径：src/java/main/xxx.xml  如果时web工程的话，项目部署会导致src路径消失  
        	1. 使用类加载器，只能读取类路径的配置文件
        	2. 使用ServletContex对象的getRealPath( ) 可以得到当前项目部署的绝对路径，就是项目运行的实际路径
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        	创建工厂使用了构建者模式，只需要把钱“配置文件”，提供给构建者 包工头“sqlSessionFactoryBuilder”,就可以创建工厂
            优势：把对象的细节隐藏，使用者直接调用方法即可拿到对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        SqlSessionFactory build = sqlSessionFactoryBuilder.build(in);
        //3.根据工厂创建出SqlSession对象
        	生产SqlSession使用了工厂模式  每次生产SqlSession时不用new搭配新的对象，不需要每次改源码、重新编译、部署、重启服务器
            优势：解耦（降低类之间的依赖关系）
        SqlSession sqlSession = build.openSession();
        //4.根据对象创建Dao层接口的代理对象.
        	创建Dao接口实现类：代理模式
        	优势：不修改源码的基础上，有已有方法增强
        IUserMapper mapper = sqlSession.getMapper(IUserMapper.class);
        //5.代理对象执行方法
        List<User> all = mapper.findAll();
        for (User user : all) {
            System.out.println(user);
        }
        //6.释放资源
        sqlSession.close();
        in.close();
    }

6. 自定义Mybatis的分析：

在这里插入图片描述

创建Dao接口实现类：代理模式
    	优势：不修改源码的基础上，有已有方法增强
    IUserMapper mapper = sqlSession.getMapper(IUserMapper.class);
    //5.代理对象执行方法
    List<User> all = mapper.findAll();
    for (User user : all) {
        System.out.println(user);
    }
    //6.释放资源
    sqlSession.close();
    in.close();
}