Mybatis1

目录

• 1 什么是框架
• 2 三层架构
• 3 持久层技术解决方案
• 4 mybatis的概述
• 5 mybatis的入门
  • 环境搭建
    • 1 创建maven工程并导入坐标
    • 2 创建实体类和dao的接口
    • 3 创建Mybatis的主配置文件
    • 4 创建映射配置文件
    • 注意事项
  • 入门案例
• 6、自定义Mybatis的分析:
• 7 环境搭建
• 8 Mybatis的CRUD
  • 1 保存用户（增加）
    • 配置保存（插入）操作后，获取插入数据的id
  • 2 修改
  • 3 删除
  • 4 根据id查询一个
  • 5 模糊查询
  • 6 查询用户的总记录数
• 9 参数的深入
  • 9.1 parameterType(输入类型)
    • 1 传递简单类型
    • 2 传递pojo对象
    • 3 传递pojo包装对象
  • 9.2 resultType(输出类型)
• 10 Mybatis实现DAO层的开发
• 11 properties标签的使用及细节
  • • resource属性： 常用
    • 将jdbcConfig.properties放入resources下
    • url属性:
    • 将上面的resource替换为
• 12 typeAliases标签和package标签
  • • 这样在IUserDao.xml就可以由原来的
    • 变为
    • 当然也可以批量别名：
    • package 还可以在mappers中这么用

https://mybatis.org/mybatis-3/zh/getting-started.html

1 什么是框架

软件开发中的一套解决方案，不同的框架解决的是不同的问题
使用框架的好处：
框架封装了很多的细节，使开发者可以使用极简的方式实现功能，大大提高开发效率

2 三层架构

表现层:
是用于展示数据的
业务层:
是处理业务需求
持久层:
是和数据库交互的

3 持久层技术解决方案

JDBC技术:
Connection
PreparedStatement
ResultSet
Spring 的 JdbcTemplate:
Spring中对jdbc的简单封装
Apache 的 DBUtils:
它和Spring的JdbcTemplate很像，也是对Jdbc的简单封装
以上这些都不是框架
JDBC是规范
Spring的 JdbcTemplate 和 Apache 的 DBUtils都只是工具类

4 mybatis的概述

mybatis是一个持久层框架，用java编写的。
它封装了jdbc操作的很多细节，使开发者只需要关注sql语句本身，而无需关注注册驱动，创建连接等繁杂过程
它使用了ORM思想实现了结果集的封装。
ORM:
Object Relational Mappging对象关系映射
简单的说:
就是把数据库表和实体类及实体类的属性对应起来
让我们可以操作实体类就实现操作数据库表。

5 mybatis的入门

环境搭建

1 创建maven工程并导入坐标

create project -> maven -> 不勾create ->

pom.xml

<?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>com.yu</groupId>
    <artifactId>day01_eesy_01mybatis</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
        </dependency>
    </dependencies>
</project>

2 创建实体类和dao的接口

在main.java下创建class : com.yu.domain.User

package com.yu.domain;
import java.io.Serializable;
import java.util.Date;
public class User implements Serializable{
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;

    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 String getSex() {
        return sex;
    }

    public void setSex(String 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 + '\'' +
                '}';
    }
}

在main.java.com.yu.dao下创建接口Interface： IUserDao

package com.yu.dao;

import com.yu.domain.User;

import java.util.List;

/**
 * 用户的持久层接口
 */
public interface IUserDao {
    /**
     * 查询所有操作
     * @return
     */
    List<User> findAll();

}

3 创建Mybatis的主配置文件

在resources下创建文件： SqlMapConfig.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://localhost:3306/eesy_mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <!--指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件-->
    <mappers>
        <mapper resource="com/yu/dao/IUserDao.xml"/>
    </mappers>
</configuration>

4 创建映射配置文件

在resources建立com.yu.dao.IUserDao.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.yu.dao.IUserDao">
    <!--配置查询所有-->
    <select id="findAll" resultType="com.yu.domain.User">
        SELECT * FROM USER
    </select>
</mapper>

注意事项

