tessl/maven-org-apache-dubbo--dubbo

Apache Dubbo is a powerful RPC framework for building enterprise-grade microservices with service discovery, load balancing, and fault tolerance.

—

Pending

Overview

Eval results

Files

Serialization

Name: tessl/maven-org-apache-dubbo--dubbo
Author: tessl

Apache Dubbo provides a pluggable serialization framework supporting multiple serialization protocols for efficient data transmission. The serialization system handles object marshalling/unmarshalling between different data formats and provides extensible mechanisms for custom serialization implementations.

Capabilities

Serialization Interface

Core serialization abstraction for data marshalling and unmarshalling.

/**
 * Serialization interface for data marshalling
 */
@SPI("hessian2")
public interface Serialization {
    /**
     * Get content type identifier
     * @return Content type ID
     */
    byte getContentTypeId();
    
    /**
     * Get content type
     * @return Content type string
     */
    String getContentType();
    
    /**
     * Create object output for serialization
     * @param url Configuration URL
     * @param output Output stream
     * @return Object output for writing objects
     * @throws IOException if output creation fails
     */
    ObjectOutput serialize(URL url, OutputStream output) throws IOException;
    
    /**
     * Create object input for deserialization
     * @param url Configuration URL
     * @param input Input stream
     * @return Object input for reading objects
     * @throws IOException if input creation fails
     */
    ObjectInput deserialize(URL url, InputStream input) throws IOException;
}

Object Input/Output

Interfaces for reading and writing serialized objects.

/**
 * Object output interface for writing serialized data
 */
public interface ObjectOutput extends DataOutput {
    /**
     * Write object
     * @param obj Object to write
     * @throws IOException if write fails
     */
    void writeObject(Object obj) throws IOException;
    
    /**
     * Write UTF string
     * @param s String to write
     * @throws IOException if write fails
     */
    void writeUTF(String s) throws IOException;
    
    /**
     * Write byte array
     * @param b Byte array
     * @throws IOException if write fails
     */
    void writeBytes(byte[] b) throws IOException;
    
    /**
     * Write byte array with offset and length
     * @param b Byte array
     * @param off Offset
     * @param len Length
     * @throws IOException if write fails
     */
    void writeBytes(byte[] b, int off, int len) throws IOException;
    
    /**
     * Flush output
     * @throws IOException if flush fails
     */
    void flushBuffer() throws IOException;
}

/**
 * Object input interface for reading serialized data
 */
public interface ObjectInput extends DataInput {
    /**
     * Read object
     * @return Deserialized object
     * @throws IOException if read fails
     * @throws ClassNotFoundException if class not found
     */
    Object readObject() throws IOException, ClassNotFoundException;
    
    /**
     * Read object with specific class
     * @param cls Expected class type
     * @return Deserialized object
     * @throws IOException if read fails
     * @throws ClassNotFoundException if class not found
     */
    <T> T readObject(Class<T> cls) throws IOException, ClassNotFoundException;
    
    /**
     * Read object with type and class
     * @param cls Expected class type
     * @param type Generic type
     * @return Deserialized object
     * @throws IOException if read fails
     * @throws ClassNotFoundException if class not found
     */
    <T> T readObject(Class<T> cls, Type type) throws IOException, ClassNotFoundException;
    
    /**
     * Read UTF string
     * @return String value
     * @throws IOException if read fails
     */
    String readUTF() throws IOException;
    
    /**
     * Read byte array
     * @return Byte array
     * @throws IOException if read fails
     */
    byte[] readBytes() throws IOException;
}

Built-in Serialization Implementations

Apache Dubbo provides several built-in serialization protocols.

Hessian2 Serialization:

/**
 * Hessian2 serialization implementation (default)
 */
public class Hessian2Serialization implements Serialization {
    public static final String NAME = "hessian2";
    public static final byte ID = 1;
    
    @Override
    public byte getContentTypeId() {
        return ID;
    }
    
    @Override
    public String getContentType() {
        return "x-application/hessian2";
    }
    
    @Override
    public ObjectOutput serialize(URL url, OutputStream output) throws IOException {
        return new Hessian2ObjectOutput(output);
    }
    
    @Override
    public ObjectInput deserialize(URL url, InputStream input) throws IOException {
        return new Hessian2ObjectInput(input);
    }
}

