MyBatis—持久层框架（环境搭建→CRUD→Dao实现类）

最新推荐文章于 2023-02-08 15:50:27 发布

原创最新推荐文章于 2023-02-08 15:50:27 发布 · 936 阅读

CC 4.0 BY-SA版权

本文围绕MyBatis展开，先分析了JDBC缺点，接着介绍MyBatis环境搭建，包括用XML和注解两种方式。详细说明了搭建步骤及注意事项，还阐述了增删改查操作的实现，最后提及可在MyBatis中编写dao实现类，后续将学习连接池、事务等内容。

一、概念扩充

MyBatis—持久层框架，我们在学习反射的时候，详细的介绍过框架，具体详情请看Java反射—框架设计的灵魂。

MyBatis的前身就是iBatis,iBatis本是apache的一个开源项目,
2010年这个项目由apahce sofeware foundation 迁移到了google code，并且改名MyBatis。
2013年11月迁移到Github

Mybatis是面向sql的持久层框架，封装了JDBC 访问数据库的过程，我们开发只需要关注sql语句本身的拼装，
其他过程都交给mybatis去完成

二、概念深入

*.net项曾学习过三层架构， 分别是UI层（表现层）、BLL层（业务逻辑层）、DAL层（数据访问层），
* myBatista就是一款DAL层框架，在java当中DAL层叫做持久层，可见MyBatis框架是与数据库打交道的。

三、JDBC缺点分析

JDBC(Java Data Base Connection,java数据库连接)：
*一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成.

*JDBC与数据库建立连接需注册驱动、创建连接、执行各种Statement、执行SQL语句，处理结果、释放资源等一系列等复杂的过程。

*频繁创建和打开、关闭数据连接，相当消耗资源
*sql语句、参数存在硬编码，不利于维护
*结果集的获取与遍历复杂，存在硬编码，不利于维护，希望能够查询后返回一个java对象

*MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。
*MyBatis使用简单的XML或注解方式将要执行的各种statement配置起来，
并通过java对象和statement中的sql的动态参数进行映射生成最终执行的sql语句，
最后由mybatis框架执行SQL语句，并将结果映射为java对象并返回。

*MyBatis框架采用了ORM思想解决了实体和数据库映射的问题，对JDBC进行了封装，
屏蔽了JDBC API 底层的访问细节，使得我们不在与JDBC API打交道，就可完成对数据库的持久化操作

Mybatis整体架构：

四、疑问？☟

*JDBC工具类不是也对这些繁杂的过程进行了封装了么？

*还有JdbcTemplate不是更加简化么？

*JdbcTemplate 和 mybatis分别在什么情况下使用？

*jdbc template  和 spring+mybatis一样吗？

*jdbc template 和 mybatis相比有什么优缺点?


在这我只能告诉你，JDBC工具类只是封装了注册驱动、获取连接对象、以及释放资源等步骤。在具体执行过程中依旧需要获取执行sql的对象，获取数据、遍历结合等复杂的步骤


JDBCTemplate和Mybatis的区别：
*两者不同：
*Mybatis的sql语句放在了mapper.xml文件里面.相当于配置在了环境当中,随时都可以使用. 
*JDBCTemplate则是写在了实现类里面,使用的时候还要进行重新调用配置之类的. 以后的工作中可能对多个表进行操作,配置在环境中使用起来非常方便.


JdbcTemplate针对数据查询提供了多个重载的模板方法,你可以根据需要选用不同的模板方法.如果你的查询很简单，仅仅是传入相应SQL或者相关参数，然后取得一个单一的结果，那么你可以选择如下一组便利的模板方法

优点：运行期：高效、内嵌Spring框架中、支持基于AOP的声明式事务
缺点：必须于Spring框架结合在一起使用、不支持数据库跨平台、默认没有缓存


总体来说 MyBatis 主要完成两件事情
1.根据JDBC 规范建立与数据库的连接
2.通过Annotaion/XML+JAVA反射技术,实现 Java 对象与关系数据库之间相互转化
MyBatis优缺点如下:

优点: 高效、支持动态、复杂的SQL构建, 支持与Spring整合和AOP事务、结果集做了轻量级Mapper封装、支持缓存
缺点：不支持数据库跨平台, 还是需要自己写SQL语句

