AI 助理
文档备案控制台
开发者社区 开发与运维 文章 正文

Spring学习知识点大全（一）

2026-03-26 328
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 教程来源 https://app-abdss1rim1oh.appmiaoda.com Spring是Java企业级开发的事实标准框架，以轻量、非侵入和强大DI/AOP为核心，涵盖IoC容器、AOP、数据访问、Web及测试等全栈能力。本文系统梳理其基础概念、Bean管理、依赖注入与生命周期等核心知识，助力初学者构建体系，赋能开发者深入进阶。

Spring 作为 Java 企业级开发的事实标准，以其轻量级、非侵入式的设计理念和强大的依赖注入能力，彻底改变了 Java 应用的开发方式。从最初解决 EJB 复杂性的轻量级框架，发展到如今涵盖微服务、云原生、响应式编程的全栈生态，Spring 已经成为 Java 开发者必须掌握的核心技能。本文将系统全面地梳理 Spring 框架的核心知识点，从基础概念到高级特性，帮助初学者建立完整的知识体系，也为有经验的开发者提供深入的技术参考。
20aa7ffe-c7c3-4945-aa92-b639bcf43842.png

一、Spring 概述

1.1 什么是 Spring
Spring 是一个开源的轻量级 Java 应用开发框架，旨在简化企业级应用开发的复杂性。它通过 IoC（控制反转）和 AOP（面向切面编程）等核心特性，实现了代码的解耦和模块化。

核心特性：

轻量级：非侵入式设计，对容器依赖小

控制反转（IoC）：将对象创建和依赖管理的控制权交给容器

依赖注入（DI）：容器动态地将依赖关系注入到组件中

面向切面编程（AOP）：将横切关注点与业务逻辑分离

容器：管理对象的生命周期和配置

一站式框架：提供数据访问、Web、安全、消息等完整解决方案

1.2 Spring 体系结构

Spring 框架模块化结构：

┌─────────────────────────────────────────────────────────────┐
│                    测试模块 (Test)                           │
├─────────────────────────────────────────────────────────────┤
│              Web 模块 (Web MVC, WebSocket, WebFlux)         │
├─────────────────────────────────────────────────────────────┤
│          数据访问模块 (JDBC, ORM, Transactions)             │
├─────────────────────────────────────────────────────────────┤
│           AOP 模块 (Aspects, Instrumentation)               │
├─────────────────────────────────────────────────────────────┤
│           核心容器 (Core, Beans, Context, SpEL)             │
└─────────────────────────────────────────────────────────────┘

核心模块：

Core Container：IoC 容器基础，提供 BeanFactory 和 ApplicationContext

AOP：面向切面编程支持

Data Access：JDBC、ORM、事务管理

Web：Web MVC、WebSocket、WebFlux

Test：单元测试和集成测试支持
1.3 环境搭建
Maven 依赖：

xml
<dependencies>
    <!-- Spring 核心依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.30</version>
    </dependency>

    <!-- Spring 测试支持 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.3.30</version>
        <scope>test</scope>
    </dependency>

    <!-- 日志框架 -->
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.4.11</version>
    </dependency>

    <!-- 单元测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

二、IoC 容器

2.1 控制反转与依赖注入
控制反转（IoC）：将对象的创建和依赖关系的管理从代码中转移给容器，由容器负责对象的生命周期和对象之间的关系。

依赖注入（DI）：容器在创建对象时，自动将依赖的对象注入到当前对象中。

依赖注入方式：

java
// 1. 构造器注入（推荐，用于必需依赖）
@Component
public class UserService {
    private final UserDao userDao;
    private final EmailService emailService;

    public UserService(UserDao userDao, EmailService emailService) {
        this.userDao = userDao;
        this.emailService = emailService;
    }
}

// 2. Setter 注入（用于可选依赖）
@Component
public class OrderService {
    private OrderDao orderDao;

    @Autowired
    public void setOrderDao(OrderDao orderDao) {
        this.orderDao = orderDao;
    }
}

