mybatis使用xml和注解方式实现一对一、一对多、多对多

最新推荐文章于 2024-04-19 12:24:42 发布
最新推荐文章于 2024-04-19 12:24:42 发布
阅读量1.8k 收藏 4
点赞数
分类专栏： java javaweb 文章标签： mybatis mybatis一对一、一对多、多对多
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fwx0309/article/details/83620114
版权

一.数据准备

在这里插入图片描述
account（账户表）：
在这里插入图片描述role（用户角色表）：
在这里插入图片描述
user（用户表）：
在这里插入图片描述
user_role（用户和用户角色的）：
在这里插入图片描述

二、对应的实体类

Account.java(账户实体类):

/**
 * 账户实体类
*/
public class Account  {

    private Integer id;
    private Integer uid;
    private Double money;
	//一个账户对应一个用户 （一对一）
    private User user;
    ......
    }

User.java(用户实体类):

/**
 * 用户实体类
 */
public class User {

    private Integer Id;
    private String username;
    private String address;
    private String sex;
    private Date birthday;

    //一个用户对应多个账户 (一对多)
    private List<Account> accounts;

    //一个用户可以用户多个角色（多对多）
    private List<Role> roles;
    ......
    }

Role.java(用户角色实体类):注意:这里Role类中的字段和role表中的字段是不对应的

/**
 * 用户角色实体类
 */
public class Role {
      private Integer roleId;
      private String roleName;
      private String roleDesc;
      //一个角色可以赋予多个用户（多对多）
      private List<User> users;
    ......
    }

三、xml方式实现（一对一、一对多、多对多）

1.使用maven构建项目

项目结构：
在这里插入图片描述
pom.xml文件：

<?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>cn.edu.buaa.fwx</groupId>
    <artifactId>mybatis_xml</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>../mybatis_annotation</module>
    </modules>
    <packaging>pom</packaging>

    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
        </dependency>
    </dependencies>

</project>

2.mybatis主配置文件

<?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>
    <!--加载配置文件-->
    <properties resource="jdbcConfig.properties"/>

    <settings>
        <!--启用延迟加载-->
        <setting name="lazyLoadingEnabled" value="true"/>
        <!--禁用立即加载-->
        <setting name="aggressiveLazyLoading" value="false"/>
        <!--去掉会出发延迟加载的方法，如：equals,clone,hashCode,toString-->
        <setting name="lazyLoadTriggerMethods" value=""/>
    </settings>

    <environments default="development">
        <environment id="development">
            <!-- 使用jdbc事务管理-->
            <transactionManager type="JDBC"/>
            <!-- 数据库连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 批量mapper配置
		通过package进行自动扫描包下边的mapper接口，
		要求：需要mapper.xml和mapper.java同名并且在一个目录 中
		-->
    <mappers>
        <package name="cn.edu.buaa.fwx.dao"/>
    </mappers>
</configuration>

3.实现一对一查询：一个账户对应一个用户查询

(1)dao接口：

IAccountDao.java:

/**
 * 账户持久层接口
 */
public interface IAccountDao {
    /**
     * 查询所有账户
     * @return
     */
    List<Account> accounts();
	......
}

IUserDao.java:

/**
 * 用户持久层接口
 */
public interface IUserDao {
    /**
     * 根据用户id查询用户
     * @param id
     * @return
     */
    User findById(int id);
    ......
}
(2)xml编写：

IAccountDao.xml : 使用<association></association>标签实现一对一关系映射。根据select="cn.edu.buaa.fwx.dao.IUserDao.findById"执行IUserDao接口的findById方法。


    <!--查询所有账户及对应的用户-->
    <resultMap id="accountUserMap" type="cn.edu.buaa.fwx.domain.Account">
        <id property="id" column="ID"></id>
        <result property="uid" column="UID"></result>
        <result property="money" column="MONEY"></result>
        <!-- 一对一映射 -->
        <association property="user" column="uid" select="cn.edu.buaa.fwx.dao.IUserDao.findById"></association>
    </resultMap>
    <select id="accounts" resultMap="accountUserMap">
        SELECT ID,UID,MONEY FROM account
    </select>

