精华内容
下载资源
问答
  • Protostuff详解

    千次阅读 2016-09-26 17:39:05
    一、Protostuff介绍 Protostuff是一个开源的、基于Java语言的序列化库,它内建支持向前向后兼容(模式演进)和验证功能。 Protostuff支持的序列化格式包括: protobufprotostuffgraph  即序列化对象图,...

    一、Protostuff介绍

    Protostuff是一个开源的、基于Java语言的序列化库,它内建支持向前向后兼容(模式演进)和验证功能。

    Protostuff支持的序列化格式包括:

    • protobuf
    • protostuff
    • graph 
      即序列化对象图,即带循环引用的protostuff。详见:http://www.protostuff.io/documentation/object-graphs/
    • json
    • smile 
      即二进制json,从protostuff-json模块中使用。Smile数据格式是由Jackson JSON库开发团队于2010年发布的数据格式,并在Jackson 1.6版本开始使用此格式。 
      Smile格式规范:http://wiki.fasterxml.com/SmileFormatSpec 
      与此相似的有BSON格式,见:http://bsonspec.org/ 
      要注意一点,Smile数据格式和BSON数据格式是互不兼容的。比如BSON定义了日期类型,而Smile没有日期类型。而且,有时候BSON数据格式占用的空间比原生JSON占用的空间更多。所以,对于二进制JSON来说,Smile才是更好的选择。 
      可以参考通用二进制JSON规范《Universal Binary JSON Specification》:http://ubjson.org/
    • xml
    • yaml 
      只支持序列化
    • kvp 
      即二进制的uwsgi头部(Header),详见:http://projects.unbit.it/uwsgi

    二、Protostuff特征

    1、支持protostuff-compiler产生的消息

    2、支持现有的POJO

    3、支持现有的protoc产生的Java消息

    4、与各种移动平台的互操作能力(Android、Kindle、j2me)

    5、支持转码

    三、Protostuff的模块

    1、protostuff-api模块

    面向消息和POJO(message/pojo)的序列化API,内建了对模式演进的支持。 
    可以与现有对象一起工作,只需添加模式Schema。可以通过代码生成、在运行时使用protostuff-runtime生成、或者是手写产生。

    2、protostuff-core模块

    绑定了三种二进制格式:protostuff、graph、protobuf。

    protostuff与protobuf的区别: 
    1)protobuf有一个名为“group”的编码类型域,而protostuff使用它作为嵌套的消息。 
    2)protostuff可以使用尾部界定符来处理消息流(Stream)。 
    3)protostuff的一级类在本地格式中支持循环引用。

    3、protostuff-runtime模块

    自动启用现有的POJO序列化/反序列化为各种格式。 
    可使用运行时序列化策略,w/c通过系统属性进行配置。 
    依赖于protostuff-API和protostuff-collectionschema。

    4、protostuff-json模块

    面向消息或POJO的JSON序列化/反序列化。 
    面向标量域的向前向后兼容。 
    依赖于protostuff-api、jackson-core-asl-1.7.9。如果使用了Smile格式,还需jackson-smile-1.7.9。

    5、protostuff-parser模块

    使用了ANTLR V3、面向.proto文件的词法/语法解析器。 
    供protostuff-compiler使用。

    6、protostuff-compiler模块

    面向.proto源文件的编译器。 
    可以从文件系统、类路径或从网络HTTP URL中载入.proto源文件。 
    可使用参数-Dproto_path=$path告诉编译器从哪里载入源文件。 
    可扩展/定制编译的输出。 
    要编译源文件,执行命令: 
    java -jar protostuff-compiler-1.0.9.jar 
    protostuff.properties属性文件定义:

    modules = foo
    foo.source = path/to/your/foo.proto
    #java_bean, gwt_overlay, java_v2protoc_schema
    foo.output = java_bean
    foo.outputDir = generated
    foo.options = some_key,key:value,another_key
    

    依赖于protostuff-parser模块。

    7、protostuff-me模块

    对于j2me应用,无需外部依赖 
    与api模块和core模块结合一起使用,去掉了Java泛型支持。

    四、模式Schema

    Schema包含: 
    1)对象进行序列化的逻辑 
    2)对象进行反序列化的逻辑 
    3)对象必填字段的验证 
    4)对象字段名称到字段编号的映射 
    5)对象的实例化

    对于现有的对象,必须使用protostuff-runtime来生成Schema——可以通过反射来缓存、使用Schema。 
    开发者更喜欢自定义Schema,比如对必填字段的验证等,那么可以手动编码。

    展开全文
  • Protostuff序列化

    千次阅读 2016-04-15 14:37:16
    这几天在看rpc框架的东西,一哥们写的轻量级rpc框架(http://my.oschina.net/huangyong/blog/361751?fromerr=NpC3phqY)实现,写的rpc很不错,就跟着撸了遍代码,里面用到的序列化工具是protostuff,之前我们项目...

    这几天在看rpc框架的东西,一哥们写的轻量级rpc框架(http://my.oschina.net/huangyong/blog/361751?fromerr=NpC3phqY)实现,写的rpc很不错,就跟着撸了遍代码,里面用到的序列化工具是protostuff,之前我们项目供应商接口用的xml,没用过protostuff,拿过来研究下,写个demo示例,以后再需要的话,也可以拿过来用。

    常用的序列化基本是xml,protobuf,protostuff,xml用起来简单方便,顺手就用,但是序列化/反序列化的性能不行,protobuf,Google出品,性能比xml肯定好,用于不同语言,不同平台的交互,需要预编译,用起来麻烦,改的东西都要编译下,感觉不适合数据结构经常变动,后来就来了protostuff,无需预编译,就可以对javabean进行序列化和反序列化,性能更好。

    上代码,添加maven依赖:

    	<!-- Protostuff -->
    	<dependency>
    	    <groupId>com.dyuproject.protostuff</groupId>
    	    <artifactId>protostuff-core</artifactId>
    	    <version>1.0.8</version>
    	</dependency>
    	<dependency>
    	    <groupId>com.dyuproject.protostuff</groupId>
    	    <artifactId>protostuff-runtime</artifactId>
    	    <version>1.0.8</version>
    	</dependency>
    	
    		<!-- Objenesis -->
    	<dependency>
    	    <groupId>org.objenesis</groupId>
    	    <artifactId>objenesis</artifactId>
    	    <version>2.1</version>
    	</dependency>

    ps:一般反射实例化java类的时候,newInstance如果java类没有默认构造函数,肯定不行,而objenesis用来对实例化java类,无需默认构造函数,官网:http://objenesis.org/tutorial.html,用起来很简单

    SerializationUtils,序列化工具类,上面那个哥们rpc里面用的:

    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    
    import org.objenesis.Objenesis;
    import org.objenesis.ObjenesisStd;
    
    import com.dyuproject.protostuff.LinkedBuffer;
    import com.dyuproject.protostuff.ProtostuffIOUtil;
    import com.dyuproject.protostuff.Schema;
    import com.dyuproject.protostuff.runtime.RuntimeSchema;
    
    public class SerializationUtils {
    
        private static Map<Class<?>, Schema<?>> cachedSchema = new ConcurrentHashMap<Class<?>, Schema<?>>();
        
        private static Objenesis objenesis = new ObjenesisStd(true);
        
        private SerializationUtils(){
        }
        
        @SuppressWarnings("unchecked")
        private static <T> Schema<T> getSchema(Class<T> cls){
            Schema<T> schema = (Schema<T>)cachedSchema.get(cls);
            if(schema == null){
                schema = RuntimeSchema.createFrom(cls);
                if(schema != null){
                    cachedSchema.put(cls, schema);
                }
            }
            return schema;
        }
        
        @SuppressWarnings("unchecked")
        public static <T> byte[] serializer(T obj){
            Class<T> cls = (Class<T>) obj.getClass();
            LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
            try{
                Schema<T> schema = getSchema(cls);
                return ProtostuffIOUtil.toByteArray(obj, schema, buffer);
            }catch (Exception e) {
                throw new IllegalStateException(e.getMessage(), e);
            }finally{
                buffer.clear();
            }
        }
        
        public static <T> T deserializer(byte[] data, Class<T>cls){
            try{
                T message = (T)objenesis.newInstance(cls);
                Schema<T> schema = getSchema(cls);
                ProtostuffIOUtil.mergeFrom(data, message, schema);
                return message;
            }catch (Exception e) {
                throw new IllegalStateException(e.getMessage(), e);
            }
        }
    }

    下面是几个javabean

    public class OrderInfo {
        /**
         * 订单流水
         */
        private String orderNo;
        /**
         * 订单概要信息
         */
        private Map<String, Object> orderItem;
        /**
         * 订单扩展信息
         */
        private List<OrderExt> orderExts;
        
        /**
         * 收货信息
         */
        private DelieryAddress address;
    
        //getter,setter,toString方法

    public class OrderExt {
        /**
         * 订单流水
         */
        private String orderNo;
        /**
         * 商品编码
         */
        private String goodsNo;
        
        //getter,setter,toString方法

    public class DelieryAddress {
    
        /**
         * 收货地址
         */
        private String address;
        /**
         * 收货人
         */
        private String consigneeName;
        /**
         * 送达时间
         */
        private Date expectTime;
        
        //getter,setter,toString方法

    测试类:

    public class ProtostuffTest {
    
        public static void main(String[] args) {
            OrderInfo oldOrder = createOrder();
            System.out.println(oldOrder);
            
            byte[] orderinfo = SerializationUtils.serializer(oldOrder);
            
            OrderInfo neOrder = SerializationUtils.deserializer(orderinfo, OrderInfo.class);
            
            System.out.println(neOrder);
            System.out.println(neOrder.getOrderNo() == null ? "y" : "n");
        }
        
        private static OrderInfo createOrder(){
            OrderInfo orderInfo = new OrderInfo();
            DelieryAddress delieryAddress = new DelieryAddress();
            List<OrderExt> orderExts = new LinkedList<OrderExt>();
            
            for(int i=0; i<2; i++){
                OrderExt orderExt = new OrderExt();
                orderExt.setGoodsNo("343434");
                orderExt.setOrderNo("12345");
                orderExts.add(orderExt);
            }
            
            delieryAddress.setAddress("江苏南京");
            delieryAddress.setConsigneeName("熊猫");
            delieryAddress.setExpectTime(new Date());
            
            Map<String, Object> orderItem = new HashMap<String, Object>();
            orderItem.put("google","google.com");
            orderItem.put("baidu", "baidu.com");
            
            orderInfo.setOrderItem(orderItem);
            orderInfo.setAddress(delieryAddress);
            orderInfo.setOrderExts(orderExts);
            
            return orderInfo;
        }
    
    }

    主要测试javabean字段里面null/string/list/map或其他javabean做为参数,看看是否能够正确序列化和反序列。

    结果完全没问题:



    参考:

    http://my.oschina.net/huangyong/blog/361751?fromerr=NpC3phqY

    http://www.cnblogs.com/xiaoMzjm/p/4555209.html 对xml,protobuf,protostuff的序列化/反序列性能做了一些对比测试

    展开全文
  • 我推荐使用Protostuff,其性能稍弱与colfer,但对开发者很友好,同时性能远远高于JDK提供的Serializable。 添加依赖: < dependency > < groupId > io.protostuff groupId > < artifactId > ...

    熟悉Java的朋友应该知道Java有一个叫序列化的技术,即把一个Object转换为可保存,可传输的流数据。相应的,同时存在反序列化,即将流数据转换为Object类,而在转换的过程中,该Object保持者其自身的状态。不会应该序列化或者反序列化而丢失。通常在缓存中,RPC(远程调用),或者长久保存会话信息时,大有用处。

    关于序列化的时候,大部分情况下想到的是对于需要序列化的对象实现Serializable标志接口,同时为该对象提供一个唯一的serialVersionUID。

    示例代码

    public class Person implements Serializable {  
     private static final long serialVersionUID = -763618247875550322L;
        private String name;  
    
        public String getName() {  
            return name;  
        }  
        public void setName(String name) {  
            this.name = name;  
        }  
    }  
    import java.io.FileInputStream;  
    import java.io.FileOutputStream;  
    import java.io.ObjectInputStream;  
    import java.io.ObjectOutputStream;  
    
    public class WhySerialversionUID {  
    
    public static void main(String[] args) throws Exception {  
    
    //这里是把对象序列化到文件         
    Person crab = new Person();  
    crab.setName("kaka");  
    
    ObjectOutputStream oo = new ObjectOutputStream (new FileOutputStream("kakaFile"));  
    oo.writeObject(crab);  
    oo.close();  
    
    //这里是把文件序列化到对象
    ObjectInputStream oi = new ObjectInputStream (new FileInputStream("kakaFile"));  
    Person kaka = (Person) oi.readObject();  
    //输出为Hi, My name is kaka
    System.out.println("Hi, My name is " + kaka.getName());  
    oi.close();  
        }  
    }  

    看起来使用JDK提供的序列化技术没有什么问题,其实不然。JDK提供的序列化技术相对而已效率较低。在转换二进制数组过程中空间利用率较差。github上有个专门对比序列化技术做对比的数据:https://github.com/eishay/jvm-serializers/wiki

    其中看的出来性能最优的为google开发的colfer 。这个框架尽管性能优秀,但它太过于灵活,灵活到Schema都要开发者自己指定,所以对开发者不是很友好。我推荐使用Protostuff,其性能稍弱与colfer,但对开发者很友好,同时性能远远高于JDK提供的Serializable。

    添加依赖:

            <dependency>
                <groupId>io.protostuff</groupId>
                <artifactId>protostuff-core</artifactId>
                <version>1.4.4</version>
            </dependency>
            <dependency>
                <groupId>io.protostuff</groupId>
                <artifactId>protostuff-runtime</artifactId>
                <version>1.4.4</version>
            </dependency>

    简单使用:

    private static RuntimeSchema<Person> schema = RuntimeSchema.createFrom(Person.class);
    /**
    *序列化
    */
    Person crab = new Person();  
    crab.setName("kaka");  
    //参数三缓冲器
    byte[] bytes = ProtostuffIOUtil.toByteArray(crab,schema,LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE));
    /**
     *反序列化
     */
    // 空对象
    Person newCrab = schema.newMessage();
    ProtostuffIOUtil.mergeFrom(bytes,newCrab,schema);
    System.out.println("Hi, My name is " + newCrab.getName());
    展开全文
  • 而Java默认的序列化机制效率太低,protobuf要写protostuff文件,又很麻烦,所以我这篇文章要介绍的就是——protostuff. 1、protostuff简介 在序列化文件不超过10M的时候最好还是使用Java自带的序列化机制。文件较大...

    Java的序列化是在文件传输中必不可少的一部分。常用的Java序列化机制有Java默认的序列化机制,谷歌的protobuf等。而Java默认的序列化机制效率太低,protobuf要写protostuff文件,又很麻烦,所以我这篇文章要介绍的就是——protostuff.
    1、protostuff简介
    在序列化文件不超过10M的时候最好还是使用Java自带的序列化机制。文件较大的时候用protostuff传输更好。
    protostuff也是谷歌的产品旗下的,它是从谷歌的protobuf而来的,相对于protobuf提供了更多的功能和更简易的用法。
    2、使用protostuff
    (1)添加依赖
    这里用maven,直接添加依赖。如果你没有maven,在百度上搜索相应的jar包就好了。

        <!--引入protostuff依赖-->
            <dependency>
                <groupId>io.protostuff</groupId>
                <artifactId>protostuff-core</artifactId>
                <version>1.6.0</version>
            </dependency>
     
            <dependency>
                <groupId>io.protostuff</groupId>
                <artifactId>protostuff-runtime</artifactId>
                <version>1.6.0</version>
            </dependency>
    

    (2)定义要序列化的Bean
    可以用注解等方式,这里就不再详细给出Bean的定义及实例化,详情可跳往Spring简述一
    (3)

    package org.boot.protostuff.util;
     
    import io.protostuff.LinkedBuffer;
    import io.protostuff.ProtostuffIOUtil;
    import io.protostuff.Schema;
    import io.protostuff.runtime.RuntimeSchema;
     
    import java.util.Map;
    import java.util.Objects;
    import java.util.concurrent.ConcurrentHashMap;
     
    
    public class ProtostuffUtils {
        /**
         * 避免每次序列化都重新申请Buffer空间
         */
        private static LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
        /**
         * 缓存Schema
         */
        private static Map<Class<?>, Schema<?>> schemaCache = new ConcurrentHashMap<>();
     
         // 序列化方法,把指定对象序列化成字节数组
        
        @SuppressWarnings("unchecked")
        public static <T> byte[] serialize(T obj) {
            Class<T> clazz = (Class<T>) obj.getClass();
            Schema<T> schema = getSchema(clazz);
            byte[] data;
            try {
                data = ProtostuffIOUtil.toByteArray(obj, schema, buffer);
            } finally {
                buffer.clear();
            }
     
            return data;
        }
     
     
        //反序列化方法,将字节数组反序列化成指定Class类型
        public static <T> T deserialize(byte[] data, Class<T> clazz) {
            Schema<T> schema = getSchema(clazz);
            T obj = schema.newMessage();
            ProtostuffIOUtil.mergeFrom(data, obj, schema);
            return obj;
        }
     
        @SuppressWarnings("unchecked")
        private static <T> Schema<T> getSchema(Class<T> clazz) {
            Schema<T> schema = (Schema<T>) schemaCache.get(clazz);
            if (Objects.isNull(schema)) {
                //这个schema通过RuntimeSchema进行懒创建并缓存
                //所以可以一直调用RuntimeSchema.getSchema(),这个方法是线程安全的
                schema = RuntimeSchema.getSchema(clazz);
                if (Objects.nonNull(schema)) {
                    schemaCache.put(clazz, schema);
                }
            }
     
            return schema;
        }
    }
    

    这里其实就是一个工具类,可以直接调用。下面我将对里面的方法一一讲解
    (1)LinkedBUffer字段
    社情一个内存空间用户缓存,LinkedBuffer.DEFAULT_BUFFER_SIZE 默认申请了512个字节,我们也可以使用MIN_BUFFER_SIZE ,256个字节。
    (2)schemaCache字段
    表示缓存的Schema。在这里代表了序列化对象的结构。
    (3)serialize方法
    序列化方法,西安获得需要序列化的类,然后为它分配一个缓存空间,然后获得此类的Schema.最后一行的代码ProtostuffIOUtil.toByteArray进行序列化。

    public static <T> byte[] serialize(T obj) {
            Class<T> clazz = (Class<T>) obj.getClass();
            Schema<T> schema = getSchema(clazz);
            byte[] data;
            try {
                data = ProtostuffIOUtil.toByteArray(obj, schema, buffer);
            } finally {
                buffer.clear();
            }
     
            return data;
        }
    

    (4)deserialize
    表示反序列化,根据序列化对象获取其组织结构Schema。然后根据byte直接mergeFrom成对象

     public static <T> T deserialize(byte[] data, Class<T> clazz) {
            Schema<T> schema = getSchema(clazz);
            T obj = schema.newMessage();
            ProtostuffIOUtil.mergeFrom(data, obj, schema);
            return obj;
        }
    

    (5)getSchema
    获取序列化对象的组织结构

    private static <T> Schema<T> getSchema(Class<T> clazz) {
            Schema<T> schema = (Schema<T>) schemaCache.get(clazz);
            if (Objects.isNull(schema)) {
                //这个schema通过RuntimeSchema进行懒创建并缓存
                //所以可以一直调用RuntimeSchema.getSchema(),这个方法是线程安全的
                schema = RuntimeSchema.getSchema(clazz);
                if (Objects.nonNull(schema)) {
                    schemaCache.put(clazz, schema);
                }
            }
     
            return schema;
        }
    }
    

    3、protoStuff实现序列化的原理
    在上面的序列化方法中,我们可以看到其实最核心的就是

    data = ProtostuffIOUtil.toByteArray(obj, schema, buffer);
    

    我们进到这个方法里

      public static <T> byte[] toByteArray(T message, io.protostuff.Schema<T> schema, LinkedBuffer buffer) {
        if (buffer.start != buffer.offset) {
            throw new IllegalArgumentException("Buffer previously used and had not been reset.");
        } else {
            ProtostuffOutput output = new ProtostuffOutput(buffer);
    
            try {
                schema.writeTo(output, message);
            } catch (IOException var5) {
                throw new RuntimeException("Serializing to a byte array threw an IOException (should never happen).", var5);
            }
    
            return output.toByteArray();
        }
    }
    

    可以看到

    schema.writeTo(output, message);
    

    再追进去

    public interface Schema<T> {
    String getFieldName(int var1);
    
    int getFieldNumber(String var1);
    
    boolean isInitialized(T var1);
    
    T newMessage();
    
    String messageName();
    
    String messageFullName();
    
    Class<? super T> typeClass();
    
    void mergeFrom(Input var1, T var2) throws IOException;
    
    void writeTo(Output var1, T var2) throws IOException;
    

    }

    再追进去我们就会看到它其实就是把序列化对象信息保存成CharSequence ,然后进行序列化
    同理追到反序列化。
    putObject(message,offset,input,readString());

      public static <T> void mergeFrom(byte[] data, T message, io.protostuff.Schema<T> schema) {
            IOUtil.mergeFrom(data, 0, data.length, message, schema, true);
        }
    
    

    其实就是把序列化对象信息保存成CharSequence,然后序列化。
    对于反序列化呢?核心ProtostuffIOUtil.mergeFrom(data, obj, schema);我们也追进去看看

    static <T> void mergeFrom(byte[] data, int offset, int length, T message, Schema<T> schema, boolean decodeNestedMessageAsGroup) {
            try {
                ByteArrayInput input = new ByteArrayInput(data, offset, length, decodeNestedMessageAsGroup);
                schema.mergeFrom(input, message);
                input.checkLastTagWas(0);
            } catch (ArrayIndexOutOfBoundsException var7) {
                throw new RuntimeException("Truncated.", ProtobufException.truncatedMessage(var7));
            } catch (IOException var8) {
                throw new RuntimeException("Reading from a byte array threw an IOException (should never happen).", var8);
            }
        }
    
    
     void mergeFrom(Input var1, T var2) throws IOException;
    
    

    其实以上的跟程序的做法还是要自己再跟一变进一步了解才更深刻,protostuff还是主要以应用为主的。

    展开全文
  • 之前曾经写了两篇java的序列的机制,一种是...但是protostuff却不一样,能够很好的解决上面两者的问题。这篇文章就研究一下如何去使用,并对其进行一个简单的分析。 一、认识protostuff 其实protostuff也是有局限性...
  • Protostuff序列化分析

    2017-12-30 00:48:00
    这时候发现了Protostuffprotostuff不需要依赖.proto文件,可以直接对普通的javabean进行序列化、反序列化的操作,而效率上甚至比protobuf还快,生成的二进制数据库格式和Protobuf完全相同的,可以说是一个基于...
  • Protostuff的使用

    2020-01-10 14:28:24
    初探Protostuff的使用 最近在学习RPC,看到了一个叫做Protostuff的库,是基于谷歌Protocal Buffer的序列化库,之前了解过Protocol Buffer,对学习了一些资料后,写了个demo,记录下来。 什么是Protocol Buffer? ...
  • Protostuff序列化问题

    2019-09-25 07:04:55
    分析一下Protostuff序列化和反序列化原理;以及怎么样避免改bug。 1. 问题描述  有一个push业务用到了mq,mq的生产者和消费者实体序列化我们用的是Protostuff方式实现的。由于业务需要,我们要在一个已有的枚举类...
  • protostuff 避免 更改 java 对象字段 ,比如新增一个,导致 redis 等缓存 的数据反序列化失败问题?? 问题重现: 我们有个方法 通过 attrKey 查询 List ,同时方法中有缓存,会优先查询缓存,没有读库,然后 写缓存 ...
  • 前言:由于搜集网络,发现Protostuff相关内容较少,故此发布这篇文章1.何为序列化序列化(Serialization)将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间,对象将其当前状态写入到临时或持久性存储...
  • Protobuf序列化原理

    2021-08-16 11:48:27
    一、Protobuf序列化原理简介 1.1序列化 序列化是将数据结构或对象转换成二进制字节流的过程。 Protobuf对于不同的字段类型采用不同的编码方式和数据存储方式对消息字段进行序列化,以确保得到高效紧凑的数据压缩。 ...
  • 1.利用protostuff进行深度拷贝的原理就是,先序列化再反序列化 2.再利用protostuff进行反序列化时, 集合类型是无法进行反序列化的 于是查了一篇文章如何利用protostuff进行集合对象的反序列化操作 地址: ...
  • 二、RPC原理简介 三、序列化协议概述 1 XML-RPC,SOAP,WebService 2 PHPRPC 3 Hessian 4 JSON-RPC 5 Microsoft WCF,WebAPI 6 ZeroC Ice,Thrift,GRPC 7 Hprose 8 protobuf 9 protostuff 四、项目模块...
  • RPC基本原理及实现

    2019-01-27 23:18:41
    RPC概述 RPC(Remote Procedure Call)即远程过程调用,允许一台计算机调用另一台计算机上的程序得到结果,而代码中不需要做额外的编程,就像在本地...RPC框架原理 在RPC框架中主要有三个角色:Provider、Consu...
  • RPC框架原理 在RPC框架中主要有三个角色:Provider、Consumer和Registry。如下图所示: 节点角色说明: * Server: 暴露服务的服务提供方。 * Client: 调用远程服务的服务消费方。 * Registry: 服务注册与发现的注册...
  • hash-ziplist ziplist底层使用的是压缩列表实现,前面已经详细介绍了压缩列表的实现原理。每当有新的键值对要加入哈希对象时,先把保存了键的节点推入压缩列表表尾,然后再将保存了值的节点推入压缩列表表尾。比如...
  • ProtoStuff 不支持单纯的 Map、List 集合对象,需要包在对象里面。 选择序列化的标准 效率和性能 空间开销:序列化之后的二进制数据的体积大小; 通用性和兼容性:考虑的优先级高于前两者。会直接关系到服务调用的...
  • -- 序列化,hessian/fst/protostuff,默认hessian,可不设置--> <!-- 调用方式,sync/future/callback/oneway,默认sync,可不设置 --> <!-- 失败策略,快速失败failfast/失败转移failover/失败忽略failsafe/...
  • Netty RPC 实现原理

    2020-07-21 15:58:03
    消息编解码:使用 Protostuff 序列化和反序列化消息。 核心流程 1. 服务消费方( client)调用以本地调用方式调用服务; 2. client stub 接收到调用后负责将方法、参数等组装成能够进行网络传输的消息体; 3. ...
  • 反序列化 同序列化,反序列化也有多种类型的序列化器, 在实际应用中,在Kafka提供的序列化器和反序列化器满足不了应用需求的前提下,推荐使用Avro、JSON、Thrift、ProtoBuf或Protostuff等通用的序列化工具来包装,以...
  • RPC原理和实现

    2017-03-02 13:59:23
    RPC原理浅析 RPC 服务方通过 RpcServer 去导出(export)远程接口方法,而客户方通过 RpcClient 去引入(import)远程接口方法。客户方像调用本地方法一样去调用远程接口方法,RPC 框架提供接口的代理...
  • 文章目录一、Dubbo 原理1. 整体架构2. 服务提供方的暴露服务3. 服务消费者方的引用服务4. 调用服务二、实现一个 RPC 一、Dubbo 原理 一次 RPC 调用的流程: 服务消费者方(client)一本地调用的形式调用服务。 ...
  • 序列化有多种方式可以选择,比如Json、Protobuf、Protostuff、Hessian、Kryo等、Java序列化等等。 服务消费者接受到请求后的处理 那么服务提供者怎么才能收到这个请求呢?此时服务提供者里面也得需要一个网络通信...
  • RPC框架通信原理

    2020-05-27 10:36:53
    RPC通信的技术点 序列化:xml/json/java原生序列化/protobuf/avro/kryo/protostuff/hessian2(改造过的序列化) 区别:性能(序列化的性能)、序列化后的报文大小、是否跨平台、跨语言 | 开源 、社区活跃度、技术...
  • Dubbo基本原理与机制

    2021-05-12 19:32:43
    5、Dubbo序列化 专门针对Java语言的:Kryo,FST等等 跨语言的:Protostuff,ProtoBuf,Thrift,Avro,MsgPack、hessian2等等 上述序列化方式的性能多数都显著优于hessian2,所以最好使用其他的序列化 启用Kryo或FST...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 635
精华内容 254
关键字:

protostuff原理

友情链接: viewpager.zip