如果对JDBC、JDBC连接池、JDBCTemplate不是很了解，请查看一下博客

JDBC—（Java DataBase Connectivity）

JDBC—数据库连接池

Spring JDBC——JDBCTemplate

JDBC、JDBCTemplate、MyBatis、Hiberante 比较与分析

四、MyBatis环境搭建（分别使用XML和注解的方式）

先看一下构件好的Mybatis框架目录结构

① 打开MyBatis官网,→入门→创建一个空的maven项目

由于我的本地仓库不在C盘，所以需要进行路径的修改：File→Settings→搜索Maven

pom.xml 配置文件中，引入mysql依赖包、日志依赖包、测试依赖包、以及mybatis依赖包

 <!--    打包方式-->
    <packaging>jar</packaging>

    <dependencies>
        <!--    mybatis坐标-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <dependency>
<!--            mysql坐标-->
            <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>

②创建实体类（User）

package com.zpc.mybatis;

import java.util.Date;

public class User {
    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 + '\'' +
                '}';
    }
}

QueryVo实体类

package com.itdami.domain;

public class QueryVo {
    public User getUser() {
        return user;
    }

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

    private User user;
}

③创建MyBatis的全局配置文件（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">
<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/test"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件 -->
    <mappers>
        <mapper resource="com/itdami/dao/IUserDao.xml"/>
    </mappers>
</configuration>

④配置入口文件（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.itdami.dao.IUserDao">
    <!--配置查询所有 -->
    <!-- statement，内容：sql语句。id：唯一标识，随便写，在同一个命名空间下保持唯一
      resultType：sql语句查询结果集的封装类型,tb_user即为数据库中的表
    -->
    <select id="findAll" resultType="com.itdami.domain.User">
        select * from user
    </select>
</mapper>

⑤ 添加log4j.properties配置文件

# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE

# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE

# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=d:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

⑥ MybatisTest.java ：执行MybatisTest.java类

package com.itdami.test;
import com.itdami.dao.IUserDao;
import com.itdami.domain.User;
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.InputStream;
import java.util.List;

public class MybatisTest {
    public static void main(String[] args) throws Exception {
        //指定并读取全局配置文件
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        // 构建sqlSessionFactory工厂，使用了构建者模式，builder就是构建者，隐藏创建对象细节
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
        //3使用工厂生产SqlSession对象，生产SqlSession对象，用到了工厂模式，可以降低类之间的依赖关系（解耦）
        SqlSession session = sqlSessionFactory.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();
    }

}

执行结果：这是执行结果报的非法反射的错，查询了半天说是因为JDK版本过高，应该使用JDK9以及以前的版本，但是不影响查询出来的数据：

WARNING: An illegal reflective access operation has occurred
WARNING: Illegal reflective access by org.apache.ibatis.reflection.Reflector (file:/E:/maven/maven_repository/org/mybatis/mybatis/3.4.5/mybatis-3.4.5.jar) to method java.lang.Class.checkPackageAccess(java.lang.SecurityManager,java.lang.ClassLoader,boolean)
WARNING: Please consider reporting this to the maintainers of org.apache.ibatis.reflection.Reflector
WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations
WARNING: All illegal access operations will be denied in a future release

环境搭建注意事项：

第一个：创建IUserDao.xml 和 IUserDao.java时名称是为了和我们之前的知识保持一致。
			在Mybatis中它把持久层的操作接口名称和映射文件也叫做：Mapper
			所以：IUserDao 和 IUserMapper是一样的

第二个：在idea中创建目录的时候，它和包是不一样的
			包在创建时：com.itheima.dao它是三级结构
			目录在创建时：com.itheima.dao是一级目录

第三个：mybatis的映射配置文件位置必须和dao接口的包结构相同

第四个：映射配置文件的mapper标签namespace属性的取值必须是dao接口的全限定类名
		
第五个：映射配置文件的操作配置（select），id属性的取值必须是dao接口的方法名

简化上述步骤，使用注解的方式编写dao实现类。

①：删除IUserDao.xml

②：修改dao接口的方法，使用@Select注解，指定SQL语句

package com.itdami.dao;

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

