使用 MyBatis 对表执行 CRUD 操作

说明：

　　1、CRUD： C --  create    R -- read   U -- update  D -- delete

 　　2、Mybatis 的 SQL 核心配置文件中 SQL 语句的参数的传递使用 #{...}

 　　3、以用户表为例讲解 CRUD 操作

 

1、定义 UserMapper 接口

　 UserMapper.java 文件的内容如下：

package cn.mybatis.dao;

import java.util.List;
import org.apache.ibatis.annotations.Param;
import cn.mybatis.pojo.User;


public interface UserMapper {

    /**
     * 查询用户表记录数
     * @return
     */
    public int count();
    
    
    /**
     * 查询用户表所有用户
     * @return
     */
    public List<User> findAllUser(); 
    
 
    /**
     * 单条件查询：根据用户名称查询用户列表（模糊查询）
     * @param userName 用户名称
     * @return
     */
    public List<User> getUserListByUserName(String userName);
    

    /**
     * 多条件查询：根据用户名称（模糊查询）和用户角色查询用户列表（参数：对象入参）
     * @param user 对象入参
     * @return
     */
    public List<User> getUserListByUserNameAndUserRole(User user);
    
    
    /**
     * 添加操作：实现向用户表添加用户
     * @param user 对象入参
     * @return
     */
    public int addUser(User user);
    
    
    /**
     * 修改操作：实现根据用户 id 修改用户信息的操作
     * @param user 对象入参
     * @return
     */
    public int update(User user);
    
    
    /**
     * 修改操作：实现根据用户 id 修改用户密码（使用 @param 注解实现）
     * @param id
     * @param pwd
     * @return
     */
    public int updatePwd(@Param("id")Integer id,@Param("userPwd")String pwd);
    
    
    /**
     * 删除操作：实现根据用户 id 删除用户的操作
     * @param id 用户 id
     * @return
     */
    public int delete(Integer id);
}

 

 

2、定义 sql 映射文件（.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">

