（三）Mybatis延迟加载（懒加载）、一（二）级缓存、注解开发（简单易懂，图文教学，整套实战）

最新推荐文章于 2024-05-10 09:17:10 发布
原创 最新推荐文章于 2024-05-10 09:17:10 发布 · 438 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Mybatis #延迟加载 #缓存 #注解开发 #实战

本文深入探讨MyBatis框架的高级特性，包括延迟加载、一二级缓存机制及注解开发方式，通过实例演示如何优化数据库交互，提升应用性能。

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

实战项目完成代码：MybatisTest_GitHub

上一章：（二）Mybatis增删查改、动态SQL语句、多表操作（简单易懂，图文教学，整套实战）

1.延迟加载

1.1 什么是延迟加载？

需要用到数据时才进行加载，不需要用到数据时就不加载数据。延迟加载也称懒加载.
个人理解：就是把查询分成两次，例如我们在上章中讲一对一查询，查询账户和用户，我们是一次性完成的，延迟加载就是第一次只查询账户，如果用到用户，再查询用户。
使用要点：

  • 一对一通常使用立即加载
  • 一对多通常使用延迟加载

1.2 准备工作

  1. 创建子工程day3
  2. 将day2中的资源和代码都复制过来

1.3 association的延迟加载

  1. 向com.lois.dao.UserDao接口类中添加方法findById
public User findById(int id);
  1. 向com/lois/dao/AccountDao.xml中添加映射
    <select id="findAll" resultMap="accountMap">
        select * from account;
    </select>
  1. 向测试类中添加方法进行测试
@Test
    public void findByIdUser(){
        System.out.println(userDao.findById(1));
    }
  1. 修改com/lois/dao/AccountDao.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">
<mapper namespace="com.lois.dao.AccountDao">
    <resultMap id="accountMap" type="account">
        <id column="id" property="id"/>
        <result column="uid" property="uid"/>
        <result column="money" property="money"/>
        <!--映射单个对象
            property:在account实体类中的变量名
            javaType：实体类类型，应该写全类名，但是取过别名
            column：查询出来的表的字段名，该列作为传入select方法中的变量
            select：调用的查询方法，封装成javaType类
        -->
        <association property="user" javaType="user" column="uid" select="com.lois.dao.UserDao.findById"/>
    </resultMap>

    <select id="findAll" resultMap="accountMap">
        select * from account;
    </select>
</mapper>
  1. 修改测试类方法findAllAccount，并测试运行
@Test
    public void findAllAccount(){
        List<Account> all = accountDao.findAll();
        for (Account account :
                all) {
            System.out.println("---------------------");
            System.out.println(account);
        }
    }

在这里插入图片描述
我们发现查询确实分成了三次，但是并不是在我们使用的时候才查询的，还是一次性查询出来的。

  1. 这是因为我们没有打开延迟加载，查看mybatis文档后知道要在SqlMapConfig.xml进行设置，放在configuration标签内，但是不能放在第一个
	<settings>
        <!--开启延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings>
  1. 再次运行测试类findAllAccount
    在这里插入图片描述
    我们发现他是在使用的时候才进行第二次查询，且查询过的对象不会再次发起查询（第三次输出没有查询）

1.4 collection的延迟加载

  1. 修改com/lois/dao/UserDao.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">
<mapper namespace="com.lois.dao.UserDao">
    <resultMap id="userMap" type="user">
        <id column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="age" property="age"/>
        <!--collection 是用于建立一对多中集合属性的对应关系
            ofType 用于指定集合元素的数据类型
            此处的column、select和association中的意义一样-->
        <collection property="accounts" ofType="account" column="id" select="com.lois.dao.AccountDao.findByUid"/>
    </resultMap>

    <select id="findAll" resultMap="userMap">
        select * from user
    </select>

    <select id="findById" resultType="user" parameterType="int">
        select * from user where id = #{id}
    </select>
</mapper>

我们发现在AccountDao中没有findByUid，那么我们写一个

  1. 向com.lois.dao.AccountDao接口类中添加方法
