用于结构化软件对象的重复串行化过程的制作方法

专利名称：用于结构化软件对象的重复串行化过程的制作方法
技术领域：
本发明涉及一种重复(iterative)程序，用于结构化软件对象到原始数据流的转换以及反向转换，并利用简单的通信设备如嵌入式计算机基站提供它们的直接传输，本发明还涉及所述软件对象的复位或是分配给它们的存储器空间的再利用。
背景技术：
在以高级语言编写、特别是以结构化或面向对象的语言如Java编写的应用程序中，所使用或处理的大部分数据都是以软件对象的形式组织及存储的，这些对象具有精确的结构，且比简单的字节序列复杂。这些对象中可能包含多个变量或是数据组，例如在简单类型的形式中，有字符(“char”类型)，或是整数(“int”类型)，或是基本对象类型，或是由程序员定义的类型，字符串(“string”类型)，或是含有一维或多维上述类型的数组(“array”类型)。因此，该类型的结构化对象可由一个聚集了各种不同对象的树状结构定义或表示，所述的对象本身又是各种类型的，这类结构的组织形式有时被称为对象复合图。一个对象类型可以根据另一个类型(通常被称为“超类”)的定义“继承”地定义，并且所有的类型都可以以一种树状结构来表示，该结构被称为继承图。
根据特定的情况，能够在硬件或软件环境中传输、创建或删除由计算机应用程序处理的软件对象可能是非常有用的，这些功能在上述的环境中往往是不可能或不切实际的。
举例来说，许多计算机应用程序中都包含了通信过程，通信的一方是一台计算机终端，也可能是一个计算机网络，另一方则是一个便携对象或具有数据处理能力的嵌入式平台，如银行、电话用户或健康保健管理智能卡，也可能是计算机化的识别、标记或收费设备。
这些便携对象中特别包括了一个处理器，该处理器与存有至少一个应用程序的存储设备相连，还与用来和一个或多个多个终端通信的设备相连。这些通信设备是基于例如使用不同类型技术进行的电子数据传输的，比如电连接、无线电天线、光信号或其他形式的传输，在同一个便携对象中可以组合多种不同类型的传输。由于尺寸或是某些历史原因，通常使用的通信设备往往工作在简单的协议下，比如用于智能卡的标准ISO 7816中的APDU协议。在这些协议中，有些协议只能提供简单类型对象的传输(以整数或简单字符的形式)，如只根据对象的响应发送或接收的控制参数，或是只由终端主动发出，或是两种情况兼有。以ISO 7816标准为例，APDU协议只允许传输不含有原始数据形式的类型的对象，如发送给计算机化的便携对象或是根据对象的响应获得的字节，以及只由终端主动发出的字节，作为控制参数。
在它们发展的现阶段，这些便携数据处理对象中的一些，如JavaCard，已经加入了内部函数，使得它们可以直接在高级或面向对象的语言-如Java中充分利用已编程的应用程序元素，并被集成到集中式或分布式的应用中，这些应用可在拓展的基础上进行通信。为了与位于该类嵌入式平台内的应用程序进行通信，这种应用程序的程序员必须避免使用结构化的软件对象，或是在一个接一个的基础上提供对这些进出所述嵌入式平台的对象的传输的直接处理。
为了充分利用该类语言的性能及灵活性，在编写一个可以在该类便携对象的处理器中执行的应用程序时，令该应用程序能够很容易地与该对象以外的其他应用程序通信是非常有用的。因此，在这种情况下，让应用程序能够与所述的外界应用程序交换它所处理的对象，而又不损失这些对象的组织或结构，是非常有用的。
在Java这样的编程语言中，用于结构化对象的串行化/反串行化的程序可能需要大量的硬件及软件资源。这些程序特别被用来将一个结构化对象保存为一个文件，或是在两个程序进程间传输一个结构化的对象，所述的程序进程在两个不同的工作存储器区域内执行。
然而，这些程序所需的软件与硬件资源在某些嵌入式平台上是没有的，特别是其中包括Javacard。例如，传统Java平台所使用的基类要占用大于1MB的存储空间(Java Developmeng Kit9MB)，而标准Javacard智能卡只有16kB存储容量。
传统的串行化过程利用Java环境的传统资源，并且它们的算法被设计成易于使用且可由计算机管理维护的。因此它们往往非常消耗存储器，并且要移植到性能如此有限的嵌入式平台上是非常复杂的，这里的性能有限是指存储器容量与处理器功率及速度两方面的。
另外，以Java为例，串行化过程使用一种普通对象类型管理器，它是在Java虚拟机(VM)中实现的，所述的Java虚拟机可以在各种硬件平台上执行。
由于改写到嵌入式平台上所必需的简洁程度，Javacard环境的当前版本中不带有类型管理器。因此，在标准Java配置中可以使用的串行化过程就不能访问表示结构化对象的结构的信息，所述的结构化对象是要根据以APDU格式接收到的数据来重建的。
另外，在传统的计算机环境中，存储器设备使得以面向对象的编程语言-如Java-实现的串行化过程不必在意待发送的结构化对象的大小。发送方对要发送对象的串行化可以独立于接收方的接收而进行，而被接收到的数据的反串行化也可以由接收方独立于发送方或是它们的发送时间来进行。然后，由编程环境以外的软件机制在发送方与接收方之间发送及管理线性数据流。这些数据流可以通过高容量缓存器发送，并由其他软件层管理，例如由TCP/IP这样的协议来管理。
在嵌入式平台的情况下，被用来与外界进行数据交换的软件机制不提供能够保证发送数据的完整性和连续性的流管理功能。而且嵌入式平台的有限存储器资源也使其不能在发送及转换期间储存线性数据流，从而就不能存储大的对象。

