Hessian2序列化

最新推荐文章于 2023-07-22 00:38:50 发布
最新推荐文章于 2023-07-22 00:38:50 发布
阅读量1.1k 收藏
点赞数
分类专栏： delphi 文章标签： Delphi Gmail F#
[code]
unit Hessian2Output;

{
title: hessian 2.0 序列化
author: Xiao Chun
email: cnxiaochun#gmail.com
version: draft
reference: http://hessian.caucho.com/
}

interface
uses Classes;
const
BUFFER_SIZE = 4096;

INT_DIRECT_MIN = -$10;
INT_DIRECT_MAX = $2F;
INT_ZERO = $90;

INT_BYTE_MIN = -$800;
INT_BYTE_MAX = $7FF;
INT_BYTE_ZERO = $C8;

INT_SHORT_MIN = -$40000;
INT_SHORT_MAX = $3FFFF;
INT_SHORT_ZERO = $D4;

LONG_DIRECT_MIN = -$08;
LONG_DIRECT_MAX = $0F;
LONG_ZERO = $E0;

LONG_BYTE_MIN = -$800;
LONG_BYTE_MAX = $7FF;
LONG_BYTE_ZERO = $F8;

LONG_SHORT_MIN = -$40000;
LONG_SHORT_MAX = $3FFFF;
LONG_SHORT_ZERO = $3C;

LONG_INT_MIN = -$7FFFFFFF - 1;
LONG_INT_MAX = $7FFFFFFF;
LONG_INT_ZERO = $77;

STRING_DIRECT_MAX = $1F;
STRING_DIRECT = $00;

BYTES_DIRECT_MAX = $0F;
BYTES_DIRECT = $20;

DOUBLE_ZERO = $67;
DOUBLE_ONE = $68;
DOUBLE_BYTE = $69;
DOUBLE_SHORT = $6A;
DOUBLE_FLOAT = $6B;

LENGTH_BYTE = $6E;
LIST_FIXED = $76; // 'v'

REF_BYTE = $4A;
REF_SHORT = $4B;

TYPE_REF = $75;
type
THessian2Output = class(TObject)
private
FBuffer: array[0..BUFFER_SIZE - 1] of Byte;
FOffset: integer;
FStream: TStream;
FFreeStreamOnDestroy: boolean;
_typeRefs: TStringList;
procedure PrintString(const AValue: WideString; AOffset, ACount: integer);
procedure WriteType(const AType: WideString);
procedure _WriteString(const AValue: WideString; AOffset, ACount: integer);
public
constructor Create(AStream: TStream);
destructor Destroy; override;
public
procedure StartCall(const AMethodName: WideString);
procedure CompleteCall;
procedure Flush;
procedure WriteInt(AValue: integer);
procedure WriteLong(AValue: Int64);
procedure WriteDouble(AValue: Double);
procedure WriteBoolean(AValue: boolean);
procedure WriteNull;
procedure WriteString(const AValue: WideString);
procedure WriteUTCDate(AValue: TDateTime);
procedure WriteBytes(ASourceStream: TStream); overload;
procedure WriteBytes(ASourceStream: TStream; AOffset, ACount: integer); overload;
procedure WriteMapBegin; overload;
procedure WriteMapBegin(const AType: WideString); overload;
procedure WriteMapEnd;
function WriteListBegin(ALength: integer; const AType: WideString): boolean; overload;
function WriteListBegin(ALength: integer): boolean; overload;
procedure WriteListEnd;
end;

implementation
uses JavaDate;

constructor THessian2Output.Create(AStream: TStream);
begin
inherited Create;
FOffset := 0;
if Assigned(AStream) then
begin
FFreeStreamOnDestroy := false;
FStream := AStream;
end
else begin
FFreeStreamOnDestroy := true;
FStream := TMemoryStream.Create;
end;
end;

destructor THessian2Output.Destroy;
begin
if FFreeStreamOnDestroy then FStream.Free;
if Assigned(_typeRefs) then _typeRefs.Free;
inherited;
end;

