BestHub
Sign in
Tagged articles

Protocol Buffers

44 articles · Page 1 of 1
LuTiao Programming
LuTiao Programming
Aug 22, 2026 · Backend Development

Why Spring Boot 4.1.1 Makes Controllers and JSON Unnecessary for Internal Microservice Calls

Spring Boot 4.1.1 now offers native gRPC support, letting Java microservices replace the usual REST controllers, DTOs, Feign clients and JSON payloads with a single .proto definition, generated code, and built‑in security, health, observability and testing features, while highlighting best practices and pitfalls.

JavaProtocol BuffersSpring Boot
0 likes · 12 min read
Why Spring Boot 4.1.1 Makes Controllers and JSON Unnecessary for Internal Microservice Calls
Long Ge's Treasure Box
Long Ge's Treasure Box
Jul 8, 2026 · Backend Development

Understanding gRPC: High‑Performance RPC with HTTP/2 and Protobuf

This article introduces gRPC, Google’s high‑performance RPC framework built on HTTP/2 and Protocol Buffers, compares it with REST, explains protobuf type mappings, demonstrates service definitions and all four communication patterns, and covers advanced topics such as interceptors, load balancing, deadlines, error handling, and microservice integration.

HTTP/2InterceptorsProtocol Buffers
0 likes · 20 min read
Understanding gRPC: High‑Performance RPC with HTTP/2 and Protobuf
Deepin Linux
Deepin Linux
Mar 17, 2026 · Backend Development

How to Build a High‑Performance gRPC File Transfer Service from Scratch

This step‑by‑step tutorial shows how to configure gRPC, define protobuf service contracts, and implement streaming upload and download in C++, covering environment setup, code generation, server and client logic, testing, and performance tuning for efficient file transfer.

C++Protocol BuffersStreaming
0 likes · 44 min read
How to Build a High‑Performance gRPC File Transfer Service from Scratch
Go Development Architecture Practice
Go Development Architecture Practice
Jan 28, 2026 · Backend Development

Mastering gRPC with Python: From Basics to Real‑World Microservices

This guide explains the fundamentals of gRPC, why it uses HTTP/2 and Protocol Buffers, walks through writing and compiling .proto files, provides complete Python server and client examples, and outlines common microservice and Kubernetes use cases, giving developers a practical end‑to‑end workflow.

Protocol BuffersPythonbackend development
0 likes · 11 min read
Mastering gRPC with Python: From Basics to Real‑World Microservices
IT Services Circle
IT Services Circle
Nov 17, 2025 · Backend Development

Why JSON Slows Down High‑Performance APIs and Which Binary Formats Can Save You Time

The article explains why JSON becomes a bottleneck in latency‑sensitive applications, compares four high‑performance binary serialization formats—Protocol Buffers, FlatBuffers, MessagePack, and CBOR—and provides practical guidance on selecting and deploying the right format to dramatically reduce latency, payload size, and CPU usage.

CBORData SerializationFlatBuffers
0 likes · 11 min read
Why JSON Slows Down High‑Performance APIs and Which Binary Formats Can Save You Time
Deepin Linux
Deepin Linux
Jul 4, 2025 · Backend Development

Mastering Protocol Buffers in C++: Installation, Data Types, and Real‑World Use Cases

This comprehensive guide explains what Protocol Buffers are, why they outperform JSON and XML, how to install and configure the library, the supported data types, code generation for multiple languages, practical C++ examples, and typical scenarios such as distributed systems, storage, and network communication.

C++Data StructuresPerformance
0 likes · 23 min read
Mastering Protocol Buffers in C++: Installation, Data Types, and Real‑World Use Cases
Tencent Cloud Developer
Tencent Cloud Developer
Apr 17, 2025 · Fundamentals

Protobuf Encoding Principles and Optimization Techniques

The article explains how Protocol Buffers (proto3) encode basic and composite types using varint, zigzag, fixed-size and IEEE‑754 formats, describes tag and length field structures, and presents optimization strategies such as selecting size‑efficient types, flattening nested messages, and delta‑encoding to significantly reduce serialized byte‑stream size.

Data StructuresOptimizationProtobuf
0 likes · 15 min read
Protobuf Encoding Principles and Optimization Techniques
FunTester
FunTester
Feb 11, 2025 · Fundamentals

Reconsidering Java Serialization: Challenges and Modern Alternatives

Java serialization, while convenient for object persistence, suffers from security vulnerabilities, versioning issues, performance constraints, and difficulties handling complex object graphs, prompting developers to evaluate alternatives such as JSON, Protocol Buffers, and Apache Avro, each offering distinct trade‑offs in readability, efficiency, and safety.