发明内容
因此，本发明的目标之一就是提出一种过程，使得使用嵌入式平台的应用程序的程序员能够访问自动软件工具，该自动软件工具使得一个储存或运行在该类便携对象中的软件主体或应用程序单元能够从位于另一台计算机基站上的另一个软件主体接收或向其发送以结构化软件对象形式组织的数据，前提是发送方与接收方之间的通信设备不允许传输包含所述类型对象的结构，而只允许传输较为简单形式的数据，并且该嵌入式平台的软件与硬件资源不足以支持使用传统的串行化过程。
该目标由一个数据转换过程实现，该过程可被计算机基站或嵌入式平台使用，其包括便携式对象，该便携式对象中至少包括一个处理器、存储设备以及能够以一个或多个线性数据序列的形式与一个终端交换信息的通信设备，该过程的特点在于它包括一个数据集转换步骤，这种转换是双向的，转换的一方是线性数据序列排列，另一方则是一种结构化的排列，这种结构化的排列描述或代表了一个或多个软件对象，这些软件对象是根据面向对象编程语言的规范结构化或层次化的。
根据本发明的一项特性，所述的过程包括下列步骤-待发送的第一数据集的转换或串行化，从描述或代表该对象的结构化排列到代表该第一数据集的线性数据序列，所述的数据集包含或代表了一个或多个软件对象，且该数据集根据一种面向对象的编程语言的规则被结构化或层次化；-利用通信设备将该线性数据序列从嵌入式平台发往至少一台主机，即一台终端或与终端相连的计算机基站，或是从该主机发往嵌入式平台；-在发送后将该线性数据序列转换或反串行化为排列成一个或多个结构化软件对象的数据集，所述的结构化软件对象重现或代表了第一数据集。
根据本发明的另一项特性，主机终端利用一个软件主体向嵌入式平台发送信息，所述的软件主体被称为发送函数，所述的信息在嵌入式平台中被一个响应函数接收，该函数可以借助储存在嵌入式平台中的至少一个接收方软件主体开始对这些数据进行处理，所述接收方软件主体还构成了至少一个应用程序的一部分，所述过程包括下列步骤-由代表接收方主体的通信主体接收一个数据集，该数据集是由所述响应函数为所述的接收方软件主体接收的，所述的数据集被排列成线性数据序列；-将该数据集转换为至少一个软件对象，该软件对象根据一种面向对象的编程语言被结构化或层次化；-将该结构化的软件对象发送给接收方主体，并由所述的接收方主体根据所述的对象开始进行处理。
根据本发明的一项特性，所述过程包括下列步骤-由所述响应函数从主机发送函数以至少一个发送参数的形式接收至少一个数据项，并将该参数发送给一个通信主体，该通信主体储存或运行在嵌入式平台上；-由通信主体将响应主体发来的至少一个发送参数转换或拼接成线性数据序列形式的数据集，并将这些数据储存在嵌入式平台中的一个输入流中；-由储存或运行在嵌入式平台上的串行化主体将储存在该输入流中的至少一部分数据转换或反串行化成一个数据集，该数据集包括或代表了至少一个结构化的软件对象；-由接收方主体接收该结构化的软件对象或其相关对象。
根据本发明的一项特性，所述过程包括下列步骤-将一个结构化的软件对象或其代表物从一个软件主体发送给一个串行化主体，所述的软件主体构成了运行或储存在嵌入式平台上的一个应用程序的一部分，所述的串行化主体运行或储存在所述的嵌入式平台上；-由所述的串行化主体将所述的结构化软件对象转换或串行化成线性数据序列形式的数据集，并将这些数据储存在嵌入式平台的输出流中；-由一个储存或运行在嵌入式平台上的通信主体将存储在该输出流中的至少一部分数据转换成一组响应参数，这些参数适合由所述响应函数发送；-由响应函数将这些响应参数从嵌入式平台发往主机终端，这一过程是响应函数的主动行为，也可以是对主机终端的发送函数的响应。
根据本发明的一项特性，储存在输入流或输出流中的线性数据序列代表了一个或多个软件对象，利用一个或多个被称为标签的数据项将所述的软件对象结构化或层次化，所述的标签具有一个或多个指定的值，每个值代表一种指定的行为，所述的行为对所述线性数据序列的反串行化执行。
根据本发明的一项特性，至少有一个标签被定义为代表下列行为中的一种-向结构化对象的结构中添加新元素，所述的结构化对象是由线性数据序列表示的；-引用一个元素或对象，作为源对象，其作为构成所述结构化对象的一个元素的全部或部分的值的源；-标明之后的一个或多个数据项代表了构成所述结构化对象的元素的内容；-标明缺少构成所述结构化对象的一个元素的内容。
根据本发明的一项特性，串行化主体根据一种被称为串行化过程的过程将一个被称为源对象的结构化对象串行化成一个线性数据集，所述的过程至少要处理一个被称为元素的对象，这些元素构成了该结构化源对象的结构或树状结构，所述的串行化过程要经过下列步骤-由串行化主体检测一个元素的类型，该元素被称为当前对象，它构成了所述结构化对象的结构或树状结构；-将一个数据项存储在输出流中，该数据项代表了一个表示添加新元素的标签，该数据项之后跟随着一个代表当前对象类型的数据项；-由一个串行化主体将与当前对象类型相关联的类型存储到输出流中，该类型紧随着已经存在于该输出流中的元素■可以借助于代表全部或部分结构化对象的值的数据项，■也可以借助于代表了一个标签的数据项，该标签表明要参照一个对象，其作为全部或部分结构化对象的值的源，所述的标签之后跟随着标识所述源对象的数据项。
根据本发明的一项特性，串行化过程将一个结构化对象转换成输出流，将每个当前对象的类型存储在一个存储器堆栈中，该堆栈被称为类型堆栈，由所述程序的连续重复过程按存储顺序的相反顺序读取所述对象。
根据本发明的一项特性，串行化主体借助一个被称为反串行化的过程将一个线性数据集反串行化成至少一个结构化的结果对象，所述反串行化过程通过下列步骤对存储在输入流中的每一个数据项进行处理-由串行化主体读取至少一个存储在输入流中的数据项，所述的数据项是跟随在先前已处理的数据之后的；-分析该数据项，并执行对应于该数据项的行为；本发明的目标之一是还要提出一种该类型的结构化对象传输过程，从而能够在一台主机与嵌入式平台之间传输软件对象，其中所述嵌入式平台的工作环境不含有用于所述结构化对象的类型管理器。
该目标由上述的数据转换过程实现，其特征在于所述的反串行化过程包括载入一个被称为当前对象的元素，即向所述当前对象的全部或部分指定一个直接或间接值，所述的元素构成了结构化结果对象的结构的全部或部分，当前对象载入的终止启动了-读取储存在存储器结构的下一个位置中的代表对象类型的数据项，并将该数据项从该位置删除，该存储器结构被称为类型堆栈；-把从类型堆栈中读出的数据所代表的类型储存起来，作为新的当前对象的类型。
根据本发明的一项特性，由反串行化过程创建的结构化对象被认为是完整的，并在类型堆栈为空时被发送给作为接收方的软件主体或应用程序。
根据本发明的一项特性，对应于某数据项的反串行化操作包括下列步骤，所述的数据项代表了一个标签，该标签被称为“NEW”标签并标明一个新元素-读取输入流中的至少一个后续数据项；-将该后续数据项所代表的对象类型存储在存储器堆栈中，让它紧接着可能已经储存在该堆栈中的类型，所述的堆栈被称为类型堆栈。
根据本发明的一项特性，所述反串行化过程所使用的堆栈类型包括LIFO类型堆栈，也就是说在该堆栈中是以存储顺序相反的顺序读取各存储位置的。
根据本发明的一项特性，所述的反串行化过程包括一个步骤，该步骤通过分配一个新的存储器空间或重新利用一个自由分配空间来创建一个元素，该元素构成了结构化结果软件对象的结构，所述的创建过程由一个类型管理器主体根据要被创建的元素的类型来完成。
根据本发明的一项特性，构成结构化结果软件对象结构的元素的创建步骤是在一个标明创建该元素的数据项的读取步骤与所述元素的第一载入步骤之间进行的。
根据本发明的一项特性，对应于某个数据项的行为包括将该数据项的值存储在分配给当前对象的存储器空间中的步骤，其中所述的数据项被称为简单数据项，即一个不代表标签的数据项。
根据本发明的一项特性，在反串行化过程期间，一个对象标号被分配给构成所述结构化结果对象的至少一个元素，所述的对象标号唯一地标识了所述的元素，使得该元素可以被指定给其他对象或元素，或是被其他对象或元素引用。
根据本发明的一项特性，对应于某数据项的行为包括下列步骤，其中所述的数据项代表一个标签，该标签被称为“REF”标签并标明一项引用-读取输入流中的至少一个后续数据项；
-将一个数据项存储到分配给当前对象的存储器空间中，紧接着已经存储的数据项，所述的数据项指定了一个对象作为全部或部分当前对象的值的源，所述的源对象或元素由所述的后续数据项标识。
根据本发明的一项特性，当存储在分配给所述对象的存储器空间中的数据达到指定长度时，就考虑应该终止当前对象的载入，所述的长度由存储在嵌入式平台上的类型管理器主体或是用于所述类型的管理器主体从卡式存储器中读出。
根据本发明的一项特性，从嵌入式平台向主机发送指定长度的线性数据序列是由一个重复过程完成的，该过程被称为数据读取过程，该过程包括下列递归步骤-由主机发送一条通信指令，该指令中包括至少一个发送参数，该参数代表了已经接收到的数据的长度；-由嵌入式平台接收所述的发射参数，并将其与要被发送的线性数据序列做比较；-通过发送至少一个返回参数来响应所述的通信指令，所述的返回参数代表了紧接着已被主机接收到的数据之后的数据项或项目；-由发出通信指令的主机接收返回参数，并将该参数所代表的数据存储到已经接收到的数据之后。
根据本发明的一项特性，由嵌入式平台从主机接收指定长度的线性数据序列，是在一个重复过程之后执行的，该过程被称为数据写入过程，它包括下列递归步骤-由主机发送一条通信指令，该指令带有至少一个代表数据项或项目的第一发送参数，所述的数据项紧随着待发射线性数据序列中已经被发送的那部分，并且在恰当的情况下，所述的指令中还带有一个第二发送参数，该参数代表了第一发送参数所代表的数据在待发射序列中的位置，或是已经发送的数据的长度。
-由嵌入式平台接收所述的一个或多个通信指令发送参数；-将第一发送参数所代表的数据存储在嵌入式平台上的输入流中，紧接着已被接收的数据之后。
根据本发明的一项特性，所述的数据写入过程还包括下列步骤-由嵌入式平台对第二发送参数进行比较，并与已经接收到的数据的长度做比较；-由嵌入式平台返回至少一个响应参数，该参数代表了已被接收到的数据的长度，或是代表表示比较结果的数据项，或是两者都包括。
本发明的目标之一是还要提出一种该类型的结构化对象传输过程，从而可以发送相对于上述通信设施来说在传输或临时存储大小上都具有较大尺寸的软件对象，或是无限大小的软件对象。
该目标由上述的数据转换过程实现，其特征在于至少有两个串行化、反串行化、数据读取或数据写入过程被并行执行，或是通过重复一个步骤被交织执行，所述步骤包括连续执行这些过程中的每一个过程的至少一个步骤。
根据本发明的一项特性，所述的输入流、输出流或两者都被存储在循环存储器结构形式中，这两个流可以共用同一个循环结构。
根据本发明的一项特性，所述的嵌入式平台具有一个可编程的环境，它能够存储并执行至少一个由程序员创建的应用程序，所述的通信功能与标准ISO 7816中所定义的APDU格式兼容。
根据本发明的一项特性，用于被接收对象的反串行化及后续处理工作在接收到至少一条APDU格式的指令时启动，该指令中含有至少一个数据项，该数据项表示接收结构化对象。
根据本发明的一项特性，所述的嵌入式平台具有一个与JavaCard标准兼容的可编程环境。
根据本发明的一项特性，在主机或嵌入式平台上执行的至少一个应用程序是以Java语言编写的。
根据本发明的一项特性，所述的过程被用于至少一个被称为卡主体的软件主体和至少一个被称为卡引擎代理主体的软件主体之间的通信，前者被储存或执行在嵌入式平台上，后者则被储存或执行在至少一台主机上，该主机属于一个计算机网络，该网络利用AAAMOM类型的软件基础设施借助异步消息进行通信，所述的卡引擎代理主体为所述的卡主体与所述网络中其他主体间的通信起到了中介的作用，所述的主体根据所述软件基础设施的规范工作，并且该主体属于至少一个分布式的应用程序。
另外，在某些环境或操作系统中，例如在JavaCard这样的嵌入式平台的环境下，不存在任何程序、或是只有严重消耗资源的复杂程序可以用于在该类软件对象不再有用时将它删除，或是释放它所占用的存储空间。因此，在这种情况下往往需要进行手动删除，从而必须由应用程序程序员直接并且是在一个接一个的基础上提供手动删除功能。
因此，本发明的目标之一是还要提出一种过程，它为基于嵌入式平台的应用程序的程序员提供了软件工具，这些工具允许重新使用被某些结构化软件对象中的全部或一部分占用的存储空间，这些软件对象被一个数据处理基站中的应用程序所使用，该处理基站可以是便携的，也可以不是。
拥有这些软件工具对于具有非线性结构的软件对象的简单复制来说也是非常有用的，例如树状结构形式。
因此，本发明的目标之一是要提出一种过程，它为基于嵌入式平台的应用程序的程序员提供了用于将结构化软件对象复制成另一个对象的软件工具，被复制的软件对象被称为源对象，复制后的对象被称为结果对象，该结果对象含有与源对象相同的值，但是在存储上构成一个不同的对象。
同样，为了安全性的原因，当该类软件对象所占用的存储空间被释放后，从所述空间删除来自该对象的信息至关重要，这是为了防止所述信息被接着利用相同存储空间的另一个对象或另一个应用程序读取。因此，该信息必须被手动删除，该功能由应用程序程序员直接地并且在一个接一个的基础上提供。
因此，本发明的目标之一是提出一种过程，它为基于嵌入式平台的应用程序的程序员提供了软件工具，在删除所述对象或重用该类软件对象所使用的所述空间时，可利用该工具删除或均匀化存储空间中包含的信息。
因此，本发明提出了一种如上所述的过程，其特征在于数据读出、数据写入、反串行化以及串行化过程都通过它们的实现被应用在至少一个储存在主机或嵌入式平台中的类上，所述的实现包括下列指令中的至少一种-对象写入指令，通过使用对应于某对象的串行化过程并接着执行数据写入过程和反串行化过程，将一个结构化对象发送给至少一个嵌入式平台的主体；-对象读出指令，通过使用串行化过程并接着执行数据读出程序和反串行化过程，从至少一个嵌入式平台的主体中读出一个结构化对象；-用于储存在嵌入式平台中的结构化对象的解除分配指令，该指令利用了串行化过程，后者还包括将分配给所述对象的各个组成部分的存储空间释放或解除分配的步骤，所述串行化过程是在分析所述组成部分的结构之后进行的；-用于被一个结构化对象释放的存储空间的内部管理或删除指令，该指令利用反串行化过程从一个给定的线性数据序列创建一个具有非实质内容的对象；-用于结构化源对象的复制指令，该指令利用串行化过程来创建一个代表该对象的线性数据序列，但不对所述源对象进行解除分配，随后利用反串行化过程，由该线性数据序列创建另一个结构化对象，该对象的内容与源对象完全相同。
根据本发明的一项特性，用于嵌入式平台的编程语言包括一个第一类(IOApplet)，该类描述了一种ProcessAPDU抽象方法，该方法在接收到APDU消息时在应用程序中启动一个用户定义的进程；在嵌入式平台上执行反串行化操作的程序代码被储存在所述的嵌入式平台中，为所述ProcessAPDU抽象方法的具体实现，在从第一类(IOApplet)继承而来的第二类(ObjectIOApplet)中，所述的程序代码调用一个ProcessObject方法，后者在同一实现类(ObjectIOApplet)中被描述为一个抽象方法。
根据本发明的一项特性，用于所述嵌入式平台的编程语言中含有一个第一类(IOApplet)，该类描述了一个SendAPDU方法，该方法将一个APDU格式的消息发送给主机；在嵌入式平台上执行所述串行化操作的程序代码被储存在从第一类(IOApplet)继承而来的第二类(ObjectIOApplet)中，用于使用SendAPDU方法的至少一个SendObject方法的具体实现。
本发明的另一个目标是提出一种计算机系统，该系统包括一个便携对象以及上述类型的软件工具。
该目标由一种计算机系统实现，该计算机系统由一个计算机基站构成，它被称为嵌入式平台，该嵌入式平台包括一个便携对象，该便携对象至少包含一个处理器、存储设备以及通信设备，所述的通信设备能够以一个或多个线性数据序列的形式与一个终端交换信息，所述嵌入式平台的特征在于，该平台带有一个串行化主体，它能够对一个数据集合执行一个方向或另一个方向的转换步骤，转换的一方是一种线性数据序列排列，另一方是代表一个或多个软件对象的结构化排列，这种结构化排列是根据一种面向对象编程语言的规范被结构化或层次化的。
根据本发明的一项特性，所述的嵌入式平台包括一个通信主体，它能够-代表接收方主体来接收一个数据集，该数据集是响应函数为储存在嵌入式平台上的接收方软件主体接收的，所述的数据集被组织成一个或多个线性数据序列；-将该数据集转换成至少一个软件对象，该软件对象根据一种面向对象编程语言的规范被结构化或层次化；以及-将该结构化的软件对象发送给接收方主体，并由接收方主体根据该对象开始处理。
根据本发明的一项特性，代表一个结构化软件对象的线性数据序列被储存在嵌入式平台的一个输入或输出流中，所述的嵌入式平台包括一个被称为串行化主体的软件主体，它能够创建所述嵌入式平台中的输入流所代表的一个或多个结构化对象，即反串行化所述的结构化对象，或是将代表待发送的一个或多个结构化对象的数据写入到输出流中，即串行化所述的结构化对象。
根据本发明的一项特性，所述的输入流或输出流被储存成一个或多个循环存储结构的形式。
根据本发明的一项特性，所述的串行化主体使用一个被称为类型堆栈的存储器堆栈来储存至少一个对象的类型，所述至少一个对象构成了要被串行化或反串行化的结构化对象结构的全部或部分，所述的类型堆栈拥有多个存储位置，这些存储位置只能在最近载入的存储位置被读出并删除之后才能被访问。
根据本发明的一项特性，包含在输入或输出流中的数据代表一个或多个结构化对象，其使用了一种包括一组标签的编码系统，每个所述的标签都代表一种对线性数据序列反串行化过程执行的指定行为。
根据本发明的一项特性，至少有一个标签被定义为代表下列行为中的一种-向线性数据序列所代表的结构化对象结构中加入新元素；-引用一个元素或对象，作为源对象，将其作为构成结构化对象的一个元素的全部或部分的值的源；-指示出随后的一个或多个数据项代表了构成所述结构化对象的一个元素的内容；-指示出构成所述结构化对象的一个元素的内容缺失。
根据本发明的一项特性，所述的嵌入式平台包括一个便携对象，该对象根据标准ISO 7816工作，并且使用APDU格式的指令。
根据本发明的一项特性，存储在嵌入式平台中的至少一个主体或应用程序是用Java语言编写的，所述的嵌入式平台拥有一个符合JavaCard标准的计算机环境。
根据本发明的一项特性，所述的系统在主机、嵌入式平台或两者中都包括至少一个软件类，它实现下列指令中的至少一条-对象写入指令，通过在主机中将结构化对象串行化成一个数据流，并随后将该数据流发送给嵌入式平台，来把一个结构化对象发送给所述卡的至少一个主体，并在嵌入式平台中将所述的数据流反串行化成结构化对象；-对象读取指令，通过在嵌入式平台中将结构化对象串行化成一个数据流，并随后由主机从嵌入式平台接收该数据流，来从所述卡的至少一个主体读取一个结构化对象，并在主机中将所述的数据流反串行化成一个结构化对象；-解除分配指令，用于储存在嵌入式平台中的结构化对象，在分析了所述对象各部分的结构之后，该指令根据一个选项串行化所述的对象，所述的选项包括释放或解除分配给该对象各个部分的存储空间；-用于被嵌入式平台中的一个结构化对象释放的存储空间的内部管理或删除指令，该指令通过反串行化一个给定的线性数据序列来创建一个具有非实质内容的对象；-用于在嵌入式平台中复制一个结构化对象的指令，所述结构化对象作为源对象，该指令通过串行化成代表同一个对象的线性数据序列，但不对所述源对象进行解除分配，随后将该线性数据序列反串行化成另一个结构化对象，该对象的内容与源对象完全相同。
根据本发明的一项特性，所述的嵌入式平台与至少一台属于某个计算机网络的主机进行通信，所述的网络通过符合AAA-MOM类型软件基础设施的异步消息进行通信，所述的主机包括一个被称为卡引擎代理主体的软件主体，该软件主体能够管理所述嵌入式平台与所述网络中其他主体间的通信，所述的主体根据该软件基础设施的规范进行工作，并且属于至少一个分布式的应用程序。