procedure THessian2Output.StartCall(const AMethodName: WideString);
var
Len: Integer;
begin
if BUFFER_SIZE < FOffset + 16 then Flush;

FBuffer[FOffset] := Byte('c'); Inc(FOffset);
FBuffer[FOffset] := Byte(2); Inc(FOffset);
FBuffer[FOffset] := Byte(0); Inc(FOffset);
FBuffer[FOffset] := Byte('m'); Inc(FOffset);

Len := Length(AMethodName);
FBuffer[FOffset] := Byte(len shr 8 ); Inc(FOffset);
FBuffer[FOffset] := Byte(len); Inc(FOffset);
PrintString(AMethodName, 0, Len);
end;

procedure THessian2Output.CompleteCall;
begin
if BUFFER_SIZE < FOffset + 16 then Flush;

FBuffer[FOffset] := Byte('z'); Inc(FOffset);
end;

procedure THessian2Output.WriteInt(AValue: integer);
begin
if BUFFER_SIZE < FOffset + 16 then Flush;

if (INT_DIRECT_MIN <= AValue) and (AValue <= INT_DIRECT_MAX) then
begin
FBuffer[FOffset] := Byte(AValue + INT_ZERO); Inc(FOffset);
end
else if (INT_BYTE_MIN <= AValue) and (AValue <= INT_BYTE_MAX) then
begin
FBuffer[FOffset] := Byte(INT_BYTE_ZERO + (AValue shr 8 )); Inc(FOffset);
FBuffer[FOffset] := Byte(AValue); Inc(FOffset);
end
else if (INT_SHORT_MIN <= AValue) and (AValue <= INT_SHORT_MAX) then
begin
FBuffer[FOffset] := Byte(INT_SHORT_ZERO + (AValue shr 16 )); Inc(FOffset);
FBuffer[FOffset] := Byte(AValue shr 8 ); Inc(FOffset);
FBuffer[FOffset] := Byte(AValue); Inc(FOffset);
end
else begin
FBuffer[FOffset] := Byte('I'); Inc(FOffset);
FBuffer[FOffset] := Byte(AValue shr 24); Inc(FOffset);
FBuffer[FOffset] := Byte(AValue shr 16); Inc(FOffset);
FBuffer[FOffset] := Byte(AValue shr 8 ); Inc(FOffset);
FBuffer[FOffset] := Byte(AValue); Inc(FOffset);
end
end;

procedure THessian2Output.WriteLong(AValue: int64);
begin
if BUFFER_SIZE < FOffset + 16 then Flush;

if (LONG_DIRECT_MIN <= AValue) and (AValue <= LONG_DIRECT_MAX) then
begin
FBuffer[FOffset] := Byte(AValue + LONG_ZERO); Inc(FOffset);
end
else if (LONG_BYTE_MIN <= AValue) and (AValue <= LONG_BYTE_MAX) then
begin
FBuffer[FOffset] := Byte(LONG_BYTE_ZERO + (AValue shr 8 )); Inc(FOffset);
FBuffer[FOffset] := Byte(AValue); Inc(FOffset);
end
else if (LONG_SHORT_MIN <= AValue) and (AValue <= LONG_SHORT_MAX) then
begin
FBuffer[FOffset] := Byte(LONG_SHORT_ZERO + (AValue shr 16)); Inc(FOffset);
FBuffer[FOffset] := Byte(AValue shr 8 ); Inc(FOffset);
FBuffer[FOffset] := Byte(AValue); Inc(FOffset);
end
else if (LONG_INT_MIN <= AValue) and (AValue <= LONG_INT_MAX) then
begin
FBuffer[FOffset] := Byte(LONG_INT_ZERO); Inc(FOffset);
FBuffer[FOffset] := Byte(AValue shr 24); Inc(FOffset);
FBuffer[FOffset] := Byte(AValue shr 16); Inc(FOffset);
FBuffer[FOffset] := Byte(AValue shr 8 ); Inc(FOffset);
FBuffer[FOffset] := Byte(AValue); Inc(FOffset);
end
else begin
FBuffer[FOffset] := Byte('L'); Inc(FOffset);
FBuffer[FOffset] := Byte(AValue shr 56); Inc(FOffset);
FBuffer[FOffset] := Byte(AValue shr 48); Inc(FOffset);
FBuffer[FOffset] := Byte(AValue shr 40); Inc(FOffset);
FBuffer[FOffset] := Byte(AValue shr 32); Inc(FOffset);
FBuffer[FOffset] := Byte(AValue shr 24); Inc(FOffset);
FBuffer[FOffset] := Byte(AValue shr 16); Inc(FOffset);
FBuffer[FOffset] := Byte(AValue shr 8 ); Inc(FOffset);
FBuffer[FOffset] := Byte(AValue); Inc(FOffset);
end
end;

