This guide introduces the Hutool Java utility library, showing how to install it via Maven and demonstrating key utility classes such as Convert, DateUtil, StrUtil, ReflectUtil, and more with practical code examples for backend development.
This article explains how Java developers can replace cumbersome if‑else status handling with a finite state machine implemented via enums, illustrating concepts, design patterns, and a complete example of an order‑delivery workflow, complete with diagrams and sample code.
This tutorial shows how to use the Moco API framework with a concise Groovy script—just five lines of code—to set up a mock server that serves a static blog, covering server configuration, URL redirection, mounting of static resources, and a simple wait loop for termination.
This tutorial walks through installing JDK and Maven on a CentOS server, cloning a Spring Boot Hello World project, building it with Maven, installing Docker, creating a Dockerfile, building and running the Docker image, and finally managing the container lifecycle.
This article explains Redis's startup sequence, detailing server initialization, configuration loading, event‑loop creation, supported I/O multiplexing mechanisms, timer and I/O callbacks, and the complete request‑response flow from client command to server reply.
PHP 7.4 Beta 4 has been released, fixing a series of core, date, mysqlnd, OpenSSL, reflection, and SPL bugs, while outlining the upcoming release candidate timeline and providing a download link for testers.
This article explains the fundamentals of RPC, the evolution and necessity of Dubbo in large‑scale Java applications, and outlines the core components, registration mechanisms, communication protocols, and step‑by‑step remote call process required to design a robust Dubbo‑based RPC framework.
This article introduces the most frequently used and popular Java utility classes, detailing their key methods such as IO handling, file operations, string manipulation, collection utilities, and encoding, based on analysis of 50,000 open‑source projects, helping developers avoid reinventing common functionality.
This article introduces RPC and gRPC concepts, explains how to define services with Protocol Buffers, and provides step‑by‑step Node.js and Go examples for building gRPC servers and clients, while covering language support, limitations, and reference resources.
This article presents a comprehensive overview of Huajiao's gRPC development practice, covering background decisions, gRPC features, gateway integration, Dart and Go client libraries, component architecture, protobuf conventions, code generation, SDK integration, documentation tooling, debugging strategies, and future roadmap.
This article shares practical experiences on diagnosing PHP interface performance bottlenecks using ThinkPHP's G function and profiling tools like Xhprof, then presents concrete code‑level, database‑level, and hardware‑level optimization techniques to improve execution speed and reduce resource consumption.
This article provides a step‑by‑step tutorial on installing JMeter, configuring environment variables, launching the tool, creating a test plan with thread groups and HTTP requests, and running performance tests on API endpoints, illustrated with screenshots and command‑line examples.
This article details the database table structures used for managing various homepage recommendation features—including brand, new product, popular product, subject, and advertisement tables—providing full MySQL DDL statements, field descriptions, and visual examples of both admin and mobile interfaces.
This article walks through building a simple RPC framework in Go using about 300 lines of code, covering RPC fundamentals, TLV network data format, serialization, transport layer, server and client implementations, and a complete example to help readers understand RPC concepts.
This article introduces RSocket, examines its production performance tests with Dubbo and Spring Flux, explains the protocol’s four interaction models and key features, and discusses the practical benefits of using RSocket for reactive business development and future back‑pressure scenarios.
This article explains the concept of Mock objects for testing, outlines why interface mocking is essential in web development, and details Huajiao's comprehensive Mock solution—including a SpringBoot‑based backend, MySQL data storage, Nginx redirection, and Lua scripts for dynamic request routing—providing step‑by‑step usage instructions and code examples.
This article explains the drawbacks of using a vendor directory in Go projects, outlines how Go module proxy solves those issues, and provides step‑by‑step guidance on configuring GOPROXY, choosing public or self‑hosted proxies, and recent Go 1.13 enhancements.
This article examines why GraphQL naturally emerges for complex front‑end data needs, details its language design, architecture, resolver middleware, mocking strategies, and various deployment patterns such as API‑gateway and BFF, offering practical guidance for building scalable GraphQL services.
This article examines the concept of a technical middle platform, outlining its purpose, the prerequisites for its adoption, the challenges of implementation, and the trade‑offs between over‑engineering and under‑delivering, while sharing real‑world examples of organizational friction and best‑practice recommendations.
This guide explains how to handle date and time parameters in Spring MVC by using @DateTimeFormat for request‑level conversion, configuring global formatters via WebMvcAutoConfiguration, and implementing custom Converter, GenericConverter, and Formatter beans to ensure seamless ISO‑8601 parsing.
This article explains how Spring's @Conditional annotation and its 13 specialized @ConditionalOnXxx variants let you load beans only when specific runtime conditions are met, covering usage on classes and methods, combination logic, and how to create custom conditional annotations.
This article explains the background, implementation, and practical usage of V8's code cache in browsers and Node.js, showing how serialized bytecode reduces JIT compilation overhead, speeds up startup, and benefits serverless functions.
The article examines the fundamental drawbacks of traditional monolithic applications—such as excessive complexity, slow development speed, poor scalability, and rigid technology stacks—and explains why these issues motivate developers to adopt microservice architectures.
The article demonstrates how Go’s built‑in pprof tools can be used for live performance profiling, walking through two real‑world cases—one where a malformed JSON request caused massive object allocation and CPU spikes, and another where per‑call self‑referencing structs leaked memory—while offering practical tips on input validation, allocation reduction, and GC monitoring.
This tutorial explains why cross‑origin requests fail in a SpringBoot application that uses SpringSecurity, demonstrates the problem with a sample mall project, and provides a complete solution by configuring a global CorsFilter and adjusting SpringSecurity to allow OPTIONS pre‑flight requests.
This article presents a comprehensive collection of Spring Boot best practices—ranging from custom BOM management, automatic configuration, project initialization with Spring Initializr, clean controller and service design, externalized configuration, logging, testing strategies, and more—to help developers build robust, maintainable Java microservices efficiently.
This article walks through rebuilding an asynchronous MySQL logging service using Spring Boot and MyBatis, providing full source code for the application entry point, DAO, service, controller, MyBatis mapper, and configuration, and shows the resulting database entries.
Spring Session enables distributed session sharing by storing HTTP session data in Redis, using a filter and listener configuration to replace Tomcat’s in‑memory storage, managing three Redis keys with coordinated expirations, and subscribing to keyspace events for reliable cleanup and cross‑instance access.
This article examines the challenges of a PHP‑based microservice stack, compares open‑source Java solutions, explains the rationale for adopting Spring Boot 2 with MyBatis and Undertow, and outlines a roadmap toward CI/CD automation, service discovery, and Service Mesh adoption.
This article introduces Nginx’s key capabilities—including static file serving, various load‑balancing strategies, leaky‑bucket rate limiting, browser and proxy caching, and black‑/white‑list access control—explaining how each feature can be configured and applied in high‑concurrency web environments.
This article provides a comprehensive overview of the Spring framework, Spring MVC, and Spring Boot, explaining how dependency injection reduces boilerplate and enables loose coupling, illustrating code examples with and without DI, and describing Spring Boot’s auto‑configuration, starter projects and typical starter options for building modern Java backend applications.
This guide walks beginners through Python fundamentals, essential development tools, HTTP basics, front‑end basics, popular web frameworks, database choices, testing strategies, and deployment techniques, offering practical book recommendations and actionable steps to start building real web applications.
This article completes the Spring Bean lifecycle overview by illuminating the remaining phases, explains how various XxxxAware interfaces are invoked during bean initialization, demonstrates common pitfalls with constructor injection, and provides code examples for implementing and using Aware interfaces such as BeanNameAware and BeanFactoryAware.
This article compares major PHP frameworks using Google Trends, Stack Overflow activity, GitHub star counts, and additional metrics such as Twitter followers, Packagist downloads, required PHP versions, and REST API response times to reveal why Laravel leads the 2019 rankings.
This article provides a detailed analysis of the order-related database tables—including orders, order items, operation history, and order settings—along with their fields, data types, and meanings, and showcases how these tables are presented in both admin and mobile interfaces of an e‑commerce system.
This article explains the core principles of message queues, outlines common data‑loss scenarios for RabbitMQ and Kafka, and provides practical techniques—such as transactions, confirm mode, persistence settings, and replication configurations—to ensure reliable, loss‑free messaging.
This guide defines and explains essential AMQP terminology—including virtual hosts, queues, exchanges, bindings, routing keys, producers, consumers, connections, and channels—to help developers grasp how message routing and queue management work in modern messaging systems.
This article presents a complete Spring Boot project template for an e‑commerce order service, covering README composition, one‑click local build scripts, business‑oriented package layout, automated test classification, logging, exception handling, background tasks with distributed locks, static analysis, health checks, Swagger API documentation, database migration, multi‑environment configuration, CORS setup, and a curated list of useful third‑party libraries.
This article walks through the core database tables that power product editing, SKU management, tiered pricing, full‑reduction discounts, member pricing, product reviews, verification records, and operation logs in an e‑commerce system, complete with SQL definitions and UI screenshots.
This article explains static and dynamic proxy patterns in Java, demonstrates how to use them for recording service response times, and shows how MyBatis leverages dynamic proxies to generate mapper implementations, complete with UML diagrams and sample code.
This article explains why NullPointerExceptions occur in Java, introduces the Optional class from Java 8 as a type‑safe alternative to null, and provides practical tips, code examples, and real‑world cases for using Optional to simplify error handling and improve API design.
This article explains a Java backend architecture with front‑end/back‑end separation, deployment diagrams, the concepts of thread, process and distributed locks, implementations using database optimistic locking, Redis and Zookeeper, session handling in distributed systems, and various related code examples and best‑practice notes.
The author recounts how, after his company closed, he built a lightweight Spring Boot‑Vue blog project, iterated it into a more complex human‑resource management system, documented each feature, released it on GitHub, and eventually saw it climb the GitHub Trending list, sharing lessons learned and advice for newcomers.
This article examines the contrasting popularity of MyBatis in China and Hibernate abroad, using Google Trends, Stack Overflow statistics, and industry anecdotes to reveal how cultural, managerial, and risk‑aversion factors shape Java ORM choices across regions.
This article examines the rise of Node.js as a lightweight web‑application platform since 2019, contrasting its rapid adoption with PHP’s long‑standing but gradually declining ecosystem, and explores how historical trends suggest Node.js may soon dominate backend development.
This article provides a comprehensive overview of Apache RocketMQ’s core architecture, including topic routing mechanisms, message storage file designs, high‑availability message sending, concurrent pull and consumption processes, HA synchronization, and transaction messaging, while offering practical learning steps and programming techniques for developers.
This tutorial explains how to use Spring's RestTemplate to download large files without exhausting memory, covering pitfalls of default methods, implementing a custom ResponseExtractor to stream data to disk, and adding support for resumable downloads via Range headers.
This article compares Spring's BeanFactory and ApplicationContext, explaining their roles in retrieving beans, detailing lazy versus eager loading, providing Java and XML code examples, and offering guidance on when to choose each interface for efficient backend development.
PHP 7.4 Alpha 2 has been released, fixing numerous core, date, GD, MySQLi, Opcache, and SQLite3 bugs, adding TGA image support, and previewing upcoming Typed Properties, while outlining the release timeline leading to the final version slated for November 2019.
This guide explains why to use the SLF4J façade with Logback, when to log, proper parameterized message formats, level‑specific conventions for ERROR, WARN, INFO, DEBUG, and TRACE, and provides concrete code examples for clean, performant logging in Java applications.
This article explains why Medium transitioned from a monolithic Node.js application to a microservice architecture, outlines the three core design principles, shares practical strategies for service creation, decoupling, observability, deployment, and how to avoid common microservice pitfalls.
The article introduces Apache Dubbo, a high‑performance lightweight Java RPC framework, outlines its core capabilities, development history, technical ecosystem, 2019 plans, shares micro‑service implementation experiences, and provides speaker and community information for the DataFun big‑data forum.
This article explains why session sharing is required in distributed Java back‑ends, demonstrates how Spring Session automatically synchronizes HttpSession data to Redis, and shows step‑by‑step how to configure Spring Boot, Redis, and Nginx to achieve transparent session sharing across multiple service instances.
After observing a Java process with persistently high memory usage, the article details a step‑by‑step investigation using top, ps, GC logging, and jmap to identify a memory leak caused by a third‑party jar, and shows how adjusting JVM parameters and fixing the code resolved the issue.
This article explains how to use Spring Session together with Redis to achieve transparent HTTP session sharing across multiple Spring Boot instances in a clustered environment, including project setup, Redis configuration, sample controller code, Nginx load‑balancing, and deployment steps.
This article explains the contract of equals and hashCode in Java, shows what goes wrong when only equals is overridden, provides a vivid house‑ownership analogy, and offers practical guidelines and code examples for correctly overriding both methods.
This article explains why using Java's Arrays.asList can lead to unexpected behavior, illustrates three typical pitfalls with primitive arrays, mutable lists, and unsupported modifications, and provides detailed analysis, source code insights, and practical alternatives for safely converting arrays to collections.
This tutorial walks you through installing Elasticsearch, creating indices, mapping schemas, inserting, updating, deleting, and searching documents using both cURL commands and the official Python client, illustrated with practical code examples and screenshots.
The author recounts his path from joining Alibaba's middleware team in 2014 to becoming an Apache Tomcat committer, PMC member, and Apache Foundation member, while also guiding Dubbo's migration to Apache and sharing practical lessons on open‑source contribution and large‑scale backend systems.
This article provides a detailed walkthrough of Openflowplugin's ContextChain creation process, explaining how DeviceContext, RpcContext, StatisticsContext, and RoleContext are instantiated and linked, and how the resulting ContextChain supports switch lifecycle handling and master/slave role election in an SDN controller.
This article explains how to compare JSON data returned by old and new services during a migration, demonstrates Python scripts for JSON and list comparisons, and provides useful tools and code snippets for validating data consistency before a full rollout.
This article introduces RocketMQ, compares it with ActiveMQ, explains its producer/consumer group model, describes various broker deployment modes, and provides a step‑by‑step dual‑master installation guide with configuration, log, and console setup instructions.
This article explains how Nginx obtains and releases shared memory on Unix and Windows, describes the unified ngx_shm_alloc/ngx_shm_free interfaces, and details the slab allocator’s page‑level and small‑block management, including allocation strategies, bitmap handling, and fragmentation issues.
This article explores why Java remains the dominant backend language, introduces the Dubbo framework and its evolution, explains core concepts such as providers, consumers, and registries, and details practical configurations for registry, load balancing, rate limiting, governance, monitoring, and extensions like DubboX and REST support.
Discover the most common MyBatis pitfalls—from # vs $ usage, handling nulls, resultMap quirks, and dynamic SQL issues—to master safe query practices, optimize performance, and avoid runtime errors, while comparing its strengths and weaknesses against Hibernate for effective Java backend development.
This article explains how Java's Load‑Time Weaving (LTW) enables static AOP via the java.lang.instrument package, details the core interfaces, demonstrates a complete code example with custom transformers and proxy classes, and shares practical tips for packaging the agent JAR.
This article explains how to apply the Strategy pattern within a Spring project, covering background, learning objectives, step‑by‑step code examples for query services A, B, and C, the three‑part invocation process, and both list‑based and map‑based configurations.
This article explains how Fangdd leverages Elasticsearch to boost search performance across consumer, broker, and internal products, detailing a platformized architecture that separates indexing and querying, addresses operational challenges, and outlines design patterns for index management and incremental updates.
This article reviews HTTP/2's core features, evaluates its performance advantages and limitations in real‑world web deployments, discusses server‑push and proxy challenges, and offers a forward‑looking perspective on its adoption across the industry.
A curated list of 13 high‑quality Spring Boot open‑source projects—including e‑commerce platforms, microservice frameworks, payment systems, and ERP solutions—each with brief descriptions, key features, and demo links to help Java developers find valuable codebases for learning and real‑world use.
This article reviews PHP's recent evolution—faster runtimes, a thriving ecosystem, modern language features, and improved tooling—while acknowledging lingering design quirks, to help developers decide whether PHP remains a viable choice for contemporary web development.
This article presents Gong Yunfei's 2019 talk from the Beijing Apache Flink x Apache Kafka conference, detailing how ByteDance leverages Kafka for its large‑scale streaming and data processing needs.
This article compares popular web technology stacks such as LAMP and MEAN, explains their components and derivatives, discusses other options like WISA, Ruby, Java‑Spring and Django, and provides practical guidance on how to select the most suitable stack for a project.
This article shares a publicly accessible Nacos server with login credentials, provides client configuration snippets for service discovery and configuration center, lists related Spring Cloud Alibaba tutorials, example repositories, and additional resources for developers to experiment with microservice architectures.
This article explores the challenges of API design, outlines fundamental principles such as clear mental models, simplicity, multiple implementations, and idempotency, and provides concrete best‑practice recommendations illustrated with the classic POSIX File API example.
The article explains the evolution of software architecture from simple monolithic designs through distributed applications and microservices to modern serverless solutions, outlining each model's structure, advantages, drawbacks, and impact on development, deployment, and operations for software engineers.
This article provides a comprehensive tutorial on Spring Boot, covering its purpose, key advantages, project setup with Maven, essential configuration files, integration of JdbcTemplate, JPA, MyBatis, JSP, AOP, and task scheduling, all illustrated with complete Java code snippets.
This article outlines the progressive evolution of system architecture—from a single‑server LAMP setup through service‑data separation, caching, clustering, read/write splitting, CDN, distributed databases, NoSQL, business splitting, and finally distributed services with messaging, service frameworks, service bus, communication patterns, and governance—highlighting the motivations, characteristics, and challenges at each stage.
This guide compiles must‑read books and tutorials on Spring, Spring Boot, MyBatis, MySQL, Linux, Elasticsearch, MongoDB, Docker and related tools, helping developers quickly acquire the knowledge needed to build and deploy a complex e‑commerce mall application.
After five years of Java development, this guide outlines the essential knowledge areas—including JDK source code, JVM internals, concurrency utilities, blocking queues, thread pools, and major frameworks such as Spring, MyBatis, Dubbo, and ElasticSearch—to help developers build a comprehensive expertise foundation.
This article explains what GraphQL is, how it solves common REST API problems, details its request structure, schema, type system, fragments, aliases, interfaces, unions, and resolvers, and provides a step‑by‑step tutorial for creating a GraphQL server using ThinkJS, MongoDB, and Apollo Server, while also outlining its advantages and drawbacks.
This article provides a comprehensive overview of Nginx, covering its core functions as an HTTP server and reverse proxy, the differences between forward and reverse proxy, supported load‑balancing algorithms, the master‑worker process architecture, and the detailed steps of how Nginx processes a request.
This article explains how Nginx was created to overcome Apache's limitations, describes its role as a high‑performance HTTP and reverse‑proxy server, clarifies forward and reverse proxy concepts, outlines common deployment scenarios, compares load‑balancing algorithms, and provides a feature comparison with other web servers.
This article examines Redis's I/O multiplexing mechanism, explaining why it uses non‑blocking models, detailing the Reactor pattern, comparing select, epoll, and kqueue, and providing a thorough walkthrough of the underlying C code that implements event creation, addition, deletion, and polling across platforms.
This article compiles essential Spring Boot best practices—from custom BOMs and auto‑configuration to logging, testing, and exception handling—offering developers actionable guidance to streamline microservice development, improve code quality, and maintain scalable, maintainable Java applications.
This article explains how to design a modular Python web crawler by breaking the system into five core components—scheduler, URL manager, downloader, parser, and data storage—provides detailed code examples for each module, and demonstrates a complete end‑to‑end crawling workflow on a sample website.
This article demonstrates how to replace cumbersome if‑else logic in an order‑processing system with a concise Strategy pattern implementation, using a custom @HandlerType annotation and Spring bean registration to make adding new order types effortless and maintainable.
The Shanghai Go technology salon brought together senior architects from QuTouTiao, Qiniu, and Bilibili to share real‑world implementations of Service Mesh, full‑link tracing, and microservice governance using Go, highlighting practical challenges, solutions, and future directions.
This article provides a comprehensive introduction to ZooKeeper, covering its definition, ZNode hierarchy, listener mechanisms, and practical applications such as unified configuration management, naming services, distributed locks, and cluster state monitoring, illustrating how these features enable robust coordination in distributed systems.
The Shanghai Go Language Tech Salon, co‑hosted by Qutoutiao and Jikebang, gathered senior architects from Qutoutiao, Qiniu, and Bilibili to share real‑world implementations of Go, covering a self‑built Service Mesh, full‑link tracing, and microservice governance, followed by an interactive Lean Coffee discussion on Go’s future.
This article introduces Java 8's Stream API, explains why functional streams improve code readability and performance, and walks through core operations such as filter, map, flatMap, reduce, collect, Optional handling, concurrency, and debugging techniques with clear examples and illustrations.
This article explores how MyBatis applies nine fundamental design patterns—including Builder, Factory, Singleton, Proxy, Composite, Template Method, Adapter, Decorator, and Iterator—by examining its source code, illustrating each pattern with explanations and concrete code snippets to deepen developers' understanding of real‑world pattern usage.
This article explains the Unix‑style philosophy behind command‑line programs, describes how Node.js enables powerful CLI development, and introduces essential tools such as n/nvm, nodemon, npx, nrm, commander, progress, chalk, inquirer, ora, puppeteer, as well as best practices for publishing scoped npm packages.
This article reviews HTTP/2's core features such as binary framing, multiplexing, header compression, and server push, evaluates their performance benefits and real‑world limitations, discusses implementation challenges in Go and proxy servers, and provides references for further study.
This article introduces Moco, a Java‑based mock server tool, explains its purpose for early API testing and frontend development, provides step‑by‑step startup commands, showcases JSON request/response demos for various HTTP methods, outlines global configuration, and discusses its limitations.
This article explains the original design goals of Go, outlines its key features and advantages such as fast compilation, simple syntax, powerful concurrency, and easy deployment, and compares it with languages like Java, C#, C/C++, JavaScript, Python, Scala, and Erlang.
This article examines the limitations of Spring Cloud Config—especially Git‑based permission control and coarse granularity—explains why a database‑backed configuration center is preferable, and details a custom long‑polling refresh mechanism built with Spring's DeferredResult and asynchronous servlets.
This article reviews the evolution of Youzan's order search architecture over two years, detailing challenges from data growth, the creation of a hot‑state index covering half of search traffic, time‑sharded indexes, and the AKF expansion cube that guides multi‑axis scalability.
This article explains how Spring enables transaction management through @EnableTransactionManagement, details the internal configuration selectors, bean registrations, AOP pointcuts, and the TransactionInterceptor implementation, illustrating the flow of transaction attribute detection, method interception, and exception‑based commit or rollback.
This article explains MyBatis fundamentals including the difference between #{} and ${} placeholders, various pagination approaches, logical versus physical pagination, first‑ and second‑level caching, lazy‑loading mechanisms, executor types, pagination plugin principles, and how to create a custom MyBatis plugin with code examples.