第一个:
创建IUserDao.xml和IUserDao.java时名称是为了和我们之前的知识保持一致。
在Mybatis中它把持久层的操作接口名称和映射文件也叫做: Mapper
所以: IUserDao 和IUserMapper是一 样的
第二个:
在idea中创建目录的时候，它和包是不一样的
包在创建时: com. itheima. dao它是三级结构
目录在创建时:
om. itheima. dao是一 级目录
第三个:
mybatis的映射配置文件位置必须和dao接口的包结构相同
第四个:
映射配置文件的mapper标签namespace属性的取值必须是dao接口的全限定类名
第五个:
映射配置文件的操作配置(select) ，id属 性的取值必须是dao接口的方法名
当我们遵从了第三，四，五点之后，我们在开发中就无须再写dao的实现类。

入门案例

将 log4j.properties 放到 resources 中
在test.java下创建 com.yu.test.Mybatis.java
第一步:读取配置文件
第二步:创建SqlSessionFactory工厂
第三步:创建SqlSession
第四步:创建Dao接口的代理对象
第五步:执行dao中的方法
第六步:释放资源

public class MybatisTest {
    public static void main(String[] args) throws Exception{
        //1 读取配置文件
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2 创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        //3 使用工厂生产 SqlSession对象
        SqlSession session = factory.openSession();
        //4 使用SqlSession创建Dao接口的代理对象
        IUserDao userDao = session.getMapper(IUserDao.class);
        //5 使用代理对象执行方法
        List<User> users = userDao.findAll();
        for (User user:users){
            System.out.println(user);
        }
        //6 释放资源
        session.close();
        in.close();

    }
}

注意事项:
不要忘记在映射配置中告知mybatis要封装到哪个实体类中
配置的方式:指定实体类的全限定类名

上面是使用xml的方式，下面介绍 注解 方式
mybatis基于注解的入门案例：
把IUserDao.xml移除，在dao接口的方法上使用@Select注解，并指定SQL语句
同时需要在把sqlMapConfig.xml中的mapper重新配置，使用class属性指定dao接口的全限定类名

创建project： day01_eesy_02mybatis_annotation

删除掉main/resources/com 文件夹
IUserDao.java

package com.yu.dao;

import com.yu.domain.User;
import org.apache.ibatis.annotations.Select;

import java.util.List;

/**
 * 用户的持久层接口
 */
public interface IUserDao {
    /**
     * 查询所有操作
     * @return
     */
    @Select("select * from user")
    List<User> findAll();
}

sqlMapConfig.xml

    <!--指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件
        如果是用注解来配置的话，此处应该使用class属性指定被注解的dao全限定类名
    -->
    <mappers>
        <mapper class="com.yu.dao.IUserDao"/>
    </mappers>

明确:
我们在实际开发中，都是越简便越好，所以都是采用不写dao实现类的方式。
不管使用XML还是注解配置。
但是Mybatis它是支持写dao实现类的。

6、自定义Mybatis的分析:

mybatis在使用代理dao的方式实现增删改查时做什么事呢?
只有两件事:
第一: 创建代理对象
第二: 在代理对象中调用selectList

7 环境搭建

create project -> maven -> 不勾create ->

略

8 Mybatis的CRUD

Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@631330c]
...
Rolling back JDBC Connection [com.mysql.jdbc.JDBC4Connection@631330c]
执行失败，关闭自动提交事务，回滚
加

        // 提交事务
        sqlSession.commit();

1 保存用户（增加）

IUserDao.java

   /**
     *保存用户
     */
    void saveUser(User user);

