Hibernate框架-1对1关联

最新推荐文章于 2022-09-25 21:02:11 发布
最新推荐文章于 2022-09-25 21:02:11 发布
阅读量521 收藏
点赞数
分类专栏： Java hibernate javaee 文章标签： hibernate java javaee
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mass_Effect/article/details/72853927
版权
Java 同时被 3 个专栏收录
13 篇文章 0 订阅
订阅专栏
hibernate
7 篇文章 0 订阅
订阅专栏
javaee
5 篇文章 0 订阅
订阅专栏
这篇博客详细介绍了Hibernate框架中的单向和双向1对1关联，包括基于外键和联合主键的情况。通过Annotation和XML两种方式进行配置，涵盖了无连接表和有连接表的场景，并提供了相应的实体类和XML映射文件示例。
摘要由CSDN通过智能技术生成

Hibernate单向1-1关联

对于单向的1-1关联，需要在实体类中增加相对应关联实体的属性(关联实体对象)

基于外键的单向1-1关联

Annotation方式
无连接表的单向1-1关联

首先使用@OneToOne注解代表关联实体的属性，再使用@JoinColumn映射外键即可
例：Husband类中设置了对应的Wife类对象，并为之增加@OneToOne和@JoinColumn注解，其中unique=true保证了wife_id字段的唯一性

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.OneToOne;

/**
 * @author msidolphin
 * @time   2017年6月3日
 */
@Entity
public class Husband {

    private int id;
    private String name;
    private Wife wife;

    @Id
    @GeneratedValue
    public int getId() {
        return id;
    }

    @Column(length = 50)
    public String getName() {
        return name;
    }

    @OneToOne
    @JoinColumn(name="wife_id", unique=true) 
    public Wife getWife() {
        return wife;
    }

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

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

    public void setWife(Wife wife) {
        this.wife = wife;
    }
}

由于是单向1-1，所有Wife类中没有设置Husband对象

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

/**
 * @author msidolphin
 * @time   2017年6月3日
 */
@Entity
public class Wife {

    private int id;
    private String name;

    @Id
    @GeneratedValue
    public int getId() {
        return id;
    }

    @Column(length = 50)
    public String getName() {
        return name;
    }

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

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

测试类：

import org.hibernate.cfg.Configuration;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.junit.Test;

/**
 * @author msidolphin
 * @time   2017年6月3日
 */
public class DomainJunit {
    @Test
    public void schemaExport_() {
        new SchemaExport(new Configuration().configure()).create(false, true);
    }
}

控制台日志输出的SQL语句
这里写图片描述

有连接表的单向1-1关联

有连接表的单向1-1关联需要使用@JoinTable注解映射连接表，由于是1-1关联，因此需要为@JoinTable注解中的joinColumns属性映射的外键字段设置unique=true属性，以此保证严格的1-1关联
Husband类：

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.OneToOne;

/**
 * @author msidolphin
 * @time   2017年6月3日
 */
@Entity
public class Husband {

    private int id;
    private String name;
    private Wife wife;

    @Id
    @GeneratedValue
    public int getId() {
        return id;
    }
    @Column(length = 50)
    public String getName() {
        return name;
    }
    @OneToOne
    @JoinColumn(name="wife_id", unique=true) 
    @JoinTable(
            name="husband_wife", //表名
            joinColumns=@JoinColumn(
                    name="husband_id", 
                    unique=true, 
                    referencedColumnName="id"
            ),
            inverseJoinColumns=@JoinColumn(
                    name="wife_id",
                    unique=true,
                    referencedColumnName="id"
            )
    )
    public Wife getWife() {
        return wife;
    }

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

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

