MyBatis（三）CRUD操作

不念不忘少年蓝@ 2021-06-22 15:37 534阅读 0赞

### 目录 ###

*  一、前期准备（查询所有用户Demo）
 *   *  1. 新建maven工程
     *  2. 导入坐标
     *  3. 编写必要代码（实体类和持久层接口）
     *  4. 编写SqlMapConfig.xml配置文件
     *  5. 编写映射配置文件
     *  6. 编写测试类
 *  二、 CRUD操作
 *   *  1.添加用户
     *  2. 根据id更新用户
     *  3. 根据id删除
     *  4. 根据id查询用户信息
     *  5. 模糊查询
     *  6. 单行单列查询
 *  三、问题扩展
 *   *  新增用户id的返回值

# 一、前期准备（查询所有用户Demo） #

我们还是搭建一个maven的mybatis的环境，来让我们做练习使用：

## 1. 新建maven工程 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70]

## 2. 导入坐标 ##

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.veeja</groupId>
        <artifactId>day02_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>

log4j的配置文件，放在resources下：

# 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

## 3. 编写必要代码（实体类和持久层接口） ##

创建实体类对象：

package com.veeja.domain;
    
    import java.io.Serializable;
    import java.util.Date;
    
    public class User implements Serializable { 
        private Integer id;
        private String username;
        private String address;
        private String sex;
        private Date birthday;
    
        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 String getAddress() { 
            return address;
        }
    
        public void setAddress(String address) { 
            this.address = address;
        }
    
        public String getSex() { 
            return sex;
        }
    
        public void setSex(String sex) { 
            this.sex = sex;
        }
    
        public Date getBirthday() { 
            return birthday;
        }
    
        public void setBirthday(Date birthday) { 
            this.birthday = birthday;
        }
    
        @Override
        public String toString() { 
            return "User{" +
                    "id=" + id +
                    ", username='" + username + '\'' +
                    ", address='" + address + '\'' +
                    ", sex='" + sex + '\'' +
                    ", birthday=" + birthday +
                    '}';
        }
    }

创建对应的IUserDao接口：

package com.veeja.dao;
    
    import com.veeja.domain.User;
    
    import java.util.List;
    
    /** * @author veeja * <p> * 用户的持久层接口 */
    public interface IUserDao { 
    
        /** * 查询所有的用户 * * @return */
        List<User> findAll();
    
    }

## 4. 编写SqlMapConfig.xml配置文件 ##

创建SqlMapConfig.xml，也就是mybatis的主配置文件，并且我们先在里面创建一个映射配置文件的mapper：

<?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">
            
            <environment id="mysql">
                
                <transactionManager type="JDBC"></transactionManager>
                
                <dataSource type="POOLED">
                    <property name="driver" value="com.mysql.jdbc.Driver"/>
                    <property name="url" value="jdbc:mysql://localhost:3306/mybatisdatabase?useUnicode=true&characterEncoding=utf8"/>
                    <property name="username" value="root"/>
                    <property name="password" value="0000"/>
                </dataSource>
            </environment>
        </environments>
    
        
        <mappers>
            <mapper resource="com/veeja/dao/IUserDao.xml"></mapper>
        </mappers>
    
    </configuration>

## 5. 编写映射配置文件 ##

在resources下创建对应的`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.veeja.dao.IUserDao">
        
        <select id="findAll" resultType="com.veeja.domain.User">
            select * from user
        </select>
    </mapper>

## 6. 编写测试类 ##

接下来我们创建测试类，写一个测试方法：

package com.veeja.test;
    
    import com.veeja.dao.IUserDao;
    import com.veeja.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.Test;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.List;
    
    /** * 测试mybatis的CRUD操作 */
    public class MybatisTest { 
        /** * 测试查询所有 */
        @Test
        public void testFindAll() throws IOException { 
            // 1. 读取配置文件，生成字节输入流
            InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
            // 2. 获取SqlSessionFactory
            SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
            // 3. 获取SqlSession对象
            SqlSession sqlSession = factory.openSession();
            // 4. 获取Dao的代理对象
            IUserDao userDao = sqlSession.getMapper(IUserDao.class);
            // 5. 执行查询所有方法
            List<User> users = userDao.findAll();
            for (User user:users){ 
                System.out.println(user);
            }
            // 6. 释放资源
            sqlSession.close();
            in.close();
        }
    }

运行一下我们的测试方法，完全没有问题。  
![在这里插入图片描述][20200425103411536.png]  
这样我们的环境就算搭建成功了。

# 二、 CRUD操作 #

## 1.添加用户 ##

为了节省篇幅，我就简写了部分代码，注释什么的省略，导包之类的也省略了。下文以此类推。  
**IUserDao中添加一个方法：**

public interface IUserDao { 
        void saveUser(User user);
    }

**IUserDao.xml配置文件中添加对应的配置：**

<insert id="saveUser" parameterType="com.veeja.domain.User">
        insert into user(username,address,sex,birthday)values(#{username},#{address},#{sex},#{birthday})
    </insert>

**注意这里面的一些细节：**  
`parameterType`属性： 用于指定传入参数的类型。  
sql 语句中使用`#{ }`字符：它代表占位符，相当于原来 jdbc 部分所学的`？`，都是用于执行语句时替换实际的数据。具体的数据是由`#{ }`里面的内容决定的。  
`#{ }`中内容的写法：由于我们保存方法的参数是 一个 User 对象，此处要写 User 对象中的属性名称。 它用的是 ognl 表达式。

