Hibernate关系映射：一对多关联(示例)

最新推荐文章于 2022-05-04 15:05:00 发布
最新推荐文章于 2022-05-04 15:05:00 发布
阅读量466 收藏
点赞数
分类专栏： java 框架 Hibernate 代码示例 文章标签： Hibernate关系映射：一对多关联
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LYQ2332826438/article/details/81461291
版权
java 同时被 3 个专栏收录
61 篇文章 1 订阅
订阅专栏
框架
30 篇文章 0 订阅
订阅专栏
代码示例
30 篇文章 0 订阅
订阅专栏

Hibernate关系映射：一对多关联

set

name属性: 设定待映射的持久化类的属性的

inverse 属性：

  • 在hibernate中通过对 inverse 属性的来决定是由双向关联的哪一方来维护表和表之间的关系。 inverse = false 的为主动方，inverse = true 的为被动方, 由主动方负责维护关联关系。在没有设置 inverse=true 的情况下，父子两边都维护父子关系
  • 在 1-N 关系中，将 N 方设为主控方将有助于性能改善(如果要国家元首记住全国人民的名字，不是太可能，但要让全国人民知道国家元首，就容易的多)
  • 在 1-N 关系中，若将 1 方设为主控方,会额外多出 update 语句。插入数据时无法同时插入外键列，因而无法为外键列添加非空约束.

order-by 属性：

  • 如果设置了该属性, 当 Hibernate 通过 select 语句到数据库中检索集合对象时, 利用 order by 子句进行排序
  • order-by 属性中还可以加入 SQL 函数例如：图3

key

设定与所关联的持久化类对应的表的外键

  • column: 指定关联表的外键名

one-to-many

设定集合属性中所关联的持久化类

  • class: 指定关联的持久化类的类名

案例：

市区表实体类：

package com.liuyongqi.MavenHibernateDemo05.entity;

import java.io.Serializable;
/**
 * 市区表实体类(多端)
 * @author Administrator
 * @data   2018年8月6日
 * @time   下午4:36:55
 */
public class City implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 8117542325630083142L;
	private Integer cid ;						//市区编号
	private String cname ;						//市区名称
	private Integer pid ;						//省份编号
	private Province province;					//省份对象
	public City() {
		super();
		// TODO Auto-generated constructor stub
	}
	public City(String cname, Integer pid) {
		super();
		this.cname = cname;
		this.pid = pid;
	}
	public City(Integer cid, String cname, Integer pid) {
		super();
		this.cid = cid;
		this.cname = cname;
		this.pid = pid;
	}
	public Integer getCid() {
		return cid;
	}
	public void setCid(Integer cid) {
		this.cid = cid;
	}
	public String getCname() {
		return cname;
	}
	public void setCname(String cname) {
		this.cname = cname;
	}
	public Integer getPid() {
		return pid;
	}
	public void setPid(Integer pid) {
		this.pid = pid;
	}	
	public Province getProvince() {
		return province;
	}
	public void setProvince(Province province) {
		this.province = province;
	}
	@Override
	public String toString() {
		return "City [cid=" + cid + ", cname=" + cname + ", province=" + province + "]";
	}
	
	
	
	
	
	
	
	
}

省份表实体类：

package com.liuyongqi.MavenHibernateDemo05.entity;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;
/**
 * 省份表实体类(一端)
 * @author Administrator
 * @data   2018年8月6日
 * @time   下午4:35:15
 */
public class Province implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 4463486324531064401L;
	private Integer pid ;							//省份编号
	private String pname ;							//省份名称
	private Set<City> set=new HashSet<City>();		//城市集合
	public Province() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Province(String pname) {
		super();
		this.pname = pname;
	}
	public Province(Integer pid, String pname) {
		super();
		this.pid = pid;
		this.pname = pname;
	}
	public Integer getPid() {
		return pid;
	}
	public void setPid(Integer pid) {
		this.pid = pid;
	}
	public String getPname() {
		return pname;
	}
	public void setPname(String pname) {
		this.pname = pname;
	}
	
	public Set<City> getSet() {
		return set;
	}
	public void setSet(Set<City> set) {
		this.set = set;
	}
	@Override
	public String toString() {
		return "Province [pid=" + pid + ", pname=" + pname + "]";
	}
	
	
	
	
	
	
	
	
}

