MybatisCRUD操作

水深无声 2021-07-24 15:12 262阅读 0赞

> 本篇文章主要讲解mybatis框架在IDEA中的CRUD操作

> 学习靠自觉,分享靠自愿.转载麻烦注明出处CSDN博客炒冷饭

### 文章目录 ###

*  MyBatis的CRUD操作
 *   *  查询
     *   *  序号参数绑定
         *  注解参数绑定\[推荐\]
         *  使用Map参数绑定方式
         *  使用对象参数绑定
         *  实现模糊查询
     *  删除
     *  修改(更新)
     *  添加
     *   *  需要返回值的删除,增加,修改方法
     *  主键回填
     *   *  通过last\_insert\_id()查询主键
         *  通过uuid()查询主键(可用于分布式的插入)

# MyBatis的CRUD操作 #

为了便于阅读本篇博文的代码和具体操作,先提供测试使用的数据库

<table> 
 <thead> 
  <tr> 
   <th align="center">数据库mybatis的t_user表</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly9naXRlZS5jb20vbGVpeXVqaWEvY3Nkbi9yYXcvbWFzdGVyL2ltYWdlLTIwMjAwNjEzMTEyMjA1MTI0LnBuZw?x-oss-process=image/format,png" alt="image-20200613112205124"></td> 
  </tr> 
 </tbody> 
</table>

## 查询 ##

> 标签 sql语句

### 序号参数绑定 ###

通过序号参数绑定有两种方式

*  通过\#\{argx\}的方式进行参数绑定
    
     *  注意**arg参数绑定方式的开始位置是0**,即arg0代表的是第一个参数
 *  通过\#\{paramx\}的方式进行参数绑定
    
     *  注意**param参数绑定方式的开始位置是1**,即param1代表的是第一个参数

public interface UserDao { 
        User queryUserById(Integer id);
    
        User queryUserByUsernameAndPassward(String username,String passward);
    
        User queryUserByIdAndUsername(Integer id,String username);
    }

<select id="queryUserById" resultType="User">
            select * from t_user where id =#{arg0}
        </select>
    
        <select id="queryUserByUsernameAndPassward" resultType="User">
            select id,username,passward,gender,regist_Time as registTime
            from t_user
            where username=#{arg0} and passward=#{arg1}
        </select>
    
        
        
        <select id="queryUserByIdAndUsername" resultType="User">
            select id,username,passward,gender,regist_Time as registTime
            from t_user
            where id=#{param1} and username=#{param2}
        </select>

**测试类的代码**

/** * @author 雷雨 * @date 2020/6/11 10:21 */
    public class TestUserDao { 
        public static void main(String[] args) throws IOException { 
            //1.加载配置文件
            InputStream inputStream= Resources.getResourceAsStream("mybatis-config.xml");
            //2.构建 SqlSessionFactory的对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            //3.创建SqlSession
            SqlSession sqlSession = sqlSessionFactory.openSession();
            //4.通过SqlSession获取DAO实现类对象
            //之前我们讲DAO的实现类不是我们亲自做的做的,是mybatis通过配置文件动态的早内存中通过反射为我们做动态的,
            //我们看不到这个类,但是需要这个类完成我么的DAO的功能
            UserDao mapper = sqlSession.getMapper(UserDao.class);
            User user1 = mapper.queryUserById(1);
    
            User user2 = mapper.queryUserById(1);
            System.out.println("测试方法queryUserById"+"测试单参数的查询方法在mybatis中的实现");
            System.out.println(user1);
            System.out.println(user2);
    
            System.out.println("测试方法queryUserByUsernameAndPassward"+"多参数在mybatis中如何实现查询");
            User user3 = mapper.queryUserByUsernameAndPassward("xiaobai","456");
            System.out.println(user3);
    
            System.out.println("测试方法queryUserByIdAndUsername"+"测试多参数在mybatis中查询的param的参数提供方式");
            User user4 = mapper.queryUserByIdAndUsername(2,"xiaobai");
            System.out.println(user4);
        }
    }

<table> 
 <thead> 
  <tr> 
   <th align="center">使用序号参数绑定</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly9naXRlZS5jb20vbGVpeXVqaWEvY3Nkbi9yYXcvbWFzdGVyL2ltYWdlLTIwMjAwNjEzMTEyNjE4NjA1LnBuZw?x-oss-process=image/format,png" alt="image-20200613112618605"></td> 
  </tr> 
 </tbody> 