IUserDao.xml：

	<!--根据Id查询用户-->
    <select id="findById" resultType="cn.edu.buaa.fwx.domain.User">
        SELECT * FROM user where id = #{id}
    </select>
(3)测试类：

所有的测试类中将加载资源和释放资源分别抽取出来使用

public class TestIAccount {

    private InputStream resourceAsStream = null;
    SqlSessionFactory sqlSessionFactory = null;
    SqlSession sqlSession = null;
    private IAccountDao iAccountDao = null;

    //初始化数据
    @Before
    public void init() throws IOException {
        resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        sqlSession = sqlSessionFactory.openSession();
        iAccountDao = sqlSession.getMapper(IAccountDao.class);
    }

    //释放资源
    @After
    public void destory() throws IOException {
        sqlSession.commit();
        sqlSession.close();
        resourceAsStream.close();
    }
}

测试方法

/**
     * 获取所有账号，并查出相对应的账号（一对一）
     */
    @Test
    public void testAccounts(){
        List<Account> accounts = iAccountDao.accounts();
        for (Account account : accounts) {
            //账户信息
            System.out.println(account);
            //对应的用户信息
            System.out.println(account.getUser());

            System.out.println("==========================");
        }
    }
(4)测试结果：

在这里插入图片描述

4.实现一对多查询：查询所有用户，并查出其关联的所有账户

(1)dao接口：

IUserDao.java：

/**
 * 用户持久层接口
 */
public interface IUserDao {

    /**
     * 查询所有用户
     * @return
     */
    List<User> users();
	......
}

IAccountDao.java：

/**
 * 账户持久层接口
 */
public interface IAccountDao {

    /**
     * 根据账户id查询账户
     * @param id
     * @return
     */
    Account findById(int id);
    ......
}
(2)xml编写：

IUserDao.xml：使用<collection></collection>标签实现一对多关系映射，设置标签中fetchType="lazy"属性实现延迟加载（需要在SqlMapconfig.xml主配置文件中设置延迟加载的相关配置）。根据select="cn.edu.buaa.fwx.dao.IAccountDao.findById"执行IAccountDao接口的findById方法。

	<!--查询用户和对应的账户信息-->
    <resultMap id="userAccountMap" type="cn.edu.buaa.fwx.domain.User">
        <id property="id" column="id"></id>
        <!--一个用户对应多个账户 (一对多)-->
        <collection property="accounts" column="id" select="cn.edu.buaa.fwx.dao.IAccountDao.findById" fetchType="lazy"/>
    </resultMap>
    <select id="users" resultMap="userAccountMap">
        SELECT * FROM user
    </select>

IAccountDao.xml：

	<!--根据id查询账户-->
    <select id="findById" resultType="cn.edu.buaa.fwx.domain.Account">
        SELECT * from account where uid = #{uid}
    </select>
(3)测试类：
/**
     * 查询所有用户，并查出其关联的所有账户（一对多）
     */
    @Test
    public void userAccountTest(){
        List<User> users = iUserDao.users();
        for (User user : users) {
            System.out.println(user);
            System.out.println("-------- 延迟加载下面数据 --------");
            System.out.println(user.getAccounts());
            System.out.println("=================================");
        }
    }
(4)测试结果：

未实现延迟加载的效果：
在这里插入图片描述
实现延迟加载的效果：图中在-------- 延迟加载下面数据 --------下面才执行了对account表的查询sql，说明以实现延迟加载数据的效果。
在这里插入图片描述

5.实现多对多查询：

因为用户到角色是一对多，角色到用户也是一对多，所以用户和角色的关系是多对多

这里用用户关联查询角色举例：

(1)dao接口：

IUserDao.java：

