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.
This article walks through the major MySQL 5.7 enhancements—including InnoDB buffer‑dump improvements, multi‑threaded page cleaning, dynamic buffer‑pool resizing, global tablespaces, default DYNAMIC row format, native partitioning, truncate‑undo logs, native JSON support, sys schema, optimizer hints, trigger upgrades, syslog integration, and virtual columns—providing practical steps, examples, and usage tips for DBAs.
The article lists eight common complaints about MySQL—from deep‑rooted bugs and inflexible relational schemas to confusing forks, storage‑engine chaos, profit‑driven licensing, weak native JSON support, and proprietary extensions—highlighting why many developers consider alternatives.
By defining data collection (event tracking) requirements in a structured JSON format and storing them in Git with a web interface that abstracts version control, teams can standardize identifiers, validate data formats automatically, track changes via commit logs, and streamline collaboration between product managers, developers, and testers.
This guide demonstrates how MySQL 5.7.12’s new JavaScript‑based shell lets you query, insert, update, and delete both traditional tables and JSON document collections using intuitive method‑chaining syntax, eliminating the need for SQL knowledge and simplifying migration from MongoDB‑style workflows.
This guide demonstrates how to create MySQL tables with JSON columns, insert JSON data, perform queries using JSON functions, and update JSON fields, covering essential functions like JSON_CONTAINS, JSON_SEARCH, JSON_EXTRACT, JSON_MERGE, and JSON_SET.
MySQL 5.7 introduces major enhancements such as native JSON support, an expanded Performance Schema, a new SYS Schema for health monitoring, improved security, advanced GIS capabilities, three‑fold query throughput gains, InnoDB optimizations, multi‑source replication, and a smarter optimizer with dynamic costing.
Based on an analysis of 47,251 dependency declarations from 3,862 popular GitHub Java projects, this article presents the 100 most widely used Java libraries, highlights the top 20, examines the rise of Spring components, and discusses notable JSON and other standout libraries.
MySQL 5.7 adds native JSON document storage, merging relational database strengths with NoSQL flexibility, enabling developers to use a single system for both structured and document‑oriented data while preserving ACID transactions and indexing capabilities.
This article examines a MySQL table storing large JSON logistics data, analyzes why its size grows to 130 GB, and presents practical optimizations such as data archiving, JSON field reduction, and schema redesign to keep the table manageable.
This article explains practical methods for importing various external data formats—such as CSV, plain text, XML, and JSON—into MySQL, covering command-line utilities, LOAD DATA statements, stored procedures, third‑party tools like mysqljsonimport, and using MySQL Workbench, while addressing configuration and security considerations.
This guide introduces PHP's cURL extension, outlines its basic workflow, and provides clear GET and POST code examples, showing how to configure options, execute requests, handle responses, and decode JSON data into arrays or objects.
The article enumerates eight fundamental issues with MySQL—including deep‑seated bugs, rigid relational schemas, complex JOIN handling, confusing branch and storage‑engine choices, profit‑driven licensing, lack of native JSON support, and proprietary modules—while urging developers to consider more flexible alternatives.
This article examines why PostgreSQL claims to be the most advanced open‑source database by detailing its object‑relational model, extensive native data types, large‑scale size limits, robust ACID compliance, powerful indexing options, flexible virtual table features, built‑in functions, language extensions, and how these capabilities compare to MySQL, MariaDB and Firebird.
This article compares traditional relational tables with document‑oriented NoSQL, showing how JSON‑based storage simplifies handling multiple phone numbers, emails, addresses, and evolving contact data without schema changes or complex joins.
The article explains how JavaScript interprets JSON values without quotation marks as numbers, demonstrates the difference between numeric and string representations of the same value, and warns that large numeric literals may overflow a 32‑bit integer during internal conversion.
This article explains how MySQL 5.7 introduced native JSON support with validity checks, performance improvements, and virtual column indexing, compares it to MariaDB's dynamic column and PostgreSQL, and provides step‑by‑step SQL examples for creating, inserting, querying, and indexing JSON data.
This guide walks you through creating a lightweight WPF desktop application that leverages Baidu Translate’s public API to translate words, covering API key acquisition, HTTP GET requests, JSON parsing with Newtonsoft.Json, UI design in XAML, and handling special characters, enabling instant word translation without ads.
