使用反射机制恢复xml文件表示的对象

最新推荐文章于 2025-08-22 13:45:39 发布
转载 最新推荐文章于 2025-08-22 13:45:39 发布 · 52 阅读 · 0
文章标签：

#java #开发工具

本文介绍了一种用于从XML文件和Properties文件中解析并重建Java对象的方法。该解析器可以处理任意Java对象，通过替换XML文件中的占位符为Properties文件中的值，并将XML描述转换为实际的对象实例。

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

完成如下功能：
1)有一个(任意)对象，里面有N个properties以及getter和setter方法
2)有一个properties文件，有N个key,value来描述对象中property的值
3)有一个scheme固定的xml，用来描述这个对象


要求写一个解析器：
1)将xml中的占位符，替换为properties文件中的value
2) 将xml解析成对象，调用getter方法的时候可以获得值
3)用面向对象的思想，使该解析器有扩展性


例子见附件，注意：
1)对象是任意对象，不是例子中的Student，对象中的property都是Java中的原生类型
2)xml和properties在使用的时候都是根据对象配置好的
3) xml的scheme是固定的，就是附件中的scheme

import java.util.Date;

/**
 * Created by IntelliJ IDEA.
 * User: liuzz
 * Date: 13-11-2
 * Time: 下午11:53
 */
public class Student {

    private String name;

    private int age;

    private Date birth;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Date getBirth() {
        return birth;
    }

    public void setBirth(Date birth) {
        this.birth = birth;
    }
    public String toString(){
        return "[ name = " + name +" , age = "+age+" , birth = " + birth+"]";
    }
}

object.properties2文件

name=a  
age=10  
birth=2003-11-04

object.xml文件

<object class="MyTest.MyTest.Week2.Student">  
    <property name="name">  
        <value>${name}</value>  
    </property>  
    <property name="age">  
        <value>${age}</value>  
    </property>  
    <property name="birth">  
        <value>${birth}</value>  
    </property>  
</object>

代码实现：

import java.io.BufferedReader;  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileNotFoundException;  
import java.io.IOException;  
import java.io.InputStream;  
import java.lang.reflect.AnnotatedType;  
import java.lang.reflect.Field;  
import java.sql.Date;  
import java.text.ParseException;  
import java.text.SimpleDateFormat;  
import java.util.Iterator;  
import java.util.List;  
import java.util.Properties;  
import java.util.Scanner;  
  
import javax.xml.parsers.DocumentBuilder;  
import javax.xml.parsers.DocumentBuilderFactory;  
import javax.xml.parsers.ParserConfigurationException;  
  
import org.jdom.Document;  
import org.jdom.Element;  
import org.jdom.JDOMException;  
import org.jdom.input.SAXBuilder;  
import org.w3c.dom.Node;  
import org.w3c.dom.NodeList;  
import org.xml.sax.SAXException;  
  
import com.google.common.io.Files;  
  