Java Serialization:

/**
 * Java native serialization implementation
 */
public class JavaSerialization implements Serialization {
    public static final String NAME = "java";
    public static final byte ID = 3;
    
    @Override
    public byte getContentTypeId() {
        return ID;
    }
    
    @Override
    public String getContentType() {
        return "x-application/java";
    }
}

JSON Serialization:

/**
 * JSON serialization implementation
 */
public class JsonSerialization implements Serialization {
    public static final String NAME = "json";
    public static final byte ID = 5;
    
    @Override
    public String getContentType() {
        return "text/json";
    }
}

Protobuf Serialization:

/**
 * Protocol Buffers serialization implementation
 */
public class ProtobufSerialization implements Serialization {
    public static final String NAME = "protobuf";
    public static final byte ID = 21;
    
    @Override
    public String getContentType() {
        return "application/x-protobuf";
    }
}

Serialization Configuration

Configure serialization for services and references.

Service-level Configuration:

// Configure serialization for service provider
ServiceConfig<GreeterService> service = new ServiceConfig<>();
service.setInterface(GreeterService.class);
service.setRef(new GreeterServiceImpl());
service.setSerialization("hessian2"); // Set serialization protocol

// Configure serialization for service consumer
ReferenceConfig<GreeterService> reference = new ReferenceConfig<>();
reference.setInterface(GreeterService.class);
reference.setSerialization("protobuf"); // Set serialization protocol

Protocol-level Configuration:

// Configure serialization at protocol level
ProtocolConfig protocol = new ProtocolConfig();
protocol.setName("dubbo");
protocol.setPort(20880);
protocol.setSerialization("hessian2"); // Default serialization for protocol

DubboBootstrap.getInstance()
    .protocol(protocol)
    .start();

URL-based Configuration:

// Configure via URL parameters
String url = "dubbo://localhost:20880/GreeterService?serialization=protobuf";

Custom Serialization

Implement custom serialization protocols.

/**
 * Custom serialization implementation example
 */
public class CustomSerialization implements Serialization {
    public static final String NAME = "custom";
    public static final byte ID = 100;
    
    @Override
    public byte getContentTypeId() {
        return ID;
    }
    
    @Override
    public String getContentType() {
        return "application/x-custom";
    }
    
    @Override
    public ObjectOutput serialize(URL url, OutputStream output) throws IOException {
        return new CustomObjectOutput(output);
    }
    
    @Override
    public ObjectInput deserialize(URL url, InputStream input) throws IOException {
        return new CustomObjectInput(input);
    }
}

/**
 * Custom object output implementation
 */
public class CustomObjectOutput implements ObjectOutput {
    private final OutputStream output;
    
    public CustomObjectOutput(OutputStream output) {
        this.output = output;
    }
    
    @Override
    public void writeObject(Object obj) throws IOException {
        // Custom serialization logic
        byte[] data = customSerialize(obj);
        output.write(data);
    }
    
    private byte[] customSerialize(Object obj) {
        // Implement custom serialization algorithm
        return new byte[0];
    }
    
    // Implement other DataOutput methods...
}

/**
 * Custom object input implementation
 */
public class CustomObjectInput implements ObjectInput {
    private final InputStream input;
    
    public CustomObjectInput(InputStream input) {
        this.input = input;
    }
    
    @Override
    public Object readObject() throws IOException, ClassNotFoundException {
        // Custom deserialization logic
        byte[] data = readBytes();
        return customDeserialize(data);
    }
    
    private Object customDeserialize(byte[] data) {
        // Implement custom deserialization algorithm
        return null;
    }
    
    // Implement other DataInput methods...
}

Register Custom Serialization:

# META-INF/dubbo/org.apache.dubbo.common.serialize.Serialization
custom=com.example.CustomSerialization

Serialization Security

Security considerations and configuration for serialization.

/**
 * Serialization security configuration
 */
public class SerializationSecurity {
    /** Enable serialization security check */
    public static final String SERIALIZATION_SECURITY_CHECK = "dubbo.security.serialization.check";
    
    /** Allowed serialization classes */
    public static final String ALLOWED_SERIALIZATION_CLASSES = "dubbo.security.serialization.allowed";
    
