Mybatis 学习笔记02 - CRUD

最新推荐文章于 2024-06-13 08:37:22 发布

什么样的人不睡觉

最新推荐文章于 2024-06-13 08:37:22 发布

阅读量171

点赞数

文章标签： mybatis java

本文链接：https://blog.csdn.net/O____OZzz/article/details/105661526

版权

Mybatis 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1. 添加操作

1.1 在 UserDao 接口中新增 saveUser() 方法

public interface UserDao {
    /**
     * 查询所有用户
     *
     * @return
     */
    List<User> queryUserAll();

    /**
     * 添加用户
     * @param user
     */
    void saveUser(User user);
}

1.2 在映射配置文件 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="com.hn.dao.UserDao">
    <!-- 配置查询所有用户 -->
    <select id="queryUserAll" resultType="com.hn.pojo.User">
        select * from user;
    </select>
    <!-- 配置添加用户 -->
    <insert id="saveUser" parameterType="com.hn.pojo.User">
        insert into user(username, birthday, sex, address) values (#{username}, #{birthday}, #{sex}, #{address});
    </insert>
</mapper>

parameterType：传入参数的类的全限定类名
Mybatis 使用 OGNL 表达式解析对象字段的值,#{}或${}括号中的值为实体类的属性名称
SQL语句里的参数符号 #{}里的值必须和传入参数的类的属性一一对应

1.3 测试添加用户

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;

/**
 * @Author : ShiHaoNan
 * @Date : 2020/4/21 13:55
 **/

public class MybatisTest {
    private InputStream is;
    private SqlSession session;
    private UserDao userDao;

    @Before //在测试方法之前执行
    public void init() throws Exception {
        //1.读取配置文件
        is = Resources.getResourceAsStream("mybatis-config.xml");
        //2.创建 SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
        //3.获取 SqlSession
        session = factory.openSession();
        //4.使用 SqlSession 创建dao接口的代理对象
        userDao = session.getMapper(UserDao.class);
    }

    @After  //在测试方法之后执行
    public void destroy() throws Exception {
        //6.提交事务
        session.commit();
        //7.释放资源，后开先关
        session.close();
        is.close();
    }

    /**
     * 测试添加用户
     */
    @Test
    public void testSaveUser() {
        User user = new User();
        user.setUsername("石某");
        user.setBirthday(new Date());
        user.setSex("男");
        user.setAddress("湖南省永州市");
        //5.使用代理对象执行添加方法
        userDao.saveUser(user);
    }

    /**
     * 测试查询所有用户
     */
    @Test
    public void testQueryUserAll() {
        //5.使用代理对象执行查询所有用户方法
        List<User> users = userDao.queryUserAll();
        for (User user : users) {
            System.out.println(user);
        }
    }


}

在执行添加操作后如果没有提交事务，会发生数据库事务回滚，导致添加的记录不会写到数据库中，如下图

因为我们没有设置事务自动提交，在执行数据修改操作后，需要调用 session.commit()方法来提交事务，否则添加的记录不会更新到数据库中。

1.4 测试结果

添加用户操作成功

2. 更新操作

2.1 在 UserDao 接口中新增 updateUser() 方法

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

2.2 在映射配置文件 UserMapper.xml 中配置更新操作

    <!-- 配置更新用户 -->
    <update id="updateUser" parameterType="com.hn.pojo.User">
        update user set username = #{username}, birthday = #{birthday}, sex = #{sex}, address = #{address} where id = #{id};
    </update>

2.3 测试更新用户

	/**
     * 测试更新用户
     */
    @Test
    public void testUpdateUser() {
        User user = new User();
        user.setId(1);
        user.setUsername("张某");
        user.setBirthday(new Date());
        user.setSex("男");
        user.setAddress("湖南省永州市");
        //5.使用代理对象执行更新方法
        userDao.updateUser(user);
    }

2.4 测试结果

更新用户操作成功

3. 删除操作

3.1 在 UserDao 接口中新增 deleteUserById() 方法

    /**
     * 根据 id 删除用户
     *
     * @param id
     */
    void deleteUserById(Integer id);

3.2 在映射配置文件 UserMapper.xml 中配置删除操作

    <!-- 配置删除用户 -->
    <delete id="deleteUserById" parameterType="java.lang.Integer">
        delete  from user where id = #{id};
    </delete>

如果转入的参数是基本类型或者基本类型的包装类，且只有一个参数，那么参数符号#{}里的值可以随便写。也就是说，虽然 UserDao 接口中的方法声明为void deleteUserById(Integer id) ，但是映射文件中既可以写#{id}，也可以写#{abc} 。

3.3 测试删除用户

	/**
     * 测试删除用户
     */
    @Test
    public void testDeleteUserById() {
     	//5.使用代理对象执行删除方法
        userDao.deleteUserById(1);
    }

3.4 测试结果

![删除用户操作成功](https://img-blog.csdnimg.cn/20200421180934219.png

4. 查询操作

4.1 根据 id 查询

在UserDao接口中新增queryUserById()方法

 	/**
     * 根据 id 查询用户
     *
     * @param userId
     */
    User queryUserById(Integer userId);

在映射配置文件 UserMapper.xml 中配置查询单个用户操作

    <!-- 配置查询单个用户 -->
    <select id="queryUserById" parameterType="java.lang.Integer" resultType="com.hn.pojo.User">
        select * from user where id = #{id};
    </select>

测试查询单个用户

    /**
     * 测试根据 id 查询用户
     */
    @Test
    public void testQueryUserById() {
        //5.使用代理对象执行查询单个用户方法
        User user = userDao.queryUserById(2);
        System.out.println(user);
    }

测试结果

4.2 模糊查询

在UserDao接口中新增queryUserByName()方法

    /**
     * 根据 username 模糊查询多个用户
     *
     * @param username
     * @return
     */
    List<User> queryUserByName(String username);

在映射配置文件 UserMapper.xml 中配置模糊查询多个用户操作

    <!-- 配置模糊查询多个用户 -->
    <select id="queryUserByName" parameterType="java.lang.String" resultType="com.hn.pojo.User">
        select * from user where username like #{username};
    </select>

如果返回结果有多条数据，Mybatis 会自动帮我们封装成一个 List 集合

测试模糊查询

    /**
     * 测试根据 username 模糊查询多个用户
     */
    @Test
    public void testQueryUserByName() {
        //5.使用代理对象执行根据 username 模糊查询多个用户方法
        List<User> users = userDao.queryUserByName("石");
        for (User user: users) {
            System.out.println(user);
        }
    }

测试结果

4.3 查询用户总记录数

在 UserDao 接口中新增 queryUserCount() 方法

    /**
     * 查询用户总记录数
     *
     * @return
     */
    int queryUserCount();

在映射配置文件 UserMapper.xml 中配置查询用户记录总数操作

<!-- 配置查询用户总记录数 -->
    <select id="queryUserCount" resultType="java.lang.Integer">
        select count(id) from user
    </select>

测试查询用户总记录数

/**
     * 测试查询用户总记录数
     */
    @Test
    public void testQueryUserCount() {
        int i = userDao.queryUserCount();
        System.out.println("用户总记录数为：" + i);
    }

测试结果

5. 扩展操作

5.1 添加用户时获取新增用户 id 的返回值

当 id 是由数据库的自增来实现时，而我们需要得到新增用户的 id 值，可以使用<selectKey>标签来实现返回自增 id

    <!-- 配置添加用户，并获取新增用户的 id 返回值 -->
    <insert id="saveUser" parameterType="com.hn.pojo.User">
        <!-- 配置添加操作后，获取添加数据的 id -->
        <selectKey keyProperty="id" keyColumn="id" resultType="java.lang.Integer" order="AFTER">
            select last_insert_id();
        </selectKey>
        insert into user(username, birthday, sex, address) values (#{username}, #{birthday}, #{sex}, #{address});
    </insert>

属性	描述
keyProperty	selectKey 语句结果应该被设置的目标属性
keyColumn	匹配属性的返回结果集中的列名称
resultType	结果的类型，MyBatis 允许任何简单类型用作主键的类型，包括字符串
order	如果设置为 BEFORE,那么它会首先选择主键,设置 keyProperty 然后执行插入语句。如果设置为 AFTER,会先执行插入语句,然后是 selectKey 元素

测试代码

    /**
     * 测试添加用户，并获取新增用户的 id 返回值
     */
    @Test
    public void testSaveUser() {
        User user = new User();
        user.setUsername("石三");
        user.setBirthday(new Date());
        user.setSex("男");
        user.setAddress("湖南省永州市");
        System.out.println("添加前：" + user);
        //5.使用代理对象执行添加方法
        userDao.saveUser(user);
        System.out.println("添加后：" + user);
    }

运行结果

5.2 使用实体类的包装类进行查询

开发中通过实体类传递查询条件，查询条件往往是复杂的查询条件，这时可以使用实体类包装对象传递输入参数
编写QueryVo类来封装查询条件

public class QueryVo implements Serializable {
    private User user;
    //如果还有其他的查询条件，可以一并封装进来

    public User getUser() {
        return user;
    }

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

在 UserDao 接口中新增 queryUserByVo() 方法

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

在映射配置文件 UserMapper.xml 中配置条件查询操作

    <!-- 配置根据 QueryVo 中的条件查询用户 -->
    <select id="queryUserByVo" parameterType="com.hn.pojo.QueryVo" resultType="com.hn.pojo.User">
        select * from user where address like "%"#{user.address}"%";
    </select>

测试代码

    /**
     * 测试根据 QueryVo 中的条件查询用户
     */
    @Test
    public void testQueryUserByVo() {
        User user = new User();
        user.setAddress("湖南省");
        QueryVo vo = new QueryVo();
        vo.setUser(user);
        //5.使用代理对象执行根据 QueryVo 中的条件查询用户方法
        List<User> users = userDao.queryUserByVo(vo);
        for (User user1 : users) {
            System.out.println(user1);
        }
    }

运行结果

6. Mybatis 配置文件标签讲解

6.1 properties 标签

在配置数据库连接的时候，我们可以采用以下几种方式来配置：

采用全局的内部配置

<?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>
    <!-- 全局参数 -->
    <properties>
        <property name="driver" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </properties>
    <!-- 环境，可以配置多个，default：指定采用哪个环境 -->
    <environments default="mysql">
        <!-- id：唯一标识 -->
        <environment id="mysql">
            <!-- 事务管理器，JDB类型的事务管理器-->
            <transactionManager type="JDBC"/>
            <!-- 数据源，池类型的数据源-->
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>

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

使用resources属性引入外部配置文件（常用）

编写外部配置文件jdbc-config.properties,文件必须放在类路径下

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

引入外部配置文件

    <!-- 引用外部配置文件 -->
    <properties resource="jdbc-config.properties"/>

    <!-- 环境，可以配置多个，default：指定采用哪个环境 -->
    <environments default="mysql">
        <!-- id：唯一标识 -->
        <environment id="mysql">
            <!-- 事务管理器，JDB类型的事务管理器-->
            <transactionManager type="JDBC"/>
            <!-- 数据源，池类型的数据源-->
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>

使用url属性引入外部配置文件（麻烦，不推荐）

外部配置文件可以放在任意位置，但是路径写法必须按照 Url 的方式，写起来比较麻烦，推荐第二种方法

    <!-- 引用外部配置文件 -->
    <properties url="file:///D:/JTM/JetBrains/SSM/day02_01mybatis_CRUD/src/main/resources/jdbc-config.properties"/>

URI ：Uniform Resource Identifier，即统一资源标识符，用来唯一的标识一个资源。
URL：Uniform Resource Locator，即统一资源定位器，它是一种具体的URI，可以用来标识一个资源，而且还指明了如何locate这个资源。

6.2 typeAliases 标签

如果想给某个实体类指定别名时，可以使用typeAliases标签

    <typeAliases>
    	<!-- 配置别名 -->
        <typeAlias type="com.hn.pojo.User" alias="User"/>
        <typeAlias type="com.hn.pojo.QueryVo" alias="QueryVo"/>
    </typeAliases>

`typeAlias`	用于配置别名
type	指定的是类的全限定类名
alias	指定别名，别名不再区分大小写

如果有多个实体类需要起别名的时候，可以使用package标签

    <typeAliases>
        <!-- 给包下所有实体类配置别名，并且类名就是别名，不再区分大小写 -->
        <package name="com.hn.pojo"/>
    </typeAliases>

package标签用于指定要配置别名的包，当指定之后，该包下的实体类都会注册别名，并且别名就是类名，不再区分大小写

package标签还可以用在mappers标签中，作用是将某个包内的 dao 接口全部注册为映射器

    <mappers>
    	 <!-- 指定 dao 接口所在包的位置，当指定了后就无需再写 mapper 了,不过，这种配置方式的前提是映射配置文件位置必须和dao接口的包结构相同-->
        <package name="com.hn.dao"/>
    </mappers>

这种配置方式要求映射配置文件位置必须和dao接口的包结构及名称相同
及 dao 接口 com.hn.dao.UserMapper.java 对应映射配置文件com.hn.dao.UserMapper.xml

什么样的人不睡觉

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Mybatis 学习笔记02 - CRUD

目录1. 添加操作1.1 在 UserDao 接口中新增 saveUser() 方法1.2在映射配置文件 UserMapper.xml 中添加配置1.3 测试添加用户1. 添加操作1.1 在 UserDao 接口中新增 saveUser() 方法public interface UserDao { /** * 查询所有用户 * * @return ...
复制链接

扫一扫