procedure THessian2Output.WriteDouble(AValue: Double);
var
intValue: integer;
longValue: int64;
floatValue: single;
begin
if BUFFER_SIZE < FOffset + 16 then Flush;

if Int(AValue) = AValue then
begin // 只有整数部分
intValue := Round(AValue);
if intValue = 0 then
begin
FBuffer[FOffset] := Byte(DOUBLE_ZERO); Inc(FOffset);
exit;
end
else if intValue = 1 then
begin
FBuffer[FOffset] := Byte(DOUBLE_ONE); Inc(FOffset);
exit;
end
else if (-$80 <= intValue) and (intValue < $80) then
begin
FBuffer[FOffset] := Byte(DOUBLE_BYTE); Inc(FOffset);
FBuffer[FOffset] := Byte(intValue); Inc(FOffset);
exit;
end
else if ($8000 <= intValue) and (intValue < $8000) then
begin
FBuffer[FOffset] := Byte(DOUBLE_SHORT); Inc(FOffset);
FBuffer[FOffset] := Byte(intValue shr 8 ); Inc(FOffset);
FBuffer[FOffset] := Byte(intValue); Inc(FOffset);
exit;
end;
end;

floatValue := AValue;
if floatValue = AValue then
begin
FBuffer[FOffset] := Byte(DOUBLE_FLOAT); Inc(FOffset);
intValue := PInteger(@floatValue)^;
FBuffer[FOffset] := Byte(intValue shr 24); Inc(FOffset);
FBuffer[FOffset] := Byte(intValue shr 16); Inc(FOffset);
FBuffer[FOffset] := Byte(intValue shr 8 ); Inc(FOffset);
FBuffer[FOffset] := Byte(intValue); Inc(FOffset);
exit;
end;

FBuffer[FOffset] := Byte('D'); Inc(FOffset);
longValue := PInt64(@AValue)^;
FBuffer[FOffset] := Byte(longValue shr 56); Inc(FOffset);
FBuffer[FOffset] := Byte(longValue shr 48); Inc(FOffset);
FBuffer[FOffset] := Byte(longValue shr 40); Inc(FOffset);
FBuffer[FOffset] := Byte(longValue shr 32); Inc(FOffset);
FBuffer[FOffset] := Byte(longValue shr 24); Inc(FOffset);
FBuffer[FOffset] := Byte(longValue shr 16); Inc(FOffset);
FBuffer[FOffset] := Byte(longValue shr 8 ); Inc(FOffset);
FBuffer[FOffset] := Byte(longValue); Inc(FOffset);
end;

procedure THessian2Output.WriteBoolean(AValue: boolean);
begin
if BUFFER_SIZE < FOffset + 16 then Flush;

if AValue then
begin
FBuffer[FOffset] := Byte('T'); Inc(FOffset);
end
else begin
FBuffer[FOffset] := Byte('F'); Inc(FOffset);
end
end;

procedure THessian2Output.WriteString(const AValue: WideString);
begin
_WriteString(AValue, 0, Length(AValue));
end;

procedure THessian2Output.WriteUTCDate(AValue: TDateTime);
var
UTCValue: int64;
begin
UTCValue := DateTimeToJavaDate(AValue);

if BUFFER_SIZE < FOffset + 16 then Flush;

