This article explains how to implement token‑bucket rate limiting with Guava's RateLimiter, compare it to leaky‑bucket algorithms, and combine it with optimistic and pessimistic locking techniques to prevent overselling in high‑concurrency flash‑sale applications.
This article explains several typical pitfalls that cause Spring's @Transactional annotation to be ineffective, such as unsupported database engines, unmanaged service beans, internal method calls, non‑public methods, default rollback rules, and missing transaction manager configuration, and provides practical solutions for each case.
This article details a lightweight, low‑intrusion transactional message solution for microservices, covering design principles, database schema, Spring‑based implementation with RabbitMQ integration, compensation mechanisms, scheduling, and testing, illustrating how to achieve reliable asynchronous messaging while maintaining eventual consistency.
This article explains how Spring applies nine classic design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—detailing their implementation approaches, underlying principles, and the benefits they bring to Spring's IoC container and AOP mechanisms.
This article compiles typical Java backend interview questions and detailed answers covering self‑introduction, personal growth, concurrency primitives, JVM memory management, GC tuning, cache design, large‑scale data storage, Spring IoC, AOP, distributed session handling, and common design patterns.
This article explains how Spring's @EnableAsync annotation activates asynchronous method execution, detailing the roles of AsyncConfigurationSelector, ProxyAsyncConfiguration, AbstractAsyncConfiguration, and AsyncAnnotationBeanPostProcessor, and showing the underlying code that creates proxies, advisors, and executors for async processing.
Learn how to enable Spring's @Async support, configure custom executors, use @Async with void and Future return types, and implement custom exception handling for uncaught async errors, providing a complete guide to asynchronous method execution in Spring applications.
This article provides a comprehensive overview of frequently used Spring Boot, Spring MVC, and JPA annotations, explaining their purposes, typical usage patterns, and includes example code snippets to illustrate how they are applied in Java backend development.
This article explains how Spring implements nine core design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—detailing their implementation, underlying principles, and practical significance for Java backend development.
This article explains how the Spring framework implements various classic design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—detailing their implementation mechanisms, underlying principles, and practical significance within Spring's bean lifecycle and extension points.
This article demonstrates how to use Apache POI in a Maven‑based Java project to read and write both XLS and XLSX Excel files, covering library setup, core APIs, data type handling, and practical import/export implementations with Spring MVC and MyBatis.
This article explains the roles of BeanFactory and ApplicationContext in Spring, compares BeanFactory with FactoryBean, and provides detailed code examples showing how to configure and retrieve beans, including custom FactoryBean implementations and the use of '&' to access the FactoryBean itself.
The article introduces the MockRpc platform, which uses Spring‑based extensions and a mock server to fully decouple front‑end services from middle‑end services in a micro‑service architecture, enabling zero‑intrusion testing, configurable mock data, and improved development efficiency for JD Retail.
This article explains how to use Spring's RestTemplate to perform GET, POST, PUT, and DELETE HTTP calls, compares getForObject with getForEntity, demonstrates parameter passing styles, and shows how to handle redirects with postForLocation, providing complete code examples for each operation.
This article explains how to improve the performance of multi‑query server interfaces by converting asynchronous calls to synchronous execution using Spring's @Async annotation and CountDownLatch, outlining suitable scenarios, providing Java pseudocode, and sharing practical implementation tips.
This article explains the Prototype creational design pattern, its definition, key concepts, typical usage scenarios, UML illustrations, and provides a complete Java implementation with code examples, output analysis, and a discussion of its application in Spring's prototype‑scoped beans.
This article reviews Java's history, its widespread industry adoption, and presents a detailed comparison of the nine leading Java web frameworks in 2020, helping developers select the most suitable framework for their specific project needs.
This article explains the complete Spring Bean lifecycle—from bean retrieval, through creation, property population, initialization, and destruction—using detailed flowcharts, step‑by‑step descriptions, and full source code snippets to illustrate each phase.
This article outlines the essential steps for creating a traditional Java web application, covering environment preparation, Maven skeleton creation, required dependencies for logging, databases, persistence, Spring integration, DAO and service layers, unit testing, and RESTful controller configuration.
This article presents a curated list of the ten most essential Eclipse plugins for Java developers, explaining how each tool—ranging from Git integration and Spring support to Maven, SVN, code coverage, and live reload—boosts productivity and streamlines common development workflows.
This article explains the concept of idempotency in web services, analyzes common causes of duplicate submissions, and presents multiple backend solutions—including frontend button disabling, PRG pattern, session flags, local locks using ConcurrentHashMap, AOP interceptors, and distributed Redis locks—accompanied by complete Java code examples.
This tutorial provides a step‑by‑step guide on configuring the Alipay sandbox, generating keys, setting up notification URLs, creating the required database tables, and integrating the full payment flow—including DAO, service, controller, and JSP code—into a Java SSM backend project.
This article compiles over 150 Java interview questions covering collections, JVM tuning, concurrency, Spring framework, design patterns, Spring Boot, Netty, and Redis, providing a comprehensive study guide to help candidates prepare for upcoming interview seasons.
This article provides a systematic tutorial on using Spring‑Kafka, covering basic setup, embedded Kafka for testing, topic creation methods, message sending with KafkaTemplate, transactional messaging, request‑reply patterns, advanced @KafkaListener configurations, manual acknowledgment, listener lifecycle control, SendTo forwarding, and retry with dead‑letter queues, all illustrated with complete code examples.
This article aggregates over forty WeChat posts that cover Java interview topics ranging from Redis and hash structures to Spring lifecycle, multithreading, serialization, and database sharding, providing a valuable reference for developers preparing for technical interviews.
This article surveys Java’s evolution and market dominance, then evaluates the ten leading Java frameworks—Spring, Hibernate, Struts, Play, GWT, Grails, Blade, JSF, and Vaadin—highlighting their key features, use cases, and why choosing the right one is crucial for successful web development.
This article reviews the nine most popular Java frameworks in 2020—Spring, Hibernate, Struts, Play, Google Web Toolkit, Grails, Blade, JavaServer Faces, and Vaadin—detailing their features, industry adoption, and why they remain top choices for building scalable, high‑performance enterprise and web applications.
This article provides a comprehensive introduction to the Spring ecosystem, covering its core concepts such as IoC and AOP, detailing each of the seven framework modules, and explaining related projects like Spring MVC, Spring Security, Spring Data, Spring Boot, and Spring Cloud for modern Java backend development.
This article explains how Spring bean scopes affect thread safety, why most beans are safe when stateless, how to use ThreadLocal correctly, its internal hash‑map design, and the memory‑leak pitfalls that arise when ThreadLocal entries are not cleaned up.
This article lists and briefly describes the ten most starred Java open‑source projects on GitHub for November, covering tools such as NLP libraries, learning guides, big‑data frameworks, rapid‑development platforms, algorithm collections, job schedulers, code‑style checkers, traffic‑control systems, the Spring framework, and service‑discovery solutions.
This article explains the concept of cross-origin, why it occurs in modern web architectures, and provides practical Spring‑based solutions using JSONP and CORS together with jQuery AJAX examples, complete with configuration snippets and code samples.
This article explains how to write integration tests for Spring services that call external APIs by using WireMock to mock HTTP responses, handle dynamic ports, simulate error and timeout scenarios, and adjust exception handling in RestTemplate calls.
This article explains the role of Spring's DispatcherServlet, details its traditional web.xml configuration, walks through its request‑handling workflow, and shows how Spring Boot automatically configures and registers the servlet using concise code examples and annotations.
This article explains how to design a standardized JSON response format, define status codes and messages, and implement a global @ResponseResult annotation with interceptors and ResponseBodyAdvice in Java to simplify controller return values and improve error handling.
This article explains why improper use of ThreadLocal can lead to memory leaks in Java, details the underlying weak‑reference mechanism, and provides practical steps—including explicit removal and Spring integration—to safely manage ThreadLocal data and avoid resource exhaustion.
An in‑depth overview of the Spring ecosystem explains its core container, modules such as AOP, MVC, Data, Security, Boot and Cloud, detailing how IoC and dependency injection simplify Java enterprise development, and guides readers through configuration, architecture, and the advantages of using Spring for modern backend applications.
This article provides a thorough tutorial on using Spring‑Kafka, covering basic Maven setup, producer and consumer code, embedded Kafka for testing, programmatic topic creation, synchronous and asynchronous message sending, transaction handling, request‑reply patterns, advanced @KafkaListener options, manual acknowledgments, lifecycle control, message forwarding with @SendTo, and retry with dead‑letter queues.
This article explains how to build a reusable Java utility for exporting massive Excel reports, covering customizable headers, field formatting, multithreaded data retrieval, asynchronous processing, and provides full source code with detailed analysis and usage instructions.
This article presents a comprehensive, practice‑oriented overview of Domain‑Driven Design, covering its conceptual foundations, project‑level management, architectural layering, design patterns, implementation techniques with Java/Spring, testing, continuous integration, and deployment strategies for enterprise applications.
This article explains how @ConfigurationProperties and @ConfigurationPropertiesScan work in Spring Boot, the differences from @Value, and why upgrading from 2.2.0 to 2.2.1 may cause configuration beans to stop loading.
Recent tech headlines reveal a programmer’s server lockup leading to a startup’s collapse, Microsoft’s entry into the OpenJDK project, Spring Framework 5.1.11 and RxJava 2.2.14 releases, PyCharm 2019.3 EAP adding R support, and Samsung’s decision to dissolve its in‑house CPU team in favor of ARM.
This article compiles detailed notes from three rounds of Meituan’s Java interviews, covering SOA, micro‑services, load balancing, concurrency, JVM internals, Spring, database optimization, and algorithm challenges, while also outlining a learning roadmap for seasoned Java developers.
This article explains how to replace tangled if‑else statements in business code with the Strategy and Factory design patterns, demonstrates their implementation in Java and Spring, and shows how to register strategy beans to improve readability and maintainability.
This article explains why Spring's BeanUtils.copyProperties cannot copy static inner class fields and List properties without proper getters/setters, demonstrates the issue with demo code, and provides practical solutions to ensure successful property copying.
This article explains how excessive if‑else statements in business code hurt readability and maintainability, and demonstrates how to replace them with the Strategy and Factory design patterns integrated with Spring, using a food‑delivery discount example and complete Java code snippets.
This article explains how to replace tangled if‑else logic in business code with the Strategy and Factory design patterns, integrates them into a Spring application, and demonstrates the resulting improvements in readability, maintainability, and extensibility for discount calculations.
In a recent Java backend project, using Spring's BeanUtils.copyProperties to copy a request object with static inner classes and List fields caused missing fields and request failures, revealing the need for proper getters, setters, and separate handling of inner‑class properties.
This article explains how Spring handles circular dependencies through constructor injection errors, demonstrates how setter injection with singleton scope avoids the issue, and shows why prototype‑scoped beans still fail, providing code examples and internal mechanism details.
This article explores Dubbo's graceful shutdown mechanisms across versions 2.5.x, 2.6.x, and 2.7.x, detailing the underlying shutdown hooks, registry and protocol cleanup, Spring integration challenges, and best‑practice configurations to ensure in‑flight requests complete without service disruption.
This article explains the complete Spring Bean lifecycle—including definition via XML, various initialization methods, three ways to obtain and use a bean, and bean destruction techniques—illustrated with Java code snippets and a diagram for clear understanding.
Spring, Spring MVC, Spring Boot, and Spring Cloud are Java frameworks that respectively provide core IoC/AOP functionality, web MVC capabilities, convention‑over‑configuration rapid development, and comprehensive microservice governance, together forming a layered ecosystem for building clean, manageable, and scalable backend applications.
This article outlines ten frequent errors that Java backend developers make—from over‑focusing on low‑level details and leaking internal structures to neglecting proper testing—and offers practical guidelines and examples to write cleaner, more maintainable Spring‑based services.
This article explores the complexities of building a generic TCC distributed transaction framework, emphasizing the need for RM-local transaction integration, Spring TransactionManager takeover, fault‑recovery mechanisms, idempotency guarantees, and proper handling of Try/Confirm/Cancel phases to ensure global consistency.
This article provides a detailed overview of the most commonly used Spring MVC request‑mapping annotations, Spring Bean stereotypes, dependency‑injection and scope annotations, container configuration annotations such as @Autowired and @Primary, and essential Spring Boot annotations, illustrating each with clear code examples and diagrams.
This article examines common misuse of base Controller and Service classes in Java Spring projects, explains why they violate the Liskov Substitution Principle, and provides practical steps to split, refactor, and properly structure code across the three‑tier architecture.
This article provides a comprehensive guide to essential Spring annotations—including @Controller, @RestController, @Service, @Autowired, @RequestMapping, @ModelAttribute, @Cacheable, @CacheEvict, @Resource, @PostConstruct, @PreDestroy, @Repository, @Component, @Scope, @SessionAttributes, @Required and @Qualifier—explaining their purposes, usage patterns, and practical examples with accompanying diagrams.
This article introduces QMQ, Qunar's internal distributed message queue, covering its background, design motivations, core concepts, code examples for producing and consuming both real‑time and delayed messages, transactional messaging support, and the overall architecture of its metaserver, broker, and delay components.
This article presents a curated list of the most popular Java open‑source projects on GitHub for July, highlighting eleven repositories—most of them Spring‑based—along with their star counts, brief descriptions, and links for developers seeking valuable resources.
This article examines common misuse of base Controller and Service classes in Java micro‑service projects, critiques embedding business logic in Controllers, exposing persistence models to APIs, and offers concrete refactoring steps, project structuring patterns, and best‑practice guidelines to restore a clean three‑layer architecture.
This article outlines ten frequent errors that Java backend developers make—from over‑focusing on low‑level details and leaking internal structures to neglecting separation of concerns, proper exception handling, multithreading, validation, XML configuration, profile management, dependency injection, and testing—offering practical guidance to prevent each pitfall.
This article explains how to diagnose and manually re‑execute a Spring @Scheduled task that fails to send notifications by using Arthas to obtain the ApplicationContext, invoke the bean method, and reveals that a missing timeout in Hutool caused the original hang.
This article compares Spring's traditional RestTemplate blocking client with the newer reactive WebClient non‑blocking client, explaining their underlying mechanisms, performance differences under concurrency, and provides complete code examples for both approaches, helping developers choose the appropriate tool for efficient HTTP calls.
This article compiles a comprehensive set of Ant Financial interview questions covering Java fundamentals, concurrency, Spring, Linux, database design, NoSQL, distributed systems, and personal experience topics across the first, second, and third interview rounds.
This article provides a comprehensive overview of core Java concepts and related technologies, covering Spring's lifecycle, TCP three-way handshake and four-way termination, thread pool execution flow, JVM memory structure and Java Memory Model, as well as Spring MVC, JDBC, Spring Cloud components, and Dubbo service framework.
This comprehensive guide explores the fundamentals of the Spring framework—including its core modules, dependency injection, IoC, bean scopes, configuration styles, annotation-driven setup, event handling, and common design patterns—providing Java developers with practical examples and code snippets to master Spring's capabilities.
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 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 explains the dangers of XSS and SQL injection attacks, demonstrates realistic attack scenarios, and provides a comprehensive backend solution using Spring AOP, HttpMessageConverter, custom Servlet Filters, request wrappers, and ESAPI to sanitize inputs and protect web applications.
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.
This article explains the code types involved in synchronous remote calls, demonstrates how blocking IO leads to callback hell, and shows how to simplify the programming model using Java CompletableFuture, AsyncHttpClient, and Project Reactor’s reactive streams to efficiently retrieve city data.
This article explains how Spring registers bean definitions through various mechanisms such as BeanDefinitionRegistryPostProcessor, BeanFactoryPostProcessor, annotations, XML, @Import, ImportSelector and ImportBeanDefinitionRegistrar, using analogies and code examples to illustrate the process.
This article explains the fundamental role of Spring's BeanDefinition as the core data structure that records all bean metadata, compares it to real‑world analogies, lists the key BeanDefinition interface methods, demonstrates registration via annotations and @Bean methods, and shows how to inspect bean definitions at runtime.
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.
This tutorial explains the fundamentals of Aspect Oriented Programming (AOP) and demonstrates how to create a logging aspect in a Spring MVC application, covering AOP terminology, Spring annotations, pointcut expressions, a WebLog DTO, the WebLogAspect implementation, and how to test the logging output via Swagger UI.
This article presents a curated list of the most popular Java open‑source projects on GitHub for May, highlighting each repository's purpose, star count, and key features ranging from algorithm visualizations and interview prep notes to full‑stack e‑commerce platforms and core Spring frameworks.
This article provides an in‑depth, English‑language overview of the Spring framework, covering its purpose, core modules, IoC and AOP principles, bean scopes and lifecycle, transaction management, MVC architecture, and the design patterns it employs, all without heavy code examples.
This article reviews the most frequently applied design patterns in Spring—including IoC/DI, Factory, Singleton, Proxy (AOP), Template Method, Observer, Adapter, and Decorator—explaining their purpose, how Spring implements them, and providing concise code examples for each.
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 Youzan’s layered unit‑testing framework for microservice applications, outlines typical pain points such as massive test‑case rewrites, unstable test data, and missing result verification, and demonstrates how tools like DbUnit, H2, springockito, spring‑test and PowerMock are combined to provide data preparation, mock injection, automatic cleanup, and declarative result checks.
This article walks through a NullPointerException triggered by Spring Data Redis cache, analyzes the root cause in the RedisCache implementation, reproduces the issue with a Spring Boot demo, and provides practical solutions including connection‑pool tuning and custom cache handling.
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.
This article explains how Spring 5’s spring‑core jar incorporates JSR‑305 annotations, introduces the JSR‑305 standard for static analysis, and demonstrates practical usage—including package‑level rules and @Nullable/@NonNull examples—in Spring Boot microservice projects.
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 chronicles a Chinese computer science graduate’s step‑by‑step evolution from learning basic C and Java in university to building campus apps, winning software contests, mastering Spring, Hadoop, Elasticsearch, and Neo4j, and ultimately landing offers from top tech firms, illustrating the challenges and perseverance required for a successful software engineering career.
This article explains how to implement scheduled tasks in Java, compares built‑in JDK timers, Quartz, and Spring's task scheduler, and provides detailed steps for using Spring XML configuration, annotations, and dynamic code addition together with a guide to writing cron expressions.
This guide lists the core Spring 3 and Spring 4 modules, explains the purpose of each module, and provides the exact JAR dependencies you need to include when using Spring without Spring Boot, helping avoid compilation and runtime errors.
This article explains how to create Java scheduled tasks using Spring's built‑in task scheduler, covering XML configuration, annotation‑based setup, dynamic code addition, and detailed usage of cron expressions for precise timing control.
This article explains how to extract generic type information in Spring, first by manually parsing class hierarchies with reflection and then using Spring 4's ResolvableType utility, providing code examples and API references for fields, methods, constructors, and instances.
This article introduces the EasyRPC framework, explaining its RPC fundamentals, the use of Netty for communication, Spring for configuration, dynamic proxy for transparent calls, Protostuff for message serialization, and details both server-side service publishing and client-side invocation with reconnection handling.
This article introduces the high‑performance Cglib BeanCopier used in the Mica microservice framework, compares its speed with other bean‑copy tools, demonstrates usage with Spring and Lombok, explains the underlying ASM bytecode generation, and discusses current limitations such as lack of chainable beans and primitive‑wrapper handling.
The article explains why using the synchronized keyword together with Spring's @Transactional annotation can lead to lost updates when many threads increment a database field, analyzes the underlying transaction‑proxy interaction, and presents a refactored solution that moves the lock to a separate service to ensure correct results.
This article explains how to simplify Spring service method parameter checks by encapsulating inputs in POJOs, applying bean‑validation annotations, and using a custom AOP aspect or standard @AssertTrue to automatically enforce validation logic.
This article presents a curated collection of over 200 Java interview questions covering fundamentals, collections, concurrency, reflection, web technologies, Spring ecosystem, databases, messaging, and JVM internals, aimed at developers preparing for junior to senior-level interviews and seeking to identify and fill knowledge gaps.
This article explains how Spring implements declarative transaction management using proxies, compares JDK dynamic proxies and CGLIB, demonstrates their behavior with code examples, and clarifies which method modifiers support transactional annotations in Spring applications.
This article discusses practical Java programming techniques, including proper DTO conversion, use of BeanUtils, Lombok annotations, builder patterns, static constructors, validation with JSR‑303, and design considerations such as refactoring, strategy versus state patterns, to help developers write cleaner, more maintainable backend code.
Spring’s shift from XML to annotation‑based configuration is explained, covering @Configuration and @Bean requirements, example Java classes, equivalent XML, annotation definitions, bean scopes, component scanning, unit‑testing, and practical tips for wiring beans without field injection, providing a complete guide for modern Spring development.
This article examines the challenges of using transactions with database read/write splitting, including potential master‑slave switching errors, connection‑pool deadlocks caused by isolation levels and propagation, and presents Spring‑based dynamic data source and transaction management solutions.
This article explores nine commonly used Spring design patterns—including Simple Factory, Factory Method, Singleton, Adapter, Wrapper, Proxy, Observer, Strategy, and Template Method—explaining their concepts, showing XML or Java code examples, and illustrating how Spring implements each pattern in real applications.
This tutorial explains how to integrate the ShedLock library with Spring, covering Maven dependencies, JDBC table setup, required annotations, and example code for creating synchronized scheduled jobs that run on only one instance at a time.
