Hibernate Annotation 基于外键的单向一对多关联

最新推荐文章于 2024-11-04 22:26:34 发布
最新推荐文章于 2024-11-04 22:26:34 发布
阅读量85 收藏
点赞数
分类专栏： Hibernate 文章标签： java 数据库 开发工具
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/paladin1988/article/details/84274591
版权


基于外键关联的单向一对多关联是一种很少见的情况，并不推荐使用。
基于连接表的单向一对多关联 应该优先被采用。请注意，通过指定unique="true"，我们可以把多样性从多对多改变为一对多。


摘自Hibernate Reference

Product与Category是多对一的关系，Product对象维护着对Category对象的参考，如果由Category对象维护对多个Product对象的管理，就是一对多单向关联。
多对一就是从Product端来看，多个产品属于一个分类，每个产品都需要维护各自的Category对象。
而一对多就是从Category端来看，一个Category下有多个分类，Category需要维护多个Product信息。

 

嘿，不好意思，各位看官，因为恢复系统把之前做的物理数据模型图弄丢了，本来打算一并附上的，现在搞不到了，呵呵。

 

 

SQL脚本：（附件中可下载）

 

-- MySQL dump 10.13  Distrib 5.1.55, for Win32 (ia32)
--
-- Host: localhost    Database: hibernate_demo
-- ------------------------------------------------------
-- Server version	5.1.55-community

/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
/*!40101 SET NAMES utf8 */;
/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
/*!40103 SET TIME_ZONE='+00:00' */;
/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;

--
-- Table structure for table `category`
--

DROP TABLE IF EXISTS `category`;
/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE `category` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(30) NOT NULL,
  `description` varchar(30) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=9 DEFAULT CHARSET=latin1;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Dumping data for table `category`
--

LOCK TABLES `category` WRITE;
/*!40000 ALTER TABLE `category` DISABLE KEYS */;
INSERT INTO `category` VALUES (1,'fruit2','fruit category2');
/*!40000 ALTER TABLE `category` ENABLE KEYS */;
UNLOCK TABLES;

--
-- Table structure for table `product`
--

