Mybatis笔记--简单的CRUD操作

最新推荐文章于 2022-11-06 14:59:12 发布
最新推荐文章于 2022-11-06 14:59:12 发布
阅读量504 收藏
点赞数
分类专栏： 开发 语言与框架学习 文章标签： 1024程序员节 mybatis spring 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53978900/article/details/127501642
版权

Mybatis笔记–简单的CRUD操作

一些概念

数据持久层与数据持久化
  • 持久化是将程序数据由瞬时状态和持久状态之间的转化，也就是把数据保存起来，存在库中
  • 完成持久化的代码层–DAO层（Data Access Object)数据访问对象），为了操作数据库而存在
Maven
  • 管理jar包的工具，使用pom.xml文件来控制包的导入和删除等等，非常非常方便
Mybatis架构图

Mybatis CRUD的实现

导入jar包
<?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>org.example</groupId>
    <artifactId>Mybatis-study</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>Mybatis-01</module>
    </modules>
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
        <!--  Mybatis的jar包      -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
         <!--  junit测试的包     -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
         <!--  mysql数据库连接的包     -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
    </dependencies>
</project>
  • 注意这里的编码问题，默认的写的是encoding="UTF-8"，但是这样不能使用中文，要改为encoding="utf-8"
编写核心配置文件
<?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="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?useSSL=true&amp;useUnicode&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="rootroot"/>
            </dataSource>
        </environment>
    </environments>
<!--    dao层映射文件-->
    <mappers>
        <mapper resource="com/test/dao/TeacherMapper.xml"/>
    </mappers>
</configuration>
构建MyBatis工具类
package com.test.utils;

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 java.io.InputStream;
import java.io.IOException;

/**
 * @program: Mybatis-study
 * @description:
 * @author: Morii
 * @create: 2022-09-21 21:45
 **/
