RealThinClient SDK是用于开发标准的HTTP(S)服务器，ISAPI扩展以及客户端的VCL控件。可用于Windows下的CodeGear Delphi 6-2010。
VCL for writing stable HTTP(S) Servers, ISAPI extensions and Clients with CodeGear Delphi 6-2010 for Windows.
帮助您创建可靠和可扩展的跨平台应用程序
RealThinClient SDK是一个灵活和模块化框架，可以使用Delphi构建可靠和可扩展的跨平台应用程序，通过利用具有完整IPv4和IPv6支持的HTTP/S和内置的多线程，为Web设计了压力测试，以确保最高稳定性。通过使用内置线程池的非阻塞事件驱动通信，使用RealThinClient SDK构建的应用程序可以在所有支持的平台上通过在真正的多线程环境中使用有限数量的线程来处理数千个活动连接。
编写可通过防火墙的客户端、服务器和ISAPI扩展（Apache和MS IIS兼容）
编写可靠的HTTP(S)服务器\路由器\代理服务器\反向代理服务器和负载平衡器
使用第三方加密组件作为RealThinClient SDK的插件（例如：StreamSec Tools 2.x = 99€）添加强大的SSL/TLS加密，或者在Windows上运行RTC客户端的内置SSL支持，并将RTC服务器代码转换为ISAPI DLL以在具有SSL支持的第三方Web服务器上运行（例如MS IIS，Apache或Abyss）
使用RTC Web服务器(包含Delphi源码)进行ISAPI扩展的调试
基于组件和模块化设计，您可以在现有的Delphi应用程序中添加新的远程处理功能，并重新使用现有的代码
只需通过设置属性（内置的线程池）就可以使你的客户端、服务器采用多线程处理
只需通过设置属性启用自动压缩和内置加密
通过使用RTC脚本引擎增强您的“静态”HTML页面，在本地Delphi代码和可视化HTML演示文稿之间建立桥梁
一个服务器端代码可以编译成独立服务器和ISAPI扩展
灵活且强大的RTC远程功能，支持创建和维护链接对象，以及完全可自定义的基于模板的远程功能向导。
集成完整的JSON和XML-RPC支持：在Delphi中编写函数，并通过XML-RPC和/或JSON格式（JSON + REST，JSON-RPC 1.0和2.0）使第三方可以远程访问它们。轻松调用第三方以XML-RPC和/或JSON格式发布的远程功能。
具有完整源代码的组件和演示项目，可以使用Delphi构建跨平台应用程序。
RealThinClient SDK特征说明
多部署: 单一的代码库针对Windows、Mac OSX、iOS和Android
在Delphi中编写一个项目，并将其编译为(a)用于Windows、Mac OSX、iOS或Android的强大的独立客户端或服务器，或...(b)用于MS IIS或Apache的ISAPI DLL扩展或...(c )将你的应用程序整合到第三方的基于消息的服务器，比如NexusDB服务器。
RAD: 编写事件,无用户界面
使用RTC开发的一切都是基于组件的，因此你需要编写的所有代码都以事件的形式定义的，也就是说你只需要在相应的事件下编写代码即可，因此你可以不需要向导或编写用户界面就可以设计自己的服务器和客户端应用程序。
轻松的多线程: 简单的打开/关闭切换
所有的RTC连接组件都嵌入了一种非常成熟的多线程机制。你只需要简单的设置MultiThreaded属性为True就可以让成千上万的活动连接同时运行在独立的线程中，这时任何新接收到的连接都会由一个线程池进行处理。这种机制可以节约宝贵的系统资源。
HTTP(S): 无需担心防火墙
RTC客户端可以不用进行任何配置就可以通过防火墙到达网络。通过设置UseProxy属性为True，数据客户端就可以使用一个同样设置的连接供应站与网络进行数据传输，就像IE浏览Web一样。这就意味着客户可以在任何局域网内都可以访问网络。
非阻塞
不同于其他大部分的网络组件，RTC连接组件是非阻塞型和事件驱动型的。这就意味着即使不使用多线程模式，客户端与服务器端通信时都不会被阻塞(出现”应用程序没有响应”的情况).在整个连接中，每一个状态的改变都会触发一个相应的事件。
远程函数: 可重用,简单编写,简单调用
就像使用本地函数一样执行和使用远程函数。你只需要放置一个RtcFunction组件在你的Form或DataModule中，然后设置函数名称和在OnExecute事件中编写自己的代码即可。OnExecute事件将接收连接对象、函数参数和一个结果对象，你只需要使将参数传递到事先写好的函数中，剩下的就留给控件处理。
强大的加密功能&自动压缩功能
RTC组件提供内置和易于使用的强加密以及使用远程功能时的自动数据压缩功能。启用或禁用远程功能的强加密或压缩是完全透明的。你只需在RtcClientModule和RtcServerModule中简单的设置Encryption 和 Compression属性，剩下的就留给控件处理。
插件框架: 编写自己的插件或使用第三方插件
所有使用RTC SDK编写的客户端、服务器端的代码都将以功能模块和插件的形式与同样使用RTC SDK编写的应用程序整合。比如，你可以整合Web服务器、消息服务器、应用服务器、数据库服务器、自己编写的功能函数到一个数据服务器中，即使这些组件并没有被特意设计成共享同一个服务空间。
基于简单易用的插件框架，你可以将任意多个的功能性组件和数据性组件整合到一起。比如将RtcDataProvider, RtcServerModule 和RtcDataServerLink整合到一个数据服务连接组件中，使服务器的功能得以扩展。同时由于保持代码在不同的单元(Data Modules),你甚至可以向其他同样使用RTC SDK开发的人提供自己的插件(当然也可以出售插件)。
小体积
当使用D7压缩后，一个完整的使用RTC SDK开发的Web服务器占用的空间不到600KB。虽然它如此小，但它的功能丰富，稳定性高，可扩展性好。
RealThinClient SDK :服务器端组件
RtcHttpServer
实现TCP/IP上的HTTP协议，用于将RTC组件编译到独立的服务器应用程序中(继承TRtcDataServer). 所有高层的服务器端的RTC组件都使用TRtcDataServer 子类与HTTP客户端(RTC客户端、Web浏览器、SOAP客户端等)通信.最好的方法是将你使用高层RTC组件编写的代码分开到不同的数据模块中，然后使用单独的一个DataModule将RtcHttpSever编译到一个独立的应用程序(EXE)中。
RtcISAPIServer
实现ISAPI接口，扩展ISAPI兼容的Web服务器(继承TRtcDataServer)。
所有高层的服务器端的RTC组件都使用TRtcDataServer 子类与HTTP客户端(RTC客户端、Web浏览器、SOAP客户端等)通信。最好的方法是将你使用高层RTC组件编写的代码分开到不同的数据模块中，然后使用单独的一个DataModule将RtcISAPISever编译到ISAPI扩展(DLL)中。
RtcMessageServer
实现可扩展的基于消息的服务器端的组件，可用于通过第三方的消息层访问RTC应用程序。RTC SDK包含一个随时可使用的NexusDB插件，该插件使用RtcMessageServer组件将RTC应用程序整合到NexusDB服务器。
RtcDataServerLink
在你有一些数据提供组件或服务模块组件交叉的单元时是非常有用的，因为它可以群集相关的数据提供组件以及将它们链接到它们的数据服务器。如果你只有一个或少数几个数据提供组件，你可以直接将链接它们到数据服务器连接组件，而无需RtcDataServerLink。
RtcDualDataServerLink
连接一组RTC组件到2个或更多的服务器连接组件(RtcHttpServer 和 RtcMessageServer)。这可以让你只需编写你的应用程序一次，然后可以通过标准的HTTP协议或通过安全的HTTPS协议（如果需要也可以通过不同的基于消息的传输比如NexusDB传输层）获取。
RtcDataProvider
用于实现处理HTTP请求和响应的事件。每一个Data Provider只响应对应自己的请求而不会处理其他的请求。Data Providers以插件的形式在服务器上工作，这使得Data Providers可以单独或则与其他RTC组件结合来开发多功能的服务器。
下面是一些可能用到的Data Providers列表:
File provider 用于传送文件
PHP provider 用于处理php脚本和发送html页面
SOAP provider 用于实现不同的Web服务器
Page providers 用于生成动态的 HTML 页面
Image providers 用于为Web动态生成图片
RtcServerModule
执行一组远程函数。它可以让服务器为自己的远程函数提供远程访问的能力。RtcServerModule没有事件可执行，你只需要在一边将RtcServerModule和它的服务器连接起来，同时配合另一边的RtcFunctionGroup就可以激活远程函数。
RtcFunctionGroup
提供访问函数的功能。当配合RtcServerModule使用时，它会自动为所有的RTC客户端激活远程访问的功能。当配合RtcClientModule使用时，服务器可以以客户端函数调用的返回结果的形式调用客户端的函数。为了实现远程函数，你至少需要一个RtcFunctionGroup组件以及连接一个或多个RtcFunction组件，Function Groups也可以让你调用同一组的其他函数。 RtcFunctionGroup首先是由RtcServerModule 和 RtcClientModule为了实现远程函数而使用的，但是其他的组件也可以直接使用它。
RtcFunction
为你的RTC服务器添加新的远程函数的步骤是:
将一个RtcFunction连接到一个RtcFunctionGroup，
务必让Function Group指派一个RtcServerModule，
选择一个"FunctionName"，然后在OnExecute事件中编写自己的代码。
当编写远程函数时，你除了自己的代码外无需再考虑其他的事情。一旦出现异常(你可以在OnExecute事件里抛出异常),客户端会得到异常信息(Result.isType=rtc_Exception),所以你不需要担心。
RtcScriptEngine
可以在HTML和XML文件里使用像Pascal一样的脚本语言。
当使用RTC脚本引擎时，你就可以决定你的Delphi函数、编译服务器或ISAPI扩展应该有多少应用程序代码以及在你的HTML/XML文件中应该有多少脚本。这使得你可以将PHP和JSP这样的语言和Delphi整合。
RealThinClient SDK : 客户端组件
RtcHttpClient
它负责使用HTTP/HTTPS协议和你的服务器直接通信。
它发送由高层客户端RTC组件比如RtcDataRequest 和 RtcClientModule发起的请求，然后接收响应并同样使用高层组件处理这些响应。
RtcMessageClient
它是一个可以将你的高层客户端组件(比如DataRequest 和 ClientModule)整合到第三方传输层的组件。比如，你可以在你的NexusDB服务器中使用NexusDB插件调用RTC远程函数。
RtcDataClientLink
在你有大量的Data Request或Client Module交叉单元时它是非常有用的。因为它可以群集相关的客户端请求组件以及与它们的数据客户端连接相整合。如果你只有一两个数据请求组件，你可以直接与数据客户端连接组件整合，而不需要RtcDataClientLink。
RtcDualDataClientLink
用于创建小型的客户端连接池，当提交一个请求时，组件可以根据当前可用连接中挂起的请求的数量决定使用哪个连接。一个新的请求将由挂起/活动请求最少的连接提交，除非你明确的指出了不同的连接对象。
RtcDataRequest
与RtcDataProvider相对应的客户端组件。它可以让客户端向RTC服务器或其他的HTTP服务器提交请求。使用该组件，你可以向一个Web服务器请求一个文件，提交一个SOAP请求，执行一个服务器端的PHP脚本等等。你可以使用该组件请求HTTP服务器提供的所有服务。
RtcClientModule
与RtcServerModule相对应的客户端组件。它可以让客户端调用由服务器的一个服务模块提供的函数。RtcClientModule没有事件可以实现，你只需要整合一个客户端连接组件(RtcHttpClient)就可以调用远程函数。如果你定义了客户端函数然后整合到RtcClientModule中，那就可以执行这些客户端远程函数。没有特别需要实现的部分。服务器是以客户端对服务器端调用的返回结果的形式调用客户端远程函数的。
RtcResult
处理远程函数调用返回的结果。使用OnResult事件(OnResult事件接收连接(Sender:TRtcConnection)，传递的参数(Param：TRtcValue)以及接收到的结果(Result:TRtcValue))，你可以轻松的编写处理返回结果的代码。
RealThinClient SDK 各版本的IDE和平台支持情况:
IDE / 平台 | | | | iOS
32-bit | iOS
64-bit | Android |
Delphi 7–XE | YES |
|
|
|
|
|
Delphi XE2 | YES | YES | YES | YES |
|
|
Delphi XE3 | YES | YES | YES |
|
|
|
Delphi XE4 | YES | YES | YES | YES |
|
|
Delphi XE5–XE7 | YES | YES | YES | YES |
| YES |
Delphi XE8–XE10.2 | YES | YES | YES | YES | YES | YES |
VCL for writing stable HTTP(S) Servers, ISAPI extensions and Clients with CodeGear Delphi 6-2010 for Windows.
-
Write Firewall-friendly Clients, Servers and ISAPI Extensions (Apache 2.x and MS IIS 5.x compatible)
-
One code compiles as Stand-alone Server and/or ISAPI Extension for MS IIS, Apache, etc.
-
Debug ISAPI extensions using the RTC WebServer (full source code in Delphi included)
-
Make your Client and/or Server Multi-Threaded,simply by setting a property (built-in thread-pooling)
-
Enable Auto-Compression and strong Encryption
- Built-in Compression enabled by setting a property
- Built-in Encryption enabled by setting a property
- Advanced SSL using third-party components
-
Empower your "static" HTML pages and use the RTC Scripting Engine to create a bridge between your Delphi code and your visual HTML presentation
-
Component-based and Modular Design allows you to add new Remote Client/Server functionality into your existing Delphi applications and re-use existing code
-
Write and call flexible Remote Functions empowered by the compact RTC format or the standard XML-RPC format(simply pick your format by setting a property)
-
Use the Remote Functions Wizard to easily write client-side classes for calling server-side functions.
-
Delphi components with full source code ready for:
- Borland/CodeGear Delphi 6 - 2007 for Windows
- CodeGear Delphi / RAD Studio 2009 for Windows
- Lazarus for Windows
- Lazarus for Linux and MacOSX (beta)
|
RealThinClient SDK : Short Description of included Features
|
Multi-Deployment:
ISAPI Extensions,
Stand-alone Servers,
Third-party Servers
|
Write one server app and compile it as (a) robust Stand-alone Server, capable of serving unlimited number of clients, or as (b) ISAPI DLL extension which can be deployed to any ISAPI-capable Web Server (for example: MS IIS or Apache), or (c) integrate your application into third-party Message-based Servers like the NexusDB Server.
|
RAD:
Write events,
not interfaces
|
Everything you do with RTC is component-based, while all the code you will ever need to write is defined as events, so you can design your server and client applications, without the need to use wizards or write interfaces.
|
Easy MultiThreading:
turn on/off with
a simple switch
|
A very sophisticated Threading mechanism is built into all RTC Connection components, which allows thousands of active connections to be running in separate threads, all at the same time. And the only thing you need to do is change a simple MultiThreaded property to True. Then, any newly received connection will be handled by a thread pooling mechanism which saves valuable System resources, while still enabling nearly unlimited number of simultaneous connections at the same time.
|
HTTP protocol:
No Firewall problems
|
RTC Clients will never have to be specially configured to get through corporate firewall's and reach the internet. Simply by setting the UseProxy property to True, Data Client connection will use a connection provider which uses the same settings to read and send its data to the internet, as MS Internet Explorer does for browsing the Web. This means that Clients can work in any corporate LAN and have full access to the internet.
|
|
Non-Blocking
|
Other than most other internet components, RTC connection components are non-blocking and event-driven. This means that, even when not using a multithreaded mode, your users will not be blocked ("Application Not Responding") during communication between your client and the server. For each state change in the connection, there is an event that will be triggered.
|
Remote Functions:
reusable,
easy to write,
easy to call
|
Implementing and using remote functions is as easy as writing local functions. You just place a RtcFunction component on your Form or a DataModule, set function name and write your OnExecute event. OnExecute event receives the Connection object, Function Parameters and a Result object. You just have to use the parameters passed to the function to prepare the result. The rest is done "under the hood" by RealThinClient components.
|
Strong encryption &
automatic compression
|
RTC components offer built-in, easy-to-use strong encryption with Encryption Keys of variable length and automatic data compression. You don't even have to think about encryption keys or data compression, everything will be generated and maintained for you. Using strong encryption and compression with remote functions is completely transparent, you will never have to worry about encryption or compression again. Simply set Encryption and Compression parameters in RtcClientModule and RtcServerModule, the rest is up to RTC.
|
Plug-In Framework:
write your own plug-ins
or use 3rd-party plug-ins
|
All Client and Server code you write using RTC SDK is ready to be used as building blocks or plug-ins in any application that uses RTC SDK. For example, you can combine a Web Server, Messenger server, Application server, Database server and your own functions in one Data Server, even when those components weren't specially designed to share the same Server space. Because of the easy-to-use plug-in framework on top of which all RTC Components are built, you can link unlimited number of functionality and data providing components like RtcDataProvider, RtcServerModule and/or RtcDataServerLink to one Data Server connection component, enhancing that server's functionality with each new component. And by keeping code in separate units (Data Modules), you can even provide your own plug-ins (and sell those plug-ins) to anyone who uses the RTC SDK Library.
|
|
Small footprint
|
A complete Web Server implementation, using RTC SDK, is less than 600 KBytes when compiled with D7. Even though it is so small, it offers enough functionality with great stability and scalability.
|
|
Build rock-solid Internet-ready applications
|
All RTC components are stress-tested for the highest stability. Check Test Results for more info.
By using non-blocking event-driven communication with a built-in thread-pooling mechanism, RealThinClient SDK can handle thousands of active connections by using a limited number of threads in a real multi-threaded environment (for example, 100 threads will be more than enough to handle several thousand active connections). Combined with reduced need for all important resources (CPU, Memory, Threads, Timers, Handles, etc), automatic handling of all communication-related objects, flexible remote functions (accept any structure for parameters and return any other structure as a result), automatic session handling (integrated time-out with variable life time) and a lot more, makes writing stable and performant Servers and Clients very easy with RealThinClient components.
|
|
What is inside the RealThinClient SDK package?
|
|
RealThinClient SDK : Server-side components
|
|
RtcHttpServer: implements the HTTP protocol over TCP/IP and is used to compile RTC components into a stand-alone server application (extends TRtcDataServer). All high-level server-side RTC components use TRtcDataServer descendants to communicate with HTTP Clients (RTC Clients, Web Browsers, SOAP Clients, etc). Best practice is to write all your code using high-level server-side RTC components separated on different data modules, then use one extra DataModule where you will use one RtcHttpSever to compile the functionality into a stand-alone server application (EXE).
|
|
RtcISAPIServer: implements the ISAPI interface and is used for for writing extensions for ISAPI-compatible web servers (extends TRtcDataServer). All high-level server-side RTC components use TRtcDataServer descendants to communicate with HTTP Clients (RTC Clients, Web Browsers, SOAP Clients, etc). Best practice is to write all your code using high-level server-side RTC components separated on different data modules, then use one extra DataModule where you will use one RtcISAPISever to compile the functionality into one ISAPI extension (DLL).
|
|
RtcMessageServer: implements an extensible Message-based Server-side component, which can be used to access RTC applications through third-party communication layers. RTC SDK includes a ready-to-use NexusDB plugin, which uses the RtcMessageServer component to integrate RTC applications into a NexusDB Server.
|
|
RtcDataServerLink: very useful when you have a number of Data Provider or Server Module components spread across units, because it groups related Data Provider components and links them to their Data Server connection. If you only have one or any small number of Data Provider components, you can link them directly to Data Server connection component, without the need of a RtcDataServerLink.
|
|
RtcDualDataServerLink: Link a group of RTC components to 2 or more Server connection components (RtcHttpServer and RtcMessageServer). This allows you, for example, to write your application code once, but make it accessible through the standard HTTP protocol, through a secure HTTPS protocol and (if required) through different message-based transports like the NexusDB transport layer.
|
RtcDataProvider: used to implement events which will handle HTTP requests and prepare responses (for example, client requests a file, which has to be read from a local drive and written out as a response). Each Data Provider only responds to his requests, ignoring the rest. This makes Data Providers work as plug-ins for the Server, which can be used alone or in combination with other RTC components to create a powerful and multifunctional Server.
Here is a short list of possible Data Providers:
-
File provider to send files
-
PHP provider to process php scripts and send HTML pages out
-
SOAP provider to implement different Web Services
-
Page providers to generate dynamic HTML pages
-
Image providers to dynamically generate images for the Web
-
anything else, there is no limit
|
|
RtcServerModule: execution point for a group of Remote Functions. It enables the Server to provide remote access to its remote functions. RtcServerModule has no events which would have to be implemented, you just link a RtcServerModule with its Server on one side and a RtcFunctionGroup on the other side to enable remote functions.
|
RtcFunctionGroup: provides access to a group of functions. When used by a RtcServerModule, it automatically enables access to remote functions for all RTC Clients. When used by a RtcClientModule, it gives server the ability to call client-side functions as a result of client's function calls.
To implement remote functions, you will need at least one RtcFunctionGroup component and link one or more RtcFunction components to it. Function Groups also enable you to call other functions from the same group to fill parameters for other function calls. RtcFunctionGroup is primarily used by the RtcServerModule and RtcClientModule components to hold implementations for their remote functions, but it can also be used directly by any other component.
|
RtcFunction: link one RtcFunction to a RtcFunctionGroup, check that the Function Group is assigned to a RtcServerModule, then choose a "FunctionName" and write your function code in the OnExecute event. That's all you have to do to add a new remote function to your RTC Server.
When writing a remote function, you don't have to think about anything but your function code. In case of an exception (which you can also raise inside your OnExecute event handler), client will get the exception message as a result (Result.isType=rtc_Exception), so you don't even have to worry about that.
|
|
RtcScriptEngine: makes it possible to use a Pascal-like scripting language from within HTML and/or XML files. When using the RTC Scripting Engine, you can decide for yourself how much of your application code you want to have in form of Delphi functions, compiled inside your Server or ISAPI extension, and how much you want to have in form of scripts inside your HTML/XML files. This allows you to combine the power of Delphi with the flexibility of scripting languages like PHP and JSP.
|
|
RealThinClient SDK : Client-side components
|
|
RtcHttpClient: this is the component that will be responsible for direct communication with your servers when using the HTTP or HTTPS protocol. It sends requests prepared by higher-level client-side RTC components like RtcDataRequest and RtcClientModule, then accepts responses and uses the same higher-level components to process those responses.
|
|
RtcMessageClient: this is the component which you can use to integrate your higher-level Client-side components (like DataRequest and ClientModule) into third-party transport layers. For example, by using the included NexusDB plugin, you can call RTC remote functions integrated in your NexusDB Server.
|
|
RtcDataClientLink: very useful when you have a number of Data Request or Client Module components spread across units, because it groups related client request components and links them to their Data Client connection. If you only have one or two data request components, you can link them directly to Data Client connection component, without the need of a RtcDataClientLink.
|
|
RtcDualDataClientLink: use to create a small pool of client connections, allowing the component to decide which connection to use when posting a request, depending on the number of currently pending requests on available connections. A new request will be posted through the connection with the lowest number of pending/active requests, unless you explicitly specify a different connection object.
|
|
RtcDataRequest: client-side counterpart to RtcDataProvider. It enables the client to post requests to a RTC Server or any other HTTP Server. Using this component, you can request files from a Web Server, post a SOAP request to a Web Service, execute a server-side PHP script, etc. Everything any HTTP Server is providing, you can request it using this component.
|
RtcClientModule: client-side counterpart to RtcServerModule. It enables the client to call functions provided by the Server through one of its Server Modules. RtcClientModule has no events which would have to be implemented, you just link a RtcClientModule to a Client connection component (RtcHttpClient) and you can call remote functions.
If you define client-side functions and link them to this RtcClientModule, this will be the execution point of those client-side remote functions. No special implementation needed. Client-side remote functions are functions which server can call on the client-side as a result of client's calls to a server-side function.
|
|
RtcResult: process results received from remote function call(s). Using the "OnResult" event, which receives the connection (Sender:TRtcConnection), parameters sent (Param:TRtcValue) and the result received (Result:TRtcValue), you can easily write the code to process the result. Maybe only do a simple check if function executed successfully, or show a message dialog, or create a separate form containing all data received, or fill received content into other component on the same form or datamodule (for example, fill ClientDataSet with records from a database).
|
彩票走势图 
相关产品
授权相关问题
微信
在线咨询
渝公网安备
50010702500608号
客服热线