public List<Account> findByUid(int uid);
  1. 向com/lois/dao/AccountDao.xml映射文件中添加映射
    <select id="findByUid" parameterType="int" resultType="account">
        select * from account where uid = #{uid}
    </select>
  1. 向测试类中添加方法进行测试
@Test
    public void findByUidAccount(){
        System.out.println(accountDao.findByUid(1));
    }
  1. 修改测试类中的findAllUser方法，为了更好的看到延迟加载
	@Test
    public void findAllUser(){
        List<User> all = userDao.findAll();
        for (User user :
                all) {
            System.out.println("------------------------");
            System.out.println(user);
        }
    }
  1. 运行测试方法findAllUser
    在这里插入图片描述

2.缓存

像大多数的持久化框架一样，Mybatis 也提供了缓存策略，通过缓存策略来减少数据库的查询次数，从而提高性能。
Mybatis 中缓存分为一级缓存，二级缓存。
在这里插入图片描述

2.1 一级缓存

一级缓存是存在SqlSession中，只要SqlSession没有 flush 或 close，它就存在。

2.1.1 验证一级缓存
  1. 在测试类中添加测试方法
@Test
    public void testFirstLevelCache1(){
        User user1 = userDao.findById(1);
        System.out.println(user1);
        User user2 = userDao.findById(1);
        System.out.println(user2);
        System.out.println(user1 == user2);
    }
  1. 运行测试
    在这里插入图片描述
    我们可以看到只发生了一次查询，且user1 == user2为true，我们知道这是比较的地址，所以user1和user2指向同一个对象。其实一级缓存在上面的实验中已经出现过了，在延迟加载查询账户时，小明只查询了一次。
2.2 分析一级缓存

一级缓存是 SqlSession 范围的缓存，当调用 SqlSession 的修改，添加，删除，commit()，close()等方法时，就会清空一级缓存。

2.2.1 重启session
  1. 将测试类中SqlSessionFactory factory提取成为成员变量
private InputStream in;
    private SqlSession session;
    private AccountDao accountDao;
    private UserDao userDao;
    private RoleDao roleDao;
    private SqlSessionFactory factory;
    //在测试方法执行之前执行
    @Before
    public void before() throws IOException {
        //1.获取工厂图纸（配置信息）
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.招募工人（创建构建者）
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        //3.给工人图纸建造工厂（构建者构建工厂对象）
        factory = builder.build(in);
        //4.构建产品流水线（打开自动提交事务）
        session = factory.openSession(true);
        //5.根据产品设计图生产出产品（动态代理）
        accountDao = session.getMapper(AccountDao.class);
        userDao = session.getMapper(UserDao.class);
        roleDao = session.getMapper(RoleDao.class);
    }
  1. 添加测试方法
@Test
    public void testFirstLevelCache2(){
        User user1 = userDao.findById(1);
        System.out.println(user1);
        //重启session
        session.close();
        session = factory.openSession(true);
        userDao = session.getMapper(UserDao.class);

        User user2 = userDao.findById(1);
        System.out.println(user2);
        System.out.println(user1 == user2);
    }
  1. 运行测试
    在这里插入图片描述
    我们发现查询了两次，而且两者比较为false
2.2.2 其他方法
  • 将上面的重启session注释掉，换成session.clearCache()，效果跟上面一样
  • 如果换成在中间调用了修改，添加，删除，commit()的效果也是一样

2.2 二级缓存

二级缓存是 mapper 映射级别的缓存，多个 SqlSession 去操作同一个 Mapper 映射的 sql 语句，多个SqlSession 可以共用二级缓存，二级缓存是跨 SqlSession 的。

2.3 开启二级缓存

  1. 在 SqlMapConfig.xml 文件开启二级缓存
<settings>
	<!-- 开启二级缓存的支持 -->
	<setting name="cacheEnabled" value="true"/>
</settings>
  1. 配置相关的 Mapper 映射文件（我们以UserDao.xml为例），在mapper标签内添加