City.hbm.xml：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2018-8-6 16:39:06 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
    <class name="com.liuyongqi.MavenHibernateDemo05.entity.City" table="city">
        <id name="cid" type="java.lang.Integer">
            <column name="cid" />
            <generator class="native" />
        </id>
        <property name="cname" type="java.lang.String">
            <column name="cname" />
        </property>
       <!--  <property name="pid" type="java.lang.Integer">
            <column name="pid" />
        </property> -->
        <!--  多端--> 
        <many-to-one name="province" class="com.liuyongqi.MavenHibernateDemo05.entity.Province" column="pid" lazy="false" fetch="join"></many-to-one>      
    </class>
</hibernate-mapping>

Province.hbm.xml：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2018-8-6 16:39:06 by Hibernate Tools 3.5.0.Final -->
<hibernate-mapping>
    <class name="com.liuyongqi.MavenHibernateDemo05.entity.Province" table="province" >
        <id name="pid" type="java.lang.Integer">
            <column name="pid" />
            <generator class="native" />
        </id>
        <property name="pname" type="java.lang.String">
            <column name="pname" />
        </property>
        <!--  一端-->
        <set name="set" table="city" inverse="true" lazy="false" cascade="all-delete-orphan">
        	<key column="pid"></key>
        	<one-to-many class="com.liuyongqi.MavenHibernateDemo05.entity.City" />
        </set>        
    </class>
</hibernate-mapping>

SessionFactoryUtil工具类：

package com.liuyongqi.MavenHibernateDemo05.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

/**
 * 提供了开启和关闭session的方法
 * @author Administrator
 * @data   2018年8月1日
 * @time   下午3:32:56
 */
public class SessionFactoryUtil {
	//ThreadLocal为每个线程提供一个单独的存储空间
	private static ThreadLocal<Session> threadLocal=new ThreadLocal<Session>();
	
	//私有化静态变量，静态变量只实例化一次
	private static SessionFactory sessionFactory;
	//实例化一次sessionFactory
	static {
		Configuration configure = new Configuration().configure();
		sessionFactory=configure.buildSessionFactory();
	}
	//私有化构造方法
	private SessionFactoryUtil() {
		
	}
	//打开session的方法
	public static Session openSession() {
		//从ThreadLocal中拿取一个session
		Session session = threadLocal.get();
		if(null==session) {
			//sessionFactory打开一个session
			session=sessionFactory.openSession();
			//把session又放入ThreadLocal中
			threadLocal.set(session);
		}
		return session;
	}
	
	//关闭资源
	public static void closeSession() {
		//从ThreadLocal中拿取一个session
		Session session = threadLocal.get();
		if(null==session) {
			if(session.isOpen()) {
				//关闭session
				session.close();
			}
			threadLocal.set(null);
		}		
	}
	
	public static void main(String[] args) {
		Session session = openSession();
		System.out.println(session);
		System.out.println("ok");
	}
	
}

添加测试代码：

package test;

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

import com.liuyongqi.MavenHibernateDemo05.entity.City;
import com.liuyongqi.MavenHibernateDemo05.entity.Province;
import com.liuyongqi.MavenHibernateDemo05.util.SessionFactoryUtil;

/**
 * 
 * @author Administrator
 * @data   2018年8月6日
 * @time   下午5:06:11
 */