</table>

### 注解参数绑定\[推荐\] ###

public class UserDao{ 
            //相当于给我们的参数绑定了一个别名用于在mybatis的配置文件中能直接使用别名来识别,我们要传的参数,而不使用之前的param1..param2等的参数绑定方式
        User queryUserByIdAndPassward(@Param("id")Integer id ,@Param("passward") String passward);
    }

<select id="queryUserByIdAndPassward" resultType="User">
            select id,username,passward,gender,regist_Time as registTime
            from t_user
            where id=#{id} and passward=#{passward}
    </select>

**结果**

<table> 
 <thead> 
  <tr> 
   <th align="center">使用注解绑定参数</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly9naXRlZS5jb20vbGVpeXVqaWEvY3Nkbi9yYXcvbWFzdGVyL2ltYWdlLTIwMjAwNjEzMTQwNjU2MzY0LnBuZw?x-oss-process=image/format,png" alt="image-20200613140656364"></td> 
  </tr> 
 </tbody> 
</table>

### 使用Map参数绑定方式 ###

public class UserDao{ 
        //将要查询的参数封装为一个Map
        User queryUserByIdAndPassward2(Map map);
    }

映射配置文件

<select id="queryUserByIdAndPassward2" resultType="User">
            select id,username,passward,gender,regist_Time as registTime
            from t_user
            where id=#{id} and passward=#{passward}
        </select>

测试类

public class TestUserDao { 
        public static void main(String[] args) throws IOException { 
            //1.加载配置文件
            InputStream inputStream= Resources.getResourceAsStream("mybatis-config.xml");
            //2.构建 SqlSessionFactory的对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            //3.创建SqlSession
            SqlSession sqlSession = sqlSessionFactory.openSession();
            //4.通过SqlSession获取DAO实现类对象
            //之前我们讲DAO的实现类不是我们亲自做的做的,是mybatis通过配置文件动态的早内存中通过反射为我们做动态的,
            //我们看不到这个类,但是需要这个类完成我么的DAO的功能
             Map map = new HashMap();
            map.put("id",2);
            map.put("passward","456");
            User user6 = mapper.queryUserByIdAndPassward2(map);
            System.out.println("测试方法queryUserByIdAndPassward2"+"将参数封装为一个map集合,通过集合提供参数");
            System.out.println(user6);
        }
    }

<table> 
 <thead> 
  <tr> 
   <th align="center">使用Map参数绑定结果</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly9naXRlZS5jb20vbGVpeXVqaWEvY3Nkbi9yYXcvbWFzdGVyL2ltYWdlLTIwMjAwNjEzMTQxMDI1MDU1LnBuZw?x-oss-process=image/format,png" alt="image-20200613141025055"></td> 
  </tr> 
 </tbody> 
</table>

### 使用对象参数绑定 ###

public class UserDAO{ 
            //将要查询的参数封装为一个对象
        User queryUserByIdAndPassward3(User user);
    }

映射文件

<select id="queryUserByIdAndPassward3" resultType="User">
            select id,username,passward,gender,regist_Time as registTime
            from t_user
            where id=#{id} and passward=#{passward}
        </select>

测试类

public class TestUserDao { 
        public static void main(String[] args) throws IOException { 
            //1.加载配置文件
            InputStream inputStream= Resources.getResourceAsStream("mybatis-config.xml");
            //2.构建 SqlSessionFactory的对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            //3.创建SqlSession
            SqlSession sqlSession = sqlSessionFactory.openSession();
            //4.通过SqlSession获取DAO实现类对象
            //之前我们讲DAO的实现类不是我们亲自做的做的,是mybatis通过配置文件动态的早内存中通过反射为我们做动态的,
            //我们看不到这个类,但是需要这个类完成我么的DAO的功能
            
            
            User user = new User();
            user.setId(1);
            user.setPassward("123");
            User user7 = mapper.queryUserByIdAndPassward3(user);
            System.out.println("测试方法queryUserByIdAndPassward3"+"将参数封装为一个对象,通过对象的属性提供参数");
            System.out.println(user7);
            
        }
    }

结果

