一、Java基础相关

（一）Java基本概念

1. Java的性质与应用领域
   • Java是一种通用的高级编程语言，其核心概念涵盖了面向对象编程（OOPS）的基本概念，包括抽象化、多态性、继承、封装等。Java常用于开发桌面应用程序和服务器环境（开发独立应用程序），是世界上使用最广泛的编程语言之一。
2. JDK与JVM的区别
   • JDK（Java开发工具包）是一个开发目的的工具包，它还包括执行环境。而JVM（Java虚拟机）纯粹是运行时环境，无法使用JVM编译源文件。
3. Java中的访问修饰符
   • 在Java中，访问说明符用于定义访问范围，包括public（类、方法、字段可从任何地方访问）、Protected（方法、字段可以从它们所属的同一类或子类以及同一包的类中访问，但不能从外部访问）、default（Method,Field,class只能从同一程序包访问，而不能从其本机程序包外部访问）、private（方法、字段可以从它们所属的相同类中访问）。

（二）面向对象编程（OOPS）

1. OOPS基本概念
   • 抽象化：隐藏实现细节，只展示必要的功能。
   • 多态性：能够在不同上下文中为某事物赋予不同含义或用法，如“一个接口，许多实现”，具体表现为方法重载（overloading）和方法重写（overriding）。
   • 继承：子类从父类获取属性和方法。
   • 封装：将属性和方法组合在一个单元中，实现数据隐藏，帮助程序员遵循模块化开发，每个对象有独立的方法和变量，功能独立于其他对象。
2. 多态性的具体体现与示例
   • 方法重载：在同一个类中，定义多个同名方法，但参数列表不同，根据不同输入参数调用不同实现，增加代码灵活性和可读性，例如：

1
2
3
4
5
6
7
8

class Overload {
    public void display(char c) {
        System.out.println(c);
    }
    public void display(char c, int num) {
        System.out.println(c + " " + num);
    }
}

• 方法重写：发生在子类和父类之间，子类重写父类方法以实现更具体行为，运行时根据对象实际类型决定调用的方法实现，例如：

1
2
3
4
5
6
7
8
9
10
11

class Animal {
    public void makeSound() {
        System.out.println("My sound varies based on my type");
    }
}
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("I bark");
    }
}

3. 内部类与子类的区别
   • 内部类是嵌套在另一个类中的类，具有对其嵌套类的访问权限，可访问外部类中定义的所有变量和方法。
   • 子类是从另一个称为超类的类继承的类，可访问其父类的所有公共和受保护的方法以及字段。

（三）数据类型与变量

1. 基本数据类型与包装类
   • Java的基本数据类型包括字节（byte）、短整型（short）、字符型（char）、整型（int）、长整型（long）、浮点型（float）、双精度型（double）、布尔型（boolean）。包装类则用于将原始数据类型包装为对象，以便在面向对象环境中使用，如Integer、Double等，提供了数据类型转换的多态API和实用程序方法，如hashCode()和equals()。
2. 数据封装的意义与实现方式
   • 封装可帮助程序员遵循模块化方法进行软件开发，每个对象有自己的方法和变量，功能独立，还用于数据隐藏。实现方式包括将类声明为final，使其不可被继承；将类的所有成员声明为私有；不提供修改状态的API或公共方法，若有则应创建副本进行修改并返回；若成员可变，应声明为final；通过构造函数初始化对象，对可变对象参数进行深层克隆；不公开可变成员引用，如需公开应正确克隆并返回。
3. 字符串相关
   • 字符串在Java中是不可变的，即创建后不可更改。字符串实例是具有两个字段（char[] value和int hash field）的对象，value表示字符串字符数组，hash用于存储字符串的hashCode，初始化为零，每次调用hashCode()时若为零则重新计算。字符串广泛用于共享参数、加载类、返回值等场景，因其不可变性，在多线程环境中自动变为线程安全，适用于HashMap或HashTable的键，且可从字符串池中获取字符串文字，提高性能。

（四）Java类特性

1. 类的继承与限制
   • 一个类可以继承另一个类，使用关键字extends。但Java不支持多重继承，一个类只能扩展一个类，以避免访问继承成员时产生歧义。可以使用关键字final对类限制继承，创建不可变类。
