PHP 序列化和反序列化 for ActionScript 3.0

最新推荐文章于 2022-07-14 17:24:13 发布
最新推荐文章于 2022-07-14 17:24:13 发布
阅读量136 收藏
点赞数
分类专栏： Flash/as3 文章标签： ActionScript PHP phprpc Flash C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxyskycn/article/details/83488333
版权

Serializable.as

ActionScript代码 
/**********************************************************\  
|                                                          |  
| The implementation of PHPRPC Protocol 3.0                |  
|                                                          |  
| Serializable.as                                          |  
|                                                          |  
| Release 3.0.0                                            |  
| Copyright (c) 2005-2007 by Team-PHPRPC                   |  
|                                                          |  
| WebSite:  http://www.phprpc.org/                         |  
|           http://www.phprpc.net/                         |  
|           http://www.phprpc.com/                         |  
|           http://sourceforge.net/projects/php-rpc/       |  
|                                                          |  
| Authors:  Ma Bingyao <andot@ujn.edu.cn>                  |  
|                                                          |  
| This file may be distributed and/or modified under the   |  
| terms of the GNU Lesser General Public License (LGPL)    |  
| version 3.0 as published by the Free Software Foundation |  
| and appearing in the included file LICENSE.              |  
|                                                          |  
\**********************************************************/   
   
/* Serializable interface for custom PHP serialize.  
 *  
 * Copyright (C) 2006-2007 Ma Bingyao <andot@ujn.edu.cn>  
 * Version: 3.0  
 * LastModified: Oct 23, 2007  
 * This library is free.  You can redistribute it and/or modify it.  
 */   
   
package org.phprpc.util{   
    import flash.utils.ByteArray;   
    public interface Serializable {   
        function serialize():ByteArray;   
        function unserialize(ss:ByteArray):void;   
    }   
}
 

PHPSerializer.as

ActionScript代码 
/**********************************************************\  
|                                                          |  
| The implementation of PHPRPC Protocol 3.0                |  
|                                                          |  
| PHPSerializer.as                                         |  
|                                                          |  
| Release 3.0.0                                            |  
| Copyright (c) 2005-2007 by Team-PHPRPC                   |  
|                                                          |  
| WebSite:  http://www.phprpc.org/                         |  
|           http://www.phprpc.net/                         |  
|           http://www.phprpc.com/                         |  
|           http://sourceforge.net/projects/php-rpc/       |  
|                                                          |  
| Authors:  Ma Bingyao <andot@ujn.edu.cn>                  |  
|                                                          |  
| This file may be distributed and/or modified under the   |  
| terms of the GNU Lesser General Public License (LGPL)    |  
| version 3.0 as published by the Free Software Foundation |  
| and appearing in the included file LICENSE.              |  
|                                                          |  
\**********************************************************/   
/* PHP serialize/unserialize library for ActionScript 3.0.  
 *  
 * Copyright (C) 2006-2007 Ma Bingyao <andot@ujn.edu.cn>  
 * Version: 3.0  
 * LastModified: Nov 6, 2007  
 * This library is free.  You can redistribute it and/or modify it.  
 */   