//sqlsessionFactory -->sqlSession
public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory ;
    static
    {
        try {
            //使用Mybatis第一步:获取sqlSessionFactory对象，字如其名，工厂
            String resource = "mybatis-config.xml";
            //读取数据流
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
    //SqlSession里有sql执行的所有方法，返回一个对象来对数据库进行操作
    public static SqlSession getSqlSession()
    {
        return sqlSessionFactory.openSession();
    }
}
创建实体类
  • 这里就举个例子，get和set，toString方法都写好
package com.test.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @program: Mybatis-study
 * @description: 实体类
 * @author: Morii
 * @create: 2022-09-23 10:38
 **/
//@Data
//@AllArgsConstructor
//@NoArgsConstructor
public class User {
    private int id;
    private String name;
    private String password;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public User(int id, String name, String password) {
        this.id = id;
        this.name = name;
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}
编写Mapper接口类
  • 写在DAO层里
package com.test.dao;

import com.test.pojo.User;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import java.util.List;
import java.util.Map;

/**
 * @program: Mybatis-study
 * @description: Dao接口
 * @author: Morii
 * @create: 2022-09-23 10:43
 **/
public interface UserMapper {
    List<User> getUserList();
    //根据id查询
    User getUserById(int id);
    //参数比较少的时候用@Param注解标注来传递即可,多了就用Map
    User selectUserByNP(@Param("username") String username,@Param("pwd") String pwd);
    int addUser(User user);
    int updateUser(User user);
    int deleteUser(int id);
    int addUser2(Map<String,Object> map);
    List<User> getUserByLimit(Map<String,Object> map);

//    //查
//    @Select("select * from user where id=#{id}")
//    User getUserByID(@Param("id")int id);
//
//    //增
//    @Select("insert into user(id,name,pwd) values (#{id},#{name},#{password})")
//    Integer  addUsers(User user);
//
//    //删
//    @Delete("Delete from user where id=#{id}")
//    Integer deleteUsers(@Param("id")int id);
//
//    //改
//    @Update("Update user set name=#{name},pwd=#{password} where id=#{id}")
//    Integer updateUsers(User user);
}
编写Mapper.xml配置文件
  • 此配置文件里写sql语句，数据返回格式等等，也就取代了实现接口的Impl层
  • 写到资源文件resources的下面，包的格式和java包里的的一样
  • 注意增删改要提交事务
<?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，这里一定不能写错-->
<mapper namespace="com.test.dao.UserMapper">

    <!--select id=接口名 resultType=返回格式"-->
    <select id="getUserList" resultType="com.test.pojo.User">
        select * from mybatis.user
    </select>

    <resultMap id="UserMap" type="com.test.pojo.User">
        <result column="id" property="id" />
        <result column="name" property="name" />
        <result column="pwd" property="password" />
    </resultMap>

    <!--parameterType参数返回类型 返回格式，这里应用定义好了的Map-->
    <select id="getUserById" parameterType="int" resultMap="UserMap">
        select * from mybatis.user where id=#{id}
    </select>
 	<!--模糊搜索：select * from mybatis.user where name like "%"#{value}"%"-->
    
    <insert id="addUser" parameterType="com.test.pojo.User">
        insert into mybatis.user (id ,name ,pwd) values (#{id},#{name},#{pwd})
    </insert>
    <!--map版本-->
    <insert id="addUser2" parameterType="map">
        insert into mybatis.user (id,name,pwd) values (#{userid},#{username},#{userpwd})
    </insert>

    <update id="updateUser" parameterType="com.test.pojo.User">
        update mybatis.user set name=#{name},pwd=#{pwd} where id=#{id}
    </update>

    <delete id="deleteUser" parameterType="int">
        delete from mybatis.user where  id=#{id}
    </delete>
 	<!--分页-->
    <select id="getUserByLimit" parameterType="map" resultMap="UserMap">
        select * from  mybatis.user limit #{startIndex},#{pageSize}
    </select>
</mapper>
测试
  • 到此位置Mybatis的CURD就差不多了，接下来就是使用的代码了
package com.test.dao;

import com.test.pojo.Student;
import com.test.pojo.Teacher;
import com.test.pojo.User;
import com.test.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.apache.log4j.Logger;
import org.junit.Test;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @program: Mybatis-study
 * @description:
 * @author: Morii
 * @create: 2022-09-23 11:00
 **/
public class UserMapperTest {
    static Logger logger=Logger.getLogger(UserMapperTest.class);
    //查询全部
    @Test
    public void test1()
    {
        //获得SqlSession对象
        SqlSession sqlSession= MybatisUtils.getSqlSession();
        //getMapper
        //拿到通过xml获取的实例,使用了反射
        UserMapper userMapper =sqlSession.getMapper(UserMapper.class);
        //拿到的数据放进List里
        List<User> userList= userMapper.getUserList();
        //输出
        for(User user:userList)
        {
            System.out.println(user);
        }
        //关闭
        sqlSession.close();
    }
    
    //根据id查
    @Test
    public void test2()
    {
        SqlSession sqlSession=MybatisUtils.getSqlSession();
        UserMapper userMapper =sqlSession.getMapper(UserMapper.class);
        User user= userMapper.getUserById(1);
        System.out.println(user);
    }
    //插入用户
    @Test
    public void test3()
    {
        SqlSession sqlSession=MybatisUtils.getSqlSession();
        UserMapper mapper=sqlSession.getMapper(UserMapper.class);
        //插入信息
        int res=mapper.addUser(new User(2,"曾书书","haohaohao"));
        if(res>0)
        {
            System.out.println("插入成功");
        }
        
        //提交事务
        sqlSession.commit();
        sqlSession.close();

    }
    //插入用户 Map版本
    @Test
    public void test33()
    {
        SqlSession sqlSession=MybatisUtils.getSqlSession();
        UserMapper mapper=sqlSession.getMapper(UserMapper.class);
        Map<String,Object> map=new HashMap<>();
        //插入信息
        map.put("userid",5);
        map.put("username","齐昊");
        map.put("userpwd","ahahhaha");
        int res=mapper.addUser2(map);
        if(res>0)
        {
            System.out.println("插入成功");
        }
        //提交事务
        sqlSession.commit();
        sqlSession.close();

    }
    //更新信息
    @Test
    public void test4()
    {
        SqlSession sqlSession=MybatisUtils.getSqlSession();
        UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
        int res= userMapper.updateUser(new User(3,"陆雪琪","woaizhang"));
        if(res>0)
        {
            System.out.println("更新成功");
        }
        sqlSession.commit();
        sqlSession.close();
    }
    //删除用户
    @Test
    public void test5()
    {
        SqlSession sqlSession=MybatisUtils.getSqlSession();
        UserMapper userMapper=sqlSession.getMapper(UserMapper.class);
        int res=userMapper.deleteUser(2);
        if(res>0)
        {
            System.out.println("删除成功");
        }
        sqlSession.commit();
        sqlSession.close();
    }

    @Test
    //分页查询
    public void test6()
    {
        SqlSession sqlSession=MybatisUtils.getSqlSession();
        UserMapper mapper=sqlSession.getMapper(UserMapper.class);
        Map<String,Object> map=new HashMap<>();
        map.put("startIndex",0);
        map.put("pageSize",2);
        List<User> userList=mapper.getUserByLimit(map);
        for (User user:userList)
        {
            System.out.println(user);
        }
        sqlSession.close();
    }

//      子查询思路：
//      1.先查学生，再查老师
//      2.然后将学生表里的tid绑定到Teacher对象，再使用getTeacher来查询老师表里的信息
    @Test
    public void test12()
    {
        SqlSession session=MybatisUtils.getSqlSession();
        StudentMapper mapper=session.getMapper(StudentMapper.class);
        List<Student> students=mapper.getStudents();
        for (Student student:students)
        {
            System.out.println("name:"+student.getName()+"\tTeacher_Name:"+student.getTeacher().getName());
        }
        session.close();
    }

//    嵌套查询思路：
//    1.sql语句正常写-->
//    2.Map里单独分出association 然后将对象对应的表要查出的属性做映射
    @Test
    public void test13()
    {
        SqlSession session=MybatisUtils.getSqlSession();
        StudentMapper mapper=session.getMapper(StudentMapper.class);
        List<Student> students=mapper.getStudents2();
        for (Student student:students)
        {
            System.out.println(student);
        }
        session.close();
    }

}
Maven静态资源过滤配置
  • 在pom文件里加上配置
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <filtering>true</filtering>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
            </resource>
        </resources>
    </build>
目录结构
   <include>**/*.xml</include>
                <include>**/*.properties</include>
            </includes>
        </resource>
        <resource>
            <directory>src/main/java</directory>
            <filtering>true</filtering>
            <includes>
                <include>**/*.xml</include>
                <include>**/*.properties</include>
            </includes>
        </resource>
    </resources>
</build>


> #### 目录结构

![](https://img-blog.csdnimg.cn/img_convert/9c5f6870d0239090fc4f93f71bdec6b1.png)
HHachiman
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
MyBatis的CRUD操作
Pursuit_li的博客
01-02 309
crud是指在做计算处理时的增加(Create)、读取查询(Retrieve)、更新(Update)和删除(Delete)几个单词的首字母简写。crud主要被用在描述软件系统中数据库或者持久层的基本操作功能。
使用MyBatis实现CRUD
Mr. Xu的博客
11-03 727
MyBatis介绍： ​ mybatis 是一个优秀的基于 java 的持久层框架，它内部封装了 jdbc，使开发者只需要关注 sql 语句本身，而不需要花费精力去处理加载驱动、创建连接、创建 statement 等繁杂的过程。 ​ mybatis 通过xml 或注解的方式将执行的各种statement 配置起来，并通过java 对象和statement 中sql的动态参数进行映射生成最终执行的 sql 语句，最后由 mybatis 框架执行 sql并将结果映射为 java 对象并返回。 采用 ORM (
MySQL数据库（表的CRUD基础操作（最常用））
最新发布
yanxiang3306
11-06 8074
全列查询是把整个表中的所有数据都遍历了一边，这种用法在数据量比较大的时候不建议使用，MySQL数据库是基于客户端-服务器类型的，当我们发送指令的时候，服务器来接收指令，并给予服务。我们所需要的数据是存储在硬盘中的，所以服务器需要在硬盘中读取我们需要的数据，并加以解析，当全部都查询的时候，会增加数据传输时间和网络开销。注意：只可以就行单行插入，并且必须是全列的，否则就失败了。
用mybatis实现简单的CRUD
Alan_Xiang的博客
12-20 4560
下面介绍如何用mybatis实现简单的增删改查功能，有两种方式，一种是通过xml配置文件实现，一种是通过注解实现。 　　仍然通过对user的操作进行说明，新建好项目并导入jar包后，新建数据库和表，并插入两条记录：create database mybatis; use mybatis; CREATE TABLE users(id INT PRIMARY KEY AUTO_INCREMENT, N
MyBatis-Plus 学习笔记.pdf
08-30
MyBatis-Plus 学习笔记 MyBatis-Plus 是一个基于 MyBatis 的增强工具，旨在简化开发、提高效率。它提供了许多实用的特性和功能，例如无侵入、损耗小、强大的 CRUD 操作、支持 Lambda 形式调用、支持多种数据库、...
MyBatis笔记1
08-03
Mapper接口通常会与实体类对应，提供CRUD操作。例如，创建一个`AccountMapper`接口，以及相应的`AccountMapper.xml`文件，用于处理`Account`实体的数据库操作。 MyBatis的主要优势在于灵活性，它允许开发者自定义...
10_MyBatis笔记.pdf
08-27
MyBatis是一个流行的Java持久层框架，它提供了一种便捷的方式来操作数据库，主要负责CRUD（创建、读取、更新、删除）操作。这个框架起源于iBatis，旨在简化原本繁琐的JDBC代码，通过将SQL语句与Java代码解耦，使得...
MyBatis框架笔记1
08-08
Mapper接口则代表数据库中的一个表，提供了CRUD操作的方法。 3、MyBatis入门案例 创建MyBatis项目的第一步是引入MyBatis相关的jar包。然后，需要设置数据库环境，创建对应的Java Bean类，比如User类，以映射数据库...
mybatis学习笔记
02-23
MyBatis 学习笔记 MyBatis 是一个流行的 SQL 映射框架，能够自定义 SQL、存储过程和高级映射的持久层框架。在本文中，我们将从基本概念开始，逐步深入讲解 MyBatis 的使用和配置。 MyBatis 概念 MyBatis 是一个...
MyBatis实现简单的CRUD，适合初学者
08-10
MyBatis实现简单的CRUD，适合初学者，包含了项目完整源码。
MyBatis复习笔记
tl1216的博客
08-21 323
MyBatis最初是Apache的一个开源项目iBatis, 2010年6月这个项目由Apache Software Foundation迁移到了Google Code。随着开发团队转投Google Code旗下，iBatis3.x正式更名为MyBatis。代码于2013年11月迁移到GithubiBatis一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。iBatis提供的持久层框架包括SQL Maps和Data Access Objects（DAO）
一步一步搭建Mybatis开发环境，实现CRUD增删改查操作
shang_0122的博客
05-25 3674
从零搭建Mybatis开发环境，一步一步实现CRUD操作，助你更好使用Mybatis
MyBatis对表执行CRUD操作
Learning
12-17 896
一、使用MyBatis对表执行CRUD操作——基于XML的实现 1、定义sql映射xml文件 　　userMapper.xml文件的内容如下： <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <
mybatis的CRUD操作及其细节
xiao____ming的博客
08-18 295
在映射配置文件中添加必要标签： 1、查询操作，select标签，id属性的值是方法名，parameterType属性的值是方法参数的全限定类名，resultType属性的值是要将结果集封装到的实体类的全限定类名； ps：因为此处根据id或username查询都只需要一个id属性，所以代码中的uid、uname仅表示占位符，任意字符都可以。 模糊查询时，在调用方法时参数时要加上占位符，例如： List<User> list = userDao.findByName("%王%"); <!--配
mybatis入门-实现基本CRUD操作
青松之竹_Java博客
08-22 2462
闲着没事，整理整理初学mybatis时候的笔记。用于入门
Mybatis简单的crud
qq_43163943的博客
11-28 77
1、Mybatis的基础配置 https://blog.csdn.net/qq_43163943/article/details/110261144 2、Mybatis基础的crud 在文章最底部有整合了的crud，可以跳过代码分割分析区 1）插入用户 注意：第一行的属性名与数据库中的字段名相对应， 第二行的属性名与程序中的pojo类相对应 第一行和第二行...
Mybatis系列全解（三）：Mybatis简单CRUD使用介绍
潘潘和他的朋友们
12-01 440
封面：洛小汐 作者：潘潘 在理解中执行，在执行中理解，学习技术也循此道。 前言 上一篇文章 《Mybatis系列全解（二）：Mybatis简介与环境搭建》 ，我们对 Mybatis 做了初步讲解，并搭建了一套基本环境，共同完成了一次查询操作。所以本篇文章我们在此基础上，继续拓展了插入、修改、删除三种操作，把我们的CRUD基础操作进行完善。 目录 1、Mybatis查询操作回顾 2、插入操作 3、修改操作 4、删除操作 5、总结 Mybatis查询操作回顾 默认已安装 Java 开发环境、Mysql
mybatis入门学习之简单CRUD
杨小白的博客
07-27 386
Mybatis 对象关系映射 框架 （ORM Object（对象） relation（关系） Mapping（映射）） 框架 class Dept{ private String dName;//部门名称 private List&lt;Emp&gt; emps;// 关系 一对多 } //查询 ID 为 2 的 部门 Dept dept = mybatis.get...
mybatis-3.4.3官方文档
12-19
除了基本的CRUD操作，MyBatis还提供了一些高级功能，如动态SQL、结果集映射、缓存和事务管理等。这些功能在文档中都有详细的说明和示例代码，帮助读者全面理解和运用。 此外，文档还介绍了一些与MyBatis相关的概念...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值