/**
 * 用户持久层接口
 */
public interface IUserDao {

    /**
     * 查询所有用户
     * @return
     */
    List<User> users();
}

IRoleDao.java：

/**
 * 用户角色持久层接口
 */
public interface IRoleDao {

    /**
     * 根据角色rid查询角色
     * @param uid
     * @return
     */
    Role findByUid(int uid);
}
(2)xml编写：

IUserDao.xml：

	<!--查询用户和对应的角色信息-->
    <resultMap id="userAccountMap" type="cn.edu.buaa.fwx.domain.User">
        <id property="id" column="id"></id>
        <!--一个用户可以用户多个角色（一对多）-->
        <collection property="roles" column="id" select="cn.edu.buaa.fwx.dao.IRoleDao.findByUid" fetchType="lazy"/>
    </resultMap>
    <select id="users" resultMap="userAccountMap">
        SELECT * FROM user
    </select>

IRoleDao.xml：

	<!--Role字段映射-->
    <resultMap id="userRoleMap" type="cn.edu.buaa.fwx.domain.Role">
        <id property="roleId" column="ID"></id>
        <result property="roleName" column="ROLE_NAME"></result>
        <result property="roleDesc" column="ROLE_DESC"></result>
    </resultMap>
    <!--根据用户id查询角色信息（多表查询）-->
    <select id="findByUid" parameterType="int" resultMap="userRoleMap">
        SELECT * FROM role r LEFT JOIN user_role ur ON r.ID = ur.RID WHERE ur.UID = #{uid}
    </select>
(3)测试类：
/**
     * 查询所有用户，并查出其关联的所有角色（多对多）
     */
    @Test
    public void userRoleTest(){
        List<User> users = iUserDao.users();
        for (User user : users) {
            System.out.println(user);
            System.out.println("-------- 延迟加载下面数据 --------");
            System.out.println(user.getRoles());
            System.out.println("=================================");
        }
    }
(4)测试结果：

在这里插入图片描述

四、注解方式实现（一对一、一对多、多对多）

1.使用maven构建项目

项目结构：
只需要主配置xml文件（SqlMapConfig.xml）,不用再创建对应的Mapper.xml。 pom.xml、SqlMapConfig.xml文件的配置和xml方式一样。
在这里插入图片描述

2.实现一对一查询：一个账户对应一个用户查询

(1)dao接口：