<!--开启User支持二级缓存-->
    <cache/>
  1. 配置 statement 上面的 useCache 属性
	<select id="findById" resultType="user" parameterType="int" useCache="true">
        select * from user where id = #{id}
    </select>
  1. 添加测试方法
@Test
    public void testSecondLevelCache(){
        SqlSession session1 = factory.openSession();
        UserDao userDao1 = session1.getMapper(UserDao.class);
        User user1 = userDao1.findById(1);
        System.out.println(user1);
        session1.close();//一级缓存消失

        SqlSession session2 = factory.openSession();
        UserDao userDao2 = session2.getMapper(UserDao.class);
        User user2 = userDao2.findById(1);
        System.out.println(user2);
        session2.close();//一级缓存消失

        System.out.println(user1 == user2);
    }
  1. 运行测试
    在这里插入图片描述
    我们发现确实只查询了一次，但是user1 == user2 却是false，这表示他们不是同一个对象，这是为什么？
    注意： 这样因为二级缓存存储在factory中，但是他的存储形式不是以对象存储，而是以数据的方式存储，需要用的时候再生成对象，所以在上面查询中，生成了两个对象。

3.注解开发

Mybatis不仅提供了使用xml映射来完成配置，还提供了一种跟简单的配置方法，注解配置。xml映射和注解配置不能在同一个Dao接口类中使用！！

3.1 准备工作

  1. 创建子工程day3_annotation
  2. 复制子工程day1的main和test文件（不要在idea中复制）
  3. 删除UserDao.xml映射文件

3.2 增删查改

  1. 修改UserDao接口类
/**
     * 查询所有用户
     * @return
     */
    @Select("select * from user")
    public List<User> findAll();

    /**
     * 根据id查询用户
     * @param id
     * @return
     */
    @Select("select * from user where id = #{id}")
    public User findById(int id);

    /**
     * 保存用户
     * @param user
     */
    @Insert("insert into user(name,age) values (#{name},#{age})")
    public void save(User user);

    /**
     * 修改用户
     * @param user
     */
    @Update("update user set name = #{name},age = #{age} where id = #{id}")
    public void update(User user);

    /**
     * 根据id删除用户
     * @param id
     */
    @Delete("delete from user where id = #{id}")
    public void deleteById(int id);

我们只需要在方法的上方使用@Select、@Insert、@Update、@Delete即可完成配置

  1. 运行测试方法进行测试

3.3 实体类属性与数据库表映射

如果实体类属性的名称和查询出来的表列字段不一致时，我们就要手动设置映射关系

	@Select("select * from user")
    @Results(value = {
            @Result(id = true,column = "ids" ,property = "id"),
            @Result(column = "username" ,property = "name"),
            @Result(column = "age" ,property = "age")
    })
    public List<User> findAll();

如果我们要在别处使用怎么办，Results注解还有一个id属性，设置后可以在别处使用

@Results(id = "userMap",value = {
            @Result(id = true,column = "ids" ,property = "id"),
            @Result(column = "username" ,property = "name"),
            @Result(column = "age" ,property = "age")
    })

在其他方法上添加注解ResultMap

@ResultMap(value = {"userMap"})

3.4 一对一（使用延迟加载）

  1. 将day3子项目中的Account实体类和AccountDao接口类复制到day3_annotation子项目中
  2. 在AccountDao接口中修改方法findAll
@Select("select * from account")
    @Results(id = "AccountMap",value = {
            @Result(id = true,column = "id",property = "id"),
            @Result(column = "uid",property = "uid"),
            @Result(column = "money",property = "money"),
            @Result(column = "uid",property = "user",one = @One(select = "com.lois.dao.UserDao.findById",fetchType = FetchType.LAZY))
    })
    public List<Account> findAll();

使用@one即可分布查询，如果将 fetchType 属性设置 FetchType.LAZY 即开启懒加载

  1. 修改测试类，获取accountDao，并添加测试方法
accountDao = session.getMapper(AccountDao.class);

	@Test
    public void findAllAccount(){
        List<Account> all = accountDao.findAll();
        for (Account account :
                all) {
            System.out.println("---------------------");
            System.out.println(account);
        }
    }

