diff --git "a/\345\217\266\344\277\212\346\235\260/20241226 springmvc\345\237\272\347\241\200\344\275\277\347\224\250.md/03  Spring 12.26.md" "b/\345\217\266\344\277\212\346\235\260/20241226 springmvc\345\237\272\347\241\200\344\275\277\347\224\250.md/03  Spring 12.26.md"
new file mode 100644
index 0000000000000000000000000000000000000000..7bfbbae677710c3d290c552a319fe6f9f4a890b0
--- /dev/null
+++ "b/\345\217\266\344\277\212\346\235\260/20241226 springmvc\345\237\272\347\241\200\344\275\277\347\224\250.md/03  Spring 12.26.md"	
@@ -0,0 +1,883 @@
+## 一、初体验
+1. 官网：https://spring.io/
+2. Spring要和，JDK版本对应得上，否则会报错信息类似：Failed to read candidate component class，也就是注解扫描不了，这是版本兼容问题引起的，根据Spring官网Spring Framework与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   |
+3. Spring Framework的特点
+	1. 控制反转：IoC，反转资源获取方向；把自己创建的资源、向环境索取资源变为环境将资源准备好，我们享受资源注入。
+	2. 面向切面编程：AOP，在不修改源代码的基础上增强代码功能。
+	3. 容器：Spring IoC是一个容器，因为它包含并管理组件对象的生命周期；组件享受到了容器化的管理，替程序员屏蔽了组件创建过程中的大量细节，极大降低了使用门槛，大幅度提高了开发效率。
+	4. 一站式：在IOC和AOP的基础上可以整合各种企业应用的开源框架和优秀的第三方库，而且在Spring旗下的项目已经覆盖了广泛领域，很多方面的功能性需求可以在Spring Framework 的基础上全部使用Spring来实现。
+4. 入门案例
+	1. 环境要求：
+		- JDK : 1.8 
+		- Spring : 5.3.39
+	2. 构建工程项目
+	3. pom.xml中引入相关依赖，并 刷新maven
+--------------------------
+```xml
+   <dependencies>
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-context</artifactId>
+            <version>5.3.39</version>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.13.2</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+```
+-------------------------
+	4. 创建软件包
+	![image.png](https://gitee.com/onesheet/images_backup/raw/master/images/20241215222659.png)
+	5. 创建用于测试的实体类Teacher
+	![image.png](https://gitee.com/onesheet/images_backup/raw/master/images/20241215222947.png)
+	6. **创建spring配置文件：resources目录下创建bean.xml**
+![image.png](https://gitee.com/onesheet/images_backup/raw/master/images/20241215223246.png)
+![image.png](https://gitee.com/onesheet/images_backup/raw/master/images/202412191016646.png)
+![image.png](https://gitee.com/onesheet/images_backup/raw/master/images/202412191016805.png)
+![image.png](https://gitee.com/onesheet/images_backup/raw/master/images/20241215223436.png)
+	7. **在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">
+    <!--完成user对象创建
+            id属性：唯一标识,相当于对象被调用时取的名字
+            class属性：要创建的对象所在类的绝对路径
+        -->
+    <bean id="teacher" class="com.mdd.entity.Teacher"></bean>
+</beans>
+```
+----------------------------
+	8. **创建测试类com.md.test.TestTeacher进行测试**
+------------
+```java
+public class TestTeacher {
+    @Test
+    public void t1() {
+        // 1.加载spring配置文件，得到IOC容器context
+        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
+        // 2.从IOC容器获取spring创建好的对象
+        Teacher teacher = (Teacher) context.getBean("teacher");
+        // 3.使用对象调用方法测试
+        System.out.println("teacher = " + teacher);
+        teacher.teach();
+    }
+}
+```
+![image.png](https://gitee.com/onesheet/images_backup/raw/master/images/20241215224418.png)
+
+-----------------------
+## 二、一些术语概念
+### 1. IoC容器
+1. IoC 是 Inversion of Control 的简写，译为 控制反转。
+2. IoC容器
+	1. 管理着所有的Java对象的实例化和初始化，
+	2. 控制着对象与对象之间的依赖关系。
+	3. IoC容器管理的Java对象称为 Spring Bean，
+	4. 它与使用关键字 new 创建的Java对象没有任何区别。
+3. IoC容器是Spring框架中最重要的核心组件之一，它贯穿了Spring从诞生到成长的整个过程。
+
+### 2. 控制反转（ IoC ）
+> 控制反转是一种思想
+
+1. 将对象的创建权利交出去，交给第三方容器（IOC容器）负责
+2. 将对象和对象之间的关系维护权交出去，交给第三方容器负责
+
+>如何实现控制反转
+
+- 通过依赖注入DI的方式实现
+
+### 3. 依赖注入（ DI ）
+DI （Dependency Injection）：依赖注入，依赖注入实现了控制反转的思想，是指Spring创建对象的过程中，将对象依赖属性通过配置进行注入。
+
+>依赖注入常见的实现方式有两种：
+
+1. set注入 ,常用
+2. 构造器注入
+
+>结论： IoC 是一种控制反转的思想，而 DI 是对IoC的一种具体实现。
+
+Bean管理：指对IOC容器中的Bean对象的创建，以及Bean对象中属性的赋值（或Bean对象之间关系的维护）
+
+### 4. IoC容器的实现
+>Spring中的IoC容器就是IoC思想的一个落地产品实现。IoC容器中管理的组件也叫做bean。在创建bean之前，首先需要创建IoC容器，Spring提供了IoC容器的两种实现方式
+
+① BeanFactory
+
+这是IoC容器的基本实现，是Spring内部使用的接口。面向Spring本身，不提供给开发人员使用。
+
+② ApplicationContext
+
+BeanFactory的子接口，提供了更多高级特性，面向Spring的使用者，几乎所有场合都使用 ApplicationContext，而不是底层的BeanFactory
+
+③ ApplicationContext的主要实现类
+![image.png](https://gitee.com/onesheet/images_backup/raw/master/images/20241215230030.png)
+
+---------------
+| 类型                           | 说明                                               | 路径示例                                     |
+| ------------------------------ | -------------------------------------------------- | -------------------------------------------- |
+| ClassPathXmlApplicationContext | 通过读取类路径下的xml格式配置文件创建IoC容器对象   | appcontext.xml                               |
+| FileSystemApplicationContext   | 通过文件系统路径读取xml格式配置文件创建IoC容器对象 | file:F:/workspace/example/src/appcontext.xml |
+---------------
+
+## 三、如何通过XML管理Bean
+
+1. 还是 com.mdd.entity.Teacher 为例，来演示
+2. 获取bean方式
+	1. 根据id获取：
+		1. id属性是bean的唯一标识，所以根据bean标签的id属性可以精确获取到一个组件对象。
+		2. ![](https://gitee.com/onesheet/images_backup/raw/master/images/202412191016571.png)
+	2. 根据类型获取
+		1. ![image.png](https://gitee.com/onesheet/images_backup/raw/master/images/202412191016728.png)
+
+	3. 根据id和类型获取
+		1. ![image.png](https://gitee.com/onesheet/images_backup/raw/master/images/20241215231631.png)
+
+
+
+>注意： 当根据类型获取bean时，要求IoC容器中指定类型的bean只能有一个，当配置两个时会抛出异常
+
+
+### * 依赖注入的两种常见方式
+>类是有属性的，创建对象过程中，如何向属性注入具体的值？
+
+1. 方式1：使用set方法完成（使用xml中的标签实现）
+2. 方式2：基于构造器完成
+
+
+1. 使用set方法完成
+	1. 类中补充setter toString
+		1. ![image.png](https://gitee.com/onesheet/images_backup/raw/master/images/202412191016811.png)
+
+	2. 修改bean.xml，进行属性值注入
+		1. ![image.png](https://gitee.com/onesheet/images_backup/raw/master/images/20241215232345.png)
+		2. 测试：
+			1. ![image.png](https://gitee.com/onesheet/images_backup/raw/master/images/20241215232424.png)
+
+
+3. 基于构造器依赖注入
+	1. 补全类中的构造器
+		1. ![image.png](https://gitee.com/onesheet/images_backup/raw/master/images/202412191016440.png)
+
+	2. 修改bean.xml
+		1. ![image.png](https://gitee.com/onesheet/images_backup/raw/master/images/202412191016644.png)
+
+	3. 测试
+		1. !![image.png](https://gitee.com/onesheet/images_backup/raw/master/images/202412191016926.png)[image.png](https://gitee.com/onesheet/images_backup/raw/master/images/20241215232915.png)
+
+
+4. 不同类型的属性有不同的表示方式
+	1. 简单类型 ： value
+	2. 对象引用类型 : ref
+	3. 数组 \<array>value或ref\</array>
+	4. 集合\<list>value或ref\</list>
+	5. 空值 \<null>\</null>
+
+ 
+
+5. 练习
+	1. 使用spring框架完成以下操作
+	2. 分别创建老师，课程，学生三个类，每个类要有三个属性，做成javabean
+	3. 配置bean.xml进入Bean管理，分别创建老师，课程，学生的bean
+	4. 老师有：姓名,多门课程（数组），多个学生（集合）
+	5. 课程有：课程名称，学分
+	6. 学生有：姓名，年龄，一个任课老师。
+	7. 编写测试类，对每种bean进行测试。
+
+
+## 进阶一：
+1. 使用lombok 快速创建javabean的类
+2. 特殊类型的注入，实体符&lt; &gt; <![CDATA[防护罩]]>
+3. <![CDATA[<李四>]]> <![CDATA[防护罩]]>
+4. 4. druid数据源  https://zhuanlan.zhihu.com/p/690241776
+5. 外部属性文件的引入，
+6. 自动装配
+7. 三层架构：dao,service,controller
+	1. 详解三层架构 是什么? 为什么? 怎么做? 
+	2. ![image.png](https://gitee.com/onesheet/images_backup/raw/master/images/20241219150430.png)
+
+	3. https://blog.csdn.net/S_yyuan/article/details/121554927
+	5. 步骤
+	  1. 创建好各个软件包：entity->dao->service->controller
+	  2. 创建实体类  User（用来封装数据），（相当于做菜品材料）
+	  3. 创建数据访问层 （采购员）
+	     1. UserDao 接口 ，相当于采购员岗位，接口中的方法。相当于岗位职责
+	     2. UserDao 接口的实现类UserDaoImpl，相当于聘请的具体采购员，要符合岗位职责，所以要实现所有方法
+	     3. 在UserDaoImpl实现类中，写操作数据库的具体逻辑（具体的采购办法）
+	  4. 创建业务逻辑层 （厨师）
+	     1. UserService 接口，明确厨师的岗位职责，编写业务层要实现的功能方法
+	     2. UserService 接口的实现类UserServiceImpl，相当于根据厨师岗位职责招聘来的厨师，所有要具备厨师岗位所有技巧，即实现接口的所有方法
+	     3. 在UserServiceImpl实现类中，厨师做菜，要有材料，所以依赖于采购员，把采购员UserDao做为一个类属性注入进来
+	     4. 在UserServiceImpl实现类中，对UserDao传过来的数据，做进一步处理。相当于加工材料做成菜。
+		     1. 厨师做菜的材料，是依赖采购员来采购的。所以
+		     2. 在UserServiceImpl实现类中要定义一个UserDao的属性
+		     3. 在Bean中将UserDao对象入注入进来 
+	  5. 创建表示层 （服务员）
+	     1. UserController 类，
+	        1. 负责接收用户请求，并转发给UserServiceImpl：相当于服务员接收顾客点菜后，将菜单订单转发给厨师，厨师会根据这个订单开始做菜
+	        2. 负责接收UserServiceImpl的响应，将转发给用户：相当于服务员将厨师做好的菜。端给前面点菜的顾客。
+	        3. 因为厨师做好了菜之后，服务员才能将菜端给顾客，所以服务员的工作是依赖于厨师的。
+		        1. controller 类中要定义一个 UserService的属性
+		        2. 在Bean中将UserServicec对象注入进来 
+	6. 总结
+		1. Controller依赖Service,Service依赖Dao
+		2. 所以controller的bean要注入Service，Service的bean要注入Dao
+8. ### **注解开发**
+	1. 项目结构如bean.xml时一样
+	2. 新建config包，并创建SpringConfig类，里面改写bean.xml的配置
+	3. SpringConfig 配置
+		1. 声明自己是一个配置类 @Configuration
+		2. 扫描自定久类Bean所在的包@ComponentScan("com.pdd")
+		3. 为了方便管理，将jdbc和mybatis的配置单独成一个子配置文件
+			1. JdbcConfig
+				1. @Component   声明自己是组件一部分
+				2. @PropertySource("classpath:jdbc.properties") 加载外部的属性文件
+				3. 以@Value注解，注入四个属性变量@Value("${jdbc.driver}")
+				4. 以自定义方法的形式，public DruidDataSource getDruidDataSource(){ 返回一个DataSource对象
+				5. 不要忘记在这个方法上加上@Bean注解
+
+			2. MybatisConfig
+				1. @Component   声明自己是组件一部分
+				2. @MapperScan("com.pdd.mapper") 扫描mapper代理接口所在的包
+				3. 以自定义方式的形式， 返回一个SqlSessionFactoryBean的对象
+				4. 不要忘记在这个方法上加上@Bean注解
+	4. @Import({JdbcConfig.class, MyBatisConfig.class}) 将刚才创建的两个子配置文件导入进来
+	5. 新建测试类
+		1. 手动方式 ApplicationContext context =  new AnnotationConfigApplicationContext(SpringConfig.class); 得到IOC容器。由xml转为从配置类中获取容器。
+		2. 依赖注入的方式
+			1. @RunWith(SpringJUnit4ClassRunner.class)  测试类上方加这个注解 
+			2. @ContextConfiguration(classes = SpringConfig.class) 测试类上方加这个注解 
+			3. 直接将需要的对象，以属性自动装配的方式注入 @Autowired  private DeptController deptController;
+			4. 直接使用这个注入的对象 Dept dept = deptController.selectOneById(3);
+
+
+Spring 常用注解
+组件定义与依赖注入
+
+在Spring中，可以使用以下注解来定义组件并注入依赖：
+
+- _@Component_：通用组件，不指定角色。
+  
+- _@Service_：用于业务逻辑层（Service层）。
+  
+- _@Repository_：用于数据访问层（DAO层）。
+  
+- _@Controller_：用于表示层（Controller层）。
+  
+- _@Autowired_：自动注入Spring容器管理的bean。引用类型，对象
+- @Value : 自动注入简单的值String ，int 
+  
+- @PropertySource 加载外部属性文件
+  
+
+配置与作用域
+
+- _@Configuration_：声明一个类为配置类，相当于XML形式的Spring配置。    
+- _@Bean_：用于在配置类中声明一个bean。一般用于第三方对象的new出来的对象    
+- @ComponentScan({"com.pdd.controller","com.pdd.service"})  将自己建的类，要生成bean所在的包
+- @Import({JdbcConfig.class, MyBatisConfig.class})  导入子配置文件
+- @MapperScan  mybatis提供的，扫描接口的注解，为了的给所有接口生成对应的实现类的bean
+
+
+
+
+
+
+
+## 注解重构项目,步骤分解
+1. 导入POM.xml文件各种坐标
+2. 补全各处包 entity,mapper,service,controller,config
+3. 在entity实体类包下，根据表结构创建对应的实体类Video
+
+  ```java
+  // Video.java
+  @Data  // 相当于写了get,set,toString  
+  @AllArgsConstructor  //全参  
+  @NoArgsConstructor //无参  
+  public class Video {  
+   // 做成javaBean标准类的形式，  
+   // 属性全私有，get，set,toString ,全参和无参构造器  
+   private int videoId;  
+   private String videoName;    }
+  ```
+
+  
+
+ 4.  在mapper包下，创建sql语句的代理接口,VideoMapper (dao层)，在方法上方编写SQL语句，不用创建它的实现类。因为mybatis自动代理会实现所有的mapper接口的接口
+```java
+// VideoMapper
+public interface VideoMapper {  
+    // 就是对表的，CRUD是CREATE、READ、UPDATE和DELETE的首字母缩写  
+//    定义五个方法，分别表示查询所有，根据编号查询某行，根据编号删除某行，添加，修改  
+//    查询所有，返回所有行的集合 List    List<Video> selectAllVideos();  
+
+    //    根据编号查询某行,返回一个video  
+    Video selectVideoById(int id);  
+      
+    //        根据编号删除某行,返回受影响的行数 int    int deleteVideoById(int id);  
+      
+    //    添加，返回受影响的行数  
+    int insertVideo(Video video);  
+      
+    //        修改，返回受影响的行数  
+    int updateVideo(Video video);  
+
+}
+```
+ 5. 在service包下，创建一个VideoService接口和一个它的实现类
+
+	 ```java
+	 // VideoService
+	 import java.util.List;  
+	 
+	 public interface VideoService {  
+	     // 1.可以直接把mapper的方法，都复制过来，并删除所有的SQL语句  
+	     // 2.稍微对方法的返回值类型做一下调整，根据受影响行数，判断是true,false(就是将int 改成 Boolean)    //    查询所有，返回所有行的集合 List  
+	     List<Video> selectAllVideos();  
+	 
+	     //    根据编号查询某行,返回一个video  
+	     Video selectVideoById(int id);  
+	       
+	     //        根据编号删除某行,返回受影响的行数 int    Boolean deleteVideoById(int id);  
+	       
+	     //    添加，返回受影响的行数  
+	     Boolean insertVideo(Video video);  
+	       
+	     //        修改，返回受影响的行数  
+	     Boolean updateVideo(Video video);  
+	 
+	 }
+	```
+	
+	 ```java
+	 //VideoServiceImpl
+	 package com.demo.service.impl;  
+	 
+	 import com.demo.entity.Video;  
+	 import com.demo.mapper.VideoMapper;  
+	 import com.demo.service.VideoService;  
+	 import org.springframework.beans.factory.annotation.Autowired;  
+	 import org.springframework.stereotype.Service;  
+	 
+	 import java.util.List;  
+	 
+	 @Service   //  类名上方写注解，用来对Spring表明身份我是一个Bean,快来接管我  
+	 public class VideoServiceImpl implements VideoService {  
+	     // 1. 实现接口的所有方法，快捷方式，光标停在波浪线上，按ALT+回车  
+	     // 2. 因为service层是依赖于mapper层的，所有要建一个mapper属性，用来依赖注入,在其上方，写个注解@Autowired // 自动装配  
+	     // 3. 在类名上添加注解@Service  
+	     // 4. 修改各个方法体中的逻辑，具体就是调用mapper的方法来实现,意见就是service自己不干活，让mapper去干活  
+
+
+​	 
+	     @Autowired // 自动装配  
+	     private VideoMapper videoMapper;  
+	       
+	     @Override  
+	     public List<Video> selectAllVideos() {  
+	         List<Video> videos = videoMapper.selectAllVideos();  
+	         return videos;  
+	     }  
+	       
+	     @Override  
+	     public Video selectVideoById(int id) {  
+	         return videoMapper.selectVideoById(id);  
+	     }  
+	       
+	     @Override  
+	     public Boolean deleteVideoById(int id) {  
+	         return videoMapper.deleteVideoById(id)>0;  
+	     }  
+	       
+	     @Override  
+	     public Boolean insertVideo(Video video) {  
+	         return videoMapper.insertVideo(video)>0;  
+	     }  
+	       
+	     @Override  
+	     public Boolean updateVideo(Video video) {  
+	         return videoMapper.updateVideo(video)>0;  
+	     }  
+	 
+	 }
+	 ```
+
+
+​	 
+
+ 6. 在controller包下，创建一个VideoController类
+
+	 ```java
+	 //VideoController
+	 package com.demo.controller;  
+	 
+	 import com.demo.entity.Video;  
+	 import com.demo.service.VideoService;  
+	 import org.springframework.beans.factory.annotation.Autowired;  
+	 import org.springframework.stereotype.Controller;  
+	 
+	 import java.util.List;  
+	 
+	 @Controller  
+	 public class VideoController {  
+	     // 1. 表明身份，@Controller  
+	     // 2. 复制serviceImpl实现类的方法过来，删除所有方法名上@Override  
+	     // 3. 修改@Autowired 下面的依赖对象，由mapper改为service接口（不是实现类）  
+	     // 4. 将所有方法中的调用videoMapper改为videoService  
+	     // 5. 将所有Boolean返回值类型的方法，改成String，根据True false 来返回 成功，还是失败  
+	 
+	     @Autowired // 自动装配  
+	     private VideoService videoService;    
+	 
+	    public List<Video> selectAllVideos() {  
+	         List<Video> videos = videoService.selectAllVideos();  
+	         return videos;  
+	     }  
+
+
+​	 
+	     public Video selectVideoById(int id) {  
+	         return videoService.selectVideoById(id);  
+	     }  
+
+
+​	 
+​	     
+	     public String deleteVideoById(int id) {  
+	        // 根据True false 来返回 成功，还是失败  
+	        return videoService.deleteVideoById(id)?"删除成功":"删除失败";  
+	    }  
+
+
+​	 
+​	      
+	    public String insertVideo(Video video) {  
+	         return videoService.insertVideo(video)?"添加成功":"添加失败";  
+	     }  
+
+
+​	    
+​	 
+	     public String updateVideo(Video video) {  
+	         return videoService.updateVideo(video)?"修改成功":"修改失败";  
+	     }  
+	 
+	 }
+	```
+
+
+​	 
+
+ 7. 在config下编写三个配置类,spring核心配置类，jdbc的配置类，mybatis配置类。其中jdbc又依赖jdbc.properties文件
+
+	```properties
+	# jdbc.properties
+	jdbc.driver = com.mysql.cj.jdbc.Driver  
+	jdbc.url = jdbc:mysql:///spring_pdd  
+	jdbc.username = root  
+	jdbc.password = root
+	```
+
+
+​	
+​	
+	```java
+	//JdbcConfig
+	package com.demo.config;  
+	
+	import com.alibaba.druid.pool.DruidDataSource;  
+	import org.springframework.beans.factory.annotation.Value;  
+	import org.springframework.context.annotation.Bean;  
+	import org.springframework.context.annotation.PropertySource;  
+	import org.springframework.stereotype.Component;  
+	
+	@Component  
+	@PropertySource("classpath:jdbc.properties")  
+	public class JdbcConfig {  
+	    //** 主要就是实现，通过4要素让druid连接mysql，并返回一个druid的Bean  
+	    // 1. 表明身份@Component，说自己是子组件，让核心配置类，可以来加载我  
+	    // 2. jdbc主要的负责连接mysql的4要素，依赖druid  
+	    // 3. 为了方便维护，一般将4要素的值，写在一个jdbc.properties文件中  
+	    // 4. 在类名上方，用一个注解，导入这个properties文件 @PropertySource("classpath:jdbc.properties")    // 5. 因为setXX不能直接使用properties文件中的值，所以要中转一下。定义四个私有属性来注入 用@Value  
+	    // 6. 不要忘记，将druidDataSource标识为一个Bean ,直接在方法上方，写注解@Bean  
+	
+	    @Value("${jdbc.driver}")  
+	    private String driver;  
+	    @Value("${jdbc.url}")  
+	    private String url;  
+	    @Value("${jdbc.username}")  
+	    private String username;  
+	    @Value("${jdbc.password}")  
+	    private String password;  
+	      
+	    @Bean  
+	    public DruidDataSource druidDataSource(){  
+	        DruidDataSource dataSource = new DruidDataSource();  
+	        dataSource.setDriverClassName(driver);  
+	        dataSource.setUrl(url);  
+	        dataSource.setUsername(username);  
+	        dataSource.setPassword(password);  
+	        return dataSource;  
+	    }  
+	
+	}
+	```
+
+
+​	
+
+```java
+// MybatisConfig
+package com.demo.config;  
+
+import org.mybatis.spring.SqlSessionFactoryBean;  
+import org.mybatis.spring.annotation.MapperScan;  
+import org.springframework.context.annotation.Bean;  
+import org.springframework.context.annotation.Configuration;  
+import org.springframework.stereotype.Component;  
+
+import javax.sql.DataSource;  
+
+@Component  
+@MapperScan("com.demo.mapper")  
+public class MybatisConfig {  
+    // 1. 表明身份，同意让核心配置类，来加载我  
+    // 2. mybatis配置类的工作职责：  
+    //  2.1.扫描mapper实现自动代理 @MapperScan("com.demo.mapper")。  
+    //  2.2.创建一个sqlSessionFactoryBean,用一个方法实现SSFB,它是依赖druid对象的，所以要通过形参来注入dataSource  
+
+    @Bean  
+    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource){  
+        SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();  
+        sessionFactoryBean.setDataSource(dataSource);  
+        return sessionFactoryBean;  
+    }  
+}
+```
+
+
+
+```java
+// SpringConfig
+package com.demo.config;  
+
+import org.springframework.context.annotation.ComponentScan;  
+import org.springframework.context.annotation.Configuration;  
+import org.springframework.context.annotation.Import;  
+
+@Configuration  
+@Import({JdbcConfig.class, MybatisConfig.class})  
+@ComponentScan({"com.demo.service","com.demo.controller"})  
+public class SpringConfig {  
+    // 1. 表明身份，告诉系统，我是配置类@Configuration  
+    // 2. 加载子配置文件：@Import({JdbcConfig.class, MybatisConfig.class})  
+    // 3. spring本职工作是为了管理IOC容器，所以要把本项目中所有bean扫描进来，统一管理 @ComponentScan({"com.demo.service","com.demo.controller"})  
+}
+```
+
+
+
+10. 编写测试类
+
+```java
+//TestVideo
+package com.demo.test;  
+
+import com.demo.config.SpringConfig;  
+import com.demo.controller.VideoController;  
+import com.demo.entity.Video;  
+import com.demo.mapper.VideoMapper;  
+import com.demo.service.VideoService;  
+import org.junit.Test;  
+import org.junit.internal.runners.JUnit4ClassRunner;  
+import org.junit.runner.RunWith;  
+import org.springframework.beans.factory.annotation.Autowired;  
+import org.springframework.context.ApplicationContext;  
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;  
+import org.springframework.test.context.ContextConfiguration;  
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
+
+ 
+import java.util.List;  
+
+
+public class TestVideo {  
+     
+
+    @Test  
+    public void t1() {  
+        // 1. 加载spring核心配置类,拿到ioc容器  
+        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);  
+        // 2. 从容器中直接拿controller.service,mapper的Bean  
+        VideoMapper mapper = context.getBean(VideoMapper.class);  
+        // 3. 执行对象方法  
+        int i = mapper.deleteVideoById(1);  
+        System.out.println("i = " + i);  
+    }  
+      
+    @Test  
+    public void t2() {  
+        // 1. 加载spring核心配置类,拿到ioc容器  
+        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);  
+        // 2. 从容器中直接拿controller.service,mapper的Bean  
+        VideoService service = context.getBean(VideoService.class);  
+        // 3. 执行对象方法  
+        Boolean aBoolean = service.deleteVideoById(1);  
+        System.out.println("aBoolean = " + aBoolean);  
+    }  
+
+  
+
+
+    @Test  
+    public void t3() {  
+        // 1. 加载spring核心配置类,拿到ioc容器  
+        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);  
+        // 2. 从容器中直接拿controller.service,mapper的Bean  
+        VideoController controller = context.getBean(VideoController.class);  
+        // 3. 执行对象方法  
+        String s = controller.deleteVideoById(1);  
+        System.out.println("s = " + s);  
+      
+    }  
+
+}
+```
+
+
+
+#### pom.xml
+
+```xml
+<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/maven-v4_0_0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.jd</groupId>
+    <artifactId>myBook</artifactId>
+    <packaging>war</packaging>
+    <version>1.0-SNAPSHOT</version>
+    <properties>
+        <!--编译编码-->
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+    <dependencies>
+        <!--spring框架坐标-->
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-webmvc</artifactId>
+            <version>5.2.25.RELEASE</version>
+        </dependency>
+
+        <!-- 为了方便我们直接在test里测试。可以导入这个坐标-->
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-test</artifactId>
+            <version>5.2.25.RELEASE</version>
+        </dependency>
+
+        <!--以下是spring整合mybatis的依赖坐标-->
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-jdbc</artifactId>
+            <version>5.2.25.RELEASE</version>
+        </dependency>
+
+        <dependency>
+            <groupId>javax.servlet</groupId>
+            <artifactId>javax.servlet-api</artifactId>
+            <version>3.1.0</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+            <version>2.9.0</version>
+        </dependency>
+
+        <!--        // 自动set,get,toString-->
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.18.36</version>
+        </dependency>
+        <!--mybatis坐标-->
+        <dependency>
+            <groupId>org.mybatis</groupId>
+            <artifactId>mybatis</artifactId>
+            <version>3.5.16</version>
+        </dependency>
+
+        <!-- mysql驱动坐标-->
+        <dependency>
+            <groupId>com.mysql</groupId>
+            <artifactId>mysql-connector-j</artifactId>
+            <version>8.3.0</version>
+        </dependency>
+        <!-- junit测试框架的坐标-->
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.13.2</version>
+            <scope>test</scope>
+        </dependency>
+
+        <!--   mybatis-spring 依赖 spring-jdbc-->
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>druid</artifactId>
+            <version>1.1.20</version>
+        </dependency>
+
+        <!--   我们要将mybatis交给spring管理，就导一个mybatis-spring坐标-->
+
+        <dependency>
+            <groupId>org.mybatis</groupId>
+            <artifactId>mybatis-spring</artifactId>
+            <version>2.0.6</version>
+        </dependency>
+    </dependencies>
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.tomcat.maven</groupId>
+        <artifactId>tomcat7-maven-plugin</artifactId>
+        <version>2.2</version>
+        <configuration>
+          <path>/</path>
+          <port>80</port>
+          <uriEncoding>utf-8</uriEncoding>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+</project>
+
+```
+
+
+
+
+
+
+
+## SpringMVC
+### 1.快速入门
+
+1. 先设置好maven
+2. 创建maven的webapp模块项目
+3. 导入pom.xml文件
+4. 启动Tomcat
+5. 打开浏览器，Hello World
+
+### 2.完善结构
+
+1. 先设置好maven
+2. 创建maven的webapp模块项目
+3. 补全相关目录
+4. 导入pom.xml文件
+5. 编写实体类
+6. 编写controller类
+7. 编写springmvc-config和webconfig这两个配置类
+8. 改写controller类，绑定url路径，接受请求，响应数据
+9. 启动Tomcat
+10. 浏览器开始测试,第8步写好的url地址
+
+// 作业 ：
+
+1，建mvc项目 2.编写controller类，实现1，实现跳转，2返回字符串，3，返回对象 。4.接收普通参数，5，接收对象，6，接收json的集合
+
+
+
+### 3.请求与响应  ： 
+
+### 	浏览器请求方-》发出请求，java程序接收方：响应请求
+
+1. 响应方式 Response
+   1. 方法的返回值类型，即为响应数据的类型
+   2. 页面跳转 ，将页面地址以字符串返回 (了解)
+   3. 回写数据，结合@ResponseBody （掌握）
+      - 直接回写字符串    （应用）
+      - 直接回写json格式字符串（应用）
+      - 返回对象或集合，结合jackson和EnableWebMVC（应用）[重点]
+
+   
+
+2. 请求 Request
+
+     1. 发送请求的方法
+
+        1. get  ： 可直接浏览器在url中 拼接参数key=value
+        2. post :  表单或json
+        3. put ：表单或json
+        4. delete ：表单或json
+     2. 语法的形参，即为请求的参数
+     3. 请求参数类型(理解)
+
+        1. 基本类型：字符串，数值
+        2. 对象：如从表单得到一个学生对象的数据
+        3. 数组或集合：如从表单全选多个对象或数据
+        4. json格式 ： JavaScript方向提交的Json数据
+     4. 获得请求参数 （掌握）
+        - 获得基本类型参数(应用) 
+        - 获得entity类型参数(应用)
+        - 获得数组类型参数(应用)
+        - 获得集合类型参数(应用)
+
+          - 从url请求参数中获取  @RequestParam
+          - 从表单项中获取 ：通过类的属性封装  （了解）
+          - 从js发送的json中获取 （重点） @RequestBody
+        -  静态资源访问的开启(应用) ： 添加资源处理器
+        - 参数绑定注解@RequestParam(应用)
+        - Restful风格的参数的获取(应用)
+        
+          - GET：用于获取资源
+          - POST：用于新建资源
+          - PUT：用于更新资源
+          - DELETE：用于删除资源
+          - 例如：
+            - /user/1 GET ： 得到 id = 1 的 user
+            - /user/1 DELETE： 删除 id = 1 的 user
+            - /user/1 PUT： 更新 id = 1 的 user
+            - /user POST： 新增 user
+          - /user/{id} 占位符表示参数，@PathVariable注解进行占位符的匹配获取工作
+        - 类型转换器
+        
+          - 默认已经提供一些常用的类型转换
+          - 客户端提交的字符串转换成int型进行参数设置
+          - 自定义转换器
+          - ```java
+            public class DateConverter implements Converter<String, Date> {
+                public Date convert(String dateStr) {
+                    //将日期字符串转换成日期对象 返回
+                    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
+                    Date date = null;
+                    try {
+                        date = format.parse(dateStr);
+                    } catch (ParseException e) {
+                        e.printStackTrace();
+                    }
+                    return date;
+                }
+            }
+            
+            public void test(Date date) throws IOException {
+                    System.out.println(date);
+                }
+            ```
+        
+            
diff --git "a/\345\217\266\344\277\212\346\235\260/20241226 springmvc\345\237\272\347\241\200\344\275\277\347\224\250.md/20241226\344\270\250springmvc\345\237\272\347\241\200\344\275\277\347\224\250.md" "b/\345\217\266\344\277\212\346\235\260/20241226 springmvc\345\237\272\347\241\200\344\275\277\347\224\250.md/20241226\344\270\250springmvc\345\237\272\347\241\200\344\275\277\347\224\250.md"
new file mode 100644
index 0000000000000000000000000000000000000000..d0041ee9792e1598e657173d9e703a63666c82c4
--- /dev/null
+++ "b/\345\217\266\344\277\212\346\235\260/20241226 springmvc\345\237\272\347\241\200\344\275\277\347\224\250.md/20241226\344\270\250springmvc\345\237\272\347\241\200\344\275\277\347\224\250.md"	
@@ -0,0 +1,375 @@
+# 一、笔记部分
+
+## springmvc基础使用
+
+### --- 基础架构总览 ---
+
+- 配置 —— Config
+- 界面层 —— Controller
+- 网页资源 —— webapp
+
+![image-20241226105719017](https://gitee.com/Bluesky-kk/my-pic/raw/master/img/upgit_20241226_1735181842.png)
+
+### --- pom.xml ---
+
+```
+<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/maven-v4_0_0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>me.trytofeel</groupId>
+    <artifactId>SpringMvcProject</artifactId>
+    <packaging>war</packaging>
+    <version>1.0-SNAPSHOT</version>
+
+    <!--    <name>SpringMvcProject Maven Webapp</name>-->
+    <!--    <url>http://maven.apache.org</url>-->
+
+    <dependencies>
+        <dependency>
+            <groupId>com.mysql</groupId>
+            <artifactId>mysql-connector-j</artifactId>
+            <version>9.1.0</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.mybatis</groupId>
+            <artifactId>mybatis</artifactId>
+            <version>3.5.16</version>
+        </dependency>
+
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.13.2</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>druid</artifactId>
+            <version>1.2.24</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.18.36</version>
+            <scope>compile</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.mybatis</groupId>
+            <artifactId>mybatis-spring</artifactId>
+            <version>2.0.6</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-jdbc</artifactId>
+            <version>5.2.25.RELEASE</version>
+        </dependency>
+
+        <!-- 为了让Test类,也可以用DI注入需要的bean,故导入一个包 -->
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-test</artifactId>
+            <version>5.2.25.RELEASE</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework</groupId>
+            <artifactId>spring-webmvc</artifactId>
+            <version>5.2.25.RELEASE</version>
+        </dependency>
+
+        <!-- 依赖servlet -->
+        <dependency>
+            <groupId>javax.servlet</groupId>
+            <artifactId>javax.servlet-api</artifactId>
+            <version>3.1.0</version>
+            <!-- 避免插件版的tomcat与服务器上原有的tomcat冲突 -->
+            <scope>provided</scope>
+        </dependency>
+
+        <!-- 自动实现json格式的封装 -->
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+            <version>2.9.0</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.tomcat.maven</groupId>
+                <artifactId>tomcat7-maven-plugin</artifactId>
+                <version>2.2</version>
+                <!-- 修改端口和根目录 -->
+                <configuration>
+                    <port>80</port>
+                    <path>/</path>
+                    <!-- 请求的乱码，要去配tomcat插件-->
+                    <uriEncoding>utf-8</uriEncoding>
+                </configuration>
+            </plugin>
+        </plugins>
+
+        <!--            <finalName>SpringMvcProject</finalName>-->
+    </build>
+</project>
+```
+
+### --- tomcat快捷运行 ---
+
+于IDEA的运行配置下的 编辑配置
+
+![image-20241226110240087](https://gitee.com/Bluesky-kk/my-pic/raw/master/img/upgit_20241226_1735182163.png)
+
+添加maven运行配置
+
+- 需对应运行的指令 | 工作目录
+
+![image-20241226110351083](https://gitee.com/Bluesky-kk/my-pic/raw/master/img/upgit_20241226_1735182234.png)
+
+### 0. 配置 —— Config
+
+编写SpringMvc配置`SpringMvcConfig`
+
+```
+package me.trytofeel.config;
+
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.EnableWebMvc;
+
+@Configuration
+@ComponentScan("me.trytofeel.controller")
+@EnableWebMvc // 启用WebMvc 涵盖了各种强大功能
+public class SpringMvcConfig {
+}
+```
+
+#### 编写Web配置`WebConfig`
+
+```
+package me.trytofeel.config;
+
+import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
+
+// Tomcat 监听
+public class WebConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
+    @Override
+    protected Class<?>[] getRootConfigClasses() {
+        return new Class[0]; // 加载Spring配置类
+    }
+
+    @Override
+    protected Class<?>[] getServletConfigClasses() {
+        return new Class[]{SpringMvcConfig.class}; // 加载SpringMVC配置类
+    }
+
+    @Override
+    protected String[] getServletMappings() {
+        return new String[]{"/"}; // 设置网站要接管的目录
+    }
+}
+```
+
+### 1. 界面层 —— Controller
+
+#### `UserController`
+
+```
+package me.trytofeel.controller;
+
+import me.trytofeel.bean.User;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Controller
+@ResponseBody // 这个注解，声明只是返回数据体本身，写在类上，对所有方法生效
+@RequestMapping("/user") // 类的上方，写@RequestMapping相当于给url加了一层目录 => localhost/user/XXXXXX
+public class UserController {
+    // controller 以前只是去依赖service干活，现在在MVC模式下，多了一个绑定网址的功能
+
+    // 1.页面跳转
+    // 如何让这个方法绑定一个url地址，通过@RequestMapping("/请求内容")
+    // 浏览器向服务器发送的是请求
+    @RequestMapping("/t1") //  http://localhost:80/t1 | 当浏览器发送此请求的时候调用这个方法
+    public String testA() {
+        return "index.jsp"; // 如果直接返回字符串，这个字符串代表的是一个视图页面
+    }
+
+    // 2.回写数据，结合@ResponseBody(掌握)
+    // 此时这个方法，只是想单纯返回字符串本身，而不是它代表的页面，要加一个注解
+    @RequestMapping(value = "t2", produces = "text/html;charset=utf-8") // 请求绑定的时候，指定编码
+    public String t2() {
+        return "疯狂KFC给我打钱!"; // 响应的数据，中文会乱码，需要指定编码
+    }
+
+    // 直接回写JSON格式字符串
+    @RequestMapping("getUser")
+    public User getUser() {
+        // 结合jackson，导坐标后要在SpringMvcConfig 添加@EnableWebMvc注解
+        return new User(1, "张三"); // @EnableWebMvc 会自动将对象转换成JSON
+    }
+
+    // 用集合返回一堆User
+    @RequestMapping("getUserList") // 启用@EnableWebMvc之后还会自动处理编码问题
+    public List<User> getUserList() {
+        ArrayList<User> users = new ArrayList<User>();
+        users.add(new User(1, "张三"));
+        users.add(new User(2, "张三"));
+        users.add(new User(3, "张三"));
+        users.add(new User(4, "张三"));
+        users.add(new User(5, "张三"));
+        return users;
+    }
+
+    // 用集合返回一堆User
+    @RequestMapping("getUserById") // 启用@EnableWebMvc之后还会自动处理编码问题
+    public User getUserById(int id) { // 方法的形参，就是url的请求参数，要求两个参数名称一致 | .../user/getUserListById?id=XXX
+        ArrayList<User> users1 = new ArrayList<User>();
+        users1.add(new User(1, "张三"));
+        users1.add(new User(2, "张三"));
+        users1.add(new User(3, "张三"));
+        users1.add(new User(4, "张三"));
+        users1.add(new User(5, "张三"));
+        return users1.get(id - 1);
+    }
+
+}
+```
+
+#### 
+
+```
+TestController
+package me.trytofeel.controller;
+
+import me.trytofeel.bean.User;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Controller
+@ResponseBody
+@RequestMapping(produces = "application/json;charset=utf-8")
+public class TestController {
+
+    // 获取基本类型
+    @RequestMapping("string") // .../string
+    public void getString(String username, int id) {
+        System.out.println("username = " + username);
+        System.out.println("id = " + id);
+//        return "你给我传了" + username + "和" + id;
+    }
+
+    // 获得实体类型
+    @RequestMapping("toUser")
+    public void getString(User user) { // 浏览器直接传递对象的属性，方法形参写对象类型，就会自动创建这个对象
+        System.out.println("user = " + user); // 请求的乱码，要去配tomcat插件
+    }
+
+    // 获得数组类型
+    @RequestMapping("array") // array?hobby=aaa&hobby=bb&hobby=cc
+    public String getArray(String[] hobby) {
+        List<String> strings = Arrays.asList(hobby);
+        return strings.toString();
+    }
+
+    // 获得集合类型
+    @RequestMapping("list") // list?hobby=aaa&hobby=bb&hobby=cc
+    public String getList(@RequestParam List<String> hobby) {
+        return hobby.toString();
+    }
+
+    @RequestMapping("test1")
+    public String test1(@RequestParam(value = "user", required = false, defaultValue = "六六") String username) { // 取别名 required = false (非必填) defaultValue = "六六" (默认值) | ?user=王维 ≠ ?username=王维
+        return username;
+    }
+
+    // 从js发送的json中获取
+    @RequestMapping("getUser")
+    public User getUser(@RequestBody User user) { // 如果 要以 Json格式来接收参数，就需要一个注解
+        return user;
+    }
+
+    // 获取json数组
+    @RequestMapping("getUserList")
+    public List<User> getUserList(@RequestBody List<User> userList) {
+        return userList;
+    }
+
+}
+```
+
+### --- Postman ---
+
+- 传入json参数
+
+![image-20241226111240396](https://gitee.com/Bluesky-kk/my-pic/raw/master/img/upgit_20241226_1735182761.png)
+
+```
+{
+	"userId": 111,
+	"username": "测试"
+}
+```
+
+- 传入json数组
+
+![image-20241226111329774](https://gitee.com/Bluesky-kk/my-pic/raw/master/img/upgit_20241226_1735182811.png)
+
+```
+[
+	{
+		"userId": 111,
+		"username": "测试1"
+	},
+	{
+		"userId": 222,
+		"username": "测试2"
+	},
+	{
+		"userId": 333,
+		"username": "测试3"
+	}
+]
+```
+
+# 二、作业部分
+
+### 1. 实现跳转
+
+![image-20241226111031532](https://gitee.com/Bluesky-kk/my-pic/raw/master/img/upgit_20241226_1735182632.png)
+
+### 2. 返回字符串
+
+![image-20241226111143918](https://gitee.com/Bluesky-kk/my-pic/raw/master/img/upgit_20241226_1735182705.png)
+
+### 3. 返回对象
+
+![image-20241226111721816](https://gitee.com/Bluesky-kk/my-pic/raw/master/img/upgit_20241226_1735183043.png)
+
+### 4. 接收普通参数
+
+![image-20241226111646948](https://gitee.com/Bluesky-kk/my-pic/raw/master/img/upgit_20241226_1735183007.png)
+
+### 5. 接收对象
+
+![image-20241226111843193](https://gitee.com/Bluesky-kk/my-pic/raw/master/img/upgit_20241226_1735183124.png)
+
+### 6. 接收json的集合
+
+![image-20241226111930521](https://gitee.com/Bluesky-kk/my-pic/raw/master/img/upgit_20241226_1735183171.png)
\ No newline at end of file