public class RecoverObject<O> {  
    private String propertiesFile;  
    private String objectXmlFile;  
    private String recoverObjextXmlFile;  
    private String clazzName;  
    private Properties properties;  
    public RecoverObject(String propertiesFile, String objectXmlFile){  
        this.propertiesFile = propertiesFile;  
        this.objectXmlFile = objectXmlFile;  
        this.recoverObjextXmlFile = this.objectXmlFile+".recover";  
          
        this.properties = new Properties();  
        initObject();  
    }  
    private void processXmlFile(String context){  
        int pre = -1, s = -1, e = -1;  
        StringBuffer buffer = new StringBuffer();  
        while((s = context.indexOf("${", pre+1))!=-1){  
            e = context.indexOf("}", s + 2);  
            buffer.append(context.substring(pre+1, s));  
            String attr = context.substring(s+2, e);  
            buffer.append(this.properties.get(attr));  
            pre = e;  
        }  
        buffer.append(context.substring(pre+1));  
        try {  
            Files.write(buffer.toString().getBytes(), new File(this.recoverObjextXmlFile));  
        } catch (IOException e1) {  
            // TODO Auto-generated catch block  
            e1.printStackTrace();  
        }  
          
    }  
    private void initObject(){  
        FileInputStream in;  
        try {  
            in = new FileInputStream(new File(this.propertiesFile));  
            this.properties.load(in);  
            in.close();  
        } catch (FileNotFoundException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }   
        StringBuffer buffer = new StringBuffer();  
        try {  
            Scanner scan = new Scanner(new FileInputStream(new File(this.objectXmlFile)));  
            while(scan.hasNextLine()){  
                buffer.append(scan.nextLine());  
                buffer.append("\n");  
            }  
        } catch (FileNotFoundException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
        String context = buffer.toString();  
        this.processXmlFile(context);  
          
    }  
      
    public O get(){  
        SAXBuilder builder=new SAXBuilder(false);  
        Class<?> demo=null;  
        try {  
            Document doc=builder.build(this.recoverObjextXmlFile);  
            Element object=doc.getRootElement();  
            this.clazzName = object.getAttributeValue("class");  
            demo=Class.forName(this.clazzName);  
            O o = (O) demo.newInstance();  
            List propertiesList = object.getChildren("property");  
            for(Iterator iter = propertiesList.iterator(); iter.hasNext();){  
                Element attr = (Element) iter.next();  
                String attrName = attr.getAttributeValue("name");  
                String attrValue = attr.getChildText("value");  
                Field f= demo.getDeclaredField(attrName);  
                f.setAccessible(true);  
                Class<?> type = f.getType();  
                if(type.equals(String.class)){  
                    f.set(o, attrValue);  
                }else if(type.equals(int.class)){  
                    f.set(o, Integer.parseInt(attrValue));  
                }else if(type.equals(java.util.Date.class)){  
                    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");  
                    f.set(o, format.parse(attrValue));  
                }  
                  
            }  
            return o;  
        } catch (JDOMException e) {  
              
            e.printStackTrace();  
        } catch (IOException e) {  
              
            e.printStackTrace();  
        } catch (ClassNotFoundException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        } catch (InstantiationException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        } catch (IllegalAccessException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        } catch (NoSuchFieldException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        } catch (SecurityException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        } catch (IllegalArgumentException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        } catch (ParseException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
          
        return null;  
    }  
    public static void main(String [] args){  
        RecoverObject<Student> object = new RecoverObject<Student>("./source/object.properties2", "./source/object.xml");  
        Student s = object.get();  
        System.out.println(s);  
    }  
}

 

完成如下功能：
1)有一个(任意)对象，里面有N个properties以及getter和setter方法
2)有一个properties文件，有N个key,value来描述对象中property的值
3)有一个scheme固定的xml，用来描述这个对象


要求写一个解析器：
1)将xml中的占位符，替换为properties文件中的value
2) 将xml解析成对象，调用getter方法的时候可以获得值
3)用面向对象的思想，使该解析器有扩展性


例子见附件，注意：
1)对象是任意对象，不是例子中的Student，对象中的property都是Java中的原生类型
2)xml和properties在使用的时候都是根据对象配置好的
3) xml的scheme是固定的，就是附件中的scheme

 

Student.java文件

 

[java]  view plain  copy
 
  1. import java.util.Date;  
  2.   
  3. /** 
  4.  * Created by IntelliJ IDEA. 
  5.  * User: liuzz 
  6.  * Date: 13-11-2 
  7.  * Time: 下午11:53 
  8.  */  
  9. public class Student {  
  10.   
  11.     private String name;  
  12.   
  13.     private int age;  
  14.   
  15.     private Date birth;  
  16.   
  17.     public String getName() {  
  18.         return name;  
  19.     }  
  20.   
  21.     public void setName(String name) {  
  22.         this.name = name;  
  23.     }  
  24.   
  25.     public int getAge() {  
  26.         return age;  
  27.     }  
  28.   
  29.     public void setAge(int age) {  
  30.         this.age = age;  
  31.     }  
  32.   
  33.     public Date getBirth() {  
  34.         return birth;  
  35.     }  
  36.   
  37.     public void setBirth(Date birth) {  
  38.         this.birth = birth;  
  39.     }  
  40.     public String toString(){  
  41.         return "[ name = " + name +" , age = "+age+" , birth = " + birth+"]";  
  42.     }  
  43. }  


