Go 1.19, slated for an August 2022 release, brings minor language tweaks, a revised memory model aligned with major languages, new LoongArch support, Unix build constraints, runtime soft memory limits, compiler and assembler enhancements, and an updated ELF linker format.
This article provides a step‑by‑step tutorial on installing and configuring Spring Boot Admin, including Maven dependencies, server and client setup, YML properties, security, Nacos registration, email notifications, custom health indicators, and Micrometer metrics to monitor Spring Boot services.
This article explains Spring's circular‑dependency solution, detailing the early‑exposure mechanism, the three‑level cache (singletonObjects, earlySingletonObjects, singletonFactories), how BeanPostProcessors and AOP proxies interact during bean creation, and why the third‑level cache is essential for correct bean wiring.
This article explains the standard JWT claims, demonstrates how to generate a token with custom claims in Java, and compares single‑token and double‑token renewal schemes, including practical steps for handling expiration, refresh logic, and Redis‑based token storage.
The article explains NetEase Cloud IM's "Circle Group" product, detailing its massive relationship complexity and scale, the technical challenges it creates, and the layered backend architecture and mechanisms designed to handle multi‑entity coupling, huge member volumes, and efficient change notifications.
This guide explains how to use OpenResty’s Lua capabilities to replace Tomcat‑based Redis access with direct Nginx‑Redis integration, apply compression to reduce bandwidth, set up periodic cache refreshes, configure single‑worker timers, and manage cache settings via a signed backend API.
This article explains how to dramatically reduce the average response time of a high‑traffic Java service from 250 ms to about 80 ms by applying HttpClient pooling, keep‑alive strategies, proper timeout settings, and idle‑connection monitoring, complete with code examples and configuration details.
This article introduces the open‑source Disruptor library, explains its core concepts such as Ring Buffer, Sequencer, and Wait Strategy, and provides a step‑by‑step Java implementation—including Maven dependency, event model, factory, handler, manager, producer, and test code—demonstrating how to build a fast in‑memory message queue.
This article explains how to use XPath in Python to bypass the first table header row during web scraping, provides a concise code example, and walks through the implementation steps so readers can adapt the technique to similar crawling tasks.
The article analyzes the risks and efficiency challenges of using Apollo for dynamic configuration in various business scenarios, explores past mitigation approaches, and presents a standardized, automated, and immersive view‑driven solution that achieved full coverage and zero production configuration errors in Zhuanzhuan's B2C platform.
This article demonstrates how to design a simple Calculator interface, provide both annotation‑based and reflection‑based implementations, and achieve hot deployment by loading user‑supplied JAR files at runtime, including dynamic bean registration and removal in a Spring container.
This article explains why Redis is ultra‑fast by exploring its in‑memory design and the nine fundamental data structures—SDS, linked lists, ziplist, hash tables, skiplist, intset, quicklist, and listpack—that power keys, values, and internal objects, complete with code examples and version‑specific changes.
This article explains the differences between @Valid and @Validated annotations, demonstrates how to use validation groups, group sequences, and nested validation in Spring and Hibernate Validator, and provides complete code examples illustrating each concept for robust backend data validation.
This article explains the fundamental differences between RPC and HTTP services, covering the OSI model, RPC architecture components, synchronous vs asynchronous calls, and reviews popular RPC frameworks such as gRPC, Thrift, and Dubbo, helping developers choose the right approach for backend development.
Bilibili’s Open Platform streamlines video uploads by replacing a complex multi‑parameter flow with a single upload_token that encapsulates authentication and file metadata, enabling chunked uploads, merging, and manuscript submission via a JavaScript SDK, which cuts integration errors and speeds first‑time submissions by over sixty percent.
This article details a performance evaluation of Apache Commons Pool2 on a MacBook Pro, comparing no‑wait and wait scenarios, presenting QPS results, identifying bottlenecks in LinkedBlockingDeque and AtomicLong, and outlining the test setup, code, and conclusions.
This comprehensive guide explains what Nginx is, its core features, typical use cases, ecosystem extensions, installation methods, detailed configuration examples—including HTTPS, redirects, static mapping, proxying, rate limiting, authentication, load‑balancing strategies, and security hardening—plus an overview of its architecture and source‑code layout.
The article compares using Java's ExecutorService thread pool versus external message queues such as RabbitMQ or Redis for asynchronous processing, discussing their design differences, suitable scenarios, code examples, and considerations for scalability, reliability, and when to transition from in‑process queues to middleware.
This article presents a series of images that quickly review essential C++ backend development topics, highlighting low‑level concepts such as memory management, inter‑process communication, network programming, and the importance of databases and Linux, while comparing C++ to Java backend routes.
The HC Community Property Management System, launched by the java110 team in April 2017, is an open‑source, front‑end/back‑end separated, distributed Java project that includes backend, frontend, owner‑mobile, and property‑mobile modules, with detailed development tools, hardware/software requirements, microservice structure, and deployment instructions.
This article introduces eight widely used software architecture design patterns—including single‑database single‑app, content distribution, query separation, microservices, multi‑level caching, sharding, elastic scaling, and multi‑datacenter deployment—explaining their typical designs, advantages, disadvantages, and practical considerations for building scalable, high‑performance systems.
This article compares Redis Streams with Kafka, highlighting Redis's simplicity, performance, and built‑in features like consumer groups, while discussing when each solution is appropriate for different project scales and requirements.
This article explains the various ways to execute code during a Spring Boot application's startup, comparing Java static blocks, constructors, @PostConstruct methods, and Spring's ApplicationRunner and CommandLineRunner interfaces, including ordering with @Order and providing sample code and execution results.
A developer tried to boost performance by caching user data with ThreadLocal, but thread‑pool reuse caused data leakage across requests, leading to missing and duplicated orders, a P1 incident, and a hard‑learned lesson on proper ThreadLocal cleanup.
This article explains Redis memory eviction strategies, including volatile and allkeys policies, details the approximate LRU algorithm Redis uses, and provides Java implementations of an LRU cache using LinkedHashMap and a custom doubly‑linked list, complete with code examples and configuration settings.
This article explains how Lombok uses compile‑time annotations and the Java Annotation Processing Tool (APT) to automatically generate boilerplate code such as getters, setters, and constructors, and provides step‑by‑step examples of defining custom annotations, processors, and compiling them.
This article explains how to use OpenResty with Lua to integrate Redis directly into Nginx for cache‑driven request forwarding, data compression, timed updates, single‑process scheduling, and configurable URL caching, thereby improving concurrency, reducing latency, and enhancing backend resilience.
The article traces Bilibili’s API gateway evolution from a crash‑prone 2015 PHP monolith through a Go‑based bilizone, then fragmented BFF services, to a unified microservice gateway that centralizes routing, authentication, rate limiting, and governance, enabling scalable, decoupled development and a full API ecosystem.
This article explains how RocketMQ and RabbitMQ guarantee message reliability by covering production, storage, and consumption stages, introducing confirm mechanisms, persistence settings, manual acknowledgments, and compensation strategies such as message database storage to achieve near‑zero data loss in distributed systems.
This article explains eight widely used software architecture design patterns—including single‑database single‑application, content distribution, query separation, microservices, multi‑level caching, database sharding, elastic scaling, and multi‑data‑center—detailing their typical scenarios, advantages, and disadvantages for backend developers.
The article explains how RocketMQ tackles growing business traffic by introducing an asynchronous broker layer, using commitlog and consumeQueue files, page‑cache, mmap, topic/tag routing, and a nameserver to achieve high‑throughput, low‑latency, and highly available message delivery.
This article presents sixteen practical best‑practice recommendations for developing Spring Boot microservices, covering dependency management, auto‑configuration, project initialization, code organization, service design, database isolation, concurrency, configuration externalization, exception handling, logging, testing, and more, to help Java backend engineers build robust, maintainable applications.
This article analyzes why ZuanZuan built its own RocketMQ transaction‑message solution, compares the custom implementation with the community edition’s two‑phase commit approach, explains the underlying principles, sending flow, failure handling, and unknown‑state processing, and summarizes the trade‑offs of each design.
This guide explains why Spring Boot deprecates the META-INF/spring.factories file, how the change affects custom starters, and provides step‑by‑step code examples for migrating to the new AutoConfiguration.imports mechanism.
This article explains how to parse user‑defined query strings and convert them into type‑safe Spring Data Querydsl predicates, covering query patterns, code examples, dynamic query building, and handling complex parent‑child relationships in backend services.
This article presents sixteen practical Spring Boot best‑practice recommendations—ranging from custom BOM management and automatic configuration to project structure, logging, testing, and externalized configuration—to help developers build clean, maintainable, and production‑ready Java microservices.
This article shares sixteen practical Spring Boot best practices—from managing dependencies with custom BOMs and leveraging auto‑configuration to structuring code, handling exceptions, externalizing configuration, and testing—helping developers build maintainable, scalable Java microservices efficiently.
The article explains the challenges of authentication in microservice architectures and compares several solutions—including CAS single sign‑on, distributed session with Redis, client‑side token with JWT, and a recommended Spring Cloud + Spring Security + OAuth2 + JWT approach—detailing their workflows, advantages, and drawbacks.
The recent Spring Boot announcements introduce version 3.0.0‑M3 with Micrometer Observation support, restore REST Assured and JMS, while 2.7.0 adds GraphQL metrics, new test annotations, Podman Buildpack integration, Cache2k, simplified Jackson Mixins, PEM‑based SSL, and updates to core Spring projects, and 2.5.14/2.6.8 provide final bug‑fix releases.
The article analyses low‑code platforms by defining low‑code as visual programming, contrasting declarative and imperative approaches, examining front‑end and back‑end implementation schemes, interaction models, storage options, workflow engines, and future trends, ultimately showing that declarative foundations drive both strengths and limitations.
This article explains how to separate backend admin users using stateful Session authentication from front‑end app users using stateless JWT in a Spring Security‑based system, covering path‑interception strategies, session key isolation, custom UserDetailsService implementations, and complete configuration examples for an Id Server authorization server.
This article walks through a scenario‑driven capacity assessment for a production‑grade Kafka cluster, covering QPS calculations, storage needs, physical machine count, disk choices, memory, CPU, network bandwidth, deployment steps, and a final resource summary.
This article explains Google’s API design guidelines for resource naming, covering uniqueness, URI path formatting, collection identifiers, ID constraints, full and relative names, and how to annotate fields in protobuf messages for clear, consistent backend APIs.
This article introduces three request‑merging techniques—Hystrix Collapser, a custom BatchCollapser, and Guava's ConcurrentHashMultiset—explaining their design, implementation, configuration, and suitable scenarios to reduce downstream load and improve overall system throughput.
This guide walks through setting up a Spring Boot 2.3.9 WebSocket server, defining message types and enums, implementing encoder/decoder, configuring the endpoint and bean, and creating a simple HTML/JavaScript client to test real‑time messaging between multiple users.
After two weeks of research, this guide presents a ranked list of 37 Python web frameworks—detailing their official sites, strengths, weaknesses, and visual overviews—to help developers choose the most supported and suitable framework for their projects.
This article compares LVS and Nginx load balancing, explaining their layer differences, performance characteristics, configuration flexibility, health‑check capabilities, and typical use‑cases, while also discussing related concepts such as forward/reverse proxy, static‑dynamic separation, and practical deployment considerations.
The article explains the copy‑on‑write (COW) concurrency strategy, its suitability for read‑heavy scenarios, and demonstrates how Java implements COW with CopyOnWriteArrayList and CopyOnWriteArraySet, including volatile array handling, write‑locking, snapshot reads, and iterator behavior.
This article explains the three main reasons for using message queues—decoupling, asynchrony, and peak‑shaving—then compares popular MQ products, dives deep into RocketMQ’s components, models, reliability, ordering, filtering, delay, transactions, dead‑letter handling, high‑availability, storage, load balancing, and long‑polling, providing a comprehensive guide for backend engineers.
This article walks readers through MyBatis batch processing from basics to advanced, highlighting common mistakes, explaining the roles of commit, clearCache, and flushStatements, and presenting three progressively refined code versions plus Oracle-specific optimizations to dramatically improve bulk insert performance.
This guide demonstrates how to implement a simple hot‑search feature and personal search‑history management using Java and Redis, covering ZSet‑based ranking, timestamp handling, and a DFA‑based sensitive‑word filter with Spring‑Boot configuration and reusable service methods.
This article explains MyBatis first‑ and second‑level caching, demonstrates how join queries can cause stale data when only the updated mapper's cache is cleared, and introduces a custom @CacheRelations annotation with a RelativeCache implementation that propagates invalidation across related mappers.
This article examines a JDK bug that drops millisecond precision in file timestamps, explains why Java’s WatchService falls back to polling on macOS, contrasts it with Linux’s inotify‑based implementation, and shares practical workarounds for reliable file change detection.
This article explains Spring Cloud's role in building distributed micro‑service systems, illustrates an e‑commerce order‑payment scenario, and details the core components Eureka, Feign, Ribbon, Hystrix, and Zuul, showing how they work together for service registration, discovery, load balancing, fault tolerance, and API routing.
This article presents a comprehensive design for a high‑concurrency e‑commerce inventory system that prevents overselling by combining Redis‑based stock checks with database persistence and a task‑engine workflow, offering code examples, pipeline usage, and strategies for idempotency and fault tolerance.
This article explains key high‑concurrency web concepts such as QPS, throughput, and response time, then details traffic and server optimizations, load‑balancing strategies (L4/L7, Nginx, LVS), CDN fundamentals, process/thread/coroutine models, asynchronous I/O, PHP Swoole concurrency, and database caching techniques for scalable backend systems.
This article compares the PHP web frameworks Laravel and Yii, detailing their core features, installation requirements, validation, routing, CRUD generation, extensions, migrations, testing, security, and documentation, and provides scored evaluations to help developers choose the most suitable framework for their projects.
The article explains Go’s built‑in error interface, distinguishes errors, exceptions and panics, presents three handling patterns—classic returns, stateful objects, and functional deferred execution—shows how to wrap errors for context, and demonstrates using the errgroup concurrency primitive (including an extended version) for safe parallel processing.
This article compares Java's legacy date handling in JDK7 with the modern java.time API introduced in JDK8, demonstrating how to create, format, and convert dates using LocalDate, LocalDateTime, DateTimeFormatter, and related methods, and provides a comprehensive table of useful LocalDate APIs.
This article explains the principles and practical usage of MyBatis first‑level and second‑level caches, describing how caching reduces database load, showing configuration steps, code demonstrations, flow diagrams, and important considerations such as cache invalidation and LRU eviction.
This article details the end‑to‑end development of a supplier management system using SpringBoot, Thymeleaf, Mybatis‑Plus, MySQL and Redis, covering project planning, code implementation, file upload handling, caching optimization, and deployment considerations.
This article introduces FastMybatis, a lightweight Java MyBatis extension that enables zero‑configuration CRUD operations across multiple databases, shows how to quickly set up a Spring Boot project with the starter, provides full code examples for entities, mappers, services, a comprehensive mapper method list, and demonstrates Query object usage for flexible data retrieval.
This article explains Java 17’s sealed classes, describing how the new sealed, non‑sealed, and permits keywords let developers precisely restrict inheritance hierarchies, with concrete code examples and a three‑layer hero model illustrating practical usage.
This article explains how Spring Kafka’s KafkaMessageListenerContainer and ConcurrentMessageListenerContainer work, details their start-up process and internal consumer threads, shows how @KafkaListener bridges business logic, and provides configuration examples for single‑message and batch processing in Spring Boot.
This guide demonstrates how to configure Maven profiles for different environments, use the Maven assembly and jar plugins to create a zip package of a Spring Boot application, and deploy and manage the service on Linux using a custom shell script called shenniu_publish.sh.
This article explains Spring's bean lifecycle, detailing how the framework resolves circular dependencies using a three‑level cache (singletonObjects, earlySingletonObjects, singletonFactories), and why a two‑level cache is insufficient, especially when AOP proxies are involved.
This article demonstrates how to build a real‑time messaging system for a space‑station scenario using RabbitMQ and Spring Boot, covering configuration of direct and fanout exchanges, scheduling updates, one‑to‑one chat, and broadcast messaging with complete Java code examples.
The article explains that Spring MVC Controllers are singleton beans by default, discusses the thread‑safety risks of using instance variables in such Controllers, and presents several solutions—including prototype scope, ThreadLocal, and AtomicInteger—to ensure safe concurrent handling of requests.
This article explains how to replace manual BeanUtil mapping with MapStruct, leverage Spring's Converter interface, and use the MapStruct Spring Extensions plugin to automatically register mappers with ConversionService, including custom adapter configuration and integration of built‑in Spring converters.
This article explores the concept of fully interface‑based domain modeling, demonstrates how to design domain objects as interfaces, shows repository implementations for JPA, MyBatis and Elasticsearch, discusses association handling, and explains how such designs enable seamless switching between monolithic, clustered and microservice deployments.
The article discusses common pitfalls in application layering, presents the Alibaba coding guideline for multi‑layer architecture, proposes an optimized layering model with clear responsibilities for controller, service, manager, and DAO layers, and explains domain model conversions to improve maintainability and reuse.
This article introduces MDword, a PHP library for programmatically creating Word documents, outlines its recent updates, compares it with PHPWord, and provides step‑by‑step installation and usage examples including code snippets for template processing, image insertion, and document saving.
This article explains the concepts of MyBatis first-level and second-level caches, demonstrates how they work with practical Java code, shows configuration methods, and highlights important considerations such as cache invalidation and eviction policies.
The article walks through building a minimal SQLite‑style database in Go, covering memory‑disk page storage, B‑tree indexing, simple SQL parsing for INSERT and SELECT, row serialization, a pager that flushes pages, and a basic REPL, while highlighting current single‑page limits and future extensions.
Node.js 18 introduces built‑in fetch and test modules, modernizes the standard library, adds a native test runner, upgrades the V8 engine, and outlines future roadmap items such as modern HTTP, improved type support, and enhanced ESM capabilities, all while offering quick installation via version managers.
This article explains a refined approach for implementing QPS and response‑time samplers in a Java performance‑testing framework, covering static and dynamic load models, the use of LongAdder, thread‑count utilities, and detailed code examples for reliable metric collection.
This article walks developers through the fundamentals of the OSI model, TCP three‑way handshake and UDP characteristics, explains socket concepts, demonstrates Node.js server and client implementations with heartbeats and custom protocols, and details how to build and use a socket connection pool with the generic‑pool library.
This article dissects the inner workings of OpenFeign within Spring Cloud, explaining how @EnableFeignClients triggers bean registration, how FeignClientsRegistrar and related configuration classes create BeanDefinitions, and how the FeignBuilder ultimately generates dynamic proxy instances for Feign clients.
The article examines Go's origin, rapid adoption in China since 2014, market hiring trends, popularity metrics like TIOBE rankings, and highlights the language's ease of use, strong tooling, corporate backing, and cloud‑native ecosystem as the main drivers of its success.
The author argues that for straightforward API or server‑side rendering tasks, using minimal or no web framework—illustrated with Deno Deploy examples—reduces overhead, mental load, and premature optimization, while still enabling scalable, maintainable services.
Node.js 18 introduces an updated V8 engine, experimental global Fetch and Web Streams APIs, a new test runner module, and platform‑specific binary upgrades, providing developers with modern JavaScript features and improved tooling for backend development.
The article explains why a Spring Cloud project upgraded from Java 8 to Java 11 gets stuck during Maven compilation, shows how to enable detailed compiler logs with Maven‑compiler‑plugin settings, presents the lengthy compilation output, and advises cautious use of Lombok’s @Builder.Default to avoid similar hangs.
The guide reviews the essential requirements for Go local caching and compares seven open‑source caches—freecache, bigcache, fastcache, offheap, groupcache, ristretto, and go‑cache—while detailing the sharded, lock‑reduced designs of freecache, bigcache, fastcache, and offheap, and explains how off‑heap allocation or pointer‑free maps achieve near zero‑GC performance.
In this interview, Shopee backend engineer Draven discusses how his early blogging evolved into authoring a comprehensive Go language design book, compares book‑writing to blog series, shares his research‑driven learning methods for new technologies, outlines his current focus on OS, networking and C++, and invites readers to suggest technical books for a World Book Day giveaway.
This article explains the background, concepts, and implementation details of Aspect‑Oriented Programming in Java, covering joinpoint interface design, advice abstraction, static and dynamic weaving, and how Spring AOP applies these principles with illustrative code and diagrams.
This article introduces Java 18’s JEP 408 Simple Web Server, explains its purpose and limitations, walks through creating an HTML page, demonstrates launching the server via command line with various options, and shows how to access and verify the served content.
This guide walks you through setting up a basic Java gRPC project by outlining required Maven dependencies, creating the .proto SDK, implementing a server with a custom service, building a client stub, and running a test to verify the end‑to‑end RPC call.
This article demonstrates how to build a simple hot‑search functionality with user search history, hot‑keyword ranking, and profanity filtering in a Spring Boot application using Java, Redis ZSet operations, and a DFA‑based sensitive‑word filter, providing complete controller and service code examples.
This article explains how to retrieve sales statistics for multiple business units and their associated products in MySQL by comparing rows, discusses alternative approaches such as loop queries, OR concatenation, and mixed filtering, and demonstrates why row‑by‑row comparison is the most suitable solution.
This article demonstrates how to use EasyPOI to export Excel files with dynamically generated column headers and data rows in Java, covering dependency configuration, header creation, data population, merging cells, utility methods, DTO definitions, and a complete test case.
This article demonstrates how to replace verbose if‑else statements in an order‑processing system with a clean Strategy Pattern implementation, using custom annotations, a handler context, and Spring Boot components, providing complete code examples and a concise summary of the approach.
The article presents a kindergarten management system featuring three user roles, outlines its Spring Boot and Thymeleaf technology stack, details required runtime and database environments, provides step‑by‑step deployment instructions, and includes complete backend controller source code for user, teacher, student, and school management functionalities.
Learn how to use Spring Retry’s @Retryable and @Recover annotations to implement elegant, non-intrusive retry mechanisms in Spring Boot, covering configuration, code examples, parameter meanings, backoff strategies, and important considerations for reliable error handling.
Microsoft released .NET 7 Preview 3, introducing major updates such as full native AOT compilation, improved startup times, Write‑Xor‑Execute support, enhanced code generation, new X.500 certificate handling, and default‑enabled GC optimizations across most platforms.
This tutorial explains how to design and structure Django templates using a base.html layout, block inheritance, and reusable includes to keep the UI organized, eliminate duplicated code, and make future maintenance of a Django web project much easier.
This article compares native JDK ScheduledExecutorService, Spring Task, Redis‑based approaches, and popular distributed scheduling frameworks such as Quartz, Elastic‑Job, LTS, and XXL‑Job, providing code examples, usage scenarios, advantages, and best‑practice recommendations for implementing reliable timed jobs in microservice environments.
This guide explains why excessive try‑catch blocks hurt Spring Boot projects, introduces a unified response class, custom business exception, error enumeration, and a global @RestControllerAdvice handler, providing clean, reusable error handling with sample code and test usage.
SAPI++ is an open‑source multi‑application, multi‑tenant SaaS framework built on ThinkPHP 6.x, offering out‑of‑the‑box installation, API authentication, menu integration, and support for various front‑end technologies; the article details its features, advantages, required environment, and directory layout for developers.
This article demonstrates how to transform a flat list into a hierarchical tree structure in Java by defining a NodeVO class, implementing a recursive Stream‑based conversion method, and testing it with sample data, showcasing the elegance of the Stream API over traditional loops.
This article explains the mathematical and computer‑science definition of idempotency, why it is essential for reliable distributed services, how to handle timeout scenarios, and presents eight concrete design patterns—including unique IDs, database constraints, token mechanisms, optimistic/pessimistic locks, and distributed locks—along with code examples and HTTP method analysis.