2. 抽象类与接口的区别与使用场景
   • 抽象类可以包含有或没有具体实现的成员，使用abstract关键字声明，子类继承抽象类可选择实现其抽象方法。接口只能拥有没有具体实现的公共静态方法的声明，使用interface声明，实现接口的类必须实现接口的所有方法。当父类和子类存在直接IS - A关系时，优先使用抽象类；当需要公开公共API，且类在不同上下文中行为不同时，适合使用接口。
3. 静态成员与实例成员的区别
   • 静态成员不依赖于类的任何实例，绑定到类型，使用类型名称访问，在类的所有对象间共享，可从任何对象访问，但不能从静态方法访问非静态成员，静态方法不能被覆盖，静态字段通过静态块初始化。实例成员与对象实例相关，每个对象都有自己的实例成员副本。
4. final关键字的用途
   • 用于声明常量，值只能分配一次，分配后不能更改。也可用于声明方法，使其不能被子类覆盖；声明类，使其不能被继承，如String、Integer等包装器类。

（五）Java中的操作符与表达式

1. 运算符分类与示例
   • 算术运算符（+、-、*、/、%、++、–）用于算术计算。
   • 关系运算符（==、!=、>、<、<=、>=）用于关系比较。
   • 按位运算符（&、|、^、~）用于逐位操作。
   • 逻辑运算符（&&、||、!）用于逻辑比较。
   • 赋值运算符（=、+=、-=、*=、/=）用于为变量分配值。
2. 三元运算符的使用
   • 三元运算符（? :）根据布尔值评估决定将哪个值分配给变量，例如：

1

status = (rank == 1)? "Done" : "Pending";

（六）Java中的循环与控制结构

1. 循环类型与特点
   • for循环：用于重复执行给定次数的语句，当知道执行次数时使用，例如：

1
2
3

for (int i = 0; i < 10; i++) {
    System.out.println(i);
}

• while循环：当某些语句需重复执行直到满足条件时使用，在执行语句前检查条件，例如：

1
2
3
4
5

int i = 0;
while (i < 10) {
    System.out.println(i);
    i++;
}

• do - while循环：与while循环类似，但执行语句块后检查条件，语句至少执行一次，例如：

1
2
3
4
5

int i = 0;
do {
    System.out.println(i);
    i++;
} while (i < 10);

2. break与continue语句的区别
   • break关键字用于立即中断循环，跳出循环体。
   • continue关键字用于中断当前迭代，跳过当前迭代剩余语句，继续下一次迭代。

（七）Java中的数组与集合

1. 数组的定义与使用
   • 数组是一种存储固定大小的同类型元素的容器，通过下标访问元素，例如：

1
2

int[] arr = new int[5];
arr[0] = 1;

2. 集合框架概述
   • Java的Collections API提供了存储和操作一组对象的架构，包括List、Queue、Set等接口及其实现类，如ArrayList、LinkedList、HashSet等。集合可用于执行搜索、排序、删除、插入等操作，不同集合具有不同特性，如有些不允许重复元素，有些使用链表或数组存储元素，有些使用哈希表或树来存储元素。
3. ArrayList与LinkedList的区别
   • ArrayList在内部使用数组存储元素，添加（无需扩展时）和获取元素时间复杂度为常数，但删除元素时需移动元素，时间复杂度为线性。LinkedList内部维护链接节点存储元素，添加和删除元素较快，但检索元素时间复杂度为线性。
4. HashTable与HashMap的区别
   • HashTable和HashMap都存储键 - 值对，且查找操作时间复杂度为常数。但HashTable是同步的，适合多线程环境共享修改，不允许Null键或值；HashMap不同步，性能更好，适合单线程环境或多线程环境中不共享修改，允许Null键和多个Null值。

（八）Java中的异常处理

1. 异常处理机制概述
   • 异常处理是处理计算过程中异常发生的过程，通过try - catch - finally块实现。try块中放置可能抛出异常的代码，catch块捕获并处理特定类型异常，finally块无论是否发生异常都会执行，用于释放资源等操作。
2. 自定义异常的创建与使用
   • 自定义异常需继承Throwable类或其子类（Exception或RuntimeException），使用extend关键字。例如创建一个检查数字是否能被3整除的自定义异常：

1
2
3
4
5

class CustomException extends Exception {
    CustomException(String errormsg) {
        super(errormsg);
    }
}

