JSON 之 jackson 用法

最新推荐文章于 2024-07-01 16:24:15 发布
最新推荐文章于 2024-07-01 16:24:15 发布
阅读量6.2k 收藏 7
点赞数
分类专栏： Java 文章标签： java json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jitianxia68/article/details/52304531
版权


Jackson简单用法一：

importjava.text.SimpleDateFormat; 

importjava.util.ArrayList; 

importjava.util.Date; 

importjava.util.HashMap; 

importjava.util.List; 

importjava.util.Map; 

 

import org.codehaus.jackson.JsonGenerator; 

importorg.codehaus.jackson.map.DeserializationConfig; 

importorg.codehaus.jackson.map.ObjectMapper; 

import org.codehaus.jackson.map.SerializationConfig; 

importorg.codehaus.jackson.map.annotate.JsonSerialize.Inclusion; 

importorg.codehaus.jackson.type.TypeReference;

 

import com.fasterxml.jackson.databind.DeserializationFeature;

 

import java.util.Date; 

 

public classJacksonTest { 

    public staticObjectMapper getDefaultObjectMapper() { 

       ObjectMapper mapper = new ObjectMapper(); 

        //设置将对象转换成JSON字符串时候:包含的属性不能为空或"";   

        //Include.Include.ALWAYS 默认   

        //Include.NON_DEFAULT 属性为默认值不序列化   

        //Include.NON_EMPTY 属性为空（""）  或者为 NULL 都不序列化   

        //Include.NON_NULL 属性为NULL 不序列化   

        mapper.setSerializationInclusion(Inclusion.NON_EMPTY); 

       

        //设置将MAP转换为JSON时候只转换值不等于NULL的 

        mapper.configure(SerializationConfig.Feature.WRITE_NULL_MAP_VALUES, false); 

        mapper.setDateFormat(newSimpleDateFormat("yyyy-MM-ddHH:mm:ss")); 

//     mapper.configure(JsonGenerator.Feature.ESCAPE_NON_ASCII, true); 

       

        //设置有属性不能映射成PO时不报错 

        mapper.disable(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES); 

//     mapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES,false);  上一条也可以如此设置；

       

        return mapper; 

    } 

    public static voidmain(String[] args) throws Exception{ 

        //准备数据 

        Name name1 = new Name("zhang","san"); 

        Name name2 = new Name("li","si"); 

        Name name3 = new Name("wang","wu"); 

        Student student1 = newStudent(1,name1,"一班",newDate());   

        Student student2 = newStudent(2,name2,"二班",newDate());   

        Student student3 = newStudent(3,name3,"三班",newDate());   

       List<Student> studentList = new ArrayList<Student>(); 

        studentList.add(student1); 

        studentList.add(student2); 

        studentList.add(student3); 

       Map<String,Student> studentMap = new HashMap<String, Student>(); 

        studentMap.put("1", student1); 

        studentMap.put("2", student2); 

        studentMap.put("3", student3); 

        Student json2object = null; 

       List<Student> json2list = null; 

       Map<String,Student> json2map = null; 

       ObjectMapper mapper = getDefaultObjectMapper(); 

         

        /* Object --> JSON */ 

        String object4json = mapper.writeValueAsString(student1); 

        System.out.println("Object ----> JSON"); 

        System.out.println(object4json); 

        System.out.println("------------------------------------------------------"); 

         

        /* List<Object> --> JSON */ 

        String listforjson = mapper.writeValueAsString(studentList); 

        System.out.println("List<Object> ----> JSON"); 

        System.out.println(listforjson); 

        System.out.println("------------------------------------------------------"); 

         

        /* Map<String,Object> ----> JSON */ 

        String map4json = mapper.writeValueAsString(studentMap); 

        System.out.println("Map<String,Object> ----> JSON"); 

        System.out.println(map4json); 

        System.out.println("------------------------------------------------------"); 

         

        /* JSON --> Object */ 

        json2object = mapper.readValue(object4json,Student.class); 

        System.out.println("JSON ----> Object"); 

        System.out.println(json2object); 

        System.out.println("------------------------------------------------------"); 

        /* JSON --> List<Object> */ 

        json2list = mapper.readValue(listforjson, newTypeReference<List<Student>>() {}); 

        System.out.println("JSON --> List<Object>"); 

        System.out.println(json2list.toString()); 

        System.out.println("------------------------------------------------------"); 

        /* JSON --> Map<String,Object> */ 

        json2map = mapper.readValue(map4json, newTypeReference<Map<String,Student>>() {}); 

        System.out.println("JSON --> Map<String,Object>"); 

        System.out.println(json2map.toString()); 

    } 

} 

 

