This article explains the fundamentals of Spring AOP's JDK and CGLib dynamic proxies, compares their implementation details, presents performance test results across Java 1.6‑1.8, and offers practical guidance on choosing the appropriate proxy based on use‑case.
This article details the design, evolution, and implementation of an online test‑monitoring platform that transforms CI/CD pipelines into proactive alerting systems, covering the initial Spring‑based prototype, its shortcomings, the 2.0 configurable and visual redesign, plugin architecture, and future distributed deployment plans.
A comprehensive collection of over 70 interview questions covering Java concurrency, Spring framework, MySQL optimization, JVM internals, Linux command-line tricks, Redis usage, and system monitoring, designed to help backend engineers prepare for technical interviews across major Alibaba subsidiaries.
This article compiles the most frequently asked Java interview questions—from basic introductions and multithreading concepts to JVM internals, Spring framework details, middleware, database fundamentals, and Redis—providing a comprehensive study guide for job seekers.
The article explains how a microkernel architecture separates a stable core from plug‑in components, enabling static and dynamic composition through annotations or configuration files, illustrated by e‑commerce checkout and iQIYI payment redesign, and introduces the open‑source Navi framework for declarative matcher‑based component selection, highlighting extensibility as essential for rapid business growth.
Explore the GOF 23 design patterns with a deep dive into the Singleton pattern, covering its purpose, characteristics, comparison to static classes, and multiple Java implementations—including eager, lazy, double‑checked locking, volatile, static inner class, and enum approaches—plus Spring’s real‑world usage.
This article walks through nine common design patterns used in the Spring framework—Simple Factory, Factory Method, Singleton, Adapter, Decorator, Proxy, Observer, Strategy, and Template Method—showing their concepts, Spring-specific implementations, and practical code snippets.
This article systematically outlines the essential steps and considerations for creating a classic Java web application, covering environment preparation, Maven scaffolding, logging and database dependencies, DAO design with MyBatis, Spring integration, service-layer best practices, and RESTful controller implementation.
This tutorial provides a step‑by‑step guide for configuring the Alipay sandbox, generating keys, setting up the required database tables, and integrating Alipay payment APIs into a Java SSM project, complete with code snippets, configuration details, and troubleshooting tips.
This article outlines practical techniques for enhancing Java service robustness, covering standardized response structures, thorough parameter validation, retry strategies, idempotent design, and functional programming with lambdas to reduce runtime errors and improve maintainability.
This article explains how a JavaEE project integrates JSP front‑end with Struts2, Spring, and MyBatis on the backend, describes the three‑tier architecture, the role of each layer, database communication with Oracle, and the evolution from classic MVC to Web 2.0 approaches.
This article explains why microservice architectures demand specialized automated testing, compares testing styles such as unit, contract, and end‑to‑end, and walks through a practical Java‑based framework built on Spring, TestNG and Dubbo, including setup steps and code examples.
The article outlines Alibaba’s three‑stage interview assessment—fundamental knowledge, project experience, and project depth—provides key Java and framework topics to study, and explains how mastering these layers can boost both interview performance and everyday development skills.
The article explains how Dubbo's standalone service container loads optional Spring, Jetty, and Log4j modules, details their configuration properties, demonstrates various startup methods, and provides a complete Java implementation of the SpringContainer with start and stop logic, followed by a test main class.
This article outlines the complete set of front‑end, back‑end, database, server, and deployment technologies and best‑practice knowledge a developer needs to build and run a simple yet functional Java Web application, providing a clear big‑picture roadmap for beginners.
This article shares the practical experience, new features, component changes, migration steps, and pitfalls encountered while upgrading an old Spring Boot 1.x backend to Spring Boot 2.0, offering guidance for a smoother transition and highlighting post‑upgrade issues such as path matching, HTTP PUT handling, and Swagger compatibility.
This article explains how to implement scheduled tasks in Spring using the lightweight Spring Task framework, covering both XML‑based and annotation‑based configurations, providing complete code examples, cron expression details, and practical tips for Java backend developers.
This guide outlines a comprehensive, step‑by‑step strategy for preparing Java backend interview candidates—covering architecture, databases, core Java, multithreading, JVM, and practical tips to demonstrate senior‑level expertise.
This article explains the principles of distributed locks, discusses why they are needed in distributed applications, and provides a complete Java implementation using Redis’s NX and EX parameters, including lock acquisition, blocking and non‑blocking modes, unlocking with Lua scripts, configuration, usage examples, and testing strategies.
This article explains why distributed caching is essential for high‑traffic services, presents three programming approaches (direct code, Spring‑Data‑Redis injection, and annotation‑based), compares three cache‑access patterns, details sharding models, outlines smooth and offline migration steps, and addresses cache penetration, concurrency, avalanche, and transaction support with concrete code examples.
This article outlines the fundamental Java SE concepts, servlet and JSP basics, HTML/JavaScript essentials, and the core SSH frameworks (Struts2, Spring, Hibernate) while providing interview questions and guidance on project modeling, design, and implementation for enterprise-level development.
The article analyzes a StackOverflowError that occurs during Spring application startup after upgrading to JDK 8, tracing the deep bean‑creation call chain caused by extensive use of @Autowired with MyBatis MapperFactoryBean, and recommends upgrading mybatis‑spring and switching to @Resource to prevent the overflow.
This article walks through the evolution from plain Java implementations of a DAO interface to using the Decorator pattern, Java dynamic proxies, CGLIB proxies, and finally Spring AOP, demonstrating how each approach adds reusable timing logic while discussing their advantages and drawbacks.
This article explains Aspect‑Oriented Programming (AOP) as a complement to OOP, introduces core AOP concepts such as aspects, join points, pointcuts, advice, weaving and introductions, and provides a step‑by‑step Spring XML configuration with Java code examples demonstrating time‑logging and logging aspects, ordering, selective pointcuts, and forced CGLIB proxy usage.
This article provides a comprehensive overview of essential Java fundamentals, covering ThreadLocal, the JVM memory model, garbage collection mechanisms, synchronization primitives like synchronized and ReentrantLock, volatile semantics, concurrency utilities, thread pools, class loading, and common data structures such as HashMap and ConcurrentHashMap.
This article introduces Dubbo’s background, explains the evolution of e‑commerce architectures to RPC‑based distributed systems, details Dubbo’s components, advantages, and drawbacks, and provides a complete Maven‑based demo—including Zookeeper installation, Spring configuration, and Java code—for building and consuming a Dubbo service.
This article explains the purpose of using a framework, introduces Spring's core concepts of container, inversion of control, and aspect‑oriented programming, and demonstrates them through a Java banking report example with complete code, XML configuration, and annotation‑based AOP to achieve loose coupling and modularity.
This article provides a comprehensive introduction to essential Java backend technologies—including Spring MVC, Spring IoC/AOP, MyBatis, Dubbo, Maven, RabbitMQ, Log4j, Ehcache, Redis, Shiro—and outlines basic design‑pattern concepts, helping developers understand their roles, core mechanisms, and practical usage.
This tutorial explains why sensitive configuration data must be encrypted in microservice environments, walks through installing the Unlimited Strength JCE, configuring Spring Cloud Config’s {cipher} syntax, using symmetric and asymmetric keys, testing encryption endpoints, and managing keystores with keytool.
This article explains the fundamentals of Spring AOP by introducing proxy patterns, demonstrating static and dynamic proxy implementations with full Java code examples, and showing how Spring integrates JDK and CGLIB proxies through XML configuration for real‑world cross‑cutting concerns such as transactions and logging.
This article provides an in‑depth exploration of Spring's core concepts—including the IOC container, ApplicationContext vs BeanFactory, bean instantiation lifecycles, and the role of FactoryBean—supplemented with diagrams and source code excerpts to help Java developers understand the framework's inner workings.
This article introduces core Java backend concepts such as reflection and annotations, explains ORM principles, and provides concise overviews of major frameworks—including Hibernate, MyBatis, Struts2, Spring, and Spring MVC—along with related tools like JUnit, SVN, and Maven.
This article provides a step‑by‑step tutorial on building a Spring container, configuring Spring MVC with DispatcherServlet, setting up essential beans such as multipartResolver, custom handler mapping, handler adapter, view resolver, component scanning, and finally integrating MyBatis with SqlSessionFactoryBean and SqlSessionTemplate for a complete Java backend solution.
This step‑by‑step guide shows how to create a simple Spring Boot application, configure Gradle or Maven builds, write MockMvc tests, and use Spring REST Docs to automatically generate up‑to‑date API documentation snippets that can be included in Asciidoctor‑based docs.
This article explains how to correctly configure Maven dependencies for Spring 3 (and briefly for Spring 4), detailing the framework’s five module groups, their individual jars, dependency relationships, and providing ready‑to‑use XML snippets for both core and web projects.
This tutorial walks through building a lightweight Spring MVC clone in Java, covering the MVC workflow, nine core components, project setup, custom annotations, a DispatcherServlet implementation, and a test controller, with full source code and deployment instructions.
This article reviews the most popular Java web frameworks, ranking Spring, JSF, and GWT at the top, introduces additional options like Play!, Struts, Vaadin, Grails, and provides sample code and setup instructions for each, helping developers choose the right tool for their projects.
This guide walks through extracting Java source files from a deployed WAR package, decompiling the bytecode with free tools, and reorganizing the output into a Maven‑compatible web project structure so the application can be maintained and extended.
This article examines the performance problems of a custom microservice gateway—including high CPU usage and frequent Full GCs—detailing root‑cause analysis, trie‑based URL routing, regex optimization, and further architectural improvements to enhance scalability and reliability.
This article provides a comprehensive guide on integrating ActiveMQ with Spring, covering XML configuration of connection factories, producers, consumers, various MessageListener implementations, message conversion, and JMS transaction management, supplemented with complete code examples and deployment instructions.
This article outlines the core professional skills, project experience, development processes, tools, interview questions, and negotiation tips that Java developers need to master to succeed in job interviews and advance from junior to senior positions.
The author recounts a recent Alibaba Java Web interview journey, reflects on gaps uncovered during the process, and compiles a comprehensive list of core Java Web concepts—including JVM internals, servlets, Spring, Hibernate, Struts, HTTP fundamentals, and design patterns—to guide future learning and preparation.
This article presents a detailed Java learning roadmap that starts with front‑end basics, progresses through core Java SE concepts, object‑oriented programming, databases, web technologies, major frameworks, and advanced topics such as JPA, Lucene, and high‑performance architecture, offering a structured path for aspiring developers.
This article provides a detailed English-language overview of the Spring Framework, covering its lightweight nature, IoC container, AOP support, core modules, bean lifecycle, configuration methods, annotations, transaction management, and Spring MVC architecture in a concise yet thorough manner.
This article presents a complete design and implementation of a flash‑sale (SecKill) system, detailing entity models, DAO methods, service and controller layers, a high‑concurrency test, and an improved solution using row‑level locking to prevent overselling under heavy load.
The article examines Spring Data REST’s CVE‑2017‑8046 remote‑code‑execution flaw, showing how a malicious JSON Patch path is turned into an unchecked SpEL expression that can run arbitrary commands, reproduces the exploit on a sample Spring Boot app, and advises upgrading to versions that include the path‑verification fix.
This article explains Java's dynamic proxy mechanism, covering the roles of InvocationHandler and Proxy classes, their APIs, the parameters required for creating proxy instances, and a complete example that demonstrates how method calls are intercepted and delegated through a custom handler.
This article introduces Spring's BeanPostProcessor, explains its two callback methods, and demonstrates through a real‑world A/B testing scenario how custom annotations and a post‑processor can inject dynamic proxies to simplify routing logic and improve code maintainability.
This article explains how Spring Framework applies four classic design patterns—Interpreter, Builder, Factory Method, and Abstract Factory—to simplify object creation and configuration, providing clear Java code examples, Spring bean definitions, and a discussion of their roles within the framework.
This article explains how to design and implement a Java‑based flash‑sale (seckill) system that can handle tens of thousands of concurrent requests, covering entity modeling, DAO methods, service logic, controller handling, a concurrency simulation test, and an improved locking strategy to prevent overselling.
The article reflects on a year of Java backend work, discussing common misconceptions and covering fundamentals such as class initialization order, value and reference passing, collection usage, exception handling, object‑oriented principles, multithreading, Spring framework components, web basics, database and NoSQL integration, server operations, and third‑party API integrations, offering practical lessons learned.
This article presents a curated list of essential Java books covering JVM internals, HotSpot, concurrency, multithreading, effective coding practices, web technologies, large‑scale site architecture, middleware, distributed consistency, MySQL, and deep Spring source analysis, offering guidance for developers seeking to deepen their backend expertise.
This guide outlines the core knowledge areas for Java web development, covering JVM fundamentals, servlet lifecycle, major frameworks like Spring and Hibernate, HTTP essentials, and design patterns, offering a concise roadmap for aspiring backend engineers.
The article surveys cache fundamentals—request flow, hit rates, eviction policies, and media—then compares local versus distributed caches and reviews concrete implementations such as programmatic caches, Ehcache, Guava, memcached, and Redis, before detailing Spring’s annotation‑driven caching and a Meituan case study on custom annotation caches.
This article explains the fundamental ACID properties of database transactions, details the four isolation levels—READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE—illustrates common concurrency issues like dirty, non‑repeatable, and phantom reads with examples, and shows how Spring’s transaction propagation and additional features can be leveraged to manage them effectively.
This article details the challenges encountered when upgrading a production environment from Java 7 to Java 8, including Spring 4.0 compatibility issues, JVM crashes, GC and JIT tuning, and Metaspace memory management, and provides concrete solutions and best‑practice recommendations.
This tutorial explains how to install Docker and MyEclipse, create a Dockerfile for a Tomcat 7 image, build and run the container, deploy a Spring Shopping Cart example inside it, and use MyEclipse features to manage and test the Dockerized web application.
This guide introduces Spring StateMachine, shows how to add the 1.2.0 release to a Spring Boot project, defines order‑related states and events, configures the state machine with annotations and Java code, and demonstrates a complete run that processes payment and receipt events.
This comprehensive guide outlines the core Java programming competencies, web development frameworks, project experience, management tools, system architecture components, interview questions, and personal evaluation tips that aspiring Java engineers should master before a job interview.
Alibaba architects attended the SpringOne conference in Las Vegas, sharing insights on emerging technologies such as ReactiveX, Ratpack, Java 9 modules, Spring 5 and 1.4, Zipkin, XRebel, PaaS platforms, serverless computing, cloud‑native principles, Agile, DevOps, and microservices, highlighting both global trends and challenges for Chinese cloud providers.
This article explains how to centralize Java application logs by configuring Log4j's JMSAppender to send log events to an ActiveMQ broker, demonstrates project setup with Maven, shows Spring integration, and provides detailed code examples and troubleshooting steps for reliable remote logging.
This article explains Spring's declarative transaction mechanism, detailing transaction attributes such as propagation behavior, isolation levels, timeout and read‑only flags, and illustrates each propagation type with Java code examples to show how transactions are started, joined, suspended, or nested.
This article provides a comprehensive collection of 69 Spring interview questions and answers, covering core concepts such as the framework overview, benefits, modules, IoC container, bean scopes, dependency injection, AOP, annotations, JDBC template, DAO support, transaction management, and MVC architecture.
This article provides a comprehensive overview of the Spring framework, covering its low‑invasion design, IoC container, dependency injection types, bean scopes, autowiring options, bean creation methods, post‑processors, zero‑configuration annotations, and AOP support with AspectJ, supplemented by practical code examples.
This article explores two practical approaches to implementing a delayed queue—using a sorted‑queue with JDK's DelayQueue logic and a Redis‑based solution with ordered sets and Spring Scheduled—to handle high‑throughput order processing while discussing their trade‑offs and implementation details.
This article introduces the Spring Framework, explains its layered architecture and core modules, and details fundamental concepts such as Dependency Inversion Principle, Dependency Injection, BeanFactory, BeanDefinition, and ApplicationContext, along with practical Java‑based configuration and annotation‑driven wiring examples.
This article explains how Spring's XML configuration can inject simple values, collections, arrays, maps, Properties, bean references, internal beans, null values, and object‑graph navigation, and it provides concise syntax examples and test code for each case.
This article explains the fundamentals of dependency and dependency injection in Spring, compares class relationships such as inheritance, association, aggregation, and composition, and demonstrates constructor, static‑factory, instance‑factory, setter, constant, and ID reference injection with detailed XML configurations and Java code examples.
This article explains how to structure Spring XML configuration files, define bean metadata, use id/name/alias for bean naming, and instantiate beans via constructors, static factory methods, or instance factories, providing detailed code examples and JUnit tests for each approach.
This article explains the concepts of Spring's IoC container and beans, guides through setting up a development environment, details the required JARs, demonstrates creating a simple Hello World application with interface and implementation, and shows how to configure and retrieve beans using XML configuration.
This article introduces the Spring framework, explaining its purpose as a lightweight Java SE/EE development platform, detailing the many features it provides such as IoC, AOP, transaction management, web integration, and outlining why developers choose Spring and how to effectively learn it.
This article explains the concepts of Single Sign‑On and Message Queues, outlines their business scenarios, core elements, and simple implementation approaches in J2EE, and provides a concrete Spring‑Redis example with configuration and listener code.
This article explains how to build a highly configurable, extensible, and maintainable embedded process flow by leveraging Spring AOP and AspectJ to create a lightweight alternative to heavyweight BPM engines, detailing the architecture, design, code examples, and a purchase‑item use case.
This comprehensive guide lists and explains over seventy common Spring framework interview questions, covering core concepts, modules, IoC, AOP, bean scopes, configuration styles, MVC, data access, transaction management, and annotation-based programming to help Java developers prepare effectively.