FBuffer[FOffset] := Byte('d'); Inc(FOffset);
FBuffer[FOffset] := Byte(UTCValue shr 56); Inc(FOffset);
FBuffer[FOffset] := Byte(UTCValue shr 48); Inc(FOffset);
FBuffer[FOffset] := Byte(UTCValue shr 40); Inc(FOffset);
FBuffer[FOffset] := Byte(UTCValue shr 32); Inc(FOffset);
FBuffer[FOffset] := Byte(UTCValue shr 24); Inc(FOffset);
FBuffer[FOffset] := Byte(UTCValue shr 16); Inc(FOffset);
FBuffer[FOffset] := Byte(UTCValue shr 8 ); Inc(FOffset);
FBuffer[FOffset] := Byte(UTCValue); Inc(FOffset);
end;

procedure THessian2Output.WriteNull;
begin
if BUFFER_SIZE < FOffset + 16 then Flush;

FBuffer[FOffset] := Byte('N'); Inc(FOffset);
end;

procedure THessian2Output.WriteBytes(ASourceStream: TStream);
begin
if ASourceStream = nil then
begin
WriteNull;
end
else begin
WriteBytes(ASourceStream, 0, ASourceStream.Size);
end;
end;

procedure THessian2Output.WriteBytes(ASourceStream: TStream; AOffset, ACount: integer);
var
sublen: integer;
N: integer;
begin
if ASourceStream = nil then
begin
WriteNull;
end
else begin
if AOffset > 0 then
begin
ASourceStream.Position := AOffset;
end
else begin
ASourceStream.Position := 0;
end;

if BUFFER_SIZE < FOffset + 16 then Flush;

while ACount > $8000 do
begin
FBuffer[FOffset] := Byte('b'); Inc(FOffset);
FBuffer[FOffset] := Byte($8000 shr 8 ); Inc(FOffset);
FBuffer[FOffset] := Byte($8000); Inc(FOffset);

sublen := $8000;
while sublen > 0 do
begin
if sublen > (BUFFER_SIZE - FOffset) then N := BUFFER_SIZE - FOffset else N := sublen;
ASourceStream.ReadBuffer(FBuffer, N); Inc(FOffset, N);

// Flush
FStream.WriteBuffer(FBuffer, FOffset);
FOffset := 0;

Dec(sublen, N);
end;
ACount := ACount - $8000;
//AOffset := AOffset + $80000;
end;

if ACount < $10 then
begin
FBuffer[FOffset] := Byte(BYTES_DIRECT + ACount); Inc(FOffset);
end
else begin
FBuffer[FOffset] := Byte('B'); Inc(FOffset);
FBuffer[FOffset] := Byte(ACount shr 8 ); Inc(FOffset);
FBuffer[FOffset] := Byte(ACount); Inc(FOffset);
end;

while ACount > 0 do
begin
if ACount > (BUFFER_SIZE - FOffset) then N := BUFFER_SIZE - FOffset else N := ACount;
ASourceStream.ReadBuffer(FBuffer, N); Inc(FOffset, N);

// Flush
FStream.WriteBuffer(FBuffer, FOffset);
FOffset := 0;

Dec(ACount, N);
end;
end
end;

procedure THessian2Output.WriteMapBegin;
begin
WriteMapBegin('');
end;

procedure THessian2Output.WriteMapBegin(const AType: WideString);
begin
if BUFFER_SIZE < FOffset + 16 then Flush;

FBuffer[FOffset] := Byte('M'); Inc(FOffset);
WriteType(AType);
end;

procedure THessian2Output.WriteMapEnd;
begin
if BUFFER_SIZE < FOffset + 16 then Flush;

FBuffer[FOffset] := Byte('z'); Inc(FOffset);
end;

function THessian2Output.WriteListBegin(ALength: integer): boolean;
begin
result := WriteListBegin(ALength, '');
end;

function THessian2Output.WriteListBegin(ALength: integer; const AType: WideString): boolean;
var
refV: integer;
begin
if _typeRefs <> nil then
begin
refV := _typeRefs.IndexOf(AType);
if refV >= 0 then
begin
refV := Integer(_typeRefs.Objects[refV]);

if BUFFER_SIZE < FOffset + 16 then Flush;

