Mybatis 的基础使用_mybatis 简单调用-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_30763385/article/details/109433685

本文介绍了MyBatis的优势，它能避免JDBC访问数据库时的繁琐代码，实现代码复用。还说明了Java连接MySQL使用MyBatis的环境准备，通过四个步骤小试牛刀，最后详细阐述了表结构及一对一、一对多、多对多的CRUD操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

why have Mybatis?

平时我们都用JDBC访问数据库，除了需要自己写SQL之外，还必须操作Connection, Statement, ResultSet 这些其实只是手段的辅助类。不仅如此，访问不同的表，还会写很多雷同的代码，显得繁琐和枯燥
就像这样
在这里插入图片描述
现在，只要这样

具体的sql语句都写在了xx.xml文件里
在这里插入图片描述
这样的文件说明什么？？？
代码可以复用！！！
不用写重复的代码了，只要引用这个文件就代码执行了这个sql语句

环境准备

Java 连接 MySQL 需要驱动包
在这里插入图片描述

 我们需要用到的MyBatis下载地址

或者直接用maven

<!-- mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.10</version>
</dependency>
<!-- mysql -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
     <version>8.0.21</version>
</dependency>

<build>
    <resources>
        <resource>
            <!-- directory：指定资源文件的位置 -->
            <directory>src/main/java</directory>
            <includes>
                <!-- “**” 表示任意级目录    “*”表示任意任意文件 -->
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <!--  filtering：开启过滤，用指定的参数替换directory下的文件中的参数(eg. ${name}) -->
            <filtering>false</filtering>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
        </resource>
    </resources>
</build>

注意： maven打包，默认会把src/main/resources下面的配置文件打包进来，src/main/java下的java文件编译打包进来。
因此，需要配置 build

CREATE TABLE category_ (
  id int(11) NOT NULL AUTO_INCREMENT,
  name varchar(32) DEFAULT NULL,
  PRIMARY KEY (id)
) ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

INSERT INTO category_ VALUES (null,'category1');
INSERT INTO category_ VALUES (null,'category2');

小试牛刀

原文地址

基本原理

应用程序找Mybatis要数据
mybatis从数据库中找来数据
2.1 通过mybatis-config.xml 定位哪个数据库
2.2 通过Category.xml执行对应的select语句
2.3 基于Category.xml把返回的数据库记录封装在Category对象中
2.4 把多个Category对象装在一个Category集合中
返回一个Category集合

大概就是这样吧，我把作者的图改了改，应该没事吧，反正。。。。。。(⊙﹏⊙)

第一步，应用程序找Mybatis要数据

public class TestMybatis {

  public static void main(String[] args) throws IOException {
    String resource = "mybatis-config.xml";
    // 配置文件的读取
    InputStream inputStream = Resources.getResourceAsStream(resource);
    // 根据配置文件mybatis-config.xml得到sqlSessionFactory
    /*
     * 每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的。
     * SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。
     * 而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先配置的 Configuration 实例来构建出 SqlSessionFactory 实例。
     * */
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    // 根据sqlSessionFactory 得到session
    SqlSession session = sqlSessionFactory.openSession();

    // 通过session的selectList方法，调用sql语句listCategory。 listCategory这个就是在配置文件Category.xml中那条sql语句设置的id
    List<Category> cs = session.selectList("listCategory");
    for (Category c : cs) {
      System.out.println(c.getName());
    }
    
    // 第二种方式
    CategoryMapper mapper = session.getMapper(CategoryMapper.class);
    for (Category c : mapper.listCategory()) {
      System.out.println(c.getName());
    }
  }
}

第二种方式对应的 mapper 接口

public interface CategoryMapper {
  public List<Category> listCategory();
}

第二步，写配置文件 mybatis-config.xml

用于连接数据库、加载映射文件(操作数据库的 SQL 语句)

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

    <!--别名，自动扫描com.how2java.pojo下的类型，使得在后续配置文件Category.xml中使用resultType的时候，可以直接使用Category,而不必写全com.how2java.pojo.Category-->
    <typeAliases>
      <package name="com.how2java.pojo"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
        	<!-- 提供连接数据库用的驱动，数据库名称，编码方式，账号密码-->
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!--定位哪个数据库-->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/test?useSSL=false&amp;serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="1234"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 映射 Category.xml
	映射文件即 SQL 映射文件，该文件中配置了操作数据库的 SQL 语句-->
    <mappers>
        <mapper resource="com/how2java/pojo/Category.xml"/>
    </mappers>

</configuration>

