Ethan Tsui's Technical Blog

Spring is a lightweight Java development framework designed to improve developer efficiency and system maintainability. Its core strengths include:

• IoC and DI: Uses a central container to manage object creation and dependencies, achieving high cohesion and low coupling.
• AOP (Aspect-Oriented Programming): Allows implementation of cross-cutting concerns like permission interception and monitoring.
• Declarative Transaction Management: Manages transactions via configuration rather than hard-coded JDBC logic.
• Integration: Provides direct support for frameworks like Struts, Hibernate, MyBatis, and Quartz.
• API Template Encapsulation: Simplifies complex JavaEE APIs (JDBC, JavaMail, etc.) through template classes.

Executing a SQL query in MySQL involves the following sequence of components and stages:

1. Connector: Establishes the connection, manages it, and authenticates the user.
2. Query Cache: (Removed in MySQL 8.0) Checks if the query result is cached and returns it immediately if found.
3. SQL Parser: Performs lexical and syntactic analysis to build a syntax tree for identifying tables, fields, and statement types.
4. SQL Executor: Consists of three phases:
   • Preprocessing: Validates the existence of tables/fields and expands SELECT * into all specific columns.
   • Optimization: Selects the execution plan with the lowest estimated cost.
   • Execution: Executes the chosen plan by retrieving records from the storage engine and returning them to the client.

MySQL architecture is divided into two primary layers:

1. Server Layer: Responsible for establishing connections, analyzing, and executing SQL. It contains core modules including the Connector, Query Cache, Parser, Preprocessor, Optimizer, and Executor. All built-in functions (date, time, math, encryption) and cross-engine features (stored procedures, triggers, views) are implemented here.
2. Storage Engine Layer: Responsible for data storage and retrieval. It supports multiple engines like InnoDB, MyISAM, and Memory. Index data structures are implemented at this layer (e.g., InnoDB uses B+ trees by default for primary and secondary indexes).

The Java Heap (or GC Heap) is the primary area managed by garbage collectors. It is divided into three main regions to allow for different collection algorithms based on the characteristics of the objects stored there:

1. Young Generation: Further subdivided into the Eden space and two Survivor spaces (S0 and S1).
2. Old Generation: Stores long-lived objects that have survived multiple Minor GC cycles.
3. Metaspace: Stores class metadata (replacing the Permanent Generation in Java 8+).

Executing a SQL query in MySQL involves the following sequential stages:

1. Connector (连接器): Establishes the connection, manages it, and authenticates the user.
2. Query Cache (查询缓存): Returns results immediately if the exact query is cached. Note: This module was removed in MySQL 8.0.
3. SQL Parser (解析器): Performs lexical and syntactic analysis to build a syntax tree, identifying table names, fields, and statement types.
4. Execution (执行 SQL), which consists of three phases:
   • Preprocessing (预处理): Validates the existence of tables and fields, and expands SELECT * into all specific columns.
   • Optimization (优化): Selects the execution plan with the lowest estimated cost.
   • Execution (执行): Executes the chosen plan, retrieves records from the storage engine, and returns them to the client.

Spring is a lightweight Java framework designed to improve development efficiency and maintainability. Its core capabilities include:

• Inversion of Control (IoC) and Dependency Injection (DI): Manages object creation and lifecycles via a container to achieve low coupling.
• Aspect-Oriented Programming (AOP): Enables cross-cutting concerns like permission interception and monitoring.
• Declarative Transaction Management: Manages transactions via configuration rather than manual JDBC commit/rollback code.

The JVM architecture consists of the Class Loading Subsystem, the Runtime Data Area (Memory Structure), and the Bytecode Execution Engine.

Runtime Data Area Components:

• Method Area (Metaspace): Contains the runtime constant pool, type information, field/method data, and references to ClassLoaders and Class instances.
• Heap: The primary area for object allocation and garbage collection.
• Stack: Stores local variables and method call frames.
• Native Method Stack: Used for native method execution.
• Program Counter (PC) Register: Tracks the current instruction being executed.

These three entities represent different levels of the ecosystem:

1. Spring: The base lightweight framework providing core IoC and AOP support.
2. SpringMVC: A specific module of the Spring framework based on the Model-View-Controller design pattern, used for building Web applications and RESTful services.
3. SpringBoot: A framework built on top of Spring that enables rapid creation of production-ready applications through 'auto-configuration' and 'convention over configuration', integrating common third-party libraries (e.g., Spring Data, Spring Security).