public class TestSave{
	public static void main(String[] args) {
		Session session = SessionFactoryUtil.openSession();
		Transaction transaction = session.beginTransaction();
		Province province = new Province();
		province.setPname("湖南省1");
		
		City c1 = new City();
		c1.setCname("长沙1");
		City c2 = new City();
		c2.setCname("株洲1");
		City c3 = new City();
		c3.setCname("湘潭1");
		
		//互设
		province.getSet().add(c1);
		province.getSet().add(c2);
		province.getSet().add(c3);
		c1.setProvince(province);
		c2.setProvince(province);
		c3.setProvince(province);
		
		session.save(province);
		
		//结果
		/*Hibernate: 
		    insert 
		    into
		        province
		        (pname) 
		    values
		        (?)
		Hibernate: 
		    insert 
		    into
		        city
		        (cname, pid) 
		    values
		        (?, ?)
		Hibernate: 
		    insert 
		    into
		        city
		        (cname, pid) 
		    values
		        (?, ?)
		Hibernate: 
		    insert 
		    into
		        city
		        (cname, pid) 
		    values
		        (?, ?)
		Hibernate: 
		    update
		        city 
		    set
		        pid=? 
		    where
		        cid=?
		Hibernate: 
		    update
		        city 
		    set
		        pid=? 
		    where
		        cid=?
		Hibernate: 
		    update
		        city 
		    set
		        pid=? 
		    where
		        cid=?*/
		//为啥会出现update语句
		//缺少配置
		//解决方法
		//在一端的set集合那里加上inverse="true"		
		transaction.commit();
		SessionFactoryUtil.closeSession();
	}
}

控制台结果；

Hibernate: 
		    insert 
		    into
		        province
		        (pname) 
		    values
		        (?)
		Hibernate: 
		    insert 
		    into
		        city
		        (cname, pid) 
		    values
		        (?, ?)
		Hibernate: 
		    insert 
		    into
		        city
		        (cname, pid) 
		    values
		        (?, ?)
		Hibernate: 
		    insert 
		    into
		        city
		        (cname, pid) 
		    values
		        (?, ?)

 查询测试代码：

package test;

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

import com.liuyongqi.MavenHibernateDemo05.entity.City;
import com.liuyongqi.MavenHibernateDemo05.entity.Province;
import com.liuyongqi.MavenHibernateDemo05.util.SessionFactoryUtil;

/**
 * 
 * @author Administrator
 * @data   2018年8月6日
 * @time   下午5:06:11
 */
public class TestSelect{
	public static void main(String[] args) {
		Session session = SessionFactoryUtil.openSession();
		Transaction transaction = session.beginTransaction();
		//默认延时加载
		Province province = session.get(Province.class, 1);		
		transaction.commit();
		SessionFactoryUtil.closeSession();
		System.out.println(province);
		for (City c : province.getSet()) {
			System.out.println(c);
		}
		//关闭延时加载(修改配置)
		//解决方法：在一端和多端都加上lazy="false"
	}
}

控制台结果：

Hibernate: 
    select
        province0_.pid as pid1_1_0_,
        province0_.pname as pname2_1_0_ 
    from
        province province0_ 
    where
        province0_.pid=?
Hibernate: 
    select
        set0_.pid as pid3_0_0_,
        set0_.cid as cid1_0_0_,
        set0_.cid as cid1_0_1_,
        set0_.cname as cname2_0_1_,
        set0_.pid as pid3_0_1_ 
    from
        city set0_ 
    where
        set0_.pid=?
Province [pid=1, pname=湖南省]
City [cid=1, cname=长沙, province=Province [pid=1, pname=湖南省]]
City [cid=3, cname=株洲, province=Province [pid=1, pname=湖南省]]
City [cid=2, cname=湘潭, province=Province [pid=1, pname=湖南省]]

修改测试代码：

package test;

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

import com.liuyongqi.MavenHibernateDemo05.entity.City;
import com.liuyongqi.MavenHibernateDemo05.entity.Province;
import com.liuyongqi.MavenHibernateDemo05.util.SessionFactoryUtil;

/**
 * 
 * @author Administrator
 * @data   2018年8月6日
 * @time   下午5:06:11
 */