通过阅读下列说明并参照附图，将能更清楚地了解本发明以及它的特性与优点，其中-图1示出了一幅部分示意图，该图展示了主机或终端向嵌入式平台上的软件主体或从所述软件主体进行写入或读取操作时的对象传输及转换，在本发明的该版本中，所述的卡只包含一个应用程序；-图2示出了一幅更为详细的示意图，该图对应于主机或终端向嵌入式平台上的软件主体或从所述软件主体进行读取与写入操作时的对象传输及转换，在本发明的该版本中，所述的卡只包含一个应用程序；-图3示出了一幅部分示意图，该图展示了主机或终端向嵌入式平台上的软件主体或从所述软件主体进行写入或读取操作时的对象传输及转换，在本发明的该版本中，所述的卡包含多个应用程序；-图4示出了一幅部分示意图，该图展示了由一个数据流反串行化成一个结构化软件对象时所涉及的对象与主体；-图5示出了一幅部分示意图，该图展示了将一个结构化软件对象串行化成一个数据流时所涉及的对象与主体。
具体实施例方式
在某些语言中(例如“Java embarque”-Eyrolles-Paris 1999)，短语“嵌入式计算机”被用来指代一种本身不可见的计算机，因为它是被集成到一个拥有另一种功能的设备中去的。法语短语“ordinateurembarque”是英语“嵌入式计算机”的近似解释。
该特性，即另一个设备中所提供的一种特定功能，基本上说明了这样一个事实，即这类嵌入式计算机往往只具有有限的硬件或软件资源，并且常常使用基本的操作系统或软件环境。尽管也可以进行扩充增强，但是该类计算机的资源通常只是512kb直至更低数量级的静态存储器，以及一个8bit或16bit的处理器。在智能卡的例子中，可用的RAM容量可能在4kb数量级上，对于当前最强大的型号可以达到32kb。
在一般的IT背景下，短语“平台”指的是至少包括一个处理器和存储设备的数据处理装置。通过拓展上述的定义，并为了在该背景下进行说明的目的，短语“嵌入式平台”被用来指代包括该类平台的便携对象，所述的对象是真正便携的或是具有很小的尺寸的，或是拥有有限处理能力或存储能力的。
以下的说明解释了符合本发明的程序，在其对应的版本中，指定的任务与操作分配在各个有关的主体与应用程序之间。计算机应用程序的灵活组织本质上意味着这种分配可被实现为不同的形式，特别是在各个主体及它们的指定任务之间的差别只是抽象概念的情况下，这种差别对于它们的主要工作特性没有影响。因此显而易见，符合本发明的程序也可以被实现在本文中未说明的其他版本中，而不会偏离本发明的基本主旨，特别是可以按不同的方式组合为各种任务或主体提供的不同变化形式。同样，任务在同时储存在同一处的主体或应用程序间的抽象分配，也可以本文中未说明的不同变型版本组合起来，而不会偏离本发明的基本主旨。
在以下的说明中，主要以嵌入式平台为例来图解符合本发明的程序，所述的嵌入式平台包括一块使用JavaCard类型系统环境的智能卡，并且与一个终端通信，所述的终端包括一个数据处理基站，该基站执行一个用Java语言编写的应用程序。
然而，显而易见的是，符合本发明的程序也可以被应用到其他环境，所述的其他环境中的数据传输函数不提供某种模式下的结构化软件对象传输，所述的模式对于程序员是开放可见的。符合标准ISO7816的智能卡也可以被涉及，这类卡使用另一种编程环境，例如“Windows for SmartCards”，或是可用其他编程语言-如VisualBasic-编写的环境。这一点同样适用于符合其他标准的智能卡或是使用该类平台的便携对象或终端，所述的智能卡也在通信功能上受到类似的限制。
所述的程序还可以被应用于包括一个嵌入式数据处理基站的任意便携对象，而不论该嵌入式数据处理基站是否便携，比如汽车电子器件、识别标志、蜂窝电话或便携采集终端。
同样，符合本发明的程序将主要被示为涉及嵌入式平台的使用，所述的嵌入式平台与一个被称为终端或主机的数据处理基站通信。所述的程序自然也可以被用于所述终端是构成任意类型计算机网络的一部分的基站的情况下，而不会偏离本发明的基本主旨。因此，被描述为由该终端执行的各种功能也可以被分配在多个不同的设备之间，并且这种分配可以随时间变化。勿庸置疑，所述的程序也可以被应用在所述嵌入式平台直接或间接与一个或多个其他嵌入平台通信的情况下，同样也不会偏离本发明的基本主旨。笼统地说，主机或主机终端被定义为与嵌入式平台通信的应用程序或基站。
符合本发明的程序尤其可被应用于智能卡-例如符合JavaCard标准的-与计算机网络-例如用Java语言编写的-通信，所述的通信通过符合AAA-MOM类型软件基础设施的异步消息进行。在这种情况下，所述的卡与所述网络其他部分间的通信通常由一个被称为卡主体代理主体的软件主体管理，该主体为各个软件主体起到了中间媒介的作用，所述各个软件主体被称为卡主体，它们被存储在所述的卡上。在卡环境中，这些卡主体由一个被称为卡引擎主体的软件主体管理或协调，或两者皆有。
然后，符合本发明的程序让该卡引擎主体与卡引擎代理主体通信，以便根据Java语言或AAA基础设施标准交换结构化软件对象。能够与外界交换结构化对象这一事实使得所述的卡能够实现与AAA基础设施的增强兼容性，并且可以被网络中的其他AAA主体视为AAA类型的主体本身。
符合本发明的程序还可以被应用于智能卡-例如符合JavaCard标准的-与计算机网络-例如用Java编写的-之间的通信，所述的通信通过面向对象的RPC(远程程序呼叫)协议进行，例如带有Java RMI(远程方法调用)或COBRA类型软件基础设施的协议。
如果一个应用程序需要从一个终端向一个含有智能卡的嵌入式平台传输软件对象，这种传输往往会采用主/从类型的通信形式。这意味着所述的终端要主动执行向嵌入式平台的传输函数。为了进行通信，该函数向所述平台发送一条通信指令，并伴随有发送参数。然后，该指令可以在平台中启动一个或多个处理操作，并接收来自平台的响应参数。
在根据标准ISO 7816进行工作的智能卡的例子中，该指令的参数以APDU(应用程序协议数据单元)类型的格式被发送，其中包括如下组织的数据序列与指令一同发送的发送参数

CLA一个字节，指定接收方类型或应用程序。
INS一个字节，指定要执行的指令。
P1，P2两个字节，提供与APDU指令相关的信息。
Lc发送数据的长度。
Data被发送的数据。
Le等待的返回数据长度。
卡返回的响应参数