在这里插入图片描述

第三步，写映射文件 Category.xml

该文件中配置了操作数据库的 SQL 语句

<?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.how2java.pojo">
    <!-- 执行对应的select语句-->
    <!-- id: listCategory 进行标示以供应用程序调用-->
    <!-- 
	    resultType="Category" 表示返回的数据和Category关联起来，
	    这里本应该使用的是 com.how2java.pojo.Category, 但是因为在mybatis-config.xml文件中配置了别名，
	    所以直接使用Category就行了
    -->
    <select id="listCategory" resultType="Category">
            select * from   category_      
    </select>
</mapper>
<!--
执行完之后把返回的数据库记录封装在Category对象中
可能有多个Category对象，把多个Category对象装在一个Category集合中
最后返回一个Category集合
-->

第四步，写实体类 Category.java

和 Category.xml 中的 resultType 对应

@Data
public class Category {
  private int id;
  private String name;
}

CRUD

操作	语句
增加	`insert into category_ ( name ) values (#{name})`
删除	`delete from category_ where id= #{id}`
get	`select * from category_ where id= #{id}`
更新	`update category_ set name=#{name} where id=#{id}`
查询所有	`select * from category_`

<mapper namespace="com.how2java.pojo">
	<!-- #{name}会自动获取Category对象的name属性值-->
	<!-- parameterType 传参 -->
    <insert id="addCategory" parameterType="Category" >
        insert into category_ ( name ) values (#{name})   
    </insert>
     
    <delete id="deleteCategory" parameterType="Category" >
        delete from category_ where id= #{id}  
    </delete>
     
    <select id="getCategory" parameterType="_int" resultType="Category">
        select * from   category_  where id= #{id}   
    </select>

    <update id="updateCategory" parameterType="Category" >
        update category_ set name=#{name} where id=#{id}   
    </update>
    
    <select id="listCategory" resultType="Category">
        select * from   category_     
    </select>    
</mapper>

Category c = new Category();
// 增加
c.setName("新增加的Category");
session.insert("addCategory",c);  
// 删除
c.setId(6);
session.delete("deleteCategory",c);
// 获取
Category c= session.selectOne("getCategory",3);
//修改
session.update("updateCategory",c);
// 除了查询 ，增删改需要加上commit语句
session.commit();
// 查询所有
List<Category> cs = session.selectList("listCategory");
for (Category c : cs) {
    System.out.println(c.getName());
}
session.close();

表结构

CREATE TABLE category_ (
  id int(11) NOT NULL AUTO_INCREMENT,
  name varchar(32) DEFAULT NULL,
  PRIMARY KEY (id)
) ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

create table product_(
id int NOT NULL AUTO_INCREMENT,
name varchar(30)  DEFAULT NULL,
price float  DEFAULT 0,
cid int ,
PRIMARY KEY (id)
)AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

delete from category_;
INSERT INTO category_ VALUES (1,'水果');
INSERT INTO category_ VALUES (2,'日用品');
delete from product_;
INSERT INTO product_ VALUES (1,'苹果', 18, 1);
INSERT INTO product_ VALUES (2,'香蕉', 12, 1);
INSERT INTO product_ VALUES (3,'西瓜', 20, 1);
INSERT INTO product_ VALUES (4,'保温杯', 90, 2);
INSERT INTO product_ VALUES (5,'洗脸盆', 12, 2);
INSERT INTO product_ VALUES (6,'电风扇', 100, 2);

两张表，一张类别表，一张商品表

一对一

一个商品，我需要该商品对应类型，是一对一的关系，在 resultMap 中需使用 association

SELECT p.id, p.name, p.price,
c.name AS "category"
FROM product_ p
LEFT JOIN category_ c
ON p.cid = c.id

在这里插入图片描述
对应实体类

@Data
public class Product {
  int id;
  String name;
  float price;
  Category category;
}

@Data
public class Category {
  String name;
}

<resultMap id="myProduct" type="Product">
  <id column="id" property="id"/>
  <result column="name" property="name"/>
  <result column="price" property="price"/>
  <!-- property 的值为 Product 下的 Category category; -->
  <association property="category" javaType="Category">
    <result column="category" property="name"/>
  </association>
</resultMap>

<select id="listAllProduct" resultMap="myProduct">
  SELECT p.id, p.name, p.price,
         c.name AS "category"
  FROM product_ p
         LEFT JOIN category_ c
                   ON p.cid = c.id
</select>

for (Product product : mapper.listAllProduct()) {
  System.out.println(product);
}

查询结果

Product(id=4, name=保温杯, price=90.0, category=Category(name=日用品))
Product(id=5, name=洗脸盆, price=12.0, category=Category(name=日用品))
Product(id=6, name=电风扇, price=100.0, category=Category(name=日用品))
Product(id=1, name=苹果, price=18.0, category=Category(name=水果))
Product(id=2, name=香蕉, price=12.0, category=Category(name=水果))
Product(id=3, name=西瓜, price=20.0, category=Category(name=水果))

一对多

一个类型，我需要查询该类别的所有商品

对应 sql语句

SELECT 
c.id, c.name ,
p.id "p_id",p.name "p_name",p.price
FROM category_ c 
LEFT JOIN product_ p 
ON c.id = p.cid

在这里插入图片描述

对应实体类

@Data
public class Category {
  int id;
  String name;
  List<Product> products;
}

@Data
public class Product {
  int id;
  String name;
  float price;
}

<resultMap type="Category" id="myCategory">
  <id column="id" property="id"/>
  <result column="name" property="name"/>
  <!-- 一对多的关系 -->
  <!-- property: 为实体类 Category 下的 List<Product> products; ofType：List<Product> 内的类型 -->
  <collection property="products" ofType="Product">
    <id column="p_id" property="id"/>
    <result column="p_name" property="name"/>
    <result column="price" property="price"/>
  </collection>
</resultMap>

<select id="listCategoryAndProducts" resultMap="myCategory">
  SELECT
    c.id, c.name ,
    p.id "p_id",p.name "p_name",p.price
  FROM category_ c
         LEFT JOIN product_ p
                   ON c.id = p.cid
</select>

for (Category listCategoryAndProduct : mapper.listCategoryAndProducts()) {
  System.out.println(listCategoryAndProduct);
}

Category(id=1, name=水果, products=[Product(id=1, name=苹果, price=18.0), Product(id=2, name=香蕉, price=12.0), Product(id=3, name=西瓜, price=20.0)])
Category(id=2, name=日用品, products=[Product(id=4, name=保温杯, price=90.0), Product(id=5, name=洗脸盆, price=12.0), Product(id=6, name=电风扇, price=100.0)])

多对多

create table order_ (
  id int(11) NOT NULL AUTO_INCREMENT,
  code varchar(32) DEFAULT NULL,
  PRIMARY KEY (id)
) ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

create table order_item_(
  id int(11) NOT NULL AUTO_INCREMENT,  
  oid int , 
  pid int ,
  number int ,
  PRIMARY KEY(id)
)AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

delete from order_ ;
INSERT INTO order_ VALUES (1,'订单A');
INSERT INTO order_ VALUES (2,'订单B');

delete from order_item_ ;
INSERT INTO order_item_ VALUES (null, 1, 1, 100);
INSERT INTO order_item_ VALUES (null, 1, 2, 100);
INSERT INTO order_item_ VALUES (null, 1, 3, 100);
INSERT INTO order_item_ VALUES (null, 2, 2, 100);
INSERT INTO order_item_ VALUES (null, 2, 3, 100);
INSERT INTO order_item_ VALUES (null, 2, 4, 100);

一张订单可以包含多种产品
一种产品可以出现在多张订单里

SELECT o.*,p.name, p.price
FROM order_ o 
LEFT JOIN order_item_ oi	
ON o.id =oi.oid 
LEFT JOIN product_ p 
ON p.id = oi.pid

在这里插入图片描述

@Data
public class Order {
  int id;
  String code;
  List<Product> products;
}

@Data
public class Product {
  String name;
  float price;
}

<resultMap type="Order" id="myOrder">
  <id column="id" property="id"/>
  <result column="code" property="code"/>
  <collection property="products" ofType="Product">
    <result column="name" property="name"/>
    <result column="price" property="price"/>
  </collection>
</resultMap>

<select id="listOrders" resultMap="myOrder">
  SELECT o.*, p.name, p.price
  FROM order_ o
         LEFT JOIN order_item_ oi
                   ON o.id = oi.oid
         LEFT JOIN product_ p
                   ON p.id = oi.pid
</select>

for (Order listOrder : mapper.listOrders()) {
  System.out.println(listOrder);
}

Order(id=1, code=订单A, products=[Product(name=苹果, price=18.0), Product(name=香蕉, price=12.0), Product(name=西瓜, price=20.0)])
Order(id=2, code=订单B, products=[Product(name=香蕉, price=12.0), Product(name=西瓜, price=20.0), Product(name=保温杯, price=90.0)])