    public void setWife(Wife wife) {
        this.wife = wife;
    }
}

Wife类无需改动，同上

控制台输出的sql语句:
这里写图片描述

XML方式

使用<many-to-one>标签设置关联实体属性，由于是1-1，所以unique属性要设置为true
husband.hbm.xml文件

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="pers.msidolphin.hibernate.one2one">
    <class name="Husband" table="husband">
        <id name="id" column="id">
            <generator class="native"></generator>
        </id>
        <property name="name" column="name" length="50"/>
        <many-to-one name="wife" column="wife_id" unique="true"></many-to-one>
    </class>
</hibernate-mapping>

wife.hbm.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="pers.msidolphin.hibernate.one2one">
    <class name="Wife" table="wife">
        <id name="id" column="id">
            <generator class="native"></generator>
        </id>
        <property name="name" column="name" length="50"></property>
    </class>
</hibernate-mapping>

Hibernate双向1-1关联

双向1-1关联需要在两个实体类中都增加引用关联实体的属性

基于外键的双向1-1关联

Annotation方式
无连接表的双向1-1关联

两端都需要为关联实体属性增加@OneToOne注解，对于基于外键的双向1-1关联，外键可以存放在任意一端，存放外键的一端，需要增加@JoinColumn注解映射外键字段，当选择一方增加外键后，该表即变为从表，而另一张表则为主表，主表对应的实体使用@OneToOne注解时，应增加mappedBy属性，表示该表作为主表使用，不增加对应从表的外键(这么做是为了防止修改从表时需要更新对应的主表字段，导致生成额外的update语句，引起性能下降)
例:
Husband类：husband表作为主表

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;

/**
 * @author msidolphin
 * @time   2017年6月3日
 */
@Entity
public class Husband {

    private int id;
    private String name;
    private Wife wife;

    @Id
    @GeneratedValue
    public int getId() {
        return id;
    }

    @Column(length = 50)
    public String getName() {
        return name;
    }

    @OneToOne(mappedBy="husband")
    public Wife getWife() {
        return wife;
    }
    public void setId(int id) {
        this.id = id;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setWife(Wife wife) {
        this.wife = wife;
    }
}

Wife类:

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;

/**
 * @author msidolphin
 * @time   2017年6月3日
 */
@Entity
public class Wife {

    private int id;
    private String name;
    private Husband husband;

    @Id
    @GeneratedValue
    public int getId() {
        return id;
    }

    @Column(length = 50)
    public String getName() {
        return name;
    }

    @OneToOne
    @JoinColumn(
            name="husband_id", 
            unique=true
    ) 
    public Husband getHusband() {
        return husband;
    }

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

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

    public void setHusband(Husband husband) {
        this.husband = husband;
    }
}

结果：
这里写图片描述

有连接表的双向1-1关联

有连接表的双向1-1关联需要在两端都使用@JoinTable映射连接表，在映射连接表时，两端指定的连接表的表名应当相同，字段名当然也要一致
Husband类：

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.OneToOne;

/**
 * @author msidolphin
 * @time   2017年6月3日
 */
@Entity
public class Husband {

    private int id;
    private String name;
    private Wife wife;

    @Id
    @GeneratedValue
    public int getId() {
        return id;
    }

    @Column(length = 50)
    public String getName() {
        return name;
    }

    @OneToOne
    @JoinTable(
            name="husband_wife", //表名
            joinColumns=@JoinColumn(
                    name="husband_id", 
                    unique=true, 
                    referencedColumnName="id"
            ),
            inverseJoinColumns=@JoinColumn(
                    name="wife_id",
                    unique=true,
                    referencedColumnName="id"
            )
    )
    public Wife getWife() {
        return wife;
    }

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

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

    public void setWife(Wife wife) {
        this.wife = wife;
    }
}

Wife类：

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.OneToOne;

/**
 * @author msidolphin
 * @time   2017年6月3日
 */
@Entity
public class Wife {

    private int id;
    private String name;
    private Husband husband;

    @Id
    @GeneratedValue
    public int getId() {
        return id;
    }

    @Column(length = 50)
    public String getName() {
        return name;
    }

    @OneToOne
    @JoinTable(
            name="husband_wife", //表名
            joinColumns=@JoinColumn(
                    name="wife_id", 
                    unique=true, 
                    referencedColumnName="id"
            ),
            inverseJoinColumns=@JoinColumn(
                    name="husband_id",
                    unique=true,
                    referencedColumnName="id"
            )
    )
    public Husband getHusband() {
        return husband;
    }

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

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

