http://www.delphi2007.net/delphiblog/html/delphi_200661410165611486.html
最近阅读了SocketConn的源码和WebService 的源码，把追踪的过程写了下来，方便大家学习。毕竟这需要精力，时间和毅力。感谢煮茶待英雄博志区和三层数据库讨论区兄弟们的支持，特别是julian兄弟，不是他，我可能没耐心继续下去。如果有时间，大家可以继续完善。从socket和Websevice的底层实现细节，我们发现BORLAND的工程师们的构思和实现的过程。我觉得这对我们的学习应该是非常重要的。学会思考。学会读源码，学会分析。
希望和我交往的朋友可通过QQ或Email联系我。Wu_yanan2003@yahoo.com.cn
另见： 《远程调用技术代码追踪(webservice) 》
《远程调用技术代码追踪(Socket) 》
《远程调用技术代码追踪(ASTA) 》
《远程调用技术代码追踪(RemObjects) 》
远程调用技术内幕
在前面我已经分析了socket和webservice的代码追踪。现在总结一下：三层架构的运作模型：
1. BizSnap与.NET Remoting 的Server端运作模式
当Client 将Request 送达Server端后，会经过一个Message Dispatcher机制，这个机制大多是几个重要的组件合作完成，主要在于解出Request中对于所要求对象的描述，以及欲呼叫的方法等信息，有了这些信息后Dispatcher就可以找到对应的对象与方法，接着就开始了呼叫动作，由于Request 是SOAP讯息格式，并不能直接用来呼叫对象的方法，因此得先将SOAP讯息转化为Stack(堆栈)，完成这个转换动作后就到了这种处理模式中的核心概念了，也就是建立起目的对象并呼叫对应的方法，这个动作非常依赖前面的Message To Stack程序，因为这个程序会将SOAP讯息转化为Stack，有了Stack之后Push Stack and Call Method 动作才能正确的执行，那么如何呼叫目的方法呢?很简单，只要利用该语言所提供的RTTI信息(.NET 中则是MetaData)，就可取得该方法的内存地址，接着只须以低阶的ASM 或IL 所提供的CALL 指令即可呼叫该方法，由于已将SOAP讯息转为Stack，因此传入参数就不是问题了。在呼叫结束后，Stack 中已经有了传回的参数，接着只须将Stack转回SOAP 讯息传回给Client端就可以了。
BizSnap、.NET Remoting 的Client端运作模式
不管是BizSnap或是.NET Remoting，当Client端欲呼叫Web Services时都会经过一个Proxy Object，于BizSnap中这个对象就是THTTPRIO，.NET Remoting中这个对象就是RealProxy，由于这个对象属于静态的，因此在使用之前必需将其转型回目的对象的型别，当Client端下达转型动作后整个魔法就开始运行了，首先Proxy Object会利用RTTI或是MetaData信息取得欲转型的类别信息，并依照这些信息建立起一个兼容于该类别的对象(Transparent Proxy Object)，接着将这个对象中的所有方法地址替换为Stub Method，Stub Method 做的事情很单纯，只是将Stack转为SOAP Message后送出，当Server端响应后再将SOAP Message转换为Stack 后返回，这样整个Client端呼叫动作就完成了，下次再呼叫时只需由Cache中取出这个已建立好的Transparent Proxy Object，就可以直接进行呼叫，这可以避免因反复以RTTI或是MetaData建立Transparent Proxy Object而失去效率。
BizSnap、.NET Remoting 的处理模式属于较低阶的方法，这种方法的坏处大于好处，
好处是设计者可以完全不了解其内部运作，以传统方式来撰写程序，坏处是过度依赖编译器及平台，增加日后移植到其它语言或平台上的难度，另外使用动态产生对象类别的低阶技术很容易引发效率及内存管理的问题。
2. NET Web Services 与Java
NET Web Services 与Java 的处理模式与.NET Remoting、BizSnap大同小异，其间最大的不同之处在于这种模式利用了其语言的特性，采动态呼叫的方式来执行呼叫的动作，而非如先前所提的模式在Stack与Message之间进行转换，这种模式简单的在Client端与Server端之间插入一个预先编译好的Proxy Object，这个Object是由WSDL所产生的，其中定义了所有目标对象的方法，在这些方法中简单的将传入的参数转换为SOAP Message，将传回的讯息转回参数，其间的运作完全属于高阶型态:
Client 端的呼叫
服务器端：
由上面两个图上可看出，这种模式讲求简单，Client端的Stub Method 由原本的一个变成每个方法一个，Server端则由原本的低阶CALL命令转为语言本身所提供的动态呼叫功能。这样的简化带来了效率，由于Client端不再经过动态转型与建立中介对象的动作，因此在效率上有显着的提升，也因为少了这些低阶的动作，内存管理上显得容易多了。但这种方式却有着另外的几个缺点，由于Proxy Object的程序代码增加，相对的程序所占用的内存也随之变大，另外Server采用动态呼叫的方式来唤起方法，这种方式通常效率不高。
RemObjects SDK
前面所提的两种模式皆有其优缺点，RO 在这方面则提出了另一个崭新的处理模式，
下图是RO 的Server端处理模式:
上图中大约与前面所提及的模式相同，其中不同之处在于Invoke Object，这是一个预先编译好的对象，其作用与.NET Web Services的Proxy Object相同，这个对象中所有方法都是Stub Method，将SOAP讯息转为参数后呼叫Real Object(Implement Object)的方法，完成后将参数转回讯息后返回Client端。那么这种模式有何独到之处呢??答案是效率，整个动作之中看不到低阶的Stack或是动态呼叫，没有这些动作的加入，当然速度上也就加快不少。
RO 的Client端处理方式与Server端大同小异，因此结论是! RO 没有用到任何的中介技术，也没有用到任何语言独有的功能，这也是RO .NET 为何能在短短的几个月内就能完成的主要原因。
-----------------------------------以上摘自 黄忠成
下面对RO自带的代码CalcService进行分析：
ROWinMessageServer1, TROIndyHTTPServer, TROIndyTCPServer
服务器支持windowMsg, HTTP, TCP等连接方式：
ROMessage: TROSOAPMessage; ROBINMessage1: TROBINMessage;
支持SOAP, 和bin两种数据格式：
RO支持多种连接方式和两种数据格式，具体请参考相应资料。
现在先分析服务器端和ROTCPClient客户端及相应的TROBINMessage。
打开CalcService服务器端之后，开始跟踪代码：
unit uROTypes;
initialization
type TRODataType = (rtInteger, rtDateTime, rtDouble, rtCurrency, rtWidestring, rtString,
rtInt64, rtBoolean, rtVariant, rtBinary, rtUserDefined);
定义了RO的相应的数据类型
unit uROClient;
_MessageClasses := TClassList.Create;
_ExceptionClasses := TClassList.Create;
用来注册Message和exception类。
procedure RegisterStringFormats(const StringFormats: array of TROStringFormatClass);
unit uROProxy;
initialization
_ProxyClasses := TStringList.Create;
//创建ProxyClasses
unit uROServer;
initialization
AddTerminateProc(FinalizeClasses);
_ServerClasses := TClassList.Create;
_ClassFactoryList := nil;
//创建成ServerClasses
unit uROIndyTCPServer;
initialization
RegisterServerClass(TROIndyTCPServer);
// TROIndyTCPServer 注册到ServerClasses列表中。
unit uROIndyHTTPServer;
initialization
RegisterServerClass(TROIndyHTTPServer);
// TROIndyHTTPServer注册到ServerClasses列表中。
unit uROBINMessage;
initialization
RegisterMessageClass(TROBINMessage);
// TROBINMessage注册到MessageClass列表中。
unit uROWinMessageServer;
initialization
RegisterServerClass(TROWinMessageServer);
// TROWinMessageServer注册到MessageClass列表中。
然后到
unit CalcLibrary_Intf;单元
initialization
RegisterProxyClass(CalcService_IID, TCalcService_Proxy);
可以看到，注到到前面创建的_ProxyClass中。
_ProxyClasses := TStringList.Create;
procedure RegisterProxyClass(const anInterfaceID : TGUID; aProxyClass : TROProxyClass);
begin
_ProxyClasses.AddObject(GUIDToString(anInterfaceID), TObject(aProxyClass))
end;
unit CalcService_Impl;
initialization
TROClassFactory.Create('CalcService', Create_CalcService, TCalcService_Invoker);
这里是比较重要的地方：
我们要把一些信息到TROClassFactory中注册。
依次是接口，过程(唤起业务对象)，invoker类（完成数据打包，发送等）
procedure Create_CalcService(out anInstance : IUnknown);
begin
anInstance := TCalcService.Create(NIL);
end;
另外unit CalcLibrary_Invk;
TCalcService_Invoker = class(TROInvoker)
private
protected
published
procedure Invoke_Sum(const __Instance:IInterface; const __Message:IROMessage; const __Transport:IROTransport);
procedure Invoke_GetServerTime(const __Instance:IInterface; const __Message:IROMessage; const __Transport:IROTransport);
end;
这个类则是完成了低层的调用。
看看这段代码：
procedure TCalcService_Invoker.Invoke_Sum(const __Instance:IInterface; const __Message:IROMessage; const __Transport:IROTransport);
__Message.Read('A', TypeInfo(Integer), A, []);
__Message.Read('B', TypeInfo(Integer), B, []);
Result := (__Instance as CalcService).Sum(A, B);
这里调用了TcalcService的具体方法：
__Message.Initialize(__Transport, 'CalcLibrary', 'CalcService', 'SumResponse');
__Message.Write('Result', TypeInfo(Integer), Result, []);
__Message.Finalize;
由此可见，真正工作的是TCalcService_Invoker这个类
它把低层的通信隐藏了起来。取出客户端调用的参数后，调用TcalcService做实际的业务处理，然后把相应的信息写入Message中返回给客户端。稍后请看详细的分析。
看看实际注册的过程：
TRORemotableCreatorFunc = procedure(out anInstance : IInterface);
constructor TROClassFactory.Create(const anInterfaceName: string;
aCreatorFunc: TRORemotableCreatorFunc;
anInvokerClass : TROInvokerClass);
begin
inherited Create;
fInvoker := NIL;
fCreatorFunc := aCreatorFunc;
fInterfaceName := anInterfaceName;
fInvokerClass := anInvokerClass;
RegisterClassFactory(Self);
end;
TROClassFactory = class(TInterfacedObject, IROClassFactory)
private
fCreatorFunc : TRORemotableCreatorFunc;
把实际调用业务对象的地址赋给fCreatorFunc，在适当的时候创建该业务对象。
继续：
procedure RegisterClassFactory(const aClassFactory : IROClassFactory);
begin
ClassFactoryList.Add(aClassFactory);
end;
把每个工厂增加到ClassFactoryList中，统一管理。
TROClassFactoryList = class(TInterfaceList)
继续：
Application.CreateForm(TfmMain, fmMain);
constructor TROMessage.Create(aOwner : TComponent);
begin
inherited Create(aOwner);
InitObject;
end;
继续：
procedure TROSOAPMessage.InitObject;
begin
inherited;
fXMLMessage := NewROXmlDocument;
fXMLMessage.New(tag_Envelope);
end;
function NewROXmlDocument : IXMLDocument;
result := TROMSXMLDocument.Create;
//这里就不细分析了，在《远程调用WEBSERVICE》中已经具体分析过。用来解析XML。
总结一下：CalcLibrary_Intf,，CalcService_Impl和CalcLibrary_Invk单元。这三个单元。
CalcLibrary_Intf
主要是声明了业务接口。TCalcService_Proxy一个代理的类（这里用的是静态代理），这里留到以后（RO代码生成技术，生成三个单元，我是不喜欢这种用法的，如果能改成用动态代理，估计会节省大量的代码，整个维护更加简单。从EJB到SPRING，大家可以看到这种代码生成技术的不足，否则JAVA中的SPRING也不会这么流行，有兴趣的兄弟，还是可以把它改成动态代理来实现。我也有一个想法，Indy控件的效率及代码生成还有数据持久层及业务对象处理上(做一款类似spring的框架)，RO支持的还是不充分的，有时间，准备把它改写一遍，有兴趣的可以和我一起交流）。
继续代码追踪：
CoCalcService = class
class function Create(const aMessage : IROMessage; aTransportChannel : IROTransportChannel) : CalcService;
end;
这个是一个服务类。就是创建一个TCalcService_Proxy代理。
CalcService_Impl这个单元，则是真正的业务对象方法实现的单元。
procedure Create_CalcService(out anInstance : IUnknown);
begin
anInstance := TCalcService.Create(NIL);
end;
这里RO用了一种常用的事件绑定的手法。这样RO的工厂指针赋值后就可唤起业务对象，实现业务对象的激活。
TROClassFactory.Create('CalcService', Create_CalcService, TCalcService_Invoker);
我们看还注册了TCalcService_Invoker这个类。
回到CalcLibrary_Invk单元中发现
procedure TCalcService_Invoker.Invoke_Sum(const __Instance:IInterface; const __Message:IROMessage; const __Transport:IROTransport);
{ function Sum(const A: Integer; const B: Integer): Integer; }
var
A: Integer;
B: Integer;
Result: Integer;
begin
try
__Message.Read('A', TypeInfo(Integer), A, []);
//把客户端发送的Message消息包拆包，赋给已定义的变量。
__Message.Read('B', TypeInfo(Integer), B, []);
Result := (__Instance as CalcService).Sum(A, B); // 调用
__Message.Initialize(__Transport, 'CalcLibrary', 'CalcService', 'SumResponse');
__Message.Write('Result', TypeInfo(Integer), Result, []);
//把服务器端的结果打包。标记'Result',写入值。发送客户端。
__Message.Finalize;
finally
end;
end;
它调用了真正的业务对象，现在大概清楚它的工作原理了吧，让我们继续追踪它的源码。
首先创建TROBINMessage类。
constructor TROBINMessage.Create(aOwner: TComponent);
begin
inherited;
UseCompression := TRUE;
end;
前面说过，RO支持SOAP, 和bin两种数据格式：它们的父类都是TROMessage
RO的消息处理的技术是非常值得学习的，它的模型比较先进。我会仔细分析的。
先到父类里看看：
constructor TROMessage.Create(aOwner : TComponent);
begin
inherited Create(aOwner);
InitObject;
end;
看看InitObject
procedure TROMessage.InitObject;
begin
fSerializer := CreateSerializer;
fClientID := NewGuid();
//CreateGUID(fClientID);
end;
先停下来仔细研究ROMessage,这个类非常重要。
TROMessage = class(TComponent, IUnknown, IROMessage, IROMessageCloneable, IROModuleInfo)
private
fSerializer : TROSerializer;
fMessageName,
fInterfaceName : string;
fOnReadFromStream: TStreamOperation;
fOnWriteToStream: TStreamOperation;
fOnServerException: TExceptionEvent;
……
fClientID : TGUID;
这里比较重要的TROSerializer, fMessageName, fInterfaceName, fClientID
TStreamOperation = procedure(aStream : TStream) of object; 处理TStream
TExceptionEvent = procedure(anException : Exception) of object; 处理异常
另外用了GUID做标识。
function TROMessage.Clone: IROMessage; 克隆一个RoMessage
function TROMessage.Clone: IROMessage;
begin
result := TROMessageClass(ClassType).CreateRefCountedClone(self) as IROMessage;
end;
constructor TROMessage.CreateRefCountedClone(iMessage: TROMessage);
begin
Create(); //调用构造函数
Assign(iMessage); //赋值
fReferenceCounted := true;
end;
现在看看TROSerializer，这是TROMessage最重要的部分：
里面主要定义了一些虚方法。这个一个序列化的类。主要功能是序列化。COM中也叫散集和列集。说穿了就是数据怎么序列化到一个流中，或者逆操作。我们来仔细研究研究。个人觉得这里面的东西很值得研究。搞清楚序列化，对于我们灵活的使用RO将有非常大的帮助。
procedure TROSerializer.BeginReadObject(const aName: string;
aClass : TClass; var anObject: TObject; var LevelRef : IUnknown; var IsValidType : boolean; ArrayElementId : integer = -1);
begin
IsValidType := aClass.InheritsFrom(TROComplexType)
end;
//判断是不是RO定义的TROComplexType（合成类型的类）派生出来的子类。
//序列化(读)
procedure TROSerializer.Read(const aName: string; aTypeInfo: PTypeInfo;
var Ptr; ArrayElementId : integer = -1);
begin
case aTypeInfo^.Kind of
tkClass : ReadObject(aName, GetTypeData(aTypeInfo).ClassType, Ptr, ArrayElementId);
else RaiseError(err_TypeNotSupported, [GetEnumName(TypeInfo(TTypeKind), Ord(aTypeInfo^.Kind))]);
end;
end;
其它类型就不研究了，大家估计都用过。我自己开发的一款类型的O/Pmaping中也用到了相应的技术，可以通过设置VO之间的映射，把两个VO加入明细VO类中，然后通过RTTL信息解析出SQL语句(select, insert,update,delete)（分析）。，有兴趣的兄弟可以跟我联系。我的例子如下：
/------------------------------------------------------
例如：
Tuser = (TdataTransferObject)
A: TA;
B: TB;
End;
用法：
rdmDS.select(TUser, ds) 返回一个数据集
/-------------------------------------------------------
继续看看ReadObject怎么处理的：
procedure TROSerializer.ReadObject(const aName: string; aClass : TClass; var Ref; ArrayElementId : integer = -1);
var obj : TObject absolute Ref;
props : PPropList;
cnt, i : integer;
LevelRef : IUnknown;
validtype : boolean;
// Temporary variables
int64val : int64;
intval : integer;
enuval : byte;
dblval : double;
//extval : extended;
strval : string;
{$IFNDEF DELPHI5}wstrval : widestring;{$ENDIF}
objval : TObject;
begin
obj := nil; { no matter what's passed in, we wanna start fresh }
BeginReadObject(aName, aClass, obj, levelref, validtype, ArrayElementId);
procedure TROSerializer.BeginReadObject(const aName: string;
aClass : TClass; var anObject: TObject; var LevelRef : IUnknown; var IsValidType : boolean; ArrayElementId : integer = -1);
begin
IsValidType := aClass.InheritsFrom(TROComplexType)
end;
在序列化（读）一个对象时，首先判断是不是从TROComplexType派生的。
if Assigned(obj) and (not validtype) then RaiseError(err_TypeNotSupported, [obj.ClassName]); //如果不是从TROComplexType派生，则抛出一个异常！
这里大家应该清楚了，如果想序列化一个对象，必须从TROComplexType派生才可以。
清楚了这点，在三层中传递对象的问题，大家应该知道怎么解决了吧。
TROComplexType = class(TPersistent)
private
fFieldCount : integer;
fFieldList : PPropList;
序列化从Tpersistent派生出来({m+}{m-}这里是关键)，这里RO还加上了RTTL信息。
if Assigned(obj) and (obj.ClassInfo <> nil) then begin
cnt := GetTypeData(obj.ClassInfo).PropCount;
//GetTypeData 函数获得类的属性数量。
if (cnt>0) then begin
GetMem(props, cnt*SizeOf(PPropInfo)); //分配存放属性信息的空间
try
cnt := GetPropList(PTypeInfo(obj.ClassInfo), tkProperties, props);
//GetPropList 传入类的 TTypeInfo 指针和 TPropList 的指针，它为 PropList 分配一块内存后把该内存填充为指向 TPropInfo 的指针数组，最后返回属性的数量。
for i := 0 to (cnt-1) do begin
with props^[i]^ do begin
。。。。。。。。。。。。。。
tkInteger : begin
ReadInteger(Name, GetTypeData(PropType^).OrdType, intval);//虚函数：调用子类方法(从客户端发送的一个流中) 例：
procedure TROStreamSerializer.ReadInteger(const aName: string;
anOrdType: TOrdType; var Ref; ArrayElementId : integer = -1);
var sze : byte;
src : pointer;
begin
src := @Ref;
。。。。。
fStream.Read(src^, sze);
end;
SetOrdProp(obj, Name, intval); //把属性信息写入对象中。
end;
。。。。。。。。。。。
tkClass : begin
ReadObject(Name, GetTypeData(PropType^).ClassType, objval); //递归
SetObjectProp(obj, Name, objval); //把属性（对象）写入对象中。
end;
…………..
CustomReadObject(aName, aClass, obj, ArrayElementId);
EndReadObject(aName, aClass, obj, levelref);
end;
//把TROArray类型的数据（序列化）
procedure TROSerializer.CustomWriteObject(const aName: string; aClass : TClass; const Ref; ArrayElementId : integer = -1);
var obj : TObject absolute Ref;
i : integer;
itemref : pointer;
begin
if Assigned(obj) then begin
if (obj is TROArray) then with TROArray(obj) do begin
if (GetItemClass<>NIL) then begin
for i := 0 to (Count-1) do begin
itemref := GetItemRef(i);
Write(ArrayItemName, GetItemType, itemref, i);
end;
end
else begin
for i := 0 to (Count-1) do begin
itemref := GetItemRef(i);
Write(ArrayItemName, GetItemType, itemref^, i);
end;
end;
end;
end;
end;
//再回到CreateSerializer
procedure TROMessage.InitObject;
begin
fSerializer := CreateSerializer;
fClientID := NewGuid();
//CreateGUID(fClientID);
end;
function TROBINMessage.CreateSerializer : TROSerializer;
begin
result := TROStreamSerializer.Create(NIL);
end;
//真正工作的类是TROStreamSerializer，具体的数据（序列化）稍后再分析。
constructor TROIndyTCPServer.Create(aComponent: TComponent);
begin
inherited;
fIndyServer := CreateIndyServer;
fIndyServer.Name := 'InternalIndyServer';
{$IFDEF DELPHI6UP}
fIndyServer.SetSubComponent(True);
{$ENDIF}
end;
跟踪一下TROIndyTCPServer用法：
constructor TROServer.Create(aOwner: TComponent);
begin
inherited;
fDispatchers := GetDispatchersClass.Create(Self);
end;
function TROServer.GetDispatchersClass : TROMessageDispatchersClass;
begin
result := TROMessageDispatchers; // Default
end;
constructor TROMessageDispatchers.Create(aServer : TROServer);
begin
inherited Create(GetDispatcherClass);
fServer := aServer;
end;
function TROIndyTCPServer.CreateIndyServer: TIdTCPServer;
begin
result := TROTIdTCPServer.Create(Self);
result.OnExecute := InternalOnExecute;
result.DefaultPort := 8090;
end;
调用：
constructor TIdTCPServer.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
FBindings := TIdSocketHandles.Create(Self);
// Before Command handlers
FReplyTexts := TIdRFCReplies.Create(Self);
FCommandHandlers := TIdCommandHandlers.Create(Self);
FCommandHandlersEnabled := IdCommandHandlersEnabledDefault;
FGreeting := TIdRFCReply.Create(nil);
FMaxConnectionReply := TIdRFCReply.Create(nil);
FThreads := TThreadList.Create;
FThreadClass := TIdPeerThread;
FReplyUnknownCommand := TIdRFCReply.Create(nil);
//
FTerminateWaitTime := 5000;
FListenQueue := IdListenQueueDefault;
//TODO: When reestablished, use a sleeping thread instead
// fSessionTimer := TTimer.Create(self);
end;
//继续：
constructor TIdComponent.Create(axOwner: TComponent);
begin
inherited Create(axOwner);
GStackCriticalSection.Acquire; try
Inc(GInstanceCount);
if GInstanceCount = 1 then begin
GStack := TIdStack.CreateStack;
end;
finally GStackCriticalSection.Release; end;
end;
class function TIdStack.CreateStack: TIdStack;
begin
Result := GStackClass.Create;
end;
constructor TIdStackWindows.Create;
var
sData: TWSAData;
begin
inherited Create;
if not GStarted then
begin
if WSAStartup($202, sData) = SOCKET_ERROR then begin
raise EIdStackInitializationFailed.Create(RSWinsockInitializationError);
end;
GStarted := True;
end;
end;
//可以看出真正进行SOCKET通过的部分应该是TidSocketHandle,而TidSocketHandle又调用了TidStack的派生类TidStackWindows来完成真正的底层通信工作的。
TidStack里面的方法都是抽象的，说明具体的通信细节是由派生类实现的。这样的好处是什么，底层通信的无关性。我觉得这是非常重要的部分，仔细阅读RO的源码中，发现了类似非常多的应用，正是这种良好的设计，使RO的通信部分与业务逻辑部分彻底分离。同时支持多种通信协议。
constructor TROIndyTCPServer.Create(aComponent: TComponent);
begin
inherited;
fIndyServer := CreateIndyServer;
fIndyServer.Name := 'InternalIndyServer';
fIndyServer.SetSubComponent(True);
end;
classs单元：
function InitInheritedComponent(Instance: TComponent; RootAncestor: TClass): Boolean;
function InitComponent(ClassType: TClass): Boolean;
begin
Result := False;
if (ClassType = TComponent) or (ClassType = RootAncestor) then Exit;
Result := InitComponent(ClassType.ClassParent);
Result := InternalReadComponentRes(ClassType.ClassName, FindResourceHInstance(
FindClassHInstance(ClassType)), Instance) or Result;
end;
var
LocalizeLoading: Boolean;
begin
GlobalNameSpace.BeginWrite; // hold lock across all ancestor loads (performance)
try
LocalizeLoading := (Instance.ComponentState * [csInline, csLoading]) = [];
if LocalizeLoading then BeginGlobalLoading; // push new loadlist onto stack
try
Result := InitComponent(Instance.ClassType);
if LocalizeLoading then NotifyGlobalLoading; // call Loaded
finally
if LocalizeLoading then EndGlobalLoading; // pop loadlist off stack
end;
finally
GlobalNameSpace.EndWrite;
end;
end;
procedure NotifyGlobalLoading;
var
I: Integer;
G: TList;
begin
G := GlobalLoaded; // performance: eliminate repeated trips through TLS lookup
for I := 0 to G.Count - 1 do
TComponent(G[I]).Loaded;
end;
procedure TIdTCPServer.Loaded;
begin
inherited Loaded;
// Active = True must not be performed before all other props are loaded
if Active then begin
FActive := False;
Active := True;
end;
end;
procedure TROServer.Loaded;
begin
inherited;
IntSetActive(FALSE);
Active := fLoadActive;
fDoneAfterLoad := TRUE;
end;
procedure TIdTCPServer.SetActive(AValue: Boolean);
var
i: Integer;
LListenerThread: TIdListenerThread;
begin
if (not (csDesigning in ComponentState)) and (FActive <> AValue)
and (not (csLoading in ComponentState)) then begin
if AValue then begin
// InitializeCommandHandlers must be called only at runtime, and only after streaming
// has occured. This used to be in .Loaded and that worked for forms. It failed
// for dynamically created instances and also for descendant classes.
if not FCommandHandlersInitialized then begin
FCommandHandlersInitialized := True;
InitializeCommandHandlers;
end;
// Set up bindings
if Bindings.Count = 0 then begin
Bindings.Add;
end;
function TIdSocketHandles.Add: TIdSocketHandle;
begin
Result := Inherited Add as TIdSocketHandle;
Result.Port := DefaultPort;
end;
constructor TIdSocketHandle.Create(ACollection: TCollection);
begin
inherited Create(ACollection);
Reset;
FClientPortMin := 0;
FClientPortMax := 0;
if assigned(ACollection) then begin
Port := TIdSocketHandles(ACollection).DefaultPort;
end;
end;
// Set up ThreadMgr
ThreadMgr.ThreadClass := ThreadClass;其不意 //TIdPeerThread
function TIdTCPServer.GetThreadMgr: TIdThreadMgr;
begin
if (not (csDesigning in ComponentState)) and (not Assigned(FThreadMgr)) then
begin
// Set up ThreadMgr
ThreadMgr := TIdThreadMgrDefault.Create(Self); //指定TIdTCPServer
FImplicitThreadMgr := true;
end;
Result := FThreadMgr;
end;
constructor TIdThreadMgr.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
FActiveThreads := TThreadList.Create;
FThreadPriority := tpNormal;
end;
// Setup IOHandler
if not Assigned(FIOHandler) then begin
IOHandler := TIdServerIOHandlerSocket.Create(self);
constructor TIdComponent.Create(axOwner: TComponent);
begin
inherited Create(axOwner);
GStackCriticalSection.Acquire; try
Inc(GInstanceCount);
if GInstanceCount = 1 then begin
GStack := TIdStack.CreateStack;
end;
finally GStackCriticalSection.Release; end;
end;
FImplicitIOHandler := true;
end;
// Set up listener threads
FListenerThreads := TThreadList.Create;
IOHandler.Init;
for i := 0 to Bindings.Count - 1 do begin
with Bindings[i] do begin
AllocateSocket;
procedure TIdSocketHandle.AllocateSocket(const ASocketType: Integer = Id_SOCK_STREAM;
const AProtocol: Integer = Id_IPPROTO_IP);
begin
// If we are reallocating a socket - close and destroy the old socket handle
CloseSocket;
if HandleAllocated then begin
Reset;
end;
FHandle := GStack.CreateSocketHandle(ASocketType, AProtocol);
FHandleAllocated := True;
end;
TIdStackSocketHandle = TSocket; Integer;
//可以看出真正进行SOCKET通过的部分应该是TidSocketHandle,而TidSocketHandle又调用了Gstack
function TIdStack.CreateSocketHandle(const ASocketType: Integer;
const AProtocol: Integer = Id_IPPROTO_IP): TIdStackSocketHandle;
begin
result := WSSocket(Id_PF_INET, ASocketType, AProtocol);
if result = Id_INVALID_SOCKET then begin
raise EIdInvalidSocket.Create(RSCannotAllocateSocket);
end;
end;
//创建一个SOCKET套接字
function TIdStackWindows.WSSocket(AFamily, AStruct, AProtocol: Integer): TIdStackSocketHandle;
begin
result := Socket(AFamily, AStruct, AProtocol);
end;
if (FReuseSocket = rsTrue) or ((FReuseSocket = rsOSDependent) and (GOSType = otLinux))
then begin
SetSockOpt(Id_SOL_SOCKET, Id_SO_REUSEADDR, PChar(@Id_SO_True), SizeOf(Id_SO_True));
end;
Bind;
Bind的调用如下：
function TIdSocketHandle.TryBind: Boolean;
begin
Result := not GStack.CheckForSocketError(GStack.WSBind(Handle, Id_PF_INET, IP, Port)
, [Id_WSAEADDRINUSE]);
if Result then begin
UpdateBindingLocal;
end;
end;
function TIdStackWindows.WSBind(ASocket: TIdStackSocketHandle;
const AFamily: Integer; const AIP: string;
const APort: Integer): Integer;
var
Addr: TSockAddrIn;
begin
Addr.sin_family := AFamily;
if length(AIP) = 0 then begin
Addr.sin_addr.s_addr := INADDR_ANY;
end else begin
Addr.sin_addr := TInAddr(StringToTInAddr(AIP));
end;
Addr.sin_port := HToNS(APort);
result := Bind(ASocket, @addr, SizeOf(Addr));
end;
侦听：
Listen(FListenQueue);
procedure TIdSocketHandle.Listen(const anQueueCount: integer);
begin
GStack.CheckForSocketError(GStack.WSListen(Handle, anQueueCount));
end;
//这里创建了一个侦听线程,用于accept客户连接。
LListenerThread := TIdListenerThread.Create(Self, Bindings[i]);
constructor TIdListenerThread.Create(AServer: TIdTCPServer; ABinding: TIdSocketHandle);
begin
inherited Create;
FBinding := ABinding;
FServer := AServer;
end;
//加入线程池中。
FListenerThreads.Add(LListenerThread);
procedure TThreadList.Add(Item: Pointer);
begin
LockList;
try
if (Duplicates = dupAccept) or
(FList.IndexOf(Item) = -1) then
FList.Add(Item)
else if Duplicates = dupError then
FList.Error(@SDuplicateItem, Integer(Item));
finally
UnlockList;
end;
end;
//启动线程。
LListenerThread.Start;
end;
end;
end else begin
TerminateListenerThreads;
// Tear down ThreadMgr
try
TerminateAllThreads;
finally
if ImplicitThreadMgr and TIdThreadSafeList(Threads).IsCountLessThan(1) then begin // DONE -oAPR: BUG! Threads still live, Mgr dead ;-(
FreeAndNil(FThreadMgr);
FImplicitThreadMgr := False;
end;
end;//tryf
end;
end;
FActive := AValue;
end;
procedure TIdListenerThread.Run;
var
LIOHandler: TIdIOHandler;
LPeer: TIdTCPServerConnection;
LThread: TIdPeerThread;
begin
try
if Assigned(Server) then begin // This is temporary code just to test one exception
while True do begin
LThread := nil;
LPeer := TIdTCPServerConnection.Create(Server);
constructor TIdTCPConnection.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
FGreeting := TIdRFCReply.Create(nil);
FLastCmdResult := TIdRFCReply.Create(nil);
FRecvBuffer := TIdSimpleBuffer.Create;
RecvBufferSize := GRecvBufferSizeDefault;
FSendBufferSize := GSendBufferSizeDefault;
FInputBuffer := TIdManagedBuffer.Create(BufferRemoveNotify);
FMaxLineLength := IdMaxLineLengthDefault;
end;
LIOHandler := Server.IOHandler.Accept(Binding.Handle, SELF);
//等候客户端连接：
function TIdSocketHandle.Select(ASocket: TIdStackSocketHandle;
ATimeOut: Integer): boolean;
var
ReadList: TList;
begin
ReadList := TList.Create; try
ReadList.Add(Pointer(ASocket));
Result := GStack.WSSelect(ReadList, nil, nil, ATimeOut) = 1;
TIdAntiFreezeBase.DoProcess(result = false);
finally ReadList.free; end;
end;
//一旦有客户连接跳出循环，处理客户消息。否则一直循环。
if LIOHandler = nil then begin
FreeAndNil(LPeer);
Stop;
Exit;
end
else begin
LThread := TIdPeerThread(Server.ThreadMgr.GetThread);
LThread.FConnection := LPeer;
LThread.FConnection.IOHandler := LIOHandler;
LThread.FConnection.FFreeIOHandlerOnDisconnect := true;
end;
// LastRcvTimeStamp := Now; // Added for session timeout support
// ProcessingTimeout := False;
if (Server.MaxConnections > 0) and // Check MaxConnections
NOT TIdThreadSafeList(Server.Threads).IsCountLessThan(Server.MaxConnections)
then begin
Server.ThreadMgr.ActiveThreads.Remove(LThread);
LPeer.WriteRFCReply(Server.MaxConnectionReply);
LPeer.Disconnect;
FreeAndNil(LThread); // This will free both Thread and Peer.
end else begin
Server.Threads.Add(LThread); //APR
// Start Peer Thread
LThread.Start;
Break;
end;
end;
end;
except
on E: Exception do begin
if Assigned(LThread) then
FreeAndNil(LThread);
Server.DoListenException(Self, E);
end;
end;
End;
///
//客户端分析
///
现在来分析分析客户端代码：ROTCPClient先看这个工程：
constructor TROBINMessage.Create(aOwner: TComponent);
begin
inherited;
UseCompression := TRUE;
end;
服务器端分析过，这里就不分析了。
constructor TROIndyTCPChannel.Create(aOwner: TComponent);
begin
inherited;
fIndyClient := CreateIndyClient;
fIndyClient.Name := 'InternalIndyClient';
{$IFDEF DELPHI6UP}
fIndyClient.SetSubComponent(TRUE);
{$ENDIF}
end;
constructor TROBaseConnection.Create(aOwner: TComponent);
{ Creates an object of type TROBaseConnection, and initializes properties. }
begin
inherited Create(aOwner);
{$IFDEF RemObjects_UseEncryption}
fEncryption := TROEncryption.Create();//(nil);
{$ENDIF}
//fEncryption.SetSubComponent(true);
//fInternalEncryption := true;
{ ToDo -cCDK: Add your initialization code here. }
end;
function TROIndyTCPChannel.CreateIndyClient: TIdTCPClient;
begin
result := TIdTCPClient.Create(Self);
result.Port := 8090;
result.Host := '127.0.0.1';
end;
constructor TIdTCPClient.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
FBoundPort := BoundPortDefault;
end;
constructor TIdComponent.Create(axOwner: TComponent);
begin
inherited Create(axOwner);
GStackCriticalSection.Acquire; try
Inc(GInstanceCount);
if GInstanceCount = 1 then begin
GStack := TIdStack.CreateStack;
end;
finally GStackCriticalSection.Release; end;
end;
接下来看看客户端调用情况：
可以看出来这个时候，还没有连接到服务器上。
procedure TfmMain.btnCalcClick(Sender: TObject);
var
vService:CalcService;
begin
vService:=CoCalcService.Create(ROBINMessage1,ROIndyTCPChannel1);
try
lblResult.Caption:=IntToStr(vService.Sum(StrToInt(edtValue1.Text),StrToInt(edtValue2.Text)));
finally
vService:=Nil;
end;
end;
接下来会详细分析，客户端怎么调用服务器方法。数据如何打包。传输的。
vService:=CoCalcService.Create(ROBINMessage1,ROIndyTCPChannel1);
我们看到创建了一个实例：
CalcService_Intf这个单元，是RO自已生成的：
class function CoCalcService.Create(const aMessage : IROMessage; aTransportChannel : IROTransportChannel) : CalcService;
begin
result := TCalcService_Proxy.Create(aMessage, aTransportChannel);
end;
大家看到，这里调用了一个代理类：也就是“桩”。
RO用的是静态代理的技术。我个人觉得这里应该采用“动态代理”技术。好处我在前面已经说过了。就不多说了，继续。+
TCalcService_Proxy = class(TROProxy, CalcService)
private
protected
function Sum(const A: Integer; const B: Integer): Integer;
function GetServerTime: DateTime;
end;
继承于TROProxy类。
创建的时候用了接口技术。个人认为，这是RO的核心中的核心。正是因为使用了这个接口，好处就是消息处理格式，消息底层处理完完全全分离了。因此，静态代理也变得更加单纯。不用关心怎么去操作不同格式的消息，及消息的底层调用，与底层通信协议无关了。所以这里用HTTP， TCP，UDP不同的组件，就可以实现在业务层根据不动的情况下。多种网络通信的可能性。
中间层服务器可以服务通过这种组件和不同协议的客户端通信，被不同协议的客户端所调用。
constructor TROProxy.Create(const aMessage: IROMessage;
const aTransportChannel: IROTransportChannel);
begin
inherited Create;
fMessage := pointer(aMessage);
fTransportChannel := pointer(aTransportChannel);
end;
IROTransport = interface
['{56FA09B9-FFC8-4432-80E3-BF78E5E7DF33}']
function GetTransportObject : TObject;
end;
IROTransportChannel = interface(IROTransport)
['{EDFA0CF3-3265-46C9-AC5C-14C3CACF2721}']
procedure Dispatch(aRequest, aResponse : TStream);
end;
//我们看到IROTransportChannel很简单，就是分发消息，GetTransportObject这个函数是由接口得到实例。
TROTransportChannel = class(TComponent, IROTransportChannel, IROMetadataReader)
function GetTransportObject : TObject; virtual; abstract;
这个类是TROIndyTCPChannel的父类，可以看到上面的方法是虚方法。
看看真正实现的内容。
function TROIndyTCPChannel.GetTransportObject: TObject;
begin
result := Self;
end;
这里很简单，但必须自己实现这个方法，因为Delphi本身不支持直接从接口转化成实例类。再看看procedure Dispatch(aRequest, aResponse : TStream);
研究一下RO底层消息到底是如何分发的。
procedure Dispatch(aRequest, aResponse : TStream); reintroduce;
procedure IntDispatch(aRequest, aResponse : TStream); virtual; abstract;
procedure TROTransportChannel.Dispatch(aRequest, aResponse : TStream);
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
{$IFDEF REMOBJECTS_UseEncryption}
if Encryption.EncryptionMethod <> tetNone then begin
EncRequest:= TMemoryStream.Create;
EncResponse := TMemoryStream.Create;
try
DoEncryption(aRequest,EncRequest); //进行加密
IntDispatch(encRequest, encResponse);
DoDecryption(EncResponse,aResponse); //进行解密
finally
EncRequest.Free;
EncResponse.free;
end;
end
else
{$ENDIF}
begin
IntDispatch(aRequest, aResponse);
end;
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
end;
procedure TROIndyTCPChannel.IntDispatch(aRequest, aResponse: TStream);
begin
try
if not IndyClient.Connected
then IndyClient.Connect;
IndyClient.WriteStream(aRequest, TRUE, TRUE);
IndyClient.ReadStream(aResponse);
finally
if not KeepAlive
then IndyClient.Disconnect;
end;
end;
//是不是有点失望，它的消息分发太简单了。这就是抽象编程的优点。分发只管分发消息。打包由其它的类实现。这里远程调用被抽象成了：‘一个aRequest，一个aResponse’。是不是有点象B/S架构中的HTTP请求。
再看看前面的代码：
TROProxy = class(TInterfacedObject, IUnknown)
property __Message : IROMessage read GetMessage;
具体实现
function TCalcService_Proxy.Sum(const A: Integer; const B: Integer): Integer;
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
__Message.Write('A', TypeInfo(Integer), A, []);
__Message.Write('B', TypeInfo(Integer), B, []);
__Message.Finalize;
__Message.WriteToStream(__request);
__TransportChannel.Dispatch(__request, __response);
__Message.ReadFromStream(__response);
__Message.Read('Result', TypeInfo(Integer), result, []);
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
这里总结一下：
TROTransportChannel.Dispatch用来处理底层的数据包是否加密解密。
派生的子类TROIndyTCPChannel，借助具体的通信实现类TIdTCPClient完成数据的收发。数据的打包借助TROBINMessage, SOAPMessage类，来完成具体的打包细节，因为用了接口，所以数据的打包变得很灵活可以是SOAP消息，或者BIN消息。
具体的通信细节则隐藏在了TROIndyTCPChannel控件中，不同的控件，就实现了不同的通信细节，比如TROIndyUDPChannel，具体的返回服务器参数的问题则由静态代理配合Message类来完成：如TCalcService_Proxy和TROBINMessage类。
因此，中间层通过TROIndyTCPServer ,TROIndyUDPServer, TROIndyHTTPServer等控件。就可以分别和不同的客户TROIndyTCPChannel, TROIndyUDPChannel进行通信了。
可能有人又不理解为什么，再看看
__Message.WriteToStream(__request);
__TransportChannel.Dispatch(__request, __response);
__Message.ReadFromStream(__response);
是不是豁然开朗了呢？
业务对象 –> 静态代理
静态代理借助 Message接口，TransportChannel接口巧妙地把具体的消息打包的消息收发隐藏在代理之后。
再看看代理类：
class function CoCalcService.Create(const aMessage : IROMessage; aTransportChannel : IROTransportChannel) : CalcService;
begin
result := TCalcService_Proxy.Create(aMessage, aTransportChannel);
end;
由此可见，传进去的message，aTransportChannel接口不同，由此消息打包的底层的通信就彻底发生了变成。而丝毫不影响业务对象本身，而中间层只需要支持多种Message及通信类就行，这是设计模式中的桥式结构。接口的妙用，体现的沐漓尽致
------------------------------------------------------------------------------------------------------------
| |
TROServer TROTransportChannel
| |
TCP， UDP， HTTP TCP， UDP， HTTP
| |
--------------------------------------------------------------------------------------------------
bin , soap bin , soap
| |
TROMessage TROMessage
| |
------------------------------------------------------------------------------------------------------
业务对象
//具体的加密解密在后面详细分析。现在总结一下静态代理底层到底做了什么：
TROProxy = class(TInterfacedObject, IUnknown)
private
fMessage, //通过接口解析各种不同格式消息
fTransportChannel : pointer; //通过接口处理不同的协议通信
fInterfaceName : string; //处理的接口名称
….
end;
所以静态代理的工作原理就是，利用fMessage解析，打包数据利用fTransportChannel传输，接收服务器端数据。
继续追踪源代码：
看看具体怎么调用的：
lblResult.Caption:=IntToStr(vService.Sum(StrToInt(edtValue1.Text),StrToInt(edtValue2.Text)));
这里是关键，我们好好看看RO是怎么打包数据，传输数据。然后接收服务器端数据，解析出数据的，代码如下：
function TCalcService_Proxy.Sum(const A: Integer; const B: Integer): Integer;
var __request, __response : TMemoryStream;
__http : IROHTTPTransport;
begin
__request := TMemoryStream.Create; //请求
__response := TMemoryStream.Create; //响应
try
__Message.Initialize(__TransportChannel, 'NewLibrary', CalcService_DefaultURN, 'Sum'); //初始化数据：
if Supports(__TransportChannel, IROHTTPTransport, __http) then begin
__http.Headers['SOAPAction'] := '"urn:CalcLibrary-CalcService#Sum"';
if (__http.TargetURL='') then __http.TargetURL := CalcService_EndPointURI;
//处理HTTP协议特有的数据包头，判断是否支持HTTP接口。这里不支持，因为这里是TCP协议。
end;
__Message.Write('A', TypeInfo(Integer), A, []); //打包数据（参数1）
__Message.Write('B', TypeInfo(Integer), B, []); //打包数据（参数2）
__Message.Finalize;
__Message.WriteToStream(__request); //把数据打包入流中。
__TransportChannel.Dispatch(__request, __response); //向服务器端发送数据包，并返回服务器端数据包。
__Message.ReadFromStream(__response); //解析服务器端数据包
__Message.Read('Result', TypeInfo(Integer), result, []); //读出数据包中数据，写入返回值中。
finally
__request.Free;
__response.Free;
end
end;
现在看这段代码，估计不难了吧。我们不得不惊叹RO设计的完美，简单。
这里的抽象编程运用的沐漓尽致。
下面来仔细分析一下具体工作流程：
//数据包初始化过程：
procedure TROBINMessage.Initialize(const aTransport : IROTransport; const anInterfaceName, aMessageName : string);
begin
inherited;
procedure TROMessage.Initialize(const aTransport: IROTransport; const aLibraryName, anInterfaceName, aMessageName: string);
begin
Initialize(aTransport, anInterfaceName, aMessageName);
end;
把TROIndyTCPChannel，接口，及调用函数传下去。
procedure TROMessage.Initialize(const aTransport : IROTransport; const anInterfaceName, aMessageName: string);
begin
fInterfaceName := anInterfaceName;
fMessageName := aMessageName;
end;
SetHTTPInfo(aTransport, dfBinary);
// 是否使用HTTP协议传输数据：如果是则把相应信息设置。
procedure SetHTTPInfo(const aTransport : IROTransport; aDataFormat : TDataFormat);
var http : IROHTTPTransport;
begin
{$IFDEF DOTNET}
{$ELSE}
if Supports(aTransport, IROHTTPTransport, http) then begin
http.ContentType := DataFormatStrs[aDataFormat];
http.UserAgent := str_ProductName;
end;
{$ENDIF DOTNET}
end;
if fDestroyStream then FreeAndNIL(fStream);
fStream := TMemoryStream.Create;
fDestroyStream := TRUE;
//创建一个TmemoryStream对象。准备打包数据。
TROMessage = class(TComponent, IUnknown, IROMessage, IROMessageCloneable, IROModuleInfo)
private
fSerializer : TROSerializer;
我们看到ROMessage通过序列化对象，对数据进行序列化操作，写入流中。
TROStreamSerializer 派生与TROSerializer,在前面已经对序列化进行了详细的介绍，请参考前面内容。
(Serializer as TROStreamSerializer).SetStorageRef(fStream); // Very important!
//注意：Bin数据时
procedure TROStreamSerializer.SetStorageRef(aStorageRef: TStream);
begin
//result := TObject(aStorageRef) is TStream;
//if result then fStream := TStream(aStorageRef);
fStream := aStorageRef;
end;
//SOAP数据时：
TROSOAPMessage
(Serializer as TROXMLSerializer).SetStorageRef(pointer(fMessageNode));
procedure TROXMLSerializer.SetStorageRef(aStorageRef : pointer);
begin
fNode := nil;
if Supports(IUnknown(aStorageRef), IXMLNode) then begin
//RaiseError('TROXMLSerializer: Not a valid IXMLNode reference',[]);
fBodyNode := NIL;
fRespNode := NIL;
fMaxRef := 0;
fNode := IXMLNode(aStorageRef);
end;
{fNode := aStorageRef;}
end;
MessageName := aMessageName;
InterfaceName := anInterfaceName;
Stream_WriteStringWithLength(fStream,InterfaceName);
procedure Stream_WriteStringWithLength(iStream:TStream; const iString: string);
var lLength:integer;
{$IFDEF DOTNET}
lBuffer:array of byte;
i:integer;
{$ENDIF DOTNET}
begin
lLength := Length(iString);
iStream.Write(lLength, SizeOf(lLength)); //往流中写入长度信息：
if (lLength > 0) then begin
{$IFDEF DOTNET}
SetLength(lBuffer, lLength);
for i := 0 to lLength-1 do lBuffer[i] := ord(iString[i+1]);
iStream.Write(lBuffer, lLength);
{$ELSE}
iStream.Write(iString[1], lLength);
{$ENDIF}
end;
//ToDo: find a save and FAST way to do this in .NET
end;
Stream_WriteStringWithLength(fStream,MessageName);
end;
从上看出，binMessage首先把接口名称和消息名称写出了流中。
__Message.Write('A', TypeInfo(Integer), A, []);
把参数A写入流中：
procedure TROMessage.Write(const aName: string; aTypeInfo: PTypeInfo;
const Ptr; Attributes: TParamAttributes);
begin
Serializer.Write(aName, aTypeInfo, Ptr);
end;
继续：
procedure TROSerializer.Write(const aName: string; aTypeInfo: PTypeInfo;
const Ref; ArrayElementId : integer = -1);
begin
case aTypeInfo^.Kind of
tkEnumeration : WriteEnumerated(aName, aTypeInfo, Ref);
tkInteger : WriteInteger(aName, GetTypeData(aTypeInfo)^.OrdType, Ref);
tkFloat : if (aTypeInfo=TypeInfo(TDateTime))
then WriteDateTime(aName, Ref)
else WriteFloat(aName, GetTypeData(aTypeInfo)^.FloatType, Ref);
tkWString : WriteWideString(aName, Ref);
tkLString,
tkString : WriteString(aName, Ref);
tkInt64 : WriteInt64(aName, Ref);
tkClass : WriteObject(aName, GetTypeData(aTypeInfo).ClassType, Ref, ArrayElementId);
else RaiseError(err_TypeNotSupported, [GetEnumName(TypeInfo(TTypeKind), Ord(aTypeInfo^.Kind))]);
end;
end;
整型数据：
procedure TROStreamSerializer.WriteInteger(const aName: string;
anOrdType: TOrdType; const Ref; ArrayElementId : integer = -1);
var sze : byte;
src : pointer;
begin
src := @Ref;
sze := 0;
case anOrdType of
otSByte,
otUByte : sze := SizeOf(byte);
otSWord,
otUWord : sze := SizeOf(word);
otSLong,
otULong : sze := SizeOf(integer);
end;
fStream.Write(src^, sze); //fStream由TROBINMessage初始化时创建的。
end;
继续：
__Message.Finalize;
procedure TROMessage.Finalize;
begin
//FreeAndNIL(fSerializer);
end;
继续回来业务方法中：
__Message.WriteToStream(__request);
注意：这里是对整个客户端的请求消息进行打包后的数据流。
__TransportChannel.Dispatch(__request, __response);
__Message.ReadFromStream(__response);
__Message.Read('Result', TypeInfo(Integer), result, []);
procedure TROBINMessage.WriteToStream(aStream: TStream);
begin
WriteStream(typMessage, fStream, aStream);
注意：aStream：是request数据流. fStream：TROStreamSerializer 处理参数后的数据流。
inherited;
end;
//这里要注意：
fStream 是内部的一个Tsteam包括了接口信息，消息信息，及参数数据。
而aStream是要得到的binMessage的整个数据流（包括头信息，客户ID等）
请仔细看下面的分析：这里说明一下，为什么要这样设计，其实道理比较简单。
Fstream仅仅写了了相当的调用信息，而__request流则附加了标志，头等信息，这样分离设计是有好处的。便于系统维护。灵活改变数据结构，而减少整个程序的代码修改。
真正的参数打包部分交给了TROStreamSerializer来处理。TROBINMessage.WriteStream则把头信息，ID等加入整个数据流中。
procedure TROBINMessage.WriteStream(aMessageType: TMessageType; Source, Destination : TStream);
var start : cardinal;
lHeader : TBINHeader;
begin
//创建一个头信息
lHeader := TBINHeader.Create();
constructor TBINHeader.Create;
begin
inherited Create();
fHeader[0] := Ord(BINSignature[0]);
fHeader[1] := Ord(BINSignature[1]);
fHeader[2] := Ord(BINSignature[2]);
fHeader[3] := Ord(BINSignature[3]);
fHeader[4] := Ord(BINSignature[4]);
end;
头首部标志为 ‘RO107’
try
lHeader.Compressed := UseCompression;
procedure TBINHeader.SetCompressed(const Value: boolean);
begin
if Value then
fHeader[OFFSET_MESSAGE_FLAGS] := fHeader[OFFSET_MESSAGE_FLAGS] or BINMESSAGE_FLAG_COMPRESSED
else
fHeader[OFFSET_MESSAGE_FLAGS] := fHeader[OFFSET_MESSAGE_FLAGS] and not BINMESSAGE_FLAG_COMPRESSED;
end;
OFFSET_MESSAGE_FLAGS值为5，
lHeader.MessageType := aMessageType;
procedure TBINHeader.SetMessageType(const Value: TMessageType);
begin
fHeader[OFFSET_MESSAGE_TYPE] := byte(Value);
end;
OFFSET_MESSAGE_FLAGS值为6，
lHeader.ClientID := GetClientID;
procedure TBINHeader.SetClientID(const Value: TGUID);
begin
Move(Value, fHeader[OFFSET_CLIENTID], SizeOf(TGUID));
end; OFFSET_CLIENTID=12
lHeader.WriteToStream(Destination);
//写入BinHeader头信息：
procedure TBINHeader.WriteToStream(iStream: TStream);
begin
iStream.Write(fHeader, SizeOf(fHeader));
end;
//写入__request的数据信息
Source.Position := 0;
if UseCompression then begin
start := GetTickCount;
CompressStream(Source, Destination);
附加的数据流(合并数据)，把头信息，和参数打包信息合并。
procedure CompressStream(anInputStream, aCompressedStream : TStream);
var zstream : TCompressionStream;
begin
try
zstream := TCompressionStream.Create(clMax, aCompressedStream);
zstream.CopyFrom(anInputStream, 0);
finally
FreeAndNIL(zstream);
end;
end;
继续：
procedure TROMessage.WriteToStream(aStream: TStream);
begin
if Assigned(fOnWriteToStream) then begin
aStream.Position := 0; // Just in case
fOnWriteToStream(aStream);
end;
aStream.Position := 0; // Just in case
end;
继续回到SUM方法中：
__TransportChannel.Dispatch(__request, __response);
__Message.ReadFromStream(__response);
继续：
procedure TROTransportChannel.Dispatch(aRequest, aResponse : TStream);
。。。。。。。。。
{$IFDEF REMOBJECTS_UseEncryption}
if Encryption.EncryptionMethod <> tetNone then begin
EncRequest:= TMemoryStream.Create;
EncResponse := TMemoryStream.Create;
try
DoEncryption(aRequest,EncRequest);
IntDispatch(encRequest, encResponse);
DoDecryption(EncResponse,aResponse);
finally
EncRequest.Free;
EncResponse.free;
end;
end
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
对数据流是否首先进行加密，解密。
procedure TROIndyTCPChannel.IntDispatch(aRequest, aResponse: TStream);
begin
try
if not IndyClient.Connected
then IndyClient.Connect;
IndyClient.WriteStream(aRequest, TRUE, TRUE);
IndyClient.ReadStream(aResponse);
finally
if not KeepAlive
then IndyClient.Disconnect;
end;
end;
这里三句，分别是连接服务器端，写入流操作（发送消息给中间层），读取中间层返回的结果。先看看网络通信相关代码。
procedure TIdTCPClient.Connect(const ATimeout: Integer = IdTimeoutDefault);
begin
…………………….
IOHandler := TIdIOHandlerSocket.Create(Self);
…………………..
IOHandler.Open;
procedure TIdIOHandlerSocket.Open;
begin
inherited Open;
if not Assigned(FBinding) then begin
FBinding := TIdSocketHandle.Create(nil);
end
else
FBinding.Reset(true);
end;
创建了一个TidSocketHandle类。前面已经介绍过这个类了。这里就不说了。
ResetConnection;
IOHandler.ConnectClient(Host, Port, BoundIP, BoundPort, BoundPortMin, BoundPortMax, ATimeout);
//-------------------------------------------------ConnectClient---------------------------------------------
procedure TIdIOHandlerSocket.ConnectClient(const AHost: string;
const APort: Integer; const ABoundIP: string; const ABoundPort,
ABoundPortMin, ABoundPortMax: Integer; const ATimeout: Integer = IdTimeoutDefault);
。。。。。。。。。。。。。。。。。。
with Binding do begin
AllocateSocket;
procedure TIdSocketHandle.AllocateSocket(const ASocketType: Integer = Id_SOCK_STREAM;
const AProtocol: Integer = Id_IPPROTO_IP);
。。。。。。
FHandle := GStack.CreateSocketHandle(ASocketType, AProtocol);
。。。。。。。。
end;
获取一个套接字：
function TIdStack.CreateSocketHandle(const ASocketType: Integer;
const AProtocol: Integer = Id_IPPROTO_IP): TIdStackSocketHandle;
begin
result := WSSocket(Id_PF_INET, ASocketType, AProtocol);
if result = Id_INVALID_SOCKET then begin
raise EIdInvalidSocket.Create(RSCannotAllocateSocket);
end;
IP := ABoundIP;
Port := ABoundPort;
ClientPortMin := ABoundPortMin;
ClientPortMax := ABoundPortMax;
Bind;
end;
if not GStack.IsIP(LHost) then begin
DoStatus(hsResolving, [LHost]);
end;
//设置IP及端口地址：
Binding.SetPeer(GStack.ResolveHost(LHost), LPort);
……………..
DoStatus(hsConnecting, [Binding.PeerIP]);
…………………………
GStack.CheckForSocketError(Binding.Connect);
//连接服务器
function TIdSocketHandle.Connect(const AFamily: Integer = Id_PF_INET): Integer;
begin
Result := GStack.WSConnect(Handle, AFamily, PeerIP, PeerPort);
UpdateBindingLocal; //更新IP地址，主机名等信息
UpdateBindingPeer; //更新端口号信息等
……………….
function TIdStackWindows.WSConnect(const ASocket: TIdStackSocketHandle;
const AFamily: Integer; const AIP: string;
const APort: Integer): Integer;
var
Addr: TSockAddrIn;
begin
Addr.sin_family := AFamily;
Addr.sin_addr := TInAddr(StringToTInAddr(AIP));
Addr.sin_port := HToNS(APort);
result := Connect(ASocket, @Addr, SizeOf(Addr));
end;
SocksInfo.MakeSocksConnection(AHost, APort);
//-------------------------------------------ConnectClien结束---------------------------------------------
继续回到
procedure TIdTCPClient.Connect(const ATimeout: Integer = IdTimeoutDefault);
………………..
if Assigned(Intercept) then begin
Intercept.Connect(Self);
end;
DoStatus(hsConnected, [Host]);
DoOnConnected;
except
DisconnectSocket;
raise;
end;
end;
退出该函数。
继续。
procedure TROIndyTCPChannel.IntDispatch(aRequest, aResponse: TStream);
begin
………………………………..
// aRequest为TROTransportChannel传进来的EncRequest:= TMemoryStream.Create;
IndyClient.WriteStream(aRequest, TRUE, TRUE);
IndyClient.ReadStream(aResponse);
//第一句是借助把流发送到服务端。（根据包长度拆分成多个小包）。
//第二句读服务器端流数据。
procedure TIdTCPConnection.WriteStream(AStream: TStream; const AAll: boolean = true;
const AWriteByteCount: Boolean = False; const ASize: Integer = 0);
var
if ASize = 0 then begin
LStreamEnd := AStream.Size;
end else begin
LStreamEnd := ASize + AStream.Position;
end;
LSize := LStreamEnd - AStream.Position;
if AWriteByteCount then begin
WriteInteger(LSize); //写入数据包长度。
end;
BeginWork(wmWrite, LSize); try
LBuffer := TMemoryStream.Create; try //生成临时发生流。
LBuffer.SetSize(FSendBufferSize);
while True do begin
LSize := Min(LStreamEnd - AStream.Position, FSendBufferSize);
if LSize = 0 then begin
Break;
end;
//分批读出数据包。
LSize := AStream.Read(LBuffer.Memory^, LSize);
if LSize = 0 then begin
raise EIdNoDataToRead.Create(RSIdNoDataToRead);
end;
WriteBuffer(LBuffer.Memory^, LSize);
end;
finally FreeAndNil(LBuffer); end;
finally EndWork(wmWrite); end;
end;
WriteBuffer(LBuffer.Memory^, LSize);
procedure TIdTCPConnection.WriteBuffer(const ABuffer; AByteCount: Integer;
const AWriteNow: boolean = false);
var
LBuffer: TIdSimpleBuffer;
nPos, nByteCount: Integer;
begin
//判断是否与服务器端连接，否则调用TIdTCPConnection.Connected
if connected then begin
if (FWriteBuffer = nil) or AWriteNow then begin
LBuffer := TIdSimpleBuffer.Create; try
LBuffer.WriteBuffer(ABuffer, AByteCount);
if Assigned(Intercept) then begin
LBuffer.Position := 0;
Intercept.Send(LBuffer); //发送数据
AByteCount := LBuffer.Size;
end;
nPos := 1;
repeat
nByteCount := IOHandler.Send(PChar(LBuffer.Memory)[nPos - 1], LBuffer.Size - nPos + 1);
function TIdIOHandlerSocket.Send(var ABuf; ALen: integer): integer;
begin
if Connected then
begin
Result := Binding.Send(ABuf, ALen, 0);
end
else begin
raise EIdClosedSocket.Create(RSStatusDisconnected);
end;
end;
function TIdSocketHandle.Send(var Buf; len, flags: Integer): Integer;
begin
result := GStack.WSSend(Handle, Buf, len, flags);
end;
…………………………….
nPos := nPos + nByteCount;
until nPos > AByteCount;
finally FreeAndNil(LBuffer); end;
end else begin
FWriteBuffer.WriteBuffer(ABuffer, AByteCount);
if (FWriteBuffer.Size >= FWriteBufferThreshhold) and (FWriteBufferThreshhold > 0) then begin
FlushWriteBuffer(FWriteBufferThreshhold);
end;
end;
end
else
begin
Raise EIdNotConnected.Create(RSNotConnected);
end;
end;
end;
继续：
读服务器端返回的数据：
procedure TIdTCPConnection.ReadStream(AStream: TStream; AByteCount: Integer = -1;
const AReadUntilDisconnect: Boolean = False);
。。。。。。。。。。。。。。。。。。。。。。。。。。。。
if (AByteCount = -1) and (AReadUntilDisconnect = False) then begin
AByteCount := ReadInteger; //读数据包长度
end;
function TIdTCPConnection.ReadInteger(const AConvert: boolean = true): Integer;
begin
ReadBuffer(Result, SizeOf(Result));
……
end;
继续：
procedure TIdTCPConnection.ReadBuffer(var ABuffer; const AByteCount: Integer);
…………………..
while (InputBuffer.Size < AByteCount) do begin
ReadFromStack;
function TIdTCPConnection.ReadFromStack(const ARaiseExceptionIfDisconnected: Boolean = True;
ATimeout: Integer = IdTimeoutDefault; const ARaiseExceptionOnTimeout: Boolean = True):
…………………………………….
if Connected then begin
LByteCount := 0;
repeat
if IOHandler.Readable(ATimeout) then begin
function TIdSocketHandle.Readable(AMSec: Integer = IdTimeoutDefault): boolean;
………………………………
try
ReadList.Add(Pointer(Handle));
Result := GStack.WSSelect(ReadList, nil, nil, AMSec) = 1;
TIdAntiFreezeBase.DoProcess(result = false);
finally ReadList.free; end;
end;
调用：
TIdStackWindows.WSSelect
function TIdStackWindows.WSSelect(ARead, AWrite, AErrors: TList; ATimeout: Integer):
………………………….
if ATimeout = IdTimeoutInfinite then begin
Result := Select(0, @FDRead, @FDWrite, @FDError, nil);
end else begin
tmTo.tv_sec := ATimeout div 1000;
tmTo.tv_usec := (ATimeout mod 1000) * 1000;
Result := Select(0, @FDRead, @FDWrite, @FDError, @tmTO);
end;
GetFDSet(ARead, FDRead);
GetFDSet(AWrite, FDWrite);
GetFDSet(AErrors, FDError);
end;
/-------------------------------------------服务器端---------------------------------------------------
此时，客户端处于阻塞状态，直到服务器端返回的数据包为止。
现在在看看服务器端如何响应的：
procedure TIdListenerThread.Run;
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
LThread := TIdPeerThread(Server.ThreadMgr.GetThread);
function TIdThreadMgrDefault.GetThread: TIdThread;
begin
Result := CreateNewThread;
ActiveThreads.Add(result);
end;
这里创建了一个线程TIdPeerThread，加入到线程池中。
LThread.FConnection := LPeer;
LThread.FConnection.IOHandler := LIOHandler;
LThread.FConnection.FFreeIOHandlerOnDisconnect := true;
end;
if (Server.MaxConnections > 0) and // Check MaxConnections
……………………….
Server.Threads.Add(LThread); //APR
LThread.Start; //启动新的线程TidPeerThread，TidListenerThread线程继续listen.
…………………….
End;
下面看看新创建的线程TidPeerThreadj是怎么工作的。
procedure TIdPeerThread.Run;
begin
try
try
if not Connection.Server.DoExecute(Self) then begin
except
。。。。。。。。。。。。。。。。。。。。。。。。
end;
function TIdTCPServer.DoExecute(AThread: TIdPeerThread): boolean;
。。。。。。。。。。。。。。。
if Result then begin
OnExecute(AThread);
end;
end;
end;
继续：
procedure TROIndyTCPServer.InternalOnExecute(AThread: TIdPeerThread);
var req, resp : TStringStream;
tcptransport : IROTCPTransport;
begin
req := TStringStream.Create('');
resp := TStringStream.Create('');
tcptransport := TIndyTCPConnectionTransport.Create(aThread);
try
with AThread do begin
Connection.ReadStream(req);
DispatchMessage(tcptransport, req, resp);
Connection.WriteStream(resp, TRUE, TRUE);
if not KeepAlive
then Connection.Disconnect;
end;
finally
req.Free;
resp.Free;
end;
end;
继续：
procedure TIdTCPConnection.ReadStream(AStream: TStream; AByteCount: Integer = -1;
const AReadUntilDisconnect: Boolean = False);
。。。。。。。。。。。。。。。。。。。。。。。。。。。。
if (AByteCount = -1) and (AReadUntilDisconnect = False) then begin
AByteCount := ReadInteger; //读数据包长度
end;
function TIdTCPConnection.ReadInteger(const AConvert: boolean = true): Integer;
begin
ReadBuffer(Result, SizeOf(Result));
……
end;
继续：
procedure TIdTCPConnection.ReadBuffer(var ABuffer; const AByteCount: Integer);
…………………..
while (InputBuffer.Size < AByteCount) do begin
ReadFromStack;
function TIdTCPConnection.ReadFromStack(const ARaiseExceptionIfDisconnected: Boolean = True;
ATimeout: Integer = IdTimeoutDefault; const ARaiseExceptionOnTimeout: Boolean = True):
…………………………………….
if Connected then begin
LByteCount := 0;
repeat
if IOHandler.Readable(ATimeout) then begin
function TIdSocketHandle.Readable(AMSec: Integer = IdTimeoutDefault): boolean;
………………………………
try
ReadList.Add(Pointer(Handle));
Result := GStack.WSSelect(ReadList, nil, nil, AMSec) = 1;
TIdAntiFreezeBase.DoProcess(result = false);
finally ReadList.free; end;
end;
调用：
TIdStackWindows.WSSelect
function TIdStackWindows.WSSelect(ARead, AWrite, AErrors: TList; ATimeout: Integer):
………………………….
if ATimeout = IdTimeoutInfinite then begin
Result := Select(0, @FDRead, @FDWrite, @FDError, nil);
end else begin
tmTo.tv_sec := ATimeout div 1000;
tmTo.tv_usec := (ATimeout mod 1000) * 1000;
Result := Select(0, @FDRead, @FDWrite, @FDError, @tmTO);
end;
GetFDSet(ARead, FDRead);
GetFDSet(AWrite, FDWrite);
GetFDSet(AErrors, FDError);
end;
继续回到：function TIdTCPConnection.ReadFromStack
LByteCount := IOHandler.Recv(FRecvBuffer.Memory^, FRecvBuffer.Size);
function TIdIOHandlerSocket.Recv(var ABuf; ALen: integer): integer;
begin
if Connected then
begin
Result := Binding.Recv(ABuf, ALen, 0);
end
else begin
raise EIdClosedSocket.Create(RSStatusDisconnected);
end;
end; 接收数据。
。。。。。。。。
if LByteCount > 0 then begin
FRecvBuffer.Size := LByteCount;
if Assigned(Intercept) then begin
FRecvBuffer.Position := 0;
Intercept.Receive(FRecvBuffer);
LByteCount := FRecvBuffer.Size;
end;
if ASCIIFilter then begin
for i := 1 to FRecvBuffer.Size do begin
PChar(FRecvBuffer.Memory)[i] := Chr(Ord(PChar(FRecvBuffer.Memory)[i]) and $7F);
end;
end;
FInputBuffer.Seek(0, soFromEnd);
FInputBuffer.WriteBuffer(FRecvBuffer.Memory^, FRecvBuffer.Size);
end;
继续TIdTCPConnection.ReadStream：
。。。。。。。。。。。。。。。。。。。。。。。。。
if InputBuffer.Size > 0 then begin
i := Min(InputBuffer.Size, LWorkCount);
InputBuffer.Position := 0;
AStream.CopyFrom(InputBuffer, i); //拷贝数据
InputBuffer.Remove(i);
Dec(LWorkCount, i);
end;
继续：
procedure TROIndyTCPServer.InternalOnExecute(AThread: TIdPeerThread);
。。。。。。。。。。。。。。。
DispatchMessage(tcptransport, req, resp);
Connection.WriteStream(resp, TRUE, TRUE);
我们看到rep中的数据为：'RO107'#1#0#0#0#0#0#0'(繩腦w\E?O喿'#$17'檩x阢f``pN蘄'#$E'N-*薒Ne'#6'r僈s晙'#$14'?'#0'gO'#5#$AD
下面看一个消息分发的机制：
function TROServer.DispatchMessage(const aTransport: IROTransport; aRequeststream, aResponsestream: TStream) : boolean;
var dispatcher : TROMessageDispatcher;
excstr : string;
{$ifdef REMOBJECTS_UseEncryption}
DEncRequest,DUnEncResponse : TMemoryStream;
{$endif}
begin
result := FALSE;
try
{aRequeststream.Position := 0;
if Assigned(OnReadFromStream) then OnReadFromStream(aRequeststream);
aRequeststream.Position := 0;}
dispatcher := Dispatchers.FindDispatcher(aTransport, aRequeststream);
if (dispatcher=NIL) then RaiseError(err_CannotFindMessageDispatcher, []); // Should never happen! If this happens there's no way to format the exception correctly
{$IFDEF REMOBJECTS_UseEncryption}
if Encryption.EncryptionMethod <> tetNone then begin
dEncRequest := TMemoryStream.Create;
dUnEncResponse := TMemoryStream.Create;
try
DoDecryption(aRequeststream,dEncRequest);
TriggerReadFromStream(dEncRequest);
result := dispatcher.ProcessMessage(aTransport, dEncRequest, dUnEncResponse); // This traps exception and cannot fail
TriggerWriteToStream(dUnEncResponse);
DoEncryption(dUnEncResponse,aResponsestream);
finally
dEncRequest.Free;
dUnEncResponse.free;
end;
end
else
{$ENDIF}
begin
TriggerReadFromStream(aRequeststream);
result := dispatcher.ProcessMessage(aTransport, aRequeststream, aResponsestream); // This traps exception and cannot fail
TriggerWriteToStream(aResponsestream);
end;
except
on E:Exception do begin
if (E.Message<>'') then excstr := E.Message
else excstr := err_UnhandledException;
{$IFDEF DOTNET}
aResponseStream.CopyFrom(TStringStream.Create(excstr), Length(excstr));
{$ELSE}
aResponseStream.Write(excstr[1], Length(excstr));
{$ENDIF DOTNET}
TriggerWriteToStream(aResponsestream);
end;
end;
{aResponsestream.Position := 0;
if Assigned(OnWriteToStream) then OnWriteToStream(aResponsestream);
aResponsestream.Position := 0;}
end;
function TIdSocketHandle.Select(ASocket: TIdStackSocketHandle;
ATimeOut: Integer): boolean;
var
ReadList: TList;
begin
ReadList := TList.Create; try
ReadList.Add(Pointer(ASocket));
Result := GStack.WSSelect(ReadList, nil, nil, ATimeOut) = 1;
TIdAntiFreezeBase.DoProcess(result = false);
finally ReadList.free; end;
end;
function TROBINMessage.CreateSerializer : TROSerializer;
begin
result := TROStreamSerializer.Create(NIL);
end;
继续：
constructor TROStreamSerializer.Create(aStorageRef: TStream);
begin
inherited Create();
SetStorageRef(aStorageRef);
end;
我们发现TROStreamSerializer这个类很有趣。继续看看。
扫一扫
7434
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