其实跟使用xml映射配置差不多，只是采用了注解的方式，如果调用的也在前面讲过了，这里就不重复了

3.5 一对多（使用延迟加载）

  1. 将day3子项目中的User实体类复制到day3_annotation子项目中
  2. 修改UserDao接口中的findAll方法
    /**
     * 查询所有用户，并且查询出用户下所有账户信息
     * @return
     */
    @Select("select * from user")
    @Results(id = "userMap", value = {
            @Result(column = "id",property = "id"),
            @Result(column = "name",property = "name"),
            @Result(column = "age",property = "age"),
            @Result(column = "id",property = "accounts",many = @Many(select = "com.lois.dao.AccountDao.findByUid",fetchType = FetchType.LAZY))
    })
    public List<User> findAll();
  1. 发现AccountDao.findByUid方法未完成，修改完成
    @Select("select * from account where uid = #{uid}")
    public List<Account> findByUid(int uid);
  1. 向测试类中添加方法，进行测试
	@Test
    public void findAllUser(){
        List<User> all = userDao.findAll();
        for (User user :
                all) {
            System.out.println("------------------------");
            System.out.println(user);
        }
    }

3.6 缓存

一级缓存在这里就不说了，默认是开启的
那么我们来看看二级缓存是如何使用

  1. 配置SqlMapConfig.xml开启二级缓存（其实默认就是开启的，这步可以跳过）
<!-- 配置二级缓存 -->
<settings>
	<!-- 开启二级缓存的支持 -->
	<setting name="cacheEnabled" value="true"/>
</settings>
  1. 然后只需要在需要使用二级缓存的dao接口类上方加入@CacheNamespace(blocking = true)即可
@CacheNamespace(blocking = true)
public interface UserDao {

我在这里就不测试了，需要的话自行测试

3.7 注解开发总结

