package cn.jsprun.utils;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
public class Serializer {
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 __N = 78;
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 __s = 115;
private static final byte __LeftB = 123;
private static final byte __RightB = 125;
private static final String __NAN = "NAN";
private static final String __INF = "INF";
private static final String __NINF = "-INF";
private static final String charset="GBK";
public static String serialize(Object obj) {
return serialize(obj, charset);
}
@SuppressWarnings("unchecked")
public static String serialize(Object obj, String charset) {
ByteArrayOutputStream stream = new ByteArrayOutputStream();
serialize(stream, obj, charset);
String result=null;
try {
result = stream.toString(charset);
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
@SuppressWarnings("unchecked")
private static void serialize(ByteArrayOutputStream stream, Object obj, String charset) {
if (obj == null) {
writeNull(stream);
} else if (obj instanceof Boolean) {
writeBoolean(stream, ((Boolean) obj).booleanValue() ? __1 : __0);
} else if ((obj instanceof Byte) || (obj instanceof Short) || (obj instanceof Integer)) {
writeInteger(stream, getAsciiBytes(obj));
} else if (obj instanceof Long) {
writeDouble(stream, getAsciiBytes(obj));
} else if (obj instanceof Float) {
Float f = (Float) obj;
obj = f.isNaN() ? __NAN : (!f.isInfinite() ? obj : (f.floatValue() > 0 ? __INF : __NINF));
writeDouble(stream, getAsciiBytes(obj));
} else if (obj instanceof Double) {
Double d = (Double) obj;
obj = d.isNaN() ? __NAN : (!d.isInfinite() ? obj : (d.doubleValue() > 0 ? __INF : __NINF));
writeDouble(stream, getAsciiBytes(obj));
} else if ((obj instanceof Character) || (obj instanceof String)) {
writeString(stream, getBytes(obj, charset));
} else if (obj instanceof Map) {
writeMap(stream, (Map) obj, charset);
} else if (obj instanceof List) {
writeList(stream, (List) obj, charset);
} else {
System.out.println("Serializer.serialize: The DataType is invalid");
}
}
private static void writeNull(ByteArrayOutputStream stream) {
stream.write(__N);
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 = getAsciiBytes(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);
}
@SuppressWarnings("unchecked")
private static void writeList(ByteArrayOutputStream stream, List a, String charset) {
int len = a.size();
byte[] alen = getAsciiBytes(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, getAsciiBytes(new Integer(i)));
serialize(stream, a.get(i), charset);
}
stream.write(__RightB);
}
@SuppressWarnings("unchecked")
private static void writeMap(ByteArrayOutputStream stream, Map h,String charset) {
int len = h.size();
byte[] hlen = getAsciiBytes(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, getAsciiBytes(key));
} else if (key instanceof Boolean) {
writeInteger(stream, new byte[] { ((Boolean) key).booleanValue() ? __1 : __0 });
} else {
writeString(stream, getBytes(key,charset));
}
serialize(stream, h.get(key),charset);
}
stream.write(__RightB);
}
private static byte[] getAsciiBytes(Object obj) {
try {
return obj.toString().getBytes("US-ASCII");
}
catch (Exception e) {
return null;
}
}
private static byte[] getBytes(Object obj, String charset) {
try {
return obj.toString().getBytes(charset);
} catch (Exception e) {
return obj.toString().getBytes();
}
}
public static Object unserialize(String ss,int state){
return unserialize(ss, charset, state);
}
@SuppressWarnings("unchecked")
public static Object unserialize(String ss, String charset,int state){
ByteArrayInputStream stream =null;
try {
stream = new ByteArrayInputStream(ss.getBytes(charset));
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
Object result = unserialize(stream, charset, state);
return result;
}
@SuppressWarnings("unchecked")
private static Object unserialize(ByteArrayInputStream stream, String charset,int state) {
switch (stream.read()) {
case __N:
return readNull(stream);
case __b:
return readBoolean(stream);
case __i:
return readInteger(stream);
case __d:
return readDouble(stream);
case __s:
return readString(stream, charset);
case __U:
return readUnicodeString(stream);
case __a:
return readArray(stream, charset, state);
default:
System.out.println("Serializer.unserialize: The DataType Is invalid,state="+state);
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 Boolean readBoolean(ByteArrayInputStream stream) {
stream.skip(1);
boolean b = stream.read() == __1;
stream.skip(1);
return b;
}
private static Number readInteger(ByteArrayInputStream stream) {
stream.skip(1);
String i = readNumber(stream);
return Integer.parseInt(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);
}
if ((d.indexOf('.') > 0) || (d.indexOf('e') > 0) || (d.indexOf('E') > 0)) {
return new Double(d);
}
int len = d.length();
char c = d.charAt(0);
if ((len < 19) || ((c == '-') && (len < 20))) {
return new Long(d);
}
if ((len > 20) || ((c != '-') && (len > 19))) {
return new Double(d);
}
try {
return new Long(d);
}
catch (Exception e) {
return new Double(d);
}
}
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);
stream.skip(2);
try {
return new String(buf, charset);
} catch (Exception e) {
return new String(buf);
}
}
private static String readUnicodeString(ByteArrayInputStream stream) {
stream.skip(1);
int len = Integer.parseInt(readNumber(stream));
stream.skip(1);
StringBuffer sb = new StringBuffer(len);
int c;
for (int i = 0; i < len; i++) {
if ((c = stream.read()) == __Slash) {
char[] chs=new char[4];
chs[0] = (char) stream.read();
chs[1] = (char) stream.read();
chs[2] = (char) stream.read();
chs[3] = (char) stream.read();
sb.append((char) (Integer.parseInt(new String(chs), 16)));
}
else {
sb.append((char) c);
}
}
stream.skip(2);
return sb.toString();
}
@SuppressWarnings("unchecked")
private static Object readArray(ByteArrayInputStream stream, String charset,int state) {
stream.skip(1);
int n = Integer.parseInt(readNumber(stream));
stream.skip(1);
Map map = null;
List list = null;
if(state==0){
list=new ArrayList(n);
state=-1;
}else if(state==1){
map=new TreeMap();
}else {
map=new HashMap(n);
}
for (int i = 0; i < n; i++) {
Object key;
switch (stream.read()) {
case __i:
key = readInteger(stream);
break;
case __s:
key = readString(stream, charset);
break;
case __U:
key = readUnicodeString(stream);
break;
default:
return null;
}
Object result = unserialize(stream, charset, state);
if (list != null) {
if ((key instanceof Integer) && (((Integer) key).intValue() == i)) {
list.add(result);
} else {
list = null;
}
}else{
map.put(key, result);
}
}
stream.skip(1);
if (list != null) {
return list;
}else{
return map;
}
}
}
分享到：
发表评论
相关推荐
总的来说，JSP开源论坛JspRun是一个强大的、可定制的社区平台，它利用JSP和Java技术提供了丰富的社区功能，并通过开源的方式鼓励用户参与和创新。无论是对JSP技术的学习，还是对论坛系统的运营，JspRun都是一个值得...
JspRun是一个流行的开源论坛系统，它基于Java Servlet和JSP技术，用于构建社区网站。这个项目包含了丰富的功能，如用户管理、主题讨论、帖子回复、权限控制等，旨在为用户提供一个互动性强、易于管理的在线交流平台...
通过部署这个论坛代码，用户可以在自己的服务器上安装并运行JSprun，创建一个完全符合自己需求的论坛环境。这种神奇的功能不仅降低了创建论坛的门槛，也极大地激发了社区创新和个性化定制的可能性。 标签“论坛”...
JSPrun 6.0的数据字典包含了多个核心表，如用户信息、帖子、板块、分类、权限等。以下是一些关键表格的简介： - `threads`（主题表）：存储论坛帖子的基本信息，包括主题ID、作者、创建时间、最后回复时间等。 -...
《JspRun6.0数据库字典》是针对基于Java技术构建的论坛系统JspRun6.0的一个重要参考资料，对于论坛的后台管理和维护人员来说，具有极高的实用价值。这个数据库字典详细列出了JspRun6.0论坛系统所使用的数据库结构，...
jspRun开源论坛是一款基于Java技术开发的开源社区系统，其设计目标是提供类似Discuz! 6的功能，为用户搭建互动性强、易于管理的在线社区平台。该系统以其高效、稳定、可扩展性而受到开发者和用户的青睐。在深入探讨...
《JspRun!_6.0.0_Source_GBK.zip源码详解》 JspRun! 是一个广泛应用的开源论坛系统，尤其在中文社区中深受青睐。它的版本号6.0.0表明这是一个相对成熟且稳定的发布，而GBK编码则意味着这个版本主要面向中文用户，...
《JspRun!_6.0.0_Source》是一款基于Java技术开发的开源论坛系统，其源代码的发布为开发者提供了深入理解Web应用程序构建、尤其是论坛应用开发的宝贵资源。这款论坛系统以其高效、稳定和易用性在互联网上广受欢迎。...
JspRun技术手册.pdf
JspRun6.0论坛是一款基于Java和Web技术的开源论坛软件，它提供了丰富的功能和用户友好的界面，适合搭建在线社区。本教程将详细介绍如何在Linux系统（以CentOS6.0为例）上搭建JspRun6.0论坛。 首先，确保你的系统...
4. **数据库连接**：安装过程中，你需要创建一个数据库（如MySQL、Oracle等）并配置相应的数据库连接参数，如数据库URL、用户名、密码等，这些信息通常会在JspRun! 的配置文件中设置。 5. **初始化论坛**：访问应用...
作为一个专业的IT知识讲解，我们将深入探讨jsprun6.0的核心特性、技术架构以及其在实际应用中的价值。 1. **核心技术与框架** jsprun6.0是用Java语言编写的，这意味着它利用了Java的跨平台优势，可以在各种操作...
在v6.0版本中，JspRun!选择了GBK，旨在提供更加完善的中文显示与处理能力，避免乱码问题，保障了用户在论坛交流中的顺畅体验。 2. **核心架构**：JspRun!采用Java Servlet和JSP技术构建，具备良好的跨平台性和稳定...
【个人（jsprun）bbs论坛源码】是一个针对个人用户设计的论坛软件系统，其核心在于提供一个互动交流的平台，使用户能够创建、管理自己的社区。BBS（Bulletin Board System）论坛源码是实现这一功能的基础，它包含了...
这个“JspRun!_6_UTF8.rar”文件是JspRun!的UTF-8版本，它提供了一种便捷的安装方式，让用户能够快速地在自己的服务器或本地环境中搭建一个支持多语言的论坛。 JspRun! 的UTF-8编码确保了论坛能正确显示各种语言的...
JspRun6.0源码的开发就充分利用了Java的这些特性，包括类、对象、接口、异常处理、多线程、网络编程等核心概念。通过学习JspRun6.0的源代码，开发者可以深入理解如何在实际项目中运用这些概念，提高自己的编程技能。...
总结来说，JSPrun论坛是一个采用Java技术开发的高效、稳定的社区平台，它的易用性、灵活性和可扩展性使其在众多论坛软件中脱颖而出。无论是对于初学者还是经验丰富的开发者，JSPrun都是一个值得探索和使用的开源项目...
首先，我们来看一下JspRun!的核心特性。该系统基于Java Servlet和JSP技术，这使得它具有良好的可扩展性和高性能。Java平台的稳定性和安全性为论坛的运行提供了坚实的基础。JspRun! v6.0优化了代码结构，提升了系统的...
【JspRun!社区论坛系统】是一个基于Java和JSP技术构建的开源社区论坛软件，广泛应用于学生毕业设计和学习项目。此版本为v6.0 UTF-8安装版，适用于多语言环境，特别是中文环境，确保了字符编码的正确性，避免了乱码...