Data响应数据。
SW1，SW2两个字节，构成由卡发送的检验消息或代码。
可见，这种APDU格式不提供除线性数据序列以外任何其他形式的数据的发送与接收，所述的线性数据序列即一个简单的字节串。如果一个应用程序是用一种语言编写的，或是用于不带有APDU通信指令以外任何其他指令的嵌入式平台，希望传输更充分结构化的对象的程序员就没有可用于该目的的简单软件工具。该程序员就不得不在该应用程序中提供将该类结构化对象转换成一个字节串的功能，然后利用APDU指令发送该字节串，并最终按相反方向重转换所述的对象。这对应于所述对象的手工串行化、发送以及反串行化，换句话说，就是以最小的细节编写这些操作。
在程序员使用Java语言开发用于JavaCard标准嵌入式平台的应用程序的例子中，JavaCard中的可用工具提供了APDU格式的线性数据发送，它利用了下列JavaCard指令-“process(APDU)”所述的卡接收APDU格式的数据，并开始处理其中包含的发送参数，该处理由这些数据中指定的接收方软件主体或“小程序”完成；-“sendAPDU()”或“APDU.sendbytes()”在先前启动的处理之前或之中，所述的卡按APDU格式将其他数据以及返回参数发回给主机。
所述的“sendAPDU()”指令被实现在JavaCard环境里的“IOApplet”类中，其实现形式为可应用于含有原始数据的无类型对象的方法。
另一方面，所述的“Process(APDU)”则被声明在JavaCard环境里的“IOApplet”类中，其形式为一个抽象方法。这意味着该方法存在于Javacard环境中，但是实现该方法的代码必须由一个应用程序的程序员编写，所述的应用程序将要使用该指令。例如，程序员在应用程序中创建“IOApplet”类的一个继承子类，该子类中就包含了一种方法，该方法中容纳了该“Process(APDU)”方法所要执行的处理的代码。当接收到一条消息时，所述的JavaCard环境只是调用“Process(APDU)”方法，然后启动程序员编写在附加代码中的处理程序。
为了在该环境中为程序员提供用于直接发送结构化软件对象的工具，符合本发明的程序提供了类似的指令，但是这些指令直接接受符合Java语言的特定面向对象特性的结构化软件对象。这些指令可以被用在JavaCard环境中，并且可以是例如“process(Object)”和“sendObject()”类型的。
为了让程序员-此处也称为用户-能够直接使用这些指令而不必关心APDU指令语法，符合本发明的程序接管了应用程序或发送方主体与接收方主体之间对象及数据的串行化、发送以及反串行化操作。
在JavaCard环境的例子中，这些操作可以通过例如执行一段包含在“Process(APDU)”方法中的程序代码来实现，该方法属于“IOApplet”类的一个子类，例如称为“ObjectIOApplet”。然后，在接收到一条APDU消息时，该代码由所述的环境自动启动，该消息本身含有转换操作以及对另一个“Process(Object)”抽象方法的调用。使用本发明该类型的版本，程序员只需编写要由所述的卡在接收到结构化对象时执行的操作的代码。该程序员可以在“ObjectIOApplet”类的继承子类中编写该代码，以便实现“Process(Object)”抽象方法。
在以下段落中，只对在所述卡一端执行的转换、串行化及反串行化操作进行说明。显而易见，所述的程序也可以被用来在主机端执行同样的操作。所述主机终端的硬件与软件资源通常远优于所述的卡上可用的资源，然而，这些操作在主机上也可以被编写或组织得不同，这样做不偏离本发明的基本主旨。
在图1所示的本发明版本中，一台主机终端(1)与一个嵌入式平台通信，该嵌入式平台可以是例如一个JavaCard标准的智能卡(2)。主机(1)执行至少一个应用程序(11)，其中包括至少一个软件主体(111)，并利用APDU格式的通信函数(101)与卡(2)通信，该函数与通信资源密切联系，其中包括例如连接单元(100)。该连接单元包含一种连接方法，例如通过电接触、微波链路、IR链路或磁迹，或是这几类方法中的两种或更多的组合。
卡(2)执行一个应用程序(22)，并利用响应函数(201)与主机(1)进行通信，所述的应用程序包括至少一个软件主体(221)，而所述的响应函数是JavaCard系统环境组成部分。为了这一目的，所述的响应函数(201)要使用一种与主机终端(1)的通信资源(100)相兼容类型的通信资源(200)。
当主机应用程序(11)的主体(111)希望向卡主体(221)发送数据，以便指示其执行一个进程(2210)或请求位于卡存储器上的信息时，它就会执行一条对象写指令，从而启动用来向所述的卡发送结构化软件对象(31)的程序，该指令被命名为例如“WriteObject()”。然后，所述的软件对象(31)就被串行化，即被主机转换主体(12)转换成一个APDU格式的数据集。该主机转换主体接着利用通信函数(101)通过主机连接单元(100)以及卡通信资源(200)将这些数据发送给卡(2)。
当所述的数据在卡中被所述的响应函数(201)接收到时，该响应函数就会将所述的数据发送给一个卡转换主体(21)，所述的响应函数管理所述的通信资源(200)。所述的卡转换主体(21)反串行化数据，以相反的方向转换它们以便重新获得它们的原始结构，该结构是软件对象(34)形式的。接着，利用一条对象处理指令将所述的结构化软件对象(34)发送给接收方主体(22)，所述的指令会执行对应于接收数据的处理程序(2210)，该指令被命名为例如“Process(Object)”。
当卡内(2)应用程序(22)的主体(221)希望向主机(1)的主体(111)发送数据时，它就会执行一条对象发送指令，该指令会启动用于向主机发送结构化软件对象(41)的程序，该指令被命名为例如“SendObject()”。所述的软件对象(41)接着就被串行化，即被例如卡转换主体(21)转换成一个APDU格式的数据集。然后，该卡转换主体利用响应函数(201)、通过卡通信资源(200)以及主机通信单元(100)将这些数据发送给主机(1)。
当所述的数据被主机通信函数(101)接收到时，所述的通信函数就会将这些数据发送给主机转换主体(12)，该通信函数管理连接单元(100)。所述的主机转换主体(12)反串行化数据，按相反的方向转换它们以便重新得到它们的原始结构，该结构是软件对象(44)形式的。然后，由一条读取接收数据的对象读取指令将所述的结构化软件对象(44)发送给接收方主体(11)，该指令被命名为例如“ReadObject()”。
图2示出了本发明的一个版本，其中，由主机和卡转换主体(分别为12和21)执行的串行化/反串行化以及发送操作，是由两个不同的主体完成的(分别为121，122和211，212)。
因此，所述的卡转换主体(21)包括一个通信主体(211)和一个串行化主体(212)。通信主体(211)管理字节转换操作，并利用响应函数(201)以发送参数(32)和响应参数(43)的形式交换数据。对于数据接收而言，所述的通信主体(211)检验接收数据是否完整，并将发送参数(32)连接成一个线性数据序列，该数据序列被储存在一个输入流(33)中。对于数据发送而言，所述的通信主体(211)读取输出流(42)中的一个线性数据序列，并拆分这些数据，以便将它们分散成与所述响应函数(201)的发送能力相容的响应参数(43)。
所述的串行化主体(212)管理对象级的转换操作，并执行适当的串行化/反串行化。对于数据发送以及后续的串行化而言，所述的串行化主体(212)分析待发送的结构化软件对象(41)的结构与内容，并将该对象编码成线性数据序列的形式，该数据序列被储存在输出流(42)中。对于数据接收以及后续的反串行化而言，所述的串行化主体(212)读取输入流(33)中的线性数据序列。然后，它分析该流中的数据，并重建它们所代表的结构化软件对象(34)。
图3示出了本发明的一个版本，其中所述的卡可以拥有多个主体(221，222，223，231)，这些主体可以具有对应于符合本发明的程序的接收方身份，并且可能被分散在一个或多个应用程序(22，23)之间。为了能够处理卡(2)与主机(1)之间的所有数据交换，符合本发明的程序中包括一个接口主体(210)，卡(2)与主机(1)之间的所有结构化数据交换都要通过该接口主体发送。
在本发明的该版本中，不管所述的接收方是谁，都要由接口主体(210)替代应用程序(22)或接收方主体(221)来接收所有发送给卡的数据。然后，所述的接口主体(210)指示由所述的通信主体(211)进行发送参数(32)的连接，以及由所述的串行化主体(212)进行结果数据(33)的后续反串行化，这与上文所述的一样。一旦这些数据被重建为一个结构化的软件对象(34)，同一个接口主体(210)就会把所述的结构化对象(34)发送给软件主体(221)，该软件主体是被接收到的数据(32)的接收方。在另一个版本中(未示出)，接口主体(210)接收到的数据(32)中含有对应于接收方主体(221)的识别信息，或是由接口主体(210)在所述的数据(32)被发送之前向其中加入相应的信息。反串行化得到的结构化对象(34)接着就被反串行化主体(212)或一个分配主体(未示出)直接送出。
同样，接口主体(210)也要接收由一个发送方应用程序(22)或一个发送方主体(221)发送给主机的所有数据。然后，所述的接口主体(210)指示由串行化主体(212)串行化这些数据，并由通信主体(211)将所述的输出流(42)连接起来，这与上文所述的一样。得到的数据接着由响应函数(201)通过通信资源(200，100)以响应参数(43)的形式发送给终端(1)。
在本发明的另一个版本中(未示出)，接口主体(210)被插入到发送及转换链中(201，211，212，221)。对于卡内接收(主机写指令)而言，接口主体(210)根据接收数据中所包含的信息将接收到的数据或对象导向它们的接收方(221，222，223，231)。对于从卡发送(主机读指令)而言，接口主体(210)也可以被包括以接收待发送的数据或对象，并向所述的数据或对象分配代表它们的发送方(221，222，223，231)的信息。
可以认为，主机(1)-不论是终端本身还是能够管理该终端的任意软件主体，与卡上的一个主体或应用程序之间的信息交换，是在两个不同的层次上执行的，即字节层次和对象层次。
在对象层次上，组织成结构化软件对象的待发送数据被转换成一个线性数据流，反之亦然。该串行化步骤对对象的结构进行操作，它是由各个平台中的串行化主体执行的。
在字节或字节串层次上，组织成简单线性流的数据被利用发送函数分段发送，例如按APDU格式，这是卡与外界交换信息的唯一手段。这些交换由主机以及卡通信主体控制，两者通过利用该通信函数来发送参数与彼此通信。
为了向用户提供可见的指令，各种处理程序被实现在一个或多个类中，并且通常有至少一个在卡中工作，一个在终端或主机中工作。在Java语言中，符合本发明的程序还可以为卡提供一个“ObjectIOApplet”类，并为主机提供一个“ObjectIOProxy”类，该程序利用了以下的语法class ObjectIOProxy{voidwriteObject(Object o)；ObjectreadObject()；}该“ObjectIOProxy”类定义了一个主机中的类，以便向用户应用程序提供“writeObject(Object)”和“readObject()”指令class ObjectIOApplet{void process(Object o)；void sendObject(Object o)；}该“ObjectIOApplet”类定义了一个卡中的类，以便向用户应用程序提供“process(Object)”和“sendObject()”指令。
由于卡在本质上是被动的，因此所有这些转换和发送操作都由主机主动发起，而主机是利用代码中一条触发APDU指令发送的指令来实现的。正是这条指令启动了相关主体请求的转换操作。
因此，当在卡应用程序代码中执行时，“process(Object)”和“sendObjectO”指令不会直接触发相应的转换操作。“sendObjectO”指令将待发送对象储存在一个数据队列中，例如“qout”，在该队列中，要被串行化以便发送的对象由一条“qout.push(object)”类型的引入指令导入。当一个串行化操作被启动时，这些待发送的对象就从所述的输出队列中被提取出来，提取的顺序与它们被导入的顺序相同。
同样，所述的指令还可以从一个输入队列-例如“qin”-提取一个对象，该对象已经被主机先前启动的操作串行化了。所述的提取由一条“qin.pop()”类型的提取指令实现。
读、写、串行化与反串行化操作由“ObjectIOProxy”类从主机控制，利用了用户可见的指令。这些指令可以被实现在该类的代码中，例如以下列形式实现-“card.Serialize out”在卡中开始待发送对象的串行化，如下所述。这些对象可以在执行“sendObject()”指令时被卡应用程序存储在一个输出队列中；-“card.Read”在卡中开始输出流数据的读取，并将这些数据发送给主机，如下所述；-“card.Write”开始向卡发送数据，并向输入流中写入数据，如下所述；-“card.Serialize In”在卡中开始对输入流中的对象反串行化，如下所述。
在此处所述的本发明版本中，卡输出及输入流被储存在同一个循环存储结构中。本发明的其他版本也同样可行，其中为各个流使用不同的存储结构，或是利用其他类型的存储结构。
在该例中，循环存储结构相当于一组连续的存储位置，其中的第一个位置被系统认为是紧接着最后一个位置的。这意味着一个线性数据序列可以从任意位置开始存储在该结构中，而又不会失去连续性，这样做的前提是所述序列的长度不大于存储位置的总数。
输入与输出流共享同一个循环结构这一事实，涉及将两个流中所包含的数据存储到这同一个循环结构的不同区域内。这些流中所包含的数据在被读取后就会被删除，删除是立即进行的，也可以是在某项操作期间进行的，两个流的长度与位置在该循环结构中可变。当两个流之一没有足够的空间来储存新数据时(这是由于新数据受到了另一个流的未删除数据的阻碍)，就必须处理所述的另一个流，以释放它占用的空间。
该类循环结构使得利用有限的存储资源来处理没有预先确定长度的流成为可能。只要把对两个流进行的不同操作充分均匀的交替进行，就可以实现这个目的。
在字节层次，从一个平台的输出流到另一个平台的输入流的数据交换以及反向的情形是像下文所述的那样进行的。
如果主机希望获得位于卡输出流中的数据，它就发送一条读取指令，例如符合Java语法的“card.Read”。该指令启动一次读取会话，该会话通常会被分为多项事务，每项事务代表进程的一次重复(iteration)。
为了启动所述的读取会话，主机会通过它的通信主体与发送函数发出一条APDU格式的指令，并伴有代表其希望接收的数据长度的发送参数(P1和P2，对应于短整数)。从通信主体接收到该条指令后，卡就会读取卡输出流中的第一数据块，并将该块发送给卡响应函数。然后，该第一数据块被作为响应数据(DataR)返回给主机，以此对所述的APDU指令作出响应。
因此，所述读取进程的各次连续重复涉及由主机发送APDU指令，该指令伴随有代表已经接收到的数据长度的发送参数(P1和P2，即一个短整数)。一旦被卡通信主体接收到，该长度就起到了确认先前的发送的作用。由此，所述的通信主体就会返回紧接着主机所指示的长度之后的输出流数据，以此作为响应数据(DataR)。应该注意的是，数据从输出流中被读出但是未被删除，从而可以在有需要的时候重新被发送。这意味着在这种发送过程中不会有数据被遗漏。
当主机所请求的数据长度被正确接收后，读取会话终止，主机也停止循环。如果卡通信主体发送了一个数据项(例如一个长度为零的DataR域)或是一个表示输出流中的所有可用数据都已经被发出的代码(SW1或SW2)，所述的读取会话也可以被中止或中断。如果卡输出流为空，主机就必须在卡中启动一次新的从卡“qout”队列到卡输出流的对象串行化操作，以便让输出流接收新数据。
当主机希望从它的输出流向卡发送数据时，它就会发出一条写指令，例如符合Java语法的“card.Write”。该指令启动一次写入会话，该会话通常会被分为多项事务，每项事务代表进程的一次重复。
为了启动所述的写入会话，主机通过它的通信主体和发送函数发出一条APDU格式的指令，该指令伴有代表了它希望发送的数据长度的发送参数(P1和P2，即一个短整数)。这第一条APDU指令的数据域(DataT)中含有待发送的第一数据块或组，该数据块是从主机输出流读取的。在接收到这条指令后，卡响应函数就将所述的第一数据块发送给卡通信主体。然后，该卡通信主体将该第一数据块写入卡输入流。
所述写入进程的每次连续重复都涉及由主机发送APDU指令，该指令伴有代表了已经发出的数据长度的发送参数(P1和P2，即一个短整数)。该第一APDU指令的数据域(DataT)中含有从主机输出流读取的下一个数据块或组。在接收到该指令时，卡响应函数就将这些参数以及该数据块发送给卡通信主体。然后，该卡通信主体将发送参数(P1和P2)中声明的数据长度与写入会话开始以来已经接收到的数据长度进行比较。这意味着在该发送过程中不会有数据被遗漏。
如果该比较过程没有发现错误，那么所述的卡通信主体就会将该数据块写入卡输入流。如果检测到错误，所述的通信主体则会向主机返回一个代码或标记，该代码指示了一项错误并且/或者代表了该错误的特性。该代码或标记可以通过响应函数的响应参数(SW1和SW2)、返回的数据域(DataR)、该域的长度或是这些元素的组合形式被返回。
当主机声明的长度被发送完毕，所述的写入会话就会终止，主机也会停止循环。如果卡通信主体发出一个代码或标记以表明卡输入流不能接收任何新数据，所述的会话也会被中止或中断。这时，所述的主机就必须在卡中启动一个或多个操作，以便释放包含该输入流的存储结构中的空间。
这可能涉及在卡内启动一次新的从输入流到“qin”对象输入队列的数据反串行化操作，所述的输入队列可以被卡应用程序访问。这也可能涉及启动一次新的读取会话，以接收包含在卡输出流中的数据，从而释放存储这两个流的循环结构中的空间。
在对象层次上，串行化与反串行化操作是在数据流与卡主体或卡应用程序之间进行的，反之亦然，如下所述。
对象在卡中从输入流(33)被反串行化至“qin”输入队列，在该队列中，对象可以被“Process(Object)”指令直接访问，该指令由“ObjectIOApplet”类提供，并由接收方主体或应用程序使用。
为了实现符合本发明的程序，当主机希望在卡内启动一次反串行化操作时，它就会使用一条指令，例如符合Java语法的“card.SerializeIn”。
图4示出了一个结构化软件对象(34)的反串行化，该操作是通过解码对应于所述对象的输入流(32)数据实现的，还示出了所述结构化对象(34)或结果对象的存储及结构成分创建操作。
串行化主体(212)一个接一个地读取储存在输入流(33)内一个线性序列中的数据，根据一个给定的代码译码这些数据，并根据该译码结果创建一个结构化软件对象(34)。储存在该输入流中的数据序列中的某些数据可能具有一个指定值，并且该值被看作是表示一个代码标签的存在。该解码可以通过调用一种分配方法来实现，该分配方法是各类待解码的结构化对象所特有的，例如利用下列语法Typeobject∷decode(Object，InputStream)来解码一个“Typeobject”类型的对象“Object”，该对象来自输入流“Input Stream”。
该代码包括一组标签，每个标签都有指定的用途，并且每个标签都对应于输入流中一个数据项的至少一个特定值。从而，输入流中具有对应于这些标签之一的值的每个数据项都会在反串行化过程中被串行化主体译码出来。
对于使用符合本发明的程序的应用程序来说，串行化主体(212)可以被设计来识别多个标签组，或者每个标签可以由多个不同的数据值表示，这样做不会偏离本发明的基本主旨。该类多样性尤其可被用来解决一个卡(2)或卡类型对应多个不同终端或主机环境的情况。
对于此处所述的本发明版本，所述的代码包括“NULL”、“NEW”、“REF”和“DATA”类型的标签。
-一个NULL标签代表不存在数据，但是在串行化主体进行创建的过程中要在结构中占据一个位置。
-一个NEW标签向串行化主体表示一个新对象说明的开始，该对象是所述转换过程得到的结构化软件对象(34)，或是一个包括该类结构化对象(34)一部分的对象，它被称为元素。
-一个REF标签表示将一个对象(同一个或另一个对象)指定为说明中所有或部分对象或元素的值的源。该标签被用来通过引用指定一个值。
-一个DATA标签表示以下的数据代表说明中的对象或元素的值或内容。该内容可以由原始数据构成，该原始数据代表被直接指定给对象的一个或多个值，也可以包括其他标签，该标签表示定义该内容的对象或引用。
根据标签的类型，一个标签之后可以接一个或多个数据项，这些数据项的译码是根据相关标签的含义来确定的。
-当读到一个NEW标签时，串行化主体知道它必须将接下来的数据项译码成代表新对象的类型。
-同样，当读到一个REF标签时，串行化主体知道它必须将接下来的数据项译码成代表一个对象的标识符，该对象通过引用被指定为该值的源。
在此处所述的本发明版本中，所述的标签被编码在一个字节中，编码方式与类型及引用标识符相同，但是很明显，符合本发明的程序还要提供其他代码的使用，根据相关计算机环境的需求及可行性，这些代码会有所不同，或更复杂，或更明确。
当读到输入流(32)的数据时，串行化主体(212)会分析每个数据项的值，并创建及载入对象或元素(340，341，342，343，344)，这些对象构成了结果对象(34)。对输入流(32)的这种读取重复进行，直到该输入流所代表的对象(34)的重建被完成为止。该创建可以通过调用一个分配方法来实现，该方法是各个对象类型所特有的，例如使用下列语法Typeobject∷malloc()在反串行化时创建或分配一个“Typeobject”类型的对象。
该类型的对象可以具有不同的结构，这些创建与载入操作由一个管理主体(TM0、TM1、TM2)直接或间接地控制，该管理主体是待创建的对象类型所对应的特定类型，例如Java语言中的“typemarshaller”主体。该类型管理主体特定用于一种或多种对象类型，并且受到一个通用类型管理器主体(TMG)的控制，例如Java语言中的“type manager”主体。特别地，该类型管理器主体储存了对应于反串行化期间所创建的各种对象类型的标识符。该通用类型管理器主体(TMG)还包括代码与程序或方法，它们特定用于这些不同的对象类型，并且被用于相同对象的串行化/反串行化。所述的类型管理器主体还被用来管理对象的列表以及它们的分配，从而可以执行新的分配并在解码时重新利用一块自由空间来创建一个新对象。
通常，类型管理器主体(TMG)中包含所有不同对象类型的信息，这些对象是可以在卡中管理的。该信息可由一个主机生成，例如在卡编程阶段。然后，以程序代码(“glue code”)的形式将该信息与应用程序所使用的类(“applet”)一同发送，所述的程序代码(“gluecode”)会被添加到通用类型管理器主体(TMG)的代码中。
利用下文中将要说明的类型管理器主体，以及类型marshaller主体，符合本发明的程序就可以在一个嵌入式平台上管理基本类型或构造类型的结构化对象的串行化与反串行化，所述嵌入式平台-例如JavaCard-的编程环境中不包括这种类型管理器。
一个对象或元素在解码期间的创建对应于该对象的分配，即保留指定的存储器空间并将该空间分配给该对象。某些嵌入式环境，尤其是包括Javacard在内，并不提供可被用来释放先前被一个删除对象占用的存储器空间的软件工具，比如传统Java语言的“garbagecollector”主体。在串行化主体(212)创建一个对象时，符合本发明的程序提供这样一种可行性，即在执行该创建操作时，将先前被另一个对象占用的存储器空间分配给该对象，所述的另一个对象已成为过剩的，例如与待创建对象的类型相同的对象。由此就可以时刻重用卡的存储空间，由于卡存储空间的有限性，这是非常有价值的优点。
在图4所示的例子中，输入流(32)对应于一个结构化结果对象(34)，该对象的结构或图表可按下列形式用Java语言描述