object.properties2文件

 

 

[plain]  view plain  copy
 
  1. name=a  
  2. age=10  
  3. birth=2003-11-04  

 

 

object.xml文件

 

[html]  view plain  copy
 
  1. <object class="MyTest.MyTest.Week2.Student">  
  2.     <property name="name">  
  3.         <value>${name}</value>  
  4.     </property>  
  5.     <property name="age">  
  6.         <value>${age}</value>  
  7.     </property>  
  8.     <property name="birth">  
  9.         <value>${birth}</value>  
  10.     </property>  
  11. </object>  

 

 

 

代码实现：

 

[java]  view plain  copy
 
  1. import java.io.BufferedReader;  
  2. import java.io.File;  
  3. import java.io.FileInputStream;  
  4. import java.io.FileNotFoundException;  
  5. import java.io.IOException;  
  6. import java.io.InputStream;  
  7. import java.lang.reflect.AnnotatedType;  
  8. import java.lang.reflect.Field;  
  9. import java.sql.Date;  
  10. import java.text.ParseException;  
  11. import java.text.SimpleDateFormat;  
  12. import java.util.Iterator;  
  13. import java.util.List;  
  14. import java.util.Properties;  
  15. import java.util.Scanner;  
  16.   
  17. import javax.xml.parsers.DocumentBuilder;  
  18. import javax.xml.parsers.DocumentBuilderFactory;  
  19. import javax.xml.parsers.ParserConfigurationException;  
  20.   
  21. import org.jdom.Document;  
  22. import org.jdom.Element;  
  23. import org.jdom.JDOMException;  
  24. import org.jdom.input.SAXBuilder;  
  25. import org.w3c.dom.Node;  
  26. import org.w3c.dom.NodeList;  
  27. import org.xml.sax.SAXException;  
  28.   
  29. import com.google.common.io.Files;  
  30.   
  31. public class RecoverObject<O> {  
  32.     private String propertiesFile;  
  33.     private String objectXmlFile;  
  34.     private String recoverObjextXmlFile;  
  35.     private String clazzName;  
  36.     private Properties properties;  
  37.     public RecoverObject(String propertiesFile, String objectXmlFile){  
  38.         this.propertiesFile = propertiesFile;  
  39.         this.objectXmlFile = objectXmlFile;  
  40.         this.recoverObjextXmlFile = this.objectXmlFile+".recover";  
  41.           
  42.         this.properties = new Properties();  
  43.         initObject();  
  44.     }  
  45.     private void processXmlFile(String context){  
  46.         int pre = -1, s = -1, e = -1;  
  47.         StringBuffer buffer = new StringBuffer();  
  48.         while((s = context.indexOf("${", pre+1))!=-1){  
  49.             e = context.indexOf("}", s + 2);  
  50.             buffer.append(context.substring(pre+1, s));  
  51.             String attr = context.substring(s+2, e);  
  52.             buffer.append(this.properties.get(attr));  
  53.             pre = e;  
  54.         }  
  55.         buffer.append(context.substring(pre+1));  
  56.         try {  
  57.             Files.write(buffer.toString().getBytes(), new File(this.recoverObjextXmlFile));  
  58.         } catch (IOException e1) {  
  59.             // TODO Auto-generated catch block  
  60.             e1.printStackTrace();  
  61.         }  
  62.           
  63.     }  
  64.     private void initObject(){  
  65.         FileInputStream in;  
  66.         try {  
  67.             in = new FileInputStream(new File(this.propertiesFile));  
  68.             this.properties.load(in);  
  69.             in.close();  
  70.         } catch (FileNotFoundException e) {  
  71.             e.printStackTrace();  
  72.         } catch (IOException e) {  
  73.             e.printStackTrace();  
  74.         }   
  75.         StringBuffer buffer = new StringBuffer();  
  76.         try {  
  77.             Scanner scan = new Scanner(new FileInputStream(new File(this.objectXmlFile)));  
  78.             while(scan.hasNextLine()){  
  79.                 buffer.append(scan.nextLine());  
  80.                 buffer.append("\n");  
  81.             }  
  82.         } catch (FileNotFoundException e) {  
  83.             // TODO Auto-generated catch block  
  84.             e.printStackTrace();  
  85.         }  
  86.         String context = buffer.toString();  
  87.         this.processXmlFile(context);  
  88.           
  89.     }  
  90.       
  91.     public O get(){  
  92.         SAXBuilder builder=new SAXBuilder(false);  
  93.         Class<?> demo=null;  
  94.         try {  
  95.             Document doc=builder.build(this.recoverObjextXmlFile);  
  96.             Element object=doc.getRootElement();  
  97.             this.clazzName = object.getAttributeValue("class");  
  98.             demo=Class.forName(this.clazzName);  
  99.             O o = (O) demo.newInstance();  
  100.             List propertiesList = object.getChildren("property");  
  101.             for(Iterator iter = propertiesList.iterator(); iter.hasNext();){  
  102.                 Element attr = (Element) iter.next();  
  103.                 String attrName = attr.getAttributeValue("name");  
  104.                 String attrValue = attr.getChildText("value");  
  105.                 Field f= demo.getDeclaredField(attrName);  
  106.                 f.setAccessible(true);  
  107.                 Class<?> type = f.getType();  
  108.                 if(type.equals(String.class)){  
  109.                     f.set(o, attrValue);  
  110.                 }else if(type.equals(int.class)){  
  111.                     f.set(o, Integer.parseInt(attrValue));  
  112.                 }else if(type.equals(java.util.Date.class)){  
  113.                     SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");  
  114.                     f.set(o, format.parse(attrValue));  
  115.                 }  
  116.                   
  117.             }  
  118.             return o;  
  119.         } catch (JDOMException e) {  
  120.               
  121.             e.printStackTrace();  
  122.         } catch (IOException e) {  
  123.               
  124.             e.printStackTrace();  
  125.         } catch (ClassNotFoundException e) {  
  126.             // TODO Auto-generated catch block  
  127.             e.printStackTrace();  
  128.         } catch (InstantiationException e) {  
  129.             // TODO Auto-generated catch block  
  130.             e.printStackTrace();  
  131.         } catch (IllegalAccessException e) {  
  132.             // TODO Auto-generated catch block  
  133.             e.printStackTrace();  
  134.         } catch (NoSuchFieldException e) {  
  135.             // TODO Auto-generated catch block  
  136.             e.printStackTrace();  
  137.         } catch (SecurityException e) {  
  138.             // TODO Auto-generated catch block  
  139.             e.printStackTrace();  
  140.         } catch (IllegalArgumentException e) {  
  141.             // TODO Auto-generated catch block  
  142.             e.printStackTrace();  
  143.         } catch (ParseException e) {  
  144.             // TODO Auto-generated catch block  
  145.             e.printStackTrace();  
  146.         }  
  147.           
  148.         return null;  
  149.     }  
  150.     public static void main(String [] args){  
  151.         RecoverObject<Student> object = new RecoverObject<Student>("./source/object.properties2", "./source/object.xml");  
  152.         Student s = object.get();  
  153.         System.out.println(s);  
  154.     }  
  155. }  

 