  • 注解开发跟xml开发大致一样
  • 注解开发使用延迟加载不需要对SqlMapConfig.xml配置文件进行修改
  • 一个Dao接口只能有一个实现方式，要么是注解开发要么是xml映射
  • 如果你想看各个注解还有什么属性，可以按ctrl+鼠标点击该注解查看
  • 个人认为注解开发要比xml简单许多

上一章：（二）Mybatis增删查改、动态SQL语句、多表操作（简单易懂，图文教学，整套实战）

相关内容：

（一）初见MyBatis，快速入门以及配置文件映射文件讲解（构建思路讲解，图文教学，整套实战）

（二）Mybatis增删查改、动态SQL语句、多表操作（简单易懂，图文教学，整套实战）

（三）Mybatis延迟加载（懒加载）、一（二）级缓存、注解开发（简单易懂，图文教学，整套实战）

Mybatis注解与 延时加载(懒加载) 二级缓存注解配置
01-06
注解： 1.@Insert：实现新增。 2.@Update：实现更新。 3.@Delete：实现删除。 4.@Select：实现查询。 5.@Result：实现结果集封装。 6.@Results：可以与@Result一起使用，封装多个结果集。 7.@One：实现一对一结果集封装。 8.@Many：实现一对多结果集封装。 9.@CacheNamespace(blocking = true)：开启二级缓存 环境： 无映射文件 示例一 CRUD操作 示例 二 多对一 延时加载（懒加载） 根据id查询员工及其员工的部门信息 1.1 User类结构 2.注解配置
MyBatis注解式延迟加载
天天向上
08-17 790
1. 延迟加载 描述：延迟加载又名懒加载、按需加载，即我们需要这个数据的时候才去加载这个数据。在注解开发中可以通过设置@One或@Many的fetchType = FetchType.LAZY来指定按需加载。 需求：在用户与账户一对一关联查询的基础上，查询指定用户信息及其账户信息，对账户信息的查询实现延迟加载。 2. 数据库环境 2.1 表的创建 # 创建用户表 CREATE TABLE IF NOT EXISTS `user`( `id` INT AUTO_INCREMENT, `user
MyBatis延迟加载&注解&缓存
weixin_61300833的博客
09-16 603
目录 延迟加载: 延迟加载一(多)对一,Assoction实现: Collection 实现延迟加载 (一对多,多对多) MyBatis注解开发 使用 Mybatis 注解实现基本CRUD 使用Mybatis注解实现复杂关系映射开发 复杂关系映射的注解说明 延迟加载: 就是需要用到数据的时才会进行加载,不需要用到数据时就不加载数据,延迟加载也叫懒加载 坏处: 因为只有当需要用到数据时才会进行数据库查询,这样在大批量数据查询时,因为查询工作...
Mybatis深入了解（七）----延迟加载
令仔很忙
07-17 2468
resultMap可以实现高级映射（使用association、collection实现一对一及一对多映射），association、collection具备延迟加载功能。resultType无法实现延迟加载。 延迟加载：先从单表查询、需要时再从关联表去关联查询，大大提高 数据库性能，因为查询单表要比关联查询多张表速度要快。
Mybatis(延迟加载,缓存,注解开发)
限定私语的博客
06-11 1751
1. Mybatis 延迟加载策略 Mybatis 中一对一，一对多，多对多关系的配置可以实现对象的关联查询。实际开发过程中很多时候我们并不需要总是在加载用户信息时就一定要加载他的账户信息。此时就是我们所说的延迟加载。 1.1 概念 延迟加载：就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据。延迟加载也称懒加载. 好处：先从单表查询，需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。 坏处：因为只有当需要用到数据时，才会进行数据库查询，这样在大批量数据查
Mybatis
LeslieGuGu的博客
02-11 278
文章目录1.MyBatis映射文件深入1.1 动态sql语句1.1.1动态 SQL 之<**if>**1.1.2 动态 SQL 之<**foreach>**1.2 SQL片段抽取2.Mybatis的注解开发2.1 MyBatis的常用注解2.2 MyBatis的增删改查3. Mybatis 延迟加载策略3.1 延迟加载3.2 实现需求3.3 使用assocation实现延迟加载3.4 使用Collection实现延迟加载第 2 章 Mybatis 缓存2.1 Mybatis一级缓
Mybatis（四）之延迟加载，缓存，注解开发
qq_32719221的博客
11-15 216
内容 Mybatis中的延迟加载，什么是延迟加载，什么是立即加载 Mybatis中的缓存，为什么使用缓存，什么样的数据能使用缓存，什么样的数据不能使用 Mybatis中的一级缓存和二级缓存 Mybatis中的注解开发， 环境搭建，单表CRUD操作(代理Dao方式)，多表查询操作，缓存的配置 Mybatis中的延迟加载 问题：在一对多中，当我们有一个用户，它有100个账户 在查询用户的时候，要...
MyBatis的延迟加载（懒加载）
qq_57570052的博客
12-22 1136
MyBatis 中的延迟加载是指在需要时才加载对象的某些属性或关联对象，而不是在初始查询时就加载所有数据。这对于性能优化和减少不必要的数据库查询非常有用。
Mybatis框架学习17- Mybatis 注解开发
qq_41302594的博客
09-10 407
文章目录Mybatis 注解开发1. Mybatis 注解开发的环境搭建2. Mybatis 常用的基础注解说明3. Mybatis 使用注意事项 - 以查询为例4. Mybatis 注解开发进行 CRUD 操作4.1 使用 Mybatis 注解开发进行保存操作4.2 使用 Mybatis 注解开发进行更新操作4.3 使用 Mybatis 注解开发进行删除操作4.4 使用 Mybatis 注解开发...
8.mybatis（延迟加载、缓存、注解开发）
勇敢牛牛
10-31 879
Mybatis延迟加载策略 （1）何为延迟加载（按需加载）？ 1.   什么时候？用什么时候立即发起查询。 指的是我们真正使用数据时，才去数据库查询，而不是一上来就去把数据显示出来。 2.   mybatis的延迟加载策略 如果在测试中不打印，那么它将会延迟加载，何时输出何时加载。 3.什么时候用延迟？什么时候用立 即？ 一对多和多对多，更适用于延迟加载。 多对一和一对一...
MyBatis：缓存，延迟加载，注解应用
qq_40286307的博客
09-06 201
MyBatis 加载策略 什么是延迟加载？ 实际开发过程中很多时候并不需要总是在加载用户信息时就一定要加载他的订单信息。此时就是我们所说的延迟加载。 在一对多中，当有一个用户，它有个100个订单；在查询用户时，用户下的订单应该是，什么时候用，什么时候查询；在查询订单时，订单所属的用户信息应该是随着订单一起查询出来。 延迟加载：就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据。延迟加载也称懒加载。 优点：先从单表查询，需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表
Mybatis用注解实现局部延迟加载
qq_43223307的博客
12-10 407
【JAVA学习笔记】Mybatis注解、延迟加载以及缓存
lfj3974的专栏
10-22 407
1. mybatis注解 上一章介绍mybatis的使用时，主要介绍的是通过XML方式进行SQL相关配置，其实我们还可以通过注解来减少编写Mapper映射文件，本章就主要讲解相关的注解。 1.1 常用的CRUD注解 @Insert：实现新增 @Update：实现更新 @Delete：实现删除 @Select：实现查询 通过上面的注解，可以替代mapper.xml里面的相关SQL标签，例如通过 @Select("select * from user") public List<User>
Mybatis框架学习第七节：MyBatis 的延迟加载与注解开发
paynmind的博客
07-27 229
此博客用于个人学习，来源于ssm框架的书籍，对知识点进行一个整理。 7.1 延迟加载： 实际开发过程中很多时候我们并不需要总是在加载用户信息时就一定要加载他的账户信息。此时就是所谓的延迟加载。 7.1.1 概念与优劣： 延迟加载：就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据，延迟加载也称懒加载。 好处：先从单表查询，需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。 坏处：因为只有当需要用到数据时，才会进行数据库查询，这样在大批量数据查询时，因为查询
mybatis 懒加载
李卫康的博客
08-05 2105
延迟加载： xml中的配置： <!-- select:指定延迟加载需要执行的statement的id 用到了 不同的命名空间下的id因此要使用命名空空间 column:订单信息中关联用户信息查询的列 是外键user_id --> select * from orders select ord
【Mybatis 】（四） 延迟加载、缓存、注解开发
Java
02-15 206
目录 1.Mybatis中的延迟加载 2.Mybatis中的缓存 3.Mybatis中的注解开发 1.Mybatis中的延迟加载 1.1 介绍 问题：在一对多中，当我们有一个用户，它有100个账户。 在查询用户的时候，要不要把关联的100个账户查出来？ 在查询账户的时候，要不要把关联的一个用户查出来？ 在查...
Mybatis懒加载
最新发布
好记性不如烂笔头
05-10 1358
延迟加载”的含义是 : 暂时不用的对象不会真正载入到内存中，直到真正需要使用对象时，才去执行数据库查询操作，将该对象加载到内存中。在 MyBatis 中，如果一个对象的某个属性需要延迟加载，那么在映射该属性时，会为该属性创建相应的代理对象并返回。当真正要使用延迟加载的属性时，会通过代理对象执行数据库加载操作，得到真正的数据。
Mybatis中的延迟加载、Mybatis中的缓存、Mybatis中的注解开发
m0_52196529的博客
11-25 309
Mybatis中的延迟加载、Mybatis中的缓存、Mybatis中的注解开发
Mybatis、使用注解的方式编写用户和角色一对多关系，并使用延迟加载
添砖加瓦
07-04 1563
1、数据库准备CREATE TABLE `role` (  `ID` INT(11) NOT NULL COMMENT '编号',  `ROLE_NAME` VARCHAR(30) DEFAULT NULL COMMENT '角色名称',  `ROLE_DESC` VARCHAR(60) DEFAULT NULL COMMENT '角色描述',  PRIMARY KEY  (`ID`)) ENGI...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值