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

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

文章目录

MyBatis的CRUD操作

MyBatis的CRUD操作

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

数据库mybatis的t_user表

查询

标签 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);
}

    <!-- 描述方法 -->
    <!-- id:描述的是那个接口中的那个方法 resultType:描述的方法的放回结果的类型 #{arg0}:表示的是接口中的第一个参数,那么接口中的形参的第二个参数就用#{arg1}表示 -->
    <!-- 这里使用的是一个select标签,表示的是原来接口中的方法是一个查询方法 <!- 注意在mybatis-config.xml中给实体类定义了别名,但是我们也可以不使用别名,只是使用别名方便,但是不要求必须使用 -->
    <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>

    <!-- 如果需要查询时提供的参数是多个还有另一种提供参数的方式-->
    <!--这里要注意的是使用arg和param方式提供参数的方式不同 arg方式参数是从零开始计数,0代表的是第一个参数 param方式提供参数,param1代表的是第一个参数 -->
    <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);
    }
}

使用序号参数绑定

注解参数绑定[推荐]

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>

结果

使用注解绑定参数

使用Map参数绑定方式

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

映射配置文件

    <!--将要查询时提供的参数封装为一个Map,我们在查询时,提供Map就可以查询到相关的信息 -->
    <!--我们在#{}中填写的其实就是map的key值,通过key来获取key对应的value值 -->
    <!-- 本例中假定我们定义的map的key也是id和passward -->
    <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);
    }
}

使用Map参数绑定结果

使用对象参数绑定

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

映射文件

    <!-- 将参数封装为一个对象,通过对象的属性(属性的定义就是有关get和set方法),通过属性给查询方法提供参数-->
    <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);
        
    }
}

结果

使用对象封装参数

实现模糊查询

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

映射配置文件


    <!-- 当我们的方法的返回值类型是集合类型时,我们在映射文件中的返回值类型写的是泛型的类型,而不是集合的类型-->
    <!-- 注意实现模糊方法是使用mysql中的方法concat(),来实现字符串的拼接 -->
    <select id="queryUsersByUsername" resultType="User">
        select id,username,passward,gender,regist_Time as registTime
        from t_user
        where username LIKE concat('%',#{arg0},'%')<!--字符串拼接,注意这是一个mysql的方法而不是mybatis的方法 -->
    </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);
            
        }        

        
    }
}

结果

实现模糊查询

注意模糊查询时在映射配置回家中返回值是泛型的类型不是集合的类型
实现模糊查询需要用到通配符需要用到一个方法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();
    }
}

结果

修改后的结果

添加

标签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(),'-','')   <!--适用于字符类型自增主键-->
            <!-- 将-替换为''空字符 最重要的方法还是UUID()方法,在mysql中集成了UUID()方法,用来获取字符串的唯一标识 -->
        </selectKey>
        insert into t_user(id,username) values(#{id},#{username})
    
</mappe>

MybatisCRUD操作

文章目录

MyBatis的CRUD操作

查询

序号参数绑定

注解参数绑定[推荐]

使用Map参数绑定方式

使用对象参数绑定

实现模糊查询

删除

修改(更新)

添加

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

主键回填

通过last_insert_id()查询主键

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