> ognl 表达式 它是 apache 提供的一种表达式语言，全称是：Object Graphic Navigation Language 对象图导航语言  
> 它是按照一定的语法格式来获取数据的。  
> 语法格式就是使用 `#{对象.对象}`的方式  
> `#{user.username}`它会先去找 user 对象，然后在 user 对象中找到 username属性，并调用getUsername()方法把值取出来。但是我们在 parameterType 属性上指定了实体类名称，所以可以省略`user.` 而直接写 `username`。

测试类添加新的测试方法，而且我们可以发现，前面的操作几乎都是一样的，我们就把它给提取出来，形成一个方法，以供我们调用，最后形成以下代码：

/** * 测试mybatis的CRUD操作 */
    public class MybatisTest { 
    
        private InputStream in = null;
        private SqlSession sqlSession = null;
        private IUserDao userDao = null;
    
        @Before //用于在测试方法执行之前执行
        public void init() throws IOException { 
            // 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 destory() throws IOException { 
            // 6. 释放资源
            sqlSession.close();
            in.close();
        }
        
        /** * 测试保存操作 */
        @Test
        public void testSave() throws IOException { 
    
            User user = new User();
            user.setUsername("mybatis");
            user.setAddress("who care?");
            user.setSex("?");
            user.setBirthday(new Date());
    
            // 执行保存方法
            userDao.saveUser(user);
    
            // 最后一定要提交事务，否则会回滚操作，导致保存无效
            sqlSession.commit();
        }
    }

我们运行之后可以发现，在数据库中确实添加了一条新的记录：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 1]  
但是后面的删除和更新操作也需要提交事务，所以我们就把这个语句也放在`destroy()`方法中：

@After //用于在测试方法执行之后执行
    public void destory() throws IOException { 
    	// 最后一定要提交事务，否则会回滚操作，导致保存无效
    	sqlSession.commit();
    	
    	// 6. 释放资源
    	sqlSession.close();
    	in.close();
    }

## 2. 根据id更新用户 ##

**IUserDao中添加一个方法：**

public interface IUserDao { 
        void updateUser(User user);
    }

**IUserDao.xml配置文件中添加对应的配置：**

<update id="updateUser" parameterType="com.veeja.domain.User">
    	update user set username=#{username},address=#{address},sex=#{sex},birthday=#{birthday} where id=#{id}
    </update>

**测试类中添加新的测试方法：**

/** * 测试更新操作 */
    @Test
    public void testUpdate() throws IOException { 
    
        User user = new User();
        user.setId(63);
        user.setUsername("mybatis");
        user.setAddress("hahhahaha");
        user.setSex("7");
        user.setBirthday(new Date());
    
        // 执行保存方法
        userDao.updateUser(user);
    
    }

**我们打开数据库查看，完全符合我们的预期：**  
![在这里插入图片描述][20200425114249573.png]

## 3. 根据id删除 ##

**IUserDao中添加一个方法：**

public interface IUserDao { 
        void deleteUser(Integer userId);
    }

**IUserDao.xml配置文件中添加对应的配置：**

<delete id="deleteUser" parameterType="java.lang.Integer">
        delete from user where id= #{uid}
    </delete>

**测试类中添加新的测试方法：**

/** * 测试删除操作 */
    @Test
    public void testDelete() throws IOException { 
        // 执行删除方法
        userDao.deleteUser(63);
    }

**我们打开数据库查看，对应的记录已经被删除掉了，完全符合我们的预期：**  
![在这里插入图片描述][20200425115254335.png]