import java.util.List;

public interface IUserDao {
    /**
     * 查询所有操作
     */
    @Select("select * from user")
    List<User> findAll();
}

③：修改SqlMapConfig.xml中mapper配置,使用class属性执行被注解的dao全限定类名

<!--使用配置文件进行配置 指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件
 <mappers>
    <mapper resource="com/itdami/dao/IUserDao.xml"/>
</mappers>
 -->
<!--   使用注解进行配置，使用class属性执行被注解的dao全限定类名
  <mappers>
    <mapper class="com.itdami.dao.IUserDao"/>
</mappers>
-->
<mappers>
    <mapper class="com.itdami.dao.IUserDao"/>
</mappers>

执行MybatisTest.java类，结果相同：

五、增删改查

①在IUserDao 添加增删改查的方法

package com.itdami.dao;

import com.itdami.domain.User;

import java.util.List;

public interface IUserDao {
    /**
     * 查询所有操作
     */
    List<User> findAll();

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

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

    /**
     * 根据用户条数
     */
     int findCount();

    /**
     * 保存方法
     */
    void saveUser(User user);

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

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

}

②在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.itdami.dao.IUserDao">
    <!--配置查询所有 -->
    <!-- statement，内容：sql语句。id：唯一标识，随便写，在同一个命名空间下保持唯一
      resultType：sql语句查询结果集的封装类型,tb_user即为数据库中的表
    -->
    <select id="findAll" resultType="com.itdami.domain.User">
        select * from user
    </select>

    <!--    根据用户id查询用户信息-->
    <select id="findById" parameterType="int" resultType="com.itdami.domain.User">
        select * from user where id=#{uid}
    </select>

    <!--    模糊查询-->
    <select id="findByName" parameterType="String" resultType="com.itdami.domain.User">
        select * from user where username like #{uname}
    </select>

   <!-- 参数类型是实体类型   -->
    <select id="findUserByVo" parameterType="com.itdami.domain.QueryVo" resultType="com.itdami.domain.User">
        select * from user where username like #{user.username}
    </select>

    <!--    查询用户记录条数-->
    <select id="findCount" resultType="Int">
        select count(id) from user
    </select>

    <!--  插入用户信息  -->
    <!--parameterType:参数的类型 ,
    插入操作之后，执行，插入数据之后，返回插入数据的id
    keyProperty="id":id的属性名称
    resultType="int" ；结果集类型
    keyColumn="id"：数据库id的值
    order="AFTER" ：插入操作之后执行
   <selectKey keyProperty="id" keyColumn="id" resultType="int" order="AFTER">
   </selectKey>
     -->
    <insert id="saveUser" parameterType="com.itdami.domain.User">

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

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

    <!--    删除用户 parameterType中既可以写INt，也可以写Integer，也可以写java.lang.Integer-->
    <delete id="deleteUser" parameterType="java.lang.Integer">
        delete  from  user where id=#{userId}
    </delete>

</mapper>

③在MybatisTest类中写具体的测试类

package com.itdami.test;

import com.itdami.dao.IUserDao;
import com.itdami.domain.QueryVo;
import com.itdami.domain.User;
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 org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.InputStream;
import java.util.Date;
import java.util.List;

public class MybatisTest {
    private InputStream in;
    private SqlSession session;
    private IUserDao userDao;

   @Before //用于测试方法执行之前
    public void init()throws Exception
    {   //读取配置文件生成自己输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        // 构建sqlSessionFactory工厂，使用了构建者模式，builder就是构建者，隐藏创建对象细节
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //3使用工厂生产SqlSession对象，生产SqlSession对象，用到了工厂模式，可以降低类之间的依赖关系（解耦）
        session = factory.openSession();
        //4使用SQLSession创建Dao接口代理对象，使用了代理模式，可以在不修改原码基础上，对已有的方法增强
        userDao = session.getMapper(IUserDao.class);
    }

    @After //用于测试方法执行之后
    public void destory()throws Exception{
       session.commit();
       //释放资源
        session.close();
        in.close();

    }