class Name{ 

    private String firstName; 

    private String lastName; 

    publicName(){} 

    publicName(String firstName, String lastName) { 

        this.firstName = firstName; 

        this.lastName = lastName; 

    } 

    public StringgetFirstName() { 

        return firstName; 

    } 

    public voidsetFirstName(String firstName) { 

        this.firstName = firstName; 

    } 

    public StringgetLastName() { 

        return lastName; 

    } 

    public voidsetLastName(String lastName) { 

        this.lastName = lastName; 

    } 

    public StringtoString() { 

        return firstName + " " + lastName; 

    } 

} 

 

 

 class Student{ 

    private int id; 

    private Name name; 

    private String className; 

    private Date birthDay; 

    publicStudent(){} 

    publicStudent(int id, Name name, String className, Date birthDay) { 

        super(); 

        this.id = id; 

        this.name = name; 

        this.className = className; 

        this.birthDay = birthDay; 

    } 

    public int getId(){ 

        return id; 

    } 

    public void setId(int id) { 

        this.id = id; 

    } 

    public NamegetName() { 

        return name; 

    } 

    public voidsetName(Name name) { 

        this.name = name; 

    } 

    public DategetBirthDay() { 

        return birthDay; 

    } 

    public voidsetBirthDay(Date birthDay) { 

        this.birthDay = birthDay; 

    } 

    public StringgetClassName() { 

        return className; 

    } 

    public voidsetClassName(String className) { 

        this.className = className; 

    } 

    @Override 

    public StringtoString() { 

        return "Student [birthDay=" + birthDay + ",id=" + id + ", name=" + name + ",classname="+ className + "]"; 

    } 

} 

 

/* 输出：

 Object ---->JSON

 {"id":1,"name":{"firstName":"zhang","lastName":"san"},"className":"一班","birthDay":"2016-08-2420:20:15"}

 ------------------------------------------------------

 List<Object>----> JSON

 [{"id":1,"name":{"firstName":"zhang","lastName":"san"},"className":"一班","birthDay":"2016-08-2420:20:15"},{"id":2,"name":{"firstName":"li","lastName":"si"},"className":"二班","birthDay":"2016-08-2420:20:15"},{"id":3,"name":{"firstName":"wang","lastName":"wu"},"className":"三班","birthDay":"2016-08-2420:20:15"}]

 ------------------------------------------------------

 Map<String,Object> ----> JSON

 {"3":{"id":3,"name":{"firstName":"wang","lastName":"wu"},"className":"三班","birthDay":"2016-08-2420:20:15"},"2":{"id":2,"name":{"firstName":"li","lastName":"si"},"className":"二班","birthDay":"2016-08-2420:20:15"},"1":{"id":1,"name":{"firstName":"zhang","lastName":"san"},"className":"一班","birthDay":"2016-08-2420:20:15"}}

 ------------------------------------------------------

 JSON ---->Object

 Student[birthDay=Wed Aug 24 20:20:15 CST 2016, id=1, name=zhang san,classname=一班]

 ------------------------------------------------------

 JSON -->List<Object>

 [Student[birthDay=Wed Aug 24 20:20:15 CST 2016, id=1, name=zhang san,classname=一班],Student [birthDay=Wed Aug 24 20:20:15 CST 2016, id=2, name=li si,classname=二班],Student [birthDay=Wed Aug 24 20:20:15 CST 2016, id=3, name=wang wu,classname=三班]]

 ------------------------------------------------------

 JSON -->Map<String,Object>

 {3=Student[birthDay=Wed Aug 24 20:20:15 CST 2016, id=3, name=wang wu,classname=三班],2=Student [birthDay=Wed Aug 24 20:20:15 CST 2016, id=2, name=li si,classname=二班],1=Student [birthDay=Wed Aug 24 20:20:15 CST 2016, id=1, name=zhangsan, classname=一班]}

*/

 

 

 

