php 网站缓存做广个公司网站权重

👋 大家好，我是 阿问学长！专注于分享优质开源项目解析、毕业设计项目指导支持、幼小初高的教辅资料推荐等，欢迎关注交流！🚀

01-Spring框架概述与IoC容器入门

📖 本文概述

本文是SSM框架系列的第一篇，将深入介绍Spring框架的核心概念和IoC（控制反转）容器的基本原理与使用方法。通过理论讲解和实践代码，帮助读者建立对Spring框架的整体认知。

🎯 学习目标

• 理解Spring框架的设计理念和核心特性
• 掌握IoC（控制反转）和DI（依赖注入）的概念
• 学会配置和使用Spring IoC容器
• 能够编写基本的Spring应用程序

1. Spring框架概述

1.1 什么是Spring框架

Spring是一个开源的Java企业级应用开发框架，由Rod Johnson在2003年创建。Spring的核心理念是简化Java企业级应用的开发，提供全面的编程和配置模型。

Spring的核心特性：

1. 轻量级：Spring是非侵入性的，不强制继承特定的类或实现特定的接口
2. 控制反转（IoC）：通过IoC容器管理对象的创建和依赖关系
3. 面向切面编程（AOP）：支持横切关注点的模块化
4. 容器：Spring包含并管理应用对象的生命周期和配置
5. 框架集成：可以很好地集成其他优秀的开源框架

1.2 Spring框架的优势

// 传统方式：紧耦合的代码
public class UserService {private UserDao userDao = new UserDaoImpl(); // 硬编码依赖public User findUser(Long id) {return userDao.findById(id);}
}// Spring方式：松耦合的代码
public class UserService {private UserDao userDao; // 依赖注入public void setUserDao(UserDao userDao) {this.userDao = userDao;}public User findUser(Long id) {return userDao.findById(id);}
}

优势对比：

• 降低耦合度：组件之间的依赖关系由Spring容器管理
• 提高可测试性：可以轻松注入Mock对象进行单元测试
• 增强可维护性：修改实现类不需要修改业务代码
• 支持配置管理：通过配置文件或注解管理对象关系

1.3 Spring框架架构

Spring框架由多个模块组成，主要包括：

Spring Framework
├── Core Container (核心容器)
│   ├── spring-core
│   ├── spring-beans
│   ├── spring-context
│   └── spring-expression
├── Data Access/Integration (数据访问/集成)
│   ├── spring-jdbc
│   ├── spring-tx
│   ├── spring-orm
│   └── spring-jms
├── Web (Web层)
│   ├── spring-web
│   ├── spring-webmvc
│   └── spring-websocket
├── AOP (面向切面编程)
│   ├── spring-aop
│   └── spring-aspects
└── Test (测试)└── spring-test

2. IoC（控制反转）详解

2.1 什么是IoC

**控制反转（Inversion of Control，IoC）**是一种设计原则，用于减少代码之间的耦合度。在IoC模式中，对象的创建和依赖关系的管理被"反转"给了外部容器，而不是由对象自己控制。

传统控制方式 vs IoC控制方式：

// 传统方式：对象自己控制依赖
public class OrderService {private PaymentService paymentService;public OrderService() {// 对象自己创建依赖this.paymentService = new PaymentServiceImpl();}
}// IoC方式：容器控制依赖
public class OrderService {private PaymentService paymentService;// 通过构造器注入依赖public OrderService(PaymentService paymentService) {this.paymentService = paymentService;}
}

2.2 DI（依赖注入）

**依赖注入（Dependency Injection，DI）**是IoC的一种实现方式。Spring容器负责创建对象并注入其依赖的其他对象。

DI的三种方式：

1. 构造器注入
2. Setter方法注入
3. 字段注入

2.3 IoC容器

Spring IoC容器是Spring框架的核心，负责管理对象的创建、配置和生命周期。

主要的IoC容器接口：

• BeanFactory：基础的IoC容器接口
• ApplicationContext：高级的IoC容器接口，扩展了BeanFactory

3. Spring IoC容器实践

3.1 环境搭建

首先创建一个Maven项目，添加Spring依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.example</groupId><artifactId>spring-ioc-demo</artifactId><version>1.0.0</version><packaging>jar</packaging><properties><maven.compiler.source>8</maven.compiler.source><maven.compiler.target>8</maven.compiler.target><spring.version>5.3.21</spring.version></properties><dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>${spring.version}</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13.2</version><scope>test</scope></dependency></dependencies>
</project>

3.2 基于XML配置的IoC容器

步骤1：创建业务接口和实现类

// UserDao接口
public interface UserDao {void save(String user);String findById(Long id);
}// UserDao实现类
public class UserDaoImpl implements UserDao {@Overridepublic void save(String user) {System.out.println("保存用户：" + user);}@Overridepublic String findById(Long id) {System.out.println("查询用户ID：" + id);return "用户" + id;}
}// UserService类
public class UserService {private UserDao userDao;// Setter方法注入public void setUserDao(UserDao userDao) {this.userDao = userDao;}public void saveUser(String user) {userDao.save(user);}public String getUser(Long id) {return userDao.findById(id);}
}

步骤2：创建Spring配置文件

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!-- 配置UserDao Bean --><bean id="userDao" class="com.example.dao.impl.UserDaoImpl"/><!-- 配置UserService Bean，并注入UserDao依赖 --><bean id="userService" class="com.example.service.UserService"><property name="userDao" ref="userDao"/></bean></beans>

步骤3：测试IoC容器

public class SpringIoCTest {@Testpublic void testIoC() {// 创建IoC容器ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");// 从容器中获取BeanUserService userService = context.getBean("userService", UserService.class);// 使用BeanuserService.saveUser("张三");String user = userService.getUser(1L);System.out.println("获取到的用户：" + user);}
}

4. 小结

本文介绍了Spring框架的基本概念和IoC容器的核心原理：

1. Spring框架是一个轻量级的Java企业级开发框架
2. **IoC（控制反转）**是Spring的核心特性，用于降低代码耦合度
3. **DI（依赖注入）**是IoC的实现方式，由容器负责注入依赖
4. ApplicationContext是Spring的高级IoC容器接口

🔗 下一篇预告

下一篇文章将详细介绍依赖注入(DI)的各种方式和高级特性，包括构造器注入、Setter注入、自动装配等内容。

💡 练习建议

1. 动手实践本文的代码示例
2. 尝试创建更多的Bean并配置它们之间的依赖关系
3. 思考IoC模式相比传统方式的优势

---

相关文章：

• 下一篇：依赖注入(DI)详解与实践
• 返回目录