3. 异常处理的最佳实践
   • 将清理代码放在finally块中，确保资源正确关闭。
   • 避免在catch子句中使用Throwable，以免捕获无法处理的异常。
   • 使用描述性消息提供异常信息，帮助理解问题。
   • 记录指定的异常，为调用者提供更多信息。
   • 不要忽略异常，防止未来代码变更导致问题。
   • 首先捕获最具体的异常，提供更精确的异常处理。
   • 使用更具体的异常，使API更易于理解。
   • 不要记录并重新抛出异常，如需提供更多信息应捕获并包装在定制异常中。

（九）Java中的线程

1. 线程的概念与用途
   • 线程有助于在程序中实现并行性，可同时执行多个操作，减少响应时间，例如将问题分解为多个线程处理；多个任务可并行运行，如事件处理或绘制；可同时为多个客户提供服务；充分利用CPU优势，尤其在多核CPU情况下。
2. 线程的创建与启动方式
   • 继承Thread类并重写run()方法，然后创建该类实例并调用start()方法启动线程。
   • 实现Runnable接口，实现run()方法，将该实现类实例作为参数传递给Thread类构造函数创建线程并启动。
3. 线程的生命周期与状态转换
   • 线程生命周期包含5个状态：New（创建线程类实例但未调用start()方法）、Runnable（调用start()方法但线程调度程序未选择执行）、Running（线程调度程序选择线程且当前正在运行）、Blocked（线程不符合运行条件但仍活动）、Terminated（线程的run()方法退出）。
4. 线程同步与通信机制
   • 线程同步用于管理对共享资源的访问，可通过synchronized关键字实现互斥访问，确保同一时刻只有一个线程访问共享资源。线程间通信可使用wait()、notify()和notifyAll()方法，wait()使线程释放锁并等待，notify()唤醒一个等待线程
   • notifyAll()唤醒所有等待线程，以协调它们对共享资源的操作。例如，多个线程操作同一队列时，可利用这些机制保证数据一致性与操作顺序。

二、Java内存相关

（一）Java内存模型概述

Java内存模型（JMM）定义了Java程序中各种变量的访问规则，规范了多线程环境下变量如何在主内存与工作内存间交互，主内存存储所有实例变量、静态变量等共享数据，工作内存是每个线程私有的缓存区，存放从主内存拷贝来的变量副本，线程对变量操作在工作内存完成后再同步回主内存，确保数据一致性与可见性。

（二）内存区域划分

1. 堆内存（Heap）
   • 堆是Java虚拟机管理的最大内存区域，用于存放对象实例，被所有线程共享，在Java程序启动时创建，垃圾回收机制主要针对堆内存进行对象回收，可细分为新生代（Young Generation）与老生代（Old Generation），新生代又分伊甸园区（Eden Space）和两个 Survivor区，对象创建时先在伊甸园区，经垃圾回收后部分存活对象转移到Survivor区或老生代继续存活。
2. 栈内存（Stack）
   • 栈内存为每个线程私有，生命周期与线程同步，存放局部变量、方法调用信息（如方法返回地址、参数、局部变量表等），栈帧是栈的基本单元，每当调用一个方法就创建一个栈帧压入栈顶，方法结束时栈帧弹出，遵循“后进先出”原则，栈内存大小在编译期或启动时确定，若栈空间不足会抛出StackOverflowError异常。
3. 方法区（Method Area）
   • 方法区也是被所有线程共享，存储已被虚拟机加载的类信息（如类的全限定名、父类、接口等）、常量、静态变量、即时编译器编译后的代码等，在Java 8之前是堆的一部分，Java 8起使用元空间（Metaspace）替代，元空间直接使用本地内存，避免了永久代（之前方法区实现形式）内存溢出问题。
4. 程序计数器（Program Counter Register）
   • 程序计数器是每个线程私有的极小内存空间，记录当前线程执行的字节码指令地址，分支、循环、跳转、异常处理等操作依赖它来确定下一条指令，若线程正在执行Java方法，计数器记录虚拟机字节码指令地址；若执行本地方法，计数器值为空（Undefined），此区域是唯一不会出现内存溢出情况的区域。

（三）对象的创建、存储与回收

1. 对象创建过程
   • 当代码中执行new关键字创建对象时，首先会去检查常量池是否有对应的类符号引用并加载类（若未加载），接着为对象分配内存空间（在堆内存中，依据内存是否规整采用指针碰撞或空闲列表方式分配），然后对分配的内存初始化为零值（保证对象实例字段有默认初始值），再设置对象头（存储对象分代年龄、哈希码等信息），最后执行对象的构造函数进行初始化，此时对象才算真正可用。