// 3. 字段注入（最简洁，但不推荐）
@Component
public class ProductService {
    @Autowired
    private ProductDao productDao;
}

2.2 Bean 配置方式
XML 配置方式：

xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 基本 Bean 配置 -->
    <bean id="userDao" class="com.example.dao.UserDaoImpl"/>

    <!-- 构造器注入 -->
    <bean id="userService" class="com.example.service.UserService">
        <constructor-arg ref="userDao"/>
        <constructor-arg value="张三"/>
    </bean>

    <!-- Setter 注入 -->
    <bean id="orderService" class="com.example.service.OrderService">
        <property name="orderDao" ref="orderDao"/>
        <property name="timeout" value="5000"/>
    </bean>

    <!-- 静态工厂方法 -->
    <bean id="dateFormat" class="java.text.SimpleDateFormat" 
          factory-method="getInstance"/>

    <!-- 实例工厂方法 -->
    <bean id="serviceFactory" class="com.example.ServiceFactory"/>
    <bean id="service" factory-bean="serviceFactory" factory-method="createService"/>
</beans>

注解配置方式：

java
// @Configuration 声明配置类
@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {

    // @Bean 声明 Bean
    @Bean
    public DataSource dataSource() {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUsername("root");
        dataSource.setPassword("password");
        return dataSource;
    }

    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }

    // 条件创建 Bean
    @Bean
    @Conditional(DevCondition.class)
    public DevService devService() {
        return new DevService();
    }

    // Bean 生命周期回调
    @Bean(initMethod = "init", destroyMethod = "cleanup")
    public SomeService someService() {
        return new SomeService();
    }
}

混合配置：

java
@Configuration
@ImportResource("classpath:spring-config.xml")  // 导入 XML 配置
@ComponentScan(basePackages = "com.example")
@PropertySource("classpath:application.properties")  // 导入属性文件
public class MixedConfig {

    @Value("${jdbc.url}")
    private String jdbcUrl;

    @Autowired
    private Environment env;
}

2.3 Bean 的作用域

java
@Component
// 单例（默认）
@Scope("singleton")
public class SingletonBean {
}

@Component
// 原型（每次获取都创建新实例）
@Scope("prototype")
public class PrototypeBean {
}

@Component
// 请求作用域（Web 应用）
@Scope(value = "request", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class RequestBean {
}

@Component
// 会话作用域（Web 应用）
@Scope(value = "session", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class SessionBean {
}

@Component
// 应用作用域（Web 应用）
@Scope(value = "application", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class ApplicationBean {
}

// 自定义作用域
@Component
@Scope("thread")
public class ThreadScopeBean {
}

// 配置自定义作用域
@Configuration
public class CustomScopeConfig {

    @Bean
    public static CustomScopeConfigurer customScopeConfigurer() {
        CustomScopeConfigurer configurer = new CustomScopeConfigurer();
        configurer.addScope("thread", new SimpleThreadScope());
        return configurer;
    }
}

2.4 Bean 生命周期

@Component
public class LifecycleBean implements InitializingBean, DisposableBean, 
                                       BeanNameAware, BeanFactoryAware {

    private String name;

    public LifecycleBean() {
        System.out.println("1. 构造器执行");
    }

    // 属性注入后执行
    @Autowired
    public void setName(String name) {
        System.out.println("2. 属性注入");
        this.name = name;
    }

    // Bean 名称感知
    @Override
    public void setBeanName(String name) {
        System.out.println("3. BeanNameAware: " + name);
    }

    // BeanFactory 感知
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("4. BeanFactoryAware");
    }

    // 初始化前执行
    @PostConstruct
    public void postConstruct() {
        System.out.println("5. @PostConstruct");
    }

    // 初始化方法
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("6. InitializingBean.afterPropertiesSet");
    }

    // 自定义初始化方法
    @Bean(initMethod = "customInit")
    public void customInit() {
        System.out.println("7. 自定义初始化方法");
    }

    // 销毁前执行
    @PreDestroy
    public void preDestroy() {
        System.out.println("8. @PreDestroy");
    }

    // 销毁方法
    @Override
    public void destroy() throws Exception {
        System.out.println("9. DisposableBean.destroy");
    }

    // 自定义销毁方法
    @Bean(destroyMethod = "customDestroy")
    public void customDestroy() {
        System.out.println("10. 自定义销毁方法");
    }
}

2.5 条件化 Bean 装配

// 条件接口实现
public class DevCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Environment env = context.getEnvironment();
        return "dev".equals(env.getProperty("spring.profiles.active"));
    }
}

