What is the difference between Serialization and M

2019-05-12 14:54发布

站内文章 / 前端开发
27 0 0

我知道，在多个分布式技术（如RPC）的术语，术语“编组”使用，但不明白它是从序列化的不同之处。 难道他们都转化成对象一系列的位？

有关：

什么是序列化？

什么是对象编组？

Answer 1:

编组序列化是在远程过程调用的情况下松散的代名词，而是意图的问题语义不同。

特别地，编组是有关获取参数从这里到那里，而串行化是关于结构化数据复制到或从原始的形式，例如作为字节流。 在这个意义上，序列是一个单元进行编组，通常是通过执行按值语义。

另外，也可以用于其目的在于通过引用编组，在这种情况下“在电线上”的数据只是为原始对象的位置信息。 然而，这样的对象可能仍然适合于值序列化。

如@Bill提及，可能有额外的元数据，诸如代码基础位置或甚至对象实现代码。



Answer 2:

无论做一个共同点-那就是序列化对象。 序列化是用来转移对象，或者存储它们。 但：

  • 序列：当您序列化一个对象，只有对象内的部件数据被写入字节流; 没有实际实现的对象的代码。
  • 编组：当我们谈论的对象传递到远程对象（RMI）项编组使用。 在编组对象被序列（构件数据被串行化）+基本代码被安装。

所以序列化是编组的一部分。

代码库 ，告诉对象的接收器，其中该对象的实现可以找到的信息。 任何计划，认为它可能永远传递一个对象可能没见过它之前必须设置代码库，从而使接收器可以知道从哪里下载的代码，如果没有可用的本地代码另一个程序。 接收器将，在反序列化对象，取从它代码库，并从该位置加载的代码。



Answer 3:

从编组（计算机科学），维基百科的文章：

术语“元帅”被认为是在Python标准库“连载”的代名词1 ，但条件是不能在与Java相关的RFC 2713的代名词：

到“编组”的对象是指，当编组对象是“解组”，是通过自动加载对象的类定义获得的原始对象的一个​​副本，可能这样的方式来记录它的状态和基本代码（一个或多个）。 你可以封送任何对象，序列化或远程。 编组站就像系列化，除了编组也记录代码库。 编组站是在编组对待远程对象特地从系列化不同。 （RFC 2713）

“串行化”的对象是指将其状态转换成字节流以这样的方式，该字节流可以被转换回对象的一个​​副本。

因此，编组也节省除了其状态字节流中的对象的代码 。



Answer 4:

我认为，主要区别是，据说编组站也涉及到代码库。 换句话说，你将无法进行编组和解组对象分成不同的类的状态相当于实例。 。

序列化只是意味着你可以存储对象和reobtain等效的状态，即使它是另一个类的一个实例。

话虽这么说，他们通常是同义词。



Answer 5:

编组指函数的签名和参数转换成一个单一的字节数组。 专门为RPC的目的。

序列化更经常是指将整个对象/对象树到字节数组 编组将依次将它们添加到所述消息，并通过网络传递序列化对象的参数。 *序列化也可以用于存储到磁盘。*



Answer 6:

编组站是规则告诉编译器如何的数据将在另一个环境/系统来表示; 例如; 

[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
public string cFileName;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)]
public string cAlternateFileName;

你可以看到两个不同的字符串值表示为不同的值类型。

序列化只会转换的对象内容，不表示（将保持相同），并服从系列化的规则，（什么出口或无）。 例如，私人值将不被序列化，公共价值是客体结构将保持不变。



Answer 7:

编组通常相对紧密相关的进程之间是; 序列化不一定有预期。 所以编组进程之间的数据时，例如，您可能希望只发送参考潜在昂贵的数据恢复，而与系列化，你会想保存这一切，反序列化时正确重建对象（或多个）。



Answer 8:

下面是两个更具体的例子：

序列化实施例： 

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

typedef struct {
    char value[11];
} SerializedInt32;

SerializedInt32 SerializeInt32(int32_t x) 
{
    SerializedInt32 result;

    itoa(x, result.value, 10);

    return result;
}

int32_t DeserializeInt32(SerializedInt32 x) 
{
    int32_t result;

    result = atoi(x.value);

    return result;
}

int main(int argc, char **argv)
{    
    int x;   
    SerializedInt32 data;
    int32_t result;

    x = -268435455;

    data = SerializeInt32(x);
    result = DeserializeInt32(data);

    printf("x = %s.\n", data.value);

    return result;
}

在串行化，数据以可以存储和非平坦后的方式压平。

编组演示：

（MarshalDemoLib.cpp） 

#include <iostream>
#include <string>

extern "C"
__declspec(dllexport)
void *StdCoutStdString(void *s)
{
    std::string *str = (std::string *)s;
    std::cout << *str;
}

extern "C"
__declspec(dllexport)
void *MarshalCStringToStdString(char *s)
{
    std::string *str(new std::string(s));

    std::cout << "string was successfully constructed.\n";

    return str;
}

extern "C"
__declspec(dllexport)
void DestroyStdString(void *s)
{
    std::string *str((std::string *)s);
    delete str;

    std::cout << "string was successfully destroyed.\n";
}