Jackson简单用法二：

 

 

 

 

importjava.io.File;

importjava.io.IOException;

importjava.io.InputStream;

importjava.io.OutputStream;

importjava.io.Reader;

importjava.io.Writer;

importjava.net.URL;

importjava.text.DateFormat;

importjava.text.SimpleDateFormat;

 

importorg.codehaus.jackson.JsonGenerationException;

importorg.codehaus.jackson.JsonParseException;

importorg.codehaus.jackson.map.DeserializationConfig;

importorg.codehaus.jackson.map.JsonMappingException;

importorg.codehaus.jackson.map.ObjectMapper;

importorg.codehaus.jackson.map.SerializationConfig;

importorg.codehaus.jackson.map.annotate.JsonSerialize;

/*

 * ObjectMapper的readValue() 方法：

<T> T   readValue(byte[]src, Class<T> valueType)

<T> T   readValue(byte[]src, JavaType valueType)

<T> T   readValue(byte[]src, TypeReference valueTypeRef)

<T> T   readValue(Filesrc, Class<T> valueType)

<T> T   readValue(Filesrc, JavaType valueType)

<T> T   readValue(Filesrc, TypeReference valueTypeRef)

<T> T   readValue(InputStreamsrc, Class<T> valueType)

<T> T   readValue(InputStreamsrc, JavaType valueType)

<T> T   readValue(InputStreamsrc, TypeReference valueTypeRef)

<T> T   readValue(JsonNoderoot, Class<T> valueType)

<T> T   readValue(JsonNoderoot, JavaType valueType)

<T> T   readValue(JsonNoderoot, TypeReference valueTypeRef)

<T> T   readValue(JsonParserjp, Class<T> valueType)

<T> T   readValue(Readersrc, Class<T> valueType)

<T> T   readValue(Readersrc, JavaType valueType)

<T> T   readValue(Readersrc, TypeReference valueTypeRef)

<T> T   readValue(Stringcontent, Class<T> valueType)

<T> T   readValue(Stringcontent, JavaType valueType)

<T> T   readValue(Stringcontent, TypeReference valueTypeRef)

 

 

ObjectMapper的writeValue() 方法：

 

void writeValue(File resultFile, Object value)

void    writeValue(JsonGeneratorjgen, Object value)

void    writeValue(JsonGeneratorjgen, Object value, SerializationConfig config)

void    writeValue(OutputStreamout, Object value)

void    writeValue(Writerw, Object value)

byte[]  writeValueAsBytes(Objectvalue)

String  writeValueAsString(Objectvalue)

*/

 

 

