2.Framework

Probabilistic membership testing with Guava BloomFilter, false positives, sizing, serialization, and appropriate use cases.

Lombok's compile-time annotation processing/compiler integration and the trade-offs of generated Java boilerplate.

MyBatis as a SQL-mapping framework: explicit SQL, parameter/result mapping, sessions, mappers, and transaction boundaries.

Spring Cloud as an integration ecosystem for distributed-service concerns, with version-train compatibility and evolving components.

A roadmap from dependency injection and bean lifecycle through AOP, transactions, MVC, Boot, and source-code reading.

Spring Boot's opinionated application bootstrap, starters, auto-configuration, embedded servers, external configuration, and observability.

Spring MVC's DispatcherServlet request pipeline, controllers, handler mapping/adapters, binding, validation, and response rendering.

Local token/rate limiting with Guava RateLimiter and its limits in distributed systems.

Mapper definitions, parameter binding, result mapping, dynamic SQL, sessions, and safe transaction usage in MyBatis.

A conceptual map of Spring Core/Beans/Context, AOP, data/transactions, web MVC/reactive, testing, and integration modules.

A learning roadmap for Boot configuration, auto-configuration, web/data integration, packaging, observability, and source analysis.

Controller mappings, request binding, validation, JSON responses, exception handling, and safe web-layer boundaries.

MyBatis execution flow from mapper proxy through mapped statement, executor, statement handler, parameter/result handling, and caching.

Source-level request flow through DispatcherServlet, HandlerMapping, HandlerAdapter, interceptors, argument/return handlers, and exception processing.

A practical roadmap for learning MyBatis from SQL mapping through caching, plugins, transactions, and source internals.

Why singleton controllers handle concurrent requests and should avoid unsynchronized mutable instance state.

A roadmap from DispatcherServlet and controllers through argument resolution, message conversion, validation, errors, and source analysis.

Building event-driven network clients and servers with Bootstrap, EventLoopGroup, Channel, Pipeline, handlers, and graceful shutdown.

Historical Netty 3 architecture and why its APIs/classes should not be projected onto modern Netty 4.x designs.

Centralized configuration, namespaces, change delivery, local caching, and operational considerations for Apollo-style config systems.

Eureka-style client registration and discovery, heartbeats, cached registries, and availability-oriented semantics.

Declarative HTTP interfaces, encoding/decoding, errors, timeouts, retries, and service-discovery integration.

Reactive API gateway routing, filters, cross-cutting policy, and the importance of non-blocking/backpressure-safe customization.

Historical Hystrix circuit breaker, timeout, fallback, and isolation concepts that remain useful even though the library is legacy.

Historical Ribbon client-side load balancing and durable instance-selection concepts.

Distributed trace/span propagation concepts and the transition from Spring Cloud Sleuth to newer observability stacks.

Netflix Zuul gateway/filter architecture and its place as historical context beside newer Spring gateway stacks.

Spring application-event publication, listener execution, transactions, asynchrony, and coupling considerations.

Singleton, prototype, request/session and other Spring bean scopes, including lifecycle and thread-safety implications.

Pointcuts, advice, proxies, aspect ordering, and the self-invocation limitation of proxy-based Spring AOP.

Dependency injection through components/configuration with constructor injection, explicit dependencies, and container-managed lifecycle.

Dependency resolution by type/qualifier/name metadata and the BeanPostProcessor infrastructure behind annotation injection.

Proxy/interceptor transaction flow from metadata lookup to transaction manager begin/commit/rollback.

Packaging reusable dependencies plus conditional auto-configuration and typed configuration properties without surprising applications.

Spring cache abstraction usage, cache annotations, cache keys, invalidation, and the limits of local or remote cache providers.

Executable Boot archive layout, launcher/class-loader concept, nested dependencies, and why exact launcher classes are version-specific.

Conditional creation of SqlSessionFactory, mapper integration, transaction participation, and application override points.

How Boot conditionally configures MVC defaults while allowing application customization and full override.

The application entry point, SpringApplication, configuration sources, profiles, lifecycle hooks, and graceful startup/shutdown.

How Spring Boot creates and customizes an embedded servlet container from dependencies, web application type, and server properties.

A practical Netty learning roadmap from event loops and pipelines through buffers, codecs, backpressure, and version-pinned source reading.

A durable mental model for Netty server bootstrap, event loops, channel registration, pipelines, and ByteBuf allocation.

Thread/semaphore bulkhead isolation, bounded queues, timeout behavior, and modern resilience interpretation.

From bean definition and instantiation through dependency injection, post-processors, initialization, proxies, use, and destruction.

Spring's proxy-based aspect-oriented programming model: join points, pointcuts, advice, aspects, and proxies.

Inversion of Control and dependency injection as moving object construction/wiring policy from business classes to a container.

