This guide shows the original Maven dependency for the MySQL Connector/J library and provides the updated coordinates with the newer groupId, artifactId, and version, helping Java developers keep their projects up to date.
The article outlines the typical evolution of large‑scale internet system architecture—from simple single‑node deployments through cluster and distributed cluster stages to future cloud‑native designs—highlighting the business‑driven reasons, technical challenges, security concerns, and practical principles for each phase.
This article explains how Java source files are compiled into class files, how they can be decompiled, and provides a detailed, code‑rich tutorial on protecting a Spring Boot project by configuring ProGuard through a proguard.cfg file and Maven plugin to produce an obfuscated JAR.
The investigation revealed that Elasticsearch RestClient’s built‑in round‑robin and dead‑node blacklisting redirected traffic from failed data‑node addresses—mistakenly included in the static IP list—onto a single client node, causing severe load imbalance and timeouts, which were eliminated after correcting the IP list.
This article explains the inner workings of Spring Boot's auto‑configuration mechanism, covering the role of @SpringBootApplication, @EnableAutoConfiguration, spring.factories scanning, conditional annotations, and how configuration properties are bound to beans, with code examples and diagrams for clear understanding.
This article shares a senior architect's personal career timeline from early jobs in Fujian to senior roles at Ant Financial, along with practical Java interview tips, lessons on communication, workload management, and project showcase strategies to help junior developers succeed in competitive tech interviews.
This article explains why MySQL LIKE queries are inefficient for search, introduces Elasticsearch as a high‑performance alternative, and provides a complete Spring Boot integration tutorial—including version compatibility, Maven dependencies, Java configuration, entity mapping, repository interfaces, service and controller code, and testing steps—to implement CRUD‑style full‑text search for a book catalog.
This article provides a practical guide to API design, covering fundamental concepts, rate‑limiting strategies, version management, permission and security considerations, and tips for effective inter‑team API collaboration, all illustrated with real‑world code examples.
This article explains how to implement an efficient routing system for Node.js web frameworks using a Trie (prefix tree) data structure, covering static, dynamic, and regex route matching, code examples, performance considerations, and practical tips for optimizing route lookup.
This article provides a step‑by‑step tutorial on configuring Nginx as an HTTP server, static file server, reverse proxy, load balancer, and explains location matching, variable usage, and common directives such as return, rewrite, error_page, and access logging.
Learn how to configure Spring WebFlux's WebClient with various HTTP client connectors, customize memory limits, handle responses, send request bodies and form data, apply filters, and use advanced exchange methods, all illustrated with concise Java code examples for reactive backend development.
The article recounts a production incident caused by a simple log addition, then analyzes FastJSON’s serialization process, explaining why methods like isChinaName() are invoked, how ASM-generated serializers work, and offers best‑practice guidelines using @JSONField(serialize = false) to control serialization.
This article compares popular Java task scheduling solutions—including Quartz, ElasticJob‑Lite, XXL‑JOB, and custom implementations—explaining their core components, clustering strategies, distributed lock mechanisms, and practical code examples to help engineers choose the right framework for their needs.
Microsoft announced the official release of .NET 7 on November 9, highlighting major enhancements such as improved Base Class Library, native ARM64 support, expanded Linux and IBM Power compatibility, integrated .NET MAUI and Blazor updates, and streamlined container and Azure cloud‑native capabilities.
The article examines Baidu's Contract Advertising Platform, detailing its shift from a monolithic, siloed design to a DDD‑driven microservices architecture using COLA, CQRS, and layered governance, and shares best practices for handling complex B2B advertising scenarios, service iteration, and evolving business needs.
This article examines whether Redis can serve as a reliable message queue by exploring its List, Pub/Sub, and Stream data types, comparing their features, performance, and limitations, and ultimately guiding readers on suitable use cases versus professional queue solutions.
This article narrates a real‑world debugging scenario where adding a new field to a Java class stored in Redis caused deserialization failures, explains why missing serialVersionUID leads to mismatched versions, and demonstrates how explicitly defining serialVersionUID resolves the issue.
This article analyzes a FastJSON serialization issue caused by an unexpected call to isChinaName(), explains the underlying JavaBeanSerializer workflow, demonstrates how ASM-generated serializers work, and proposes coding conventions using @JSONField to prevent unwanted method execution during JSON conversion.
This tutorial explains how to use Baidu's WebUploader component together with a Spring Boot backend to achieve large file uploads via chunking, breakpoint resume, merging, and instant MD5‑based upload, and also demonstrates a multithreaded chunked download solution with Java client code.
The author describes receiving a paid PHP development request, quickly implementing a cURL‑based HTTP client class to handle GET, POST, PUT, and DELETE requests with JSON payloads, and shares the full code to help others solve similar integration problems.
This article describes how to design and implement a gray (canary) messaging capability for RabbitMQ and Kafka, covering background, gray scenarios, two consumption strategies, and detailed production and consumption flows with code snippets for header tagging, requeue handling, and consumer group management.
This article consolidates essential Spring utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AOP helpers—explaining their purpose, common methods, and usage examples to help developers avoid redundant custom code and leverage built‑in functionality.
This article explains how to add a daemon flag to a Rust server, showing two implementations—one using the fork crate and another using the daemonize crate—so the service can keep running after the shell exits.
This article dissects MyBatis’s internal workflow, explaining how mapper interfaces are linked to XML files, detailing the step‑by‑step SQL execution process, and demonstrating how to create and apply custom typeHandlers for parameter setting and result mapping, all based on MyBatis 3.5.5 source code.
This article analyzes the original template‑variable replacement logic used in Alipay's card package, identifies costly String.replace operations, and presents five iterative optimizations—including removal of indexOf/substring, caching with Guava, and replacing String.replace with StringBuilder—that together achieve more than a ten‑fold speedup while discussing trade‑offs in readability and resource consumption.
This article explains MyBatis's first-level (SqlSession-scoped) and second-level (Mapper-scoped) caching mechanisms, their default behaviors, key generation, configuration options, and the impact of Spring integration, and provides recommendations for disabling caches in distributed environments to avoid data inconsistency.
This guide walks through preparing the environment, installing and configuring Elasticsearch, Logstash, Kibana, Kafka, and Filebeat on a CentOS 7 system, including necessary code snippets, user permissions, and troubleshooting tips for a fully functional logging and data pipeline.
This article explains how to secure Spring Boot APIs by encrypting request and response bodies with symmetric AES, handling signatures, and configuring Jackson serialization to preserve enum and date formats, providing complete code examples and debugging insights.
Shopee’s scalable fund‑routing decision engine combines a configurable Go‑based rule engine with Redis‑backed, Lua‑driven quota control to dynamically match loan orders to external capital providers, enforce multi‑dimensional volume limits, achieve tens of thousands TPS, and provide extensible risk‑management capabilities across markets.
Spring Framework 6.0 RC1 introduces Java 17+ requirement, migration to Jakarta EE 9+, AOT compilation support, virtual‑thread integration, and updated compatibility with Tomcat 10, Jetty 11, and Hibernate 6.1, while adding new HTTP client features and observability enhancements.
The article demonstrates how to replace fragile if‑else shop‑ranking logic in a Java backend with the Strategy pattern, progressing from simple factories and enums to Spring‑auto‑wired and generic factories, highlighting improved extensibility, reduced coupling, Open‑Closed compliance, and the trade‑off of added abstraction complexity.
This article provides a comprehensive overview of DolphinScheduler’s design strategies, distributed architecture, fault‑tolerance mechanisms, configuration files, core APIs, Quartz integration, master‑worker execution flow, RPC communication, load‑balancing algorithms, and logging services, accompanied by detailed code excerpts and diagrams.
This article explains why Zipkin is needed for microservice observability, describes its architecture, core components, trace and span model, workflow, and provides step‑by‑step Docker and JAR deployment instructions, helping developers quickly locate service bottlenecks and failures.
Spring Framework 6.0 RC1 has been released, requiring Java 17+, migrating to Jakarta EE 9+ namespaces, supporting the latest web containers and Hibernate ORM, introducing AOT compilation, virtual‑thread executor support, new @HttpExchange client, RFC 7807 handling, Micrometer observability, and more.
This article explains what an API gateway is, why it is needed in micro‑service architectures, outlines core design ideas such as request routing, service registration, load balancing, resilience and security, and compares major open‑source gateways like OpenResty, Kong, Zuul 1/2 and Spring Cloud Gateway.
The article reviews decades of Java development, explaining why technologies such as JSP, Struts, Hibernate, Applet, Swing, JDBC, and XML are now largely obsolete for new learners, and recommends focusing on Spring MVC, MyBatis, and a deep understanding of Servlets.
Spring Boot 2.7.5 has been released with over 30 bug fixes and dependency upgrades, includes details on configuration comment detection, Kafka auto‑configuration changes, PEM certificate handling, and provides guidance on switching from the unavailable Alibaba Cloud Maven mirror to Tencent Cloud’s mirror.
This article explores the use of Reactor in Spring Cloud Gateway, highlighting its role in enabling reactive programming for efficient API gateway implementations through non-blocking, asynchronous operations and advanced data flow management.
This article explains how to structure API responses in a micro‑service architecture, defines a unified JSON format with status codes, shows how to use annotations and interceptors to automatically wrap results, and demonstrates code refactoring for cleaner, more maintainable controller logic.
This article explains RocketMQ’s core components, the rocketmq‑remoting module, its Netty‑based protocol design, message structure, communication flow, and the Reactor multi‑thread model that together ensure high‑performance, reliable messaging in distributed backend systems.
This article introduces Google Guava's powerful utilities—including Joiner, Splitter, CharMatcher, Multiset, Multimap, BiMap, Table, Functions, Predicate, Cache, and asynchronous callbacks—explaining their advantages over standard JDK classes and demonstrating practical usage with code examples for Java developers.
This article walks through the design and implementation of a hand‑written Spring AOP module, covering core concepts such as Advice, Pointcut, weaving, proxy creation, and the integration of these components into a bean lifecycle to enable method‑level enhancements without modifying source code.
This article provides a comprehensive tutorial on using Spring annotations for pure annotation‑based development, defining beans, managing bean scopes, performing various injection techniques, reading configuration properties, and integrating Spring with MyBatis, complete with code examples and best‑practice tips.
This article explains how to restrict certain APIs to internal network calls by comparing three approaches—microservice isolation, gateway + Redis whitelist, and gateway + AOP—and provides a complete Java implementation of the AOP solution with code examples.
This article shares a backend team's practical experience of adopting GraphQL with Express and Apollo Server as a BFF layer, covering motivations, implementation steps, schema merging, proxy configuration, HTTP caching strategies, DataLoader optimization, code generation, and integration testing to improve performance and developer efficiency.
This article explains why and how to split a Spring Boot project into Maven modules, defines a common framework with clearly separated modules such as api, base, rpc, service, interaction, and start, and provides practical steps and code snippets for managing dependencies in complex backend applications.
This article introduces gRPC, explains its HTTP/2 and Protocol Buffers foundations, walks through writing and compiling .proto files, provides complete Python server and client examples, and shows how to quickly set up the environment and integrate gRPC into microservice and Kubernetes deployments.
This article explains three practical solutions for exposing internal‑only APIs in a Spring Cloud environment—separating services, using a gateway with a Redis whitelist, and applying a gateway‑plus‑AOP strategy—complete with code examples and deployment tips.
This article walks through a real‑world OOM incident in an MQ consumer caused by large Excel import/export, explains how memory dumps and Prometheus logs pinpointed the culprit, and shows how switching from XSSFWorkbook to SXSSFWorkbook and tuning the thread pool resolved the issue.
This article walks through building a Redis validation tool in Rust, demonstrates how trait objects cause lifetime compilation errors, and shows how to fix them by adding explicit lifetime parameters to structs and implementations.
This guide explains how to use Spring Boot's RouterFunction API to create, combine, and nest reactive routes with RequestPredicates, demonstrating practical code examples for GET, POST, and complex route compositions in a Spring WebFlux application.
This article provides a comprehensive tutorial on role‑based access control (RBAC) concepts, model classifications, permission definitions, user‑group usage, and step‑by‑step implementations of Spring Security, JWT integration, JSON login, password encryption, and database authentication with extensive code examples.
This article explains nine practical methods for reading files placed in the resources folder of a Spring Boot project, covering classloader resource retrieval, URL decoding, getFile(), getResourceAsStream, ClassPathResource, absolute paths, and environment‑variable based approaches, each with code examples.
This article explains how RocketMQ implements distributed transaction messages using a two‑phase commit model, detailing the problems with RPC and ordinary MQ, the step‑by‑step workflow, relevant code snippets, and how consistency is ensured across microservice subsystems.
After upgrading to Spring Boot 2.7.1 (Spring Framework 5.3.21), the execution order of @Around, @Before, and @After advice changes, leading to ThreadLocal data loss inside @Around, and the article explains the cause, reproduces the issue, and recommends using only @Around for reliable logic.
This article demonstrates how to use RabbitMQ's delayed‑queue plugin together with Spring Boot to create a lazy exchange, configure a durable queue, send messages with a specified delay, and consume them, providing complete Java code examples and explaining why this approach outperforms traditional Redis, database polling, or JVM DelayQueue solutions.
HiMock is a comprehensive mock platform designed to overcome traditional mock limitations by offering low‑code, code‑decoupled, high‑performance, and full‑scenario support across multiple protocols and front‑end/back‑end channels, enabling efficient testing, performance benchmarking, and parallel development for complex services such as bike, e‑bike, and ride‑hailing.
This tutorial demonstrates how to create Spring Boot scheduled tasks whose execution intervals can be changed at runtime using both CronTrigger and PeriodicTrigger, providing REST endpoints to update the cron expression or timer value dynamically.
This article explains why RabbitMQ is used for decoupling, asynchronous processing, and traffic shaping, describes its architecture and core components such as broker, exchange, queue, binding, routing key, vhost, producer, consumer, and channel, and outlines its six operating modes with illustrative diagrams.
This article walks through the practical steps of improving Elasticsearch relevance for an enterprise search platform, covering user requirements, index creation, analysis, scoring models, boost and filter techniques, function_score customizations, and post‑query interventions to deliver more accurate and business‑aligned results.
This article presents a real-world Java backend case where a newly hired developer caused a NullPointerException during data matching and batch insertion, analyzes each line of the problematic code, and offers defensive programming techniques such as null checks, Optional, and utility methods to avoid NPEs.
This comprehensive guide explores Node.js’s architecture, core APIs, global variables, built‑in modules, function styles, the event‑loop mechanics, task scheduling, next‑tick and microtasks, libuv’s role, and strategies for off‑loading work, providing developers with a deep understanding of how Node.js runs JavaScript efficiently.
This article provides a detailed tutorial on Celery, covering its architecture, installation, task structures, basic and advanced usage, integration with Django, and code examples for creating workers, scheduling tasks, and retrieving results, enabling developers to implement robust asynchronous processing in Python applications.
This article provides a step‑by‑step guide on designing the database schema and implementing a multi‑level approval workflow for office automation, covering form submission, dynamic approver selection, core audit tables, transaction safety, and the logic for approval and rejection handling.
Eclipse Foundation announced Jakarta EE 10, introducing a new Core Profile and dozens of updated specifications that simplify, modernize, and lightweight‑enforce cloud‑native Java applications while maintaining compatibility with earlier releases.
This article provides a step‑by‑step tutorial on building a unified authentication center with Spring Security OAuth2, covering project module planning, authorization and resource server configuration, client module setup, gateway integration, and custom security components, complete with Maven dependencies and Java code examples.
This article explains the principles, advantages, and implementation details of Java's JDK dynamic proxy and CGLIB proxy mechanisms, providing step‑by‑step code examples that demonstrate how to enhance method calls such as user registration with validation logic.
This guide walks through designing a simple front‑end/back‑end microservices architecture, implementing it with Spring Boot and Eureka, deploying the services on a Kubernetes cluster using K8seasy, and adding high‑availability features such as multi‑instance registration, Prometheus‑Grafana monitoring, Zipkin tracing, and Sentinel flow‑control.
The first release candidate of PHP 8.2.0 (RC1) has been published, introducing trait constants, a new Random extension, enhanced JIT support, updated MIME types for the built‑in web server, memory optimizations, new socket and Curl options, additional ZipArchive methods, and several performance and cross‑platform improvements.
This article explains how Spring Boot's auto‑configuration works, detailing the role of @SpringBootApplication, @EnableAutoConfiguration, the spring.factories mechanism, conditional annotations, and how configuration properties are bound to beans such as ServerProperties, providing a clear understanding for developers and interview preparation.
This article explains how interviewers assess candidates on MQ reliability by discussing system decoupling, traffic control, the three stages of message flow, detection of loss, id generation, idempotent consumption, handling backlog, and scaling strategies for Kafka and similar brokers.
This article explains Java's verbosity problem, introduces Lombok as a code‑generation tool that uses annotations like @Data to auto‑create getters, setters, equals, hashCode and toString, shows installation and Maven setup, and discusses both the productivity gains and the hidden drawbacks such as team dependency, debugging challenges, inheritance issues, encapsulation concerns, and future JDK compatibility risks.
This article explains how RocketMQ creates and manages threads, covering single‑thread techniques, the ServiceThread abstract class, ThreadPoolExecutor fundamentals, custom thread‑pool wrappers, and the critical role of descriptive thread names for debugging and performance monitoring.
The article explains the logical execution order of a SQL query—starting with FROM/JOIN, then WHERE, GROUP BY, HAVING, SELECT, DISTINCT, ORDER BY, and finally LIMIT—using diagrams, code snippets, and practical examples to illustrate each step.
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.
