Understanding Structured Thinking: Concepts, Benefits, and Practical Methods

Introduction

The author reflects on participating in a technical book discussion group and discovering the need for a more comprehensive, structured approach to answering architecture‑related questions. After studying the concept of structured thinking and the Pyramid Principle, the article aims to share a personal understanding of structured thinking through both technical and non‑technical examples.

What Is Structured Thinking?

Structured thinking is defined as a mental process that organizes information from disorder to order based on the inherent logic of a subject. It is a way to combat entropy by making information orderly, systematic, and easier to remember and understand.

Why Master Structured Thinking?

From the Input Perspective

Accelerates learning and knowledge acquisition.

Enables more comprehensive problem analysis and easier identification of core issues.

From the Output Perspective

Improves clarity in communication, making reports, articles, and code easier to understand.

Helps produce well‑structured documents and solutions.

How to Apply Structured Thinking

Adopt Multiple Angles

Consider time, space, logic, causality, importance, etc., when analyzing a problem. Examples include using the PDCA cycle for iterative improvement, breaking complex processes into stages, and visualizing system components.

Zoom In / Zoom Out

Switch between macro and micro perspectives to gain a fuller view of an issue. The article cites the C4 model for software architecture as an illustration of zooming across system, container, component, and class levels.

5W2H or 2W1H

Use the 5W2H framework (What, Why, When, Where, Who, How, How Much) or its simplified 2W1H version (What, Why, How) to structure analysis and communication.

MECE Principle

Ensure categories are Mutually Exclusive and Collectively Exhaustive. The article shows examples of both compliant and non‑compliant classifications and relates the principle to software design (e.g., single‑responsibility and orthogonal methods).

Code Example: Spring Application Context Refresh

The following code demonstrates a well‑structured lifecycle method in Spring, illustrating how ordered steps improve readability and maintainability.

org.springframework.context.support.AbstractApplicationContext#refresh
@Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // Prepare this context for refreshing.
        //1 初始化前的准备
        prepareRefresh();
        // Tell the subclass to refresh the internal bean factory.
        //2 获取 BeanFactory，加载所有 bean 的定义信息（未实例化）
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
        // Prepare the bean factory for use in this context.
        // 3 BeanFactory 的预处理配置
        prepareBeanFactory(beanFactory);
        try {
            // Allows post-processing of the bean factory in context subclasses.
            // 4. 准备 BeanFactory 完成后进行的后置处理
            postProcessBeanFactory(beanFactory);
            // Invoke factory processors registered as beans in the context.
            // 5. 执行 BeanFactory 创建后的后置处理器
            invokeBeanFactoryPostProcessors(beanFactory);
            // Register bean processors that intercept bean creation.
            // 6. 注册 Bean 的后置处理器
            registerBeanPostProcessors(beanFactory);
            // Initialize message source for this context.
            // 7. 初始化MessageSource
            initMessageSource();
            // Initialize event multicaster for this context.
            // 8. 初始化事件派发器
            initApplicationEventMulticaster();
            // Initialize other special beans in specific context subclasses.
            // 9. 子类的多态 onRefresh
            onRefresh();
            // Check for listener beans and register them.
            // 10. 监听器检查和注册
            registerListeners();
            // ------- BeanFactory已创建完成 --------
            // Instantiate all remaining (non-lazy-init) singletons.
            // 11. 初始化所有剩下的单例Bean（非懒加载的）
            finishBeanFactoryInitialization(beanFactory);
            // Last step: publish corresponding event.
            // 12. 完成容器的创建工作（发布相应的事件)
            finishRefresh();
        } catch (BeansException ex) {
            if (logger.isWarnEnabled()) {
                logger.warn("Exception encountered during context initialization - " + "cancelling refresh attempt: " + ex);
            }
            // Destroy already created singletons to avoid dangling resources.
            // 销毁已经创建的单例避免浪费资源
            destroyBeans();
            // Reset 'active' flag.
            // 重置  active 标记
            cancelRefresh(ex);
            // Propagate exception to caller.
            // 异常抛给调用方
            throw ex;
        } finally {
            // Reset common introspection caches in Spring's core, since we
            // might not ever need metadata for singleton beans anymore...
            //13 清理缓存
            resetCommonCaches();
        }
    }
}

Conclusion

The article summarizes structured thinking as a method to organize content, making it more orderly, memorable, and easier to understand. It encourages readers to apply structured thinking in PPTs, reports, articles, code, and everyday communication for qualitative improvement.