Apache AvroJSONJava
0 likes · 9 min read
Reconsidering Java Serialization: Challenges and Modern Alternatives
JD Tech Talk
JD Tech Talk
Jan 10, 2025 · Backend Development

Analysis of gRPC: Principles, Advantages, Disadvantages, and a Cross‑Language Demo

This article examines gRPC’s implementation principles, multi‑language support, Protocol Buffers foundation, advantages and disadvantages, and provides a C++/Go demo illustrating its cross‑language capabilities within cloud‑native environments, including project structure, code snippets, and discussion of HTTP/2 transport.

HTTP/2Protocol BuffersRPC
0 likes · 8 min read
Analysis of gRPC: Principles, Advantages, Disadvantages, and a Cross‑Language Demo
JD Cloud Developers
JD Cloud Developers
Jan 10, 2025 · Backend Development

Why gRPC Is the Go-To RPC Framework for Multi-Language Backend Services

This article examines gRPC’s implementation principles, its multi‑language support, Protocol Buffers integration, performance advantages, and limitations such as browser compatibility, while providing a C++/Go demo that showcases cross‑language RPC calls and a detailed project structure.

Protocol BuffersRPCbackend development
0 likes · 9 min read
Why gRPC Is the Go-To RPC Framework for Multi-Language Backend Services
Deepin Linux
Deepin Linux
Sep 19, 2024 · Backend Development

Comprehensive Guide to gRPC: Concepts, C++ Implementation, and Real‑World Use Cases

This article explains the limitations of traditional RPC, introduces gRPC and Protocol Buffers, details their architecture and performance advantages, provides step‑by‑step C++ server and client code, and discusses practical scenarios such as microservices, real‑time data processing, and a file‑storage service example.

C++Protocol Buffersdistributed systems
0 likes · 29 min read
Comprehensive Guide to gRPC: Concepts, C++ Implementation, and Real‑World Use Cases
Ops Development & AI Practice
Ops Development & AI Practice
Jun 16, 2024 · Backend Development

Mastering Protocol Buffers 3: From Installation to Real-World Usage

This guide walks you through what Protocol Buffers are, how to install the protoc compiler on macOS, Windows, and Python, explains the proto3 syntax—including messages, fields, enums—and demonstrates compiling .proto files and using the generated code in Python, while highlighting Protobuf's efficiency, extensibility, and multi‑language support.

Data SerializationProtobufProtocol Buffers
0 likes · 7 min read
Mastering Protocol Buffers 3: From Installation to Real-World Usage
Ops Development & AI Practice
Ops Development & AI Practice
Jun 16, 2024 · Industry Insights

Protocol Buffers vs Swagger: Which Is Best for High‑Performance APIs?

This article compares Google’s Protocol Buffers and the Swagger/OpenAPI framework, detailing their features, data formats, use cases, flexibility, development workflows, and why Google created protobuf, helping developers choose the right tool for high‑performance data serialization or comprehensive API documentation.

API DesignData SerializationOpenAPI
0 likes · 7 min read
Protocol Buffers vs Swagger: Which Is Best for High‑Performance APIs?
MaGe Linux Operations
MaGe Linux Operations
Mar 10, 2024 · Backend Development

Mastering RPC: From Concepts to gRPC Implementation in Go

This article explains the fundamentals of Remote Procedure Call (RPC), its historical origins, the step‑by‑step execution process, and provides a practical guide to installing and using gRPC with Protocol Buffers in Go, including full code examples and advantages.

GoProtocol BuffersRPC
0 likes · 14 min read
Mastering RPC: From Concepts to gRPC Implementation in Go
MaGe Linux Operations
MaGe Linux Operations
Feb 28, 2023 · Fundamentals

Why Protocol Buffers Outperform JSON: A Hands‑On Java Benchmark

This article introduces Google’s Protocol Buffers, explains its compilation process, walks through a complete Java example, and compares its encoding speed, data size, and memory usage against JSON, showing that ProtoBuf becomes significantly faster and more compact as the number of operations increases.

Data FormatsPerformanceProtocol Buffers
0 likes · 9 min read
Why Protocol Buffers Outperform JSON: A Hands‑On Java Benchmark
Java Architecture Diary
Java Architecture Diary
Jan 16, 2023 · Backend Development

How to Compile and Run Nacos Console in Standalone Mode