## 4. 根据id查询用户信息 ##

**IUserDao中添加一个方法：**

User findById(Integer userId);

**IUserDao.xml配置文件中添加对应的配置：**

<select id="findById" parameterType="INT" resultType="com.veeja.domain.User">
        select * from user where id = #{uid}
    </select>

**注意这里面的一些细节：**  
`resultType`属性：用于指定结果集的类型。  
`parameterType`属性： 用于指定传入参数的类型。  
sql 语句中使用`#{ }`字符：它代表占位符，相当于原来 jdbc 部分所学的`？`，都是用于执行语句时替换实际的数据。具体的数据是由`#{ }`里面的内容决定的。  
`#{ }`中内容的写法：由于数据类型是基本类型，所以此处可以随意写。

**测试类中添加新的测试方法：**

/** * 测试根据用户id查询的操作 */
    @Test
    public void testFindById() throws IOException { 
        // 执行查询一个用户的方法
        User user = userDao.findById(42);
        System.out.println(user);
    }

**查询正确：**  
![在这里插入图片描述][20200425120017639.png]

## 5. 模糊查询 ##

**根据用户名称进行模糊查询的操作。**

**IUserDao中添加一个方法：**

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

**IUserDao.xml配置文件中添加对应的配置：**

<select id="findByName" parameterType="String" resultType="com.veeja.domain.User">
        select * from user where username like #{uname}
    </select>

**测试类中添加新的测试方法：**

/** * 测试根据用户名称进行模糊查询 */
    @Test
    public void testFindByName() throws IOException { 
        // 执行删除方法
        List<User> users = userDao.findByName("%刘%");
        for (User user : users) { 
            System.out.println(user);
        }
    }

**查询成功：**  
![在这里插入图片描述][20200425120824822.png]

## 6. 单行单列查询 ##

**我们尝试查询一下用户的总记录数。**

**IUserDao中添加一个方法：**

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

**IUserDao.xml配置文件中添加对应的配置：**

<select id="findTotal" resultType="int">
        select count(id) from user
    </select>

**测试类中添加新的测试方法：**

/** * 测试根查询用户的总记录数 */
    @Test
    public void testFindTotal() throws IOException { 
        // 执行删除方法
        int total = userDao.findTotal();
        System.out.println("用户总数："+total);
    }

**查询结果也没有问题：**  
![在这里插入图片描述][20200425121606284.png]

# 三、问题扩展 #

## 新增用户id的返回值 ##

新增用户后，同时还要返回当前新增用户的 id 值，因为 id 是由数据库的自动增长来实现的，所以就相 当于我们要在新增后将自动增长 auto\_increment 的值返回。

我们需要在xml文件修改一下增加用户的配置：

<insert id="saveUser" parameterType="com.veeja.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>

添加了一个selectKey的标签，其中的属性中，keyProperty对应实体类中的属性，keyColumn对应数据库中的列名，resultType代表返回值的类型，而order表示是在查询之后执行还是在查询之前执行，我们选择的是`AFTER`，就表示是在查询之后执行。

**然后我们在测试类中，再添加一个方法：**

/** * 测试保存操作，带有返回值id的保存 */
    @Test
    public void testSave2() throws IOException { 
    
        User user = new User();
        user.setUsername("mybatis");
        user.setAddress("who care?");
        user.setSex("?");
        user.setBirthday(new Date());
    
        System.out.println("保存之前的user："+user);
        // 执行保存方法
        userDao.saveUser(user);
    
        System.out.println("保存之后的user："+user);
    }

运行一下，可以看到，我们确实获取到了生成的id：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 2]

--------------------

end.

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70]: /images/20210615/f9628092eba24e8eaa23644b24084372.png
[20200425103411536.png]: /images/20210615/c704654adc94452f99874aaa65762375.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 1]: /images/20210615/280ba8872b314919b2b598ad117230eb.png
[20200425114249573.png]: /images/20210615/9cb33beaffb54138a5f6ca12c2b0641c.png
[20200425115254335.png]: /images/20210615/81f4a3740ebd412bb9b3b097c1bb544f.png
[20200425120017639.png]: /images/20210615/a9d58dbb874e4092abbdd981966266d2.png
[20200425120824822.png]: /images/20210615/43fd2feebc514094b7f2c620124a7281.png
[20200425121606284.png]: /images/20210615/e1c83a5a25d0487ca34aef524d6ab5c1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 2]: /images/20210615/dec1caf8ce334acd9323004a3a8e1018.png