The article explains how using the week‑based year pattern (YYYY) instead of the calendar year pattern (yyyy) in Java's SimpleDateFormat can cause dates like 2019‑12‑31 to be displayed as 2020‑12‑31, illustrating the issue with code examples and a clear explanation of the underlying rules.
This article presents a step‑by‑step tutorial for building a console‑based food delivery ordering system in Java without a database, covering entity class design, DAO interfaces, management classes for admins, dishes, orders and users, as well as a menu‑driven UI and sample test code.
The article explains a subtle Java date‑formatting bug where using the week‑based year pattern (YYYY) can incorrectly display the next calendar year for dates at year‑end, demonstrates the issue with sample code, and clarifies why yyyy should be used for ordinary year representation.
This article explains why Spring’s field injection is discouraged, compares constructor‑, setter‑, and field‑based injection methods, outlines the drawbacks of field injection such as final‑field incompatibility and hidden dependencies, and recommends using constructor injection for required beans and setter injection for optional ones.
To celebrate the 2022 New Year, Meituan’s technology team offers a curated gift of the 22 most‑read and most‑watched 2021 technical articles—spanning logging, knowledge graphs, GraphQL, data warehousing, performance, security, and more—while inviting readers to complete a survey for a chance to win a premium keyboard wrist rest.
This article examines the motivations behind rewriting the popular Java RPC framework Dubbo in Go, discussing language efficiency, micro‑service architecture, RPC competition, thread‑pool challenges, and the emerging role of Dubbo‑Go in service‑mesh environments.
This article explains how to invalidate JWT tokens during password changes, permission updates, or logout by using a Redis-backed blacklist approach in Spring Cloud Gateway, detailing the extraction of the token's jti, gateway filtering, downstream modifications, and a logout endpoint implementation.
This article explains the purpose, evolution, business logic, architectural design, and key design principles of a payment operations platform, detailing its user groups, system architecture, interaction model, permission management, and security considerations for internal staff in payment companies.
This article details how JD’s Seckill platform expanded its product pool by up to tenfold through architectural redesign, JVM garbage‑collection tuning, dual‑cache updates, local LRU caching, and Bloom filter integration, achieving significant performance and stability gains for large‑scale flash‑sale events.
JDK 18, released on March 22, 2022, introduces nine new JEPs—including default UTF‑8 charset, a simple web server, @snippet for Javadoc, method‑handle based reflection, Vector API, internet address resolution SPI, foreign function & memory API, switch pattern matching, and deprecation of finalization—while being a short‑term feature release.
This article introduces Caffeine Cache as a high‑performance replacement for Guava Cache, explains its W‑TinyLFU eviction algorithm, demonstrates various loading and eviction strategies with code examples, and shows how to integrate and configure it in Spring Boot applications.
This article introduces Jsoup, an open‑source Java library for extracting and manipulating HTML, explains its key features such as DOM traversal and CSS selectors, and provides a concise code example that fetches Wikipedia headlines, helping developers automate web data collection.
This article explains how to replace Java's LinkedBlockingQueue with the high‑throughput LMAX Disruptor library, covering dependency setup, event definition, Disruptor creation, producer and consumer implementations, handler configuration, startup/shutdown procedures, and provides both Java and Groovy demo code.
This article outlines the functional and non‑functional requirements, traffic calculations, service decomposition, and detailed microservice designs needed to build a highly available, scalable Twitter‑style system using distributed caches, databases, and asynchronous processing.
This article summarizes typical causes of backend interface latency—such as slow MySQL queries, complex business logic, thread‑pool and lock misconfigurations, and machine constraints—and presents concrete optimization techniques including pagination fixes, indexing strategies, multithreading, proper thread‑pool tuning, lock refinement, caching, and asynchronous callbacks.
This article compares the performance of three HTTP server implementations—Java FunTester, Go's net/http, and the fasthttp library—by measuring QPS, CPU usage, and memory consumption across 1, 5, and 10 concurrent threads, and concludes that fasthttp consistently outperforms the others.
This article explains how to use Alibaba's open‑source Canal middleware to capture MySQL binlog changes and forward them via RabbitMQ for real‑time data synchronization, covering server installation, configuration, testing, and a Java client implementation.
This article explains how Spring Boot’s auto‑configuration works by describing the role of @SpringBootApplication, the conditional annotations that drive bean creation, the use of META‑INF/spring.factories, and provides a step‑by‑step example of building a custom auto‑configuration module with full code samples.
Spring Boot 2.6.0 introduces several important changes such as default prohibition of circular dependencies, custom sanitizing functions, automatic Redis connection‑pool activation, moved reactive session properties, Maven build‑info exclusions, WebTestClient support for MVC testing, and Log4j2 composite configuration options.
This article explains RabbitMQ's advanced reliability features, including how to prevent message loss with confirmCallback and returnCallback, configure TTL and dead‑letter queues, and provides practical code samples and interview‑style Q&A for backend developers.
The article explains what a flash‑sale (秒杀) is, outlines the severe technical challenges it creates for e‑commerce platforms such as massive concurrent traffic, database load and bandwidth spikes, and then presents concrete backend strategies and architectural designs to handle these issues efficiently.
This article explains the Chain of Responsibility design pattern, showing how to refactor order processing in a Spring 5.2 Java 8 application by defining abstract handlers, implementing concrete handlers, configuring bean ordering, and extending the chain for new order types.
The article examines the definition, pain points, and industry approaches to managing ultra‑complex microservice call networks, highlighting ByteDance's layered architecture, traffic identity marking, and practical recommendations for scaling and governing massive service ecosystems.
This article explains how Java 8 functional interfaces such as Function, Supplier, Consumer, and Runnable can be used to eliminate cluttered if‑else statements, showing practical examples for exception handling, branch processing, and null‑value handling with concise lambda‑based code.
This article explores the challenges of data consistency in distributed systems, explains fundamental concepts such as CAP and BASE, compares industry solutions like 2PC, Saga, TCC, and local message tables, and shares practical insights from payment service refactoring and Alipay's DTS framework.
This article explains how to replace database‑polling scheduled jobs in e‑commerce systems with RabbitMQ delayed queues by leveraging dead‑letter exchanges and message TTL, providing step‑by‑step configuration, code examples, and deployment details for Spring Boot applications.
Spring Boot Admin 2.5.5 is now available via Maven, bringing online restart support, Mac M1 compatibility, enhanced exception emails, paginated event logs, and several critical bug fixes including audit log loss and a log4j security issue.
This article explores why engineering skills outrank pure algorithm knowledge, explains the challenges of implementing flow‑control algorithms such as token bucket and sliding‑window rate limiting, and walks through Sentinel‑Go's concrete LeapArray implementation with detailed Go code examples.
This article presents a complete backend implementation of a medical appointment management system, describing user roles, environment setup, technology stack, and providing full Java service and controller code for doctor, admin, and login functionalities.
This article explains microservice fundamentals, outlines their advantages, and dives deep into data‑design considerations such as one‑database‑per‑service, polyglot persistence versus multi‑model databases, and why MongoDB’s dynamic schema, change streams, and sharding make it a strong fit for scalable microservice architectures.
This article explains how systematic code review—covering language familiarity, functional understanding, architecture analysis, interface security, branch completeness, logging, asynchronous risks, performance optimization, and coding standards—helps game developers detect bugs, improve reliability, and maintain high‑quality server code.
This article explains three Redis‑based rate‑limiting strategies—using SETNX, sorted‑set (ZSet) sliding windows, and a token‑bucket algorithm with List—provides Java code examples for each method, discusses their advantages and drawbacks, and shows how to integrate them into backend services.
This article explains why RESTful API versioning is needed, presents four common versioning strategies (URI, request parameter, custom header, and media type), and provides complete Spring Boot code examples for each method along with factors to consider when choosing a strategy.
This article chronicles a developer’s personal and technical evolution—from refactoring a lottery service with Druid, exploring Cobar sharding, diving deep into MetaQ’s messaging model, to designing custom task‑scheduling systems—highlighting lessons learned, architectural insights, and the enduring value of connecting the dots in software engineering.
This article explains the shortcomings of static front‑end permission schemes in modern SPA architectures and presents a comprehensive, database‑driven user‑role‑page‑function‑API model that enables dynamic, fine‑grained access control for both frontend menus and backend endpoints.
This article explains the concept of event tracking (埋点), its importance for capturing user behavior, outlines the four‑module architecture of a tracking system, compares code‑based, visual and full tracking methods, describes data models, storage, management, and presents a practical case study with analysis techniques.
This article analyzes common business scenarios requiring timed tasks, reviews single‑machine and distributed scheduling solutions such as Timer, ScheduledExecutorService, Spring, Quartz, TBSchedule, Elastic‑Job, Saturn, and XXL‑Job, and provides a detailed feature‑by‑feature comparison to help choose the most suitable framework.
This article explains how to bypass Java's private access restrictions using reflection, introduces the core Field and setAccessible APIs, provides a reusable PriUtil wrapper with get/set methods for instance and static members, and demonstrates usage through concrete test classes and scripts.
Explore a comprehensive list of 18 essential Spring interview questions covering design patterns, core modules, IoC, DI, AOP, proxy types, bean lifecycle, circular dependency resolution, transaction management, and Spring Boot auto‑configuration, complete with concise explanations and illustrative diagrams to help you ace your interview.
This article walks through implementing a complex e‑commerce search API, starting with a monolithic SQL query, then refactoring it into multiple indexed queries, and finally accelerating it with Redis set and sorted‑set operations, including pagination and transaction optimizations.
This article analyzes the challenges of massive log storage and retrieval, calculates the bandwidth and hardware costs of traditional pipelines, and presents a streamlined architecture that uses in‑memory buffering, UDP transport, compression, and ClickHouse to achieve petabyte‑scale throughput while cutting storage costs by over 75%.
With hardware costs dropping, many default to Redis for caching, but it isn’t always optimal; this article examines EhCache—a pure‑Java, in‑process cache—covering its architecture, eviction policies, API and XML configurations, and step‑by‑step Spring Boot integration, helping you decide when to prefer it.
The article examines why certain companies mandate POST for every API, comparing GET and POST characteristics, discussing RESTful principles, ROI considerations, and the practical trade‑offs of such a uniform approach, while offering guidance on when each method is appropriate.
This guide explains how to achieve 99.999999% reliability in RabbitMQ message delivery by using publisher confirms, persisting exchanges/queues/messages, storing outbound messages in a database, and switching consumers to manual acknowledgments to prevent loss in extreme failure scenarios.
This article introduces the retrofit‑spring‑boot‑starter library, shows how to add the Maven dependency, configure @RetrofitScan, define HTTP interfaces, inject them into services, and demonstrates advanced features such as annotation‑based interceptors, custom interceptors, connection‑pool management, logging, exception formatting, call adapters, converters, and global interceptors for Spring Boot projects.
This article introduces MDC, explains its API and advantages, and provides practical solutions for traceId propagation in multithreaded environments, HTTP calls, and custom thread pools using Java logging frameworks such as Log4j, Logback, and Log4j2.
This article explains what MDC is, the problems it faces such as traceId loss in child threads and HTTP calls, and provides concrete solutions including interceptor implementation, thread‑pool wrappers, and logging pattern adjustments to ensure reliable traceId propagation in Java backend services.
The article outlines a comprehensive process for diagnosing and optimizing performance problems in production business systems, covering causes such as high concurrency, data growth, hardware constraints, and detailing analysis of hardware, OS, database, middleware, JVM settings, code inefficiencies, and the role of monitoring and APM tools.
This article presents ten GraphQL principles—grouped into integrity, agility, and operations—that guide the design, evolution, and safe production deployment of a unified data graph, emphasizing a single schema, collaborative implementation, versioned registries, performance monitoring, and robust access and demand controls.
This article provides a step‑by‑step tutorial on using Spring Boot Actuator to monitor microservice applications, covering quick setup, essential endpoints such as health, metrics, loggers, info, beans, heapdump, threaddump and shutdown, endpoint exposure configuration, and securing them with Spring Security.
The article introduces the freight BCS system, explains its business background, describes multiple validation modes for data consistency and business logic correctness, compares implementation approaches, and outlines the architecture, task flow, and future enhancements to improve system reliability and operational monitoring.
Tomcat is an open‑source Java web server that implements core Java EE specifications such as Servlets and JSP, and its architecture includes containers, connectors, pipelines, valves, and lifecycle management, with detailed explanations of component roles, startup process, deployment, NIO handling, Comet, and asynchronous servlet support.
This article explains how to customize authentication and resource server exception messages in Spring Security OAuth2, covering the creation of custom translators, entry points, and filters, with step‑by‑step code examples and testing procedures for handling username/password errors, grant type errors, client credential errors, token expiration, and insufficient permissions.
This article introduces the ten most important new features of PHP 8.1—including enums, fibers, the never return type, readonly properties, final class constants, array_is_list(), fsync/fdatasync, string‑key array unpacking, the $_FILES full_path key, and the IntlDatePatternGenerator class—each explained with clear code examples.
This article explains how to integrate OAuth2.0 with JWT token issuance in Spring Security, covering transparent vs opaque tokens, server‑side configuration, resource‑server validation, testing with Postman, and key source‑code snippets for a complete end‑to‑end authentication solution.
This article explains the fundamentals of database transactions, defines distributed transactions, and provides a comprehensive comparison of classic solutions such as XA, SAGA, TCC, local message tables, transaction messages, maximum‑effort notifications, and AT mode, while also covering exception handling and the sub‑transaction barrier technique.
This article explains how Dubbo3’s Triple protocol, built on HTTP/2 and compatible with gRPC, improves performance, routing, security, and usability over classic RPC protocols like Dubbo2 and HTTP/1.1, while offering cross‑language support, streaming, and seamless integration with cloud‑native service governance.
This article explains eight typical situations—such as using non‑transactional storage engines, missing Spring bean registration, non‑public methods, self‑invocation, absent transaction manager, incorrect propagation settings, swallowed exceptions, and wrong exception types—that cause the @Transactional annotation in Spring to appear ineffective, and provides practical solutions for each.
This article explains how Mybatis-Plus extends MyBatis by injecting dynamic configuration XML, customizing mapper registration, and generating CRUD SQL statements through classes like MybatisSqlSessionFactoryBuilder, MybatisConfiguration, MybatisMapperRegistry, and various AbstractMethod implementations.
This article explains the design of Go's error type, why errors are returned as pointers, compares error handling across languages, discusses panic, wild goroutines, sentinel and custom errors, and presents practical guidelines such as processing errors once, eliminating redundant checks, and wrapping errors for richer context.
An extensive Phoronix benchmark on Ubuntu‑based AMD EPYC servers compares PHP 8.1 with earlier releases, revealing roughly 4 % speed gains over PHP 8.0, lower peak memory usage, and consistent performance improvements across micro‑benchmarks, XML parsing, and JSON generation.
magic-api is a Java-based rapid API development framework that lets developers create HTTP APIs without writing Controllers, Services, DAOs, or XML, offering features like multi-database support, dynamic scripting, Swagger docs, and easy Maven integration, as demonstrated in the quick‑start guide.
This article explains how Nginx performs round‑robin and weighted‑round‑robin load balancing, shows the underlying algorithms, and provides complete Go implementations with configuration examples, code snippets, and test outputs for both basic and weighted scenarios.
The article explains how to design a high‑concurrency system by planning server architecture, load balancing, master‑slave databases, NoSQL clusters, caching layers, message‑queue based asynchronous processing, static‑content CDN, and automated redundancy to ensure scalability and reliability.
This tutorial explains JSON fundamentals, demonstrates Python's json module functions, introduces the JSONPath library for extracting data from JSON documents, and provides a complete example of crawling city information from a website and parsing it with JSONPath.
This article presents a comprehensive analysis of flash‑sale (seckill) business characteristics, technical challenges, and architectural principles, offering detailed backend design solutions—including request interception, queue management, database sharding, caching strategies, optimistic locking, and anti‑cheating measures—to achieve high‑throughput, low‑latency processing for millions of concurrent users.
This article introduces MyBatis-PageHelper, a universal pagination plugin that supports a wide range of databases, explains how to configure custom dialect aliases, shows Maven and Spring integration, details numerous plugin parameters, and provides multiple code examples for various usage patterns.
This article explains the Go 1.16 embed feature by describing the typical configuration‑file problem, showing traditional file‑reading code versus embed‑based code, and diving into the compiler’s embedcfg handling and the underlying design philosophy of the new io/fs package.
The article examines why certain companies mandate POST for every API endpoint, comparing GET and POST differences such as security, payload size, data types, speed, intended usage, and caching, and concludes that POST suits large data submissions while GET is better for simple queries and static resources.
This article details a two‑week effort to diagnose and resolve high CPU usage, server load, and circuit‑breaker issues in a Java backend, covering JVM thread analysis with jtop, Hystrix optimization, Spring data‑binding fixes, and the resulting performance gains.
This article explains how to use Spring Security together with JWT to build a stateless authentication system for front‑end/back‑end separated applications, covering token issuance, refresh logic, custom filters, handlers, UserDetailsService implementation, global security configuration, and testing procedures.
PHP 8.1.0 introduces enums, read‑only properties, first‑class callable syntax, new initializers, intersection types, never return type, final class constants, explicit octal literals, fibers, string‑keyed array unpacking, and numerous performance optimizations, providing developers with richer language features and faster execution.
This article introduces Java 8's Stream API, explains its intermediate and terminal operations, highlights its functional characteristics, compares its performance with traditional iterator loops through benchmark tests, and offers practical recommendations for using streams and parallel streams in backend development.
The investigation of QLB‑4‑based TFServing calls revealed uneven traffic, stale routing after scaling, and idle servers due to layer‑4 hash routing, leading the team to replace QLB‑4 with a Consul‑driven client‑side load‑balancer that dynamically pools servers, eliminates restarts, and cuts GPU waste.
The article explains what Spring Boot application starters are, enumerates all 44 available starters with brief descriptions of their functionality, and invites readers to share the content and join a community for further architectural learning.
This article presents a comprehensive design and implementation of a drag‑and‑drop, code‑less workflow orchestration system that abstracts business logic into DAG‑based state machines, detailing architecture, core data structures, Go code examples, and two practical use cases for arithmetic and data‑consumption scenarios.
This article details a two‑week effort to diagnose and resolve high CPU usage, server load, Hystrix circuit‑breaker inefficiencies, and Spring data‑binding exceptions in a Java backend service, resulting in doubled QPS capacity, stable circuit breaking under heavy traffic, and significant performance gains.
This article explains how to meet a performance‑testing requirement for cancelling orders 10 seconds after placement by leveraging Java's thread‑safe DelayQueue, detailing the design, implementation, test case, execution steps, and observed results.
This article explains the differences between Spring's singleton and prototype bean scopes, describing how singleton beans are cached and shared across requests while prototype beans are created anew each time, and discusses their performance advantages, thread‑safety drawbacks, and practical implications for developers.
This article explains how Vivo Game Center adopted a modular architecture—combining componentization, configuration, and experiment-driven deployment—to enable rapid, flexible UI layout adjustments, unified backend processes, and data-driven A/B testing, thereby improving development efficiency and user‑targeted operations.
This article explains how to use the Go gobreaker library to implement circuit‑breaker patterns, describing its three states, state transitions, configurable parameters, and providing full source‑code examples to help developers improve fault tolerance in micro‑service architectures.
This article explains the functional purpose, layered and cluster designs, distributed architecture, caching strategies, asynchronous checks, storage heterogeneity, payment solutions, and anti‑bot mechanisms of a cloud‑based shopping cart, highlighting stability, high performance, elasticity, and fault‑tolerance.
This article presents a comprehensive set of Java performance optimization guidelines—including proper use of singletons, avoiding excessive object creation, preferring primitive types, minimizing synchronized blocks, and leveraging efficient collection initialization—supported by code examples and explanations to help developers write faster, more memory‑efficient Java applications.
This article provides a hands‑on guide to Java 8 Stream Collectors, demonstrating how to use toList, toSet, toCollection, toMap, summingInt, joining, groupingBy, partitioningBy and related collectors with clear code examples and output results.
This guide walks through using the Gorilla WebSocket library in Go, covering dependency setup, server implementation with an Upgrader, Java and Go client examples, testing procedures, and performance observations that highlight Go's advantages for WebSocket workloads.
The article explains the functional purpose, early evolution, layered and clustered design, distributed technical architecture, caching, asynchronous checks, heterogeneous storage, payment solutions, and anti‑bot measures of a cloud‑based shopping cart, highlighting stability, performance, elasticity, and fault‑tolerance.
This article provides an in‑depth overview of Apache Log4j2, comparing it with Logback and Log4j 1, highlighting its superior asynchronous performance, zero‑GC operation, flexible configuration formats, rich appender ecosystem, and practical code examples for Maven integration, XML setup, and advanced logging techniques.
This article explains the problem of service avalanche in distributed systems, introduces the Hystrix circuit‑breaker concept and its four command modes, evaluates existing PHP implementations, and details the design and implementation of a custom hystrix‑ex Composer package that integrates with Guzzle middleware for high‑concurrency fault tolerance.
PHP 8.1 introduces the built‑in array_is_list() function, which determines whether an array’s keys form a sequential list starting at zero, simplifying checks that previously required manual verification, and the article provides usage examples, code snippets, and a link to the RFC.
This guide explains step‑by‑step how to create, register, and use a custom function in Casbin to support multiple super‑admin users, including code examples for PHP anonymous functions and Enforcer registration.
When integrating a third‑party API, building deeply nested JSON structures can become cumbersome, but using Java's double‑brace initialization for maps and JSONObjects dramatically reduces boilerplate code while keeping the payload readable and maintainable.
This article provides a detailed, step‑by‑step guide for startups to design and select a complete backend technology stack, covering language choices, components, processes, systemization, and the practical evaluation of tools such as project management, DNS, load balancing, databases, messaging, CI/CD, monitoring, and deployment.
The article explains PHP 8.1’s pure intersection types, how they differ from union types, demonstrates their use with an example function that combines multiple interfaces, and provides links to the official RFC and related PHP 8.1 feature articles.
This article outlines the objectives, call flow, architectural design, and potential challenges of a payment center system that unifies transaction, payment, and finance services, detailing its four main modules, data handling, and integration with third‑party payment channels.
MDword is a PHP library that enables dynamic Word document generation by focusing on data and logic while allowing style adjustments through Word templates, offering features such as field updates, bug fixes, automatic table of contents, and a richer template‑based workflow compared to PHPWord.
This article introduces the concept of signals, explains how the Python Blinker library implements them with named, anonymous, and multicast signals, demonstrates various usage patterns including decorators and receiver checks, and shows how to integrate Blinker with Flask for request‑level event handling.
This article explains how miscalculating Hystrix semaphore quotas, combined with a JDK GCLocker‑initiated GC bug, can cause unexpected request rejections, and provides a proper method for computing concurrency limits and alternative buffering strategies such as Java semaphores and thread pools.
This article explains how to achieve near‑zero message loss in RabbitMQ by using producer confirm mode, durable exchanges/queues/messages, database‑backed message storage, and manual consumer acknowledgments, while providing practical code examples for each technique.
This article explains the concept of PHP 8.1 Fibers, compares synchronous and parallel HTTP request handling, shows how to implement simple asynchronous workflows with sockets or ReactPHP, and discusses why Fibers are low‑level building blocks rather than a complete async solution.
This article explains common reasons why Spring's @Transactional annotation can become ineffective—such as self‑invocation, non‑public methods, multiple data sources, incorrect rollback settings, and unsupported database engines—and provides concrete code examples and solutions to ensure proper transaction management.