<table> 
 <thead> 
  <tr> 
   <th align="center">使用对象封装参数</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly9naXRlZS5jb20vbGVpeXVqaWEvY3Nkbi9yYXcvbWFzdGVyL2ltYWdlLTIwMjAwNjEzMTQxMzM5OTMxLnBuZw?x-oss-process=image/format,png" alt="image-20200613141339931"></td> 
  </tr> 
 </tbody> 
</table>

### 实现模糊查询 ###

public class UserDao{ 
            //实现模糊查询
        List<User> queryUsersByUsername(String username);
    }

映射配置文件

<select id="queryUsersByUsername" resultType="User">
            select id,username,passward,gender,regist_Time as registTime
            from t_user
            where username LIKE concat('%',#{arg0},'%')
        </select>

测试类

public class TestUserDao { 
        public static void main(String[] args) throws IOException { 
            //1.加载配置文件
            InputStream inputStream= Resources.getResourceAsStream("mybatis-config.xml");
            //2.构建 SqlSessionFactory的对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            //3.创建SqlSession
            SqlSession sqlSession = sqlSessionFactory.openSession();
            //4.通过SqlSession获取DAO实现类对象
            //之前我们讲DAO的实现类不是我们亲自做的做的,是mybatis通过配置文件动态的早内存中通过反射为我们做动态的,
            //我们看不到这个类,但是需要这个类完成我么的DAO的功能
            
            List<User> users = mapper.queryUsersByUsername("xiaobai");
            System.out.println("测试方式queryUsersByUsername,实现模糊查询username为xiaobai的用户");
            for (User user8: users
                 ) { 
                System.out.println(user8);
                
            }        
    
            
        }
    }

结果

<table> 
 <thead> 
  <tr> 
   <th align="center">实现模糊查询</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly9naXRlZS5jb20vbGVpeXVqaWEvY3Nkbi9yYXcvbWFzdGVyL2ltYWdlLTIwMjAwNjEzMTQxNjA4NzI3LnBuZw?x-oss-process=image/format,png" alt="image-20200613141608727"></td> 
  </tr> 
 </tbody> 
</table>

*  注意模糊查询时在映射配置回家中返回值是泛型的类型不是集合的类型
 *  实现模糊查询需要用到通配符需要用到一个方法concat()方法,这个方法是mysql的方法不是mybatis的方法

## 删除 ##

> 标签 sql语句

void deleteUserById(Integer id);

映射文件

<delete id="deleteUserById" parameterType="int">
            delete from t_user
            where id =#{arg0}
        </delete>

*  注意在删除.修改和添加方法是和查询方法不同的:
    
     *  查询方法有返回值类型 resultType=""
     *  而删除,修改,添加方法有的是参数类型parameterType=""
 *  删除,修改,添加方法的参数绑定方式和添加方法的参数绑定方式完全相同

测试类

public class TestUserDao { 
        public static void main(String[] args) throws IOException { 
            //1.加载配置文件
            InputStream inputStream= Resources.getResourceAsStream("mybatis-config.xml");
            //2.构建 SqlSessionFactory的对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            //3.创建SqlSession
            SqlSession sqlSession = sqlSessionFactory.openSession();
            //4.通过SqlSession获取DAO实现类对象
            //之前我们讲DAO的实现类不是我们亲自做的做的,是mybatis通过配置文件动态的早内存中通过反射为我们做动态的,
            //我们看不到这个类,但是需要这个类完成我么的DAO的功能
            UserDao mapper = sqlSession.getMapper(UserDao.class)
            mapper.deleteUserById(2);
            sqlSession.commit();
        }
    }

*  注意修改添加,删除方法和查询方法不同
    
     *  在修改添加,删除方法中要求明确的指定事务,而mybatis默认是关闭事务自动提交的,我们需要手动提交,使用方法sqlSession.commit()和rollback()
     *  在查询中mybatis不需要我们mybatis的事务管理,因此不需要提交

结果

## 修改(更新) ##

> 标签sql语句

void updateUser(User user);

映射文件

<update id="updateUser" parameterType="User">
            update t_user
            set username =#{username},passward=#{passward},gender=#{gender}
            where id= #{id}
        </update>

测试类

public class TestUserDao { 
        public static void main(String[] args) throws IOException { 
            //1.加载配置文件
            InputStream inputStream= Resources.getResourceAsStream("mybatis-config.xml");
            //2.构建 SqlSessionFactory的对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            //3.创建SqlSession
            SqlSession sqlSession = sqlSessionFactory.openSession();
            //4.通过SqlSession获取DAO实现类对象
            //之前我们讲DAO的实现类不是我们亲自做的做的,是mybatis通过配置文件动态的早内存中通过反射为我们做动态的,
            //我们看不到这个类,但是需要这个类完成我么的DAO的功能
            UserDao mapper = sqlSession.getMapper(UserDao.class)
           
                
            User user = new User(1,"xiaolei", "7758", true, new Date());
            mapper.updateUser(user);
            sqlSession.commit();
        }
    }

结果

<table> 
 <thead> 
  <tr> 
   <th align="center">修改后的结果</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><img src="https://imgconvert.csdnimg.cn/aHR0cHM6Ly9naXRlZS5jb20vbGVpeXVqaWEvY3Nkbi9yYXcvbWFzdGVyL2ltYWdlLTIwMjAwNjEzMTQ1MjA3MDE2LnBuZw?x-oss-process=image/format,png" alt="image-20200613145207016"></td> 
  </tr> 
 </tbody> 
</table>

## 添加 ##

> 标签sql语句

//添加操作
        void insertUser(User user);

映射文件

<insert id="insertUser" parameterType="User">
            insert into  t_user
            values (#{id},#{username},#{passward},#{gender},#{registTime})
        </insert>

测试类

public class TestUserDao { 
        public static void main(String[] args) throws IOException { 
            //1.加载配置文件
            InputStream inputStream= Resources.getResourceAsStream("mybatis-config.xml");
            //2.构建 SqlSessionFactory的对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            //3.创建SqlSession
            SqlSession sqlSession = sqlSessionFactory.openSession();
            //4.通过SqlSession获取DAO实现类对象
            //之前我们讲DAO的实现类不是我们亲自做的做的,是mybatis通过配置文件动态的早内存中通过反射为我们做动态的,
            //我们看不到这个类,但是需要这个类完成我么的DAO的功能
            UserDao mapper = sqlSession.getMapper(UserDao.class)
           
            //测试添加方法
            User user10 = new User(null,"xiaolei2","521",false,new Date());
            mapper.insertUser(user10);
            sqlSession.commit();
        }
    }

结果

### 需要返回值的删除,增加,修改方法 ###

有的时候我们需要像之前的JDBC的操作一样,有一个返回值来确定我们修改了几条数据

这时**只需要将UserDAO中定义抽象的方法的返回值改为Interger**,然后在测试类中用一个变量进行接收就可以获取到修改数据的行数,其他的操作不需要修改

## 主键回填 ##

在我们插入数据的操作中,可能**我们的主键会设置为自增的,但是我们在填入数据后又需要用到主键自增填入的数据,这时直接通过类来获取主键值是获取不到的,因为我们在插入数据时,没有给主键赋值,这时只能获取到null值**,因此,我们需要在执行jdbc操作时,在数据库追那个给主键进行了自增后,再把这个值赋值给我们实体类中属性.这时通过实体类的属性就能得到主键的值,就叫做主键回填

场景:比如用户注册,在注册后会在数据库生成一个id值,唯一的标识该用户,但是我们希望将这个值返回给用户,让用户知道,但是不使用主键回填技术,我们可以创建这个用户(用户能进行注册),但是却不能将值返回给用户

> 标签两种方式回填方式函数

### 通过last\_insert\_id()查询主键 ###

<mapper namespace="per.Dao.UserDao">
        <insert id="inserProtect" parameterType="protect">
            <selectKey keyProperty="id" resultType="int" order="AFTER">
            	SELECT LAST_INSERT_ID()   
            </selectKey>
            insert into t_user(id,username) values(#{id},#{username})
        
    </mappe>

### 通过uuid()查询主键(可用于分布式的插入) ###

*  UUID()的值是不会相同的

<mapper namespace="per.Dao.UserDao">
        <insert id="inserProtect" parameterType="protect">
            <selectKey keyProperty="id" resultType="int" order="AFTER">
            	SELECT Replace(UUID(),'-','')   
                
            </selectKey>
            insert into t_user(id,username) values(#{id},#{username})
        
    </mappe>