    /**
     * 测试查询操作
     */
    @Test
    public void testFindAll(){
       List<User> users=userDao.findAll();
        for (User user : users) {
            System.out.println(user);
        }
    }
    /**
     * 根据用户Id查询用户信息
     */
    @Test
    public void testFindById(){
        List<User> users=userDao.findByName("%狗%");
        for (User user : users) {
            System.out.println(user);
        }
    }

    /**
     * 模糊查询
     */
    @Test
    public void testFindByName(){
        User user=userDao.findById(41);
        System.out.println(user);
    }

    @Test
    public void testFindByVo(){
        QueryVo vo =new QueryVo();
        User user = new User();
        user.setUsername("%狗%");
        vo.setUser(user);

       List<User> users=userDao.findUserByVo(vo);
        for (User user1 : users) {
            System.out.println(user1);
        }
    }
    /**
     * 查询记录数目
     */
    @Test
    public void testFindCount(){
        System.out.println(userDao.findCount());
    }

    /**
     * 插入保存操作
     */
    @Test
    public void testSave() {
        User user = new User();
        user.setUsername("沙僧");
        user.setAddress("流沙河");
        user.setSex("男");
        user.setBirthday(new Date());
        System.out.println("操作前"+ user);
        userDao.saveUser(user);
        System.out.println("操作后"+ user);
    }

    /**
     * 更新操作
     */

    @Test
    public void testUpdate() {
        User user = new User();
        user.setUsername("猪八戒");
        user.setAddress("高老庄");
        user.setId(41);
        userDao.updateUser(user);
    }

    /**
     * 删除操作
     */

    @Test
    public void testDelete() {
        //删除的方法
        userDao.deleteUser(49);
    }
}

六、Mybatis中编写dao实现类

上述我们用代理DAO（不写接口的实现类）的方式实现了MyBatis的增删改查操作，其实Mybatis中也是可以写DAO实现类的。

整体目录结构：

① 新增UserDaoImpl类，实现IUserDao接口

package com.itdami.dao.impl;

import com.itdami.dao.IUserDao;
import com.itdami.domain.User;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

import java.util.List;

public class UserDaoImpl implements IUserDao {
    private SqlSessionFactory factory;

    public UserDaoImpl(SqlSessionFactory factory){
        this.factory = factory;
    }

    public List<User> findAll() {
        //1.根据factory获取SqlSession对象
        SqlSession session = factory.openSession();
        //2.调用SqlSession中的方法，实现查询列表
        List<User> users = session.selectList("com.itdami.dao.IUserDao.findAll");//参数就是能获取配置信息的key
        //3.释放资源
        session.close();
        return users;
    }

    public User findById(Integer userId) {
        //1.根据factory获取SqlSession对象
        SqlSession session = factory.openSession();
        //2.调用SqlSession中的方法，实现查询一个
        User user = session.selectOne("com.itdami.dao.IUserDao.findById",userId);
        //3.释放资源
        session.close();
        return user;
    }

    public List<User> findByName(String username) {
        //1.根据factory获取SqlSession对象
        SqlSession session = factory.openSession();
        //2.调用SqlSession中的方法，实现查询列表
        List<User> users = session.selectList("com.itdami.dao.IUserDao.findByName",username);
        //3.释放资源
        session.close();
        return users;
    }

    public int findCount() {
        //1.根据factory获取SqlSession对象
        SqlSession session = factory.openSession();
        //2.调用SqlSession中的方法，实现查询一个
        Integer count = session.selectOne("com.itdami.dao.IUserDao.findCount");
        //3.释放资源
        session.close();
        return count;
    }

    public void saveUser(User user) {
        //1.根据factory获取SqlSession对象
        SqlSession session = factory.openSession();
        //2.调用方法实现保存
        session.insert("com.itdami.dao.IUserDao.saveUser",user);
        //3.提交事务
        session.commit();
        //4.释放资源
        session.close();
    }

    public void updateUser(User user) {
        //1.根据factory获取SqlSession对象
        SqlSession session = factory.openSession();
        //2.调用方法实现更新
        session.update("com.itdami.dao.IUserDao.updateUser",user);
        //3.提交事务
        session.commit();
        //4.释放资源
        session.close();
    }

