Java

Checked and unchecked exceptions, propagation, finally, try-with-resources, and Error versus Exception.

Practical exception-handling rules: catch at meaningful boundaries, preserve context, avoid swallowing failures, and map errors once.

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.

Comparing blocking streams, selector-based non-blocking channels, and asynchronous completion APIs without oversimplifying their OS mappings.

A thread-per-connection blocking server, its simplicity, and the need for bounded resources and modern virtual-thread context.

Java asynchronous channel APIs, completion handlers/futures, and the distinction between API-level asynchrony and OS implementation details.

Java blocking I/O semantics and when a simple blocking programming model remains appropriate.

ByteBuffer position, limit, capacity, flip/clear/compact, and heap versus direct buffers.

A selector/event-loop server architecture and the separation of I/O readiness from application work.

A completion-driven server design using asynchronous accept/read/write operations and explicit connection state.

Byte streams, character streams, buffering, decorators, and explicit charset boundaries in Java I/O.

Java NIO channel abstractions, partial reads/writes, scattering/gathering, and channel lifecycle.

Choosing text/binary serialization by schema evolution, compatibility, size, CPU, tooling, and security.

Reading and writing files with stream APIs, buffering, resource cleanup, and when NIO Files is simpler.

High-level Java filesystem operations and important caveats around atomicity, metadata, and large files.

Heartbeat design for detecting stale connections and distinguishing liveness from end-to-end health.

A blocking server architecture, thread-per-connection trade-offs, and bounded concurrency requirements.

Buffers, channels, selectors, readiness-based multiplexing, and the scope of Java NIO.

Length-prefix, delimiter, and fixed-size framing for converting a TCP byte stream into application messages.

Path composition, normalization, absolute/real paths, and filesystem-safe comparisons.

Designing a Java non-blocking server with Selector, per-connection state, partial I/O, and backpressure.

Java enum types as fixed typed instances with fields, methods, switch support, and identity semantics.

Java switch statements and expressions, fall-through, enums/strings, and modern exhaustive pattern-oriented forms.

The transient modifier in Java native serialization and why it is not a general secrecy/security mechanism.

final variables, methods, classes, final-field semantics, and what final does not make immutable.

Java's Cloneable marker interface, shallow copying, constructor bypass, and why explicit copy APIs are usually clearer.

Integer boxing/unboxing, value comparison, caching, parsing, overflow, and null-unboxing hazards.

ArrayList's resizable-array model, complexity, capacity growth, iteration, and concurrency characteristics.

Legacy Hashtable synchronization, null restrictions, and modern replacement choices.

Core Object methods: equals/hashCode, toString, class identity, monitor methods, and cloning/finalization caveats.

Heap-based priority queues, ordering semantics, complexity, and concurrency limitations.

Java native serialization, serialVersionUID, compatibility, security risks, and modern alternatives for service/data formats.

Hash-based Set semantics, equality/hashCode requirements, null handling, and concurrency characteristics.

Java String immutability, pooling, equality, concatenation, encoding boundaries, and implementation-sensitive storage.

Java LinkedList as a doubly linked List/Deque, with operation costs and cache-locality trade-offs.

Insertion/access-order HashMap with a linked iteration order and the basis of simple LRU-style maps.

Designing Java immutable objects and the concurrency benefits of stable state.

A HashSet variant with deterministic insertion-order iteration.

Legacy synchronized mutable text builder and its relationship to StringBuilder.

Safe Java List/array conversion and the mutability semantics of Arrays.asList and modern collection factories.

Choosing HashMap, LinkedHashMap, TreeMap, ConcurrentHashMap, and synchronized/legacy maps.

Synchronized Set wrappers and the need for external synchronization during compound operations and iteration.

Efficient mutable text construction, capacity, non-thread-safety, and compiler concatenation optimizations.

Choosing among ArrayList, LinkedList, CopyOnWriteArrayList, and synchronized wrappers by access pattern.

Synchronized Map wrappers, compound-operation atomicity, iteration locking, and concurrent alternatives.

Sorted/navigable set semantics, comparator ordering, and logarithmic tree operations.

String identity, content equality, ordering, null safety, and case-insensitive comparison cautions.

The synchronized List wrapper, compound operations, iteration requirements, and alternatives.

Sorted and navigable maps, key ordering, logarithmic operations, and comparator consistency.

Legacy synchronized Vector behavior and why ArrayList or specialized concurrent collections are usually preferred.

What ConcurrentModificationException means, structural modification tracking, and why fail-fast behavior is not a thread-safety guarantee.

Historical JDK 7 HashMap bucket-chain implementation and resize behavior, clearly separated from modern JDK internals.

