This tutorial shows how to use Python's urllib and json libraries to call the Kuaidi100 API, retrieve real‑time logistics data for various Chinese courier companies, and display the tracking timeline, while explaining how to discover the correct request URL via browser dev tools.
This article introduces a self‑implemented Swagger UI built on think‑vuele, explains its architecture and dependencies, provides step‑by‑step usage instructions and Maven integration, and details performance optimizations such as API summary loading, mock data generation, and customizable request headers.
This article extends the previous JsonPath utility guide by demonstrating how to write comprehensive Groovy‑based Spock unit tests, covering Maven/Gradle setup, basic and data‑driven demos, detailed test cases for JSON path extraction, array operations, statistical functions, and a deliberately introduced bug with its console output.
This article demonstrates how to use JsonPath's built‑in functions such as $.ss.min(), $.ss.max(), $.ss.avg(), $.ss.stddev(), $.ss.length() and $.ss.sum() to compute minimum, maximum, average, standard deviation, length and sum of JSON array elements, providing Java code examples and expected console output.
This article explains how to use JsonPath in Java to filter JSON data, covering operators, functions, and practical examples such as checking values in arrays, subsets, size constraints, and empty checks, with complete code snippets for each case.
This tutorial shows how to use standard Unix shell tools such as grep, cut, sort, uniq, awk, and join to extract insights—top companies, most common surnames, popular given names, age distribution, and hometown statistics—from a JSON dataset of over 6,000 Beijing residency applicants.
This tutorial demonstrates how to use JsonPath combined with regular expressions to filter JSON arrays, perform case‑insensitive matches, and discuss the limitations of regex validation on node values, providing concrete Java code examples and console outputs.
This article explains how Laravel routes and controllers can return various HTTP responses—including plain strings, JSON arrays, custom Response objects with headers, cookies, redirects, view rendering, JSONP, and file downloads—while showing the corresponding PHP code for each technique.
This article explains why the new Java development manual forbids returning large Long values as JSON, explores the IEEE754 double‑precision limits that cause JavaScript Number precision loss, and provides practical solutions such as converting Longs to strings to avoid silent data corruption.
This article demonstrates how to integrate the JsonPath library into a Java project, explains its syntax for querying JSON structures, and provides practical code examples for extracting authors, prices, and entire nodes from a sample JSON document.
Explore essential Python tricks—from dictionary and set comprehensions to using Counter for counting, pretty‑printing JSON, and building a quick XML‑RPC file service—showcasing concise code snippets that illustrate the language’s clean syntax and powerful standard library.
This tutorial walks through building a simple Python web crawler that searches the Pansou site, handles AJAX‑loaded JSON data, extracts file links, and enables interactive downloading, illustrating core backend techniques such as HTTP GET requests, JSON parsing, and user‑driven pagination.
This tutorial explains how to analyze Meituan food page URLs, use browser developer tools to locate AJAX JSON responses, construct Python requests with proper headers, extract restaurant information via regular expressions, and save the results to a local file.
MySQL 8.0.21 introduces numerous enhancements such as dynamic redo log control, optional tablespace path validation, refined lock system, JSON_VALUE function, atomic CREATE TABLE…AS SELECT, optimizer improvements, reduced group replication cache, multi‑address X Plugin support, and various security and deprecation updates.
The article thoroughly examines Lottie animation technology, describing how After Effects projects are converted into JSON, parsed into Objective‑C data models such as LOTComposition and LOTLayer, and rendered on iOS/Android via Core Animation, detailing asset handling, layer hierarchy, frame interpolation, and implementation specifics.
The article examines Alibaba's FastJson library, presenting performance tests against Jackson and Gson, revealing modest speed gains, low adoption in Maven, numerous unresolved issues, and ultimately recommending developers switch to Jackson for JSON processing in Java projects.
This guide explains what Lottie is, how to install the Bodymovin plugin for After Effects, export animations as JSON, preview them across platforms, and troubleshoot common issues such as unsupported effects, expression baking, mask usage, file size optimization, and multi‑layer animation stacking.
This article explains how to generate and customize Laravel resource and resource collection classes, use them to convert Eloquent models and collections into JSON, handle pagination, conditional attributes, relationships, and add metadata to API responses.
This guide explains how Laravel Eloquent can serialize models and their relationships to arrays or JSON, control visible and hidden attributes, append custom values, and customize date formatting using casts and Carbon serialization, with practical code examples for each feature.
This article explains MySQL's large object data types—TEXT, BLOB, and JSON—covering their storage formats, performance implications, indexing rules, partition restrictions, relevant server parameters, and practical examples of creating tables, inserting data, and querying JSON values.
fastjson 1.2.68 introduces a safeMode configuration that disables autoType, adds an autoType blacklist, supports GeoJSON, and fixes several bugs including JSONObject conversion issues, jsonpath .max/.min handling, and Map.Entry generics, while providing detailed release notes for developers.
Learn to retrieve song titles, album names, and playback links from QQ Music’s artist ranking pages using Python’s requests library, parse JSON responses from XHR calls, and store results in Excel, with a complete walkthrough from setup to final summary.
This article continues the FunTester series by detailing the core functionality for sending HTTP requests, handling headers and cookies, parsing responses into JSON, and returning structured results, complete with practical Java code examples and step‑by‑step explanations.
The article explains how unordered Python dictionaries cause inconsistent MD5 signatures when assembling JSON payloads for an ERP API, and demonstrates using collections.OrderedDict together with json.dumps separators to produce a stable, correctly signed request.
Fastjson 1.2.66, a maintenance release, introduces security hardening, an AutoType blacklist, and a series of bug fixes ranging from BeanToArray errors to Kotlin generic handling, while also adding support for Queue deserialization and enhanced date parsing.
This article shares five practical Python tips—dictionary and set comprehensions, the Counter class, pretty‑printing JSON, a quick XML‑RPC web service, and criteria for choosing solid open‑source libraries—each illustrated with clear code examples to help developers write cleaner, more efficient code.
The article analyzes Fastjson's design choices, performance shortcuts, memory‑leak issues caused by substring handling, hard‑coded framework dependencies, and why its focus on speed over standards and quality has prevented it from gaining global popularity compared to libraries like Jackson.
This article provides a concise introduction to JSON, covering its role as a lightweight data exchange format, language independence, syntax rules, data types such as objects, arrays, strings, numbers, booleans and null, as well as file conventions and MIME type, offering practical examples for beginners.
This guide introduces Elasticsearch fundamentals—including its core concepts, main features, and essential terminology—followed by step‑by‑step Docker setup and practical API commands for creating, indexing, searching, and managing documents in a single‑node cluster.
This article explains the purpose, features, and practical usage of JSON Schema for describing data structures, generating documentation, and validating API inputs and outputs, and provides a detailed example with code and tips for effective schema design.
This tutorial explains how Spring Boot automatically configures Jackson's ObjectMapper, shows how to override it with a custom mapper that formats Date fields, and demonstrates both serialization and deserialization of JSON using the customized ObjectMapper in a Spring MVC controller.
This guide explains how Spring Boot automatically configures JSON libraries like Jackson, shows how to add the necessary starter, demonstrates returning JSON objects with @RestController, and illustrates receiving JSON payloads via @RequestBody with complete MockMvc test examples.
This article walks through creating a JSON parser in JavaScript, covering the JSON grammar, railroad and BNF diagrams, step‑by‑step implementation of object, array and value parsing, robust error handling, and suggestions for meaningful error messages.
This article presents a reusable Java verification class that centralizes common validation logic for automated testing, handling JSON responses, code checks, numeric and boolean assertions, array detection, and regex matching, while also fixing hidden bugs and extending array validation capabilities.
JSON's ubiquity makes reliable validation and formatting essential, and this guide introduces nine practical tools—including online services, CLI utilities, and IDE plugins—detailing their features, usage options, and where to access their source code or downloads.
This article introduces nine free JSON utilities—including online validators, command‑line processors, IDE plugins, and editors—explaining their main features, typical use cases, and where to access each tool via web links or source repositories.
This article introduces nine popular JSON utilities—including online validators, command‑line converters, IDE plugins, and formatters—detailing their main features, usage scenarios, and where to download or access their source code, helping developers choose the right tool for JSON processing tasks.
This article compares CSV, JSON, Parquet, and Avro file formats, outlining their structures, advantages, and drawbacks, and explains how Apache Spark supports each format for efficient big‑data storage and processing.
This article introduces JSON basics, explains the Fastjson library from Alibaba, outlines its key features, and provides practical Java code examples for parsing, serializing, and converting between JSON strings, objects, arrays, maps, lists, and beans using Fastjson’s API.
Discover nine powerful JSON utilities—including online validators, formatters, CLI converters, and IDE plugins—that simplify parsing, validation, and editing, with direct links to each tool’s website or repository, helping developers efficiently work with JSON across various environments.
This article examines how Spring Boot 2.2.0.RELEASE loads configuration files, where it searches for them, how it supports YAML and properties formats, how to add JSON support, the precedence of property sources, and the placeholder resolution process by tracing the relevant source code.
PostgreSQL 12 brings major enhancements—including up to 40% faster queries on large datasets, improved indexing, partitioning, JSON path queries, generated columns, pluggable table access methods, stronger authentication, and built‑in JIT compilation—while also adding better localization, multi‑constraint authorization, and convenient maintenance commands.
This article walks through why developers should replace FastJson with Gson, explains Gson's core features, demonstrates basic and advanced serialization and deserialization—including handling arrays, collections, generic types, custom serializers, and annotations—while providing complete code examples and best‑practice tips.
MySQL 8.0 adds JSON‑formatted error logs and flexible filtering components, allowing administrators to install JSON sink and filter modules, extract specific fields with tools like jq, and apply rules that drop or throttle messages to improve log readability and automation.
This article examines how to correctly define boolean-type member variables in Java POJOs, comparing primitive boolean and wrapper Boolean, discussing naming conventions like success vs isSuccess, default values, JavaBeans getter/setter rules, and the impact on JSON serialization across fastjson, Gson, and Jackson.
This article explains PostgreSQL's jsonb type, its performance advantages over plain json, outlines its pros and cons, and demonstrates common operations such as inserting, querying, filtering, array expansion, containment checks, and indexing with practical book‑entry examples.
This article explains why JSON output in a Java console is often unreadable, presents a custom method that formats and indents JSON strings with visual markers, provides the full implementation code, shows the resulting output, and notes its current limitations.
This article provides a complete Java HttpClient implementation for sending push notifications through AlertOver’s API, including JSON payload construction, request execution, response handling, and highlights potential integration tips for production environments.
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.
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.
When using Moco API for interface virtualization, the default extractor cannot handle POST requests with JSON bodies, so a custom JsonExtractor is created to read the request content, parse the JSON, and return the desired parameter value.
When using Moco API for request virtualization, the default extractor cannot handle POST JSON bodies, so this article shows how to implement a custom JsonExtractor in Java and use Groovy matchers to verify JSON parameters effectively.
Zhihu’s Morph dynamic solution, built on a Flexbox‑based DSL and JSON, enabled rapid, cross‑platform updates of mobile ad cards, dramatically reducing rollout time from eight days to one and supporting over 70 styles with minimal impact on app size and performance.
This guide shows how to retrieve MySQL query results in Python and transform the default tuple output into usable string, list, and JSON formats, providing complete code examples for each conversion method to support automated testing validation.
Using JMH, this article benchmarks the serialization and deserialization performance of four popular Java JSON libraries—Gson, Fastjson, Jackson, and Json-lib—by testing various scenarios with a complex Person model, analyzing results, and providing guidance on selecting the most suitable library for high‑performance applications.
This article explains why Retrofit + Gson parsing can fail when server‑sent fields differ from client definitions or when lists contain heterogeneous item types, and demonstrates how to customize TypeAdapters and use @JsonAdapter to gracefully handle these scenarios in Android applications.
This article explains how to compare JSON data returned by old and new services during a migration, demonstrates Python scripts for JSON and list comparisons, and provides useful tools and code snippets for validating data consistency before a full rollout.
The article describes a problem with Moco's default request extractor that fails to retrieve JSON parameters from POST requests and provides a custom Java extractor implementation that reads the request content and extracts the desired JSON field.
This article introduces the lightweight Go framework gobox, demonstrating its exception definition, common utility functions such as slice deduplication, file and directory existence checks, recursive file listing, JSON file saving and parsing, substring extraction, time formatting constants, and random number generation based on timestamps, all with clear code examples.
Go’s reflection, accessed via the reflect package’s TypeOf and ValueOf functions, lets programs inspect and modify runtime types and values—including fields, tags, and slices—while obeying settable rules, enabling generic utilities such as JSON serialization, deep equality checks, and dynamic ORM-like behavior.
This article explains how Elasticsearch stores JSON documents, indexes them, and uses RESTful PUT, GET, DELETE, and search APIs to perform create, read, update, and delete operations, illustrating each step with concrete employee examples and query syntax.
This guide lists and describes twenty indispensable Java libraries—including logging, JSON parsing, testing, HTTP, XML, database pooling, messaging, PDF handling, and more—so developers can quickly find the right tools for everyday backend development tasks.
This article explains the fundamentals of JSON, its object and array structures, maps JSON types to Java equivalents, and provides a complete Java implementation of a JSON parser including token definitions, lexical analysis, and object/array construction with detailed code examples.
The article examines Flutter’s limited built-in JSON handling, explains why the popular json_serializable package can fall short for complex, generic objects, and introduces fish-serializable—a custom library with a ValueHolder, FishSerializable interface, JsonSerializer, and IntelliJ plugin—already used in production at Alibaba’s Xianyu and soon to be open-sourced.
This article examines the drawbacks of maintaining separate native codebases for iOS and Android, reviews the evolution of cross‑platform solutions such as WebView‑based frameworks, React Native, and Flutter, and shares practical insights, code examples, and future plans for using Flutter in large‑scale mobile projects.
This article presents eight practical strategies—including upgrading Node.js, leveraging fast-json-stringify, optimizing promises, tuning V8 GC, using streams correctly, and employing node‑clinic tools—to dramatically improve the performance and scalability of Node.js applications.
The article shares Meituan‑Dianping’s practical experience in designing a mobile operations configuration platform that achieves high efficiency, flexibility, and stability through visual tooling, workflow control, preview mechanisms, JSON‑based data, and a three‑stage architecture evolution from classic caching to SDK‑driven distributed caching.
This article explains how Swift's Codable protocol simplifies converting between JSON and native data structures, covering basic usage, handling nested objects, optional values, key mapping, date formats, enums, dynamic payloads, and custom types for robust iOS development.
The article explains why automated JSON comparison is needed in testing, introduces the json_tools library and a custom recursive approach for detecting differences, shows example outputs, explains the change descriptors, and compares the pros and cons of each method.
This article introduces the Lottie animation library, explaining its background, how it converts After Effects designs into lightweight JSON, its advantages and limitations, practical usage via npm or CDN, and suitable scenarios such as UI guides, loading and transition animations.
This article details the design, algorithmic challenges, and implementation of an automated JSON diff tool used in Qunar's Hackathon to compare complex API responses, handle unordered arrays, ignore configurable nodes, and provide fast, accurate regression testing for large JSON payloads.
This article explores PostgreSQL’s NoSQL capabilities by comparing JSON and JSONB data types, demonstrating their storage differences, read/write performance tests on millions of rows, index strategies, and the new full‑text search support for JSON/JSONB introduced in version 10.
This tutorial walks through using Python and browser developer tools to locate the NetEase Cloud Music comment API, extract encrypted request parameters, retrieve hot comments in JSON, and parse the Hot Songs chart to collect each song's name and ID with regular expressions.
This tutorial shows how to export WeChat Moments using a third‑party service, then build a Python Scrapy spider to crawl the exported pages, parse the JSON data, and save the moments to a file, with detailed commands and code examples.
This article shares a collection of practical testing shortcuts—including browser cache clearing methods, Chrome cookie management, MySQL query reuse, full‑database search techniques, JSON formatting plugins, and cookie editing tools—to help testers boost efficiency and reduce repetitive work.
MySQL 8.0 GA (8.0.11) brings up to twice the performance of 5.7, adds NoSQL document storage, window functions, hidden and descending indexes, CTEs, enhanced JSON handling, improved InnoDB reliability, built‑in high availability, and stronger security, while requiring in‑place upgrades and backups.
This article explains how Swift 4.0 introduced Codable, how Swift 4.1 added keyEncodingStrategy and keyDecodingStrategy to automatically convert between snake_case and camelCase, and how to implement custom key transformations such as PascalCase using the .custom strategy.
The XinYue Club App migrated from an HTTP + JSON text protocol to a compact, AES‑GCM‑encrypted binary JCE protocol, detailing header/body structures, compression, signature validation, and security measures, while comparing the readability and debugging ease of JSON against the performance and protection benefits of binary communication.
This article presents a comprehensive guide to API design for mobile applications, covering documentation standards, common request and response parameters, naming conventions, thin‑client principles, extensibility, security, compatibility, performance and user‑experience optimizations, with practical examples and code snippets.
When a Spring Cloud Feign client sends a request containing Java 8 date/time types like LocalDate, LocalTime, or LocalDateTime, the response may trigger JSON parse errors because Spring MVC serializes them as arrays, but Feign expects a proper object, which can be resolved by adding Jackson's JSR‑310 module and configuring the ObjectMapper.
This article walks through using Python to log into CSDN, capture the dynamic Geek News list via its JSON API, handle request parameters, and extract article titles and links, providing concise code screenshots for a complete web‑scraping solution.
Pluto is an iOS layout engine that uses JSON/JS files to describe UI elements, dramatically improving development efficiency while maintaining smooth performance and low memory usage for complex feed styles.
This article walks through the evolution of AJAX, explains how XMLHttpRequest works, introduces JSON as a lightweight data format, and shows how to handle cross‑origin requests with CORS, including practical code examples and a simple jQuery wrapper.
The article shows that replacing reflection‑heavy Gson with lightweight JSONObject for manual serialization and a compile‑time annotation‑processor generated library called Mson can cut JSON parsing and writing time to about one‑tenth, while maintaining compatibility and eliminating ProGuard rules for performance‑critical Android apps.
The December 2017 DB‑Engines ranking shows Oracle still on top, while PostgreSQL maintains steady growth, gaining momentum with JSON support and the Citus extension, as developers turn to it over NoSQL alternatives, signaling a potential shift in the database landscape.
This guide walks you through using MySQL's native JSON data type—creating tables with JSON columns, inserting simple and complex JSON values, updating nested structures, generating indexed columns from JSON fields, converting strings to JSON, and a comprehensive list of built‑in JSON functions.
MySQL 8.0 RC1 introduces major enhancements such as improved JSON handling, a full‑featured Document Store with transaction support, expanded Unicode and GIS capabilities, plus a suite of modern SQL features designed to better serve mobile‑first and cloud‑native applications.
This guide walks you through using Python to crawl Qunar’s tourist spot pages, retrieve location and sales data, enrich it with Baidu Map’s geocoding API, and then create interactive heatmaps and ranking charts with ECharts, while storing results in JSON and Excel files for further analysis.
Lottie, Airbnb’s open‑source animation library, parses After Effects‑exported JSON to render vector animations natively on Android, iOS, and React Native, letting developers share a single asset across platforms, simplify code, manage assets from assets, SD card or network, while balancing modest APK size increase against performance limits for complex scenes.
This article chronicles JavaScript’s journey from its humble origins in Netscape’s browser to becoming the dominant language for client‑side interactivity, asynchronous communication, JSON data exchange, and even server‑side development with Node.js, highlighting key milestones, technical concepts, and code examples.
This article explains how to transform raw Git diff output into a structured JSON format, handle various diff headers, and apply line‑by‑line highlighting using the diff‑match‑patch algorithm, while also offering performance optimizations for long lines.
This article presents a comprehensive Java benchmark that compares JSON libraries (Jackson, Fastjson, DSL‑JSON, Jsoniter, Thrift) with Google Protocol Buffers across various data types and structures, revealing where Protobuf truly outperforms JSON and where modern JSON parsers narrow the gap.
This article explains what JSON is, why it’s ideal for data exchange, contrasts it with JavaScript objects, and dives deep into JSON.stringify, JSON.parse, and toJSON, illustrating each concept with clear code examples and practical tips for developers.
This article benchmarks Java JSON libraries against Google Protobuf, analyzing decode/encode performance for integers, doubles, strings, objects, and lists, revealing that while Protobuf often outperforms JSON, optimized JSON libraries like DSL‑JSON can narrow the gap dramatically.
Learn how to store, retrieve, and manipulate JSON data in Redis using the ReJSON module, covering basic commands, advanced field operations, numeric updates, and step‑by‑step installation on Redis 4.0+, with practical code examples and configuration instructions.
The latest MySQL release introduces a transactional data dictionary, role‑based account permission management, multiple InnoDB enhancements—including stable auto‑increment counters, memcached multi‑key support, dynamic deadlock detection, shared temporary tables, and NOWAIT/SKIP LOCKED options—plus advanced JSON operators, aggregation functions, pretty‑print utility, and optimizer features such as hidden and descending indexes.
MySQL 5.7.7 adds a native JSON data type that validates documents, stores them in a pointer‑key/value structure for fast selective deserialization, provides rich functions and path expressions for manipulation, and enables indexing via generated virtual columns while defining clear comparison and sorting rules.
This article presents comprehensive API design standards for mobile apps, covering request/response conventions, naming rules, data type handling, security measures, compatibility, performance and user‑experience optimizations, and offers practical examples to help front‑end and back‑end engineers create robust, maintainable interfaces.
The article recaps a MySQL 8.0 optimizer meetup where experts discussed version naming, enterprise vs community edition differences, character‑set choices, storage‑engine evolution, hint usage, sharding strategies, high‑availability architectures, market position, and upcoming feature requests from the community.
This guide introduces MySQL 8.0’s new JSON aggregation functions, demonstrates how to create tables, insert data, and use JSON_ARRAYAGG and JSON_OBJECTAGG to combine rows into JSON arrays or objects, and provides a real‑world product‑attribute example that returns complete JSON structures.