    public void deleteUser(Integer userId) {
        //1.根据factory获取SqlSession对象
        SqlSession session = factory.openSession();
        //2.调用方法实现更新
        session.update("com.itdami.dao.IUserDao.deleteUser",userId);
        //3.提交事务
        session.commit();
        //4.释放资源
        session.close();
    }
}

② 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.itdami.dao.IUserDao">
    <!--配置查询所有 -->
    <!-- statement，内容：sql语句。id：唯一标识，随便写，在同一个命名空间下保持唯一
      resultType：sql语句查询结果集的封装类型,tb_user即为数据库中的表
    -->
    <select id="findAll" resultType="com.itdami.domain.User">
        select * from user
    </select>

    <!--    根据用户id查询用户信息-->
    <select id="findById" parameterType="int" resultType="com.itdami.domain.User">
        select * from user where id=#{uid}
    </select>

    <!--    模糊查询-->
    <select id="findByName" parameterType="String" resultType="com.itdami.domain.User">
        select * from user where username like #{uname}
    </select>


    <!--    查询用户记录条数-->
    <select id="findCount" resultType="Int">
        select count(id) from user
    </select>

    <!--  插入用户信息  -->
    <!--parameterType:参数的类型 ,
    插入操作之后，执行，插入数据之后，返回插入数据的id
    keyProperty="id":id的属性名称
    resultType="int" ；结果集类型
    keyColumn="id"：数据库id的值
    order="AFTER" ：插入操作之后执行
   <selectKey keyProperty="id" keyColumn="id" resultType="int" order="AFTER">
   </selectKey>
     -->
    <insert id="saveUser" parameterType="com.itdami.domain.User">

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

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

    <!--    删除用户 parameterType中既可以写INt，也可以写Integer，也可以写java.lang.Integer-->
    <delete id="deleteUser" parameterType="java.lang.Integer">
        delete  from  user where id=#{userId}
    </delete>

</mapper>

③ 修改Mybatis测试类：

package com.itdami.test;

import com.itdami.dao.IUserDao;
import com.itdami.dao.impl.UserDaoImpl;
import com.itdami.domain.User;
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 org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.InputStream;
import java.util.Date;
import java.util.List;

public class MybatisTest {
    private InputStream in;
    private IUserDao userDao;

   @Before //用于测试方法执行之前
    public void init()throws Exception
    {   //读取配置文件生成自己输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        // 构建sqlSessionFactory工厂，使用了构建者模式，builder就是构建者，隐藏创建对象细节
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //4使用SQLSession创建Dao接口代理对象，使用了代理模式，可以在不修改原码基础上，对已有的方法增强
        userDao = new UserDaoImpl(factory);
    }

    @After //用于测试方法执行之后
    public void destory()throws Exception{
        in.close();
    }

    /**
     * 测试查询操作
     */
    @Test
    public void testFindAll(){
       List<User> users=userDao.findAll();
        for (User user : users) {
            System.out.println(user);
        }
    }
    /**
     * 根据用户Id查询用户信息
     */
    @Test
    public void testFindById(){
        User user=userDao.findById(41);
        System.out.println(user);

    }

    /**
     * 模糊查询
     */
    @Test
    public void testFindByName(){
        List<User> users=userDao.findByName("%狗%");
        for (User user : users) {
            System.out.println(user);
        }
    }


    /**
     * 查询记录数目
     */
    @Test
    public void testFindCount(){
        System.out.println(userDao.findCount());
    }

    /**
     * 插入保存操作
     */
    @Test
    public void testSave() {
        User user = new User();
        user.setUsername("小魔仙");
        user.setAddress("城堡");
        user.setSex("男");
        user.setBirthday(new Date());
        System.out.println("操作前"+ user);
        userDao.saveUser(user);
        System.out.println("操作后"+ user);
    }

    /**
     * 更新操作
     */

    @Test
    public void testUpdate() {
        User user = new User();
        user.setUsername("小仙女");
        user.setAddress("天上人间");
        user.setId(41);
        userDao.updateUser(user);
    }

    /**
     * 删除操作
     */

    @Test
    public void testDelete() {
        //删除的方法
        userDao.deleteUser(50);
    }
}

下一篇我们将学习Mybatis 连接池及事务，动态SQL，以及多表操作的学习，持续关注点赞哦！