public class TestUpdate{
	public static void main(String[] args) {
		Session session = SessionFactoryUtil.openSession();
		Transaction transaction = session.beginTransaction();
		Province province = session.get(Province.class, 2);
		if(province!=null) {
			province.setPname("湖南省2");
			session.update(province);
		}
		transaction.commit();
		SessionFactoryUtil.closeSession();
	}
}

控制台结果：

Hibernate: 
		    select
		        province0_.pid as pid1_1_0_,
		        province0_.pname as pname2_1_0_ 
		    from
		        province province0_ 
		    where
		        province0_.pid=?
		Hibernate: 
		    select
		        set0_.pid as pid3_0_0_,
		        set0_.cid as cid1_0_0_,
		        set0_.cid as cid1_0_1_,
		        set0_.cname as cname2_0_1_,
		        set0_.pid as pid3_0_1_ 
		    from
		        city set0_ 
		    where
		        set0_.pid=?
		Hibernate: 
		    update
		        province 
		    set
		        pname=? 
		    where
		        pid=?

删除测试代码：

package test;

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

import com.liuyongqi.MavenHibernateDemo05.entity.City;
import com.liuyongqi.MavenHibernateDemo05.entity.Province;
import com.liuyongqi.MavenHibernateDemo05.util.SessionFactoryUtil;

/**
 * 
 * @author Administrator
 * @data   2018年8月6日
 * @time   下午5:06:11
 */
public class TestDelete{
	public static void main(String[] args) {
		Session session = SessionFactoryUtil.openSession();
		Transaction transaction = session.beginTransaction();
		Province province = session.get(Province.class, 2);
		if(province!=null) {
			session.delete(province);
		}
		transaction.commit();
		SessionFactoryUtil.closeSession();
	}
}

控制台结果

Hibernate: 
		    select
		        province0_.pid as pid1_1_0_,
		        province0_.pname as pname2_1_0_ 
		    from
		        province province0_ 
		    where
		        province0_.pid=?
		Hibernate: 
		    select
		        set0_.pid as pid3_0_0_,
		        set0_.cid as cid1_0_0_,
		        set0_.cid as cid1_0_1_,
		        set0_.cname as cname2_0_1_,
		        set0_.pid as pid3_0_1_ 
		    from
		        city set0_ 
		    where
		        set0_.pid=?
		Hibernate: 
		    delete 
		    from
		        city 
		    where
		        cid=?
		Hibernate: 
		    delete 
		    from
		        city 
		    where
		        cid=?
		Hibernate: 
		    delete 
		    from
		        city 
		    where
		        cid=?
		Hibernate: 
		    delete 
		    from
		        province 
		    where
		        pid=?

今天的测试就到这里了，希望大家看完以后自己测试一下

如果大家想浏览我的下一篇文章，请留言

此文章属于原创，不准转载：https://blog.csdn.net/LYQ2332826438