This guide walks you through cloning the Nacos repository, compiling it with Maven (including special handling for Mac M‑series chips), explains the role of Protocol Buffers, and shows how to configure and run the Nacos console in standalone mode.

CompilationJavaNacos
0 likes · 2 min read
How to Compile and Run Nacos Console in Standalone Mode
Open Source Linux
Open Source Linux
Oct 18, 2022 · Backend Development

Master gRPC: Build High‑Performance RPC Services with Python

gRPC is a high‑performance, open‑source RPC framework built on HTTP/2 and Protocol Buffers, and this guide explains its core concepts, communication patterns, protobuf usage, and provides step‑by‑step Python examples for creating, compiling, and running client‑server services, plus deployment tips.

HTTP/2Protocol BuffersPython
0 likes · 10 min read
Master gRPC: Build High‑Performance RPC Services with Python
Efficient Ops
Efficient Ops
Oct 10, 2022 · Backend Development

Master gRPC: From Basics to Building a Python Microservice

This article introduces gRPC, explains its HTTP/2 and Protocol Buffers foundations, walks through writing and compiling .proto files, provides complete Python server and client examples, and shows how to quickly set up the environment and integrate gRPC into microservice and Kubernetes deployments.

HTTP/2Protocol BuffersPython
0 likes · 9 min read
Master gRPC: From Basics to Building a Python Microservice
Code Ape Tech Column
Code Ape Tech Column
Aug 12, 2022 · Backend Development

Understanding RPC and gRPC: Concepts, Frameworks, and a Practical Java Implementation

This article explains the fundamentals of Remote Procedure Call (RPC), compares popular RPC frameworks such as gRPC, Thrift, Dubbo and Spring Cloud, details gRPC’s architecture, Protocol Buffers serialization, HTTP/2 advantages, and provides a step‑by‑step Java demo with full source code and performance benchmarks.

JavaProtocol BuffersRPC
0 likes · 16 min read
Understanding RPC and gRPC: Concepts, Frameworks, and a Practical Java Implementation
FunTester
FunTester
Apr 20, 2022 · Backend Development

Build a Simple Java gRPC Demo in 3 Easy Steps

This guide walks you through setting up a basic Java gRPC project by outlining required Maven dependencies, creating the .proto SDK, implementing a server with a custom service, building a client stub, and running a test to verify the end‑to‑end RPC call.

JavaMavenProtocol Buffers
0 likes · 9 min read
Build a Simple Java gRPC Demo in 3 Easy Steps
21CTO
21CTO
Dec 26, 2021 · Backend Development

REST vs gRPC: Which API Architecture Wins for Modern Microservices?

This article explains what APIs are, introduces RPC and gRPC, compares them with REST across protocols, data formats, performance, code generation, and browser support, and offers guidance on when to choose gRPC or REST for microservice and mobile applications.

API DesignHTTP/2Protocol Buffers
0 likes · 11 min read
REST vs gRPC: Which API Architecture Wins for Modern Microservices?
Senior Brother's Insights
Senior Brother's Insights
Aug 2, 2021 · Backend Development

Mastering Protocol Buffers: From Installation to Java Integration

This tutorial explains what Protocol Buffers are, why they outperform JSON/XML, and provides a step‑by‑step guide for installing the compiler, defining .proto schemas, generating Java code, integrating with Maven, and using protobuf for fast serialization in micro‑service RPC.

ProtobufProtocol BuffersRPC
0 likes · 12 min read
Mastering Protocol Buffers: From Installation to Java Integration
58 Tech
58 Tech
Jun 17, 2020 · Backend Development

Hermes: A Lightweight, High‑Reliability Mobile Message Push System Based on MQTT and Protocol Buffers

The article presents Hermes, a lightweight and highly reliable mobile push system built with MQTT and Protocol Buffers, detailing its background, technology selection, architecture, heartbeat and reconnection strategies, future optimizations, and practical results that achieve over 99% message delivery rate.

Long ConnectionMQTTProtocol Buffers
0 likes · 16 min read
Hermes: A Lightweight, High‑Reliability Mobile Message Push System Based on MQTT and Protocol Buffers
Java Architect Essentials
Java Architect Essentials
May 26, 2020 · Backend Development

gRPC Java Tutorial: Building a Spring Boot Service with Maven

This article provides a step‑by‑step guide to using Google's open‑source gRPC framework in Java, covering Protocol Buffers service definitions, Maven configuration, Spring Boot server implementation, client creation, and unit testing to demonstrate cross‑language RPC communication.