// 使用 @Conditional
@Configuration
public class ConditionalConfig {

    @Bean
    @Conditional(DevCondition.class)
    public DataSource devDataSource() {
        return new HikariDataSource();
    }

    @Bean
    @Conditional(ProdCondition.class)
    public DataSource prodDataSource() {
        return new HikariDataSource();
    }

    // 基于配置属性
    @Bean
    @ConditionalOnProperty(name = "cache.enabled", havingValue = "true")
    public CacheManager cacheManager() {
        return new ConcurrentMapCacheManager();
    }

    // 基于类的存在
    @Bean
    @ConditionalOnClass(name = "redis.clients.jedis.Jedis")
    public RedisTemplate redisTemplate() {
        return new RedisTemplate();
    }

    // 基于 Bean 的存在
    @Bean
    @ConditionalOnMissingBean(DataSource.class)
    public DataSource defaultDataSource() {
        return new HikariDataSource();
    }
}

// Spring Boot 条件注解
@Configuration
public class BootConditionalConfig {

    @Bean
    @ConditionalOnWebApplication
    public WebConfig webConfig() {
        return new WebConfig();
    }

    @Bean
    @ConditionalOnNotWebApplication
    public CliConfig cliConfig() {
        return new CliConfig();
    }

    @Bean
    @ConditionalOnResource(resources = "classpath:config.xml")
    public XmlParser xmlParser() {
        return new XmlParser();
    }

    @Bean
    @ConditionalOnExpression("${my.property:true} && ${another.property:false}")
    public ComplexBean complexBean() {
        return new ComplexBean();
    }
}

三、依赖注入详解

3.1 @Autowired 注解

java
@Component
public class InjectionDemo {

    // 字段注入
    @Autowired
    private UserDao userDao;

    // 构造器注入（推荐）
    private final OrderDao orderDao;

    @Autowired
    public InjectionDemo(OrderDao orderDao) {
        this.orderDao = orderDao;
    }

    // Setter 注入
    private ProductDao productDao;

    @Autowired
    public void setProductDao(ProductDao productDao) {
        this.productDao = productDao;
    }

    // 任意方法注入
    @Autowired
    public void injectDependencies(EmailService emailService, SmsService smsService) {
        // 注入多个依赖
    }

    // 集合注入
    @Autowired
    private List<PaymentService> paymentServices;  // 注入所有实现

    @Autowired
    private Map<String, PaymentService> paymentServiceMap;  // 注入带名称的 Map

    // 可选注入
    @Autowired(required = false)
    private Optional<CacheService> cacheService;

    // 精确匹配
    @Autowired
    @Qualifier("mysqlDataSource")
    private DataSource dataSource;
}

3.2 @Qualifier 注解

@Component
public class QualifierDemo {

    @Autowired
    @Qualifier("mysqlDataSource")
    private DataSource primaryDataSource;

    @Autowired
    @Qualifier("oracleDataSource")
    private DataSource secondaryDataSource;

    // 自定义 Qualifier 注解
    @Target({ElementType.FIELD, ElementType.PARAMETER})
    @Retention(RetentionPolicy.RUNTIME)
    @Qualifier
    public @interface MySQL {}

    @Target({ElementType.FIELD, ElementType.PARAMETER})
    @Retention(RetentionPolicy.RUNTIME)
    @Qualifier
    public @interface Oracle {}

    @Autowired
    @MySQL
    private DataSource mysqlDataSource;

    @Autowired
    @Oracle
    private DataSource oracleDataSource;
}