银色亡灵
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Hibernate实例
草原印象的博客
07-08 451
让我们看一个独立应用程序利用 Hibernate 提供 Java 持久性的例子。我们将通过不同的步骤使用 Hibernate 技术创建 Java 应用程序。 创建 POJO 类 创建应用程序的第一步就是建立 Java 的 POJO 类或者其它类，这取决于即将要存放在数据库中的应用程序。我们可以考虑一下让我们的 Employee 类使用 getXXX 和 setXXX 方法从而使它们变成符合 JavaBeans 的类。 POJO (Plain Old Java Object) 是 Java 的一个对象，这种对
bookManager：用于Spring Boot的Book Manager一对多关系项目
02-04
一对多双向关系映射带有Spring Boot的Java Web Services和RESTful API 本教程将引导您完成使用Spring Boot，Spring Data JPA，Lombok，H2和Swagger映射JPA / Hibernate一对多双向关系的步骤。 下表关系图说明了此...
Hibernate关联映射（非常详细）
youandme520的专栏
02-12 1488
在前面的学习中，我们所涉及的都是基于单表的操作，但在实际的开发过程中，基本上都是同时对多张表的操作，且这些表都存在一定的关联关系。 Hibernate 是一款基于 ORM 设计思想的框架，它将关系型数据库中的表与我们 Java 实体类进行映射，表中的记录对应实体类的对象，而表中的字段对应着实体类中的属性。Hibernate 进行增删改查等操作时，不再直接操作数据库表，而是对与之对应的实体类对象进行处理。那么，Hibernate 是如何处理多表关联问题的呢？本节我们针对此问题进行介绍。 关联映射 在关系型
Java三大框架之——Hibernate关联映射与级联操作
weixin_34320724的博客
11-26 255
什么是Hibernate中的关联映射？ 　　简单来说Hibernate是ORM映射的持久层框架，全称是（Object Relational Mapping），即对象关系映射。 　　它将数据库中的表映射成对应的对象，以对象的形式展现，这样我们就可以通过映射的对象来对数据库中的数据进行间接的操作。 　　关联映射是将数据库中的表映射成与之相对应的对象，当你对这个对象进行操作的时候，Hibernat...
Hibernate关联关系映射
qq_41659353的博客
04-03 152
1. 单向一对一 （1）主键关联：两个表通过主键建立一对一关联关系，从表的主键由被关联类生成。 映射代码： <!--主键生成器--> <generator class="foreign"/> <!--生成策略设为foreign，表明由关联类来生成主键--> <one-to-one name="关联属性的属性名" class="持久化类" constrai...
Hibernate入门经典实例
Baple的专栏
09-12 1043
http://blog.csdn.net/yidamr/article/details/8755401 hibernate是开源的，用于封装数据访问层的组件，称为:数据访问层框架(持久层框架) 写一个入门案例，体现hibernate的工作方式！明白hibernate作用及其程序结构！ 例子：用Hibernate实现增删查改案例 环境： IDE工具：Myeclipse ，m
jpa-workshop:在我的 JPAHibernate 研讨会中使用的一系列示例
07-17
一对多/多对一 多对多 嵌入式 辅助表 遗产 懒惰抓取 查询 JPQL 命名查询 Spring数据 本机 SQL 乐观锁 复合键（进行中） 去做 添加复合键的更多示例 添加三元键的例子 以上两者混合关联 用户类型（包括 ID 字段的...
最全Hibernate 参考文档
08-29
6.2.5. 一对多关联（One-to-many Associations） 6.3. 高级集合映射（Advanced collection mappings） 6.3.1. 有序集合（Sorted collections） 6.3.2. 双向关联（Bidirectional associations） 6.3.3. 三重关联...
Hibernate学习笔记
04-19
014 一对多关联映射 单向 015 一对多关联映射 双向 016 多对多关联映射 单向 017 多对多关联映射 双向 018 关联映射文件中标签中的 lazy(懒加载)属性 019 关联映射文件中集合标签中的 lazy(懒加载)属性 020 、单端...
Hibernate_3.2.0_符合Java习惯的关系数据库持久化
01-14
6.2.5. 一对多关联（One-to-many Associations） 6.3. 高级集合映射（Advanced collection mappings） 6.3.1. 有序集合（Sorted collections） 6.3.2. 双向关联（Bidirectional associations） 6.3.3. 双向关联...
Hibernate的七种映射关系之七种关联映射
kevincol22的专栏
09-19 762
关联映射就是将关联关系映射到数据库里，在对象模型中就是一个或多个引用。　　 　　一、Hibernate多对一关联映射：就是在“多”的一端加外键，指向“一”的一端。 　　比如多个学生对应一个班级，多个用户对应一个级别等等，都是多对一关系。 　　 　　1、“多”端实体加入引用“一”端实体的变量及getter,setter方法。 　　比如说多个学生对应一个班级，在学生实体类加入：pri
Hibernate基础讲解和示例
上善若泪
05-04 676
文章目录1 Hibernate1.1 简介1.2 Hibernate能干什么1.3 Hibernate运行时体系结构1.3.1 SessionFactory (org.hibernate.SessionFactory)1.3.2 Session (org.hibernate.Session)1.3.3 Transaction (org.hibernate.Transaction)1.3.4 ConnectionProvider (org.hibernate.connection.ConnectionProv
Hibernate的七种映射关系之七种关联映射（一）
weixin_34239169的博客
04-27 124
　　 　　关联映射就是将关联关系映射到数据库里，在对象模型中就是一个或多个引用。　　 　　一、Hibernate多对一关联映射：就是在“多”的一端加外键，指向“一”的一端。 　　比如多个学生对应一个班级，多个用户对应一个级别等等，都是多对一关系。 　　 　　1、“多”端实体加入引用“一”端实体的变量及getter,setter方法。 　　比如说多个学生对应一个班级，在学生实体类加入：p...
最简单的hibernate实例
qq_38056704的博客
11-21 608
学习框架的方法有三步，【导入jar包，xml配置，测试代码】，今天我们根据这个思路，演示一个最基本的hibernate项目，实现简单jdbc操作   目录 1、导包 2、代码配置 3、准备数据 4、开始测试 5、结果   1、导包 hibernate spring mysql junit jdk8 2、代码配置 hibernate.cgf.xml...
Hibernate 关系映射 收集、总结整理
Cages的专栏
05-14 198
《Hibernate 关系映射》是我很早之前收集、总结整理的，在此也发上来 希望对大家有用。因为是很早之前写的，不当之处请指正。 一、概念： 关系：名词，事物之间相互作用、相互联系的状态。 关联：名词：表示对象（数据库表）之间的关系；动词：将对象（数据库表）之间通过某种方式联系起来。 映射：将一种形式转化为另一种形式，包括关系。 级联：动词，有关系的双方中操作一方，另一方也将采取一些...
Hibernate映射解析——七种映射关系
weixin_30924239的博客
12-28 163
首先我们了解一个名词ORM，全称是（Object Relational Mapping），即对象关系映射。ORM的实现思想就是将关系数据库中表的数据映射成对象，以对象的形式展现，这样开发人员就可以把对数据库的操作转化为对这些对象的操作。Hibernate正是实现了这种思想，达到了方便开发人员以面向对象的思想来实现对数据库的操作。 Hibernate在实现ORM...
hibernate映射关系
影子
10-18 286
hibernate的关联关系映射一共有7种： 1.单向多对一 2.单向一对多 3.单向一对一 4.单向多对多 5.双向多对一 6.双向一对一 7.双向多对多 一，单向多对一（many--to--one） 两个对象之间多对一的关系，比如员工（emp）和部门（dept），多个员工可以在一个部门，映射原理就是在多的一端添加一个外键指向一的一端的主键。 在多的一端的映射
hibernate 关系映射
a709404132的博客
12-28 116
首先，我们知道hibernate是一个ORM框架，ORM的全称是（Object Relational Mapping），既对象关系映射，那么hibernate有几种对象关系映射呢？接下来我们来一一举例出 Hibernate在实现ORM功能的时候主要用到的文件有：映射类（*.java）、映射文件（*.hbm.xml）和数据库配置文件（*hibernate.cfg.xml）...
Hibernate关联映射
jamenu的博客
08-28 249
Hibernate关联映射 关联映射大体分为 一对一的关联映射 一对多的关联映射 多对多的关联映射 关联的方向 及关联有方向，大抵意思是一方能够通过关联查到对方， 这就具备了单向关联，如果双方能互相查到，就可以称为双向关联 例： public class Person { private int id; private String name; private IdCard card; //Person中持有IdCard对象，建立了单向关联 .... }
hibernate映射一对一 一对多 多对多
最新发布
09-07
一对一关系：在Hibernate中，可以通过主键关联和外键关联来实现一对一关系的映射。主键关联是指两个实体之间的关联通过主键来进行，可以使用@PrimaryKeyJoinColumn注解将两个实体关联起来。外键关联是指通过一个实体...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

银色亡灵

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值