mybatis基础操作（一）

最新推荐文章于 2024-04-30 17:28:01 发布
最新推荐文章于 2024-04-30 17:28:01 发布
阅读量372 收藏 7
点赞数 5
文章标签： mybatis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_15897815/article/details/136359643
版权

mybatis介绍

半自动的ORM框架

ORM：对象关系映射，将java中的一个对象与数据表中的一行记录一一对应。

支持自定义sql,存储过程。

对原有jdbc进行封装，几乎消除所有jdbc代码，让开发者只需关注sql本身。

支持xml和注解配置方式自定义完成ORM操作。

mybatis框架部署

pom文件导入：

        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.11</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

创建mybatis-config配置文件：

<?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>

</configuration>

在mybatis-config配文件中配置数据库信息：

<configuration>
    <!--    配置数据库链接信息,可配置多个，default用来指定默认用哪个   -->
    <environments default="mysql">
        <environment id="mysql">
            <!--       transactionManager：配置数据库管理方式     -->
            <transactionManager type="JDBC"></transactionManager>
            <!--       transactionManager：配置数据库连接信息     -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://121.5.12.105:3306/mysql？characterEncoding=utf-8"/>
                <property name="username" value="root"/>
                <property name="password" value="n123456"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

mybatis的简单使用

创建表：

CREATE TABLE tb_students(
 sid INT PRIMARY KEY AUTO_INCREMENT,
 stu_num CHAR(5) NOT NULL UNIQUE,
 stu_name VARCHAR(20) NOT NULL,
 stu_gender CHAR(2) NOT NULL,
 stu_age INT NOT NULL
);

创建实体类：

@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class Student {
    private int stuId;
    private String stuNum;
    private String stuName;
    private String stuGender;
    private int stuAge;
}

创建Dao接口：

public interface StudentDao {
    public int insertStudent(Student student);
}

创建dao接口的映射文件：

