参考学习：b站浪飞yes
# 一、Spring 引入
**事务实现**
```java
public class EmployeeServiceImpl implements IEmployeeService {
public void save(Employee employee){
// 打开资源
// 开启事务
try {
// 保存业务操作
// 提交事务
}catch (Exception e){
// 回滚事务
}finally{
// 释放资源
}
}
// ...
}
```
**MyBatis框架**
```java
public void update(Employee emp){
SqlSession session = MyBatisUtil.getSession();
EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
employeeMapper.update(emp);
session.commit();
session.close();
}
```
**请求接口**
```java
@WebServlet("/list")
public class EmployeeServlet extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.setContentType("application/json;charset=utf-8");
// 获得字符打印流对象
PrintWriter out = resp.getWriter();
// 响应数据给浏览器显示
String json = "{\"message\":\"success\", \"data\":[{\"id\":1,\"name\":\"dafei\", \"age\":18},{\"id\":2,\"name\":\"xiaoye\", \"age\":16}]}";
out.print(json);
}
}
```
如果说下面代码等价上面的，有啥感想？
**事务实现**
```java
public class EmployeeServiceImpl implements IEmployeeService {
@Transactional
public void save(Employee employee){
}
// ...
}
```
**MyBatis框架**
```java
@Autowired
private EmployeeMapper employeeMapper;
public void update(Employee emp){
employeeMapper.update(emp);
}
```
**请求接口**
```java
@RequestMapping("/list")
public class EmployeeController {
@ResponseBody
protected R service() {
return new R.ok(Arrays.asList(new Employee(1L, "dafei",18), new Employee(2L,"xiaoye", 16)));
}
}
```
请使用：**Spring框架**
# 二、Spring 介绍
## 2.1 简介
官网：https://spring.io/projects/spring-framework#learn
Spring 是一个轻量级的 **IoC / DI和 AOP 容器**的开源框架，致力于构建轻量级的 JavaEE 应用，**简化应用开发**，本身涵盖了传统应用开发，还拓展到移动端，大数据等领域。
什么是容器（Container）：从程序设计角度看就是**装对象的的对象，因为存在放入、拿出等操作，所以容器还要管理对象的生命周期**。
**大白话：Spring是一个可以存放对象的容器，并管理这些对象的生老病死，我们可以通过Spring API随意操作这些对象。**
## 2.2 Spring 优势
Spring 不能帮我们写业务逻辑，但是可以能帮助我们简化开发，作用如下
-
Spring 能帮我们低侵入/低耦合地根据配置文件创建及组装对象之间的依赖关系。
-
Spring 面向切面编程能帮助我们无耦合的实现日志记录，性能统计，安全控制等。
-
Spring 能非常简单的且强大的声明式事务管理。
-
Spring 提供了与第三方数据访问框架（如Hibernate、JPA）无缝集成，且自己也提供了一套 JDBC 模板来方便数据库访问。
-
Spring 提供与第三方 Web（如 MyBatis）框架无缝集成，且自己也提供了一套 Spring MVC 框架，来方便 Web 层搭建。
-
Spring 能方便的与如 Java Mail、任务调度、缓存框架等技术整合，降低开发难度。
**一句话：牛逼**
## 2.3 Spring 架构体系
![Spring FrameWork 体系]
-
Core Container（核心容器 IoC）包含有 Beans、Core、Context 和 SpEL 模块。
-
Test 模块支持使用 JUnit 和 TestNG 对 Spring 组件进行测试。
-
AOP 模块提供了一个符合 AOP 联盟标准的面向切面编程的实现。
-
Data Access / Integration 层包含有 JDBC、ORM、OXM、JMS 和 Transaction 模块。
-
Web 层包含了 Web、Web-Servlet、WebSocket、Web-Porlet 模块。
课程重点设涉及 **Test、Core Container、AOP、TX、MVC。**
2.4 Spring 版本
```java
snapshot：是工程版本上的概念，表示快照版本，也就是相对稳定版本，但是会再进行改进，最好不要用于生产环境
Alpha：内测版，BUG多，开发人员开发过程中使用，希腊字母α，第一，指最初版
Beta：早期版本，有缺陷，没有严重BUG，可能加入新功能，进一步开发完善
Gamma: 经Beta 版，完善修改，成为正式发布的候选版本（Release Candidate）
RC：(Release Candidate)：候选版本，几乎就是正式版了
GA：（Ggeneral Availability）：发行稳定版，官方推荐使用此版本
R，RELEASE：正式版，等价于GA
```
**JDK版本要求**：
| Spring Framework版本 | JDK版本 |
| -------------------- | --------- |
| 6.0.x | JDK 17-21 |
| 5.3.x | JDK 8-19 |
| 5.2.x | JDK 8-15 |
| 5.1.x | JDK 8-12 |
| 5.0.x | JDK 8-10 |
| 4.3.x | JDK 6-8 |
https://github.com/spring-projects/spring-framework/wiki/Spring-Framework-Versions
**Spring 6.x之后JDK版本要求是JDK17，而当前我们使用JDK11，所以选择5.3.x版本，新版本控的同学自己选择。**
此处选择Spring版本：**Spring-5.3.34**
# 三、Spring 入门案例
**需求：使用spring容器管理对象**
**步骤1：创建标准maven项目：spring_ioc_di_aop**
**步骤2：导入Spring依赖**
```xml
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.34</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.26</version>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<version>5.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
```
**步骤3：创建普通domain对象**
```java
package cn.wolfcode.spring._01_hello;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
@Setter
@Getter
public class User {
private String username;
private String password;
}
```
**步骤4：创建Spring容器文件：01.hello.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 id="user" class="cn.wolfcode.spring._01_hello.User"></bean>
</beans>
```
**步骤5：测试Spring容器**
添加junit5测试依赖
```xml
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>5.8.2</version>
<scope>test</scope>
</dependency>
```
**HelloTest测试类**
```java
package cn.wolfcode.spring.test._01_hello;
import cn.wolfcode.spring._01_hello.User;
import org.junit.jupiter.api.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class HelloTest {
@Test
public void testHello(){
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:01.hello.xml");
User user = context.getBean("user", User.class);
System.out.println(user);
System.out.println(user.getUsername());
System.out.println(user.getPassword());
}
}
```
# 四、Spring 入门解析
## 4.1 hello.xml
在hello.xml文件中最核心的代码
```xml
<bean id="user" class="cn.wolfcode.spring._01_hello.User">
<property name="username" value="dafei"></property>
<property name="password" value="666"></property>
</bean>
```
xml文件+上面代码，Spring做了一下操作：
-
借助xml文件创建了Spring容器
-
解析class指定的全限定类名，并通过反射创建了User对象，并初始化属性
-
将创建User对象缓存在spring容器中
-
建立起 user<---->User对象的映射，后续可以通过id获取User对象
## 4.2 HelloTest.java
### 4.2.1 ClassPathXmlApplicationContext
HelloTest测试案例里面有2行核心代码
```java
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:01.hello.xml");
```
-
**ClassPathXmlApplicationContext**：Spring框架的上下文对象，一般可以理解为Spring容器的化身之一，操作它的API，等价于操作Spring容器。
-
框架启动时，ClassPathXmlApplicationContext 会从classpath加载配置文件，并初始化 Spring 容器，并根据配置文件中的信息创建和管理相应的 Bean 实例（比如案例中User对象，Spring容器对象称之为Bean）。
-
通过 ClassPathXmlApplicationContext 提供的API可以操作容器中的Bean实例。
**Spring容器各种化身体系(继承)**
**BeanFactory**：
-
**功能**：是 Spring 框架最基本的 IoC 容器，提供了最基本的 IoC 功能，包括依赖注入和 Bean 的生命周期管理。
-
**特点**：BeanFactory 是 Spring IoC 容器的最底层接口，提供了延迟加载 Bean 的特性，当获取 Bean 时才进行实例化和初始化。
-
**使用场景**：适用于资源受限或需要手动控制 Bean 实例化的场景，如移动设备或性能要求较高的环境。
**ApplicationContext**：
-
**功能**：是 BeanFactory 接口的扩展，提供了更多高级特性，如国际化支持、事件传播、AOP 集成等，是 Spring 中最常用的 IoC 容器接口。
-
**特点**：ApplicationContext 在 BeanFactory 的基础上增加了更多的功能和便利性，例如自动注册 BeanPostProcessor、Bean 生命周期管理、资源加载、消息源等。
-
**使用场景**：几乎所有 Spring 应用都应该使用 ApplicationContext，除非有特殊需求需要直接使用 BeanFactory。
**AnnotationConfigApplicationContext**：
-
**功能**：用于基于注解配置的 Spring 应用上下文。通过 Java 配置类（使用注解如 @Configuration、@ComponentScan、@Bean 等）来定义和管理 Spring Bean。
-
**使用场景**：适用于完全基于注解配置的 Spring 应用，不依赖 XML 配置文件。
**ClassPathXmlApplicationContext**：
-
**功能**：用于基于 XML 配置的 Spring 应用上下文。从类路径下加载指定的 XML 配置文件，并初始化 Spring 容器和 Bean。
-
**使用场景**：适用于传统的基于 XML 配置的 Spring 应用，配置信息存储在 XML 文件中。
**总结：开发涉及到操作Spring 容器，一般使用ApplicationContext即可**
**注意：上面类虽说可以认为是Spring容器化身，但它们都是独立对象。不能直接画等号。**
### 4.2.2 getBean
getBean：从Spring容器中获取Bean对象，常规用法：
```java
//通过name/id获取Bean对象
User user = (User) context.getBean("user");
//通过对象类型获取Bean对象，如果容器中存在多个相同User实例会报错
User user = context.getBean(User.class);
//通过name/id + 类型获取Bean对象，如果容器中存在多个相同User，但是name/id不一样，不报错
User user = context.getBean("user", User.class);
```
## 4.3 常见异常
**异常1：NoSuchBeanDefinitionException: No bean named 'user2' available**
按照 bean 名称去获取 bean 时，不存在名称为 user2的 bean。
**异常2：NoUniqueBeanDefinitionException: No qualifying bean of type 'cn.wolfcode._01_hello.User' available: expected single matching bean but found 2: User,User2**
按照 cn.wolfcode._01_hello.User类型去获取 bean 时，期望找到该类型唯一的一个 bean，可是此时找到了两个。
**异常3：BeanDefinitionParsingException: Configuration problem: Bean name 'User' is already used in this <beans> element Offending resource: class path resource [01.hello.xml]**
# 五、Spring 测试
Spring 测试有2种场景
## 5.1 场景1：Junit5
每个测试都要重新启动 Spring 容器，启动容器的开销大，测试效率低下。不应该是测试代码管理 Spring 容器，应该是 Spring 容器来管理测试代码。
一般不用
## 5.2 场景2：Spring提供测试
**优势**：
-
只需启动一个容器，并管理测试代码
-
减少很多代码的书写
![使用 Spring 测试]
操作过程
- 添加测试依赖
```xml
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.3.34</version>
<scope>test</scope>
</dependency>
```
- 代码测试
```java
//在测试方法之前启动容器
//@RunWith(SpringJUnit4ClassRunner.class) //junit4
@ExtendWith(SpringExtension.class) //junit5
@ContextConfiguration("classpath:01.hello.xml") // 指定加载的配置文件
public class HelloSpringTest {
@Autowired // @Autowired 后面讲注解使用再说，此处表示从容器中获取ctx对象
private ApplicationContext ctx; //spring容器
@Test
public void testHello(){
User user = ctx.getBean("user", User.class);
System.out.println(user);
}
}
```
这里注意，
-
使用junit4 跟 junit5有区别
-
导入Spring 容器，直接使用ApplicationContext化身