Historical JDK 8 HashMap array/bin/tree design, resize concepts, load factor, and stable API-level lessons.

CPU caches, coherence, out-of-order execution, memory ordering, and why language memory models exist above hardware.

Java intrinsic monitors, mutual exclusion, happens-before visibility, reentrancy, synchronized methods/blocks, and JVM implementation caveats.

Java volatile visibility and ordering semantics, acquire/release-style happens-before behavior, atomic single reads/writes, and why volatile is not a lock.

Atomic compare-and-set as a read-modify-write primitive, retry loops, contention, ABA, and when lock-free does not mean contention-free.

AQS as the state-and-wait-queue framework behind many JUC synchronizers, with exclusive/shared acquisition, parking, cancellation, and template methods.

Explicit reentrant mutual exclusion with interruptible/timed acquisition, optional fairness, Conditions, and try/finally release.

Condition variables with await/signal, predicate loops, lock association, spurious wakeups, and the relationship to Object.wait/notify.

A reusable barrier that releases a group when all parties arrive, with barrier actions, broken-barrier behavior, and comparison with CountDownLatch.

A one-shot shared countdown synchronizer for waiting until N events complete, with AQS shared-mode semantics.

How CopyOnWriteArrayList provides lock-free reads by publishing immutable array snapshots, and when its write cost makes it unsuitable.

CopyOnWriteArraySet semantics, implementation relationship with CopyOnWriteArrayList, snapshot iteration, and read-heavy use cases.

A fixed-capacity array-backed blocking queue with explicit backpressure, FIFO element order, and optional fairness.

Per-thread context storage, ThreadLocalMap lifetime, weak keys, stale values, thread-pool leaks, remove(), and modern context-propagation considerations.

Java thread-pool execution policy, core/max workers, work queues, rejection, shutdown, sizing, bounded backpressure, and modern virtual-thread context.

Composable asynchronous computation with CompletableFuture: stage chaining, error handling, executors, blocking hazards, and cancellation semantics.

Historical JDK 7 ConcurrentHashMap design: segmented locking, read concurrency, and why these internals should not be generalized to modern JDKs.

Java ForkJoinPool, recursive task decomposition, work stealing, common-pool behavior, and the limits of fork/join for blocking work.

How Java Exchanger pairs two threads at a rendezvous point and atomically swaps one value from each participant.

A reentrant read/write lock with shared readers, exclusive writers, optional fairness, lock downgrading, and workload trade-offs.

Permit-based concurrency control with acquire/release, bounded resource access, optional fairness, and the distinction from rate limiting.

User-level versus kernel-level threads, the traditional Java platform-thread mapping, and how virtual threads change the model.

Why sun.misc.Unsafe exists, what low-level operations it exposes, and why supported Java APIs should usually be preferred.

Java's memory model, data races, happens-before, synchronization order, volatile, monitors, thread start/join, final fields, and sequential consistency for correctly synchronized programs.

Durable lock-performance principles: reduce contention and critical sections, avoid blocking work while locked, split ownership carefully, and treat JVM lock internals as version-sensitive.

A teaching implementation of a synchronizer using atomic state, a FIFO wait queue, park/unpark, and release wakeups, emphasizing invariants rather than copying JDK internals.

How fair ReentrantLock reduces barging by honoring queued predecessors, and the throughput/latency trade-off of fairness.

Producer-consumer queues with bounded capacity, blocking/timed operations, backpressure, and the semantics of major Java BlockingQueue implementations.

Convenience ExecutorService factories, their hidden queue/thread choices, and why explicit executor configuration or virtual-thread executors are often clearer.

Historical JDK 8 ConcurrentHashMap design: CAS insertion, bin synchronization, tree bins, cooperative resizing, and stable public semantics.

Producer-consumer coordination with BlockingQueue, wait/notify, and Condition, including bounded capacity and correct wait-loop semantics.

Default read/write-lock acquisition, reader/writer barging policy, writer-starvation avoidance heuristics, and throughput trade-offs.

Default semaphore barging behavior, shared AQS permit state, and why nonfair acquisition often improves throughput.

Thread.sleep timing semantics and the important difference between sleeping and waiting on an object monitor.

Default ReentrantLock barging behavior, why it can improve throughput, and how AQS queues still handle contended waiters.

A linked-node blocking queue with optional capacity, separate producer/consumer coordination, and the risk of its very large default bound.

ThreadPoolExecutor overload policies as backpressure: abort, caller-runs, discard, discard-oldest, and custom rejection semantics.

A minimal Java deadlock caused by inconsistent lock ordering, plus detection and prevention techniques.

Fair read/write-lock scheduling, queued predecessors, reader grouping, writer progress, and fairness costs.