（MarshalDemo.c） 

#include <Windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

int main(int argc, char **argv)
{
    void *myStdString;

    LoadLibrary("MarshalDemoLib");

    myStdString = ((void *(*)(char *))GetProcAddress (
        GetModuleHandleA("MarshalDemoLib"),
        "MarshalCStringToStdString"
    ))("Hello, World!\n");

    ((void (*)(void *))GetProcAddress (
        GetModuleHandleA("MarshalDemoLib"),
        "StdCoutStdString"
    ))(myStdString);

    ((void (*)(void *))GetProcAddress (
        GetModuleHandleA("MarshalDemoLib"),
        "DestroyStdString"
    ))(myStdString);    
}

在编组中，数据不一定必须以进行整平，但它需要被转换成另一个替换表示。 所有铸件编组，但并非所有的封送处理是铸造。

整编并不需要动态分配的参与，也可以只是结构之间的转换。 例如，你可能有一对，但功能预计对的第一和第二元素是周围的其他方式; 您铸造/ memcpy的一对到另一不会做的工作，因为FST和苏州高新区将得到翻转。 

#include <stdio.h>

typedef struct {
    int fst;
    int snd;
} pair1;

typedef struct {
    int snd;
    int fst;
} pair2;

void pair2_dump(pair2 p)
{
    printf("%d %d\n", p.fst, p.snd);
}

pair2 marshal_pair1_to_pair2(pair1 p)
{
    pair2 result;
    result.fst = p.fst;
    result.snd = p.snd;
    return result;
}

pair1 given = {3, 7};

int main(int argc, char **argv)
{    
    pair2_dump(marshal_pair1_to_pair2(given));

    return 0;
}

编组的概念变成当你开始处理多种类型的标签联合尤为重要。 例如，你可能会发现它很难得到一个JavaScript引擎打印“C字符串”为你，但你可以要求它打印封装的C字符串为您服务。 或者，如果你想打印从JavaScript运行中的字符串一个Lua或Python运行时。 他们都是字符串，但没有编组往往不会相处。

一个烦恼我最近是JScript的数组元帅C＃作为“__ComObject”，并没有记录的方式与该对象玩。 我能找到的地方是地址，但我真的不知道任何关于它，所以要真正弄明白的唯一方式是它在任何可能的方式去捅，希望找到有用的信息。 因此，它变得更容易地创建一个新的对象与像一个的Scripting.Dictionary友好的界面，从JScript数组对象中的数据复制到它，这对象传递给C＃，而不是JScript中的默认阵列。

test.js： 

var x = new ActiveXObject("Dmitry.YetAnotherTestObject.YetAnotherTestObject");

x.send([1, 2, 3, 4]);

YetAnotherTestObject.cs 

using System;
using System.Runtime.InteropServices;

namespace Dmitry.YetAnotherTestObject
{
    [Guid("C612BD9B-74E0-4176-AAB8-C53EB24C2B29"), ComVisible(true)]
    public class YetAnotherTestObject
    {
        public void send(object x)
        {
            System.Console.WriteLine(x.GetType().Name);
        }
    }
}

上述打印“__ComObject”，这是有点黑盒的从视图的C＃的点。

另一个有趣的概念是，你可能有了解如何编写代码，并知道如何执行指令，所以作为一个程序员，您实际上编组你想要的电脑什么概念，从你的大脑做了程序的计算机图片。 如果我们有足够好的marshallers，我们可以只想到了什么，我们想要做的/变化，该方案将改变这种方式，而不在键盘上键入。 所以，如果你能有一种方法来存储在你的大脑的几秒钟，你真的想写一个分号的所有物理变化，你可以封送数据转换成信号打印分号，但这是一个极端。



Answer 9:

我的编组的理解是对其他的答案不同。

连载：

生产或再水化利用公约一个对象图的线格式的版本。

编组：

以产生或通过利用一个映射文件再水化的对象图的线格式的版本，使得结果可被定制。 该工具可以通过遵守公约启动，但重要的区别是自定义的结果的能力。

契约优先的发展：

编组站是合同第一个发展的环境中很重要的。

  • 其能够使改变到内部对象图，同时保持外部接口随时间稳定。 这样，所有的服务用户将不必修改每一个微不足道的变化。
  • 它可以映射不同语言的结果。 例如从一种语言（“PROPERTY_NAME”）到另一个（“propertyName的”）的属性命名约定。


Answer 10:

认为他们是同义词，都具有在给消费者发送的东西制片人......在实例中的最后场被写入字节流，另一端的敌人逆ANDS了同样的情况。

NB - Java RMI的还包含运输是从收件人缺少类的支持...



Answer 11:

编组使用序列的过程实际上但主要区别在于，它的序列化只是数据成员和对象本身获取序列化而不是签名，但在编组对象+代码库（及其实施）也将得到改造成字节。

编组站是java对象转换为使用JAXB，以便它可以在Web服务中使用XML对象的过程。



文章来源: What is the difference between Serialization and Marshaling?
标签： serialization terminology marshalling rpc
举报

收藏的人(0)

Ta的文章 更多文章
登录 后发表评论
0条评论
还没有人评论过~