Java开发揭秘！java反射和映射机制
m0_56662269的博客
05-15 1299
谈起MyBatis，我先提个问：什么是 MyBatis ？ MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以对配置和原生Map使用简单的 XML 或注解，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录… 而今天咱要聊的就是Alibaba珍藏版mybatis手写文档，刷到的朋友真香警告呀！ MySQL 数
Go语言反射机制详解：interface{}与reflect的妙用
Golang编程笔记的博客
05-18 986
本文旨在全面解析Go语言反射机制，特别关注interface{}与reflect包的交互原理和实际应用。我们将覆盖从基础概念到高级用法的完整知识体系，帮助读者掌握这一强大但容易被误解的语言特性。文章首先介绍反射的基本概念，然后深入解析interface{}的实现原理，接着详细讲解reflect包的核心API。随后通过实际案例展示反射的应用场景，最后讨论性能优化和最佳实践。反射(Reflection): 程序在运行时检查、修改自身结构和行为的能力: Go语言中的空接口类型，可以容纳任何值Type。
面向对象的XML转换：利用DOM4J与Java反射技术
weixin_42593701的博客
05-25 770
XML（Extensible Markup Language）是一种用于描述和交换数据的标记语言，它允许开发者定义自己的标签和结构，这使得XML在IT行业中具有广泛的应用。XML的自定义性、层次性和文本性使得它在数据交换、系统配置、元数据描述等多个领域都发挥着重要作用。DOM4J库是一个轻量级的、易于使用的Java库，支持XML的读取、修改、创建和序列化操作。它提供了多种接口和类来操作XML文档，包括DOM、SAX和JAXP。DOM4J的核心功能包括：支持DOM1、DOM2和JAXP的解析接口。
利用JAXB实现Java对象与XML的数据转换
weixin_42360733的博客
06-21 982
JAXB（Java Architecture for XML Binding）为Java语言提供了一种灵活的方式，通过Java对象与XML文档之间进行自动绑定，从而简化了复杂XML数据的操作过程。它通过注解和绑定文件来定义对象与XML之间的映射关系，让开发者可以更专注于业务逻辑的实现，而非繁琐的XML解析细节。JAXB的核心组件包括了Marshaller和，这些组件协同工作，实现了对象与XML数据的序列化和反序列化过程。
【Java 反射机制】详解
架构师之路
12-29 1091
Java反射机制尽管在性能方面存在一定的局限性，但凭借其强大的动态获取和操作类及成员信息的能力，在众多高级编程场景和框架开发中都发挥着不可或缺的作用，是Java 程序员深入理解和掌握高级编程技巧、开发复杂应用的重要工具之一。
Java对象的XML序列化
xiaoniba1024的专栏
03-06 3180
引言 Java对象的序列化(serialization)是对象的持久存储和对象状态的网络传输的 关键环节，在RMI(Remote Method Invocation)、JMS(Java Message Service)和EJB(EnterpriseJavaBeans)中都有应用。对象序列化可以实现分布式对象，例如RMI要利用对象序列化运行远程主机上的服务，就像在本地机器上调用对象一样。对象序列化
【Mybatis】基于XML配置的基本使用
dominic_z的博客
04-07 404
文章依照官网文档所写，使用的mybatis版本为3.5.4，使用数据库为mysql 本文以使用案例为主，基础性讲解较少，请结合文档阅读。也是初学者，能力有限，有错麻烦指正，谢谢 本文所用代码上传至GitHub，全部运行方法都在测试实例中。 Getting Start 本章内容的测试代码在test/java/basic中，使用到的配置文件在src/main/resources/basic中 基本...
C# 面试问题高级：014 - 什么是反射（Reflection） ？
caifox的博客
01-16 985
反射的基本概念：反射是一种在运行时获取类型信息和操作对象的机制，提供了获取类型信息、创建对象实例、访问和修改成员变量、调用方法等功能。
Java中的反射机制详解与应用
yokeyhui的博客
12-30 993
反射机制是Java中一个强大的特性，它允许程序在运行时动态地访问和操作类、接口、字段和方法。通过反射机制，我们可以实现更加灵活和动态的代码执行，提高代码的可重用性和可维护性。反射是Java中的一个重要特性，它允许在运行时对类、接口、字段和方法进行动态访问和操作。通过反射机制，程序可以在运行时加载类、创建对象、调用方法和获取字段值等，从而实现更加灵活和动态的代码执行。这个示例代码演示了如何使用反射机制获取ArrayList类的信息、创建对象、调用size()方法和访问size字段。一、反射机制的实现原理。
泛型集合反射保存为xml文件 并可反射读取集合
03-24
- **反序列化**：从XML文件读取数据时，使用相同的反射和XML解析机制，将XML节点转换回自定义类型的实例。这一步需要创建类型实例，设置其属性值，并确保类型和集合的结构与序列化时保持一致。 - **方法调用**：...
JAVA对象序列化保存为XML文件的工具类
03-04
以下是一个简单的示例，展示了如何使用`ObjectToXMLUtil`工具类将Java对象序列化到XML文件以及从XML文件中反序列化： ```java public class Test { public static void main(String[] args) { // 创建一个示例...
使用XStream是实现XML与Java对象的转换(5)--Object Stream
08-03
如果你的项目是Maven管理的，可以在pom.xml文件中添加如下依赖： ```xml <groupId>com.thoughtworks.xstream</groupId> <artifactId>xstream <version>1.4.17 ``` 一旦引入了XStream，我们可以创建一个简单的...
java反射机制 字符串——java对象
03-28
在Java反射机制中，字符串可以用来表示类名、方法名或参数类型，是连接代码与运行时类信息的桥梁。 在Java中，将Java对象的数据封装成XML格式的字符串，通常涉及到对象序列化的过程。对象序列化是将对象的状态转换...
深入理解 Spring 的 @ControllerAdvice
Roc的博客
08-20 804
简单来说，是一个组件注解（被@Component元注解标注），它允许你将一个类声明为一个全局的、跨多个控制器的增强器（Advice）。你可以把它理解为 Spring MVC 版本的AOP（面向切面编程），但它不是基于代理，而是专门为控制器层设计的。全局异常处理全局数据绑定全局数据预处理命名清晰：类名如，明确其职责。区分使用场景开发，优先使用，专注于返回统一的 JSON 异常响应。开发传统多页应用，使用，可以混合处理异常、绑定模型等。避免过度使用。
【实时Linux实战系列】基于实时Linux的自适应控制系统
望获实时Linux系统
08-19 1089
本文介绍了基于实时Linux的自适应控制系统开发技术，重点阐述了其在工业自动化、航空航天等领域的应用价值。文章详细说明了环境准备、案例实现步骤和调试方法，包括温度自适应控制系统的开发过程，涉及实时任务调度、传感器数据采集和PWM控制等关键技术。同时提供了常见问题的解决方案和性能优化建议，为开发者掌握这一技术提供了实用指导。该技术能显著提升系统响应速度和稳定性，适用于需要高精度实时控制的各类场景。
java基础知识总结
yvya_的博客
08-19 1617
java 基础包含语法、面向对象，异常处理、文件操作等方面。
Docker容器化部署实战：Tomcat与Nginx服务配置指南
最新发布
Java
08-22 107
通过Docker快速部署Tomcat和Nginx服务，使用临时容器提取默认配置并挂载到宿主机实现持久化。
Java虚拟机故障处理工具全指南
qq_73993301的博客
08-20 1165
JVM故障处理工具全景指南：从基础到高阶诊断 本文系统介绍了JVM提供的故障诊断工具链，包括命令行工具（jps、jstat、jinfo、jmap、jhat、jstack、jcmd）和可视化工具（jconsole、VisualVM）。详细解析了各工具的核心功能和使用场景：jps用于进程查看、jstat监控GC行为、jmap生成堆转储等。文章提供了实战建议，强调基线数据收集和工具组合使用的重要性，并指出生产环境的使用注意事项。最后还介绍了远程连接、自动化分析等高级技巧，推荐结合Arthas、MAT等专业工具进行
C# 反射机制及其在XML数据操作中的应用
程序员可以在不知道具体类型的情况下，通过反射机制读取XML文件，并将数据映射到相应的对象中。同样，也可以将对象的状态保存回XML文件。这一过程通常涉及以下几个步骤： - **解析XML文件**：首先，需要解析XML文件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值