This tutorial walks through using Fastjson to create, add, delete, retrieve, and manipulate JSON objects in Java, highlighting common pitfalls and showcasing advanced methods such as compute, computeIfAbsent, and custom iteration techniques.
This article explains how leveraging JSON serialization can dramatically simplify and accelerate Java unit test development by reducing boilerplate code for data mocking and verification, offering practical examples, naming conventions, resource organization, and integration tips for backend projects.
This article introduces MySQL 8.0’s enhanced JSON capabilities, covering data types, storage limits, indexing, core functions like JSON_SET, JSON_EXTRACT, path expressions, merging, and the JSON_TABLE feature, while providing practical code examples for developers.
The article compares Go's built‑in encoding/json with third‑party libraries jsoniter, easyjson, jsonparser, and the author's jsonvalue, outlining each one's features, performance benchmarks, and ideal use cases—standard library for simplicity, easyjson for maximum speed with code generation, jsonparser or jsoniter for selective extraction, and jsonvalue for flexible, case‑insensitive handling.
This guide walks Java developers through installing Groovy, using its .groovy files, manipulating lists, maps, conditionals, loops, and leveraging built‑in JsonBuilder and HTTPBuilder for JSON handling and HTTP requests, all with clear code examples.
This article introduces MySQL 8.0's enhanced JSON capabilities, covering key constraints, storage functions, GeoJSON support, indexing, in‑place updates, essential JSON utilities, path expressions, extraction, modification techniques, and the powerful JSON_TABLE feature with clear code examples.
This tutorial demonstrates how to use Go's standard and third‑party libraries to parse and generate YAML, JSON, and XML files, covering data structures, unmarshalling, marshalling, handling maps, and producing readable output with code examples.
This guide demonstrates how to transform a JSON array into a CSV file with pandas, then sort the resulting CSV by specific columns using two different Python approaches, providing complete code snippets and explanations for each step.
This article summarizes the most useful MySQL 8.0 JSON features—including storage limits, indexing, in‑place updates, path expressions, merging, and table functions—providing clear code examples and guidance for developers who need to work with JSON data in MySQL.
This article explains the purpose of configuration files, compares common formats such as INI, JSON, TOML, and YAML, and demonstrates how to read each of them in Python using built‑in libraries or third‑party packages while highlighting their advantages and pitfalls.
This guide explains how Spring MVC can automatically negotiate response formats using the Accept header, allowing a single endpoint to return either JSON or XML based on a query parameter or MIME type, without duplicating code or routes.
This article shares practical experiences and lessons learned while integrating with Jira's REST API, covering the absence of Chinese documentation, handling of HTTP status codes, inconsistent and overly nested JSON responses, demo errors, mixed language fields, and the differences between POST and PUT methods.
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.
This tutorial demonstrates how to capture network packets from the Super Schedule Android app, perform a login request with required headers, and repeatedly fetch and parse topic data using Python urllib2 and JSON handling, enabling infinite scrolling of user‑generated topics.
This article presents a collection of practical Python techniques, including variable swapping without a temporary variable, using dictionary and set comprehensions, leveraging the Counter class for counting, pretty‑printing JSON, solving FizzBuzz concisely, inline conditional expressions, list slicing, dictionary get method, and generating combinations with itertools.
This article explains how to modify JMeter's source code so that the JDBC Request sampler returns results in a clean JSON format, covering environment setup, code changes, building the custom JAR, integration, and the resulting improvements in readability and automation.
This article demonstrates how to call third‑party APIs in Java projects by importing the HttpClientUtil utility, performing GET and POST requests (with and without parameters), handling JSON responses with a custom JsonUtils class, and includes complete code examples for each step.
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 Dolphin system for JD International channel introduces a fully configurable, drag‑and‑drop custom layout architecture that separates layout and content data, enabling business users to build personalized floor modules with minimal coding and deploy them instantly across web, mobile, and mini‑program platforms.
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.
This article explains the difference between FastJSON's getInteger and getIntValue methods, analyzes a common validation bug in a custom isRight() implementation, and provides corrected code examples and optional global switches for robust response handling in Java backend projects.
This guide explains how to use the JavaScript Fetch API to retrieve and send JSON data, covering basic GET requests, parsing responses, configuring request options, handling POST submissions with appropriate headers, and using polyfills for unsupported browsers.
This tutorial walks you through analyzing a JavaScript‑driven website, discovering the hidden API, configuring request headers with Postman, and writing a Python scraper that extracts book titles, authors, codes, and prices from epubit.com.
This article compares ClickHouse and Elasticsearch for API log storage, detailing development activity, schema handling, query performance, statistical functions, MySQL integration, new features, and practical drawbacks, while providing concrete SQL examples and migration tips.
This article presents a complete Python‑based seat reservation system that uses PySide2 to build an interactive graphical interface for selecting and booking seats, stores configuration and occupancy data in JSON files, and provides command‑line utilities for checking in, checking out, making reservations, and handling temporary leaves, illustrating both front‑end UI design and back‑end logic in a single project.
This guide walks you through analyzing Toutiao’s Ajax requests, extracting image URLs, and using Python’s requests library to download street‑photo pictures in bulk, complete with code snippets and tips for pagination and future enhancements.
Prometheus HTTP Service Discovery (HTTP SD) offers a flexible, JSON‑based approach for dynamically locating targets, contrasting with file‑based SD in event handling, update frequency, format, transport, and security, while outlining endpoint requirements, response headers, and providing concrete JSON examples for practical implementation.
This tutorial explains how to move data desensitization to the JSON serialization stage using Jackson, defines a @Sensitive annotation, custom strategies, a contextual serializer, and demonstrates the approach with a User class example that masks personal fields during serialization.
This article provides a detailed examination of the YYModel framework’s source code, explaining how it leverages Objective‑C runtime to parse JSON into model objects, covering key files, internal classes, mapping mechanisms, and the core conversion methods with illustrative code examples.
This tutorial demonstrates how to use the jq command‑line tool to extract an array of objects from a JSON file, reshape the data into a two‑column format, and output it as properly formatted CSV, including handling of quoting and raw output options.
This tutorial explains how to integrate AJAX fetch calls with Django views for both GET and POST requests, covering header configuration, CSRF handling, JSON data exchange, and the updated method for detecting AJAX requests in Django 3.1 and later.
The article compares ClickHouse, Elasticsearch, and MySQL for log storage and analysis, highlighting ClickHouse's active development, SQL support, JSON handling, performance, storage efficiency, integration options, and practical query examples to help developers decide the best backend for observability pipelines.
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 explains how to create, read, and write JSON files using Python's json module, load them into Pandas dataframes, perform data manipulation, rename columns, save to CSV, fetch JSON from URLs, and visualize the data with Seaborn, providing code examples and visual illustrations.
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 tutorial explores jq's advanced capabilities, demonstrating how to combine filters with the pipe operator, use functions like keys, length, select, map, and join, and transform JSON data into new structures and formats through practical command‑line examples.
This step‑by‑step guide shows how to log into Toutiao, locate the fan list via browser dev tools, capture the AJAX request URLs, decode Unicode nicknames, paginate through all pages, and save the results as JSON using Python.
This article explains the difference between MySQL multi-value indexes and composite indexes, demonstrates how to create and query multi-value indexes using JSON columns, and shows performance benefits and practical scenarios when dealing with tables that have a large number of columns.
This guide shows how to use the jq command‑line tool to elegantly format, query, and extract data from JSON responses across Linux, Windows, and macOS, providing practical examples, syntax basics, and integration with curl for API testing.
This tutorial demonstrates how to use Python, requests, and openpyxl to analyze a job‑listing website, construct the appropriate Ajax URLs, write a scraper that parses JSON responses, and export the collected position data into an Excel workbook.
This article explains how to create a custom Spark DataSource that reads JSON data from a standard REST API, covering the design of DefaultSource, schema inference, data fetching, and integration with Spark SQL for seamless downstream processing.
This article explains how to use MySQL's EXPLAIN FORMAT=JSON to view detailed execution plan costs, illustrates table structures, walks through two query examples with cost breakdowns, and clarifies the calculation of read_cost and eval_cost for both simple and join queries.
This article provides a comprehensive guide to using Jackson with Spring Boot, covering its core modules, Maven dependencies, ObjectMapper usage, JSON tree model, custom deserializers, XML handling, configuration options, and practical code examples for serialization and deserialization.
The article examines Fastjson’s features, demonstrates basic usage, compares it with other Java JSON libraries, and explains why the author decided to abandon Fastjson due to its lower popularity, design shortcomings, numerous open issues, and a history of serious AutoType vulnerabilities.
This guide explains how to install the GsonFormat plugin in IntelliJ IDEA and use it to quickly transform JSON strings into JavaBean classes with generated getters and setters, dramatically reducing manual mapping effort and improving development efficiency.
This article chronicles the step‑by‑step evolution of Kuaishou's special‑effects authoring tool—from early QWidget layouts through QML redesign, then JSON/Lua configuration, and finally dynamic QML loading—highlighting how each stage reduced code size, improved developer efficiency, and enabled seamless hot updates without app releases.
This article explains why PHP's json_encode sometimes returns a JSON object instead of an array, demonstrates several common scenarios, and provides practical code solutions to ensure the desired array format in the resulting JSON.
This article introduces nine popular JSON tools—including online validators, formatters, comparators, CLI utilities, IDE plugins, and editors—that help developers verify, format, compare, and manipulate JSON data efficiently across various platforms.
This guide reviews fifteen essential Python packages—from data‑visualisation with Dash and image handling with Pillow to web requests, JSON parsing, and home automation—explaining their key features, typical use‑cases, and why they’re valuable tools for developers.
This guide demonstrates how to retrieve a list of WeChat public account articles by constructing the appropriate API URL, examining its query parameters, viewing the JSON response, and using a Python script to parse the data and generate a markdown file of titles and links.
This tutorial explains what an API is, shows how to install and use the Python requests library to make GET requests, interprets common HTTP status codes, and demonstrates parsing JSON data from the Open Notify ISS API using the built‑in json module.
This article explains how the KEMIS framework provides a universal, declarative JSON‑based solution for building Management Information System (MIS) pages, covering component declaration, data fetching via initApi and api, variable resolution, expression‑based attributes, and custom component registration with React examples.
This article provides PHP functions that demonstrate how to perform HTTP GET, POST, and JSON‑encoded POST requests using cURL, including error handling, timeout settings, SSL options, retry logic, and a usage example for calling an API.
This article explains how to design a non‑intrusive unified JSON response structure for Spring MVC applications, defines the standard JSON schema, provides Java enums and generic Result classes, demonstrates usage with @ResponseResultBody and @RestControllerAdvice, and shows comprehensive exception handling techniques.
This tutorial demonstrates how to use Jackson's ObjectMapper and ObjectNode to programmatically add, modify, and delete fields in JSON strings or Java objects, providing clear code examples and explaining the underlying JsonNode API for flexible JSON manipulation.
This article demonstrates how to use standard shell utilities such as grep, cut, sort, uniq, awk, and join to quickly extract insights—like top companies, common surnames, popular given names, age distribution, and hometown rankings—from a JSON dataset of Beijing points‑based residency applicants.
This guide shows how to install the "Little Emperor" VSCode extension, add a 20‑in‑1 NES game pack, configure a list.json file with ROM metadata, and launch classic games like Contra and Mario directly inside the editor, complete with usage tips and warnings.
This article explains why configuration files are essential, compares popular formats such as INI, JSON, TOML, and YAML, and provides Python code examples for reading each type while highlighting their advantages, limitations, and security considerations.
This tutorial walks you through using Python's requests, lxml, and JSON parsing to automatically crawl the King of Glory website, extract hero skin URLs, and download the images into organized folders while displaying progress in the console.
This tutorial walks you through creating a Spring Boot web project, adding the starter dependency, implementing a REST endpoint, customizing Tomcat port and context path, and configuring Jackson for JSON output such as date formatting and global ObjectMapper settings.
This article explains how MySQL 8.0’s JSON data type enables range‑based traversal of JSON arrays, demonstrates extracting array elements with path expressions, and provides stored‑procedure examples—both a traditional loop version and an optimized version using the new "$[m to n]" syntax.
This tutorial explains how Spring Boot returns JSON using the default Jackson library, compares it with Alibaba's FastJson, demonstrates handling of null values, and shows how to encapsulate responses in a unified structure with status codes and messages for backend development.
This article demonstrates how to design a non‑intrusive, unified JSON response structure for Spring Boot applications, defines a standard Result wrapper and status enum, shows static factory methods, and explains global handling via @ResponseResultBody, @RestControllerAdvice, and centralized exception processing.
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.