    /** Blocked serialization classes */
    public static final String BLOCKED_SERIALIZATION_CLASSES = "dubbo.security.serialization.blocked";
}

Security Configuration:

# Enable serialization security
dubbo.security.serialization.check=true

# Allow specific classes
dubbo.security.serialization.allowed=com.example.SafeClass,com.example.model.*

# Block dangerous classes
dubbo.security.serialization.blocked=java.lang.Runtime,java.lang.ProcessBuilder

Generic Serialization

Support for generic object serialization without compiled stubs.

/**
 * Generic serialization for dynamic invocation
 */
public interface GenericSerialization extends Serialization {
    /**
     * Serialize generic object
     * @param obj Generic object
     * @param output Output stream
     * @throws IOException if serialization fails
     */
    void writeGenericObject(Object obj, ObjectOutput output) throws IOException;
    
    /**
     * Deserialize generic object
     * @param input Input stream
     * @return Generic object
     * @throws IOException if deserialization fails
     */
    Object readGenericObject(ObjectInput input) throws IOException;
}

Serialization Optimization

Performance optimization techniques for serialization.

Serialization Optimizers:

/**
 * Serialization optimizer interface
 */
public interface SerializationOptimizer {
    /**
     * Get serializable classes for optimization
     * @return Collection of classes to optimize
     */
    Collection<Class<?>> getSerializableClasses();
}

/**
 * Custom serialization optimizer
 */
public class MySerializationOptimizer implements SerializationOptimizer {
    @Override
    public Collection<Class<?>> getSerializableClasses() {
        return Arrays.asList(
            User.class,
            Order.class,
            Product.class
        );
    }
}

Configuration:

# Configure serialization optimizer
dubbo.protocol.optimizer=com.example.MySerializationOptimizer

Serialization Comparison

Comparison of different serialization protocols:

Protocol	Performance	Size	Cross-Language	Type Safety
Hessian2	High	Medium	Yes	Good
Protobuf	Very High	Small	Yes	Excellent
Java	Medium	Large	No	Excellent
JSON	Low	Large	Yes	Poor
Avro	High	Small	Yes	Good
Kryo	Very High	Small	No	Good

Usage Examples

Basic Serialization Configuration:

import org.apache.dubbo.config.ProtocolConfig;
import org.apache.dubbo.config.ServiceConfig;

// Configure Hessian2 serialization (default)
ProtocolConfig protocol = new ProtocolConfig();
protocol.setName("dubbo");
protocol.setSerialization("hessian2");

// Configure Protobuf for high performance
ServiceConfig<OrderService> service = new ServiceConfig<>();
service.setInterface(OrderService.class);
service.setRef(new OrderServiceImpl());
service.setSerialization("protobuf");

Multiple Protocols with Different Serialization:

// Protocol 1: Dubbo with Hessian2 (default)
ProtocolConfig dubboProtocol = new ProtocolConfig();
dubboProtocol.setName("dubbo");
dubboProtocol.setPort(20880);
dubboProtocol.setSerialization("hessian2");

// Protocol 2: REST with JSON
ProtocolConfig restProtocol = new ProtocolConfig();
restProtocol.setName("rest");
restProtocol.setPort(8080);
restProtocol.setSerialization("json");

DubboBootstrap.getInstance()
    .protocols(Arrays.asList(dubboProtocol, restProtocol))
    .start();

Serialization in Properties:

# Global serialization configuration
dubbo.protocol.serialization=protobuf

# Service-specific serialization
dubbo.provider.serialization=hessian2
dubbo.consumer.serialization=hessian2

# Protocol-specific serialization
dubbo.protocols.dubbo.serialization=hessian2
dubbo.protocols.rest.serialization=json

Performance Tuning:

// High-performance setup with Protobuf
ProtocolConfig protocol = new ProtocolConfig();
protocol.setName("dubbo");
protocol.setPort(20880);
protocol.setSerialization("protobuf");
protocol.setOptimizer("com.example.ProtobufOptimizer");

// Configure buffer sizes for better performance
protocol.setBuffer(8192);
protocol.setPayload(10485760); // 10MB

Install with Tessl CLI

npx tessl i tessl/maven-org-apache-dubbo--dubbo

docs