2. 对象在内存中的存储布局
   • 对象在堆内存中的存储分为对象头、实例数据和对齐填充部分。对象头包含两部分信息，一部分用于存储对象自身运行时数据（如哈希码、分代年龄、锁状态标志等），另一部分是类型指针，指向对象所属类的元数据（在方法区存储的类信息）；实例数据存放对象的各个实例变量内容；对齐填充是为了保证对象大小是8字节的整数倍，起到补齐作用。
3. 垃圾回收机制（GC）
   • 垃圾回收主要针对堆内存中不再被引用的对象进行回收释放空间，以维持堆内存的可用容量。常见的垃圾回收算法有标记 - 清除算法（先标记出所有需回收对象，再统一清除，会产生内存碎片）、复制算法（将内存划分为两块，只用一块，回收时把存活对象复制到另一块，简单高效但浪费空间，适用于新生代）、标记 - 整理算法（标记需回收对象后，将存活对象向一端移动，再清理边界外内存，避免碎片，常用于老生代）。垃圾回收器有Serial、ParNew、Parallel Scavenge（新生代回收器）以及CMS、G1等（老生代回收器或整堆回收器），不同回收器适用场景各异，依据应用程序特点（如响应时间要求、吞吐量等）选择。

（四）内存泄漏与内存溢出

1. 内存泄漏概念与成因
   • 内存泄漏指程序中已动态分配的堆内存由于某种原因（如对象生命周期管理不当、资源未正确释放等）无法被垃圾回收机制回收，导致可用内存随时间减少。常见原因包括长生命周期对象持有短生命周期对象引用（如静态集合存储临时对象引用）、未关闭资源（数据库连接、文件流等）、内部类持有外部类引用不当等，长期积累会使内存耗尽，影响程序性能甚至导致崩溃。
2. 内存溢出概念与常见情形
   • 内存溢出（Out Of Memory，简称OOM）即程序申请内存时，没有足够内存供其使用，抛出OOM异常。例如堆内存中创建大量对象且存活对象远超堆容量，老生代内存空间被填满无法容纳更多存活对象（Java堆内存溢出）；方法区存放过多类信息、常量等导致元空间不足（方法区内存溢出，常见于加载大量类库、动态生成类的场景）；栈内存中方法调用层级过深，栈帧不断堆积超出栈空间限制（栈内存溢出）。

（五）内存优化策略

1. 优化对象创建与生命周期管理
   • 尽量减少不必要的对象创建，复用已有对象（如使用对象池技术，对于频繁创建销毁且创建成本高的对象集中管理复用）；合理设置对象的生命周期，避免长生命周期对象不合理地“强留”短生命周期对象，及时清理不再使用的引用，降低内存占用压力。
2. 合理配置内存参数
   • 根据应用程序运行特性（如数据处理量、并发程度等）调整Java虚拟机启动参数，如设置堆内存初始大小（-Xms）与最大大小（-Xmx），调整新生代与老生代比例（-XX:NewRatio），优化Survivor区大小（-XX:SurvivorRatio）等，使内存分配契合程序实际需求，提高内存使用效率，避免频繁GC或内存不足。
3. 代码层面的内存敏感优化
   • 在编写代码时，避免使用大对象（如数组、集合等尽量按需分配合理容量）；及时关闭不再使用的资源（在finally块确保文件流、数据库连接等关闭）；优化数据结构选择，不同数据结构在内存占用、操作效率上有别，依据业务场景挑出最适配的（如查询频繁优先考虑基于哈希的数据结构，顺序遍历多则选链表类结构），从细节处把控内存消耗。

三、Spring相关

（一）Spring框架概述

1. Spring的核心价值与定位
   • Spring是一个开源的Java企业级应用开发框架，旨在简化企业级Java开发复杂性，提供依赖注入（DI）、面向切面编程（AOP）等核心功能，使开发者能专注于业务逻辑编写，增强代码的可维护性、可扩展性与可测试性，能方便整合多种技术（如数据库访问、Web开发、消息队列等）构建功能完备的企业级应用。
2. Spring的模块组成与功能简介
   • Spring核心容器（Core Container）包含Bean工厂（Bean Factory）与应用上下文（ApplicationContext），负责对象创建、配置与管理，是整个框架基石；数据访问与集成模块（Data Access/Integration）涵盖对JDBC、ORM（如Hibernate、MyBatis）框架支持，方便数据库操作；Web模块适配Web开发，支持Servlet、Spring MVC等构建Web应用；AOP模块实现横切面编程，处理诸如日志记录、事务管理等跨越多个业务组件的通用功能；还有消息模块（Messaging）助力整合消息队列，用于异步通信场景等诸多子模块协同运作。

