This article shares a step‑by‑step account of a candidate's three‑round ByteDance interview, covering background, technical questions on Java, JVM, Redis, MySQL, Kafka, and algorithm challenges, along with personal reflections on pacing, preparation, and why concise answers matter.
This guide explains how to configure Python's logging.handlers.SMTPHandler to email log messages, why QQ enterprise and Gmail require SSL instead of TLS, and provides a complete logging.conf example with sample code to avoid common pitfalls.
This article explains MyBatis's first‑level and second‑level caching mechanisms, demonstrates data inconsistency problems caused by joined‑table queries, and provides a custom annotation‑driven relation cache solution with code examples for configuring and validating the cache behavior.
This article explains the execution order of Spring AOP annotations, demonstrates why an @Around advice may invoke a method twice when ProceedingJoinPoint.proceed() is called multiple times, and provides corrected code to ensure proper single execution.
This guide walks you through downloading XXL-Job, setting up its database, configuring Spring Boot profiles, customizing log paths, deploying the admin console, writing a sample executor with @XxlJob, and managing tasks through the web UI, all with concrete commands and code snippets.
cURL author Daniel Stenberg announced plans to add native JSON handling, explaining its importance for REST APIs, the common pain points developers face, and introducing two new command‑line options that simplify sending JSON payloads and headers.
The article analyzes the challenges of maintaining data consistency when using both cache (local memory or Redis) and a database, classifies data by real‑time requirements, evaluates four double‑write strategies, and proposes practical solutions such as delayed double deletion, message‑queue compensation, and binlog‑driven cache updates.
This article demonstrates how to enable browser-based preview of Word, Excel, and PowerPoint files in Java by converting them to PDF streams with Apache OpenOffice and JODConverter, covering installation, Maven setup, utility code, service logic, and controller exposure.
This article introduces the Go programming language, explains why it is called Go rather than Golang, outlines its key advantages and common use cases, compares it with Python for beginners, and provides practical advice and resources for learning Go effectively.
IntelliJ IDEA's StreamTrace feature allows developers to debug Java Stream pipelines by visualizing each operation's element count, results, and object details, with step-by-step screenshots and a code example that filters strings longer than five characters.
This article explains the reasons for selecting Apache RocketMQ—its synchronous double‑write safety, strong performance under massive multi‑topic loads, rich features like transactional and delayed messages, active community support, and demonstrates how to leverage Java’s SPI mechanism to build a configurable, dynamically adjustable client architecture.
This article details a practical backend design and stress‑test that simulates 1 million concurrent users handling 100 billion WeChat red‑packet requests, covering load calculations, Go‑based implementation, QPS targets, monitoring, and performance analysis.
This article explains the fundamentals of event‑driven architecture, outlines when it should be used, describes common patterns such as event notification, state transfer, event sourcing, and CQRS, and provides a detailed example of applying these concepts in a content‑platform microservice system with code snippets and deployment considerations.
This article explains Java exception categories, how Spring's @Transactional decides which exceptions trigger a rollback, and provides practical annotation configurations to control rollback behavior for both checked and unchecked exceptions.
This comprehensive guide walks developers from essential computer‑science fundamentals through front‑end basics, Solidity programming, and DApp construction, offering curated resources and step‑by‑step instructions to become proficient in Web3 and blockchain development within a year.
This article explains how to implement fast (MD5‑based) upload, chunked upload, and resumable (break‑point) upload for large files in Java, detailing the Redis‑based status tracking, server‑side file handling with RandomAccessFile or MappedByteBuffer, and the required front‑end and back‑end coordination.
Learn how to enhance your Nginx server by creating custom 404 error pages, enabling and reading the stub_status module, increasing worker processes and connections, adjusting kernel limits, expanding header buffers, and configuring client-side caching for static assets, with step‑by‑step commands and examples.
This article shares a collection of practical Java backend development habits, covering configuration with @ConfigurationProperties, Lombok's @RequiredArgsConstructor, code modularization, exception throwing, reducing DB queries, avoiding null returns, simplifying if‑else, keeping controllers thin, IDE tips, source code reading, design patterns, and fundamental coding techniques.
This article walks through setting up Spock for Java/Groovy projects, lists required Maven dependencies, shows how to handle static‑method mocking with PowerMock and Mockito, and provides concrete code examples for mocking @Autowired components, shared objects, and defining mock behavior.
This article explains the fundamentals of web session management, compares server‑side, cookie‑based, and token‑based storage methods, discusses authentication versus authorization, and outlines security considerations and best‑practice recommendations for managing user sessions in modern web applications.
This article presents a comprehensive guide to building maintainable, extensible backend systems by covering coding conventions, branch naming, commit messages, comment standards, result‑wrapping patterns, database normalization, algorithmic improvements, concurrency handling, service layering, and practical code examples.
This article explains why distributed locks are needed beyond Java's JVM‑level locks, compares three common implementation approaches—database unique indexes, Redis SETNX, and Zookeeper ephemeral sequential nodes—and provides concrete SQL and Java code examples with analysis of re‑entrancy, release timing, and single‑point risks.
This article explains the fundamentals of RabbitMQ, compares normal and mirrored cluster modes, details Google’s large‑scale test setup, and walks through advanced plugins such as sharding, consistent‑hash exchange, federation, and high‑availability strategies for achieving million‑level message throughput.
This article explains Java 8's CompletableFuture, covering its purpose, core features such as thenCompose, thenCombine, thenAccept, thenRun, and thenApply, demonstrates practical code examples, and provides a detailed analysis of the underlying source‑code implementation for asynchronous callbacks.
This article explains Kafka's timing wheel algorithm, detailing its O(1) delay operation design, multi‑layer wheel structure, and how Kafka advances time using a DelayQueue, while comparing it with Netty and other open‑source projects.
The article outlines a comprehensive backend architecture for handling million‑level daily active users, covering DNS routing, L4/L7 load balancing, monolithic versus microservice deployment, caching, database sharding, hybrid‑cloud deployment, elastic scaling, and multi‑level degradation strategies to ensure high availability under sudden traffic spikes.
This article explains why front‑end and back‑end separation is essential, describes the SPA‑based architecture, outlines practical steps for responsibility division, development workflow, and implementation, and provides a detailed V1.0.0 API specification with request and response formats.
The proposed real‑time traffic comparison platform samples production traffic, replays mock requests, and checks database records, MQ messages, API parameters, and responses against a reference version, enabling near‑instant detection of regressions during refactoring, reducing test effort and release cycles while requiring instrumentation and configuration but no dedicated comparison database.
This article demonstrates how to build a token‑bucket based rate‑limiting solution in a Spring Boot application using a custom annotation, an interceptor, a bucket utility class, scheduled token generation, and global AOP exception handling to control access to APIs.
This article explains how Spring's HttpMessageConverter abstracts HTTP message conversion, shows how to read request bodies via HttpInputMessage and ServletServerHttpRequest, demonstrates a practical filter using FormHttpMessageConverter, and illustrates writing JSON responses with MappingJackson2HttpMessageConverter, all with concise code examples.
This article explains the subtle difference between 'yyyy' and 'YYYY' in Java's SimpleDateFormat, demonstrates how using the wrong pattern can cause year miscalculations—especially on December 31st—and provides code examples and a clear explanation to help developers avoid this common bug.
This guide explains how to set up a Flask backend on Windows or CentOS, generate the required signatures for WeChat's unified order API, obtain a prepay_id, and call the mini‑program wx.requestPayment interface with the correct parameters for successful payment processing.
This article walks through setting up GORM in a Go project, covering dependency management, database initialization, model definition, and practical examples of select, insert, update, delete, raw SQL execution, and transaction handling with detailed code snippets.
magic-api is a Java‑based rapid API development framework that lets developers create HTTP interfaces through a UI without writing Controllers, Services, DAOs, or XML, offering extensive database support, dynamic scripting, Swagger generation, and easy Spring Boot integration.
This article guides startup leaders through designing a complete backend technology stack, covering language choices, essential components, processes, systemization, and detailed recommendations for project management, DNS, load balancing, CDN, RPC frameworks, databases, messaging, CI/CD, monitoring, configuration, deployment, and operational best practices.
mica‑mqtt, built on t‑io, offers a simple, low‑latency, high‑performance open‑source MQTT component that integrates easily into existing services, supports multiple protocols and deployment scenarios, and includes Spring Boot starter, GraalVM compilation, and Redis‑based clustering for robust IoT solutions.
The article explains how Kafka implements delayed operations using a timing wheel with O(1) insertion and deletion, describes its parameters, multi‑level wheel design for large time spans, and the mechanism of advancing the wheel via DelayQueue and the ExpiredOperationReaper, contrasting it with Netty's approach.
The article examines the recent Xi'an health‑code system failure, highlighting that the crash stemmed from backend design flaws such as serving all static assets without a CDN, excessive bandwidth demand exceeding 125 Gbps, and inefficient QR‑code API handling.
This article explains how to design a scalable multi‑account login system by describing self‑built phone‑number authentication, optimized password‑less registration, third‑party OAuth integration, database schema separation, and one‑click carrier‑based login, while highlighting advantages, drawbacks, and implementation details.
The article explains the concepts, problem scenarios, resource granularity, rule definition, sliding‑window calculation, and implementation flow of rate limiting and circuit breaking in microservice architectures and API gateways, providing practical guidance for building robust backend services.
The article explains a typical payment‑timeout scenario and compares four backend solutions—database polling, Java DelayQueue, Redis sorted set, and RabbitMQ TTL with dead‑letter exchange—detailing their mechanisms, advantages, and drawbacks for implementing delayed task cancellation.
This article presents Bilibili’s high‑availability design, covering load‑balancing decisions, subset selection, multi‑cluster deployment, adaptive rate limiting, retry policies, timeout propagation, and chain‑failure mitigation, all illustrated with diagrams and practical SRE insights.
This article introduces Modern.js, a ByteDance‑initiated open‑source framework that unifies frontend engineering and server‑side development by offering a minimal core, integrated web server, plugin system, and progressive full‑stack features to simplify routing, rendering, API handling, and deployment for modern web applications.
This article explains the role, challenges, and solution of JD Daojia's business gateway, detailing how it aggregates multiple backend services, adopts workflow orchestration to improve code consistency, scalability, and development efficiency, and outlines future architectural considerations.
This article explains how to integrate Redis caching into PHP applications by leveraging the __call magic method to create cache, clear, and flush operations for model methods, enabling shared model layers, resource‑efficient caching, flexible data source selection, and clean, reusable code.
This article explains why third‑party payment platforms like Alipay are used, describes Alipay's payment flow, outlines the configuration steps to obtain APPID and keys, and provides a complete Python implementation for integrating Alipay into backend services.
The AiFanFan Communication system was refactored by applying domain‑driven design and micro‑services, replacing an outdated Windows C++ client and excessive middleware with a five‑layer architecture, streamlined protocols, and a cross‑platform Electron‑Vue UI, resulting in clearer modules, higher stability, reduced team size, and faster feature delivery.
The article explains common timeout points in synchronous, asynchronous, and message‑queue communication between services, and provides client‑side and server‑side strategies—including request tracing, retry policies, idempotency, fast‑fail handling, and max‑effort notifications—to mitigate these problems in backend systems.
The article details three Xianyu backend incidents where Full GC pauses caused latency spikes or outages, analyzes root causes ranging from survivor space shortage and mis‑tuned CMS to oversized async Log4j events and massive string‑concatenation logs, and presents remediation steps such as switching to G1GC, adjusting Log4j settings, and using parameterized logging to eliminate the pauses.
This article explains the Jakarta Bean Validation standard, its applicable scenarios, annotation basics, integration with Hibernate Validator, configuration options, simple and advanced usage examples—including group sequencing and multi‑field validation—along with practical code snippets and deployment considerations for backend Java development.
This article explains why and how to separate front‑end and back‑end responsibilities, introduces the SPA‑based architecture, outlines development processes, and provides a detailed API specification (including request/response formats, pagination, and special field rules) to improve collaboration and reduce integration effort.
This article explains microservice fundamentals, outlines their advantages and technical traits, and provides practical guidance on data design, database selection, polyglot persistence, scaling strategies, and why MongoDB often fits microservice architectures best.
MyBatis-Plus, a MyBatis enhancement toolkit, streamlines CRUD development, celebrates its fifth consecutive OSC popularity award, and introduces version 4.0 with a comprehensive update log that includes MyBatis 3.5.9 upgrade, dynamic mapper injection, new hooks, and numerous performance and compatibility improvements.
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.
