This guide explains how to create .http/.rest files in IntelliJ, write and run GET requests, use variables and environment files, separate multiple requests, and share request definitions securely with a team, providing practical examples and code snippets.
This guide provides Java backend developers with a comprehensive collection of practical Linux commands for CentOS 7.6, covering system service management, file operations, compression, disk and network monitoring, as well as software installation and package management, all illustrated with clear examples and screenshots.
Spring Boot’s latest multi‑version release, now available via repo.spring.io and Maven Central, delivers critical bug fixes and a security patch for CVE‑2020‑5421, with detailed version‑specific changes for 2.3.4, 2.2.10, and 2.1.17, including the number of fixes and upgrade notes.
Java 15, released in September 2020, brings fourteen major enhancements—including EdDSA signatures, hidden classes, reimplemented networking APIs, production‑grade ZGC and Shenandoah GCs, permanent text blocks, sealed classes, pattern‑matching instanceof, records, and foreign memory access—while showcasing significant contributions from Chinese tech firms to the OpenJDK community.
The article introduces Tars, an open‑source high‑performance RPC framework and integrated service governance platform derived from Tencent's internal microservice architecture, detailing its design philosophy, layered architecture, core features such as the Tars protocol, load balancing, fault and overload protection, and centralized configuration management.
This article explains the design and implementation of RocketMQ transactional messages, covering a complete order‑creation example, the producer’s transaction listener, the broker’s handling of half messages, transaction checks, and the final commit or rollback process.
Tencent Cloud API 3.0 introduces a unified, secure, high‑performance API Gateway that centralizes access, routing, and lifecycle management for microservices, offering standardized interfaces, multi‑language SDKs, CLI and Explorer tools, precise rate limiting, rich documentation, and a roadmap toward industry‑wide standardization and broader scenario adoption.
This article explains how Kafka relies on ZooKeeper to store cluster metadata, detailing the ZK node hierarchy, the process by which clients locate brokers, the broker‑side handling of metadata requests, and recommended practices for large‑scale deployments.
This article details Eastern Securities' journey from monolithic systems to a microservice architecture, describing the design and implementation of the gRPC-Nebula service governance framework and the Starry Service Governance Platform, their technical features, performance tests, multi‑language support, and the practical outcomes of the digital transformation.
The article explains the challenges of API version control, introduces canary release as an alternative deployment strategy, and illustrates its practical implementation at ING Bank, highlighting benefits such as gradual rollout, easy rollback, and improved stability for continuously evolving APIs.
This article walks through the design, parameterization, and Java implementation of load‑testing scripts for two related APIs—one that creates a resource and another that deletes it—covering special handling of duplicate IDs, method encapsulation with default arguments, concurrent execution, and visual result analysis.
This article presents a comprehensive guide for Java developers on improving code quality by introducing common utility functions, splitting oversized methods, ensuring consistent block levels, encapsulating repeated logic, reducing nesting depth, and eliminating unnecessary null‑checks, each illustrated with concrete code examples and clear recommendations.
This article introduces Spring MVC, explains the problems of mixing JSP and Servlets, details the MVC layered architecture, walks through essential configuration files and Maven dependencies, presents sample controller code, and analyzes the DispatcherServlet source to illustrate the complete request‑response flow in a Java web application.
The article presents Hmily’s monthly report, detailing its high‑performance distributed transaction solution, recent architectural refactoring, newly added modules and SPI implementations, community‑driven bug fixes and feature releases, and outlines upcoming versions supporting TCC and TAC modes.
This article explains PHP's preg_replace function, detailing its signature, parameter meanings, return values, and providing multiple code examples that demonstrate pattern matching, backreferences, array handling, and replacement limits for effective string manipulation in backend development.
This article provides a comprehensive overview of RabbitMQ, covering its origins, core components, message routing patterns, persistence mechanisms, delivery modes, RPC support, clustering design, mirrored‑queue architecture, and flow‑control strategies for building reliable backend systems.
This guide explains why programmers often keep side‑project work private, recommends a ready‑to‑use SpringBoot backend toolkit, lists popular freelance platforms, and offers practical advice on quoting, payment terms, contracts, and key tips for successful freelancing.
This article describes a complete solution for generating customized Robot Framework test reports by parsing the output.xml file, extracting test case statistics and details with Python, rendering them into an HTML template using Jinja2, and finally sending the report via email.
This article introduces MyBatis's underlying architecture by explaining the six core interfaces—SqlSession, Executor, StatementHandler, ParameterHandler, ResultSetHandler, and TypeHandler—detailing their roles, key methods, caching mechanisms, and how they are instantiated within a Spring Boot environment.
This article explains MyBatis dynamic SQL, describing each core XML tag (if, choose/when/otherwise, where, foreach, set, sql, include), showing practical code snippets, and offering advanced tips such as avoiding magic numbers and referencing SQL fragments across mapper files.
Hutool is a popular open‑source Java utility library that consolidates common JDK functions into easy‑to‑use modules, offers numerous components such as AOP, caching, cryptography, and HTTP, and can be added via Maven or Gradle to streamline development and reduce repetitive code.
This article explains Redis server's event-driven architecture, detailing how file events (read/write) and time events are processed, illustrated with state diagrams, pseudocode, and examples that show the interaction, scheduling, and impact on server performance.
This guide explains how to configure Celery to use Redis as both broker and result backend, covering project layout, code setup, task definition, execution flow, task states, and common control operations for asynchronous Python workloads.
Tencent Cloud’s Serverless Cloud Function (SCF) removes its language restrictions by providing a Custom Runtime that runs any Linux binary or script as a bootstrap, communicates with SCF via an HTTP API during cold‑start initialization and hot‑start invocations, enabling developers to deploy functions in unsupported languages such as .NET, Rust, Deno, Swift or WebAssembly, as shown by a Deno example.
The article explains microservice fundamentals, the challenges of client‑to‑service communication, and how API gateways, Backend‑for‑Frontend patterns, and Service Meshes address these issues while outlining key gateway features, popular implementations, and selection criteria for robust backend architectures.
This article introduces the Hutool Java utility library, showing how to install it via Maven and demonstrating 16 frequently used utility classes—including Convert, DateUtil, JSONUtil, StrUtil, and more—with concise code examples that illustrate simplifying common development tasks.
This event features an architect from JD.com's backend team discussing strategies for designing high-availability, high-performance order systems to handle massive concurrent orders during major sales events like 618, based on real-world case studies and Elastic technology implementations.
This article explains how to employ custom Java annotations together with reflection to mask sensitive fields in logs, define flexible desensitization rules, and dramatically reduce repetitive code when building fixed‑length, signed bank API requests, improving maintainability and extensibility of backend services.
This article presents a cloud‑based shared proxy solution that addresses common pain points of local proxy tools by enabling multi‑user configuration sharing, isolation, mock & host management, data persistence, analysis, and monitoring, thereby improving development and testing efficiency for teams.
Analyzing recent Stack Overflow surveys and GitHub trends, this article explains why Go's efficiency, simplicity, and rising popularity make it a strong contender for the best backend programming language in 2021, even as JavaScript and Python dominate the market.
The article shares the author's recent move to Xi'an, discusses the local job market, and provides detailed interview questions and answers on Java backend topics such as Redis replication, Kafka performance, MySQL transactions, and JVM garbage collection to help job seekers prepare effectively.
This article explains Kafka's role as a message system, details its fundamental components such as topics, partitions, producers, consumers, and replicas, describes how Zookeeper coordinates the cluster, and explores performance optimizations like sequential writes, zero‑copy, and network design.
This article explains why abrupt service restarts cause "Can not get connection to server" errors in Zookeeper‑based microservices and details a Java ShutdownHook solution that deregisters instances, processes in‑flight requests, and prevents client‑side failures during graceful shutdown.
This article explains why short URLs are used in spam SMS, outlines their benefits, describes the basic principle of mapping long URLs to short ones, and details service design choices such as storage, one‑to‑one mapping, high‑concurrency handling, distributed ID generation, and provides a Java implementation using Redis.
This article presents a comprehensive, practical case study of diagnosing and resolving high‑concurrency performance issues in an SSM‑based e‑commerce system, covering architecture overview, problem identification, root‑cause analysis, JVM/Tomcat/Redis/MySQL tuning, load‑balancing, and post‑optimization monitoring results.
This article explains how to design and implement custom Java annotations for field validation, permission checks, and caching, covering annotation definitions, target and retention policies, validator classes, interceptor and aspect implementations, and practical usage examples within Spring MVC.
The article explains how to use Groovy's operator‑overloading features to create a JSONPath‑style verification DSL, detailing which operators are implemented, the challenges with sign‑conversion operators, and providing a full example class with logging for each overloaded operator.
When a business platform’s settings page took 36 seconds to load, we used Chrome’s Network timing, Python profiling, and MySQL query analysis to identify backend bottlenecks, then applied redesign, thread‑pooling, batch queries, and ORM optimizations, reducing response time from 37.6 s to 1.47 s.
This article explains how to install, configure, and test MySQL 8.x query‑rewriter and DDL‑rewriter plugins, demonstrating environment setup, sample SQL scripts, rule creation, and the impact on query performance and CREATE TABLE statements.
ElasticJob 3.0.0‑alpha introduces a Spring Boot starter for ElasticJob‑Lite, one‑time tasks, expanded database support for execution logs, environment‑variable IP declaration, and several API changes including a new Maven groupId, package name, namespace, SPI‑based job types, and modular UI separation.
This article provides a comprehensive overview of Java's exception hierarchy, key keywords, handling techniques, common interview questions, and best‑practice guidelines, illustrating concepts with numerous code examples to help developers write robust and maintainable backend code.
Alibaba’s FaaS platform for Youku content distribution replaces traditional Java services with a gateway‑driven, containerized function runtime and one‑stop development/ops portal, delivering low‑cost development, isolated JVM execution, transparent monitoring, and rapid API and data‑source integration, dramatically speeding iteration while addressing classloader and lifecycle challenges.
A newly hired architect boasts high‑concurrency expertise but writes un‑commented Java code that misuses ConcurrentHashMap, leading to memory leaks; the ensuing investigation reveals missing equals/hashCode implementations, race conditions in a visit method, and a debate between synchronized blocks and putIfAbsent for safe updates.
This article outlines the design, key technical challenges, and practical implementation of Alibaba’s Youku FaaS platform, detailing its architecture, runtime environment, development workflow, and how serverless functions improve development efficiency, deployment speed, resource isolation, and operational monitoring for large‑scale content distribution.
The article explains common misconceptions about application layering, presents Alibaba's multi‑layer architecture (open‑interface, terminal display, web, service, manager, DAO), proposes an optimized layering model with RPC, and discusses domain‑model conversions such as DO, DTO, BO, AO, VO and Query to achieve clear responsibilities and maintainable code.
This guide explains Java exception classification, the default rollback behavior of Spring's @Transactional annotation, and how to configure rollback for checked and unchecked exceptions while offering best‑practice recommendations for transactional method design.
This article explains how Spring Boot simplifies Java application development by providing out‑of‑the‑box starters, automatic configuration via spring.factories, and convention‑over‑configuration rules, covering the underlying annotations, Maven structure, starter dependencies, main class, and the use of @ConfigurationProperties to bind YAML settings.
This article explains the internal workings of Java's HashSet, covering its overview, various constructors, the add and remove operations implemented via HashMap, traversal techniques, and how LinkedHashSet and TreeSet extend HashSet functionality, providing code examples and conceptual diagrams.
This article examines Lombok's ability to auto‑generate boilerplate code such as getters, setters, toString, and equals, demonstrates its usage with Maven dependencies and annotated examples, and discusses its advantages and drawbacks—including IDE reliance, JDK compatibility, and debugging challenges—before concluding with a recommendation for its selective use.
This article explains how to handle session sharing in distributed systems through replication, sticky sessions, or a dedicated session server, and addresses cache penetration and avalanche issues with practical mitigation techniques such as request filtering, empty-object caching, hash repositories, Redis clustering, staggered expirations, and concurrency controls.
This tutorial walks you through creating a Flask‑based search engine powered by Elasticsearch, covering configuration files, logging setup, blueprint routing with pagination, project startup using Flask‑Script, and production deployment with Gunicorn, complete with code examples and essential tips.
Spring Boot Admin version 2.2.4 has been released as a bug‑fix update that adds compatibility with Spring Boot 2.3.x, includes a brief overview of its monitoring capabilities, provides Maven dependency snippets, and lists the resolved issues and a link to the GitHub repository.
This article explains the role of an access‑layer gateway, presents its architecture and implementation using OpenResty, discusses technical selection, details OpenResty’s underlying Nginx/Lua mechanisms, and shows how to achieve dynamic routing, plugin‑based policies, shared data, and upstream configuration without service reloads.
This article explains the concepts of Domain‑Driven Design, why it has gained traction in China’s internet industry, and how Alibaba Entertainment applies strategic and tactical DDD practices—such as model annotation, health‑check, and hexagonal architecture—to improve scalability, readability, and maintainability of its micro‑service systems.
This article explains Spring Boot's auto‑configuration mechanism, detailing the roles of starters, spring.factories, @EnableAutoConfiguration, related annotations, and the AutoConfigurationImportSelector, while showing source code examples and how to customize or disable specific auto‑configurations.
This article reviews PHP 8’s most impactful new features—including first‑class attributes, constructor property promotion, match expressions, union types, and named arguments—showing code examples and explaining how they modernize PHP development.
This article examines common pitfalls in API design, argues that the consumer of an interface should drive its design, and presents concrete examples and best‑practice recommendations for structuring endpoints, meta data, and choosing appropriate communication protocols.
This article explains the core principles of Spring Boot’s auto‑configuration mechanism, details the roles of @EnableAutoConfiguration, spring.factories, AutoConfiguration classes and related annotations, and demonstrates how to customize or disable auto‑configuration with code examples.
This article explains the PHP file_get_contents function, detailing its purpose of reading an entire file into a string, describing each parameter and return value, and providing multiple practical code examples demonstrating basic usage, include path handling, partial reads, and custom stream contexts.
This article introduces Kafka Connect, a framework for building scalable data pipelines between Kafka and other systems, covering its architecture, key concepts like connectors and tasks, and practical deployment examples.
The article explains the differences between thread, process, and distributed locks, describes how distributed locks are implemented using third‑party storage like Redis or Zookeeper, and discusses their practical use cases, advantages, and design considerations in high‑concurrency backend applications.
This article explains how Spring Boot automatically detects cache providers, shows how to replace the default ConcurrentHashMap with EhCache by adding the dependency, configuring ehcache.xml, and verifying the CacheManager type through unit tests, providing complete code examples and step‑by‑step instructions.
This article explains how Spring Boot 2.3 provides built‑in graceful shutdown for embedded web servers, how to enable it with configuration, the role of the Shutdown enum and timeout settings, and additional techniques such as Actuator endpoints and signal handling to ensure safe application termination.
This article introduces Go (Golang) as a statically typed compiled language, walks through downloading and installing the Go toolchain, explains essential syntax such as slices, pointers, and channels with code examples, and briefly reviews popular Go web frameworks like Beego, Iris, and Buffalo.
This article presents sixteen practical Spring Boot best‑practice recommendations—from using custom BOMs and auto‑configuration to structuring code, handling concurrency, externalizing configuration, and testing—aimed at building clean, maintainable, and production‑ready Java microservices.
The author shares a first‑hand account of a newly launched backend project, explaining how strict coding standards, Groovy‑Java mixed development, and a pragmatic testing strategy—including limited unit testing, interface checks, and annotation‑based validation—enabled rapid bug resolution and a smooth release.
This article explains the purpose, usage, and underlying meta‑annotations of Spring’s core stereotype annotations—@Component, @Controller, @Repository, and @Service—showing how they enable classpath scanning, define component roles, and improve application startup performance.
This article introduces the Go programming language, guides readers through downloading and installing the Go toolchain, explains essential syntax such as slices, pointers, and channels with code examples, and surveys popular Go web frameworks like Beego, Iris, and Buffalo for backend development.
The article introduces kk-anti-reptile, a Spring Boot‑based anti‑crawler component that uses servlet filters, Redis, and configurable rule chains (IP and User‑Agent), explains its workflow, shows Maven and property configurations, and provides front‑end Axios interception code for handling 509 responses.
This article explains Redis transactions in depth, covering their command workflow, the MULTI/EXEC/DISCARD/WATCH/UNWATCH commands, error handling, practical code demonstrations, and a comparison with MySQL transaction semantics to help readers master Redis transaction usage for interviews and development.
This guide explains monolithic and microservice architectures, compares their advantages and drawbacks, outlines suitable scenarios, and reviews popular Java backend frameworks and versioning strategies to help developers choose the right approach for scalable applications.
COLA 3.0 removes unnecessary components such as Command, Interceptor, Convertor, Validator, and Assembler, applying Ockham’s razor to simplify the framework, improve readability, and reduce maintenance overhead while preserving essential extension points, illustrating how leaner architecture can enhance Java application development.
This article provides a concise overview of SpringBoot, covering its core functionalities, pros and cons, CLI tool, Maven build setup, and frequently used annotations, followed by a promotion for a comprehensive interview question PDF collection targeting major internet companies.
This article explains the definitions, distinctions, and practical usage of View Object (VO), Data Transfer Object (DTO), Domain Object (DO), and Persistent Object (PO) in layered software architecture, illustrating their roles, conversion processes, and design considerations for clean separation of concerns.
This article explains how to upgrade the think-mongo module for ThinkJS to work with MongoDB 4.x, detailing API changes, new CRUD method mappings, transaction support, and provides code examples for adapting existing projects to the latest MongoDB features.
The voting service for 'You Are My Youth 2' was re‑architected using Docker‑based QAE and the Skywalker microservices platform, adding containerized one‑click scaling, cross‑data‑center MySQL/Couchbase/HBase high availability, and Hive/Impala real‑time processing, which doubled performance, cut preparation from 30 days to 12 hours, and incorporated third‑party audit verification.
This article provides a comprehensive overview of HTTP status codes—from informational 1xx responses to client‑error 4xx and server‑error 5xx codes—including the newer RFC 6585 codes, explaining their meanings and typical usage scenarios for developers.
This article explains Nginx's high performance by detailing its multi‑process architecture, asynchronous event‑driven I/O, request handling flow, module types, comparison with Apache, maximum connection calculations, HTTP request/response structure, and the differences among select, poll, and epoll.
This article explains how to integrate Spring Boot Actuator for exposing health and metrics endpoints, configure security, disable specific endpoints, and visualize monitoring data using JConsole and Spring Boot Admin, including necessary Maven dependencies and code examples, while also noting a promotional interview‑question PDF resource.
The article explains PHP's strncmp function, a binary‑safe, case‑sensitive string comparison that compares the first N characters of two strings, detailing its syntax, parameters, return values, and providing practical code examples with expected outputs.
This article explains the PHP strcmp() function, describing its binary‑safe, case‑sensitive string comparison behavior, detailing its parameters and return values, and providing multiple code examples that illustrate how different string inputs affect the function’s output.
This article explains Java's throw‑catch mechanism, the three core principles of exception handling, and demonstrates how to design a custom exception hierarchy and a Spring Boot @ControllerAdvice‑based global handler to simplify error processing and improve code maintainability.
This article surveys the rise of microservices, explains their advantages, and provides a concise overview of the most popular Java, .NET, Node.js, Go, and Python frameworks that enable developers to build scalable, loosely‑coupled services.
This article presents a curated list of sixteen IntelliJ IDEA plugins compatible with version 2020.1, detailing each plugin's purpose, key features, usage shortcuts, and visual screenshots to help Java developers enhance productivity and code quality.
This article explains the Java RMI communication model, the need for object serialization, the requirements for serializable classes, and provides complete example code for a Person class, object I/O operations, and a simple socket‑based stub‑skeleton implementation to demonstrate remote object retrieval.
This article explains how to use Maven parent POMs, properties, and BOM (Bill of Materials) to centrally manage version numbers across multi‑module Java projects, resolve dependency conflicts, and simplify builds for backend development teams.
This article provides a concise yet comprehensive overview of the backend development technology stack, covering load balancing, microservice ecosystems, RPC frameworks, service discovery, relational and NoSQL databases, caching strategies, message queues, object storage, and search engines, while highlighting practical configurations and real‑world trade‑offs.
This article examines Project Lombok’s ability to cut boilerplate in Java, walks through before‑and‑after code examples, and reveals five major drawbacks—including JDK compatibility, forced adoption, readability issues, increased coupling, and technical debt—helping developers decide whether to embrace or avoid Lombok.
An upgrade of MyBatis from 3.2.3 to 3.4.6 caused parameterType mismatches in XML mappings, turning previously ignored type declarations into enforced ones, which led to ClassCastException errors for LocalDateTime and other types, prompting a root‑cause analysis and recommendations for careful version testing and configuration alignment.
The article shares personal experiences with Kotlin coroutines, highlighting debugging challenges, loss of context across threads, pitfalls of using ThreadLocal, synchronization issues, and performance trade‑offs, ultimately explaining why the author stopped using coroutines for server‑side development.
This article walks readers through building a high‑efficiency API testing workflow using Swagger’s automated documentation and Springfox integration, covering setup, configuration, mock services, code coverage, keyword‑driven automation, and practical deployment examples with Maven dependencies and live Swagger UI demonstrations.
This article explains PHP's strstr() function, detailing its purpose of locating the first occurrence of a needle in a haystack string, describing its parameters and return values, noting case‑sensitivity and performance considerations, and providing two practical code examples.
This article explains the inner workings of Spring Boot’s @SpringBootApplication annotation, the loading of auto‑configuration classes from META‑INF/spring.factories, the refresh of the application context, the creation of the embedded Tomcat server, and demonstrates how to create a custom starter with configuration properties.
This article presents a concise Redisson distributed‑lock example with Maven configuration, demonstrates basic lock usage, enumerates the Redis commands and Lua script semantics involved, and provides a detailed walkthrough of the relevant Java source code, highlighting key implementation details.
This article examines the trade‑offs of using Project Lombok in Java projects, showing how its syntactic sugar reduces boilerplate but can introduce technical debt, version‑compatibility issues, hidden coupling, and readability problems that may outweigh its short‑term benefits.
After a year of using Project Lombok, the author reflects on how the library initially simplifies Java boilerplate but eventually introduces technical debt, version‑compatibility issues, hidden complexity, and tighter coupling, urging teams to weigh its short‑term convenience against long‑term maintainability.
This article explains how Redis can be used for distributed locking, covering the setnx command, the SET command with NX and PX options, common pitfalls, Lua‑based atomic unlock scripts, the Redisson client, and the RedLock algorithm for achieving reliable locks across multiple nodes.
This guide walks through installing the RabbitMQ delayed‑message‑exchange plugin, configuring it in a Spring Boot application, and building Java components to send and receive delayed order‑cancellation messages, comparing the plugin approach with dead‑letter queues and providing complete code snippets and deployment steps.
This article explains how to replace repetitive if‑else rule checks in PHP with a generic rule module using the Strategy design pattern and reflection, providing step‑by‑step code examples, architectural diagrams, and a clear path to extend rules without modifying client code.
Learn how to efficiently convert between PO, VO, and DTO objects in Java using Spring BeanUtils for identical fields and MapStruct for custom mappings, including single objects, lists, and merging multiple sources, with full Maven setup and generated implementation details.