// 使用自定义 Qualifier
@Configuration
public class DataSourceConfig {

    @Bean
    @MySQL
    public DataSource mysqlDataSource() {
        return new HikariDataSource();
    }

    @Bean
    @Oracle
    public DataSource oracleDataSource() {
        return new HikariDataSource();
    }
}

3.3 @Resource 和 @Inject

import javax.annotation.Resource;
import javax.inject.Inject;
import javax.inject.Named;

@Component
public class Jsr330Demo {

    // @Resource 按名称注入（JSR-250）
    @Resource(name = "userDao")
    private UserDao userDao;

    // @Resource 默认按字段名注入
    @Resource
    private OrderDao orderDao;

    // @Inject 按类型注入（JSR-330）
    @Inject
    private ProductDao productDao;

    // @Inject 结合 @Named 按名称注入
    @Inject
    @Named("paymentService")
    private PaymentService paymentService;

    // @Inject 支持 Provider 延迟注入
    @Inject
    private Provider<CacheService> cacheServiceProvider;

    public void useCache() {
        CacheService cache = cacheServiceProvider.get();  // 延迟获取
        cache.get("key");
    }
}

3.4 循环依赖解决

// 构造器注入无法解决循环依赖（会抛出异常）
// 解决方案1：使用 Setter 或字段注入
@Component
public class ServiceA {
    @Autowired
    private ServiceB serviceB;  // 字段注入解决循环依赖
}

@Component
public class ServiceB {
    @Autowired
    private ServiceA serviceA;
}

// 解决方案2：使用 @Lazy 延迟加载
@Component
public class ServiceC {
    private final ServiceD serviceD;

    public ServiceC(@Lazy ServiceD serviceD) {
        this.serviceD = serviceD;
    }
}

@Component
public class ServiceD {
    private final ServiceC serviceC;

    public ServiceD(ServiceC serviceC) {
        this.serviceC = serviceC;
    }
}

// 解决方案3：使用 @PostConstruct 初始化
@Component
public class ServiceE {
    @Autowired
    private ServiceF serviceF;

    @PostConstruct
    public void init() {
        // 使用 serviceF 初始化
    }
}

@Component
public class ServiceF {
    @Autowired
    private ServiceE serviceE;
}

来源：
https://app-abdss1rim1oh.appmiaoda.com