MavenProtocol BuffersSpring Boot
0 likes · 16 min read
gRPC Java Tutorial: Building a Spring Boot Service with Maven
360 Tech Engineering
360 Tech Engineering
Aug 6, 2019 · Mobile Development

Performance Comparison of JSON, Protocol Buffers, and FlatBuffers for H5‑Hybrid and Flutter Data Transmission

This article presents a real‑device performance test of three data serialization structures—JSON, Protocol Buffers, and FlatBuffers—used in H5‑Hybrid and Flutter development, analyzing their size, serialization/deserialization speed, and suitability for Android, Flutter, and H5 communication channels.

AndroidFlatBuffersFlutter
0 likes · 13 min read
Performance Comparison of JSON, Protocol Buffers, and FlatBuffers for H5‑Hybrid and Flutter Data Transmission
Huajiao Technology
Huajiao Technology
Aug 6, 2019 · Mobile Development

Which Serialization Wins? Json vs Protocol Buffers vs FlatBuffers on Android, Flutter & H5

This article presents a real‑device performance comparison of Json, Protocol Buffers and FlatBuffers across Android, Flutter and H5 channels, explains their internal structures, shows serialization/deserialization code, and provides practical guidance on choosing the right format for mobile data transmission.

FlatBuffersJSONMobile Development
0 likes · 13 min read
Which Serialization Wins? Json vs Protocol Buffers vs FlatBuffers on Android, Flutter & H5
JD Tech
JD Tech
Jan 4, 2019 · Backend Development

Using Protobuf with Go: Installation, Code Examples, and Serialization

This article provides a step‑by‑step guide on installing the Protobuf compiler, setting up the Go plugin, writing .proto definitions, generating Go code, and demonstrating serialization and deserialization of Protobuf messages in a Go application, complete with troubleshooting tips and reference links.

GoProtobufProtocol Buffers
0 likes · 6 min read
Using Protobuf with Go: Installation, Code Examples, and Serialization
High Availability Architecture
High Availability Architecture
Oct 30, 2018 · Backend Development

Why Protocol Buffers Are Fundamentally Flawed: A Critical Analysis

The article presents a detailed technical critique of Protocol Buffers, highlighting its amateur origins, lack of composability, problematic type system choices, misleading backward‑compatibility claims, and the way it pollutes codebases, ultimately arguing that developers should avoid adopting it for new projects.

Protocol BuffersType Systemdesign critique
0 likes · 11 min read
Why Protocol Buffers Are Fundamentally Flawed: A Critical Analysis
Suishouji Tech Team
Suishouji Tech Team
Mar 21, 2018 · Mobile Development

How to Integrate Google Protocol Buffers into iOS Apps with Objective‑C

This guide explains why and how to use Google Protocol Buffers for efficient data exchange in iOS, covering environment setup, installation, .proto definition, compilation to Objective‑C files, project integration, and a complete encode/decode test with sample code.

Mobile DevelopmentObjective-C++Protocol Buffers
0 likes · 7 min read
How to Integrate Google Protocol Buffers into iOS Apps with Objective‑C
GF Securities FinTech
GF Securities FinTech
Sep 21, 2016 · Backend Development

Why gRPC 1.0 Is a Game-Changer for Scalable Backend Services

Google's gRPC 1.0 release brings high‑performance, multi‑language RPC support built on Protocol Buffers and HTTP/2, enabling loosely coupled, scalable backend systems for data centers, mobile apps, IoT, and microservices with improved efficiency, security, and ecosystem adoption.

HTTP/2Protocol BuffersRPC
0 likes · 7 min read
Why gRPC 1.0 Is a Game-Changer for Scalable Backend Services
21CTO
21CTO
Sep 22, 2015 · Backend Development

How to Integrate Protocol Buffers with PHP over Binary TCP Sockets

This article explains how to add Protocol Buffer communication to a PHP web system, covering library setup, proto file adjustments, code generation, binary TCP handling with pack/unpack, and the switch from read_line to fread for reliable socket reads.

Binary SocketPHPPack
0 likes · 5 min read
How to Integrate Protocol Buffers with PHP over Binary TCP Sockets
Architect
Architect
Jul 25, 2015 · Cloud Computing

Design Principles and Components of Google App Engine

This article explains Google App Engine's core design philosophies—including reuse of Google technologies, statelessness, hard limits, Protocol Buffers for service heterogeneity, and distributed storage—then details its front‑end, Datastore, service group, language‑specific implementations, and a typical HTTP request flow.

Distributed DatastoreGoogle App EngineProtocol Buffers
0 likes · 6 min read
Design Principles and Components of Google App Engine