（二）依赖注入（DI）

1. 依赖注入的概念与原理
   • 依赖注入是Spring的核心机制之一，打破传统的对象主动获取依赖对象方式（如通过new关键字在类内部实例化），改为由外部容器（Spring的IOC容器）负责创建、配置并注入依赖对象到目标对象中。原理基于控制反转（IOC）思想，将对象控制权从对象自身转移到容器，容器依据配置（XML、Java注解等形式）解析对象间依赖关系，在对象生命周期合适节点注入所需依赖，实现松耦合设计，提升组件复用与替换灵活性。
2. 依赖注入的实现方式（构造函数注入、Setter注入等）
   • 构造函数注入：通过目标对象的构造函数参数传递依赖对象，优点是对象创建时依赖完整，保证对象一致性，示例如下：

1
2
3
4
5
6

public class UserService {
    private UserRepository userRepository;
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

• Setter注入：利用对象的Setter方法注入依赖对象，灵活性高，可在对象创建后按需注入，示例：

1
2
3
4
5
6

public class ProductService {
    private ProductRepository productRepository;
    public void setProductRepository(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }
}

• 字段注入（虽便捷但不推荐用于正式项目）：直接在类的成员字段上使用注解注入依赖，如：

1
2
3
4

public class OrderService {
    @Autowired
    private OrderRepository orderRepository;
}

3. 依赖注入的优势与应用场景
   • 优势在于降低组件间耦合度，方便单元测试（可轻松模拟依赖对象），利于代码维护与扩展（替换依赖组件简单）。应用场景广泛，只要存在组件间依赖关系构建（如Web层依赖业务层、业务层依赖数据层组件等），尤其在大型项目分层架构中，各层组件交互频繁，依赖注入确保关联组件按需准确装配。

（三）面向切面编程（AOP）

1. AOP的概念与作用
   • AOP是一种编程范式，旨在分离系统中的横切面关注点（如日志记录、事务管理、权限验证等，这些功能贯穿多个业务模块）与核心业务逻辑，将横切面功能模块化、独立化，通过动态织入方式在合适时机（如方法调用前、调用后、抛出异常时）作用于业务方法，避免横切面代码在业务模块中重复编写，使业务代码更专注本质功能，同时增强系统可维护性与可扩展性。
2. AOP的术语与核心元素（切面、切点、通知等）
   • 切面（Aspect）：是横切面功能的封装体，整合切点与通知，如同一个独立模块包含对哪些业务方法（切点）做什么操作（通知）；切点（Pointcut）：定义在哪些连接点（Join Point，业务方法执行、属性访问等程序执行点）应用切面功能，可用表达式精确筛选；通知（Advice）：是切面在切点处执行的具体动作，分为前置通知（方法执行前）、后置通知（方法正常执行后）、异常通知（方法抛出异常后）、环绕通知（可灵活控制方法执行前后操作）等类型。
3. AOP的实现方式与示例场景
   • Spring AOP主要基于代理机制实现，对于接口代理使用JDK动态代理，对于类（无接口情况）使用CGLIB代理。例如在一个电商系统中，对所有订单业务方法添加日志记录，可定义日志切面，切点设为订单业务类中所有public方法，通知类型选前置通知与后置通知，前置记录方法开始执行信息（如方法名、参数），后置记录执行结果或耗时等，实现业务与日志记录解耦。

（四）Spring MVC

1. Spring MVC的架构与工作流程
   • Spring MVC是Spring框架用于Web开发的模块，遵循MVC（Model - View - Controller）设计模式。架构包含前端控制器（DispatcherServlet），作为请求入口统一接收客户端请求；处理器映射器（HandlerMapping）负责根据请求URL等信息找到对应的处理器（Controller方法）；处理器适配器（HandlerAdapter）协助调用处理器方法；视图解析器（ViewResolver）依据逻辑视图名解析出物理视图（如JSP、Thymeleaf等模板页面）；模型（Model）存放业务数据传递给视图展示。工作流程是客户端请求先到DispatcherServlet，经HandlerMapping找对应Controller方法，由HandlerAdapter调用方法处理，将结果放Model中，再经ViewResolver找视图渲染返回客户端。
2. Controller层的职责与编写规范
   • Controller层处于Web应用前端与业务逻辑层间，职责是接收客户端请求参数（通过注解如@RequestParam、@RequestBody等获取），调用业务层服务方法处理业务，将处理结果封装进Model或直接返回数据（如JSON格式，配合@ResponseBody注解），编写时需遵循单一职责原则，每个Controller类专注处理一类业务请求（如用户管理相关、商品管理相关等），方法简洁明了，标注清晰请求映射路径（如@RequestMapping）方便路由定位。
3. 视图解析与数据绑定机制
   • 视图解析通过ViewResolver实现，依据配置（如InternalResourceViewResolver针对JSP视图）的视图解析规则，把逻辑视图名（在Controller方法返回）转换为物理视图资源（文件路径等），渲染页面。数据绑定是Spring MVC将客户端请求参数自动转换绑定到Controller方法参数或业务对象上，依据参数类型、注解标识（如@ModelAttribute用于复杂对象绑定）智能转换，减少手动解析参数繁琐，提升开发效率。

（五）Spring Boot与Spring的关系

1. Spring Boot的诞生背景与目标
   • Spring Boot诞生于应对传统Spring项目繁琐配置、复杂项目搭建流程问题，旨在快速构建可独立运行、生产就绪的Spring应用。随着Java生态发展，Spring项目架构复杂度攀升，配置文件繁多、依赖管理棘手，Spring Boot应运而生，借助约定优于配置理念、自动配置特性，让开发者聚焦业务，短时间内搭建项目并高效开发，尤其适合微服务架构下多项目并行开发场景。
2. Spring Boot对Spring的简化与整合
   • Spring Boot对Spring深度整合简化体现在多方面。在配置上，通过application.properties或application.yml文件，用简洁键值对或层级结构设置大量Spring组件配置（如数据库连接、服务器端口），内置智能默认值，减少手动配置；依赖管理上，基于Starter POM机制，引入如spring-boot-starter-web、spring-boot-starter-data-jdbc等起步依赖，自动拉取关联库并合理配置，一站式解决Web开发、数据访问等基础需求；启动流程也精简，内置主类启动器，一键运行应用，同时整合健康检查、监控等运维功能，全方位提升开发运维体验。
3. Spring Boot的核心特性与应用案例
   • 核心特性有自动配置（依类路径下依赖自动生成配置，如引入MyBatis依赖则配置MyBatis相关Bean）、起步依赖（快速构建功能模块依赖集）、Actuator运维监控（暴露应用内部状态信息，供监控运维）。例如搭建小型电商后台服务，引入spring-boot-starter-web、spring-boot-starter-data-jdbc、spring-boot-starter-security起步依赖，简单配置数据库连接、安全规则后，迅速编写业务代码，利用Actuator监控接口性能、服务状态，高效搭建运行高可用性微服务应用。

（六）Spring Cloud与Spring Boot的关系

1. Spring Cloud的定位与功能概述
   • Spring Cloud定位是为分布式系统提供一站式解决方案，构建微服务架构生态。功能涵盖服务注册与发现（如Eureka、Consul）助微服务间互相知晓、定位；配置中心（如Spring Cloud Config）统一管理多微服务配置，动态刷新；熔断器（如Hystrix）防止服务雪崩，保障系统韧性；网关（如Spring Cloud Gateway）统一对外接口，路由、过滤请求等，整合诸多组件，协同运作，支撑大规模微服务集群稳定运行。
2. Spring Cloud基于Spring Boot的构建方式
   • Spring Cloud构建紧密依托Spring Boot，以Spring Boot项目为基础单元，每个微服务项目借Spring Boot优势快速搭建、独立运行，之后添入Spring Cloud对应组件依赖，像服务注册中心微服务引入spring-cloud-starter-netflix-eureka-server依赖搭建Eureka Server；客户端微服务引入spring-cloud-starter-netflix-eureka-client依赖接入注册中心，基于Spring Boot启动、配置简便性，轻松嵌入Spring Cloud复杂架构，实现分布式系统从无到有高效构建。
3. Spring Cloud与Spring Boot协同优势与应用场景
   • 协同优势在于Spring Boot负责微服务个体高效开发、运行，Spring Cloud把控微服务间交互、整体架构稳定性。在电商、金融科技等领域大规模分布式应用场景，各业务拆为微服务（订单、支付、用户等微服务）用Spring Boot开发，借Spring Cloud关联、监控、保护，实现高扩展性、高可靠性系统，灵活应对业务增长、流量波动，保障服务质量与用户体验。