​ resource目录下，新建名为mappers的文件夹，在mappers中新建名为StudentMapper.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">
<!--namespace对应完整的Dao类路径-->
<mapper namespace="com.kingyal.dao.StudentDao">
<!-- id对应方法名;parameterTpye对应参数的类型,可省略不写   -->
    <insert id="insertStudent" parameterType="com.kingyal.pojo.Student">
        insert into tb_students(stu_num,stu_name,stu_gender,stu_age)
        values(#{stuNum},#{stuName},#{stuGender},#{stuAge});
    </insert>

</mapper>

将映射文件添加到mybatis-config配置文件中：

<mappers >
    <mapper resource="mappers/StudentMapper.xml"></mapper>
</mappers>

测试：

public class StudentDaoTest {
    @Test
    public void insertStudent() throws IOException {
        // 获取数据库配置信息
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        // builder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // 会话工厂
        SqlSessionFactory factory = builder.build(inputStream);
        // 会话链接
        SqlSession sqlSession = factory.openSession();
        // 获取Dao接口
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        System.out.println(studentDao);
        // 插入操作
        int i = studentDao.insertStudent(new Student(0, "0001", "zhangsan", "M", 18));
        System.out.println(i);
        sqlSession.commit();
    }
}

mybatis的CRUD操作

在上述简单使用的基础上，继续补充crud操作，包含添加操作，删除操作，修改操作，查询操作所有，查询一条记录，多参数查询，查询记录数，主键回填等。其中，在多参数查询时，在mybsatis中进行条件查询，如果DAO中只有一个简单类型或者字符串类型的参数，在Mapper配置中可以直接用#{xxx}直接获取；如果有一个对象类型的参数，在Mapper配置中可以直接用#{key}直接获取对象的执行属性，key必须是参数对象的属性，名字不能改变。如果有多个参数，则需要在DAO中可以通过@Param指定或者使用hashmap传参，也可以在map的sql中用arg或者param实现参数的传递。

具体实现如下：

a. 创建接口

public int insertStudent(Student student);
public int insertStudentAndUseGeneratedKey(Student student);
public int deleteStudent(int stuNum);
public int updateStudent(Student student);
public List<Student> selectAllStudents();
public List<Student> selectAllStudentsByResultMap();
public Student selectStudentByNum(int sutNum);
public List<Student> selectAllStudentsByHashMap(HashMap<String,Integer> hashMap);
public List<Student> selectAllStudentsByArgs(int start, int pageSize);
public List<Student> selectAllStudentsByPage(@Param("start") int start,
                                                @Param("pageSize") int page);
public int getCount();

b. 在StudentMapper.xml的接口文件中实现sql语句：

<mapper namespace="com.kingyal.dao.StudentDao">
<!-- id对应方法名;parameterTpye对应参数的类型,可省略不写   -->
    <insert id="insertStudent" parameterType="com.kingyal.pojo.Student">
        insert into tb_students(stu_num,stu_name,stu_gender,stu_age)
        values(#{stuNum},#{stuName},#{stuGender},#{stuAge});
    </insert>
<!--    useGeneratedKeys：添加操作是否需要回填生成的主键，keyProperty：指定回填的主键值赋值给实体对象的哪个属性-->
    <insert id="insertStudentAndUseGeneratedKey" useGeneratedKeys="true" keyProperty="stuId">
        insert into tb_students(stu_num,stu_name,stu_gender,stu_age)
        values(#{stuNum},#{stuName},#{stuGender},#{stuAge});
    </insert>
    <delete id="deleteStudent">
        delete from tb_students where stu_num=#{stuNum};
    </delete>

    <update id="updateStudent">
        update tb_students set
        stu_name=#{stuName},
        stu_gender=#{stuGender},
        stu_age=#{stuAge}
        where stu_num=#{stuNum};
    </update>
<!-- select 方式1   -->
<!--resultType:返回的对象；resultSets：指定当前操作的集合类型，通常省略-->
    <select id="selectAllStudent" resultType="com.kingyal.pojo.Student" resultSets="java.util.List">
        select
        sid as stuId,
        stu_num as stuNum,
        stu_name as stuName,
        stu_gender as stuGender,
        stu_age as stuAge
        from tb_students;
    </select>
    <!-- select 方式2，建议用方式2   -->
<!--  resultMap 标签用于定义实体类与数据表的映射关系（ORM）  -->
    <resultMap id="StudentMap" type="com.kingyal.pojo.Student">
        <id column="sid" property="stuId"></id>
        <result column="stu_num" property="stuNum"></result>
        <result column="stu_name" property="stuName"></result>
        <result column="stu_gender" property="stuGender"></result>
        <result column="stu_age" property="stuAge"></result>
    </resultMap>
    <select id="selectAllStudentsByResultMap" resultMap="StudentMap">
        select sid,stu_num,stu_name,stu_gender,stu_age from tb_students;
    </select>
    <select id="selectStudentByNum" resultMap="StudentMap">
        select sid,stu_num,stu_name,stu_gender,stu_age from tb_students
        where stu_num=#{stuNum};
    </select>
    <select id="selectAllStudentsByHashMap" resultMap="StudentMap">
        select sid,stu_num,stu_name,stu_gender,stu_age from tb_students
        limit #{start}, #{pageSize};
    </select>
<!-- arg0和arg1也可以替换为param1和param2   -->
    <select id="selectAllStudentsByArgs" resultMap="StudentMap">
        select sid,stu_num,stu_name,stu_gender,stu_age from tb_students
        limit #{arg0}, #{arg1};
    </select>
    <select id="selectAllStudentsByPage" resultMap="StudentMap">
        select sid,stu_num,stu_name,stu_gender,stu_age from tb_students
        limit #{start}, #{pageSize};
    </select>
    <select id="getCount"  resultType="int">
        select count(1) from tb_students;
    </select>
</mapper>

c. 测试

public class StudentDaoTest {

    @Test
    public void insertStudent() throws IOException {
        // 获取数据库配置信息
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        // builder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // 会话工厂
        SqlSessionFactory factory = builder.build(inputStream);
        // 会话链接
        SqlSession sqlSession = factory.openSession();
        // 实体对象
        Student student = new Student(0, "00013", "wang13", "M", 29);
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        System.out.println(studentDao);
        // 插入操作
        int i = studentDao.insertStudent(student);
        sqlSession.commit();

        Assert.assertEquals(1, i);
    }

    @Test
    public void insertStudentAndUseGeneratedKey() throws IOException {
        // 获取数据库配置信息
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        // builder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // 会话工厂
        SqlSessionFactory factory = builder.build(inputStream);
        // 会话链接
        SqlSession sqlSession = factory.openSession();
        // 实体对象
        Student student = new Student(0, "00014", "wang14", "M", 29);
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        System.out.println(studentDao);
        // 插入操作
        int i = studentDao.insertStudentAndUseGeneratedKey(student);
        sqlSession.commit();
        System.out.println(student);
        System.out.println(i);

        Assert.assertEquals(1, i);
    }

    @Test
    public void deleteStudent() throws IOException {
        // 获取数据库配置信息
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        // builder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // 会话工厂
        SqlSessionFactory factory = builder.build(inputStream);
        // 会话链接
        SqlSession sqlSession = factory.openSession();
        // 实体对象
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        int i = studentDao.deleteStudent(00001);
        sqlSession.commit();

        Assert.assertEquals(1, i);
    }

    @Test
    public void updateStudent() throws IOException {
        // 获取数据库配置信息
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        // builder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // 会话工厂
        SqlSessionFactory factory = builder.build(inputStream);
        // 会话链接
        SqlSession sqlSession = factory.openSession();
        // 实体对象
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        // 待更新的实体
        Student student = new Student(0, "00003", "wang3", "M", 29);
        int i = studentDao.updateStudent(student);
        sqlSession.commit();

        Assert.assertEquals(1, i);
    }

    @Test
    public void selectAllStudent() throws IOException {
        // 获取数据库配置信息
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        // builder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // 会话工厂
        SqlSessionFactory factory = builder.build(inputStream);
        // 会话链接
        SqlSession sqlSession = factory.openSession();
        // 实体对象
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        // 待更新的实体
        List<Student> studentList = studentDao.selectAllStudents();
        sqlSession.commit();
        System.out.println(studentList.toString());
        Assert.assertNotEquals(0, studentList.size());
    }

    @Test
    public void selectAllStudentsByResultMap() throws IOException {
        // 获取数据库配置信息
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        // builder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // 会话工厂
        SqlSessionFactory factory = builder.build(inputStream);
        // 会话链接
        SqlSession sqlSession = factory.openSession();
        // 实体对象
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        // 待更新的实体
        List<Student> studentList = studentDao.selectAllStudentsByResultMap();
        sqlSession.commit();
        for (Student s : studentList) {
            System.out.println(s);
        }
        Assert.assertNotEquals(0, studentList.size());
    }

    @Test
    public void selectStudentByNum() throws IOException {
        // 获取数据库配置信息
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        // builder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // 会话工厂
        SqlSessionFactory factory = builder.build(inputStream);
        // 会话链接
        SqlSession sqlSession = factory.openSession();
        // 实体对象
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        // 待更新的实体
        Student student = studentDao.selectStudentByNum(00001);
        sqlSession.commit();
        System.out.println(student);
        Assert.assertNotNull(student);
    }

    @Test
    public void selectAllStudentsByHashMap() throws IOException {
        // 获取数据库配置信息
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        // builder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // 会话工厂
        SqlSessionFactory factory = builder.build(inputStream);
        // 会话链接
        SqlSession sqlSession = factory.openSession();
        // 实体对象
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        HashMap<String, Integer> hashMap = new HashMap<String, Integer>();
        hashMap.put("start", 1);
        hashMap.put("pageSize", 5);
        // 待更新的实体
        List<Student> studentList = studentDao.selectAllStudentsByHashMap(hashMap);
        sqlSession.commit();
        for (Student s : studentList) {
            System.out.println(s);
        }
        Assert.assertNotEquals(0, studentList.size());
    }

    @Test
    public void selectAllStudentsByArgs() throws IOException {
        // 获取数据库配置信息
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        // builder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // 会话工厂
        SqlSessionFactory factory = builder.build(inputStream);
        // 会话链接
        SqlSession sqlSession = factory.openSession();
        // 实体对象
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        // 待更新的实体
        List<Student> studentList = studentDao.selectAllStudentsByArgs(1, 5);
        sqlSession.commit();
        for (Student s : studentList) {
            System.out.println(s);
        }
        Assert.assertNotEquals(0, studentList.size());
    }
    @Test
    public void selectAllStudentsByPage() throws IOException {
        // 获取数据库配置信息
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        // builder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // 会话工厂
        SqlSessionFactory factory = builder.build(inputStream);
        // 会话链接
        SqlSession sqlSession = factory.openSession();
        // 实体对象
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        // 待更新的实体
        List<Student> studentList = studentDao.selectAllStudentsByPage(1, 5);
        sqlSession.commit();
        for (Student s : studentList) {
            System.out.println(s);
        }
        Assert.assertNotEquals(0, studentList.size());
    }

    @Test
    public void getCount() throws IOException {
        // 获取数据库配置信息
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        // builder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // 会话工厂
        SqlSessionFactory factory = builder.build(inputStream);
        // 会话链接
        SqlSession sqlSession = factory.openSession();
        // 实体对象
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        // 待更新的实体
        int count = studentDao.getCount();
        System.out.println(count);
        Assert.assertNotEquals(0, count);
    }
}
kingyal
关注
  • 5
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
mybatis基础操作笔记.txt
04-14
里面记载了创建模块添加maven依赖，编写映射文件，编写配置文件，编写单元测试等操作，还有一系列扩展
mybatis基本操作流程
m0_58476311的博客
09-09 4687
Mybatis的基本操作流程
MyBatis基本操作
m0_58342797的博客
10-17 2484
MyBatis增删改查
MyBatis操作数据库
weixin_54342360的博客
08-02 4154
MyBatis表查询以及动态sql的处理
MyBatis基本操作及SpringBoot单元测试
qq_63218110的博客
05-28 3126
本篇文章主要讲解如何使用SpringBoot提供的单元测试快速测试方法，以及如何使用MyBatis进行增、删、查、改的操作，其中在查询时讲解了${}和#{}的区别，以及如何预防SQL注入，还涉及到like查询的操作：使用concat方案解决。
MyBatis操作数据库实现
qq_42108331的博客
06-09 2026
MyBatis操作数据库实现（注解方式和XML文件方式）
MyBatis 基础操作
04-25
MyBatis的基础操作，xml的文件配置，新增了数据库的更新的这一操作。。。
mybatis对数据库基本操作
10-11
实现对表单的基本操作，模糊查询等操作
demo_springboot_ES_mybatis操作es_DEMO_mybatis_
10-01
使用springBoot+mybatis+es实现基本功能
mybatis基本使用
03-14
以下是一个基本的 MyBatis 测试使用的描述： 1. 环境准备 首先，确保你已经安装了 Java 和 Maven，并且有一个可用的数据库环境（如 MySQL）。然后，在 Maven 项目中添加 MyBatis 的依赖。 2. 配置 MyBatis 在项目的 ...
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 893
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 867
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
链表刷题集
最新发布
yajunjiao的专栏
04-30 267
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
PageHelper实现分页查询
m0_63849044的博客
04-24 1144
这行代码是在使用 MyBatis Generator (MBG) 或类似的 MyBatis 工具生成的代码来构建查询条件。（可能是MyBatis的Mapper接口）来执行基于前面定义的查询条件的查询，并获取结果列表。实例之后会被用来设置各种查询条件，如字段的等于、不等于、大于、小于、模糊查询等。实体类生成的辅助类，它通常包含了一些静态内部类和方法，用于构建查询条件。在MyBatis中，这样的对象通常用于构建查询条件。对象，可能用于作为查询条件）。的一个内部类，用于定义查询的具体条件。
MSE实现全链路灰度实践
云计算、数据库、大数据、深度学习、NLP、Python
04-24 369
待更新。
Java | 冒泡排序算法实现
yingzix688的博客
04-24 853
题目描述 编写一个Java程序，实现冒泡排序算法。程序需要能够接收一个整型数组作为输入，并输出排序后的数组。 冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
【限流】基于springboot（拦截器） + redis（执行lua脚本）实现注解限流
qq_43209531的博客
04-30 87
基于springboot（拦截器） + redis（执行lua脚本）实现注解限流
公考学习平台|基于SprinBoot+vue的公考学习平台(源码+数据库+文档)
weixin_66413741的博客
04-30 700
本共享汽车管理系统有管理员和用户。管理员功能有个人中心，用户管理，投放地区管理，汽车信息管理，汽车投放管理，汽车入库管理，使用订单管理，汽车归还管理。用户可以在注册登录，可以对汽车进行使用产生订单，还可以归还。因而具有一定的实用性。本站是一个B/S模式系统，采用Spring Boot框架，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得共享汽车管理系统管理工作系统化、规范化。
Java设计模式_概述（设计模式类型和基本原则）
weisian的博客
04-25 857
通过合成，可以将已有的类组合成新的类，达到复用的目的，同时保持类的简单和清晰。设计模式（Design pattern）代表了最佳的实践，是软件开发人员在软件开发过程中面临一般问题的解决方案，是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。但不推荐刚入门的开发者学习，哪怕把代码搞的一塌糊涂，也要先将功能完成，初学者，迈过坑是必然的，只有对自己编写的代码不满意，你才会体会到设计模式的重要性，也才能更加理解。也就是说，一个类应该尽量减少与其他类的耦合度，只与它直接相关的类进行交互。
mybatis基础操作
10-14
下面是MyBatis的基础操作： 1. 配置文件：MyBatis的配置文件包含了数据库连接信息、类型别名、映射文件等信息。 2. 映射文件：MyBatis的映射文件定义了SQL语句、参数映射和结果映射等信息。 3. SqlSessionFactory：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值