下载文档原格式
deserializeobject转jobject ［deserializeObject转jobject］在计算机编程中，数据的序列化是将数据结构或对象转化为可存储或传输的格式的过程。
而反序列化则是将序列化后的数据重新还原成原始的数据结构或对象。
在许多编程语言中，包括Java和C#等，都提供了相应的序列化和反序列化的功能。
在这篇文章中，我们将重点讨论Java中的deserializeObject 转jobject的过程。
第一步：了解序列化和反序列化的概念在开始具体讨论deserializeObject转jobject之前，我们首先需要了解什么是序列化和反序列化。
序列化是将对象转化为字节流的过程，而反序列化则是将字节流还原为原始对象的过程。
在Java中，序列化和反序列化是通过Java对象流实现的。
序列化对象需要实现Serializable接口，该接口没有任何方法，只是一个标志接口，用于表示该对象是可序列化的。
第二步：使用Gson库进行反序列化在Java中，可以使用多种方式进行反序列化操作。
其中一种常用的方式是使用Gson库，它是Google开发的一个将Java对象转化为JSON格式的库。
首先，我们需要添加Gson库的依赖。
可以通过Maven或Gradle将其添加到项目中。
接下来，我们需要创建一个Gson对象，该对象将用于执行反序列化操作。
可以使用以下代码创建一个Gson对象：Gson gson = new Gson();然后，我们可以使用gson对象的fromJson方法将JSON格式的字符串转化为Java对象。
如下所示：String jsonString = "{\"name\":\"Alice\",\"age\":25}";Person person = gson.fromJson(jsonString, Person.class);上述代码中，我们创建了一个包含name和age属性的JSON字符串。
![BurpWeb安全学院[不安全的反序列化]](https://img.taocdn.com/s1/m/1c27ed1491c69ec3d5bbfd0a79563c1ec5dad7fd.png)
BurpWeb安全学院[不安全的反序列化]介绍burpsuite官⽹上⼀套不安全的反序列化实验(免费)本⽂是在这个实验室学习的记录有针对实验的解决,也有别的⼀些如何识别不安全的反序列化测试不安全的反序列化之前,您肯定要能够识别出序列化对象,下⾯简略介绍两种语⾔的序列化格式以便您能够在遇到它们的时候识别出它们PHP序列化格式PHP的序列化对象是可读的，可以⽤⽂本表⽰的(JAVA的则是⼆进制流,您⽆法⽤⽂本阅读器查看)其中字母代表数据类型，数字代表每项的长度若 User具有以下属性的对象：$user->name = "carlos";$user->isLoggedIn = true;序列化后，该对象可能看起来像这样：O:4:"User":2:{s:4:"name":s:6:"carlos"; s:10:"isLoggedIn":b:1;}解释:O:4:"User"- 具有4个字符的类名称的对象 "User"2 -对象具有2个属性s:4:"name" -第⼀个属性的键是4个字符的字符串 "name"s:6:"carlos" -第⼀个属性的值是6个字符的字符串 "carlos"s:10:"isLoggedIn" -第⼆个属性的键是10个字符的字符串 "isLoggedIn"b:1 -第⼆个属性的值是布尔值 truePHP 序列化的⽅法是serialize()和unserialize()Java序列化格式JAVA(还有⼀些别的语⾔Ruby等) 使⽤⼆进制序列化格式这使⼈难以阅读，但是序列化数据有⼀些固定的特征例如，序列化的Java对象始终以相同的字节开头，它们是 ac edBase64下显⽰为显⽰rO0。
成为专业程序员路上用到的各种优秀资料、神器及框架本文是鄙人工作这几年随手收集整理的一些自认为还不错的资料，成长的道理上需要积累，这么长时间了，是时候放出来分享下了，或许能帮助到你。
欢迎点赞，让更多人看到，让福利普照。
因为本文以后不会更新，但项目依旧会更新。
所以，更好的做法是，请到GitHub上Star：stanzhai-be-a-professional-programmer成为一名专业程序员的道路上，需要坚持练习、学习与积累，技术方面既要有一定的广度，更要有自己的深度。
笔者作为一位tool mad，将工作以来用到的各种优秀资料、神器及框架整理在此，毕竟好记性不如烂键盘，此项目可以作为自己的不时之需。
本人喜欢折腾，记录的东西也比较杂，各方面都会有一些，内容按重要等级排序，大家各取所需。
这里的东西会持续积累下去，欢迎Star，也欢迎发PR给我。
技术站点必看书籍大牛博客GitHub篇工具篇平台工具常用工具第三方服务爬虫相关(好玩的工具)安全相关Web服务器性能-压力测试工具-负载均衡器大数据处理-数据分析-分布式工具Web前端语言篇C游戏开发相关日志聚合，分布式日志收集RTP,实时传输协议与音视频技术站点在线学习：Coursera、edX、Udacity?-way to explore国内老牌技术社区：OSChina、博客园、CSDN、51CTO 免费的it电子书：ITeBooks - Free Download - Big Library在线学习：UdemyCrowd-sourced code mentorship. and Practicecoding with fun programming challenges - CodinGameDevStore:开发者服务商店MSDN：微软相关的官方技术集中地，主要是文档类必看书籍SICP(Structureand Interpretation of Computer Programs)深入理解计算机系统代码大全2人件人月神话软件随想录算法导论（麻省理工学院出版社）离散数学及其应用设计模式编程之美黑客与画家编程珠玑The Little SchemerSimply Scheme_Introducing_Computer_ScienceC++ PrimeEffective C++TCP-IP详解Unix 编程艺术技术的本质软件随想录计算机程序设计艺术职业篇：程序员的自我修养,程序员修炼之道,高效能程序员的修炼《精神分析引论》弗洛伊德《失控》《科技想要什么》《技术元素》凯文凯利程序开发心理学天地一沙鸥搞定：无压力工作的艺术大牛博客云风（游戏界大牛）: 云风的Tian (binghe)R大【干货满满】RednaxelaFX写的文章-回答的导航帖陈皓-左耳朵耗子：酷壳 - CoolShellJeff Atwood（国外知名博主）: CodingHorror阮一峰（黑客与画家译者，Web）：RuanYiFeng’s Personal Website廖雪峰（他的Python、Git教-程不少人都看过）：HomeGitHub篇Awesome:这是个Awesome合集，常见的资料这里面都能找到Awesome2:类似第一个Awesome杂七杂八、有用没用的Awesome合集非常不错的语言类学习资料集合：Awesomenessawesome-ios-uiawesome-android-uiAwesome-MaterialDesi gnawesome-public-datasetsawesome-AppSec(系统安全)awesome-datascience书籍资料free-programming-books中文版免费的编程中文书籍索引《程序员编程艺术—面试和算法心得》GoBooksPapersLearning)深入学习(Deep Learning)资料Docker资料合集学习使用StromHadoopInternalsSparkInternals大数据时代的数据分析与数据挖掘in DatabasesDataScience blogs日志：每个软件工程师都应该知道的有关实时数据的统一概念AndroidCode PathAndroidLearn NotesPHP类库框架，资料集合优秀项目Design开源项目Android开源项目分类汇总前端 Node.jsGuide的中文分支Angular2学习资料AngularJS应用的最佳实践和风格指南React-Native学习指南七天学会NodeJSnode.js中文资料导航Nodejs学习路线图如何学习nodejs工作，工具系统管理员工具集合ProGitNginx开发从入门到精通Google全球 IP 地址库收集整理远程工作相关的资料Colorschemes for hackers游戏开发工具集，MagicTools开发者工具箱， free-for-devGitHub秘籍Git风格指南Bast-App平台工具常用工具Mac下的神兵利器asciinema:- 免费在线作图，实时协作Origami: 次世代交互设计神器百度脑图：百度脑图第三方服务DnsPod：一个不错的只能DNS服务解析提供商DigitalOcean：海外的云主机提供商，价格便宜，磁盘是SSD的，用过一段时间整体上还可以，不过毕竟是海外的，网速比较慢。
0ctf_2016_unserialize writeup -回复如何解决0ctf 2016 CTF比赛中的unserialize漏洞题目。
在CTF比赛中，unserialize漏洞题目是一类常见的Web安全问题。
这类问题通常涉及到对PHP的序列化和反序列化机制的理解和利用。
本文将以0ctf 2016比赛中的unserialize题目为例，详细说明如何解决这类问题。
0ctf 2016比赛是一个国际性的CTF比赛，旨在测试参赛者在网络安全领域的技术能力。
unserialize题目是其中一个Web安全类题目，主要考察参赛者对PHP序列化与反序列化机制的理解和利用。
题目的描述如下：用户可以通过一个表单提交他们的名字，并在名字中注入一段PHP代码。
服务器会将用户提交的名字进行序列化，并在后端存储。
当用户再次访问网站时，服务器会将存储的序列化数据反序列化并执行。
参赛者需要利用这个漏洞，执行任意的PHP代码。
首先，我们需要了解PHP的序列化和反序列化机制。
在PHP中，可以通过serialize()函数将一个PHP对象转化为一个字符串。
这个字符串包含了对象的属性名和属性值。
反之，可以通过unserialize()函数将这个字符串重新转化为一个PHP对象。
这样，我们就可以在一个请求中保存一个对象的状态，并在另一个请求中重新恢复这个对象。
在这个题目中，我们可以通过用户提交的名字注入一段PHP代码并执行，从而实现任意代码执行。
为了解决这个问题，我们需要探索序列化和反序列化机制中的一些细节。
首先，我们需要了解序列化和反序列化函数的使用方式。
在PHP中，可以通过序列化函数serialize()将一个对象转化为一个字符串，并通过反序列化函数unserialize()将这个字符串转化回对象。
接着，我们需要了解序列化和反序列化过程中的一些细节。
在PHP的序列化过程中，对象的私有属性和受保护属性会被序列化，而公共属性和静态属性不会被序列化。
php序列化（serialize）格式详解1．前⾔PHP （从 PHP 3.05 开始）为保存对象提供了⼀组序列化和反序列化的函数：serialize、unserialize。
不过在 PHP ⼿册中对这两个函数的说明仅限于如何使⽤，⽽对序列化结果的格式却没做任何说明。
因此，这对在其他语⾔中实现 PHP ⽅式的序列化来说，就⽐较⿇烦了。
虽然以前也搜集了⼀些其他语⾔实现的 PHP 序列化的程序，不过这些实现都不完全，当序列化或反序列化⼀些⽐较复杂的对象时，就会出错了。
于是我决定写⼀份关于 PHP 序列化格式详解的⽂档（也就是这⼀篇⽂档），以便在编写其他语⾔实现的 php 序列化程序时能有⼀个⽐较完整的参考。
这篇⽂章中所写的内容是我通过编写程序测试和阅读 PHP 源代码得到的，所以，我不能 100% 保证所有的内容都是正确的，不过我会尽量保证我所写下的内容的正确性，对于我还不太清楚的地⽅，我会在⽂中明确指出，也希望⼤家能够给予补充和完善。
2．概述PHP 序列化后的内容是简单的⽂本格式，但是对字母⼤⼩写和空⽩（空格、回车、换⾏等）敏感，⽽且字符串是按照字节（或者说是 8 位的字符）计算的，因此，更合适的说法是 PHP 序列化后的内容是字节流格式。
因此⽤其他语⾔实现时，如果所实现的语⾔中的字符串不是字节储存格式，⽽是 Unicode 储存格式的话，序列化后的内容不适合保存为字符串，⽽应保存为字节流对象或者字节数组，否则在与 PHP 进⾏数据交换时会产⽣错误。
PHP 对不同类型的数据⽤不同的字母进⾏标⽰，Yahoo 开发⽹站提供的 Using Serialized PHP with Yahoo! Web Services ⼀⽂中给出所有的字母标⽰及其含义：a - arrayb - boolean d - double i - integer o - common object r - reference s - string C - custom object O - class N - null R - pointer reference U - unicode stringN 表⽰的是 NULL，⽽ b、d、i、s 表⽰的是四种标量类型，⽬前其它语⾔所实现的 PHP 序列化程序基本上都实现了对这些类型的序列化和反序列化，不过有⼀些实现中对 s （字符串）的实现存在问题。
php调用java方法如何使用PHP调用Java方法。
首先，需要明确的是，PHP是一种服务器端脚本语言，而Java是一种编程语言。
虽然它们可以在服务器上一起使用，但是直接在PHP中调用Java方法是不可能的。
不过，可以通过一些中间桥接的方式，在PHP中间接地调用Java方法。
下面，我将为您详细介绍如何使用PHP调用Java方法的步骤。
第一步：编写Java类和方法首先，您需要编写一个包含您想要调用的Java方法的Java类。
假设您要调用的方法名为"helloWorld"，它接受一个字符串参数并返回一个字符串结果。
以下是一个示例的Java类代码：javapublic class HelloWorld {public static String helloWorld(String name) {return "Hello, " + name + "!";}}保存上述代码并使用Java编译器编译生成字节码文件。
第二步：将Java类打包成JAR文件要在PHP中调用Java方法，需要将编写的Java类打包成JAR文件。
您可以使用Java自带的`jar`命令或其他可用的Java打包工具来完成此操作。
以下是使用`jar`命令将上述Java类打包成JAR文件的示例代码：shelljar cvf HelloWorld.jar HelloWorld.class此命令将生成一个名为"HelloWorld.jar"的JAR文件，其中包含编译后的Java类。
第三步：在PHP中调用Java方法到目前为止，您已经编写了Java类并将其打包成JAR文件，现在您可以在PHP中调用该类的方法了。
首先，确保PHP服务器上已经安装了Java，并可以通过命令行访问到Java 虚拟机（JVM）。
然后，使用PHP的`exec()`函数执行Java命令来调用您的Jar文件中的方法。
java嵌套对象序列化_java–使用RestTemplate反序列化嵌套对象使用RestTemplate反序列化嵌套对象是在Java中进行网络请求和处理返回数据的一种常见方式。
在这个过程中，我们通常会遇到需要将返回的数据序列化成嵌套对象的情况。
嵌套对象是指一个对象中包含了其他对象作为其属性或字段的情况。
例如，假设我们有一个User对象，其中包含一个Address对象作为其属性。
在进行网络请求时，我们可能会得到一个包含User对象的JSON字符串，其中包含了Address对象的信息。
首先，我们需要定义一个User类和一个Address类来表示嵌套对象的结构。
```javapublic class Userprivate String name;private int age;private Address address;// 省略构造函数、getter和setter方法public class Addressprivate String city;private String street;private int zipCode;// 省略构造函数、getter和setter方法```接下来，我们可以使用RestTemplate来发送网络请求，并将返回的数据反序列化成嵌套对象。
```javaRestTemplate restTemplate = new RestTemplate(;User user = restTemplate.getForObject(url, User.class);```在这里，我们使用RestTemplate的`getForObject`方法发送GET请求，并将返回的JSON字符串反序列化成User对象。
但是，这样的方式只能将最外层的User对象正确反序列化，而不能正确反序列化嵌套的Address对象。
为了解决这个问题，我们需要使用Jackson库提供的`TypeReference`类。
php session的序列化规则
在PHP中，session数据是通过序列化和反序列化进行存储和
读取的。
序列化是将数据对象转换为字符串的过程，反序列化则是将字符串转换回数据对象的过程。
在PHP中，session数据的序列化规则如下：
1. 对象的属性名将被转换为字符串，并作为数组的键。
2. 对象的属性值会被转换为相应的值类型，例如字符串、整数、浮点数等。
3. 对象的方法和静态属性将不会被序列化，只有对象的状态数据会被序列化。
4. 数组中的键名会被转换为字符串，如果键名是一个有效的整数字符串（例如"123"），则会被转换为整数类型。
在序列化过程中，PHP会将session数据转换为一个字符串，
并存储在session文件或内存中。
当需要读取session数据时，PHP会将字符串反序列化为一个数组，然后可以通过键名访
问对应的数据。
需要注意的是，某些数据类型（如资源、闭包等）是无法被序列化的，如果在session中保存了这些类型的数据，反序列化
时可能会导致错误。
serializable类型字段转对象-概述说明以及解释1.引言概述部分的内容可以描述一下serializable类型字段的基本概念和作用，以及为什么将其转为对象是一个重要的需求。
下面是一个可能的概述部分的例子：引言1.1 概述在软件开发过程中，我们经常会遇到需要在不同的应用程序或不同的系统之间传输数据的情况。
其中，使用serializable类型字段来存储和传输数据是一种常见的方式。
Serializable是Java中的一个接口，它的作用是标识一个类的实例可以被序列化，即可以将对象转化为字节序列以便在网络上传输或者保存到文件中。
通过将对象序列化为字节流，我们可以实现跨平台、跨语言的数据传输和存储。
然而，将数据以serializable类型字段的形式进行传输或存储并不方便，因为它们往往是以二进制的形式存在，不易读取和理解。
因此，将serializable类型字段转为对象是一个非常重要的需求。
通过将其转为对象，我们可以更方便地对数据进行操作、分析和理解。
另外，将serializable 类型字段转为对象也可以帮助我们更好地利用对象的属性和方法，从而实现更复杂的功能。
本文将介绍如何将serializable类型字段转为对象，并探讨转换它们的重要性和未来可能的发展方向。
深入了解和应用这些技术，将会大大提高我们在数据处理和系统集成中的效率和灵活性。
接下来，让我们一起来探索吧。
文章结构的目的是为了帮助读者更好地理解文章的组织和内容安排。
本文的文章结构如下：1. 引言1.1 概述1.2 文章结构1.3 目的2. 正文2.1 什么是serializable类型字段2.2 为什么需要将serializable类型字段转为对象2.3 如何将serializable类型字段转为对象3. 结论3.1 总结3.2 对转换serializable类型字段的重要性进行强调3.3 展望未来可能的发展方向在本文的文章结构中，引言部分介绍了文章的背景和目的。
普元反序列化一、什么是普元反序列化普元反序列化（Pop PHP）是一种流行的开源PHP开发框架，用于处理PHP对象的反序列化。
二、为什么需要普元反序列化在Web应用程序中，序列化是将对象转换为字节流的过程，这样就可以将对象存储在磁盘上或通过网络传输。
而反序列化则是将字节流转换回对象的过程。
通过序列化和反序列化，可以方便地将对象在不同环境之间进行传输和共享。
然而，反序列化过程也存在一些潜在的安全风险。
当不受信任的数据被传递给反序列化函数时，攻击者可以利用这个漏洞来执行恶意代码，从而导致应用程序被攻击和破坏。
为了解决这个问题，普元反序列化框架应运而生。
三、普元反序列化的基本原理普元反序列化框架的基本原理是将反序列化过程分为两个步骤：检查和实例化。
1. 检查在普元反序列化的第一步，框架会对反序列化的数据进行验证和检查，以确保其完整性和安全性。
检查的过程包括以下几个方面：•验证数据的签名：通过使用预共享密钥对序列化数据进行签名，可以确保数据在传输过程中未被篡改。
•验证数据的类型：通过检查序列化数据的类型信息，可以防止恶意数据被恶意注入和执行。
•验证数据的长度：通过检查序列化数据的长度，可以确保数据不会被过多地传输，防止缓冲区溢出等安全问题。
2. 实例化在普元反序列化的第二步，框架会根据反序列化数据的类型信息，动态地实例化对象。
实例化的过程中，框架会使用安全且可信的方式来创建对象，从而避免恶意代码的执行和注入。
四、普元反序列化的优点和局限性普元反序列化框架相对于传统的反序列化方法，具有以下几个优点：•安全性：普元反序列化框架可以有效地防止反序列化攻击，保护应用程序的安全。
•灵活性：普元反序列化框架支持多种数据格式的反序列化，使得应用程序可以灵活地处理不同类型的数据。
•可扩展性：普元反序列化框架提供了丰富的扩展机制，可以方便地添加新的反序列化功能。
然而，普元反序列化框架也有一些局限性：•学习成本：由于普元反序列化框架的复杂性和高级特性，学习和掌握该框架可能需要一定的时间和精力。
将php序列化到数据库的对象饭序列化成java对象php的对象序列化到数据库中，形如a:3:{i:0;i:1241;i:1;i:4;i:2;i:16;}但是java需要取出这样的对象，转换成java的对象/* PHPSerializer.java** Author: Ma Bingyao* Copyright: * Version: 2.1* LastModified: 2006-08-09* This library is free. You can redistribute it and/or modify it.* /?p=202*/package org.phprpc.util;import java.io.*;import java.util.*;import ng.reflect.*;class UnSerializeResult {public Object value;public int hv;public UnSerializeResult() {}public UnSerializeResult(Object value, int hv) { this.value = value;this.hv = hv;}}public class PHPSerializer {private static Package[] __packages = Package.getPackages();private static final byte __Quote = 34;private static final byte __0 = 48;private static final byte __1 = 49;private static final byte __Colon = 58;private static final byte __Semicolon = 59; private static final byte __C = 67;private static final byte __N = 78;private static final byte __O = 79;private static final byte __R = 82;private static final byte __U = 85;private static final byte __Slash = 92;private static final byte __a = 97;private static final byte __b = 98;private static final byte __d = 100;private static final byte __i = 105;private static final byte __r = 114;private static final byte __s = 115;private static final byte __LeftB = 123;private static final byte __RightB = 125;private static final String __NAN = new String("NAN"); private static final String __INF = new String("INF"); private static final String __NINF = new String("-INF"); private PHPSerializer() {}public static byte[] serialize(Object obj) {return serialize(obj,"UTF-8");}public static byte[] serialize(Object obj, String charset) {HashMap ht = new HashMap();int hv = 1;ByteArrayOutputStream stream = new ByteArrayOutputStream();hv = serialize(stream, obj, ht, hv, charset);byte[] result = stream.toByteArray();try {stream.close();} catch (Exception e) {}return result;}public static int serialize(ByteArrayOutputStream stream, Object obj, HashMap ht, int hv, String charset) {if (obj == null) {hv++;writeNull(stream);} else {if (obj instanceof Boolean) {hv++;writeBoolean(stream, ((Boolean) obj).booleanValue() ? __1 : __0);} else if ((obj instanceof Byte) || (obj instanceof Short) || (obj instanceof Integer)) {hv++;writeInteger(stream, getBytes(obj));} else if (obj instanceof Long) {hv++;writeDouble(stream, getBytes(obj));} else if (obj instanceof Float) {hv++;Float f = (Float) obj;if (f.isNaN()) {writeDouble(stream, getBytes(__NAN));} else if (f.isInfinite()) {if (f.floatValue() > 0) {writeDouble(stream, getBytes(__INF));} else {writeDouble(stream, getBytes(__NINF));}} else {writeDouble(stream, getBytes(f));}} else if (obj instanceof Double) {hv++;Double d = (Double) obj;if (d.isNaN()) {writeDouble(stream, getBytes(__NAN));} else if (d.isInfinite()) {if (d.doubleValue() > 0) {writeDouble(stream, getBytes(__INF));} else {writeDouble(stream, getBytes(__NINF));}} else {writeDouble(stream, getBytes(d));}} else if ((obj instanceof Character) || (obj instanceof String)) {hv++;writeString(stream, getBytes(obj, charset));} else if (obj.getClass().isArray()) {if (ht.containsKey(new Integer(obj.hashCode()))) { writePointRef(stream, getBytes(ht.get(newInteger(obj.hashCode()))));} else {ht.put(new Integer(obj.hashCode()), new Integer(hv++)); hv = writeArray(stream, obj, ht, hv, charset);}} else if (obj instanceof ArrayList) {if (ht.containsKey(new Integer(obj.hashCode()))) { writePointRef(stream, getBytes(ht.get(newInteger(obj.hashCode()))));} else {ht.put(new Integer(obj.hashCode()), new Integer(hv++)); hv = writeArrayList(stream, (ArrayList) obj, ht, hv, charset);}} else if (obj instanceof HashMap) {if (ht.containsKey(new Integer(obj.hashCode()))) { writePointRef(stream, getBytes(ht.get(newInteger(obj.hashCode()))));} else {ht.put(new Integer(obj.hashCode()), new Integer(hv++));hv = writeHashMap(stream, (HashMap) obj, ht, hv, charset);}} else {if (ht.containsKey(new Integer(obj.hashCode()))) {hv++;writeRef(stream, getBytes(ht.get(newInteger(obj.hashCode()))));} else {ht.put(new Integer(obj.hashCode()), new Integer(hv++)); hv = writeObject(stream, obj, ht, hv, charset);}}}return hv;}private static void writeNull(ByteArrayOutputStream stream) {stream.write(__N);stream.write(__Semicolon);}private static void writeRef(ByteArrayOutputStream stream, byte[] r) {stream.write(__r);stream.write(__Colon);stream.write(r, 0, r.length);stream.write(__Semicolon);}private static void writePointRef(ByteArrayOutputStream stream, byte[] p) {stream.write(__R);stream.write(__Colon);stream.write(p, 0, p.length);stream.write(__Semicolon);}private static void writeBoolean(ByteArrayOutputStream stream, byte b) {stream.write(__b);stream.write(__Colon);stream.write(b);stream.write(__Semicolon);}private static void writeInteger(ByteArrayOutputStream stream, byte[] i) {stream.write(__i);stream.write(__Colon);stream.write(i, 0, i.length);stream.write(__Semicolon);}private static void writeDouble(ByteArrayOutputStream stream, byte[] d) {stream.write(__d);stream.write(__Colon);stream.write(d, 0, d.length);stream.write(__Semicolon);}private static void writeString(ByteArrayOutputStream stream, byte[] s) {byte[] slen = getBytes(new Integer(s.length));stream.write(__s);stream.write(__Colon);stream.write(slen, 0, slen.length);stream.write(__Colon);stream.write(__Quote);stream.write(s, 0, s.length);stream.write(__Quote);stream.write(__Semicolon);}private static int writeArray(ByteArrayOutputStream stream, Object a, HashMap ht, int hv, String charset) { int len = Array.getLength(a);byte[] alen = getBytes(new Integer(len));stream.write(__a);stream.write(__Colon);stream.write(alen, 0, alen.length);stream.write(__Colon);stream.write(__LeftB);for (int i = 0; i < len; i++) {writeInteger(stream, getBytes(new Integer(i)));hv = serialize(stream, Array.get(a, i), ht, hv, charset); }stream.write(__RightB);return hv;}private static int writeArrayList(ByteArrayOutputStream stream, ArrayList a, HashMap ht, int hv, String charset) { int len = a.size();byte[] alen = getBytes(new Integer(len));stream.write(__a);stream.write(__Colon);stream.write(alen, 0, alen.length);stream.write(__Colon);stream.write(__LeftB);for (int i = 0; i < len; i++) {writeInteger(stream, getBytes(new Integer(i)));hv = serialize(stream, a.get(i), ht, hv, charset);}stream.write(__RightB);return hv;}private static int writeHashMap(ByteArrayOutputStream stream, HashMap h, HashMap ht, int hv, String charset) { int len = h.size();byte[] hlen = getBytes(new Integer(len));stream.write(__a);stream.write(__Colon);stream.write(hlen, 0, hlen.length);stream.write(__Colon);stream.write(__LeftB);for (Iterator keys = h.keySet().iterator(); keys.hasNext();) { Object key = keys.next();if ((key instanceof Byte) || (key instanceof Short)|| (key instanceof Integer)) {writeInteger(stream, getBytes(key));} else if (key instanceof Boolean) {writeInteger(stream, new byte[] { ((Boolean)key).booleanValue() ? __1 : __0 });} else {writeString(stream, getBytes(key, charset));}hv = serialize(stream, h.get(key), ht, hv, charset);}stream.write(__RightB);return hv;}private static int writeObject(ByteArrayOutputStream stream, Object obj, HashMap ht, int hv, String charset) { Class cls = obj.getClass();if (obj instanceof java.io.Serializable) {byte[] className = getBytes(getClassName(cls), charset);byte[] classNameLen = getBytes(newInteger(className.length));if (obj instanceof org.phprpc.util.Serializable) {byte[] cs = ((org.phprpc.util.Serializable) obj).serialize(); byte[] cslen = getBytes(new Integer(cs.length));stream.write(__C);stream.write(__Colon);stream.write(classNameLen, 0, classNameLen.length); stream.write(__Colon);stream.write(__Quote);stream.write(className, 0, className.length); stream.write(__Quote);stream.write(__Colon);stream.write(cslen, 0, cslen.length);stream.write(__Colon);stream.write(__LeftB);stream.write(cs, 0, cs.length);stream.write(__RightB);} else {Method __sleep;try {__sleep = cls.getMethod("__sleep", new Class[0]);} catch (Exception e) {__sleep = null;}int fl = 0;Field[] f;if (__sleep != null) {String[] fieldNames;try {__sleep.setAccessible(true);fieldNames = (String[]) __sleep.invoke(obj, new Object[0]);} catch (Exception e) {fieldNames = null;}f = getFields(obj, fieldNames);} else {f = getFields(obj);}AccessibleObject.setAccessible(f, true);byte[] flen = getBytes(new Integer(f.length));stream.write(__O);stream.write(__Colon);stream.write(classNameLen, 0, classNameLen.length); stream.write(__Colon);stream.write(__Quote);stream.write(className, 0, className.length); stream.write(__Quote);stream.write(__Colon);stream.write(flen, 0, flen.length);stream.write(__Colon);stream.write(__LeftB);for (int i = 0, len = f.length; i < len; i++) {int mod = f[i].getModifiers();if (Modifier.isPublic(mod)) {writeString(stream, getBytes(f[i].getName(), charset)); } else if (Modifier.isProtected(mod)) {writeString(stream,getBytes("*"+ f[i].getName(), charset));} else {writeString(stream,getBytes(""+ getClassName(f[i].getDeclaringClass())+""+ f[i].getName(),charset));}Object o;try {o = f[i].get(obj);} catch (Exception e) {o = null;}hv = serialize(stream, o, ht, hv, charset); }stream.write(__RightB);}} else {writeNull(stream);}return hv;}private static byte[] getBytes(Object obj) { try {return obj.toString().getBytes("US-ASCII");} catch (Exception e) {return obj.toString().getBytes();}}private static byte[] getBytes(Object obj, String charset) { try {return obj.toString().getBytes(charset);} catch (Exception e) {return obj.toString().getBytes();}}private static String getString(byte[] data, String charset) { try {return new String(data, charset);} catch (Exception e) {return new String(data);}}private static Class getClass(String className) {try {Class cls = Class.forName(className);return cls;} catch (Exception e) {}for (int i = 0; i < __packages.length; i++) {try {Class cls = Class.forName(__packages[i].getName() +"."+ className);return cls;} catch (Exception e) {}}return null;}private static String getClassName(Class cls) {returncls.getName().substring(cls.getPackage().getName().lengt h() + 1);}private static Field getField(Object obj, String fieldName) { Class cls = obj.getClass();while (cls != null) {try {Field result = cls.getDeclaredField(fieldName);int mod = result.getModifiers();if (Modifier.isFinal(mod) || Modifier.isStatic(mod)) {return null;}return result;} catch (Exception e) {}cls = cls.getSuperclass();}return null;}private static Field[] getFields(Object obj, String[] fieldNames) {if (fieldNames == null) {return getFields(obj);}int n = fieldNames.length;ArrayList fields = new ArrayList(n);for (int i = 0; i < n; i++) {Field f = getField(obj, fieldNames[i]);if (f != null) {fields.add(f);}}return (Field[]) fields.toArray(new Field[0]); }private static Field[] getFields(Object obj) { ArrayList fields = new ArrayList();Class cls = obj.getClass();while (cls != null) {Field[] fs = cls.getDeclaredFields();for (int i = 0; i < fs.length; i++) {int mod = fs[i].getModifiers();if (!Modifier.isFinal(mod) && !Modifier.isStatic(mod)) { fields.add(fs[i]);}}cls = cls.getSuperclass();}return (Field[]) fields.toArray(new Field[0]);}public static Object newInstance(Class cls) {try {Constructor ctor = cls.getConstructor(new Class[0]); int mod = ctor.getModifiers();if (Modifier.isPublic(mod)) {return ctor.newInstance(new Object[0]);}} catch (Exception e) {}try {Constructor ctor = cls.getConstructor(new Class[]{ Integer.TYPE });int mod = ctor.getModifiers();if (Modifier.isPublic(mod)) {return ctor.newInstance(new Object[] { new Integer(0) }); }} catch (Exception e) {}try {Constructor ctor = cls.getConstructor(new Class[]{ Boolean.TYPE });int mod = ctor.getModifiers();if (Modifier.isPublic(mod)) {return ctor.newInstance(new Object[] { newBoolean(false) });}} catch (Exception e) {}try {Constructor ctor = cls.getConstructor(new Class[]{ String.class });int mod = ctor.getModifiers();if (Modifier.isPublic(mod)) {return ctor.newInstance(new Object[] {""}); }} catch (Exception e) {}Field[] f = cls.getFields();for (int i = 0; i < f.length; i++) {if (f[i].getType() == cls &&Modifier.isStatic(f[i].getModifiers())) {try {return f[i].get(null);} catch (Exception e) {}}}Method[] m = cls.getMethods();for (int i = 0; i < m.length; i++) {if (m[i].getReturnType() == cls&& Modifier.isStatic(m[i].getModifiers())) { try {return m[i].invoke(null, new Object[0]);} catch (Exception e) {}try {return m[i].invoke(null, new Object[] { new Integer(0) }); } catch (Exception e) {}try {return m[i].invoke(null, new Object[] { newBoolean(false) });} catch (Exception e) {}try {return m[i].invoke(null, new Object[] {""});} catch (Exception e) {}}}return null;}public static Number cast(Number n, Class destClass) { if (destClass == Byte.class) {return new Byte(n.byteValue());}if (destClass == Short.class) {return new Short(n.shortValue());}if (destClass == Integer.class) {return new Integer(n.intValue());}if (destClass == Long.class) {return new Long(n.longValue());}if (destClass == Float.class) {return new Float(n.floatValue());}if (destClass == Double.class) {return new Double(n.doubleValue());}return n;}public static Object cast(Object obj, Class destClass) { if (obj == null || destClass == null) {return obj;} else if (obj.getClass() == destClass) {return obj;} else if (obj instanceof Number) {return cast((Number) obj, destClass);} else if ((obj instanceof String) && destClass == Character.class) {return new Character(((String)obj).charAt(0));} else if ((obj instanceof ArrayList) && destClass.isArray()) {return toArray((ArrayList) obj,destClass.getComponentType());} else if ((obj instanceof ArrayList) && destClass == HashMap.class) {return toHashMap((ArrayList) obj);} else {return obj;}}private static HashMap toHashMap(ArrayList a) {int n = a.size();HashMap h = new HashMap(n);for (int i = 0; i < n; i++) {h.put(new Integer(i), a.get(i));}return h;}private static Object toArray(ArrayList obj, Class componentType) {int n = obj.size();Object a = Array.newInstance(componentType, n);for (int i = 0; i < n; i++) {Array.set(a, i, cast(obj.get(i), componentType));}return a;}private static int getPos(ByteArrayInputStream stream) { try {Field pos = stream.getClass().getDeclaredField("pos");pos.setAccessible(true);return pos.getInt(stream);} catch (Exception e) {return 0;}}private static void setPos(ByteArrayInputStream stream, int p) {try {Field pos = stream.getClass().getDeclaredField("pos");pos.setAccessible(true);pos.setInt(stream, p);} catch (Exception e) {}}public static Object unserialize(byte[] ss) throws IllegalAccessException {return unserialize(ss, null,"UTF-8");}public static Object unserialize(byte[] ss, String charset) throws IllegalAccessException {return unserialize(ss, null, charset);}public static Object unserialize(byte[] ss, Class cls) throws IllegalAccessException {return unserialize(ss, cls,"UTF-8");}public static Object unserialize(byte[] ss, Class cls, String charset) throws IllegalAccessException {int hv = 1;ByteArrayInputStream stream = new ByteArrayInputStream(ss);Object result = unserialize(stream, new HashMap(), hv, new HashMap(), charset).value;try {stream.close();} catch (Exception e) {}return cast(result, cls);}private static UnSerializeResultunserialize(ByteArrayInputStream stream, HashMap ht, inthv, HashMap rt, String charset) throws IllegalAccessException {Object obj;switch (stream.read()) {case __N:obj = readNull(stream);ht.put(new Integer(hv++), obj);return new UnSerializeResult(obj, hv);case __b:obj = readBoolean(stream);ht.put(new Integer(hv++), obj);return new UnSerializeResult(obj, hv);case __i:obj = readInteger(stream);ht.put(new Integer(hv++), obj);return new UnSerializeResult(obj, hv);case __d:obj = readDouble(stream);ht.put(new Integer(hv++), obj);return new UnSerializeResult(obj, hv);case __s:obj = readString(stream, charset);ht.put(new Integer(hv++), obj);return new UnSerializeResult(obj, hv);case __U:obj = readUnicodeString(stream);ht.put(new Integer(hv++), obj);return new UnSerializeResult(obj, hv);case __r:return readRef(stream, ht, hv, rt);case __a:return readArray(stream, ht, hv, rt, charset);case __O:return readObject(stream, ht, hv, rt, charset);case __C:return readCustomObject(stream, ht, hv, charset);case __R:return readPointRef(stream, ht, hv, rt);default:return null;}}private static String readNumber(ByteArrayInputStream stream) {StringBuffer sb = new StringBuffer();int i = stream.read();while ((i != __Semicolon) && (i != __Colon)) {sb.append((char) i);i = stream.read();}return sb.toString();}private static Object readNull(ByteArrayInputStream stream) {stream.skip(1);return null;}private static BooleanreadBoolean(ByteArrayInputStream stream) {stream.skip(1);Boolean b = new Boolean(stream.read() == __1);stream.skip(1);return b;}private static Number readInteger(ByteArrayInputStream stream) {stream.skip(1);String i = readNumber(stream);try {return new Byte(i);} catch (Exception e1) {try {return new Short(i);} catch (Exception e2) {return new Integer(i);}}}private static Number readDouble(ByteArrayInputStream stream) {stream.skip(1);String d = readNumber(stream);if (d.equals(__NAN)) {return new Double(Double.NaN);}if (d.equals(__INF)) {return new Double(Double.POSITIVE_INFINITY);}if (d.equals(__NINF)) {return new Double(Double.NEGATIVE_INFINITY);}try {return new Long(d);} catch (Exception e1) {try {Float f = new Float(d);if (f.isInfinite()) {return new Double(d);} else {return f;}} catch (Exception e2) {return new Float(0);}}}private static String readString(ByteArrayInputStream stream, String charset) {stream.skip(1);int len = Integer.parseInt(readNumber(stream));stream.skip(1);byte[] buf = new byte[len];stream.read(buf, 0, len);String s = getString(buf, charset);stream.skip(2);return s;}private static StringreadUnicodeString(ByteArrayInputStream stream) { stream.skip(1);int l = Integer.parseInt(readNumber(stream));stream.skip(1);StringBuffer sb = new StringBuffer(l);int c;for (int i = 0; i < l; i++) {if ((c = stream.read()) == __Slash) {char c1 = (char) stream.read();char c2 = (char) stream.read();char c3 = (char) stream.read();char c4 = (char) stream.read();sb.append((char) (Integer.parseInt(new String(new char[] { c1, c2, c3, c4 }), 16)));} else {sb.append((char) c);}}stream.skip(2);return sb.toString();}private static UnSerializeResultreadRef(ByteArrayInputStream stream, HashMap ht, int hv, HashMap rt) {stream.skip(1);Integer r = new Integer(readNumber(stream));if (rt.containsKey(r)) {rt.put(r, new Boolean(true));}Object obj = ht.get(r);ht.put(new Integer(hv++), obj);return new UnSerializeResult(obj, hv);}private static UnSerializeResultreadPointRef(ByteArrayInputStream stream, HashMap ht, int hv, HashMap rt) {stream.skip(1);Integer r = new Integer(readNumber(stream));if (rt.containsKey(r)) {rt.put(r, new Boolean(true));}Object obj = ht.get(r);return new UnSerializeResult(obj, hv);}private static UnSerializeResultreadArray(ByteArrayInputStream stream, HashMap ht, int hv, HashMap rt, String charset) throws IllegalAccessException {stream.skip(1);int n = Integer.parseInt(readNumber(stream));stream.skip(1);HashMap h = new HashMap(n);ArrayList al = new ArrayList(n);Integer r = new Integer(hv);rt.put(r, new Boolean(false));int p = getPos(stream);ht.put(new Integer(hv++), h);for (int i = 0; i < n; i++) {Object key;switch (stream.read()) {case __i:key = cast(readInteger(stream), Integer.class); break;case __s:key = readString(stream, charset);break;case __U:key = readUnicodeString(stream);break;default:return null;}UnSerializeResult result = unserialize(stream, ht, hv, rt, charset);hv = result.hv;if (al != null) {if ((key instanceof Integer) && (((Integer) key).intValue() == i)) {al.add(result.value);} else {al = null;}}h.put(key, result.value);}if (al != null) {ht.put(r, al);if (((Boolean) (rt.get(r))).booleanValue()) { hv = r.intValue() + 1;setPos(stream, p);for (int i = 0; i < n; i++) {int key;switch (stream.read()) {case __i:key = ((Integer) cast(readInteger(stream), Integer.class)).intValue();break;default:return null;}UnSerializeResult result = unserialize(stream, ht, hv, rt, charset);hv = result.hv;al.set(key, result.value);}}}rt.remove(r);stream.skip(1);return new UnSerializeResult(ht.get(r), hv);}private static UnSerializeResultreadObject(ByteArrayInputStream stream, HashMap ht, int hv, HashMap rt, String charset) throws IllegalAccessException {stream.skip(1);int len = Integer.parseInt(readNumber(stream));stream.skip(1);byte[] buf = new byte[len];stream.read(buf, 0, len);String cn = getString(buf, charset);stream.skip(2);int n = Integer.parseInt(readNumber(stream));stream.skip(1);Class cls = getClass(cn);Object o;if (cls != null) {if ((o = newInstance(cls)) == null) {o = new HashMap(n);}} else {o = new HashMap(n);}ht.put(new Integer(hv++), o);for (int i = 0; i < n; i++) {String key;switch (stream.read()) {case __s:key = readString(stream, charset);break;case __U:key = readUnicodeString(stream);break;default:return null;}if (key.charAt(0) == (char) 0) {key = key.substring(key.indexOf("", 1) + 1);}UnSerializeResult result = unserialize(stream, ht, hv, rt, charset);hv = result.hv;if (o instanceof HashMap) {((HashMap) o).put(key, result.value);} else {Field f = getField(o, key);f.setAccessible(true);f.set(o, result.value);}}stream.skip(1);Method __wakeup = null;try {__wakeup = o.getClass().getMethod("__wakeup", new Class[0]);__wakeup.invoke(o, new Object[0]);} catch (Exception e) {}return new UnSerializeResult(o, hv);}private static UnSerializeResultreadCustomObject(ByteArrayInputStream stream, HashMap ht, int hv, String charset) {stream.skip(1);int len = Integer.parseInt(readNumber(stream));stream.skip(1);byte[] buf = new byte[len];stream.read(buf, 0, len);String cn = getString(buf, charset);stream.skip(2);int n = Integer.parseInt(readNumber(stream));stream.skip(1);Class cls = getClass(cn);Object o;if (cls != null) {o = newInstance(cls);} else {o = null;}ht.put(new Integer(hv++), o);if (o == null) {stream.skip(n);} else if (o instanceof org.phprpc.util.Serializable) {byte[] b = new byte[n];stream.read(b, 0, n);((org.phprpc.util.Serializable) o).unserialize(b);} else {stream.skip(n);}stream.skip(1);return new UnSerializeResult(o, hv);}public static void main(String[] args) throws IllegalAccessException {List list =(List)PHPSerializer.unserialize("a:3:{i:0;i:1241;i:1;i:4;i:2;i:1 6;}".getBytes());for(Object o : list){System.out.println(o.toString());}System.out.println(list.size()); }}。