在读取输入流(33)时，串行化主体首先读取一个NEW标签(321)。然后它读取后面的数据项(322)，并接着储存对应于类型2对象的创建请求。根据该NEW标识符2标签(321)，串行化主体利用对应于同样类型(Type2)的类型管理器主体(TM2)来创建新的对象“x”(340)，在本例中该对象属于类X。在开始描述结果对象时，该新对象将是对应于该结果对象的图表的树状结构的“根”对象。
在进行创建时，串行化主体为新创建的对象(340)指定一个标号(3402)，在本例中该标号取值为0。在创建该结果对象时，所述的标号(3402)可以作为其他元素或部分元素的参考，从而可以确定该元素的内容是否已经被载入。
然后，串行化主体将该对象的类型与标号储存在一个存储器结构中，该存储器被称为类型堆栈(TYST)。该类型堆栈是一种存储器堆栈类型结构，这意味着数据项可以被储存(压栈)在另一个数据项之上，并且一个指定的数据项只有在它之后存储的数据已经被提取之后才能被读取并提出(出栈)。数据从栈中被提取出来的顺序与它们被储存进去的顺序相反(LIFO即后入先出)。
所述的串行化主体还将所述新对象(340)的类型及它的标号与所述对象对应地储存起来，该对象被称为当前对象(OBJ)，所述的类型与标号将和随后的数据一同被载入到输入流中。
下一个标签是一个DATA标签，之后紧接着两个原始数据项(324，325)，这两个数据项不是标签或标识符。这两个数据项被储存在当前对象(OBJ)，即x(340)中，作为后续元素(342，343)的值。这两个后续元素分别是被标为“i”的整型(int)和被标为“by”的字节型(byte)，这些元素分别取输入流中这两个数据项(324、325)所包含的值。
下一个标签是一个NEW标签，紧接着该标签的是一个表示类型0的数据项。该序列表示对象“x”的下一个元素是一个类型0的对象。串行化主体将为所述的对象(344)分配一个标号(3442)，在该例中该标号为1，并将对应于所述新对象(344)的标号与类型(即0)添加(压)到类型堆栈(TYST)中。所述的串行化主体还会让对应于类型0的类型管理器主体(TM0)创建一个类型0的对象，在本例中该对象为类型Y的“y”(344)。
通过对应于当前对象(OBJ)的类型管理器主体(TM2)，所述的串行化主体能够得知当前对象(OBJ)，即“x”，还未完全被载入。下一个标签是一个DATA标签，之后跟随着一个原始数据项(329)，将被指定为当前对象下一个元素(341)的值，即布尔类型元素“bo”的值，该元素是对象“x”的最后一个元素。
通过对应于当前对象(OBJ)的类型管理器主体(TM2)，所述的串行化主体就能得知所述的当前对象(OBJ)，即“x”(340)，现已完全被载入。所述载入对象(340)的标号(3402)被储存在对象堆栈中(OBJST)，而该对象(340)的标识符被储存在卡中。所述的串行化对象接着终止当前对象的载入，并提取(弹出)保存在类型栈(TYST)顶部的类型与标号。该堆栈的顶部必须被理解为可以被首先访问的堆栈位置。从类型堆栈中提取出来的类型与标号-在本例中分别为0和1-接着就被储存成对应于新当前对象(OBJ)。
下一个标签是一个DATA标签，该标签表示当前对象，即“y”，的载入。该标签之后紧接着一个REF标签(3211)和一个数据项(3312)，在该例中为0。因此，所述的串行化主体会通过引用为对象“y”(344)指定一个值，该值代表了与某个对象的值的简单联系，而所述的标号(3402)就是通过该引用(3212)被分派给该对象的。对象“y”就具有了一个被定义为引用对象“x”的值，而在反串行化过程中利用对象“x”具有标号0。因此，可以通过将对应于该对象“x”的标识符储存在卡中来定义该联系，该标识符是通过该标号从对象堆栈(OBJST)中读取的。
通过对应于当前对象(OBJ)的类型管理器主体(TM0)，所述的串行化主体就能得知所述的当前对象(OBJ)-即“y”-现已完全被载入。所述载入对象(344)的标号(3442)被储存在对象堆栈(OBJST)中，而所述对象(344)的标识符被存储在卡中。所述的串行化对象接着就会终止该载入程序，并询问类型堆栈(TYST)。
如果类型堆栈(TYST)在对象“y”的类型被提出之后为空，即没有更多的“构造类型”要被重建，那么串行化主体就断定结果对象(34)已经被完整地创建了。
在本发明的一个变形版本中，新对象的创建或分配可以在反串行化进程的任意阶段完成，从表示所述新对象的NEW标签的读取，直到该对象载入的开始。
在另一种变型中，被用于一个对象的反串行化的标号与卡内对象的标识符完全相同。
对象在卡中从输出流(42)被串行化到输出队列“qout”，该输出队列可由指令“SendObject()”直接访问，该指令由“ObjectIOApplet”类提供，并被接收方主体或应用程序使用。
为了实现符合本发明的程序，主机使用一条指令，例如符合Java语法的“card.SerializeOut”，在卡中启动一次串行化操作。
图5示出了一个结构化软件对象(41)的串行化，该对象被称为源对象，所述的串行化通过解析所述结构化对象(41)的结构成分来实现，随后以储存在对应于所述源对象(41)的输出流(42)中的数据形式进行编码。
该串行化功能被实现在一个方法中，即可用于一种指定类型对象的行为或程序，利用下列Java语法实现Typeobject∷(Object，OutputStream)这是一个用来将类型“Typeobject”的对象“Object”编码到输出流“OutputStream”中的方法。
Typeobject∷getSuper()是一个用来在编码一个“Typeobject”类型对象时，获取与一个对象的类型及构造类型相关的信息的方法。
基本类型一般是那些由环境或编程语言安排或管理的类型，而构造类型与之相对，它们被定义为多个对象的组合。现有的基本类型为例如嵌入式环境中的“整型”、“布尔型”和“字节型”，而在更全面的环境中则还包括长整型、实型、长实型和字符型(“long”、“real”、“double”和“char”)。
对于该串行化操作而言，所述的串行化主体(212)对要被串行化的源对象(42)的整个结构或图表执行一次循环扫描，从而分析对象元素(410，412，413，414，411)，该扫描从“根”对象或元素开始，在该例中为“x”。本例中所提供的源对象(42)的图表与上述图4中的一样。所述的串行化主体为每个具有构造类型的图表元素调用对应于同一个构造类型的主体(TM0，TM1，TM2)。
对输出流(42)中的源对象(41)的描述从写入一个NEW标签开始，随后是根元素类型标识符，在该例中为类型2的对象“x”。该根对象被指定为当前对象(OBJ)。该对象还接收一个标号，在该例中为0，并且它的类型与标号会被载入(压栈操作)到类型堆栈(TYST)中。
通过写入一个DATA标签而继续进行描述，之后是表示对应于根对象内容的值或引用的数据。由于对象“x”中包含一个构造类型的对象“y”(414)，因此对根对象的描述中还包括一个NEW标签，之后是所述对象“y”的类型，在本例中为“NEW 0”，该类型取代了所述对象“y”的值。在NEW标签被写入时，一个标号被分配给该标签，在本例中为1。该新对象的标号及类型接着被载入(压栈操作)到类型堆栈(TYST)中。
当对象(OBJ)-即对象“x”(410)-的内容描述被完成后，该对象的标号就与该对象的标识符一同被储存到对象堆栈(OBJST)中。所述的串行化主体接着就解析类型堆栈，提取出(出栈操作)对象“y”的类型及标号。它将所述的对象“y”存为一个新的当前对象(OBJ)，并接着开始对所述对象“y”的内容进行描述。该对象包括对根对象“x”的简单引用，被写入输出流的数据包括一个REF标签，随后是一个数据项，该数据项起到了要被指定为引用源的对象的标号的作用，在该例中，被引用的对象就是标号为0的对象“x”。
一旦对当前对象-即对象“y”(414)-的内容描述被完成，它的标号就与该对象的标识符一起被储存到对象堆栈(OBJST)中。所述的串行化主体接着就会查询类型堆栈，并提取(出栈操作)出对象“x”的类型，该类型在该类型堆栈中被储存在对象“y”之下。由于对象“x”的标号已经被储存在对象堆栈(OBJST)中，因此所述的串行化主体就知道对象“x”已经被串行化或描述了。它会再次查询类型堆栈，观察到它已经为空，从而断定构成源对象(34)的所有元素都已经在输出流(42)中被完全描述了。
由于这些算法的递归性，就可以利用一种程序代码来执行这些串行化与反串行化操作，该代码占用的存储器空间足够小，从而可以将该代码存储在一个嵌入式平台中，例如一个智能卡或JavaCard标准的便携式计算机化对象。这些算法的简洁性还使得用一个低功率处理器执行这些操作成为可能，比如那些使用在这类嵌入式平台上的处理器。
为了平衡储存在临时表单中的数据容量，主机应用程序(11)所需的各种读取、写入、串行化及反串行化操作可以被交织在一个或多个程序循环中。一个该类循环在每次重复时都执行一条对应于这些操作中的每一个操作的指令，例如使用下列Java语法DoDo card.Serialize out While(ok out)
Do card.Read While(data read)While(data in)card.WriteWhile(ok in)card.Serialize inLoop在该例中，第一行与最后一行(“Do”与“Loop”)决定了一个循环的重复，该循环中包括四行交叉的代码。一个该类循环很容易和其他操作组合在一起，并加入用于中断循环进程的各种条件。
循环中的第一行表示在卡中为先前通过通过“SendObject()”指令储存在“qout”输出队列中的对象启动一次向卡输出流的串行化会话。只要“ok out”条件满足，该会话就会被重复，例如，只要“qout”队列中有对象要被发送并且输出流未满。
第二行表示为储存在卡输出流中的数据启动一次读取会话，由主机进行读取。只要“data read”条件满足，该会话就会被重复，例如只要从卡接收到数据。
第三行表示执行并重复从主机到数据输入流的写入会话。只要“data in”条件满足，该会话就会被执行并重复，例如只要有数据要被发送给卡并且卡输入流未满。
第四行表示为存储在卡输入流中的数据执行并重复到结构化对象“qin”输入队列的反串行化会话，其中这些数据由一条“process(Object)”命令提取。只有“ok in”条件满足时，该会话才会被执行并重复，例如只要在卡输入流中有数据要被反串行化。
在被动的卡的例子中，例如符合JavaCard标准的情况，对象串行化操作的结束通常会启动对该对象的处理，例如通过自动调用“process(Object)”方法。
应该注意的是，在本例中只示出了在卡端执行的操作。在主机端执行的对称操作可以根据可用的硬件及软件资源按类似的方式或完全不同的方式实现，这样做不会偏离本发明的基本主旨。
由于这些各不相同的互补操作被交织在一个软件循环中，并且该循环可以被重复循环执行，因此一个结构化对象的传输过程所涉及的各个阶段可以在单次执行或单个传输指令的框架内并行执行。利用以循环形式存储的数据流，并无限重用相同的存储器空间，如上所述，同一个指令就可以启动结构化对象的完整传输，而且无论嵌入式平台性能如何有限，对对象的大小都没有限制。
上述转换操作都被实现(即编程)在一个或多个程序中，这些程序被载入主机与嵌入式平台，因此所述的程序可以由用户通过一些简单的指令来访问。
在此处所述的本发明版本中，就像应用到Java语言及JavaCard环境中的那样，应用程序程序员只需利用这少数几个简单的命令就可以创建应用程序。这些指令执行所有的中间操作，这些操作是对用户可见的。换句话说，用户不必关心所述指令机制的内部工作。
例如，被载入到处理站或主机终端中的“ObjectIOProxy”类提供了“WriteObject()”和“ReadObject()”命令。
同样，被载入到嵌入式平台中的“ObjectIOApplet”类也提供“Process(Object)”和“SendObject()”命令。通常，“ObjectIOApplet”类利用已知的扩展技术实现这些命令，即通过继承含有“process(APDU)”方法的“IOApplet”类来实现。这包括向该方法中添加与初始方法组合在一起的程序代码，并如初始方法中所定义的那样修改或替换代码的操作。
指令“WriteObject()”在其主机应用程序中被用户用来向卡应用程序发送结构化对象，以及在卡中开始进行处理。
在接收并反串行化一个结构化对象之后，所述的卡自动调用“Process(Object)”方法。该方法的内容可由用户编写在被载入嵌入式平台的应用程序部分之中，以便对该对象执行所需的操作。该方法接着以类似的方式被用于JavaCard中的标准“process(APDU)”命令，仅用于APDU格式的数据。
“SendObject()”指令被用户用在被载入到嵌入式平台的应用程序部分中，例如在“Process(Object)”方法代码内，以便准备从嵌入式平台向主机发送一个或多个结构化对象。该指令接着以类似的方式被用于JavaCard中的标准“sendAPDU()”命令，仅用于APDU格式的数据。
“ReadObject()”指令在其主机应用程序中被用户用来从嵌入式平台接收结构化对象，所述的结构化对象是卡应用程序为该目的准备的。
可以理解，对于程序员来说，创建一个涉及该类嵌入式平台的应用程序，用以在所述的嵌入式平台与主机或终端间传送结构化软件对象，即使所述嵌入式平台的通信资源不能以字节或整数形式传送数据，这样做也是较为容易的。
能用若干简单指令来解除结构化软件对象的分配，或是重置或清除相应的存储器空间，以及复制结构化软件对象，这一点对于嵌入式应用程序的程序员来说是很有帮助的。在所述嵌入式平台的编程环境不具有垃圾收集软件工具的情况下-例如在JavaCard环境中，这一点尤其重要，所述的软件工具能够管理已分配存储器空间的重用。
在符合本发明的一个程序版本中，在对象串行化期间用于结构化软件对象各个组件的解析步骤可以利用各种选项来完成。在同一个串行化命令的实现中可以包括多个这样的选项，该命令的每次执行都伴有一个参数，该参数指出必须使用哪个选项。这些各不相同的选项也可以被单独使用在串行化命令的不同实现中。
在一个这样的选项中，在对象串行化期间对该结构化软件对象的各个组成部分进行解析的时候，串行化主体(212)取消含有该组成部分的存储器空间的分配，或将所述的组成部分标为可以被重新用于新的分配。从而，使用该选项的串行化操作，称为解构串行化操作，执行结构化对象的转换，其后该对象所占用的存储器空间就会被释放。
在另一个版本中，符合本发明的程序可以包括一个选项或命令，该选项或指令在任何发送操作之外对储存在卡上的结构化对象执行该类解构性串行化操作，例如在“ObjectIOApplet”类的实现中。很容易理解的是，符合本发明的程序使得用户可以没有任何困难地重用被应用程序的全部或部分软件对象占用的存储器空间。
在另一个版本中(未示出)，符合本发明的程序包括一个选项或命令，该选项或命令通过重用卡内的存储器空间来对一个结构化对象进行反串行化，所述的存储器空间先前被一个结构化对象占用，而该对象已经被破坏，如上所述。该反串行化操作在任何发送操作之外执行，从一个含有完全相同或非实质性的数据的数据流进行。在分配并写入一个该类对象之后，被重用的存储器空间中不含有任何属于先前占用相关空间的对象的数据。如果该操作被实现，例如实现在“ObjectIOApplet”类中，那么符合本发明的程序就使得用户能够毫无困难地编写对应于指定位置的存储空间的全删除操作。
在另一个版本中(未示出)，符合本发明的程序包括一个选项或命令，该选项或命令在任何发送操作之外执行一个结构化对象到线性数据序列的串行化操作。然后，同一个线性数据序列被反串行化成一个与源对象相同的结果对象，但是它使用的不同的存储空间。如果该操作被实现，例如实现在“ObjectIOApplet”类中，那么符合本发明的程序就使得用户能够毫无困难地编写结构化软件对象的全复制操作。
对于该领域内的专家来说显而易见的是，本发明还提供了许多其他特定形式的版本，这样做没有偏离权利要求所提出的本发明的应用领域。因此，以上所说明的版本必须被看作是仅用于示范目的的，并且可以在附属权利要求的范围所定义的领域内被修改。因此，本发明不能被局限于以上所述的细节。
权利要求
1.供计算机基站(2)用来进行数据转换的过程，所述的计算机基站被称为“嵌入式平台”，它由一个便携对象构成，其中包括至少一个处理器、存储设备以及通信资源，所述的通信资源能够以一个或多个线性数据序列的形式与一台终端交换信息，所述过程的特征在于它包括一个数据集合的转换步骤，该转换步骤沿一个方向或另一个方向在一方和另一方之间进行转换，转换的一方是包括线性数据序列的排列，而另一方则是描述或代表一个或多个软件对象的结构化排列，该软件对象是根据一种面向对象编程语言的规范被结构化或层次化的。
2.根据上述权利要求所述的过程，其特征在于它包括下列步骤-把要被发送的第一数据集从一种描述或代表软件对象的结构化排列转换或串行化成一种代表所述第一数据集的线性数据序列，所述的第一数据集包括或代表了一个或多个软件对象(31，41)，这些软件对象是根据一种面向对象编程语言的规范被结构化或层次化的；-通过通信资源(200或100)将所述的线性数据序列从嵌入式平台(2)发送给至少一个主机(1)，即一台终端或与终端相连的工作站，或是从所述的主机(1)发送到嵌入式平台(2)；- 在发送之后，将该线性数据序列转换或反串行化成一个数据集，该数据集被排列成一个或多个结构化的软件对象(34或44)，这些软件对象重现或代表了所述第一数据集。
3.根据上述权利要求之一所述的过程，其特征在于所述的主机终端(1)利用一个软件主体(101)向所述的嵌入式平台(2)发送信息，该软件主体被称为发送函数，所述的信息在嵌入式平台中被一个响应函数(201)接收，该响应函数能够通过至少一个接收方软件主体(221)启动一个对所述数据的处理过程(2210)，所述的接收方软件主体被储存在嵌入式平台中，并且构成了至少一个应用过程(21)的一部分，所述的过程包括下列步骤- 由一个通信主体(211)代表接收方主体(221)接收数据集(32)，该数据集是由所述的响应函数(201)为所述的接收方软件主体接收的，所述的数据集被排列成一个线性数据序列；- 将该数据集转换成至少一个软件对象(34)，该软件对象根据一种面向对象编程语言的规范被结构化或层次化；- 将所述的结构化软件对象(34)发送给接收方主体(221)，并由所述的接收方主体根据所述对象启动一个处理过程(2210)。
4.根据上述权利要求之一所述的过程，其特征在于它包括下列步骤- 由响应函数(201)从主机(1)的发送函数(101)以至少一个发送参数(32)的形式接收至少一个数据项，并将该参数发送给一个储存或运行在嵌入式平台(2)上的通信主体(211)；- 由通信主体(211)将响应主体(201)发送来的至少一个发送参数(32)转换或连接成一个被排列成线性数据序列的数据集，并将这些数据储存在嵌入式平台(2)的输入流(33)中；- 由储存或运行在嵌入式平台(2)上的串行化主体(212)将储存在所述输入流(33)中的至少一部分数据转换或反串行化成一个数据集，该数据集包括或代表了至少一个结构化软件对象(34)；- 由所述的接收方主体(221)接收所述结构化软件对象(34)或其引用。
5.根据上述权利要求之一所述的过程，其特征在于它包括下列步骤- 从一个软件主体(221)向一个串行化主体(212)发送一个结构化软件对象(41)或其代表，所述的软件主体构成了储存或运行在嵌入式平台(2)上的应用过程(22)的一部分，而所述的串行化主体被储存或运行在所述的嵌入式平台上；- 由所述的串行化主体(212)将所述的结构化软件对象(41)转换或串行化成一个被排列成线性数据序列的数据集，并将这些数据储存在嵌入式平台上的一个输出流(42)中；- 由一个储存或运行在嵌入式平台(2)上的通信主体(211)将储存在所述输出流(42)中的数据的至少一部分转换成一个响应参数集(43)，该参数集能够被响应函数(201)发送；- 由响应函数(201)将所述的响应参数(43)从嵌入式平台(2)发送到主机终端(1)，该发送过程是响应函数主动进行或是响应于主机终端(1)的发送函数(101)而进行的。
6.根据上述权利要求之一所述的过程，其特征在于储存在输入流(33)或输出流(42)中的线性数据序列代表了一个或多个软件对象(31或41)，这些软件对象是利用一个或多个数据项被结构化或层次化了的，所述的数据项被称为标签，具有一个或多个给定值，所述每个指定值代表要对所述线性数据序列的反串行化执行的指定行为。
7.根据上述权利要求之一所述的过程，其特征在于至少一个标签被定义为代表下列行为之一- 向所述线性数据序列代表的结构化对象的结构中添加一个新元素；- 引用一个元素或对象，作为源对象，作为构成结构化对象的一个元素的全部或部分的值的源；- 指示出其后的一个或多个数据项代表了构成结构化对象的一个元素的内容；- 指示出构成结构化对象的一个元素的内容缺失。
8.根据上述权利要求之一所述的过程，其特征在于所述的串行化主体(212)在一个被称为串行化过程的过程之后将一个被称为源对象的结构化对象(41)串行化成一个线性数据集(42)，所述的过程通过下列步骤处理所述对象(410至414)中的至少一个，这些对象被称为元素，它们构成了所述结构化源对象(41)的结构或树状结构- 由串行化主体(212)检测出被称为当前对象的一个元素(410，414)的类型(4100)，所述元素构成所述结构化对象(41)的结构或树状结构；- 将代表一个标签的数据项存储在输出流(42)中，随后存放代表当前对象类型(TYOBJ)的数据项，所述标签指示添加一个新元素；- 由与当前对象类型(TYOBJ)相关联的类型串行化主体(TM0，TM1，TM2)在输出流中储存，在流中已有的元素之后● 或是通过一个代表结构化对象(41)的全部或部分(412，413，411)的值的数据项(424，425，429)，● 或是通过代表一个标签(4211)的数据项(4211，4212)，该标签指示引用一个对象(410)作为所述结构化对象(41)的全部或部分(414)的值的源，该标签之后跟随着标识所述源对象(410)的一个数据项(4212)。
9.根据上述权利要求之一所述的过程，其特征在于所述的串行化过程将一个结构化对象(41)转换到输出流(42)中，并在每次重复中将各个当前对象的类型储存在一个存储器堆栈(TYST)中，该堆栈被称为类型堆栈，读取该堆栈存储位置的顺序与存入顺序相反。
10.根据上述权利要求之一所述的过程，其特征在于所述的串行化主体(212)在一个被称为反串行化过程的过程之后将一个线性数据集反串行化成至少一个结构化结果对象(34)，所述的过程通过下列步骤处理储存在输入流(33)中的每个数据项-由串行化主体读取储存在输入流中先前已被处理过的数据之后的至少一个数据项；-分析该数据项并执行对应于所述数据项的行为。
11.根据上述权利要求之一所述的过程，其特征在于所述的反串行化过程涉及载入一个被称为当前对象的元素，即向所述当前对象的全部或部分指定一个直接或间接值，所述的元素构成结构化结果对象(34)的结构的全部或部分，随后当前对象的载入的结束而开始- 读取储存在存储器结构的下一个位置中的代表了一个对象类型的数据项(TYT2)，并从该位置删除该数据项，所述的存储器结构被称为类型堆栈(TYST)；- 将从类型堆栈中读出的数据项(TYT2)所代表的类型储存为新的当前对象类型(TYOBJ)。
12.根据上述权利要求之一所述的过程，其特征在于当所述的类型堆栈(TYST)为空时，反串行化过程所创建的结构化对象(34)被认为是完整的，并被发送给软件主体(221)或应用过程(22)，所述的软件主体或应用过程是所述对象的接收方。
13.根据上述权利要求之一所述的过程，其特征在于对应一个数据项(321，326)的反串行化行为包括下列步骤，所述的数据项代表一个被称为“NEW”的标签，该标签指示一个新元素- 读取输入流中的至少一个后续数据项(322，327)；- 将所述后续数据项(322，327)所代表的对象类型储存在一个存储器堆栈中，紧随已经被储存在其中的类型，所述的存储器堆栈被称为类型堆栈(TYST)。
14.根据上述权利要求之一所述的过程，其特征在于反串行化过程所用的类型堆栈(TYST)包括一个LIFO类型堆栈，即该堆栈中位置的读取顺序与储存顺序相反。
15.根据上述权利要求之一所述的过程，其特征在于所述的反串行化过程包括一个步骤，该步骤通过分配一个新的存储空间或重用一个自由空间，来创建构成所述结构化结果软件对象(34)结构的元素(410至414)，所述的创建步骤由一个对应于将被创建元素的类型的类型管理器主体(TM0，TM1，TM2)执行。
16.根据上述权利要求之一所述的过程，其特征在于构成所述结构化结果软件对象(34)结构的元素(410至414)的创建步骤是在表示所述元素创建的数据项(322，327)的读取步骤与用于同一个元素的第一载入步骤之间进行的。
17.根据上述权利要求之一所述的过程，其特征在于对应于一个数据项(324，325，329)的行为包括将该数据项的值储存到分配给当前对象的存储器空间中的步骤，所述的数据项被称为简单数据项，即它不代表一个标签。
18.根据上述权利要求之一所述的过程，其特征在于，在反串行化过程期间，为构成所述结构化结果对象(34)的结构的至少一个元素(410)分配一个对象标号(4102)，所述的对象标号以一种唯一的方式标识所述的元素，从而所述的元素可以被其他对象或元素(414)指定或引用。
19.根据上述权利要求之一所述的过程，其特征在于对应于一个数据项(3211)的行为包括下列步骤，所述的数据项代表一个被称为“REF”标签的标签，该标签表示一个引用- 读取输入流(32)中的至少一个后续数据项(3212)；- 将一个数据项储存在分配给当前对象(344)的存储器空间(3441)中，紧接着已被存储的数据，所述的数据项指定了一个对象(340)作为当前对象的所有或部分的值的源，所述的源对象或元素(340)由所述的后续数据项(3212)标识。
20.根据上述权利要求之一所述的过程，其特征在于当储存在指定存储器空间内的数据达到一个给定长度时，就考虑终止当前对象的载入，所述的长度由嵌入式平台中的类型管理器主体(TM0、TM1、TM2)或通用类型管理器主体(TMG)从卡(2)的存储器中读出。
21.根据上述权利要求之一所述的过程，其特征在于由嵌入式平台(2)向主机(1)发送一个给定长度的线性数据序列(42)是根据一个重复过程执行的，该过程被称为数据读取过程，其中包括下列重复步骤- 由主机发送一条通信指令，该指令伴有至少一个代表已接收数据长度的发送参数；- 由嵌入式平台接收所述的发送参数，并与待发送的线性数据序列进行比较；- 通过发送至少一个返回参数(43)来响应所述的通信指令，所述的返回参数代表紧接在主机已经接收到的数据之后的一个工多个数据项；- 由主机接收通信指令返回参数(43)，并将它代表的数据储存在已经接收到的数据之后。
22.根据上述权利要求之一所述的过程，其特征在于由嵌入式平台(2)从主机(1)接收一个给定长度的线性数据序列(43)，是根据一个重复过程执行的，该过程被称为数据写入过程，它包括下列重复步骤- 由主机发送一条通信指令，该指令伴有至少一个第一发送参数(32)，该参数代表了待发送的线性数据序列中紧接着已发送部分的一个或多个数据项，并且在适当的情况下，所述的指令还伴有一个第二发送参数，该参数代表了第一发送参数所代表的数据在待发送序列中的位置，或是已经被发送的数据长度；- 由嵌入式平台接收一个或多个通信指令发送参数(32)；- 将第一发送参数(32)所代表的数据储存在嵌入式平台的输入流(33)中，紧接着已接收数据之后。
23.根据上述权利要求之一所述的过程，其特征在于所述的数据写入过程还包括下列步骤- 由所述的嵌入式平台比较第二发送参数，以及比较已接收数据的长度；- 由所述的嵌入式平台返回至少一个响应参数，该响应参数或是代表已接收数据的长度，或是代表该比较结果的数据项，或者两者兼有。
24.根据上述权利要求之一所述的过程，其特征在于串行化、反串行化、数据读取或数据写入过程中的至少两个被并行执行，或是通过一个步骤的重复被交织进行，所述步骤包括连续执行每个所述过程的至少一个步骤。
25.根据上述权利要求之一所述的过程，其特征在于所述的输入流或输出流或两者，被储存为重复存储结构的形式，从而使得所述的两个流能够共享同一个重复结构。
26.根据上述权利要求之一所述的过程，其特征在于所述的嵌入式平台拥有一个可编程环境，它能够储存并执行至少一个由过程员创建的应用过程，所述的通信功能与ISO 7816标准中所定义的APDU格式相兼容。
27.根据上述权利要求之一所述的过程，其特征在于对于一个接收对象的反串行化与处理操作是由至少一条APDU格式命令的接收引起的，所述命令中包含至少一个指示结构化对象接收的数据项。
28.根据上述权利要求之一所述的过程，其特征在于所述的嵌入式平台拥有一个与JavaCard标准相兼容的可编程环境。
29.根据上述权利要求之一所述的过程，其特征在于在主机或嵌入式平台上运行的至少一个应用过程是用Java语言编写的。
30.根据上述权利要求之一所述的过程，其特征在于数据读取、数据写入、反串行化以及串行化过程都通过在至少一个类中的实现来完成，所述的类被储存在主机或嵌入式平台中，所述实现包括下列命令中的至少一条- 对象写入命令，通过对该对象使用串行化过程，并接着执行数据写入和反串行化过程，将一个结构化对象(31)发送给嵌入式平台的至少一个主体(221)；- 对象读取命令，通过使用串行化过程，并接着执行数据读取与反串行化过程，从嵌入式平台的至少一个主体(221)读取一个结构化对象(41)；- 用于储存在嵌入式平台中的结构化对象的解除分配命令，该指令利用了串行化过程，后者还包括在分析了所述组成部分的结构之后将分配给所述对象的各个组成部分的存储空间释放或解除分配的步骤；- 用于被一个结构化对象释放的存储空间的内部管理或删除命令，其通过利用反串行化过程从一个给定的线性数据序列创建一个具有非实质内容的对象；- 用于被称为源对象的结构化对象的复制命令，其利用串行化过程来创建一个代表同一对象的线性数据序列，但不对所述源对象进行解除分配，随后利用反串行化过程，从该线性数据序列创建另一个结构化对象，该对象的内容与源对象完全相同。
31.根据前面一个权利要求所述的过程，其特征在于所述嵌入式平台的编程语言中含有一个第一类(IOApplet)，该类描述了一种ProcessAPDU抽象方法，在接收到APDU消息时在应用过程中启动一个用户定义的进程；在嵌入式平台上执行反串行化操作的过程代码被储存在所述的嵌入式平台中，作为所述ProcessAPDU抽象方法的具体实现，在从第一类(IOApplet)继承而来的第二类(ObjectIOApplet)中，所述的过程代码调用一个ProcessObject方法，后者在同一实现类(ObjectIOApplet)中被描述为一个抽象方法。
32.根据权利要求(Javacard)所述的过程，其特征在于所述嵌入式平台的编程语言中含有一个第一类(IOApplet)，该类描述了一个SendAPDU方法，该方法将一个APDU格式消息发送给主机；在嵌入式平台上执行所述串行化操作的过程代码被储存在从第一类(IOApplet)继承而来的第二类(ObjectIOApplet)中，其作为调用SendAPDU方法的至少一个SendObject方法的具体实现。
33.根据上述权利要求之一所述的过程，其特征在于该过程被用于至少一个被称为卡主体的软件主体和至少一个被称为卡引擎代理主体的软件主体之间的通信，前者被储存或运行在嵌入式平台上，后者则被储存或执行在至少一台主机上，该主机属于一个计算机网络，该网络通过符合AAAMOM类软件基础设施的异步消息进行通信，所述的卡引擎代理主体为所述的卡主体与所述网络中其他主体间的通信起到了中介的作用，所述的主体根据所述软件基础设施的规范工作，并且该主体属于至少一个分布式的应用过程。
34.由一个计算机基站(2)构成的计算机系统，其被称为嵌入式平台，该嵌入式平台包括一个便携对象，该便携对象至少包含一个处理器、存储设备以及通信资源，所述的通信资源能够以一个或多个线性数据序列的形式与一个终端交换信息，其特征在于，该平台带有一个串行化主体(212)，它能够对一个数据集合沿一个方向或另一个方向在一方和另一方之间执行一个转换步骤，转换的一方是一种线性数据序列排列，另一方是描述或代表一个或多个软件对象的结构化排列，这种结构化排列是根据一种面向对象编程语言的规范被结构化或层次化的。
35.根据前一个权利要求所述的系统，其特征在于所述的嵌入式平台(2)包括一个通信主体(211)，该主体能够- 代表接收方主体(221)接收一个数据集(32)，该数据集是响应函数(201)为储存在嵌入式平台上的接收方软件主体(221)接收的，所述的数据集被排列成一个或多个线性数据序列；- 将所述的数据集转换成至少一个软件对象(34)，该软件对象根据一种面向对象编程语言的规范被结构化或层次化；- 将所述的结构化软件对象(34)发送给接收方主体(221)，并由所述的接收方主体(221)根据所述的对象开始执行进程(2210)。
36.根据前面的权利要求之一所述的系统，其特征在于代表一个结构化软件对象的线性数据序列被储存在嵌入式平台的一个输入或输出流中，所述的嵌入式平台包括一个被称为串行化主体(212)的软件主体，它能够创建嵌入式平台中的输入流所代表的一个或多个所述的结构化对象，即反串行化所述的结构化对象，或是将代表待发送的一个或多个结构化对象或待发送对象的数据写入到输出流中，即串行化所述的结构化对象。
37.根据上述权利要求之一所述的系统，其特征在于所述的输入流或输出流被储存成一个或多个重复存储结构的形式。
38.根据上述权利要求之一所述的系统，其特征在于所述的串行化主体(212)使用一个被称为类型堆栈的存储器堆栈来储存至少一个对象的类型，所述对象构成了要被串行化或反串行化的结构化对象的结构的全部或部分，所述的类型堆栈包括多个存储位置，这些存储位置只能在最近载入的存储位置被读出并删除之后才能被访问。
39.根据上述权利要求之一所述的系统，其特征在于包含在输入或输出流中的数据代表一个或多个结构化对象，其使用了一种包括一组标签的编码系统，每个所述的标签都代表一种要对所述线性数据序列的反串行化过程执行的一个给定行为。
40.根据上述权利要求之一所述的系统，其特征在于至少有一个标签被定义为代表下列行为之一- 向线性数据序列所代表的结构化对象结构中加入一个新元素；- 引用一个元素或对象，作为源对象，将其作为构成结构化对象的一个元素的全部或部分的值的源；- 指示出随后的一个或多个数据项代表了构成所述结构化对象的一个元素的内容；- 指示出构成所述结构化对象的一个元素的内容缺失。
41.根据上述权利要求之一所述的系统，其特征在于所述的嵌入式平台包括一个便携对象，该对象根据标准ISO 7816工作，并且使用APDU格式的指令。
42.根据上述权利要求之一所述的系统，其特征在于存储在嵌入式平台中的至少一个主体或应用过程是用Java语言编写的，所述的嵌入式平台拥有一个符合JavaCard标准的计算机环境。
43.根据上述权利要求之一所述的系统，其特征在于它在主机、嵌入式平台或两者中包括至少一个软件类，该软件类实现下列命令中的至少一条- 对象写入命令，通过在主机中将所述的结构化对象(31)串行化成一个数据流，并随后将该数据流发送给嵌入式平台，并在嵌入式平台中将所述的数据流反串行化成结构化对象，来把一个结构化对象(31)发送给所述卡的至少一个主体；- 对象读取命令，通过在嵌入式平台中将所述的结构化对象串行化成一个数据流，并随后从嵌入式平台接收该数据流，并在主机中将所述的数据流反串行化成一个结构化对象，来从所述卡的至少一个主体(221)读取一个结构化对象(41)；- 解除分配命令，用于储存在嵌入式平台中的结构化对象，该指令根据一个选项串行化所述的对象，所述的选项包括在分析了所述对象各部分的结构之后释放或解除分配给该对象各个部分的存储空间；- 用于被嵌入式平台中的一个结构化对象释放的存储空间的内部管理或删除命令，该指令通过反串行化一个给定的线性数据序列来创建一个具有非实质内容的对象；- 用于在嵌入式平台中复制结构化对象的指令，被复制的对象称为源对象，该指令通过串行化为代表同一个对象的线性数据序列，但不对所述源对象进行解除分配，随后将该线性数据序列反串行化成另一个结构化对象，该对象的内容与源对象完全相同。
44.根据上述权利要求之一所述的系统，其特征在于所述的嵌入式平台与至少一台属于某个计算机网络的主机进行通信，所述网络通过符合AAA-MOM类型软件基础设施的异步消息进行通信，所述的主机包括一个被称为卡引擎代理主体的软件主体，该软件主体能够管理所述嵌入式平台与所述网络中其他主体间的通信，所述的主体根据所述软件基础设施的规范进行工作，并且属于至少一个分布式的应用过程。
全文摘要
本发明涉及用来将结构化软件对象转换成原始数据流以及进行反向转换的循环程序，该程序利用简单的通信资源－如嵌入式计算机基站－来提供它们(数据流)的直接传输，还提供所述软件对象的重置，或是对分配给它们的存储器空间的重用。该程序可被嵌入式平台(2)或便携对象使用，所述的便携对象至少包括一个处理器，该处理器能够以线性数据序列的形式与一台终端交换信息。该程序包括用来向一个方向或另一个方向转换数据集的步骤，转换的一方是线性数据序列组织形式，另一方是描述或代表一个面向对象的软件对象的结构化组织形式。
文档编号G07F7/10GK1643552SQ03807289
公开日2005年7月20日 申请日期2003年2月26日 优先权日2002年2月28日
发明者奥利维尔·法布恩, 安德烈·弗雷西内, 塞尔日·拉库尔特 申请人:艾斯奥托公司