FBuffer[FOffset] := Byte(LIST_FIXED); Inc(FOffset);

WriteInt(refV);
WriteInt(ALength);

result := false;
exit;
end
end;

if BUFFER_SIZE < FOffset + 16 then Flush;

FBuffer[FOffset] := Byte('V'); Inc(FOffset);
WriteType(AType);

if BUFFER_SIZE < FOffset + 16 then Flush;

if ALength < 0 then
begin
end
else if ALength < $100 then
begin
FBuffer[FOffset] := Byte(LENGTH_BYTE); Inc(FOffset);
FBuffer[FOffset] := Byte(ALength); Inc(FOffset);
end
else begin
FBuffer[FOffset] := Byte('l'); Inc(FOffset);
FBuffer[FOffset] := Byte(ALength shr 24); Inc(FOffset);
FBuffer[FOffset] := Byte(ALength shr 16); Inc(FOffset);
FBuffer[FOffset] := Byte(ALength shr 8 ); Inc(FOffset);
FBuffer[FOffset] := Byte(ALength); Inc(FOffset);
end;
result := True;
end;

procedure THessian2Output.WriteListEnd;
begin
if BUFFER_SIZE < FOffset + 16 then Flush;

FBuffer[FOffset] := Byte('z'); Inc(FOffset);
end;

procedure THessian2Output._WriteString(const AValue: WideString; AOffset, ACount: integer);
var
sublen: integer;
tail: integer;
begin
while ACount > $8000 do
begin
if BUFFER_SIZE < FOffset + 16 then Flush;

sublen := $8000;
// chunk can't end in high surrogate
tail := Integer(AValue[AOffset + sublen - 1]);
if ($D800 <= tail) and (tail <= $DBFF) then dec(sublen);

FBuffer[FOffset] := Byte('s'); Inc(FOffset);
FBuffer[FOffset] := Byte(sublen shr 8 ); Inc(FOffset);
FBuffer[FOffset] := Byte(sublen); Inc(FOffset);

PrintString(AValue, AOffset, sublen);

ACount := ACount - sublen;
AOffset := AOffset + sublen;
end;

if BUFFER_SIZE < FOffset + 16 then Flush;

if ACount <= STRING_DIRECT_MAX then
begin
FBuffer[FOffset] := Byte(STRING_DIRECT + ACount); Inc(FOffset);
end
else begin
FBuffer[FOffset] := Byte('S'); Inc(FOffset);
FBuffer[FOffset] := Byte(ACount shr 8 ); Inc(FOffset);
FBuffer[FOffset] := Byte(ACount); Inc(FOffset);
end;
PrintString(AValue, AOffset, ACount);
end;

procedure THessian2Output.WriteType(const AType: WideString);
var
Len: integer;
typeRefV: integer;
begin
Len := Length(AType);
if Len = 0 then exit;

if _typeRefs = nil then
begin
_typeRefs := TStringList.Create;
end;

typeRefV := _typeRefs.IndexOf(AType);
if typeRefV >= 0 then
begin
typeRefV := Integer(_typeRefs.Objects[typeRefV]);

if BUFFER_SIZE < FOffset + 16 then Flush;

FBuffer[FOffset] := Byte(TYPE_REF); Inc(FOffset);

writeInt(typeRefV);
end
else begin
_typeRefs.AddObject(AType, TObject(_typeRefs.Count));

if BUFFER_SIZE < FOffset + 16 then Flush;

FBuffer[FOffset] := Byte('t'); Inc(FOffset);
FBuffer[FOffset] := Byte(Len shr 8 ); Inc(FOffset);
FBuffer[FOffset] := Byte(Len); Inc(FOffset);
PrintString(AType, 0, Len);
end
end;

procedure THessian2Output.PrintString(const AValue: WideString; AOffset, ACount: integer);
var
I: integer;
ch: integer;
begin
for i := 1 to ACount do
begin
if BUFFER_SIZE < FOffset + 16 then Flush;