<mapper namespace="cn.mybatis.dao.UserMapper">
    
    <!-- MyBatis 实现查询操作，使用的是 select 元素来映射插入语句 -->

    <!-- 查询用户表记录数 （*/0/1）-->
    <select id="count" resultType="int">
        select count(1) as count from smbms_user
    </select>

    <!-- 查询用户表所有用户 -->
    <select id="findAllUser" resultType="user">
        select * from smbms_user
    </select>
    
    <!--单条件查询：根据用户名称查询用户列表（模糊查询）; 参数传递：#{参数名}-->
    <select id="getUserListByUserName" resultType="user" parameterType="string">
        SELECT * FROM smbms_user WHERE userName LIKE CONCAT('%',#{userName},'%')
    </select>
    
    <!--多条件查询：根据用户名称（模糊查询）和用户角色查询用户列表（参数：对象入参）; 参数传递：#{属性名}（参数对象中的属性名） -->
    <select id="getUserListByUserNameAndUserRole" resultType="user" parameterType="user">
        SELECT * FROM smbms_user WHERE userName LIKE CONCAT('%',#{userName},'%') AND userRole=#{userRole}
    </select>
    
    <!--
        1、MyBatis 实现增加操作，使用的是 insert 元素来映射插入语句
        2、添加操作：实现向用户表添加用户; 参数传递：#{属性名}（参数对象中的属性名） 
    -->
    <insert id="addUser" parameterType="user">
        INSERT INTO `smbms_user` (`userCode`,`userName`,`userPassword`,`gender`,`birthday`,`phone`,`address`,`userRole`,`createdBy`,`creationDate`)
        VALUES (#{userCode},#{userName},#{userPassword},#{gender},#{birthday},#{phone},#{address},#{userRole},#{createdBy},#{creationDate})
    </insert>
    
    <!--
        1、MyBatis 实现修改操作：使用的是 update 元素来映射修改语句
        2、修改操作：实现根据用户 id 修改用户信息的操作 ; 参数传递：#{属性名}（参数对象中的属性名） 
    -->
    <update id="update" parameterType="user">
        UPDATE `smbms_user` 
        SET `userCode`=#{userCode},`userName`=#{userName},`userPassword`=#{userPassword},
            `gender`=#{gender},`birthday`=#{birthday},`phone`=#{phone},`address`=#{address},
            `userRole`=#{userRole},`modifyBy`=#{modifyBy},`modifyDate`=#{modifyDate} 
        where id=#{id}
    </update>

    <!--修改操作：实现根据用户 id 修改用户密码（使用 @param 注解实现）-->
    <update id="updatePwd">
        UPDATE `smbms_user` SET userPassword=#{userPwd} WHERE id=#{id}
    </update>
    
    <!--
        1、MyBatis 实现删除操作，是使用 delete 元素来映射删除语句
        2、删除操作：实现根据用户 id 删除用户的操作
    -->
    <delete id="delete" parameterType="integer">
        DELETE FROM `smbms_user` WHERE id=#{id}
    </delete>
</mapper>

 

 

3、编写单元测试类

　 UserMapperTest.java 文件的内容如下：

package cn.mybatis.test;

import java.text.SimpleDateFormat;
import java.text.ParseException;
import java.util.Date;
import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import cn.mybatis.dao.UserMapper;
import cn.mybatis.pojo.User;
import cn.mybatis.util.MyBatisUtil;

public class UserMapperTest {

    SqlSession session = null;

    @Test // 测试获取 session
    public void test() {
        System.err.println(MyBatisUtil.getSqlSession());
    }

    @Before // 每次执行 @Test 方法之前会执行这个方法
    public void initSession() {
        session = MyBatisUtil.getSqlSession();
    }

    @After // 每次执行 @Test 方法之后会执行这个方法
    public void closeSession() {
        MyBatisUtil.close(session);
    }

    @Test // 测试查询用户表记录数
    public void testCount() {
        int count = 0;
        count = session.getMapper(UserMapper.class).count();
        System.out.println(count);
    }

    @Test // 测试查询用户表所有用户
    public void testFindAllUser() {
        List<User> userList = null;
        userList = session.getMapper(UserMapper.class).findAllUser();
        for (User user : userList) {
            System.out.println(user);
        }
    }

    @Test // 测试根据用户名称查询用户列表（模糊查询）
    public void testGetUserListByUserName() {
        List<User> userList = null;
        String userName = "李";
        userList = session.getMapper(UserMapper.class).getUserListByUserName(userName);
        for (User user : userList) {
            System.out.println(user);
        }
    }

    @Test // 测试多条件查询：根据用户名称（模糊查询）和用户角色查询用户列表
    public void testGetUserListByUserNameAndUserRole() {
        List<User> userList = null;
        User user = new User();
        user.setUserName("孙");
        user.setUserRole(3);
        userList = session.getMapper(UserMapper.class).getUserListByUserNameAndUserRole(user);
        for (User u : userList) {
            System.out.println(u);
        }
    }

    @Test // 测试添加操作：实现向用户表添加用户
    public void testAddUser() {
        int count = 0;// 返回执行 SQL 影响的行数
        try {
            User user = new User();
            user.setUserCode("weixin");
            user.setUserName("魏子轩");
            user.setUserPassword("123456");
            Date birthday;
            birthday = new SimpleDateFormat("yyyy-MM-dd").parse("1997-08-15");
            user.setBirthday(birthday);
            user.setAddress("深圳市南山区南头古城");
            user.setGender(20);
            user.setPhone("18926477245");
            user.setUserRole(1);
            user.setCreatedBy(1);
            user.setCreationDate(new Date());
            count = session.getMapper(UserMapper.class).addUser(user);
            // 模拟异常，进行回滚
            // int i=2/0;
            session.commit(); // 提交事务（MyBatisUtil 中设置了不自动提交事务，因此手动提交）
        } catch (ParseException e) {
            e.printStackTrace();
            session.rollback();// 发生异常就回滚
            count = 0;
        }
        System.out.println(count);
    }

    @Test // 测试修改操作：实现根据用户 id 修改用户信息的操作
    public void testUpdate() {
        int count = 0;// 返回执行 SQL 影响的行数
        try {
            User user = new User();
            user.setId(16);
            user.setUserCode("liuxinxin");
            user.setUserName("刘鑫鑫");
            user.setUserPassword("123456");
            Date birthday = new SimpleDateFormat("yyyy-MM-dd").parse("1996-08-15");
            user.setBirthday(birthday);
            user.setAddress("江西南昌");
            user.setGender(2);
            user.setPhone("13340090067");
            user.setUserRole(2);
            user.setModifyBy(1);
            user.setModifyDate(new Date());
            count = session.getMapper(UserMapper.class).update(user);
            // 模拟异常，进行回滚
            // int i=2/0;
            session.commit(); // 提交事务（MyBatisUtil 中设置了不自动提交事务，因此手动提交）
        } catch (ParseException e) {
            e.printStackTrace();
            session.rollback();// 发生异常就回滚
            count = 0;
        }
        System.out.println(count);
    }

    @Test // 测试修改操作：实现根据用户 id 修改用户密码（使用 @param 注解实现）
    public void updatePwd() {
        int count = 0;// 返回执行 SQL 影响的行数
        Integer id = 1;
        String pwd = "123456";
        count = session.getMapper(UserMapper.class).updatePwd(id, pwd);
        session.commit(); // 提交事务（MyBatisUtil 中设置了不自动提交事务，因此手动提交）
        System.out.println(count);
    }

    @Test // 测试删除操作：实现根据用户 id 删除用户的操作
    public void testDelete() {
        int count = 0; // 返回执行 SQL 影响的行数
        try {
            Integer id = 16;
            count = session.getMapper(UserMapper.class).delete(id);
            session.commit(); // 提交事务（MyBatisUtil 中设置了不自动提交事务，因此手动提交）
        } catch (Exception e) {
            e.printStackTrace();
            session.rollback();// 发生异常就回滚
            count = 0;
        }
        System.out.println(count);
    }
}

 

注意点

　　1、为了使数据库查询的结果和返回类型中的属性能够自动匹配以便开发，对于 MySQL 数据库和 JavaBean 都会采用同一套命名规则，即 Java 命名驼峰规则，这样就不需要再做映射(注：数据库表的字段名和属性名不一致的情况下需要手动映射)。注意参数的传递使用 #{ 参数名 }，它告诉 MyBatis 生成 PreparedStatement 参数。

　　2、MyBatis 传入参数类型可以是 Java 基础数据类型，但是只适用于一个参数的情况，通过 {参数名}即可获取传入的值。若是多参数入参，需要复杂数据类型来支持，包括 Java 实体类、Map，通过#{属性名}或#{Map的key}来获取传入的参数值。

　　3、对于增删改(insert，update，delete)这类数据库更新操作，需要注意两点：

　　　　　　（1）该类型的操作本身默认返回执行 SQL 影响的行数，所以 DAO 层的接口方法的返回值一般设置为 int 类型。最好不要返回 boolean 类型。
　　　　　　（2） insert、update、delete 元素中均没有 resultType 属性，只有查询操作需要对返回结果类型( resultType / resultMap )进行相应的指定。