This article explains how to create a web‑based chat application similar to WeChat using Netty as the core server, WebSocket for real‑time communication, and Spring MVC for HTTP handling, covering architecture, required tools, core code, and deployment steps.
This article examines common business scenarios that require timed execution, explains why scheduled tasks are essential, compares standalone and distributed Java scheduling frameworks—including Timer, ScheduledExecutorService, Spring, Quartz, TBSchedule, Elastic-Job, Saturn, and XXL-Job—and provides guidance on selecting the most suitable solution based on scalability, reliability, and operational needs.
This article explains how to bundle a default configuration file into a Rust binary using the rust-embed crate, load it at runtime, and override it with a user‑provided file placed alongside the executable.
The article presents thirty concise architectural principles covering simplicity, iterative development, automation, ROI, user focus, concurrency, distributed system design, configuration management, and practical guidance, aiming to help architects and developers build maintainable, scalable, and user‑centric software systems.
This article explains the definitions of View Object (VO), Data Transfer Object (DTO), Domain Object (DO), and Persistent Object (PO), compares their roles, illustrates their placement in a three‑layer architecture, and provides guidance on when to merge or separate these objects in real‑world backend development.
This tutorial demonstrates how to secure Spring Boot REST endpoints using Spring Security, covering URL‑based rules, enabling method‑level security, and applying @PreAuthorize, @RolesAllowed, and @Secured annotations for precise access control.
This article provides a comprehensive overview of Spring and Spring Boot's extension points, detailing each lifecycle hook, its purpose, typical use cases, and sample implementations, enabling developers to customize bean initialization, configuration, and shutdown processes with concrete code examples.
This article explains the limitations of traditional HTTP session handling, explores session sharing strategies for clustered environments, and walks through a complete Java CAS‑based single sign‑on solution with code examples, highlighting the differences between CAS and OAuth2.
In this article, the author describes a Python web‑scraping issue where the retrieved data mismatched the displayed map, outlines the original code shared by a community member, explains how switching to a different API resolved the problem, and provides the final matching results.
Go 1.19.1 introduces security patches for net/http and net/url, fixes numerous bugs in the compiler, go command, pprof, linker, runtime, and crypto libraries, and resolves issues such as package import errors, generic compilation crashes, and signal handling problems.
The article advises that POJO class attributes should always use wrapper types without preset default values, illustrating several pitfalls such as null‑overridden defaults during Jackson deserialization, BeanUtils copy failures, MyBatis dynamic SQL issues, and RPC/API default‑value bugs.
This article walks through diagnosing and fixing an XPath extraction issue in a Python web scraper, showing the original faulty code, the corrected selector, and the final working script with sample outputs, while emphasizing best practices like setting request headers.
This article explains why servlet request/response streams are single‑read, introduces Spring's ContentCaching wrappers, and provides step‑by‑step code for creating a reusable HttpBodyRecorderFilter and a pattern‑matching proxy to record bodies based on HTTP status codes.
The article introduces eight widely used software architecture design patterns—single‑database single‑application, content distribution, query separation, microservices, multi‑level caching, sharding, elastic scaling, and multi‑data‑center deployment—explaining their structures, typical use cases, and the key pros and cons of each.
This article provides a comprehensive overview of Spring Cloud’s microservice ecosystem, explaining core components such as Eureka, Ribbon, Feign, Zuul, Hystrix, and Config, and comparing them with alternatives like Dubbo and ZooKeeper, while illustrating practical e‑commerce use cases.
This article investigates why DBLE repeatedly logs "no handler" messages by analyzing DBLE and MySQL logs, using Arthas to trace the call chain, reproducing the scenario with timeout settings, capturing network traffic, and explaining the MySQL 8.0.24 error‑packet behavior that leads to the observed logs.
This comprehensive guide explains MyBatis fundamentals, compares it with Hibernate, details its lifecycle, configuration, dynamic SQL, caching, lazy loading, batch operations, pagination, and plugin development, providing code examples and best‑practice recommendations for Java backend developers.
This article explains why manual timestamp logging is cumbersome, introduces Spring's org.springframework.util.StopWatch and Apache Commons Lang's StopWatch, provides Maven dependencies, detailed usage examples, key methods, and important cautions for accurate performance measurement in Java applications.
This article explains why a Spring Boot application that runs fine in an IDE may throw NoSuchMethodError or NoSuchFieldError when packaged as an executable jar, and provides systematic steps—including JVM class‑loading flags, Maven enforcer rules, and class‑path inspection—to locate and resolve the root cause.
The IntelliJ platform has moved its source code to Java 17, requiring IDE 2022.3 to run on Java 17 while still supporting some modules for older Java versions, and this shift impacts plugin development, version compatibility, and build processes for developers.
This article explains how Node.js determines its development direction through transparent governance, outlines how to track upcoming releases, describes the three release lines and recent features like ECMAScript Modules, node:test, and Corepack, and introduces active working groups and strategic initiatives for the next decade.
An experienced Python developer walks through a real-world web‑scraping issue, showing how a faulty XPath selector caused empty results, then provides corrected code, execution screenshots, and best practices like adding request headers, helping readers quickly resolve similar problems.
This article explains how the smart outbound calling platform was conceived, compares VoIP platforms, introduces Freeswitch architecture and development modes, details SIP call flows and configuration, and describes the progressive evolution from a single‑instance deployment to a load‑balanced, hub‑and‑spoke architecture for high‑concurrency, multi‑tenant call‑center services.
Exploring Go 1.18, the article walks readers through its three flagship additions—generics, fuzzing, and workspaces—detailing installation, underlying implementation concepts, practical code examples, and how each feature enhances type safety, automated testing, and multi‑module dependency management for modern backend development.
The article explains why unit testing matters, why managers should focus on higher‑level API tests rather than method‑by‑method coverage, and provides practical checkpoints for transaction, query, and compensation interfaces to help technical leaders promote a results‑oriented testing culture without overwhelming developers.
This tutorial walks through implementing login authentication using Spring Cloud Gateway and JWT, covering core concepts of authentication, authorization, credential handling, token generation, gateway validation, service integration, and token refresh strategies within a microservice architecture.
Version 4.4.5 of the open‑source CakePHP framework, which implements ActiveRecord, Association Data Mapping, Front Controller and MVC patterns, has been released, introducing enhanced SMTP authentication error handling, restored parameter display in debug stack frames, API documentation upgrades, a fix for diffForHumans() localization, and deprecation of ValidatableInterface.
This article explains how Spring Security builds its core FilterChainProxy and DefaultSecurityFilterChain, outlines three ways to create custom security filter chains, and demonstrates how to implement and register a custom filter within the Spring Security filter chain.
This article explains the four key techniques—page‑cache usage, sequential disk writes, zero‑copy transfers, and partitioned segment indexing—that enable Kafka to achieve exceptionally high write performance, detailing how each mechanism reduces latency and maximizes throughput.
This article explains a configurable multi‑strategy data‑masking solution for Spring Boot APIs, covering the design of a custom annotation, serializer, AnnotationIntrospector, ObjectMapper integration, and example usage on response objects.
This article introduces the Guava‑Retrying library for Java, explains how to add its Maven dependency, demonstrates building a Retryer with customizable retry conditions, stop strategies, wait strategies, and listeners, and provides detailed code examples illustrating each component.
This article explains how to configure RabbitMQ queue priority, defines reusable PHP base, service, and client classes, and demonstrates running the code to send and consume prioritized messages using the PhpAmqpLib library.
This tutorial explains the producer‑consumer principle using RabbitMQ, provides a reusable PHP base class for queue connections, and demonstrates how to create service and client classes to send and receive messages, followed by step‑by‑step instructions to run the code and view the queue.
This article explains the role of RocketMQ's NameServer, detailing its registration process, data structures, periodic heartbeat checks, failure cleanup, and how producers and consumers retrieve routing information to send and receive messages efficiently.
IntelliJ’s source code has moved to Java 17, meaning most platform and plugin modules now target Java 17, the 2022.3 IDE release requires it, and developers can use new language features by setting plugin.xml to 223, while still supporting older versions with Java 11.
This article explains how Elasticsearch leverages inverted indexes, term dictionaries, and compression techniques such as Frame‑of‑Reference and Roaring Bitmaps to enable rapid full‑text search, detailing the underlying data structures, query processing, and practical indexing tips for efficient backend search implementations.
This article introduces Go (Golang), explains its key advantages for building high‑availability, scalable backend services, and provides step‑by‑step installation instructions for macOS, Windows, and Linux platforms.
This article explains common pitfalls of Spring's transaction management—including AOP proxy limitations, unchecked exception handling, self‑invocation, asynchronous execution, multiple data sources, and large transaction issues—and provides practical solutions such as using class‑based proxies, configuring rollback rules, and splitting transactions into smaller units.
This article introduces Spring WebFlux, explains the concept of reactive programming, compares it with Spring WebMVC, describes its concurrency model, and provides complete code examples for building a reactive Spring Boot application using Mono, Flux, functional routing, and WebClient.
This tutorial walks through downloading compatible Erlang versions, installing RabbitMQ on Windows, starting the service, verifying its status, and accessing the management UI with default credentials, providing a complete setup for backend development with RabbitMQ.
This session explains why SaaS applications need tenant data routing, compares multi‑tenant sharing models, details dynamic data source architecture, routing plugin design, tenant identifier propagation, and future sidecar solutions, helping developers choose appropriate isolation strategies, configure flexible data sources, and avoid cross‑tenant data contamination.
This tutorial demonstrates how to use the MyBatis-Plus-Join (MPJ) library to perform left and right join queries in Spring Boot without writing XML SQL, covering dependency setup, entity and mapper modifications, query construction with MPJLambdaWrapper and MPJQueryWrapper, pagination support, and practical tips.
This article explains how Elasticsearch uses inverted indexes, term dictionaries, and advanced compression techniques such as Frame‑of‑Reference and Roaring Bitmaps to achieve rapid search performance while minimizing memory and disk usage, and it also covers practical indexing tips for production use.
This article theoretically outlines seven major Java performance optimization strategies—including reuse, computation, result set, resource conflict, algorithm, high‑efficiency implementation, and JVM tuning—explaining their principles, typical techniques, and how they collectively improve resource utilization and application speed.
This article provides a comprehensive analysis of Spring AOP, covering its core concepts, configuration parsing, BeanFactoryPostProcessor and BeanPostProcessor mechanisms, namespace handling, the creation of advisors and advice from @Aspect annotations, and the proxy generation process that enables method interception.
This article explains how Spring implements various design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—detailing their implementation approaches, underlying principles, and practical code examples within the Spring container.
This comprehensive guide explains why a service gateway is needed in microservice architectures, details Spring Cloud Gateway's core concepts, deployment steps, route and predicate configurations, local and global filters, integration with Nacos for service discovery, dynamic routing via Apollo, and custom global exception handling, providing code examples throughout.
This article introduces Spring WebFlux, explains reactive programming concepts, compares it with Spring MVC, and provides practical code examples demonstrating how to build a reactive web application using Spring Boot, Reactor's Mono and Flux, and functional routing.
This article explains the fundamentals of RPC and gRPC, compares popular RPC frameworks, details gRPC's features and Protocol Buffers advantages, and provides a complete Java hands‑on example with code, project structure, and performance benchmarks.
The article explains how a Business Monitoring Platform isolates user‑defined Groovy scripts by assigning each script its own custom Java ClassLoader that loads uploaded JARs, breaking parent‑delegation, preventing class conflicts, reducing Metaspace growth, and dynamically creating Feign and Dubbo beans for safe, independent execution.
This article explains the concept of dependency injection, why it is essential for Go backend services, compares manual object wiring with DI containers, reviews popular Go DI libraries, and demonstrates how to use Uber’s Fx framework (and a custom Viego framework) to simplify application initialization and lifecycle management.
This article walks through practical Go implementations of Redis list commands—including LPush, RPush, LLen, LRange, and others—provides unit test examples, demonstrates a simple performance benchmark, and shares a reusable wrapper library for streamlined backend development.
This guide explains how to use Redis Bitmap to efficiently store and query massive binary state data—such as user login status and daily sign‑ins—by leveraging GETBIT, SETBIT, BITCOUNT, BITPOS, and BITOP commands, dramatically reducing memory usage for millions of users.
This article explains how systematic data construction, using a low‑code front‑end and Java back‑end platform, streamlines complex test scenarios, reduces manual effort, and enhances both testing efficiency and code quality across multiple business systems.
This article explains the fundamentals of Remote Procedure Call (RPC), compares popular RPC frameworks such as gRPC, Thrift, Dubbo and Spring Cloud, details gRPC’s architecture, Protocol Buffers serialization, HTTP/2 advantages, and provides a step‑by‑step Java demo with full source code and performance benchmarks.
This article explains how to start PHP's built‑in HTTP server for local testing, keep it running after the terminal closes by using nohup, and notes the default log file and production‑environment limitations.
This article explains the concept of multi‑tenant architecture, compares three data isolation strategies, and provides a complete MyBatis‑Plus configuration with code examples to automatically add tenant IDs, including how to filter specific SQL statements, helping developers build cost‑effective SaaS back‑ends.
This article explains the concept of idempotency, why it is needed for HTTP interfaces, the impact on system design, and presents several practical backend solutions—including database unique keys, optimistic locking, anti‑repeat tokens, and downstream sequence numbers—accompanied by complete Spring Boot code examples using Redis for token management.
Time management in programming spans human concepts of time, language-specific handling of zones and timestamps, 32‑bit overflow risks, sync versus async processing, log timestamping, business‑level period calculations, and common pitfalls, emphasizing that mastering these nuances prevents bugs, improves performance, and enables reliable analytics.
Domain‑Driven Design (DDD) transforms traditional three‑tier development by introducing a unified domain model, clear bounded contexts, and tactical patterns like aggregates and value objects, enabling teams to separate business complexity from technical concerns, improve collaboration, and build more maintainable, adaptable software architectures.
This article walks through installing VSCode, adding Java‑related extensions, configuring Maven, importing a SpringBoot project, and using essential shortcuts and debugging features, demonstrating that VSCode can serve as a lightweight, open‑source alternative for Java development.
The article explains how Domain‑Driven Design combined with Onion Architecture creates a flexible, maintainable, and testable backend system by organizing code into concentric layers that isolate business logic from external concerns, supporting microservices, modular packaging, and appropriate testing strategies.
This article outlines the major new features of PHP 8 and PHP 7, explains why PHP 7 outperforms PHP 5, describes the execution flow, web‑request lifecycle, underlying architecture, data structures, garbage‑collection mechanism, and the PHP‑FPM master‑worker model with optimization tips.
This article explains three major pitfalls when using java.util.Arrays.asList: passing primitive arrays, attempting to modify the returned list, and misunderstanding that the list shares the original array, providing code examples and proper alternatives for each case.
This article walks through the evolution of software design from a traditional monolithic API server to a CQRS-based architecture, highlighting the drawbacks of the anemic CRUD model, the benefits of read/write separation, domain messaging, eventual consistency, and practical implementation considerations.
The article examines the difficulties encountered when implementing a Backend‑For‑Frontend (BFF) layer in the JD Finance app, introduces a visual service‑orchestration platform that replaces hard‑coded solutions with drag‑and‑drop workflows, details its core functions, architecture, and performance benefits, and demonstrates how it dramatically improves delivery speed, service governance, and debugging efficiency.
This article provides a detailed overview of Nginx, covering its role as a high‑performance web server and reverse proxy, explains installation steps, walks through core configuration files—including global, events, and http blocks—and demonstrates practical setups for reverse proxy, load balancing, static‑dynamic separation, performance tuning, and high‑availability clustering.
The article outlines common problems in API integration and presents a comprehensive set of design principles—such as sufficiency, single responsibility, simplicity, abstraction, compatibility, low coupling, orthogonality, testability, and uniformity—to help engineers create clear, maintainable, and developer‑friendly backend APIs.
This free public roadmap guides beginners through essential front‑end fundamentals, rapid PHP onboarding, and optional advanced topics, providing curated course titles and direct links to help learners quickly master web development with PHP.
This article explains the Chain of Responsibility design pattern in Java, illustrating its use for multi‑level approval workflows during high‑traffic events, provides step‑by‑step code implementations, refactors naive IF logic into modular link classes, and demonstrates testing, highlighting benefits for clean, extensible backend architecture.
This article explains how Domain‑Driven Design combined with the Onion Architecture creates a flexible, maintainable backend by separating concerns into concentric layers, detailing principles, services, testing strategies, microservice applicability, and modular packaging to help developers build scalable, technology‑agnostic systems.
This article introduces Java's Stream API, explaining how filter, map, flatMap, and other intermediate operations work, provides practical code examples for each, and demonstrates stream creation, conversion, and parallel processing to efficiently handle collections and large data sets.
This article explains the concept and execution methods of rule engines, describes the forward‑link inference approach used by ZhiZhuan’s risk‑control engine, and details the evolution from hard‑coded rules to feature‑engineered expressions using the Aviator expression engine, highlighting configuration, data sources, and practical examples.
This article introduces eight typical software architecture design patterns—including single-database single-application, content distribution, query separation, microservices, multi-level caching, sharding, elastic scaling, and multi-datacenter deployment—explaining their structures, typical use cases, advantages, and disadvantages for building scalable, high-performance systems.
This guide details nine practical techniques for accessing files in a Java project's resources folder, covering classloader paths, URL decoding, getFile vs getPath, InputStream retrieval, ClassPathResource usage, absolute paths, and environment variable methods, with complete code examples for each approach.
This article explains how to start a new project using Domain‑Driven Design, introduces key terminology such as IAAS/PAAS/SAAS, describes the evolution of architecture through bounded contexts, and details the four DDD boundaries together with clean layered, hexagonal and onion architectures for building scalable backend systems.
This article explains how a Java compiler‑time AST injection component replaces manual monitoring instrumentation with a simple @UMP annotation, detailing the technology selection, implementation using JSR‑269 annotation processors, and the trade‑offs of compile‑time versus runtime weaving.
Meta has officially added Rust, Hack, Python, and C++ as its preferred backend languages, outlining strict criteria such as core library support, security, operational risk, expertise, and developer experience, while also noting community‑supported languages and its long‑term commitment to Rust amid broader VR ambitions.
This article explains how interview candidates can demonstrate mastery of MQ reliability by describing the three message lifecycle stages, detection mechanisms for loss, idempotent consumption techniques, and strategies to resolve backlog, providing concrete examples and design principles for robust backend systems.
This article explains the concept, scenarios, advantages, and implementation details of Apache RocketMQ's timed/delay messages, including the TimerWheel algorithm, service workflow, a financial payment‑timeout use case, and practical steps for creating and consuming timed messages.
This article presents a detailed survey of over thirty Python web frameworks, describing their official sites, main features, advantages, and drawbacks, and offers guidance on selecting popular options such as Django, Flask, FastAPI, and many others for various development needs.
This article provides a detailed overview of the major features introduced in PHP versions 5 through 8, including autoloading, PDO, MySQLi, namespaces, traits, built‑in server, scalar type declarations, nullable types, JIT compilation, named arguments, union types, match expressions, and many useful code examples.
This article provides a comprehensive analysis of MyBatis, covering its core architecture, the process of obtaining SqlSessionFactory and SqlSession, the dynamic proxy mechanism for mappers, the execution flow of SQL statements, the plugin system, first‑ and second‑level caching strategies, and how Spring manages MyBatis mappers through factory beans and import registrars.
This article explains the principles behind Spring Boot Starters, how auto‑configuration works via META‑INF/spring.factories, provides practical code examples, and lists the most common starters to help Java developers streamline dependency management and reduce configuration complexity.
This tutorial explains how to create a Dockerfile for a PHP‑Apache project, build the image, run the container, verify its status, and use volume mounting and exec commands to manage the application inside the container.
The talk traces the evolution of API Gateway architectures and the engineering practices—design patterns, deployment strategies, and operational considerations—required for scalable, reliable services, then demonstrates how ClickHouse can be leveraged for massive data workloads, highlighting practical scenarios, performance optimizations, and key lessons learned.
This article explains the principle of interface idempotency, presents practical techniques such as version‑based updates and token mechanisms, and then delves into distributed rate‑limiting dimensions, common algorithms like token‑bucket and leaky‑bucket, and concrete implementations using Guava, Nginx, Redis and Lua with full code examples.
This article introduces XEChat‑Idea, a Netty‑based instant messaging and game‑battle plugin for IntelliJ IDEA, detailing its project structure, required development environment, and step‑by‑step instructions for building, running, and deploying both the server and the IDEA plugin.
The July VS Code Java update introduces built‑in Lombok support, notification‑driven activation, language‑bar version management, toggleable settings, drag‑and‑drop file operations, inlay hint exclusions, function‑breakpoint debugging, expanded quick‑fix actions, and a Spring bean dependency view, all aimed at improving the Java developer experience.
This article explains how to create a lightweight, plug‑in‑style microservice flow orchestration system using Docker‑installed Nacos for configuration, three SpringBoot services with Kafka integration, and dynamic topic management to enable hot‑swapable data pipelines without heavy frameworks.
This article provides a comprehensive overview of Spring Cloud’s microservice architecture, detailing core components such as Eureka, Zuul, Ribbon, Hystrix, Feign, and Config, comparing registration centers like Nacos, ZooKeeper, Consul, and Etcd, and discussing best practices for service discovery and API gateway design.
The article presents a comprehensive overview of JD Daojia's Open Platform, detailing its service lifecycle—from platform introduction, service design, publishing, and authorization to state management and traffic‑control mechanisms—while explaining the underlying RPC‑based architecture and fixed‑window rate‑limiting algorithm.
This article provides a comprehensive guide to Spring Batch, covering its purpose, architecture, core components such as Job, Step, ItemReader/Writer/Processor, chunk processing, skip strategies, common pitfalls, and practical configuration examples for robust batch applications.
This article introduces Spring Batch as a lightweight, comprehensive batch‑processing framework for enterprise applications, explains its overall architecture, and details core concepts such as Job, JobInstance, JobParameters, JobExecution, Step, StepExecution, ExecutionContext, JobRepository, JobLauncher, ItemReader, ItemWriter, ItemProcessor, chunk processing, skip/failure handling, best‑practice guidelines, and common troubleshooting tips.
This article introduces EasyFunction, JD's serverless FaaS platform built on iPaaS, detailing its background, applicable scenarios such as BFF, data processing, SSR and admin panels, the business benefits, core product features, and several real‑world deployment cases.
Monet is a custom API gateway built on Spring Cloud Gateway that consolidates multiple platform endpoints into a single domain, providing unified routing, API management via Zookeeper, authentication and authorization, dynamic rate‑limiting with Sentinel, and extensible monitoring, addressing scalability and operational challenges of the Linglong platform.
This guide walks through obtaining a free SSL certificate, exporting it from the provider, and configuring a Spring Boot application to use the certificate, including detailed steps, screenshots, and the necessary server.yml configuration.
The article explains how marketing automation platforms adopt industrial‑grade workflow engines to streamline complex user‑journey processes, outlines sequential, state‑machine and rule‑driven engine types, describes a self‑developed engine’s core modules and service interfaces, and highlights performance, versioning, plugin and monitoring considerations.
This article demonstrates how to implement a flexible data‑masking solution for sensitive fields in Spring Boot APIs by defining a custom annotation, creating a serializer, integrating it with Jackson via an AnnotationIntrospector, configuring the ObjectMapper, and applying the annotation to domain objects.
PHP 8.2 expands the language’s strong‑typing capabilities by introducing two new standalone types, null and false, which can now be used independently in type declarations, a feature previously unavailable and now available after the RFC’s acceptance and merge into the master branch.