DROP TABLE IF EXISTS `product`;
/*!40101 SET @saved_cs_client     = @@character_set_client */;
/*!40101 SET character_set_client = utf8 */;
CREATE TABLE `product` (
  `id` int(11) NOT NULL,
  `name` varchar(30) NOT NULL,
  `price` int(11) NOT NULL,
  `description` varchar(30) NOT NULL,
  `category_id` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `category_id` (`category_id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;
/*!40101 SET character_set_client = @saved_cs_client */;

--
-- Dumping data for table `product`
--

LOCK TABLES `product` WRITE;
/*!40000 ALTER TABLE `product` DISABLE KEYS */;
/*!40000 ALTER TABLE `product` ENABLE KEYS */;
UNLOCK TABLES;
/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;

/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;

-- Dump completed on 2012-08-16 22:20:47
 

 

//Category.java

 

package com.zyp.examples;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import javax.persistence.CascadeType;

import org.hibernate.annotations.GenericGenerator;

/**
 * Category entity. @author MyEclipse Persistence Tools
 */

@Entity
@Table(name="category")
public class Category implements java.io.Serializable {

	// Fields

	private static final long serialVersionUID = 411764056858459654L;
	
	@Id
	@GenericGenerator(name="incrementGenerator", strategy="increment")
	@GeneratedValue(generator="incrementGenerator", strategy=GenerationType.IDENTITY)
	@Column(name="id")
	private Integer id;
	
	@Column(name="name", nullable=false)
	private String name;
	
	@Column(name="description", nullable=false)
	private String description;
	
	@OneToMany(targetEntity=Product.class, cascade=CascadeType.ALL)
	@JoinColumn(name="category_id")
	private Set<Product> products = new HashSet<Product>();

	// Constructors

	/** default constructor */
	public Category() {
	}

	/** full constructor */
	public Category(String name, String description) {
		this.name = name;
		this.description = description;
	}

	// Property accessors

	public Integer getId() {
		return this.id;
	}

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

	public String getName() {
		return this.name;
	}

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

	public String getDescription() {
		return this.description;
	}

	public void setDescription(String description) {
		this.description = description;
	}

	public Set<Product> getProducts() {
		return products;
	}

	public void setProducts(Set<Product> products) {
		this.products = products;
	}
	
	

}
 

 

//Product.java

package com.zyp.examples;

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

import org.hibernate.annotations.GenericGenerator;

/**
 * Product entity. @author MyEclipse Persistence Tools
 */

@Entity
@Table(name="product")
public class Product implements java.io.Serializable {

	// Fields

	private static final long serialVersionUID = -3046977533702585304L;

	@Id
	@GenericGenerator(name="incrementGenerator", strategy="increment")
	@GeneratedValue(generator="incrementGenerator", strategy=GenerationType.IDENTITY)
	@Column(name="id")
	private Integer id;
	
	@Column(name="name", nullable=false)
	private String name;
	
	@Column(name="price", nullable=false)
	private Integer price;
	
	@Column(name="description",nullable=false)
	private String description;
	
	
	// Constructors

	/** default constructor */
	public Product() {
	}


	// Property accessors

	public Integer getId() {
		return this.id;
	}

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

	public String getName() {
		return this.name;
	}

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

	public Integer getPrice() {
		return this.price;
	}

	public void setPrice(Integer price) {
		this.price = price;
	}

	public String getDescription() {
		return this.description;
	}

	public void setDescription(String description) {
		this.description = description;
	}


}
 

 

 

//hibernate.cfg.xml

这个就不弄了，都一样

 

//HibernateUtil.java

也不弄了

 

 

//HibernateTest.java

 

package com.zyp.examples;

import java.util.HashSet;
import java.util.Set;

import org.hibernate.Session;
import org.hibernate.Transaction;

public class HibernateTest {

	public static void main(String[] args) {
		
		//同时保存分类和产品
		addAll();
		
		//根据已有分类保存产品
		//先添加分类
//		addCategory();
//		addProduct();
		
		//级联删除
//		deleteByCategory();

	}
	
	public static void deleteByCategory()
	{
		Session session = HibernateUtil.getSessionFactory().openSession();
		Transaction tx = session.beginTransaction();
		Category cat = (Category) session.load(Category.class, new Integer(1));
		session.delete(cat);

		tx.commit();
		session.close();
		HibernateUtil.shutdown();
	}
	
	public static void addAll()
	{
		Product product = new Product();
		product.setDescription("apple2");
		product.setName("apple2");
		product.setPrice(10);
		
		
		Product product1 = new Product();
		product1.setDescription("orige2");
		product1.setName("orige2");
		product1.setPrice(20);
		
		Category category = new Category();
		category.setDescription("fruit category2");
		category.setName("fruit2");
		
		
		Set<Product> products = new HashSet<Product>();
		products.add(product);
		products.add(product1);
		category.setProducts(products);
		
		Session session = HibernateUtil.getSessionFactory().openSession();
		Transaction tx = session.beginTransaction();
		session.save(category);
		//启用级联操作
//		session.save(product);
//		session.save(product1);
		tx.commit();
		session.close();
		HibernateUtil.shutdown();
		
	}
	
	public static void addCategory()
	{
		Category category = new Category();
		category.setName("fruit");
		category.setDescription("fruit category");
		
		Session session = HibernateUtil.getSessionFactory().openSession();
		Transaction tx = session.beginTransaction();
		session.save(category);
		tx.commit();
		HibernateUtil.shutdown();
	}
	
	
	public static void addProduct()
	{
		Product product = new Product();
		product.setDescription("banana");
		product.setName("banana");
		product.setPrice(10);
		
		Product product1 = new Product();
		product1.setDescription("tom");
		product1.setName("tom");
		product1.setPrice(20);		
		
		Session session = HibernateUtil.getSessionFactory().openSession();
		Transaction tx = session.beginTransaction();
		Category category = (Category)session.load(Category.class, new Integer(1));
		
		Set<Product> products = new HashSet<Product>();
		products.add(product);
		products.add(product1);
		
		category.setProducts(products);
		
		session.save(category);
		//启用级联操作
//		session.save(product);
//		session.save(product1);
		tx.commit();
		session.close();
		HibernateUtil.shutdown();
		
		
	}
}
 

 

=================== 悲剧的分界线 =========================

 

中间出了一个错误，困扰了我一个晚上，本来昨晚就应该发布这个文章的。哎，找了这么大一个互联网，就没一篇帖子给出我想要的答案，我晕，难道你们只知道双向关联，不知道单向关联么。。。。

 

仔细一想，之前的xml配置的时候貌似隐隐的出现了这样的错误，马上解决了。看起来，学习注解的时候，参考一下xml的配置还是有必要的。

 

Hibernate:
    insert
    into
        product
        (description, name, price, id)
    values
        (?, ?, ?, ?)
22:16:41,718 DEBUG AbstractBatcher:66 - Executing batch size: 2
22:16:41,718 DEBUG AbstractBatcher:418 - about to close PreparedStatement (open PreparedStatements: 1, globally: 1)
22:16:41,718 DEBUG JDBCExceptionReporter:92 - Could not execute JDBC batch update [insert into product (description, name, price, id) values (?, ?, ?, ?)]
java.sql.BatchUpdateException: Field 'category_id' doesn't have a default value
    at com.mysql.jdbc.PreparedStatement.executeBatchSerially(PreparedStatement.java:2007)
    at com.mysql.jdbc.PreparedStatement.executeBatch(PreparedStatement.java:1443)
    at org.hibernate.jdbc.BatchingBatcher.doExecuteBatch(BatchingBatcher.java:70)
    at org.hibernate.jdbc.AbstractBatcher.executeBatch(AbstractBatcher.java:268)
    at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:266)
    at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:167)
    at org.hibernate.event.def.AbstractFlushingEventListener.performExecutions(AbstractFlushingEventListener.java:321)
    at org.hibernate.event.def.DefaultFlushEventListener.onFlush(DefaultFlushEventListener.java:50)
    at org.hibernate.impl.SessionImpl.flush(SessionImpl.java:1028)
    at org.hibernate.impl.SessionImpl.managedFlush(SessionImpl.java:366)
    at org.hibernate.transaction.JDBCTransaction.commit(JDBCTransaction.java:137)
    at com.zyp.examples.HibernateTest.addAll(HibernateTest.java:67)
    at com.zyp.examples.HibernateTest.main(HibernateTest.java:14)
22:16:41,718  WARN JDBCExceptionReporter:100 - SQL Error: 1364, SQLState: HY000
22:16:41,718 ERROR JDBCExceptionReporter:101 - Field 'category_id' doesn't have a default value
22:16:41,718 ERROR AbstractFlushingEventListener:324 - Could not synchronize database state with session
org.hibernate.exception.GenericJDBCException: Could not execute JDBC batch update
    at org.hibernate.exception.SQLStateConverter.handledNonSpecificException(SQLStateConverter.java:126)
    at org.hibernate.exception.SQLStateConverter.convert(SQLStateConverter.java:114)
    at org.hibernate.exception.JDBCExceptionHelper.convert(JDBCExceptionHelper.java:66)
    at org.hibernate.jdbc.AbstractBatcher.executeBatch(AbstractBatcher.java:275)
    at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:266)
    at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:167)
    at org.hibernate.event.def.AbstractFlushingEventListener.performExecutions(AbstractFlushingEventListener.java:321)
    at org.hibernate.event.def.DefaultFlushEventListener.onFlush(DefaultFlushEventListener.java:50)
    at org.hibernate.impl.SessionImpl.flush(SessionImpl.java:1028)
    at org.hibernate.impl.SessionImpl.managedFlush(SessionImpl.java:366)
    at org.hibernate.transaction.JDBCTransaction.commit(JDBCTransaction.java:137)
    at com.zyp.examples.HibernateTest.addAll(HibernateTest.java:67)
    at com.zyp.examples.HibernateTest.main(HibernateTest.java:14)
Caused by: java.sql.BatchUpdateException: Field 'category_id' doesn't have a default value
    at com.mysql.jdbc.PreparedStatement.executeBatchSerially(PreparedStatement.java:2007)
    at com.mysql.jdbc.PreparedStatement.executeBatch(PreparedStatement.java:1443)
    at org.hibernate.jdbc.BatchingBatcher.doExecuteBatch(BatchingBatcher.java:70)
    at org.hibernate.jdbc.AbstractBatcher.executeBatch(AbstractBatcher.java:268)
    ... 9 more
Exception in thread "main" org.hibernate.exception.GenericJDBCException: Could not execute JDBC batch update
    at org.hibernate.exception.SQLStateConverter.handledNonSpecificException(SQLStateConverter.java:126)
    at org.hibernate.exception.SQLStateConverter.convert(SQLStateConverter.java:114)
    at org.hibernate.exception.JDBCExceptionHelper.convert(JDBCExceptionHelper.java:66)
    at org.hibernate.jdbc.AbstractBatcher.executeBatch(AbstractBatcher.java:275)
    at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:266)
    at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:167)
    at org.hibernate.event.def.AbstractFlushingEventListener.performExecutions(AbstractFlushingEventListener.java:321)
    at org.hibernate.event.def.DefaultFlushEventListener.onFlush(DefaultFlushEventListener.java:50)
    at org.hibernate.impl.SessionImpl.flush(SessionImpl.java:1028)
    at org.hibernate.impl.SessionImpl.managedFlush(SessionImpl.java:366)
    at org.hibernate.transaction.JDBCTransaction.commit(JDBCTransaction.java:137)
    at com.zyp.examples.HibernateTest.addAll(HibernateTest.java:67)
    at com.zyp.examples.HibernateTest.main(HibernateTest.java:14)
Caused by: java.sql.BatchUpdateException: Field 'category_id' doesn't have a default value
    at com.mysql.jdbc.PreparedStatement.executeBatchSerially(PreparedStatement.java:2007)
    at com.mysql.jdbc.PreparedStatement.executeBatch(PreparedStatement.java:1443)
    at org.hibernate.jdbc.BatchingBatcher.doExecuteBatch(BatchingBatcher.java:70)
    at org.hibernate.jdbc.AbstractBatcher.executeBatch(AbstractBatcher.java:268)
    ... 9 more

这个问题和之前的一样，都是因为外键设置了非空导致，外键是可以为空的。
为什么呢？
我们不是通过外键关联来保存Product的么，先保存category，然后保存Product，我们在保存product的时候，没有设置主键值，而是从category的id获取，而此时的product 外键要求非空，因此报错。

mysql> alter table product
    -> modify category_id int not null;

可以使用上面的语句来重现这个错误。

 

 

 

 

 

 

 

 

tomcatkitty
关注
专栏目录
Hibernate外键一对一单向和双向关联的理解
御风问情
09-23 684
Hibernate外键一对一单向和双向关联的理解
Hibernate Annotation 基于外键的单向多对一关联
04-09
本篇文章将深入探讨如何使用Hibernate Annotation来实现基于外键的单向多对一关联。 在关系型数据库中，多对一关联是一种常见的关系类型，意味着一个实体（如表）可以与另一个实体有多条记录关联，而另一个实体只能...
hibernate Annotation一对一单向外键关联
热门推荐
残缺的孤独
04-13 1万+
使用注解的方式进行设置。如下： （1）
hibernate annotation 之 一对多单向外键关联
W895972478的专栏
08-05 606
转自：hibernate annotation 之 一对多单向外键关联 假设，一个农场产出多种植物，具体的某一植物产于某一农场。  1 package net.yeah.fancydeepin.po;  2   3 import java.io.Serializable;  4 import java.util.Set;  5 import javax.persistenc
hibernate annotation 之 一对一单向外键关联
tt07406的博客
08-27 206
马士兵Hibernate -annotation 学习笔记十分详细 http://www.hongyanliren.com/2014m11/18714.html 一对一关联有三种情况： 一是关联的实体都共享同样的主键，二是其中一个实体通过外键关联到另一个实体的主键 ，三是通过关联表来保存两个实体之间的连接关系。 接下来要介绍的是，注解形式的一对一单向外键关联的情况。 环境 : JDK ...
Hibernate Annotation 一对多单向关联
gaoyw的博客
05-06 142
group里面存在一个set< User >，这是要做一个一对多的单向关联 Group类import java.util.HashSet; import java.util.Set; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.Id
Hibernate Annotation 多对一单向关联
gaoyw的博客
05-06 154
Group类import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.Id; import javax.persistence.Table; @Entity @Table(name="t_group") public class Group
035_一对一单向外键关联_annotation
yuzhouxiner7的专栏
01-12 108
星期六, 一月 09, 2016   17:59 一对一单向关联 1.a)hibernate_0700_One2One_unic_fk b)Annotation: @OneToOne@JoinColumn c)xml:&lt;many-to-one/&gt;   关系映射 对象   表与表之间的关系只有外键。     关系映射(这里讲的是对象)   关系对象的关系: ...
mysql一对一外键关联_一对一单向外键关联
weixin_30705133的博客
01-30 255
一对一单向外键关联 分为Annotation和xml方式：第一种：Annotation配置方式：丈夫和妻子 在丈夫表里面有妻子的Idpackage com.zchen.hibernate.oneTone;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence....
Hibernate Annotation 唯一外键一对一双向关联
04-09
唯一外键是指在一对一关联中，一方的主键同时也作为另一方的外键，确保两个实体共享同一个ID。这可以通过在没有`@JoinColumn`的情况下让两个实体共享相同的主键生成策略来实现。例如，使用`GenerationType.IDENTITY`...
Hibernate Annotation 基于连接表的单向一对多关联
04-09
本篇文章将详细讲解如何利用Hibernate的注解实现基于连接表的单向一对多关联。 首先，理解一对多关联：在数据库设计中，一对多关联意味着一个实体（表）可以与多个其他实体（表）相对应。例如，一个学生可以有多个...
Hibernate一对一单向外键关联 (联合主键annotation)
04-22
在单向一对一关联中，只有一个实体知道另一个实体的存在，而另一个实体并不知情。这里我们讨论的是单向外键关联，即一方实体持有了另一方的外键。 在Hibernate中，一对一关联可以通过`@OneToOne`注解来实现。这个...
Hibernate一对一单向外键关联(annotation/xml)
04-21
// 单向一对一关联 @OneToOne(mappedBy = "person") private IdentityCard identityCard; // getters and setters } @Entity public class IdentityCard { @Id @GeneratedValue(strategy = GenerationType....
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 655
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
spring循环依赖解决方式
qq_36400213的博客
11-04 802
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
【Java知识】Java基础-对象排序的实现
最新发布
wendao76的专栏
11-04 276
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
Qt自定义控件：汽车速度表
weixin_44788175的博客
11-02 422
从外到内进行绘制，初始化画布，画渐变色外圈，画刻度，写刻度文字，画指针，画扇形，画内圈渐变色，画黑色内圈，写当前值。这里难点使用正弦和余弦计算绘制刻度字。
JAVA学习-练习试用Java实现“数组排序”
weixin_69763181的博客
11-03 279
这个程序首先导入了'java.util.Arrays'和'java.util.Scanner'，然后定义了一个'main'方法。程序使用'Scanner'类来读取用户的输入，并将其分割成一个字符串数组。然后，它将字符串数组转换成整数数组，并使用'Arrays.sort'方法对整数数组进行排序。以下是一个Java程序，它使用内置的'Arrays.sort'方法对用户输入的整数数组进行排序。编写一个Java程序，对用户输入的整数数组进行排序（可以使用内置的Arrays.sort方法，也可以自己实现排序算法）。
Hibernate一对多映射配置完全指南
在处理数据库中的复杂关系时，如一对一、一对多和多对多关系，Hibernate提供了一种灵活的映射机制。本文主要讨论的是`Hibernate一对多映射配置`，这是数据库模型中常见的关系类型，一个实体（如用户）可以拥有多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值