IUserDao.xml

    <!--保存用户-->
    <insert id="saveUser" parameterType="com.yu.domain.User">
        INSERT INTO USER (username,address,sex,birthday)VALUES(#{username},#{address},#{sex},#{birthday});
    </insert>

MybatisTest.java

public class MybatisTest {
    private InputStream in;
    private SqlSession sqlSession;
    private IUserDao userDao;
    @Before//用于在测试方法执行之前执行
    public void init() throws Exception{
        //1 读取配置文件，生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2 获取SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3 获取SqlSession对象
        sqlSession = factory.openSession();
        //4 获取dao的代理对象
        userDao = sqlSession.getMapper(IUserDao.class);
    }
    @After//用于在测试方法执行之后执行
    public void destroy() throws Exception{
        // 提交事务
        sqlSession.commit();
        //6 释放资源
        sqlSession.close();
        in.close();
    }
    /**
     * 测试查询所有
     */
    @Test
    public void testFindAll() {

        //5 执行查询所有方法
        List<User> users = userDao.findAll();
        for (User user:users){
            System.out.println(user);
        }

    }

    @Test
    public void testSave() {
        User user = new User();
        user.setUsername("mybatis saveuser");
        user.setAddress("北京顺义区");
        user.setSex("男");
        user.setBirthday(new Date());

        //5 执行保存方法
        userDao.saveUser(user);

    }
}

配置保存（插入）操作后，获取插入数据的id

keyProperty： 实体类中对应的属性名称
keyColumn： 对应的表的列名
resultType：结果集类型
order： 什么时候执行 AFTER ---插入之后

IUserDao.xml

   <!--保存用户-->
    <insert id="saveUser" parameterType="com.yu.domain.User">
        <!-- 配置插入操作后，获取插入数据的id -->
        <selectKey keyProperty="id" keyColumn="id" resultType="int" order="AFTER">
            SELECT last_insert_id();
        </selectKey>
        INSERT INTO USER (username,address,sex,birthday)VALUES(#{username},#{address},#{sex},#{birthday});
    </insert>

MybatisTest.java

  /**
     * 测试保存
     */
    @Test
    public void testSave() {
        User user = new User();
        user.setUsername("mybatis saveuser");
        user.setAddress("北京顺义区");
        user.setSex("男");
        user.setBirthday(new Date());
        System.out.println("保存操作之前"+user);

        //5 执行保存方法
        userDao.saveUser(user);
        System.out.println("保存操作之前"+user);
    }

2 修改

IUserDao.java

    /**
     * 更新用户
     * @param user
     */
    void updateUser(User user);

IUserDao.xml

    <!--更新用户-->
    <update id="updateUser" parameterType="com.yu.domain.User">
        UPDATE user set username=#{username},address=#{address},sex=#{sex},birthday=#{birthday} where id=#{id}
    </update>

MybatisTest.java

    /**
     * 测试更新操作
     */
    @Test
    public void testUpdate() {
        User user = new User();
        user.setId(51);
        user.setUsername("mybatis UpdateUser");
        user.setAddress("北京顺义区");
        user.setSex("男");
        user.setBirthday(new Date());

        //5 执行保存方法
        userDao.updateUser(user);

    }

3 删除

IUserDao.java

    /**
     * 根据id删除用户
     */
    void deleteUser(Integer userId);

IUserDao.xml

    <!--删除用户-->
    <delete id="deleteUser" parameterType="java.lang.Integer">
        DELETE from USER WHERE id = #{uid}
    </delete>

MybatisTest.java

    /**
     * 测试删除操作
     */
    @Test
    public void testDelete() {
        //5 执行保存方法
        userDao.deleteUser(51);
    }

4 根据id查询一个

IUserDao.java

/**
     * 根据id查询用户信息
     * @param userId
     * @return
     */
    User findById(Integer userId);

IUserDao.xml

    <!--根据id查询用户-->
    <select id="findById" parameterType="INT" resultType="com.yu.domain.User">
        SELECT * FROM user where id = #{uid}
    </select>

MybatisTest.java

    /**
     * 测试查询一个操作
     */
    @Test
    public void testFindOne() {
        //5 执行查询一个方法
        User user = userDao.findById(48);
        System.out.println(user);
    }

5 模糊查询

IUserDao.java

    /**
     * 根据名称模糊查询用户信息
     * @param username
     * @return
     */
    List<User> findByName(String username);

方法一：（建议）
IUserDao.xml

   <!--根据名称模糊查询用户-->
    <select id="findByName" parameterType="string" resultType="com.yu.domain.User">
        SELECT * FROM USER WHERE username LIKE #{name}
    </select>

MybatisTest.java

    /**
     * 测试模糊查询操作
     */
    @Test
    public void testFindByName() {
        //5 执行方法
        List<User> users = userDao.findByName("%王%");
        for(User user : users){
            System.out.println(user);
        }
    }

方法二：
IUserDao.xml

   <!--根据名称模糊查询用户-->
    <!--参数必须是value -->
    <select id="findByName" parameterType="string" resultType="com.yu.domain.User">
        SELECT * FROM USER WHERE username LIKE '%${value}'
    </select>

MybatisTest.java

    /**
     * 测试模糊查询操作
     */
    @Test
    public void testFindByName() {
        //5 执行方法
        List<User> users = userDao.findByName("王");
        for(User user : users){
            System.out.println(user);
        }
    }

6 查询用户的总记录数

IUserDao.java

    /**
     * 查询总用户数
     * @return
     */
    int findTotal();

IUserDao.xml

    <!--查询用户的总记录数-->
    <select id="findTotal" resultType="int">
        SELECT COUNT(id) FROM USER
    </select>

MybatisTest.java

    /**
     * 测试查询总记录条数
     */
    @Test
    public void testFindTotal() {
        //5 执行方法
        int total = userDao.findTotal();
        System.out.println(total);
    }

9 参数的深入

9.1 parameterType(输入类型)

该属性的取值可以是基本类型，引用类型（例如:String 类型），还可以是实体类类型（POJO 类）。同时也可以使用实体类的包装类

1 传递简单类型

基本类型和 引用类型String 我们可以直接写类型名称 ， 也可 以使 用 包 名 . 类 名 的 方 式 ， 例 如 ：
java.lang.String。

实体类类型，目前我们只能使用全限定类名

2 传递pojo对象

Mybatis使用 ognl 表达式解析对象字段的值，#{}或者${}括号中的值为pojo属性名称。

OGNL表达式：
0bject Graphic Navigation Language
对象 图 导航 语言
它是通过对象的取值方法来获取数据。在写法上把get给省略了。
比如:我们获取用户的名称
类中的写法: user. getUsername () ;
OGNL表达式写法: user. username
mybatis中为什么能直接写username,而不用user. 呢:
因为在parameterType中已经提供了属性所属的类，所以此时不需要写对象名

3 传递pojo包装对象

例：根据queryVo中的条件查询用户
domain.QueryVo.java

package com.yu.domain;

public class QueryVo {
    private User user;

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }
}

IUserDao.java

/**
     * 根据queryVo中的条件查询用户
     * @param vo
     * @return
     */
    List<User> findUserByVo(QueryVo vo);

IUserDao.xml

<!--根据queryVo的条件查询用户-->
    <select id="findUserByVo" parameterType="com.yu.domain.QueryVo" resultType="com.yu.domain.User">
        SELECT * FROM USER WHERE username LIKE #{user.username}
    </select>

MybatisTest.java

   /**
     * 测试使用QueryVo作为查询条件
     */
    @Test
    public void testFindByVo() {

        QueryVo vo = new QueryVo();
        User user =new User();
        user.setUsername("%王%");
        vo.setUser(user);
        //5 执行方法
        List<User> users = userDao.findUserByVo(vo);
        for(User user1 : users){
            System.out.println(user1);
        }
    }

9.2 resultType(输出类型)

resultMap 标签可以建立查询的列名和实体类的属性名称不一致时建立对应关系。从而实现封装。
在 select 标签中使用 resultMap 属性指定引用即可。同时 resultMap 可以实现将查询结果映射为复杂类型的 pojo，比如在查询结果映射对象中包括 pojo 和 list 实现一对一查询和一对多查询。

1 输出简单类型

2 输出pojo对象

3 输出pojo列表

要注意domain中的实体类User中的属性要和数据库中保持一致，要不然查询会报错
解决方法：
1 查询时起别名(执行效率快)

select id as userId,username as userName from user;

2 配置查询结果的列名和实体类的属性名的对应关系(开发效率快)
即建立 User 实体和数据库表的对应关系
type 属性：指定实体类的全限定类名
id 属性：给定一个唯一标识，是给查询 select 标签引用用的。

  id 标签：用于指定主键字段
  result 标签：用于指定非主键字段
  column 属性：用于指定数据库列名
  property 属性：用于指定实体类属性名称

在IUserDao.xml中添加

    <!--配置查询结果的列名和实体类的属性名的对应关系-->
    <resultMap id="userMap" type="com.yu.domain.User">
        <!--主键字段的对应-->
        <id property="userId" column="id"></id>
        <!--非主键字段的对应-->
        <result property="userNme" column="username"></result>
        <result property="userAddress" column="address"></result>
    </resultMap>

    <select id="findAll" resultMap="userMap">
        SELECT * FROM USER
    </select>

10 Mybatis实现DAO层的开发

自定义IUserDao接口的实现类(一般不用)

在dao下创建impl.UserDaoImpl.java

分析编写dao实现类Mybatis的执行过程

分析代理dao的执行过程

11 properties标签的使用及细节

可以在标签内部配置连接数据库的信息，也可以通过属性引用外部配置文件信息

resource属性： 常用

  用于指定配置文件的位置，是按照类路径的写法来写，并且必须存在于类路径下

将jdbcConfig.properties放入resources下

jdbcConfig.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/eesy
jdbc.username=root
jdbc.password=root

SqlMapConfig.xml

<configuration>
    <!--配置properties
        可以在标签内部配置连接数据库的信息，也可以通过属性引用外部配置文件信息
        resource属性： 常用
            用于指定配置文件的位置，是按照类路径的写法来写，并且必须存在于类路径下
        url属性:
            URL： Uniform Resource Locator 统一资源定位符
            http://localhost:8080/mystroe/CategoryServlet URL
            协议       主机  端口    URI
            URI：Uniform Resource Identifier 统一资源标识符
            /mystroe/CategoryServlet
            它是可以在 web 应用中唯一定位一个资源的路径
    -->
    <properties resource="jdbcConfig.properties">
        <!--<property name="driver" value="com.mysql.jdbc.Driver"></property>-->
        <!--<property name="url" value="jdbc:mysql://localhost:3306/eesy"></property>-->
        <!--<property name="username" value="root"></property>-->
        <!--<property name="password" value="root"></property>-->
    </properties>
    <!--配置环境-->
    <environments default="mysql">
        <!--配置mysql的环境-->
        <environment id="mysql">
            <!--配置事务-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"></property>
                <property name="url" value="${jdbc.url}"></property>
                <property name="username" value="${jdbc.username}"></property>
                <property name="password" value="${jdbc.password}"></property>
            </dataSource>
        </environment>
    </environments>
    <!--配置映射文件的位置-->
    <mappers>
        <mapper resource="com/yu/dao/IUserDao.xml"></mapper>
    </mappers>
</configuration>

url属性:

  URL： Uniform Resource Locator 统一资源定位符
  http://localhost:8080/mystroe/CategoryServlet URL
  协议       主机  端口    URI
  URI：Uniform Resource Identifier 统一资源标识符
  /mystroe/CategoryServlet
  它是可以在 web 应用中唯一定位一个资源的路径

将上面的resource替换为

<properties url="file:///E:/JAVA/ideaProjects/ssm/day02_eesy_01mybatisCRUD/src/main/resources/jdbcConfig.properties">

12 typeAliases标签和package标签

SqlMapConfig.xml

    <typeAliases>
        <!--typeAliases用于配置别名，type属性指定的是实体类全限定类名。alias属性指定别名，当指定了别名就不再区分大小写-->
        <!-- 单个别名定义 --> 
        <typeAlias alias="user" type="com.yu.domain.User"/>
    </typeAliases>

这样在IUserDao.xml就可以由原来的

    <!--保存用户-->
    <insert id="saveUser" parameterType="com.yu.domain.User">

变为

    <!--保存用户-->
    <insert id="saveUser" parameterType="user">

当然也可以批量别名：

SqlMapConfig.xml

    <typeAliases>
        <!--typeAliases用于配置别名，type属性指定的是实体类全限定类名。alias属性指定别名，当指定了别名就不再区分大小写-->
        <!-- 批量别名定义，扫描整个包下的类，该包下的实体类都会注册别名，别名为类名，不区分大小写 -->
        <package name="com.yu.domain"/>
    </typeAliases>

IUserDao.xml

    <!--保存用户-->
    <insert id="saveUser" parameterType="user">

package 还可以在mappers中这么用

SqlMapConfig.xml

    <mappers>
        <!--<mapper resource="com/yu/dao/IUserDao.xml"></mapper>-->
        <!--package标签是用于指定dao接口所在的包，当指定了之后就不需要再写mapper以及resource或者class了-->
        <package name="com.yu.dao"></package>
    </mappers>