package org.phprpc.util {   
    import org.phprpc.util.Serializable;   
    import flash.utils.ByteArray;   
    import flash.utils.Dictionary;   
    import flash.utils.getQualifiedClassName;   
    import flash.utils.getDefinitionByName;   
    public class PHPSerializer {   
        private static function isInteger(s:String):Boolean {   
            var i:int;   
            var l:int = s.length;   
            if (l > 11) {   
                return false;   
            }   
            for (i = (s.charAt(0) == '-') ? 1 : 0; i < l; i++) {   
                switch (s.charAt(i)) {   
                case '0' :   
                case '1' :   
                case '2' :   
                case '3' :   
                case '4' :   
                case '5' :   
                case '6' :   
                case '7' :   
                case '8' :   
                case '9' :   
                    break;   
                default :   
                    return false;   
                }   
            }   
            var n:Number = Number(s);   
            return !(n < -2147483648 || n > 2147483647);   
        }   
        public static function getClassName(o:*):String {   
            var className:String = getQualifiedClassName(o);   
            return className.replace(/\./g, '_').replace(/\:\:/g, '_');   
        }   
        private static function getObjectOfClass(cn:Array, poslist:Array, i:uint, c:String):Object {   
            if (i < poslist.length) {   
                var pos:uint = poslist[i];   
                cn[pos] = c;   
                var obj:Object = getObjectOfClass(cn, poslist, i + 1, '.');   
                if (i + 1 < poslist.length) {   
                    if (obj == null) {   
                        obj = getObjectOfClass(cn, poslist, i + 1, '_');   
                    }   
                }   
                return obj;   
            }   
            var classname:String = cn.join('');   
            try {   
                return new (flash.utils.getDefinitionByName(classname) as Class);   
            }   
            catch (e:Error) { };   
            return null;   
        }   
        public static function createObjectOfClass(classname:String):Object {   
            try {   
                return new (flash.utils.getDefinitionByName(classname) as Class);   
            }   
            catch (e:Error) {}   
            var poslist:Array = [];   
            var pos:int = classname.indexOf("_");   
            while (pos > -1) {   
                poslist[poslist.length] = pos;   
                pos = classname.indexOf("_", pos + 1);   
            }   
            if (poslist.length > 0) {   
                var cn:Array = classname.split('');   
                var obj:Object = getObjectOfClass(cn, poslist, 0, '.');   
                if (obj == null) {   
                    obj = getObjectOfClass(cn, poslist, 0, '_');   
                }   
                if (obj != null) {   
                    return obj;   
                }   
            }   
            return {name:classname};   
        }   
        public static function serialize(o:Object):ByteArray {   
            var sb:ByteArray = new ByteArray();   
            var ht:Dictionary = new Dictionary();   
            var hv:uint = 1;   
            function _serializeNull():void {   
                sb.writeUTFBytes('N;');   
            }   
            function _serializeBoolean(b:Boolean):void {   
                sb.writeUTFBytes(b ? 'b:1;' : 'b:0;');   
            }   
            function _serializeInteger(i:int):void {   
                sb.writeUTFBytes('i:' + i + ';');   
            }   
            function _serializeDouble(d:Number):void {   
                var s:String;   
                if (isNaN(d)) {   
                    s = 'NAN';   
                }   
                else if (d == Number.POSITIVE_INFINITY) {   
                    s = 'INF';   
                }   
                else if (d == Number.NEGATIVE_INFINITY) {   
                    s = '-INF';   
                }   
                else {   
                    s = d.toString(10);   
                }   
                sb.writeUTFBytes('d:' + s + ';');   
            }   
            function _serializeByteArray(ba:ByteArray):void {   
                ba.position = 0;   
                sb.writeUTFBytes('s:' + ba.length + ':"');   
                sb.writeBytes(ba);   
                sb.writeUTFBytes('";');                
            }   
            function _serializeString(s:String):void {   
                var utf8:ByteArray = new ByteArray();   
                utf8.writeUTFBytes(s);   
                sb.writeUTFBytes('s:' + utf8.length + ':"');   
                sb.writeBytes(utf8);   
                sb.writeUTFBytes('";');   
            }   
            function _serializeDate(dt:Date):void {   
                sb.writeUTFBytes('O:11:"PHPRPC_Date":7:{');   
                sb.writeUTFBytes('s:4:"year";');   
                _serializeInteger(dt.getFullYear());   
                sb.writeUTFBytes('s:5:"month";');   
                _serializeInteger(dt.getMonth() + 1);   
                sb.writeUTFBytes('s:3:"day";');   
                _serializeInteger(dt.getDate());   
                sb.writeUTFBytes('s:4:"hour";');   
                _serializeInteger(dt.getHours());   
                sb.writeUTFBytes('s:6:"minute";');   
                _serializeInteger(dt.getMinutes());   
                sb.writeUTFBytes('s:6:"second";');   
                _serializeInteger(dt.getSeconds());   
                sb.writeUTFBytes('s:11:"millisecond";');   
                _serializeInteger(dt.getMilliseconds());   
                sb.writeUTFBytes('}');   
            }   
            function _serializeArray(a:Object):void {   
                var k:String;   
                var l:uint = 0;   
                for (k in a) l++;   
                sb.writeUTFBytes('a:' + l + ':{');   
                for (k in a) {   
                    if (typeof (a[k]) != 'function') {   
                        isInteger(k) ? _serializeInteger(k) : _serializeString(k);   
                        _serialize(a[k]);   
                    }   
                }   
                sb.writeUTFBytes('}');   
            }   
            function _serializeObject(o:Object, cn:String):void {   
                var c:Serializable = o as Serializable;   
                var cnb:ByteArray = new ByteArray();   
                cnb.writeUTFBytes(cn);   
                if (c == null) {   
                    sb.writeUTFBytes('O:' + cnb.length + ':"');   
                    sb.writeBytes(cnb);   
                    var k:String;   
                    var l:uint = 0;   
                    for (k in o) l++;   
                    sb.writeUTFBytes('":' + l + ':{');                     
                    for (k in o) {   
                        if (typeof(o[k]) != 'function') {   
                            _serializeString(k);   
                            _serialize(o[k]);   
                        }   
                    }   
                    sb.writeUTFBytes('}');   
                }   
                else {   
                    var data:ByteArray = c.serialize();   
                    sb.writeUTFBytes('C:' + cnb.length + ':"');   
                    sb.writeBytes(cnb);   
                    sb.writeUTFBytes('":' + data.length + ':{');   
                    sb.writeBytes(data);   
                    sb.writeUTFBytes('}');   
                }   
            }   
            function _serializePointRef(R:uint):void {   
                sb.writeUTFBytes('R:' + R + ';');   
            }   
            function _serializeRef(r:uint):void {   
                sb.writeUTFBytes('r:' + r + ';');   
            }   
            function _serialize(o:*):void {   
                if (typeof (o) == "undefined" || o == null || o.constructor == Function) {   
                    hv++;   
                    _serializeNull();   
                    return;   
                }   
                var className:String = getClassName(o);   
                switch (o.constructor) {   
                case Boolean :   
                    hv++;   
                    _serializeBoolean(o);   
                    break;   
                case Number :   
                    hv++;   
                    isInteger(o) ? _serializeInteger(o) : _serializeDouble(o);   
                    break;   
                case String :   
                    hv++;   
                    _serializeString(o);   
                    break;   
                case ByteArray :   
                    hv++;   
                    _serializeByteArray(o);   
                    break;   
                case Date :   
                    hv++;   
                    _serializeDate(o);   
                    break;   
                default :   
                    var r:int = ht[o];   
                    if (className == "Object" || o.constructor == Array) {   
                        if (r) {   
                            _serializePointRef(r);   
                        }   
                        else {   
                            ht[o] = hv++;   
                            _serializeArray(o);   
                        }   
                    }   
                    else {   
                        if (r) {   
                            hv++;   
                            _serializeRef(r);   
                        }   
                        else {   
                            ht[o] = hv++;   
                            _serializeObject(o, className);   
                        }                      
                    }   
                    break;   
                }   
            }   
            _serialize(o);   
            return sb;   
        }   
        public static function unserialize(sb:ByteArray):* {   
            var ht:Dictionary = new Dictionary();   
            var hv:int = 1;   
            function _readNumber():String {   
                var s:String = '';   
                var c:String = sb.readUTFBytes(1);   
                while ((c != ';') && (c != ':')) {   
                    s += c;   
                    c = sb.readUTFBytes(1);   
                }   
                return s;   
            }   
            function _unserializeNull():Object {   
                sb.position++;   
                return null;   
            }   
            function _unserializeBoolean():Boolean {   
                sb.position++;   
                var b:Boolean = (sb.readUTFBytes(1) == '1');   
                sb.position++;   
                return b;   
            }   
            function _unserializeInteger():int {   
                sb.readByte();   
                var i:int = parseInt(_readNumber());   
                return i;   
            }   
            function _unserializeDouble():Number {   
                sb.position++;   
                var d:Number;   
                var s:String = _readNumber();   
                switch (s) {   
                case 'NAN' :   
                    d = Number.NaN;   
                    break;   
                case 'INF' :   
                    d = Number.POSITIVE_INFINITY;   
                    break;   
                case '-INF' :   
                    d = Number.NEGATIVE_INFINITY;   
                    break;   
                default :   
                    d = parseFloat(s);   
                }   
                return d;   
            }   
            function _unserializeByteArray():ByteArray {   
                sb.position++;   
                var l:uint = parseInt(_readNumber());   
                sb.position++;   
                var ba:ByteArray = new ByteArray();   
                if (l > 0) {   
                    sb.readBytes(ba, 0, l);   
                }   
                sb.position += 2;   
                return ba;   
            }   
            function _unserializeString():String {   
                sb.position++;   
                var l:uint = parseInt(_readNumber());   
                sb.position++;   
                var s:String = sb.readUTFBytes(l);   
                sb.position += 2;   
                return s;   
            }   
            function _unserializeEscapedString(len:int):String {   
                sb.position++;   
                var l:uint = parseInt(_readNumber());   
                sb.position++;   
                var i:int;   
                var s:Array = new Array(l);   
                for (i = 0; i < l; i++) {   
                    if ((s[i] = sb.readUTFBytes(1)) == '\\') {   
                        s[i] = String.fromCharCode(parseInt(sb.readUTFBytes(len), 16));   
                    }   
                }   
                sb.position += 2;   
                return s.join('');   
            }   
            function _unserializeArray():Array {   
                sb.position++;   
                var n:int = parseInt(_readNumber());   
                sb.position++;   
                var i:int;   
                var k:*;   
                var a:Array = [];   
                ht[hv++] = a;   
                for (i = 0; i < n; i++) {   
                    switch (sb.readUTFBytes(1)) {   
                    case 'i' :   
                        k = _unserializeInteger();   
                        break;   
                    case 's' :   
                        k = _unserializeString();   
                        break;   
                    case 'S' :   
                        k = _unserializeEscapedString(2);   
                        break;   
                    case 'U' :   
                        k = _unserializeEscapedString(4);   
                        break;   
                    default :   
                        return null;   
                    }   
                    a[k] = _unserialize();   
                }   
                sb.position++;   
                return a;   
            }   
            function _unserializeDate(n:int):Date {   
                var i:int;   
                var k:String;   
                var a:Object = {};   
                for (i = 0; i < n; i++) {   
                    switch (sb.readUTFBytes(1)) {   
                    case 's' :   
                        k = _unserializeString();   
                        break;   
                    case 'S' :   
                        k = _unserializeEscapedString(2);   
                        break;   
                    case 'U' :   
                        k = _unserializeEscapedString(4);   
                        break;   
                    default :   
                        return null;   
                    }   
                    if (sb.readUTFBytes(1) == 'i') {   
                        a[k] = _unserializeInteger();   
                    }   
                    else {   
                        return null;   
                    }   
                }   
                sb.position++;   
                var dt:Date = new Date(a.year, a.month - 1, a.day, a.hour, a.minute, a.second, a.millisecond);   
                ht[hv++] = dt;   
                return dt;   
            }   
            function _unserializeObject():* {   
                sb.position++;   
                var l:uint = parseInt(_readNumber());   
                sb.position++;   
                var cn:String = sb.readUTFBytes(l);   
                sb.position += 2;   
                var n:uint = parseInt(_readNumber());   
                sb.position++;   
                if (cn == "PHPRPC_Date") {   
                    return _unserializeDate(n);   
                }   
                var i:int;   
                var k:String;   
                var o:Object = createObjectOfClass(cn);   
                ht[hv++] = o;   
                for (i = 0; i < n; i++) {   
                    switch (sb.readUTFBytes(1)) {   
                    case 's' :   
                        k = _unserializeString();   
                        break;   
                    case 'S' :   
                        k = _unserializeEscapedString(2);   
                        break;   
                    case 'U' :   
                        k = _unserializeEscapedString(4);   
                        break;   
                    default :   
                        return false;   
                    }   
                    if (k.charAt(0) == '\0') {   
                        k = k.substring(k.indexOf('\0', 1) + 1, k.length);   
                    }   
                    o[k] = _unserialize();   
                }   
                sb.position++;   
                return o;   
            }   
            function _unserializeCustomObject():* {   
                sb.position++;   
                sb.position++;   
                var l:uint = parseInt(_readNumber());   
                sb.position++;   
                var cn:String = sb.readUTFBytes(l);   
                sb.position += 2;   
                var n:uint = parseInt(_readNumber());   
                sb.position++;   
                var data:ByteArray = new ByteArray();   
                sb.readBytes(data, 0, n);   
                sb.position++;   
                var o:Object = createObjectOfClass(cn);   
                var c:Serializable = o as Serializable;   
                if (c == null) {   
                    o.data = data;   
                    return o;   
                }   
                c.unserialize(data);   
                return c;   
            }   
            function _unserializeRef():* {   
                sb.position++;   
                var r:uint = parseInt(_readNumber());   
                return ht[r];   
            }   
            function _unserialize():* {   
                var result:*;   
                switch (sb.readUTFBytes(1)) {   
                case 'N' :   
                    result = _unserializeNull();   
                    ht[hv] = result;   
                    hv++;   
                    return result;   
                case 'b' :   
                    result = _unserializeBoolean();   
                    ht[hv] = result;   
                    hv++;   
                    return result;   
                case 'i' :   
                    result = _unserializeInteger();   
                    ht[hv] = result;   
                    hv++;   
                    return result;   
                case 'd' :   
                    result = _unserializeDouble();   
                    ht[hv] = result;   
                    hv++;   
                    return result;   
                case 's' :   
                    result = _unserializeByteArray();   
                    ht[hv] = result;   
                    hv++;   
                    return result;   
                case 'S' :   
                    result = _unserializeEscapedString(2);   
                    ht[hv] = result;   
                    hv++;   
                    return result;   
                case 'U' :   
                    result = _unserializeEscapedString(4);   
                    ht[hv] = result;   
                    hv++;   
                    return result;   
                case 'r' :   
                    result = _unserializeRef();   
                    ht[hv] = result;   
                    hv++;   
                    return result;   
                case 'a' :   
                    return _unserializeArray();   
                case 'O' :   
                    return _unserializeObject();   
                case 'C' :   
                    return _unserializeCustomObject();   
                case 'R' :   
                    return _unserializeRef();   
                }   
                return false;   
            }   
            sb.position = 0;   
            return _unserialize();   
        }   
    }   
}
 