    public void setHusband(Husband husband) {
        this.husband = husband;
    }
}

结果：
这里写图片描述

XML方式

husband.hbm.xml文件

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="pers.msidolphin.hibernate.one2one">
    <class name="Husband" table="husband">
        <id name="id" column="id">
            <generator class="native"></generator>
        </id>
        <property name="name" column="name" length="50"/>
        <many-to-one name="wife" column="wife_id" unique="true"></many-to-one>
    </class>
</hibernate-mapping>

wife.hbm.xml文件
注：这里使用的是<one-to-one>标签，如果使用<many-to-one>标签，则在两张表中都会生成外键字段

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="pers.msidolphin.hibernate.one2one">
    <class name="Wife" table="wife">
        <id name="id" column="id">
            <generator class="native"></generator>
        </id>
        <property name="name" column="name" length="50"></property>
        <one-to-one name="husband"></one-to-one>
    </class>
</hibernate-mapping>

Hibernate联合主键关联

Annotation方式

Wife类：id和name字段作为联合主键

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;


/**
 * @author msidolphin
 * @time   2017年6月3日
 */
@Entity
public class Wife implements Serializable{

    private static final long serialVersionUID = 1L;

    private int id;
    private String name;

    @Id
    public int getId() {
        return id;
    }

    @Id
    @Column(length = 50)
    public String getName() {
        return name;
    }

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

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

    @Override
    public boolean equals(Object obj) {
        if(obj == null) {
            return false;
        }

        if(obj instanceof Wife) {
            Wife pk = (Wife) obj;
            if(this.id == pk.getId() && this.name.equals(pk.getName())) {
                return true;
            }
            return false;
        }
        return false;
    }

    @Override
    public int hashCode() {
        return this.name.hashCode();
    }
}

Husband类:

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinColumns;
import javax.persistence.OneToOne;

/**
 * @author msidolphin
 * @time   2017年6月3日
 */
@Entity
public class Husband {

    private int id;
    private String name;
    private Wife wife;

    @Id
    @GeneratedValue
    public int getId() {
        return id;
    }

    @Column(length = 50)
    public String getName() {
        return name;
    }

    @OneToOne
    @JoinColumns({
        @JoinColumn(name="wife_id", referencedColumnName="id", unique=true),
        @JoinColumn(name="wife_name", referencedColumnName="name", unique=true)
    })
    public Wife getWife() {
        return wife;
    }

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

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

    public void setWife(Wife wife) {
        this.wife = wife;
    }
}

控制台打印的SQL建表语句:
这里写图片描述

XML方式

主键类: Wife表的id和name字段作为联合主键

import java.io.Serializable;

/**
 * @author msidolphin
 * @time   2017年6月3日
 */

public class WifePk implements Serializable{

    private static final long serialVersionUID = 1L;

    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

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

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

    @Override
    public boolean equals(Object obj) {
        if(obj == null) {
            return false;
        }

        if(obj instanceof WifePk) {
            WifePk pk = (WifePk) obj;
            if(this.id == pk.getId() && this.name.equals(pk.getName())) {
                return true;
            }
            return false;
        }
        return false;
    }

    @Override
    public int hashCode() {
        return this.name.hashCode();
    }

}

Wife类:

/**
 * @author msidolphin
 * @time   2017年6月3日
 */
public class Wife {

    private WifePk pk;

    public WifePk getPk() {
        return pk;
    }

    public void setPk(WifePk pk) {
        this.pk = pk;
    }
}

Husband类:

/**
 * @author msidolphin
 * @time   2017年6月3日
 */
public class Husband {

    private int id;
    private String name;
    private Wife wife;

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public Wife getWife() {
        return wife;
    }

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

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

