A seemingly harmless log addition caused a NullPointerException during FastJson serialization, prompting a step‑by‑step investigation of the generated ASM serializer, JavaBeanSerializer workflow, getter detection rules, and practical code‑style guidelines to avoid similar pitfalls.
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.
This article explains how RESTful API design reduces testing complexity by using unique URIs, standard HTTP methods, and JSON data exchange, and shows how test engineers can extend their frameworks with serialization support and added PUT/DELETE operations.
This article examines common pitfalls when converting Java Beans to Map objects—such as type loss with JSON libraries and incorrect property name resolution in BeanMap utilities—and presents a robust solution using Dubbo's PojoUtils along with detailed code examples and analysis.
This comprehensive guide explores essential backend techniques—including lock‑free programming, zero‑copy I/O, efficient serialization, pooling, concurrency, async processing, caching strategies, sharding, storage optimizations, and queue mechanisms—to build high‑performance, scalable services while highlighting practical code examples and real‑world trade‑offs.
This article explains the fundamental components of RPC architecture, details the client‑server roles, communication protocols, serialization methods, transport protocols, and synchronous versus asynchronous invocation patterns, providing a comprehensive guide for building a custom RPC framework.
This article explains the need for generic RPC calls in gateway and testing scenarios, compares Java‑Bean‑based and serialization‑intermediate approaches, and shares Zhuanzhuan's practical implementation details, helping developers choose the most suitable generic invocation method for their RPC frameworks.
This article explains how to protect user privacy in a Java backend by creating a custom @PrivacyEncrypt annotation and a Jackson serializer that automatically mask sensitive fields such as phone numbers, emails, and ID cards during JSON serialization.
This article introduces DeepKit, a TypeScript library that preserves type information at runtime, enabling powerful data validation, serialization, and reflection capabilities for both front‑end and back‑end JavaScript applications.
Fury is a JIT‑compiled, multi‑language native serialization framework that fully implements JDK custom serialization, delivering 20‑200× speed improvements over JDK, Hessian, and Kryo, while preserving compatibility across Java, Python, Go, C++, and JavaScript, as demonstrated by detailed protocol analysis and performance benchmarks.
Sonic‑CPP, an open‑source C++ JSON library co‑developed by ByteDance’s STE and Service Framework teams, leverages SIMD vectorization, optimized memory layout, on‑demand parsing, and a compact DOM design to achieve up to 2.5× faster parsing than RapidJSON and competitive serialization performance, with extensive benchmark results and production‑grade usage.
This article shares practical Python tips for using PyYAML safely, preserving key order, customizing list indentation, outputting readable Unicode, and introduces alternative YAML libraries like oyaml, strictyaml, and ruamel.yaml for better configuration handling.
This tutorial explains Python's file opening and closing methods, various file path formats, reading and writing techniques including with‑open, pointer manipulation, copying files, CSV read/write operations, in‑memory streams with StringIO/BytesIO, sys.stdin/stdout usage, and data serialization/deserialization using JSON and pickle.
A recent production incident caused by inserting a single log statement revealed how FastJSON's ASM‑generated serializer invokes methods like isChinaName(), leading to a NullPointerException, and the article dissects the root cause, serialization mechanics, and best‑practice annotations to prevent similar bugs.
This article explains the fundamental structure of Remote Procedure Call (RPC) architecture, detailing its core components such as providers, consumers, channels, protocols, and processors, and discusses the supporting technical system including network communication, serialization methods, transport protocols, and synchronous versus asynchronous remote invocation strategies.
A seemingly harmless log addition caused a FastJson alarm, leading to a deep dive into Java bean serialization, ASM‑generated serializers, method invocation rules, and best‑practice guidelines for clean, framework‑agnostic JSON handling in backend development.
This article provides a thorough tutorial on Python file I/O, covering opening and closing files, mode flags, absolute and relative paths, reading and writing techniques, file copying, CSV read/write, in‑memory streams, sys module redirection, and serialization with JSON and pickle, including code examples and best practices.
The article recounts a production incident caused by a simple log addition, then analyzes FastJSON’s serialization process, explaining why methods like isChinaName() are invoked, how ASM-generated serializers work, and offers best‑practice guidelines using @JSONField(serialize = false) to control serialization.
The article explains RPC fundamentals and why they are vital for distributed systems, then details the core components—service provider, consumer, and registry—along with extensions such as load‑balancing, circuit breaking, and serialization, and walks through a concrete Java implementation using Zookeeper, Netty, custom protocol, JSON/Protobuf, and Spring Boot SPI plugins.
This article narrates a real‑world debugging scenario where adding a new field to a Java class stored in Redis caused deserialization failures, explains why missing serialVersionUID leads to mismatched versions, and demonstrates how explicitly defining serialVersionUID resolves the issue.
This article walks through practical trade‑offs in designing a Go microservice framework, covering protocol choices, data transport, network handling, serialization methods, service registry options, routing algorithms, and rate‑limiting strategies, while highlighting real‑world implementation details and pitfalls.
This comprehensive guide walks you through Python's file handling—from opening and closing files, using absolute and relative paths, and various read/write modes, to copying files, working with CSV, in‑memory streams, and serializing data with JSON and pickle—complete with clear code examples.
This article compares Java object serialization approaches—including default Serializable, explicit SelfDescribingMarshallable, and trivially copyable techniques—by benchmarking them with JMH and Chronicle Queue, showing that explicit serialization is roughly twice as fast as default and trivially copyable is over ten times faster.
The article advises that POJO class attributes should always use wrapper types without preset default values, illustrating several pitfalls such as null‑overridden defaults during Jackson deserialization, BeanUtils copy failures, MyBatis dynamic SQL issues, and RPC/API default‑value bugs.
This article explains the fundamentals of remote procedure call (RPC), presents a complete system architecture diagram, and provides a step‑by‑step implementation of a custom rpc‑spring‑starter using Java, Spring, Zookeeper for service registration, Netty for network communication, and dynamic proxy techniques for client‑side invocation.
This article examines the reasons for using serialization, compares three serialization protocols (JDK built‑in, Fastjson, and Hessian) with performance metrics, and provides a detailed Hessian serialization implementation, including class definitions, test results, hex analysis, and troubleshooting of common issues.
This article explains the fundamentals of TCP, why raw TCP lacks message boundaries, how HTTP and RPC are built on top of TCP, and the practical reasons why both protocols coexist in modern software architectures.
This article explains Java object serialization and deserialization, why implementing Serializable and defining a serialVersionUID are necessary for persistence and network transfer, and demonstrates the impact of transient and static fields with complete code examples.
This article explains the evolution from raw TCP sockets to HTTP and RPC, highlighting why RPC remains useful despite HTTP's prevalence, covering TCP basics, message framing, service discovery, connection handling, serialization, and performance considerations.
Fury is a JIT‑based native multi‑language serialization framework that automatically handles shared and cyclic references, offers zero‑copy support, and delivers 20‑200× speed improvements over existing solutions, making it a high‑performance drop‑in replacement for Java, Python, Go, and C++ serialization needs.
This article explains how Neutrino’s SerializableProvider API enables passing final classes, managing mutable object state, and supporting Spark checkpoint recovery through dependency injection, while also showing practical code patterns and injection of core Spark components.
This article provides a comprehensive English guide to Kafka's producer component, covering its end‑to‑end workflow, detailed steps such as record creation, serialization, partitioning, batching, sender thread, custom data structures, send modes, common exceptions, and essential configuration parameters for optimal performance.
This article explains how to assemble a production‑grade service registry by analyzing requirements, defining registration/discovery interfaces, comparing push and health‑check mechanisms, selecting long‑connection technologies, and choosing data‑storage and high‑availability strategies, all illustrated with JSON examples and design guidelines.
A real‑world story shows how an overlooked undefined value in a JSON payload caused a front‑end bug that nearly cost a developer his year‑end bonus, and explains the quirks of JSON.stringify together with practical fixes and a custom implementation.
This article examines Fastjson2's performance compared to Fastjson, detailing environment setup, benchmark results, GC analysis, and a deep dive into the library's serialization and deserialization source code to explain why memory settings dramatically affect speed.
This article explains how improper use of Java's ArrayList.subList can cause hidden memory leaks, infinite loops, ConcurrentModificationExceptions, and serialization failures in RPC frameworks, and provides concrete best‑practice solutions such as copying to a new list or using stream operations.
This article explains why processing JSON in a statically‑typed language like Go can be cumbersome, demonstrates two basic approaches—using map[string]interface{} and struct tags—highlights their limitations, and introduces third‑party libraries such as SJSON and GJSON that make JSON reading and writing more concise and efficient.
The article walks through building a minimal SQLite‑style database in Go, covering memory‑disk page storage, B‑tree indexing, simple SQL parsing for INSERT and SELECT, row serialization, a pager that flushes pages, and a basic REPL, while highlighting current single‑page limits and future extensions.
This article introduces FastJSON 2.0, explains how to add the Maven dependency, outlines the main classes and methods for JSON, JSONB, and JSONPath, and provides code examples for serializing and deserializing Java objects as well as partial parsing with JSONPath.
This article presents a comprehensive overview of designing and implementing a custom RPC framework using Spring Boot and Netty, covering concepts, architecture, service registration with Zookeeper, load balancing, custom message protocol, serialization, handling TCP fragmentation, and various client invocation modes.
This article provides a comprehensive guide to Java I/O, explaining the concepts of input and output streams, distinguishing byte and character streams, detailing node and processing streams, and offering practical code examples for file handling, buffering, conversion, and object serialization.
A recent Spring Framework 0‑day remote code execution vulnerability, caused by unsafe use of SerializationUtils#deserialize, affects Java versions above 8, is rated dangerous by security analysts, and highlights the risks of indiscriminate JDK upgrades.
This article explains the concepts, components, and lifecycle of Remote Procedure Call (RPC), compares it with HTTP, and demonstrates how to use the open‑source C++ SRPC framework to build client and server applications, including code generation, serialization, compression, and protocol handling.
This article explains the typical architecture of RPC frameworks, detailing the roles of servers, registries, and clients, the core functions of service discovery, serialization, and network transport, and surveys popular implementations such as RMI, Thrift, gRPC, Dubbo, and others.
This article presents six Java object‑creation techniques—including direct instantiation, cloning, reflection‑based allocation, dynamic class loading, constructor invocation via reflection, and deserialization—explaining each method with code examples and practical notes for developers.
This article explains the fundamentals of Remote Procedure Call (RPC), detailing the end‑to‑end workflow from defining service interfaces and implementations, registering services in a Zookeeper registry, handling network communication with Netty, and generating client‑side proxies using Spring and JDK dynamic proxies, all illustrated with complete Java code examples.
This article provides a comprehensive overview of ZooKeeper, covering its role in distributed systems, common use cases, source code setup, serialization and persistence mechanisms, network communication models, and the watcher workflow, enabling developers to understand and deploy ZooKeeper effectively.
This article explains the difference between shallow and deep copying in Java and provides five practical techniques—including constructor copying, overriding clone(), Apache Commons Lang serialization, Gson serialization, and Jackson serialization—complete with code examples and test cases to demonstrate each approach.
This article explains Python’s built‑in pickle module, detailing its four core functions, usage syntax, parameter meanings, and practical code examples for object serialization to binary data, file storage, and deserialization, while also discussing its limitations and alternatives like ZODB.
This article presents a Kotlin compiler plugin that replaces verbose annotation‑based serialization with delegate‑based syntax, dramatically improves code readability, reduces boilerplate, and achieves up to 20% faster compilation while providing detailed implementation steps, performance results, and practical guidelines.
This tutorial explains how Java developers can use Jackson Mixins to add custom JSON serialization and deserialization behavior to classes that lack default constructors or getters, without modifying the original classes, and shows how to register Mixins via ObjectMapper or custom modules.
Modern micro‑service architectures evolve from basic RPC protocols—covering serialization, transport, invocation modes, and governance—into comprehensive service‑oriented frameworks that integrate registration, load balancing, fault tolerance, observability, and automation, with popular open‑source tools like Dubbo, gRPC, and Thrift guiding implementation choices.
This article introduces Loguru, a third‑party Python logging library, explains why it simplifies logging compared to the standard logging module, outlines its key features such as out‑of‑the‑box setup, async safety, lazy evaluation, and file rotation, and provides practical code examples for quick integration into scripts, libraries, and frameworks.
This article presents a Kotlin compiler plugin that replaces verbose annotation‑based serialization with concise delegated properties, explains its design and implementation details, demonstrates significant compilation‑time reductions of up to 20% and cleaner code, and provides a step‑by‑step guide for developers interested in building similar compiler extensions.
This article introduces Python's built-in pickle module, explains its four core functions (dumps, loads, dump, load), details their parameters and usage, and provides code examples for serializing and deserializing objects to memory and files, while noting performance limitations and alternatives such as ZODB.
This article shows how to streamline Java backend unit tests by loading JSON fixtures, deserializing them into objects, and re‑serializing results for concise assertions, while providing naming conventions, Maven setup, FastJSON tricks, and advanced Mockito techniques to replace verbose manual object construction.
The article uses vivid real‑life analogies to clarify ten essential backend interview concepts—including HTTP statelessness, serialization, rate limiting, TCP handshakes, thread‑pool mechanics, flow‑control windows, BIO/NIO/AIO, deadlocks, and select versus epoll—helping readers grasp complex ideas through familiar scenarios.
This article explains how to design a modular Java SDK for an open platform, covering HTTP data transmission, flexible JSON/XML serialization adapters, and a simple API client with request/response abstractions, complete with code examples and practical implementation tips.
This article explains the internal mechanism of PyTorch's DataLoader when using multiple worker processes, detailing how tensors are serialized, shared via multiprocessing.Queue, and reconstructed in the main process to avoid unnecessary memory copies.
This article walks through the design and implementation of a Java open‑platform SDK, covering a lightweight HTTP client, flexible serialization adapters for JSON and XML, and a simple API client, while sharing practical code examples and best‑practice tips for building maintainable backend integrations.
This article introduces Python’s pickle module, explains its purpose for object persistence, details key functions like dump, dumps, load, and loads with code snippets and example outputs, and demonstrates practical usage scenarios and common pitfalls, helping readers efficiently serialize and deserialize data in Python.
This article explains how bytecode and code‑generation improve Spark SQL performance, compares Java I/O and MapReduce InputFormats, reviews serialization choices in Spark and Flink, and describes reflection‑based DataFrame creation, storage‑memory eviction, fail‑fast design, and ConcurrentHashMap usage in big‑data frameworks.
This article compares Python's built‑in json module with faster alternatives like ujson, rapidjson, and the Rust‑based orjson, showing benchmark results, installation steps, code examples, and a known ujson indentation bug to help developers choose the most efficient JSON library.
The article explains Java marker interfaces—Serializable, Cloneable, and RandomAccess—showing how their empty definitions signal capabilities such as object serialization, shallow or deep cloning, and fast list indexing, and demonstrates the practical effects on code behavior and performance.
This article explores Python’s underused singledispatch feature from PEP 443 as a clean, extensible way to serialize arbitrary objects to JSON, comparing it with traditional json module approaches and showing how it avoids cumbersome if‑elif‑else logic while keeping classes untouched.
This article presents a detailed collection of Spark performance‑tuning techniques—including submit‑script parameters, RDD and operator optimizations, parallelism and memory settings, broadcast variables, Kryo serialization, locality wait adjustments—as well as systematic methods for detecting and resolving data skew and common runtime issues such as shuffle failures, serialization errors, and JVM memory problems.
The article investigates why Python's built‑in json.dumps can be slow on large data structures, compares the performance of ujson, python‑rapidjson, simplejson, and the Rust‑based orjson, provides benchmark code, installation commands, and discusses a bug in ujson's indent handling.
This article explains a systematic process for evaluating and selecting the most suitable high‑performance JSON library for Python, covering the need assessment, benchmark definition, filtering by additional requirements, and detailed benchmark results that highlight orjson as the fastest option for small‑message encoding while discussing trade‑offs such as safety, customizability, and ecosystem support.
The article explains how Python's functools.singledispatch (PEP 443) provides a clean, extensible way to serialize arbitrary objects to JSON, avoiding custom default functions or subclassing JSONEncoder, and discusses alternatives, pitfalls, and related tools such as zope.interface and attrs.
The article examines Java's built‑in Serializable interface, highlights its cross‑language incompatibility, large payload size, and low efficiency, then presents benchmark code comparing it with a custom binary encoding, showing significant reductions in data size and processing time, and recommends modern frameworks such as Protobuf or Thrift.
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.
This article analyzes why Spark tasks fail with a "Task not serializable" exception when closures reference class members, demonstrates the issue with Scala code examples, and provides practical solutions such as using @transient annotations, moving functions to objects, and ensuring proper class serialization.
This article provides a comprehensive Python tutorial covering numeric operations, string conversions, built‑in functions, data structures, class and object mechanics, and a variety of standard library tools such as enumeration, file handling, and JSON serialization.
This article distills the core lessons from Effective Java, presenting 52 practical guidelines on coding style, object creation, generics, enums, concurrency, and serialization, complete with clear explanations and code examples to help Java developers write cleaner, safer, and more efficient programs.
This article explains how Python persistence works by serializing objects with pickle and cPickle, compares file‑based and database storage, demonstrates basic and advanced usage—including handling circular references, custom classes, and versioning—and offers practical tips for maintaining pickled data across code changes.
This comprehensive guide distills the key lessons from Effective Java, covering static factories, builder patterns, singleton pitfalls, generics, enums, serialization, concurrency, and many other best‑practice recommendations, providing Java developers with actionable advice to write cleaner, safer, and more maintainable code.
This article explains Python object persistence, covering the concepts of serialization with pickle and cPickle, various storage mechanisms, handling of complex objects, reference cycles, class instance pickling, versioning strategies, and advanced techniques such as custom state methods and Pickler/Unpickler usage.
This article explains the transient keyword in Java, covering its definition, the rules that govern its use, practical examples with Gson serialization, the impact on object fields during serialization, and how Externalizable can override its behavior, providing a comprehensive guide for developers.
This article provides a thorough overview of Python file handling, covering opening and closing files, reading and writing modes, absolute and relative paths, file copying, CSV read/write, in‑memory streams with StringIO/BytesIO, sys I/O redirection, and data serialization using JSON and pickle.
This tutorial walks you through Python's built‑in JSON handling, covering reading JSON files, converting between JSON strings and Python objects, using pandas for JSON parsing, and applying serialization, deserialization, and pretty‑printing techniques with complete code examples.
This article walks through Dubbo’s RPC encoding and decoding mechanisms, explaining how Netty pipelines add codec handlers, detailing the message header format, exploring Hessian2 serialization, and answering common pitfalls such as class‑path changes and field mismatches.
This article explains how Java's serialization mechanism uses serialVersionUID to ensure class version compatibility, demonstrates default and explicit UID generation, shows code examples for serialization and deserialization, and explores various scenarios including field changes, static variables, inheritance, and the transient keyword.
The article explains how Dubbo can use the Protostuff library as a drop‑in replacement for .proto files to perform Protobuf TLV serialization, detailing the wire‑type encoding, Maven setup, POJO example, byte‑level analysis, Dubbo configuration, and tips for reducing serialization overhead.
An in‑depth guide demonstrates how to combine Netty with Protostuff for high‑performance RPC, detailing serialization setup, custom encoder/decoder implementation, multi‑threading pitfalls, and stress‑testing results that achieve up to 400,000 objects per second per server in a clustered environment.
This article presents a practical Netty‑based RPC solution using Protostuff serialization, detailing large‑scale stress testing, performance bottlenecks, and code‑level optimizations that enable handling hundreds of thousands of objects per second reliably.
This article details how to build a high‑performance Netty RPC system using Protostuff for serialization, covering dependency setup, custom encoder/decoder implementation, multithreaded buffer handling, and stress‑test results that achieve hundreds of thousands of objects per second per server.
Protocol Buffers (ProtoBuf) is a language‑neutral, binary serialization format that enables compact, fast data exchange and easy backward‑compatible schema evolution across many languages, with automatic code generation, making it ideal for gRPC and storage despite being non‑human‑readable.
This article compares the main HTTP API design styles—REST, RPC, and GraphQL—explaining their principles, typical code examples, and trade‑offs, and also discusses serialization formats such as protobuf and JSON, helping backend developers choose the most suitable approach.
This article examines Alibaba's FastJson library, comparing its parsing speed and popularity against Jackson and Gson, presents benchmark results, highlights code defects and unresolved issues, and concludes with recommendations for using Jackson over FastJson in Java backend projects.
This article explains why RPC is essential for distributed services, defines its core concepts and architecture, compares it with REST, SOAP and SOA, outlines the components and call flow, and reviews key technologies and popular Java‑based RPC frameworks such as Dubbo, Thrift and Avro.
This article explains the fundamentals of Java IO, covering the definition of streams, their characteristics, classification by direction, data unit and function, the role of node and processing streams, buffering for performance, serialization, and includes extensive code examples and efficiency comparisons.
This article compares the performance of Python's built‑in json module with popular third‑party libraries ujson, rapidjson, and the Rust‑based orjson, showing benchmark results, installation tips, code examples, and known bugs to help developers choose the most efficient JSON serializer.
This article shares Laiye Technology's practical experience with Protobuf and gRPC, covering performance benefits, common pitfalls such as naming and compatibility issues, and the engineering solutions they implemented—including naming conventions, review processes, unified CI compilation, automatic client generation, version tagging, and Swagger documentation—to streamline large‑scale microservice development.
This article explains five core techniques for instantiating Java objects—including the new keyword, Class.newInstance(), Constructor.newInstance(), clone(), and deserialization—provides code examples for each method, and demonstrates their usage in a complete program with sample output.
This article explains Java's Serializable interface, the concepts of serialization and deserialization, when to use them, how to implement them with code examples, and dives into common issues such as transient fields, static variables, and mismatched serialVersionUID values that can cause runtime errors.
This article details a production incident where Redis memory usage surged due to improper Set serialization, explains the investigation of storage structures and capacity formulas, and outlines a step‑by‑step data migration and cleanup process to restore normal operation.
This article explains the fundamentals of RPC protocols, compares common designs such as HTTP/1.1, RESP, HTTP/2, and gRPC, and outlines the motivations and key features of Dubbo 3.0’s next‑generation protocol for better performance, extensibility, and cross‑language support.
This guide walks through building a Netty server and client that exchange Java objects using Protobuf serialization, covering .proto definition, code generation with protoc, pipeline configuration with Netty's Protobuf handlers, and full example implementations for both sides.
This article introduces Protocol Buffers, explains its advantages over XML, and provides a step‑by‑step guide for defining .proto files, compiling them with protoc, configuring a Java Gradle project, and writing code to serialize and deserialize objects using the generated classes.
This guide explains what Protocol Buffers are, compares them with XML, shows how to define a .proto schema, compile it with protoc, add the generated classes to a Java Gradle project, and demonstrates object serialization and deserialization with concrete code examples.