zxyskycn
关注
专栏目录
PHPSerializer.java
06-17
php的serialize/unserialize，方便把一个数组序列化和反序列化，但是要和java交互，就比较麻烦了。通过这个工具类可实现很好的php与java的交互。 博客地址：https://blog.csdn.net/u011582840/article/details/92650656，可以查看如何使用
php-serializer:用于快速操作大型序列化数组的库
06-22
PHP序列化程序 该库正在进行中。 在使用phpunit之前测试任何构建。 用于快速操作大型序列化字符串的库， PHPSerializer 旨在提高的效率 在 PHP 中，如果您有一个序列化数组，并且希望向该数组添加一个项目，则需要执行以下操作： $data = unserialize($serialized); array_push($data, 'some-new-item'); $serialized = unserialize($data); 这有什么问题？ 好吧，为这样一个简单的操作反序列化整个数组是非常低效的。 如果您正在反序列化一个小数组或者您不经常这样做，那么这可能没问题，但如果您处于重负载设置中，则必须有更好的方法。 PHPSerializer 背后的想法本质上是根据操作以最有效的方式解析和流式传输序列化的字符串，而不是unserialize()为每个函数处理
java反序列化 （PHPSerializer 序列化的对象）
Henry_Lin_Wind的博客
04-07 2971
java反序列化php序列化的对象 1、原始数据为一个字符串 2、原始数据为一个对象 3、原始数据为一个集合（List 或Map） 1、反序列化为java字符串 s:21:"这是一个字符串"; String str = "s:21:\"这是一个字符串\""; PHPSerializer phpSerializer = new PHPSerializer(); Object o...
java php序列化_java 反序列化PHP
weixin_36068796的博客
02-12 189
由于本人所在开发的项目，前期是由php完成的，这里需要对数据库中php序列化的字符串进行反序列化。1、引入maven依赖org.sctionphprpc3.0.22、反序列化对象方法public static Test getUnserialize(String content) throws Exception {PHPSerializer p = new PHPSerializer();if ...
phprpc.jar 包java 反序列化PHP工程demo
03-30
java 反序列化PHP ,java解析php序列化的字符串，工具包和工程实例
ActionScript3.0对象序列化：代码示例与本地文件操作
"该文档提供ActionScript3.0对象序列化的代码示例，涉及如何将数据写入本地文件。...通过理解和应用这些知识点，你可以有效地在ActionScript3.0项目中实现对象序列化，从而实现数据的持久化和跨程序通信。
flex api 3.6 带序列化反序列化的标绘
08-21
在Flex中，我们可以使用ActionScript 3.0的内置功能进行序列化和反序列化。例如，`flash.utils.ObjectOutput`和`flash.utils.ObjectInput`接口可用于将数据写入或读出二进制流。这对于持久化数据、跨域通信或者在...
聊天室ActionScript 3.0实现
04-08
4. **数据序列化与反序列化**：聊天室中的信息需要在网络间传输，这就涉及到了数据的序列化和反序列化。AS3提供了ObjectOutput和ObjectInput类，可以将对象转换为二进制数据流，方便在网络中传输，然后再在另一端...
聊天室（ActionScript 3.0）
10-23
2. **数据传输格式**：通常，聊天室会采用JSON或XML等轻量级的数据交换格式，便于解析和序列化消息内容。ActionScript 3.0提供了内置的`JSON`和`XML`对象来处理这两种格式。 3. **事件驱动编程**：ActionScript 3.0...
java 序列化成PHP格式。
08-18
将java数据 序列化成PHP的格式 a:4:{s:6:"title2";s:13:"这是标题2";s:6:"title3";s:13:"这是标题3";s:5:"title";s:13:"这是标题1";s:6:"title4";s:13:"这是标题4";} 或者a:1:{i:0;a:1:{s:4:"name";s:10:"这是1321";}}等其他类型
java序列化对象传给php
01-17
android(包括java)序列化一个对象传给php去做处理,或是接到php的序列化的对象在java中做处理的工具jar包以及使用方法. 使用方法: byte[] b = null; b = PHPSerializer.serialize(一个对象);//将一个对象序列化后返回byte[] String phpserialstr=new String(b); 将变量phpserialstr传给php即可. PHPSerializer中还有unserialize方法,是反序列化
java 对象的序列化与反序列化
06-21
java 对象的序列化与反序列化 java 对象的序列化与反序列化
Java序列化Jar包
01-16
该资源提供了java常见的三个序列化框架，分别是：JBoss Marshalling，messagePack，protobuf-java
java反序列化 PHPSerializer 序列化的对象参数描述
一起进步的博客
07-01 889
maven 引用的包 <!--反序列化 php--> <dependency> <groupId>org.sction</groupId> <artifactId>phprpc</artifactId> <version>3.0.2</version> </dependency 主要的操作方法： public static Map<String, Ob
Java之模拟PHP序列化serialize()/反序列化unserialize()方法
netuser1937的博客
11-08 1771
PHP的serialize()/unserialize()，方便把一个数组序列化和反序列化。 Java的serialize，序列化之后，会把java.util…包名都放进去了，而且格式也不同于php， 对于汉字 php 占用2个字符，java占用一个字符，隐藏php序列化后，再由java 反序列化，可能导致乱码。 PHPSerializer 工具类： 当前版本实现了对各种基本类型、数组、ArrayList、HashMap、和其它可序列化对象的序列化。实现了 PHP 5 中的 Serializable 接口的
序列化 Serializable
Lan_Se_Tian_Ma的博客
10-03 133
例：创建一个对象，里面有 hello word，把这个对象传输给其他电脑， 传输过程：先从我的电脑内存中出来，进入网线，这刹那转换成二进制或ascii编码格式，进行传输（这个过程称为序列化） 然后经过交换机，来到其他电脑，进入内存，从二进制转换回对象（这个过程称为反序列化） 为什么实体类不加Serializable不报异常，因为是在自己的电脑里操作，没有和外界有传输，对象根本没有出内存，出了内...
php序列化 java对象_将php序列化到数据库的对象饭序列化成java对象
weixin_39553272的博客
02-13 145
php的对象序列化到数据库中，形如a:3:{i:0;i:1241;i:1;i:4;i:2;i:16;}但是java需要取出这样的对象，转换成java的对象/* PHPSerializer.java** Author: Ma Bingyao * Copyright: CoolCode.CN* Version: 2.1* LastModified: 2006-08-09* This library i...
记录PHPSerializer工具类反序列化遇到的坑
cxclll的博客
07-14 607
PHPSerializer工具类反序列化失败
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值