文章标签：
Java
容器
Spring
开发者
测试技术
游客xp6ru7c63sdiu
目录
相关文章
ClawdbotMoltbot
|
27天前
|
人工智能 Linux API
OpenClaw 阿里云秒级部署保姆级教程：从0到1搭建7×24小时AI助手
2026年3月，OpenClaw（原Clawdbot）凭借其轻量化架构、丰富技能生态与大模型适配能力，成为个人与小型团队搭建AI助手的首选方案。阿里云提供专属应用镜像与一键部署能力，可实现“秒级上线”，搭配百炼Coding Plan免费大模型API，无需本地算力即可拥有7×24小时在线的AI智能体。本文提供从服务器选购、端口放行、一键部署、模型配置到本地MacOS/Linux/Windows11联动的全流程保姆级教程，所有命令可直接复制执行，无冗余步骤，零基础也能一次成功。
ClawdbotMoltbot
406 11
AI研究者手札
|
30天前
|
传感器 人工智能 自动驾驶
自动驾驶中行人目标检测数据集（近4000张图片已标注）| YOLO训练数据集 AI视觉检测
本数据集含近4000张高质量标注图像，专为自动驾驶行人检测设计，精细划分pedestrian（动态行人）、ped（旁观者）、people（人群）三类，覆盖城市、城郊、商圈等多场景，支持YOLOv5-v10等模型训练，助力行为预测与安全决策。
AI研究者手札
315 6
自动驾驶中行人目标检测数据集（近4000张图片已标注）| YOLO训练数据集 AI视觉检测
阿里云开发者
|
1月前
|
Arthas 人工智能 Java
我们做了比你更懂 Java 的 AI-Agent -- Arthas Agent
Arthas Agent 是基于阿里开源Java诊断工具Arthas的AI智能助手，支持自然语言提问，自动匹配排障技能、生成安全可控命令、循证推进并输出结构化报告，大幅降低线上问题定位门槛。
阿里云开发者
1018 64
我们做了比你更懂 Java 的 AI-Agent -- Arthas Agent
游客xp6ru7c63sdiu
|
22天前
|
XML Java Maven
Spring Boot学习知识点大全（一）
教程来源 https://app-a87ujc988w01.appmiaoda.com/ Spring Boot 是 Spring 家族中革命性框架，秉持“约定优于配置”理念，通过自动配置、起步依赖、嵌入式服务器等特性，大幅简化企业级 Java 应用开发。本文系统梳理其核心概念、注解、多环境配置与最佳实践，助初学者快速入门，为进阶开发者提供深度参考。
游客xp6ru7c63sdiu
323 0
阿里云开发者
|
1月前
|
存储 人工智能 关系型数据库
OpenClaw怎么可能没痛点？用RDS插件来释放OpenClaw全部潜力
OpenClaw插件是深度介入Agent生命周期的扩展机制，提供24个钩子，支持自动注入知识、持久化记忆等被动式干预。相比Skill/Tool，插件可主动在关键节点（如对话开始/结束）执行逻辑，适用于RAG增强、云化记忆等高级场景。
阿里云开发者
883 56
OpenClaw怎么可能没痛点？用RDS插件来释放OpenClaw全部潜力
浅浅33
|
8天前
|
存储 Java 数据库连接
ThreadLocal 深度剖析：底层实现、内存泄漏根因与生产环境避坑指南
ThreadLocal实现线程间数据隔离，但易引发内存泄漏。本文详解其核心原理（ThreadLocalMap、弱引用key/强引用value）、内存泄漏根因，并提供remove清理、try-finally保障、TransmittableThreadLocal等生产级避坑方案。
浅浅33
98 13
问号云
|
18天前
|
安全 Linux 网络安全
阿里云轻量服务器+本地部署OpenClaw集成Skills全指南：从安装到自定义教程
OpenClaw（Clawdbot）的核心价值在于通过Skills（技能）扩展实现功能定制，结合阿里云轻量服务器的稳定运行与本地环境的灵活开发，可快速搭建适配业务场景的AI智能体。本文基于2026年最新稳定版，从阿里云轻量服务器与本地（MacOS/Linux/Windows11）部署OpenClaw，到Skills集成、自定义开发及避坑指南，全程提供可直接复制的代码命令，助力零基础用户快速完成技能扩展，打造高效智能助手。
问号云
368 5
小陈写代码
|
18天前
|
存储 机器学习/深度学习 编解码
阿里云199元云服务器：2核4G+5M带宽+80G云盘，新购续费同价，初创企业首选
对于预算有限的初创团队及中小企业，阿里云推出的通用算力型u1实例199元云服务器特惠活动极具吸引力。该服务器配置为2核4G内存、5M带宽、80G ESSD Entry云盘，年费仅需199元，且新购与续费同价，活动长期有效至2027年。该服务器采用Intel ® Xeon ® Platinum处理器，性能稳定，适用于Web应用、企业办公、数据分析等多种场景，以极致性价比助力企业轻松上云，实现长期成本的确定性与可控性。
小陈写代码
182 10
一条云
|
17天前
|
JavaScript Linux API
零基础玩转OpenClaw部署及避坑指南：从阿里云到本地多系统搭建，附千问大模型API配置与免费模型接入方案
OpenClaw(原Clawdbot)作为2026年热门的开源AI执行网络，凭借其强大的任务执行与大模型集成能力，成为开发者与企业用户的首选AI工具之一。本文将详细介绍2026年阿里云轻量服务器部署及本地MacOS/Linux/Windows11部署OpenClaw的完整步骤，同时涵盖阿里云千问大模型API配置与免费大模型Coding Plan API配置方法，并针对部署过程中的常见问题提供解决方案，帮助用户快速完成OpenClaw的部署与使用。
一条云
442 4