不用再创建对应的Mapper.xml。
IAccountDao.java：实现一对一需在Results标签中配置one = @One(select = "cn.edu.buaa.fwx.dao.IUserDao.findById"）

/**
 * 账户持久层接口
 */
public interface IAccountDao {

    /**
     * 查询所有账户
     * @return
     */
    @Select("SELECT * FROM account")
    @Results(id = "accountUser",
            value = {
            //注意：因为这里account中的user属性也需要映射UID，所以必须将uid（@Result(property = "uid",column = "uid")）的映射写上，不然查出来account信息中的uid为null
            @Result(property = "uid",column = "uid"),
            @Result(property = "user",column = "uid",one = @One(select = "cn.edu.buaa.fwx.dao.IUserDao.findById"))
    })
    List<Account> accounts();
    ......
}

IUserDao.java：

/**
 * 用户持久层接口
 */
public interface IUserDao {
    /**
     * 根据用户id查询用户
     * @param id
     * @return
     */
    @Select("SELECT * FROM user where id = #{id}")
    User findById(int id);
}
(2)测试类：
/**
     * 获取所有账号，并查出相对应的账号（一对一）
     */
    @Test
    public void testAccounts(){
        List<Account> accounts = iAccountDao.accounts();
        for (Account account : accounts) {
            //账户信息
            System.out.println(account);
            System.out.println("----------------");
            //对应的用户信息
            System.out.println(account.getUser());

            System.out.println("==========================");
        }
    }
(3)测试结果：

在这里插入图片描述

3.实现一对多查询：查询所有用户，并查出其关联的所有账户

(1)dao接口：

IUserDao.java：实现一对多需在Results标签中配置many = @Many(select = "cn.edu.buaa.fwx.dao.IAccountDao.findById"）

/**
 * 用户持久层接口
 */
public interface IUserDao {

    /**
     * 查询所有用户
     * @return
     */
    @Select("SELECT * FROM user")
    @Results(id="users",value = {
            @Result(property = "id",column = "id"),
            //延迟加载账户数据
            @Result(property = "accounts",column = "id",many = @Many(select = "cn.edu.buaa.fwx.dao.IAccountDao.findById",fetchType = FetchType.LAZY))
    })
    List<User> users();
    ......
}

IAccountDao.java：

/**
 * 账户持久层接口
 */
public interface IAccountDao {
    /**
     * 根据账户id查询账户
     * @param id
     * @return
     */
    @Select("SELECT * from account where uid = #{uid}")
    Account findById(int id);
	......
}
(2)测试类：
    /**
     * 查询所有用户，并查出其关联的所有账户(一对多)
     */
    @Test
    public void userAccountTest(){
        List<User> users = iUserDao.users();
        for (User user : users) {
            System.out.println(user);
            System.out.println("-------- 延迟加载下面数据 --------");
            System.out.println(user.getAccounts());
            System.out.println("=================================");
        }
    }
(3)测试结果：

在这里插入图片描述

5.实现多对多查询：

这里还是使用用户到用户角色一对多举例

(1)dao接口：

IUserDao.java：

/**
 * 用户持久层接口
 */
public interface IUserDao {

    /**
     * 查询所有用户
     * @return
     */
    @Select("SELECT * FROM user")
    @Results(id="users",value = {
            @Result(property = "id",column = "id"),
            //延迟加载角色数据
            @Result(property = "roles",column = "id",many = @Many(select = "cn.edu.buaa.fwx.dao.IRoleDao.findByUid",fetchType = FetchType.LAZY))
    })
    List<User> users();
}

IRoleDao.java：

/**
 * 用户角色持久层接口
 */
public interface IRoleDao {
    /**
     * 根据角色rid查询角色
     * @param uid
     * @return
     */
    @Select("SELECT * FROM role r LEFT JOIN user_role ur ON r.ID = ur.RID WHERE ur.UID = #{UID}")
    @Results(id = "userRoleMap",value = {
            @Result(id = true,property = "roleId",column = "ID"),
            @Result(property = "roleName",column = "ROLE_NAME"),
            @Result(property = "roleDesc",column = "ROLE_DESC")
    })
    Role findByUid(int uid);
    ......
}
(2)测试类：
/**
     * 查询所有用户，并查出其关联的所有角色(多对多)
     */
    @Test
    public void userRoleTest(){
        List<User> users = iUserDao.users();
        for (User user : users) {
            System.out.println(user);
            System.out.println("-------- 延迟加载下面数据 --------");
            System.out.println(user.getRoles());
            System.out.println("=================================");
        }
    }
(3)测试结果：

在这里插入图片描述

fwx0309
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mybatis基于xml的一对一、一对多、多对多嵌套结果查询和嵌套查询
weixin_45803046的博客
12-22 5602
说在前面 MyBatis在映射文件中加载关联关系对象主要通过两种方式: 嵌套查询和嵌套结果。 嵌套查询: 是指通过执行另外一条SQL映射语句来返回预期的复杂类型。 会执行多条sql语句 嵌套结果查询： 是使用嵌套结果映射来处理重复的联合结果的子集。 只会执行一条复杂的sql语句 简单来说： 嵌套查询是多条sql语句分开写并配置 嵌套结果是一条sql语句关联查询并配置 实质效果是一样的。 但嵌套查询会导致数据库访问次数不定，进而有可能影响到性能。 一对一查询 举例：人和身份证是一一对应的，满足一对一查询
mybatis递归 一对多的实现方法示例
08-27
MyBatis递归实现一对多查询示例 MyBatis是一款流行的持久层框架，用于简化Java应用程序中的数据库交互。...通过使用ResultMap和Mapper.xml文件，我们可以轻松地实现递归查询一对多关系，简化了数据库交互的复杂度。
Mybatis高级映射结果集---注解---（一对多，多对一）
大表哥
11-24 1万+
理论的知识我就不说了 官方文档 http://www.mybatis.org/mybatis-3/zh/ 直接来案例 多个学生存在一个班级 ====》多对一 一个班级存在多个学生====》一对多 先在数据库中创建一个学生表 一个班级表  班级表中的主键是学生表中的外键 创建学生表的实例 package cn.easytop.lesson03.re
Mybatis的多表连接操作，一对一、一对多、多对多(1)
最新发布
2401_84010030的博客
04-19 618
如下图所示：以人（person）表和护照表（passport）所示：Entity：实体 ，在实体中要定义另一个实体类的属性如下图所示：Mapper.xml文件级联查询要用到resultMap封装查询结果。如此，这样就完成了一对多的查询。一对多：1:n 关系双方的数据，其中一方的一个数据要对应另外一方的多个数据，比如说 一个用户多个订单。Table：一对多表间的关系，
Mybatis plus 学习使用（增删改查，多对多 ，分页 ，如何存储枚举数组）
-wrath-的博客
05-07 998
Mybatis plus 学习使用（增删改查，一对多，多对多 ，分页 ，如何存储枚举数组）Mybatis plus 学习使用增删改查多对多的情况查找分页如何存储枚举数组 Mybatis plus 学习使用 最近想把自己的博客mybatis换成plus ,应为基本的增删改查，每次写好麻烦，这边先记录一下，修改的过程，数据结构不是最终的情况的情况。 增删改查 这个是很基本的，官方的文档都有，我这边也满...
MybatisPlus注解多种方式实现一对一、一对多查询、增删改
qq_54429571的博客
10-22 3249
MybatisPlus注解多种方式实现一对一、一对多查询、增删改详解。
Mybatis-Plus用纯注解搞定一对多查询
ch98000的博客
09-08 3454
业务中很常见的就属于典型的一对多关系. 假设我们需要将用户信息（包括了用户对应的角色信息）查询出来。
Mybatis 中的一对一,一对多,多对多的配置原则示例代码
08-31
Mybatis 中的一对一、一对多、多对多的配置原则示例代码 MyBatis 是支持定制化 ...MyBatis 中的一对一、一对多、多对多的配置原则示例代码是非常重要的，它们可以帮助我们更好地了解 MyBatis 的配置原则和使用方法。
用MyBatis实现表的一对多关联查询
12-05
总结来说，使用MyBatis实现表的一对多关联查询，主要包括配置映射文件、数据库设计、编写SQL映射、实现Service和DAO层。这个过程使得我们可以方便地获取到父表和子表的关联数据，大大提高了开发效率。在实际项目中，...
Mybatis基于注解实现多表查询功能
08-25
3. 使用One和Many注解：在配置多表查询时，我们可以使用One和Many注解来配置一对一和一对多的关系。例如，在Account实体类中，我们可以使用@Result注解来配置用户查询的方式。 4. 实现多表查询：最后，我们可以使用...
mybatis一对多性能优化demo
08-02
在`mybatis-config.xml`或Mapper XML文件中，我们通常会定义`<association>`标签来描述一对一的关系，而对于一对多关系，我们可以使用`<collection>`标签。例如： ```xml ``` 这里，User类有一对多...
使用注解来绑定MybatisPlus的关联查询
zhuyunlong2018的博客
05-15 992
注解形式来绑定MybatisPlus关联查询
mybatis-plus关联查询，一对一、一对多。
热门推荐
microcosm1994的博客
07-20 2万+
mybatis-plus没有提供关联查询的crud接口，所以本质上还是使用mybatis方法。 一对一 商品表中的classify_id关联商品分类表中的id 返回商品列表数据时数据内包含商品分类信息 service /** * 获取商品列表 * * @param form */ @Override public Result goodsList(GoodsDto form) { Page page = new Page().
Mybatis注解开发：使用注解实现一对一、一对多、多对多查询
丿涛哥哥的博客
05-24 1万+
Mybatis注解开发：使用注解实现一对一、一对多、多对多查询 1、 MyBatis的常用注解 这几年来注解开发越来越流行，Mybatis也可以使用注解开发方式，这样我们就可以减少编写Mapper 映射文件了。我们先围绕一些基本的CRUD来学习，再学习复杂映射多表操作。 @Insert：实现新增 @Update：实现更新 @Delete：实现删除 @Select：实现查询 @Result：实现结果集封装 @Results：可以与@Result 一起使用，封装多个结果集 @One：实现一对一结果集封装 @Ma
MyBatis一对多关联查询XMl配置写法
HaHa_Sir的博客
03-03 5496
MyBatis一对多关联查询XMl配置写法 一、情景概述 1、有一张客户表 Client ，存储客户信息， 姓名 name ，年龄 age等。 2、有一张客户附件表 client_file ,存储客户附件信息，附件名 name ，路径 path 等，其中通过外键 client_id 关联到 client表，获取附件对应的...
【MyBatis】映射一对多和多对多关系配置（看完这篇不吃亏）
无法自律的人的博客
08-27 4046
resultMap 允许我们定义复杂的映射规则，将结果集中的多个字段映射到一个对象中。因为我们是一对多的所以我们再编写vo类的时候，里面是使用list集合。建立我们给的sql文件，运行它用这里面的表，让我们更好的示例操作。在我们的配置文件里面配置我们需要的几个表，自动生成所需文件。当然我们要先建立这个包里面的类才能更好的下一步。在原本的基础的sql上我们增加一个一对多的sql。在上面我们已经写好了sql，我们生成对应的。在我们的里面添加一个sql的方法编写。在生成的接口类里面编写对应的接口方法。
Mybatis基于XML方式的一对多、多对一关系映射（下）
weixin_46002478的博客
09-12 588
前言 许多人对Myabtis持久层框架的一对多、多对一映射很模糊，本篇幅将通讲一下它们的映射关系。对谁就以谁为中心，例如：一对多中，对多，那么就是部门对员工，多对一，对一个，就是多个员工对一个部门。 数据库设计 其中d_id为外键，连接部门表dept_id。 多对一 示例：多个员工对应一个部门，且每个员工隶属一个部门。 站在员工角度而言，其就是一个典型的多对一关系 员工Bean(Employee) package com.mybatis.bean; /** * @author Superb *
java一对多xml_Mybatis关联查询之一对多和多对一XML配置详解
weixin_39622289的博客
03-03 459
平时在开发过程中dao、bean和XML文件都是自动生成的，很少写XML的配置关系，今天记录一下mybatis的关联查询中的多对一和一对多的情况。首先是有两张表(学生表Student和老师Teacher表，注：这里只是为了演示一对多和多对一的情况，请不要杠)，为了更易懂，这里只设置了最简单的几个必要字段。表结构如下图Student表：Teacher表：创建实体beanTeacher.java:im...
xml配置文件实现 数据表的一对一 一对多 多对多查询
csweettea的博客
03-12 2937
xml文件配置：一对一、一对多与多对多查询一、一对一查询(1)建立orders表与user表(2)OrderMapper接口(3)OrderMapper.xml文件配置(4)测试结果二、一对多查询(1)建表(2)User类与UserMapper接口(3)UserMapper.xml文件配置(4)测试结果三、多对多查询(1)建表(2)User实体与UserMapper接口(3)UserMapper.xml接口配置(4)测试结果 一、一对一查询   使用<resultMap>实现，使用一个订单Ord

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值