AQS shared acquisition with predecessor-aware fairness and the throughput trade-off of ordered permit allocation.

The six Thread.State values, what each means, and why Java thread state is not identical to an operating-system scheduler state.

An unbounded priority heap for concurrent producers/consumers, with ordering, capacity, and starvation caveats.

A zero-capacity rendezvous queue that directly hands an element from producer to consumer, with fair/nonfair transfer modes and thread-pool implications.

AtomicInteger/Long/Reference, CAS-based read-modify-write, accumulators/adders, atomic references, memory semantics, and contention trade-offs.

A concise roadmap for studying JVM memory, class loading, JIT compilation, garbage collection, and production diagnostics.

A production Java incident workflow covering CPU, latency, threads, heap, GC, native memory, I/O, and evidence preservation.

Reachability-based reclamation, GC roots, object liveness, and why garbage collection manages memory rather than arbitrary external resources.

Loading, linking, initialization, use, unloading, and class-loader identity in the JVM.

Heap, stacks, method-area metadata, program counters, native stacks, and the difference between JVM specification concepts and HotSpot implementation details.

A hypothesis-driven performance tuning workflow from SLO and bottleneck identification through measurement, change, and regression validation.

Mark-sweep, copying, compaction, generational collection, and the throughput/latency/space trade-offs behind modern JVM collectors.

Static initialization, superclass initialization, instance field initializers, initializer blocks, and constructors in Java.

How HotSpot commonly allocates objects, including TLABs, young-generation allocation, large objects, promotion, and why exact rules depend on the collector.

A durable overview of Serial, Parallel, G1, ZGC, Shenandoah-style collector goals without treating historical defaults as permanent facts.

How custom class loaders define classes, delegation, namespace isolation, and the operational risks of loader leaks.

JIT escape analysis, scalar replacement, lock elimination, and why stack allocation should not be treated as a guaranteed Java object-allocation rule.

Collector-selection principles and JVM flags, with emphasis on verifying support against the deployed JDK instead of copying obsolete flag recipes.

From bytecode allocation through class readiness, heap allocation, zero initialization, object headers, and Java constructor execution.

An overview of JVM garbage collection: reachability, generations, collection cycles, pauses, concurrent work, and the metrics that matter operationally.

Conceptual object layout in HotSpot: headers, instance fields, alignment, compressed references, and why byte offsets are implementation-specific.

Strong, soft, weak, phantom, and reachability-related references, with practical cautions about caches and cleanup.

Direct-pointer and handle-based object-reference models, and why Java code should not depend on a particular physical object-address representation.

How to distinguish heap retention, allocation pressure, Metaspace, direct/native memory, and thread-related out-of-memory failures.

A practical guide to JFR, jcmd, thread dumps, heap dumps, profilers, GC logs, and OS/container metrics.

A measurement-first approach to JVM memory and GC parameters, avoiding obsolete one-size-fits-all tuning recipes.

What to extract from GC logs: pause distribution, allocation pressure, live-set behavior, promotion, full collections, and concurrent-cycle health.

Encapsulation, abstraction, inheritance, composition, and polymorphism with practical Java design guidance.

Runtime type inspection and invocation with Java reflection, including access, performance, modules, and framework use cases.

Java TCP socket basics: connect/accept, stream semantics, timeouts, shutdown, framing, and production resource controls.

Servlet request/response lifecycle, container concurrency, filters/listeners, and the Jakarta namespace evolution.

Capacity-oriented Tomcat tuning: connector limits, threads, queues, timeouts, keep-alive, JVM resources, and downstream bottlenecks.

Tomcat deployment basics, connectors, applications, logs, configuration, and modern operational cautions.

The Tomcat connector boundary between network/protocol handling and the servlet container request pipeline.

Conceptual Tomcat startup: bootstrap, server/service/connectors, containers, lifecycle events, and application deployment.

From connector protocol handling through container mapping/pipeline to servlet invocation, described without freezing one Tomcat version's stack.

A version-aware workflow for checking out, building, testing, and debugging Tomcat source.

Engine, Host, Context, Wrapper, request routing, and the hierarchical Tomcat container model.

How connector, virtual-host, context, and servlet mapping configuration determines a request's destination.

Tomcat component lifecycle initialization, start, stop, destroy, and lifecycle events.

Tomcat's service, connector, container hierarchy, lifecycle, and request-processing architecture.

Type parameters, bounds, wildcards, PECS, type erasure, and the limits of Java's generic type system.

Lambdas, functional interfaces, streams, Optional, default methods, java.time, and CompletableFuture introduced around Java 8.

Natural ordering, external comparators, comparator contracts, and consistency with equality.