注解作用 @Configuration 相当于之前的applicationContext.xml，就是一个配置文件 @ComponentScan 配置扫描包，如果有@Controller，@Service，@Repositiry，@Component修饰的，则把它加入ioc容器中 @Bean 配合@

REQUIRED, REQUIRES_NEW, NESTED and other propagation modes as policies for existing versus new transaction contexts.

How Spring Boot conditionally creates cache infrastructure from classpath, properties, beans, and provider availability.

The roles of Bootstrap, EventLoopGroup, EventLoop, Channel, Pipeline, Handler, Future, and ByteBuf.

Why Netty uses direct buffers, their I/O advantages and native-memory/reference-counting risks.

BeanFactory as Spring's dependency-container contract and its relationship with ApplicationContext.

Declarative transaction boundaries, rollback rules, proxy limitations, isolation, timeouts, and external side effects.

Constructor versus setter/field cycles, early references, proxy complications, and why redesign is usually preferable.

How to express real bean dependencies instead of relying on incidental initialization order.

Historical source view of how a NioEventLoopGroup creates and manages child event loops.

How Bootstrap/ServerBootstrap accumulate configuration before channel registration and bind/connect.

End-to-end server bind flow: create, initialize, register, bind, activate, and complete the ChannelFuture.

How readiness on a listening channel leads the event loop to accept new sockets.

How every Channel owns a pipeline of handler contexts and how initial handlers are installed.

First server-startup phase: Bootstrap configuration produces a concrete listening-channel instance.

High-level ApplicationContext refresh flow from environment/bean definitions through post-processors and singleton initialization.

Conceptual SpringApplication startup phases from environment preparation through context refresh, runners, and ready events.

How Netty associates event loops with executors/threads and why event-loop thread ownership matters.

Wrapping an accepted socket as a child Channel with pipeline/configuration and parent relationship.

Dynamic pipeline modification, handler lifecycle callbacks, event-loop serialization, and sharability constraints.

Applying parent options/attributes and installing child-channel initialization logic before registration.

How BeanFactoryPostProcessor customizes bean definitions/container metadata before ordinary bean instantiation.

Conditional configuration selection, metadata/imports, bean back-off, configuration properties, and condition diagnostics.

Creation of the event-loop child set and channel-to-event-loop selection in a NioEventLoopGroup.

Selecting a worker event loop and registering the accepted child channel for thread-confined I/O processing.

Assigning the server channel to an event loop and transport selector before binding.

Why BeanPostProcessors must be registered before ordinary singleton creation and what lifecycle extension they provide.

How an active socket channel becomes interested in read readiness and feeds inbound pipeline events.

Asynchronous local-address bind, channel activation, failure handling, and bind future completion.

How Spring resolves bean dependencies, creates singleton instances, applies lifecycle processors, and caches exposed objects.

ServerBootstrap to active listener: channel creation, initialization, event-loop registration, and bind.

A conceptual map of Spring container interfaces and extension points rather than a version-frozen UML diagram.

Historical source flow from configured channel factory to a server Channel instance before registration.

How an event-loop-owned server channel performs the transport bind and transitions toward active listening state.

Propagation of channel lifecycle and read events through inbound handlers.

Reader/writer indexes, heap/direct buffers, slicing, reference counting, and ownership rules.

How annotation-driven AOP enables an auto-proxy BeanPostProcessor, described as versioned Spring internals.

Lifecycle of Spring's AOP auto-proxy creator as an infrastructure bean and BeanPostProcessor.

End-to-end Spring AOP model from infrastructure registration and advisor discovery to proxy creation and interceptor invocation.

Applying options, attributes, and pipeline handlers to a newly created server channel.

Selector waiting, selected-key processing, queued tasks, scheduling, and fairness inside a Netty NIO event loop.

Propagation of writes, flushes, binds, connects, closes, and other outbound operations through handlers toward the transport.

Allocator abstraction for heap/direct, pooled/unpooled buffers and why allocation strategy is configurable.

Where auto-proxy creation participates in the bean lifecycle and why early references matter for some dependency graphs.

Assigning a Channel to an EventLoop, registering with selector/transport state, and firing registration events.

How handler failures become exceptionCaught events and why exceptions need explicit logging, cleanup, and connection policy.

Allocator usage, capacity, slicing, copying, reference-count handling, and leak-safe buffer ownership.

Advisor matching and creation of JDK-interface or class-based proxies around eligible Spring beans.

Conceptual Channel hierarchy across transport-independent API, abstract channel support, and concrete NIO/native transports.

Interceptor-chain execution around a proxied target method and how proceed composes advice.

Pooled ByteBuf allocation, arenas/chunks/suballocation concepts, reuse benefits, and version-sensitive allocator internals.

Per-thread pooled buffer caching as an allocation optimization, with retention and event-loop affinity trade-offs.