public classJsonFormatter {

    private static finalThreadLocal<ObjectMapper> INCLUDE_NULL_MAPPER = new ThreadLocal();

 

    private static finalThreadLocal<ObjectMapper> NOT_INCLUDE_NULL_MAPPER = new ThreadLocal();

 

    private staticObjectMapper getMapper(boolean serializeNull) {

        ThreadLocaltl = serializeNull ? INCLUDE_NULL_MAPPER : NOT_INCLUDE_NULL_MAPPER; //t1是引用变量，指向两者中的一个

        if (null == tl.get()){

            ObjectMappermapper = new ObjectMapper();

           

            mapper.disable(

                    newDeserializationConfig.Feature[] { DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES });

 

            mapper.setDateFormat(newSimpleDateFormat("yyyy-MM-dd"));

            if (!serializeNull){  //不包括null时

                mapper.setSerializationInclusion(JsonSerialize.Inclusion.NON_NULL);

                mapper.disable(newSerializationConfig.Feature[] { SerializationConfig.Feature.WRITE_NULL_MAP_VALUES });

            }

 

            tl.set(mapper);

        }

 

        return(ObjectMapper) tl.get();

    }

 

    public static StringtoJsonString(Object obj) throws JsonGenerationException, JsonMappingException,IOException {

        return toJsonString(obj, true);

    }

 

    public static StringtoJsonAsString(Object obj) throws JsonGenerationException, JsonMappingException,IOException {

        return toJsonAsString(obj, true);

    }

 

    public static byte[]toJsonAsBytes(Object obj) throws JsonGenerationException, JsonMappingException,IOException {

        return toJsonAsBytes(obj, true);

    }

 

    public static voidtoJsonToFile(File file, Object obj)

            throwsJsonGenerationException, JsonMappingException, IOException {

        toJsonToFile(file, obj, true);

    }

 

    public static voidtoJsonToOutputStream(OutputStream out, Object obj)

            throwsJsonGenerationException, JsonMappingException, IOException {

        toJsonToOutputStream(out, obj, true);

    }

 

    public static voidtoJsonToWriter(Writer writer, Object obj)

            throwsJsonGenerationException, JsonMappingException, IOException {

        toJsonToWriter(writer, obj, true);

    }

 

    public static<T> T toObject(String json, Class<T> clazz)

            throwsJsonParseException, JsonMappingException, IOException {

        return toObject(json, clazz, true);

    }

 

    public static<T> T toObject(byte[] src, Class<T> clazz)

            throwsJsonParseException, JsonMappingException, IOException {

        return toObject(src, clazz, true);

    }

 

    public static  <T> T toObject(File file,Class<T> clazz)

            throwsJsonParseException, JsonMappingException, IOException {

        return toObject(file, clazz, true);

    }

 

    public static<T> T toObject(InputStream input, Class<T> clazz)

            throwsJsonParseException, JsonMappingException, IOException {

        return toObject(input, clazz, true);

    }

 

    public static<T> T toObject(Reader reader, Class<T> clazz)

            throwsJsonParseException, JsonMappingException, IOException {

        return toObject(reader, clazz, true);

    }

 

    public static<T> T toObject(URL url, Class<T> clazz) throwsJsonParseException, JsonMappingException, IOException {

        return toObject(url, clazz, true);

    }

 

    public static StringtoJsonString(Object obj, boolean serializeNull)

            throwsJsonGenerationException, JsonMappingException, IOException {

        return getMapper(serializeNull).writeValueAsString(obj);  //Yue

    }

 

    public static StringtoJsonAsString(Object obj, boolean serializeNull)

            throwsJsonGenerationException, JsonMappingException, IOException {

        return getMapper(serializeNull).writeValueAsString(obj);  //Yue

    }

 

    public static byte[]toJsonAsBytes(Object obj, boolean serializeNull)

            throwsJsonGenerationException, JsonMappingException, IOException {

        return getMapper(serializeNull).writeValueAsBytes(obj);  //Yue

    }

 

    public static voidtoJsonToFile(File file, Object obj, boolean serializeNull)

            throwsJsonGenerationException, JsonMappingException, IOException {

        getMapper(serializeNull).writeValue(file, obj);  //Yue

    }

 

    public static voidtoJsonToOutputStream(OutputStream out, Object obj, boolean serializeNull)

            throwsJsonGenerationException, JsonMappingException, IOException {

        getMapper(serializeNull).writeValue(out, obj);  //Yue

    }

 

    public static voidtoJsonToWriter(Writer writer, Object obj, boolean serializeNull)

            throwsJsonGenerationException, JsonMappingException, IOException {

        getMapper(serializeNull).writeValue(writer, obj);  //Yue

    }

 

    //泛型方法的使用,为什么要使用泛型方法呢？因为泛型类要在实例化的时候就指明类型，如果想换一种类型，不得不重新new一次，可能不够灵活；而泛型方法可以在调用的时候指明类型，更加灵活。

//  需要注意，一个static方法，无法访问泛型类的类型参数，所以，若要static方法需要使用泛型能力，必须使其成为泛型方法。

    public static<T> T toObject(String json, Class<T> clazz, boolean serializeNull) 

            throwsJsonParseException, JsonMappingException, IOException {

        return getMapper(serializeNull).readValue(json, clazz);

    }

 

    public static <T>T toObject(byte[] src, Class<T> clazz, boolean serializeNull)

            throwsJsonParseException, JsonMappingException, IOException {

        return getMapper(serializeNull).readValue(src, clazz);

    }

 

    public static<T> T toObject(File file, Class<T> clazz, boolean serializeNull)

            throwsJsonParseException, JsonMappingException, IOException {

        return getMapper(serializeNull).readValue(file, clazz);

    }

 

    public static<T> T toObject(InputStream input, Class<T> clazz, boolean serializeNull)

            throwsJsonParseException, JsonMappingException, IOException {

        return getMapper(serializeNull).readValue(input, clazz);

    }

 

    public static<T> T toObject(Reader reader, Class<T> clazz, boolean serializeNull)

            throwsJsonParseException, JsonMappingException, IOException {

        return getMapper(serializeNull).readValue(reader, clazz);

    }

 

    public static<T> T toObject(URL url, Class<T> clazz, boolean serializeNull)

            throwsJsonParseException, JsonMappingException, IOException {

        return getMapper(serializeNull).readValue(url, clazz);

    }

 

    public static voidsetDateFormat(DateFormat dateFormat) {

        getMapper(true).setDateFormat(dateFormat);

        getMapper(false).setDateFormat(dateFormat);

    }

}