    public void setWife(Wife wife) {
        this.wife = wife;
    }
}

wife.hbm.xml文件，由于使用了联合主键，所以应该使用<composite-id>标签

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="pers.msidolphin.hibernate.one2one">
    <class name="Wife" table="wife">
        <composite-id name="pk" class="pers.msidolphin.hibernate.one2one.WifePk">
            <key-property name="id"></key-property>
            <key-property name="name" length="50"></key-property>
        </composite-id>
    </class>
</hibernate-mapping>

husband.hbm.xml文件

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="pers.msidolphin.hibernate.one2one">
    <class name="Husband" table="husband">
        <id name="id" column="id">
            <generator class="native"></generator>
        </id>
        <property name="name" column="name" length="50"/>
        <many-to-one name="wife">
            <!-- 要格外注意顺序 -->
            <column name="wife_id" unique="true"></column>  
            <column name="wife_name"  unique="true"></column>   
        </many-to-one>
    </class>
</hibernate-mapping>

控制台打印的SQL建表语句:
这里写图片描述

msidolphin
关注
专栏目录
Hibernate框架-多对一和一对多关联
msidolphin的博客
06-06 1071
不管是双向还是单向关联，数据库表的设计是一样的，一般都是在N的一方增加外键(如果在1的一方增加外键势必会造成冗余)单向N-1关联以Group和User为例，一个Group可以有多个User，一个User只能对应一个Group，典型的一对多(多对一)的案列 Annotation方式对于N-1关联(无论单向还是双向)，都需要在N的一方给关联属性加上@ManyToOne注解 @ManyToOne注解有
Hibernate1对多1对1多对多关联映射例子源码含xml配置
11-05
在hibernate中，通常配置对象关系映射关系有两种，一种是基于xml的方式，另一种是基于annotation的注解方式，熟话说，萝卜青菜，可有所爱，每个人都有自己喜欢的配置方式，这个是xml配置的例子
Hibernate框架之一对一关系的处理（Demo演示）
hestyle的博客
11-24 184
在上一篇博客 Hibernate框架之一对多关系处理（Demo演示）、Hibernate框架之多对多关系处理（Demo演示） 分别演示了hibernate如何处理一对多、多对多的关系，在此篇博客将在hibernate框架下演示公司、地址一对一关系的处理。 一、Demo编写 1、公司与地址之间的一对一关系 2、公司、地址模型 Address类 package cn.hestyle.model; ...
模型生成过程中检测到一个或多个验证错误
Martin 的博客
07-13 2563
模型生成过程中检测到一个或多个验证错误:Tenant_CompanyLocation_Target: : 关系“Tenant_CompanyLocation”中 Role“Tenant_CompanyLocation_Target”的多重性无效。因为 Dependent Role 属性不是键属性，Dependent Role 多重性的上限必须为“*”。Tenant_Currency_Target:...
Hibernate框架
weixin_43979868的博客
03-11 1539
Hibernate 轻量级、持久层、ORM，Hibernate 是一款全自动的 ORM 框架。 ORM ORM 是一种自动生成 SQL 语句的技术，它可以将对象中的数据自动存储到数据库中，也可以反过来将数据库中的数据自动提取到对象中，整个过程不需要人工干预，避免了手写 SQL 带来的麻烦 Object：对象 Relation：关系型数据库 Mapping：映射 Hibernate与MyBatis的比较 缓存机制 Hibernate 提供了缓存机制（一级缓存、二级缓存、查询缓存），我们可以将那些经常使用的
学习Hibernate框架--框架搭建及简单使用
Ricartc的编程梦
10-30 2511
在学习Hibernate框架之前首先来了解一下什么是Hibernate框架以及为什么要使用它 Hibernate是 一个开源的对象关系映射框架 对JDBC进行了非常轻量级的对象封装 将JacaBean对象和数据库的表建立对应关系 它是一个优秀的Java持久化层解决方案 是当今主流的对象——关系映射工具 它简化了JDBC繁琐的编码，将数据库的连接信息都放置在配置文件中 来...
Hibernate框架之关联关系(many-to-one)
Javen天道酬勤
12-22 2012
今天天气终于放晴了，心情也会好一些。年前这段时间，打算多写点文章，将自己的东西记录下来，算是一种沉淀吧。目前写的东西都是偏基础，也是计划从基础开始写起，后面再慢慢去扩充。 这篇文章打算记录一下Hibernate实现关联关系的操作。上一篇文章介绍了Hibernate的基本使用。 在实际项目开发中，不可能永远都是在一张表上进行操作，比如一本书只有一个作者，但是一个作者可以有多本书，相对于书而言，就
如何在IDEA中使用Hibernate框架
SmallSweets的博客
03-03 4485
在eclipse和idea中使用hibernate框架是有所不同的，记录一下如何在idea中使用hibernate框架 在eclipse中使用hibernate框架请参考：如何在Eclipse中使用Hibernate框架 在idea中使用hibernate框架的步骤： 1.创建数据库和表 2.创建项目 3.连接数据库 4.自动生成核心配置文件，实体类以及实体类映射文件 5.访问数据库 1.创建数据库和表 创建数据库hibernate，在数据库中创建表User，表结构如下： 2.创建项目 为了方便导入hib
Hibernate框架2022年篇详解
SYJ的博客
09-25 1792
主流ORM框架Object Relation Mapper对象映射，将面向对象映射成面向关系
Hibernate ORM - 一对多双向关联关系
03-28
标题“Hibernate ORM - 一对多双向关联关系”指的是在数据库建模中，Hibernate ORM（对象关系映射）框架如何处理一个实体类（如User）与多个实体类（如Article）之间的关系。在这种关系中，一个用户可以拥有多个文章...
Hibernate ORM - 一对一连接表关联关系
03-28
标题"Hibernate ORM - 一对一连接表关联关系" 提示我们，这里主要讨论的是Hibernate ORM框架在处理数据库中一对一（One-to-One）关联映射的方法。Hibernate是一个流行的Java对象关系映射（ORM）工具，它允许开发者用...
Hibernate ORM - 一对一主键关联关系
03-28
Hibernate ORM 是一个强大的Java对象关系映射（ORM）框架，它允许开发者将数据库操作与Java对象模型紧密结合，简化了数据库应用程序的开发。在一对一（One-to-One）主键关联关系中，两个实体类之间存在唯一对应的...
Hibernate ORM - 多对多双向连接表关联关系
03-28
这有助于提高对Hibernate框架的理解。 通过以上步骤，我们可以在Hibernate中建立并管理多对多双向连接表的关联关系。在实际开发中，熟练掌握这种关联方式可以有效提升代码的可读性和可维护性，同时充分利用ORM框架...
hibernate--关系映射归纳和总结
nupt_Wang的专栏
12-31 1463
前言： hibernate关系映射十分重要，对于掌握hibernate是必备的知识，关系映射分为一对一 一对多 多对一 多对多  看起来关系关系复杂，但其实了解其中原理就可以灵活自如运用。 在了解详细分类之前，有一些点和关键系必须掌握其意义： cascade关键词：表示级联包括add update delete 一般情况不使用 不好。 作用：一般在保存对象时 需要先显
JavaEE--------Hibernate框架
詹煜彪9527
03-21 5009
一. Hibernate 概述 Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也...
Hibernate框架-@TableGenerator注解
msidolphin的博客
05-30 1425
主键的值以查询的形式从一个特定的表中获取，获取完之后修改主键值，理论上可以兼容任何数据库。 要配合@GeneratedValue注解—— 注解声明了主键的生成策略。有如下属性：
使用fileupload组件实现文件上传
msidolphin的博客
05-19 1083
Apache开源组织提供了一个用来处理表单文件上传的一个开源组件(Commons-fileupload)，该组件性能优异，并且使用及其简单，可以让开发人员轻松实现web文件上传功能。
C3P0数据库连接池的基本使用
msidolphin的博客
05-14 1081
c3p0数据库连接池需要c3p0.jar 和 mchange-commons-java.jar的支持 今天学习到的c3p0的配置方式有三种： 1、通过ComboPooledDataSource对象提供的一系列setter方法配置 2、通过c3p0-config.xml文件进行配置 3、通过c3p0.properties文件进行配置先介绍第一种最繁琐的方式：setterpackage pers
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值