// encoded as UTF-8
ch := Integer(AValue[i + AOffset]);
if ch < $80 then
begin
FBuffer[FOffset] := Byte(ch); Inc(FOffset);
end
else if ch < $800 then
begin
FBuffer[FOffset] := Byte($C0 + ((ch shr 6) and $1F)); Inc(FOffset);
FBuffer[FOffset] := Byte($80 + (ch and $3F)); Inc(FOffset);
end
else begin
FBuffer[FOffset] := Byte($E0 + ((ch shr 12) and $F)); Inc(FOffset);
FBuffer[FOffset] := Byte($80 + ((ch shr 6) and $3F)); Inc(FOffset);
FBuffer[FOffset] := Byte($80 + (ch and $3F)); Inc(FOffset);
end
end
end;

procedure THessian2Output.Flush;
var
offset: integer;
begin
offset := FOffset;
if offset > 0 then
begin
FOffset := 0;
FStream.WriteBuffer(FBuffer, offset);
end
end;
end.
[/code]
book_gwbasic
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
（七）数据序列化-hessian2
jjavaboy的专栏
06-23 9234
使用hessian2协议，也就是传输对象序列化，它是二进制的RPC协议，与RMI不同的是，以标准的二进制格式定义请求的信息（请求的对象、方法、参数等），可以跨语言通讯，而RMI只局限于java间通讯。 1.hessian2原理 java-hessian2 自定义的类使用默认的序列化类com.caucho.hessian.io.JavaSerializer(Class, ClassLoader) 接...
hessian学习基础篇——序列化和反序列化
05-26
NULL 博文链接：https://qinghua0208.iteye.com/blog/493516
hession2序列化
xiaoliuliu2050的专栏
01-20 1574
1引入Hessian依赖 <!--hessian--> <dependency> <groupId>com.caucho</groupId> <artifactId>hessian</artifactId> <version>4.0.38</version&g...
Hessian2序列化问题
xiaoliuliu2050的专栏
01-20 1239
原文链接：https://blog.csdn.net/u011116672/article/details/78875504 问题 定义了一个接口，返回值为Map<String, Byte>，consumer收到结果后，使用Byte value = map.get(key)获取结果，抛出了如下类型转换异常： 如下: java.lang.ClassCastException: ...
Java 序列化之Hessian2完全解读
键盘上流淌的日子
10-10 5247
欢迎大家关注本博，同时欢迎大家评论交流，可以给个赞哦！！！   Serializable 劣势   实现Serializable接口，可以通过Java的序列化机制自动完成JavaBean的序列化和反序列化过程，亦可以通过ObjectOutputStream.writeObject()和ObjectInputStream.readObject自定义部分序列化过程，但是主要序列化过程还是需要ObjectOutputStream.defaultWiteObject()和ObjectInputStream.de.
序列化之Hessian序列化
jtf8525140的专栏
07-18 5773
Hessian序列化 上一张内容，序列化之JAVA原生序列化 直接上代码了 public class HessianSerializerUtil { public static &lt;T&gt; byte[] serialize(T obj) { byte[] bytes = null; // 1、创建字节输出流 ByteArr...
Hessian 2.0序列化协议规范.docx
最新发布
09-14
《Hessian 2.0序列化协议规范》 在分布式计算和网络通信中，数据的序列化和反序列化是至关重要的环节。Hessian 2.0是一种高效的二进制序列化协议，它旨在减少网络传输的数据量，提高数据交换的效率。本文将详细介绍...
S25-hessian反序列化1
08-03
【S25-Hessian反序列化1】是一个关于Java中Hessian序列化库的讨论，主要涉及Hessian与原生Java序列化的差异以及在Spring框架中的应用。Hessian是一种二进制序列化协议，旨在提高远程过程调用(RPC)的效率。与原生Java...
浅谈Java序列化和hessian序列化的差异
08-29
Java序列化和Hessian序列化的差异 Java序列化和Hessian序列化是两种常用的序列化机制，它们都可以将对象转换为字节流，以便在网络上传输。但是，两者之间有着很大的差异，今天我们就来比较一下它们的实现机制和特点...
hessian序列化.pdf
11-10
Hessian序列化机制分析 Hessian序列化是基于Java的开源remoting框架，速度非常快。有人做过测试，结果表明Hessian序列化的速度要比Java的快上一倍，并且序列化后的字节数也要比Java的少一倍。那么，Hessian序列化的...
初步了解Hessian2
qq_42585535的博客
07-22 771
官方解答:总结一下,Hessian是一种用于在网络上交换数据和调用远程方法的二进制协议，它可以在不同的语言和平台之间实现互操作性。它使用了一种简单而高效的二进制编码格式，可以支持复杂的对象和集合，而不需要额外的元数据或模式定义。Hessian可以作为一个轻量级的替代方案，来代替XML、SOAP或其他基于文本的协议。根据“跨平台”，“二进制”等特性，我们可以看出，Hessian在序列化和远程调用方面大有可为，本篇文章就了解一下Hessian在和远程调用和序列化方面的功能。
分布式服务架构学习（六）：实现自己的序列化工具引擎（五）-序列化Hessian实现
u014378181的博客
08-07 288
Hession是一个支持跨语言传输的二进制序列化协议，相对于Java默认的序列化机制，Hessian具有更好的性能与易用性，而且支持多种不同的语言。其中，AbstractSerializerFactory、AbstractHessianOutput、AbstractSerializer、AbstractHessianInput、AbstractDeserializer是Hessian实现序列化和反...
Hession2 序列化Byte--反序列化为Integer 默认
qfzhangwei的专栏
03-24 1208
Hession2 序列化Byte--反序列化为Integer 默认（arbitrary object）情况。自定义类型反序列化则不会改变Byte类型 /** * test Byte */ ByteArrayOutputStream outputStream = new ByteArrayOutputS...
Java二进制协议之Hessian实例（2）
kwclhit的专栏
10-21 2533
前面的文章已经说了Hessian的一些基本信息，下面就to
hessian2与java序列化
努力向上的小姑娘的博客
10-30 671
首先看一个dubbo调用场景： 测试一：使用dubbo协议，没有配置系列化方式（缺省使用hessian2） （1）如果此时将B应用中Hello对象添加一个参数，升级二方包，并B应用重新发布，A应用保持不变 这时候问题来了，这时候A调用B能正常调用吗？ 答案是可以的 （2）将B应用中的serialVersionUID删除掉，重新打包发布 此时，通过A调用B也是正常的 测试二：将B应用中dubbo的协议的系列化方式修改为java （1）如果此时将B应用中Hello对象添.
记一个 dubbo中hessian2反序列化 Map 的一个问题
weixin_33847182的博客
04-15 613
dubbo版本: 2.5.10 解决方案: 改用 "dubbo" 序列化方式 (但是 dubbo 方式也存在一个比较坑的问题 详见: Dubbo序列化多个CopyOnWriteArrayList对象变成同一对象的一个大坑!!) 酌情选择吧, 我也很尴尬 转载于:https://www.cnblogs.com/imyjy/p/10708819.html...
HessianPHP使用注意事项
落叶翩翩的CSDN博客
03-15 1332
HessianPHP_v2.0.3.zip, 在php作客户端，java作服务器端时，使用注意事项： 1.需要在php.ini中配置CURL模块: extension=php_curl.dll 2.php传中文给java, 和java返回中文给php，都有中文乱码问题： 1)php和java文件本身都采用UTF-8编码 2)在php.ini中开启mbstring模块: exte
java hessian2_Java Hessian2Output類代碼示例
weixin_42544663的博客
02-13 566
本文整理匯總了Java中com.caucho.hessian.io.Hessian2Output類的典型用法代碼示例。如果您正苦於以下問題：Java Hessian2Output類的具體用法？Java Hessian2Output怎麽用？Java Hessian2Output使用的例子？那麽恭喜您, 這裏精選的類代碼示例或許可以為您提供幫助。Hessian2Output類屬於com.caucho....
Dubbo Hessian2序列化问题
rhwayfun专栏
12-22 8796
问题定义了一个接口，返回值为Map<String, Byte>，consumer收到结果后，使用Byte value = map.get(key)获取结果，抛出了如下类型转换异常： 如下: java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.Byte at sun.reflect.Native

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值