jitianxia68
关注
专栏目录
java json 工具类_Java 的 JSON 开源类库之JackSon工具类--JSONUtils
weixin_29447473的博客
02-16 380
Java 的 JSON 开源类库之JackSon工具类--JSONUtils，有需要的朋友可以参考下。JSON是JavaScriptObjectNotation的缩写，是一种轻量级的数据交换形式，是一种XML的替代方案，而且比XML更小，更快而且更易于解析。因为JSON描述对象的时候使用的是JavaScript语法，它是语言和平台独立的，并且这些年许多JSON的解析器和类库被开发出来。在这篇文章中...
json-Jackson简单使用介绍
玲儿叮当想
04-11 489
简介：         接下来介绍另外一中json工具-Jackson，Jackson是一个简单基于Java应用库，Jackson可以轻松的将Java对象转换成json对象和xml文档，同样也可以将json、xml转换成Java对象。Jackson所依赖的jar包较少，简单易用并且性能也要相对高些，并且Jackson社区相对比较活跃，更新速度也比较快。特点：容易使用 - jackson API提供...
Jackson使用详解
最新发布
长河的博客
07-01 740
Jackson 是当前用的比较广泛的，用来序列化和反序列化 json 的 Java 的开源框架。Jackson 社区相对比较活跃，更新速度也比较快， 从 Github 中的统计来看，Jackson 是最流行的 json 解析器之一。Spring MVC 的默认 json 解析器便是 Jackson。Jackson 优点很多。Jackson 所依赖的 jar 包较少 ，简单易用。与其他 Java 的 json 的框架 Gson 等相比， Jackson 解析大的 json 文件速度比较快；
at org.codehaus.jackson.map.ser.BeanSerializer.serialize(BeanSerializer.java:142) ：json转化“$ref 循环引用”...
weixin_30883777的博客
03-15 377
原因： entity实体中存在@OneToMany，@ManyToOne注解，在转化json是产生了循环引用 报的错误 解决方法： springmvc @ResponseBody 默认的json转化用的是 org.codehaus.jackson 这里两个实体类： 假如A对B 是一对多双向关联 死循环原因： JSON无法对A的属性List<B>进去JSON转换 ...
【jackson工具】使用jackson实现对象和json之间的转换
Evan_QB的博客
08-13 467
引入依赖： &lt;!-- jackson --&gt; &lt;dependency&gt; &lt;groupId&gt;org.codehaus.jackson&lt;/groupId&gt; &lt;artifactId&gt;jackson-core-asl&lt;/artifactId&gt; &lt;version&gt;1.9.13&
ObjectMapper工具包
scdncby的博客
10-29 7132
ObjectMapper类，是jackson包下一个类，java针对处理对象与json之间关系转换用的 不推荐使用。使用其他构造来代替; 注意，可以设置序列化工厂 类中引入对象 private static final JavaType JSON_NODE_TYPE = TypeFactory.type(JsonNode.class); protected static...
json4s-jackson_2.11-3.2.11-API文档-中文版.zip
05-01
赠送jar包：json4s-jackson_2.11-3.2.11.jar；...使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。
高性能的JSON处理 Jackson
06-02
本文将深入探讨Jackson库的核心特性、使用方法以及如何实现高性能的JSON处理。 ### Jackson库简介 Jackson是由FasterXML公司开发的开源项目，它在Java社区中被广泛使用，因其高效和强大的功能而备受推崇。Jackson库...
json转换工具jackson
08-04
Jackson是Java领域中处理JSON的主流库之一，由 FasterXML 组织开发，提供了高效且灵活的JSON序列化和反序列化功能。本文将深入探讨Jackson作为JSON转换工具的关键知识点，并基于提供的博文链接进行补充。 1. **...
Json 数据格式化 jackson
05-06
Jackson是Java中最流行的JSON处理库之一，由FasterXML团队开发，提供了高效且灵活的方式来序列化和反序列化Java对象为JSON格式。 Jackson库主要由三个核心模块组成，这与提供的压缩包文件中的jar文件对应： 1. **...
json4s-jackson-2.12-3.5.3-API文档-中文版.zip
07-06
赠送jar包：json4s-jackson_2.12-3.5.3.jar；...使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。
Jackson 读写 JSON
千里之行始于足下
05-25 2002
– Start ObjectMapper 提供了下面的 readValue 方法，帮助我们很方便的从不同的数据源读取对象。 readValue(String src, ...) readValue(File src, ...) readValue(URL src, ...) readValue(InputStream src, ...) readValue(DataInput src, ...) ...
jackson 转json. 过滤null值
weixin_34372728的博客
01-19 416
@Test public void tttttt() throws JsonGenerationException, JsonMappingException, IOException { ObjectMapper mapper = new ObjectMapper(); // 过滤对象的null属性. mapper.setSerializationInclusion(Inclusio...
java json 工具类_java json转换工具类
weixin_39668965的博客
02-16 120
package com.me.util;import lombok.extern.slf4j.Slf4j;import org.codehaus.jackson.map.DeserializationConfig;import org.codehaus.jackson.map.ObjectMapper;import org.codehaus.jackson.map.SerializationCon...
java json系列化_Json序列化java工具类
weixin_31349647的博客
02-16 404
json序列化通用工具类(java)>为了支持此工具类的正常使用，先导入以下jar包1.lombok包是一个简化java冗余代码的jar包，实际开发中很方便在maven的pom文件中导入lombok坐标org.projectlomboklombok1.16.182.json序列化jar包在maven的pom文件中导入lombok坐标org.codehaus.jacksonjackson-ma...
Jackson的使用(json解析)
陈如水的专栏
05-04 2635
代码如下: package com.example.administrator.jsckson.ui; import android.os.Bundle; import android.support.annotation.Nullable; import android.support.v7.app.AppCompatActivity; import android.util.Log; i
jackson-databind架包中的ObjectMapper
Chengqb的博客
05-17 1916
jackson-databind架包中的ObjectMapper目录1、ObjectMapper.readValue(json1, class1)2、ObjectMapper.writeValueAsString(class1) 注： 用于 model 对象（类和结构体）和 JSON 之间转换。 1、ObjectMapper.readValue(json1, class1) ​ 将json1字符串...
解决com.fasterxml.jackson.databind.JsonMappingException: No suitable 以 Jackson 处理复杂类型(List,map)两种方法
热门推荐
yinjayhui123的专栏
04-22 14万+
出现com.fasterxml.jackson.databind.JsonMappingException: No suitable 的情况有很多种，具体情况具体对待。 原因一： 在使用jackson 进行json字符串转java bean的时候出现如下错误，   com.fasterxml.jackson.databind.JsonMappingException: No suita
Jackson JSON 处理快速入门
以下是对Jackson库的一些主要特性和使用方法的详细说明： **Jackson特性：** 1. **易于使用**：Jackson API提供了一个高级接口，简化了常见的使用场景，使得开发者可以快速上手。 2. **无需创建映射**：对于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值