删除了小写的文件夹

后端/spring/SpringFramework/spring.md

@@ -1,2019 +0,0 @@
-> [TOC]
-
-# 1、Spring
-
-***
-
-## 1.1、简介
-
-- Spring：春天------>给软件行业带来了春天！
-
-- 2002，首次推出了Spring框架的雏形：interface21框架！
-
-- Spring框架即以interface21框架为基础，经过重新设计，并不断丰富其内涵，于2004年3月24日发布了1.0正式版。
-
-- **Rod Johnson**，Spring Framework创始人，著名作者。很难想象Rod Johnson的学历，真的让好多人大吃一惊，他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。
-
-- Spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架！
-
-- SSH：Struct2 + Spring + Hibernate!
-
-- SSM：SpringMVC + Spring + Mybatis!
-
-官网：https://spring.io/projects/spring-framework#overview
-
-官方下载地址：https://repo.spring.io/release/org/springframework/spring/
-
-GitHub：https://github.com/spring-projects/spring-framework
-
-```xml
-        <dependency>
-            <groupId>org.springframework</groupId>
-            <artifactId>spring-webmvc</artifactId>
-            <version>5.3.8</version>
-        </dependency>
-        <dependency>
-            <groupId>org.springframework</groupId>
-            <artifactId>spring-jdbc</artifactId>
-            <version>5.3.8</version>
-        </dependency>
-```
-
-## 1.2、 优点
-
-- Spring是一个开源的免费的框架（容器）！
-- Spring是一个轻量级的、非入侵式的框架！
-- 控制反转（IOC），面向切面编程（AOP）！
-- 支持事务的处理，对框架整合的支持！
-
-**总结一句话：Spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架！**
-
-## 1.3、组成
-
-![image-20220319142033626](assets/image-20220319142033626.png)
-
-## 1.4 、拓展
-
-现代化的Java开发！说白了就是基于Spring的开发！
-
-- Spring Boot
-  - 一个快速开发的脚手架
-  - 基于SpringBoot可以快速的开发单个微服务
-  - 约定大于配置
-- Spring Cloud
-  - SpringCloud是基于SpringBoot实现的
-
-因为现在大多数公司都在使用SpringBoot进行快速开发，学习SpringBoot的前提，需要完全掌握Spring以及SpringMVC！**承上启下的作用！**
-
-**弊端：发展了太久之后，违背了原来的理念！配置十分繁琐，人称：“配置地狱”**
-
-# 2、IOC理论推导
-
-***
-
-1. UserDao 接口
-
-   ```java
-   public interface UserDao {
-       void getUser();
-   }
-   ```
-
-2. UserDaoImpl 实现类
-
-   ```java
-   public class UserDaoImpl implements UserDao {
-       public void getUser() {
-           System.out.println("默认获取用户数据");
-       }
-   }
-   ```
-
-3. UserService 业务接口
-
-   ```java
-   public interface UserService {
-       void getUser();
-   }
-   ```
-
-4. UserServiceImpl 业务实现类
-
-   ```java
-   public class UserServiceImpl implements UserService {
-   
-       private UserDao userDao = new UserDaoImpl();
-   
-       public void getUser() {
-           userDao.getUser();
-       }
-   }
-   ```
-
-5. 测试
-
-   ```java
-   public class MyTest {
-       public static void main(String[] args) {
-   
-           //用户实际调用的是业务层，dao层他们不需要接触！
-           UserService userService = new UserServiceImpl();
-           userService.getUser();
-       }
-   }
-   ```
-
-在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改原代码！如果程序代码量十分大，修改一次的成本代价十分昂贵！
-
-![image-20220319144549608](assets/image-20220319144549608.png)
-
-我们使用一个Set接口实现，已经发生了革命性的变化！
-
-![image-20220319144559312](assets/image-20220319144559312.png)
-
-```java
-    private UserDao userDao;
-
-    // 利用set进行动态实现值的注入！
-    public void setUserDao(UserDao userDao) {
-        this.userDao = userDao;
-    }
-```
-
-- 之前，程序是主动创建对象！控制权在程序员手上！
-- 使用了set注入后，程序不再具有主动性，而是变成了被动的接收对象！
-
-这种思想，从本质上解决了问题，我们程序猿不用再去管理对象的创建了。系统的耦合性大大降低~，可以更加专注的在业务的实现上！这是IOC的原型！
-
-**IOC本质**
-
-**控制反转IoC（Inversion of Control），是一种设计思想，DI（依赖注入）是实现IoC的一种方法，**也有人认为DI只是IoC的另一种说法。没有IoC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。
-
-采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
-**控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection，DI）。**
-
-# 3、HelloSpring
-
-***
-
-1. 新建一个maven项目，编写实体类
-
-```java
-public class Hello {
-    private String str;
-
-    public String getStr() {
-        return str;
-    }
-
-    public void setStr(String str) {
-        this.str = str;
-    }
-
-    @Override
-    public String toString() {
-        return "Hello{" +
-                "str='" + str + '\'' +
-                '}';
-    }
-}
-```
-
-2. 编写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
-        https://www.springframework.org/schema/beans/spring-beans.xsd">
-
-
-    <!--使用Spring来创建对象，在Spring这些都称为Bean
-    类型 变量名 = new 类型();
-    Hello hello = new Hello();
-
-    id = 变量名
-    class = new的对象
-    property 相当于给对象中的属性设置一个值！
-    ref：引用Spring创建好的对象
-    value： 具体的值，基本数据类型
-        -->
-    <bean id="hello" class="com.kuang.pojo.Hello">
-        <property name="str" value="Spring"/>
-    </bean>
-</beans>
-```
-
-3. 测试
-
-```java
-public class MyTest {
-    public static void main(String[] args) {
-        //获取Spring的上下文对象！
-        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
-
-        //我们的对象现在都在Spring中的管理了，我们需要使用，直接去里面取出来就可以！
-        Hello hello = (Hello) context.getBean("hello");
-        System.out.println(hello.toString());
-    }
-}
-```
-
-**思考问题？**
-
-- Hello对象是谁创建的？
-  Hello对象是由Spring创建的。
-- Hello对象的属性是怎么设置的？
-  Hello对象的属性是由Spring容器设置的。
-
-这个过程就叫控制反转：
-
-**控制**：谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的。
-
-**反转**：程序本身不创建对象，而变成被动的接收对象。
-
-**依赖注入**：就是利用set方法来进行注入的。
-
-IOC是一种编程思想，由主动的编程变成被动的接收。
-
-可以通过new ClassPathXmlApplicationContext去浏览一下底层源码。
-
-**OK，到了现在，我们彻底不用在程序中去改动了，要实现不同的操作，只需要在xml配置文件中进行修改，所谓的IOC，一句话搞定：对象由Spring来创建，管理，装配！**
-
-# 4、IOC创建对象的方式
-
-***
-
-1. 使用无参构造创建对象，默认！
-
-2. 假设我们要使用有参构造创建对象。
-
-   1. 下标赋值
-
-   ```xml
-   <!--第一种方式：下标赋值    -->
-   <bean id="user" class="com.kuang.pojo.User">
-       <constructor-arg index="0" value="狂神说Java"/>
-   </bean>
-   ```
-
-   2. 类型
-
-   ```xml
-   <!--第二种方式：通过类型的创建，不建议使用    -->
-   <bean id="user" class="com.kuang.pojo.User">
-       <constructor-arg type="java.lang.String" value="lifa"/>
-   </bean>
-   ```
-
-   3. 参数名
-
-   ```xml
-   <!--第三种方式：直接通过参数名来设置    -->
-   <bean id="user" class="com.kuang.pojo.User">
-       <constructor-arg name="name" value="李发"/>
-   </bean>
-   ```
-
-总结：在配置文件加载的时候，容器中管理的所有对象就已经初始化了！只有一份！！！
-
-```java
-        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
-        User user = (User) context.getBean("user");
-        user.setName("123");
-        User user2 = (User) context.getBean("user");
-        System.out.println(user == user2); // true
-        System.out.println(user2.getName()); // 123
-```
-
-# 5、Spring配置
-
-***
-
-## 5.1 、别名
-
-```xml
-    <!--别名，如果添加了别名，我们也可以使用别名获取到这个对象-->
-    <alias name="user" alias="userNew"/>
-```
-
-## 5.2 、Bean配置
-
-```xml
-    <!--
-    id：bean的唯一标识符，也就是相当于我们学的对象名
-    class：bean对象所对应的全限定名：包名+类名
-    name：也是别名，而且name可以同时取多个别名
-    可以通过空格，逗号，分号分隔
-        -->
-    <bean id="userT" class="com.kuang.pojo.UserT" name="user2 u2,u3;u4">
-        <property name="name" value="黑心白莲"/>
-    </bean>
-```
-
-## 5.3、 import
-
-这个import。一般用于团队开发使用，它可以将多个配置文件，导入合并为一个。
-假设，现在项目中有多个人开发，这三个人负责不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.xml合并为一个总的！
-
-- 张三
-
-- 李四
-
-- 王五
-
-- applicationContext.xml
-
-  ```xml
-  <import resource="bean.xml"/>
-  <import resource="bean2.xml"/>
-  <import resource="bean3.xml"/>
-  ```
-
-使用的时候，直接使用总的配置就可以了。
-
-# 6、依赖注入
-
-***
-
-## 6.1 、构造器注入
-
-前面已经介绍过，参考**4、IOC创建对象的方式**
-
-## 6.2 、Set方式注入【重点】
-
-- 依赖注入：Set注入
-  - 依赖：bean对象的创建依赖于容器！
-  - 注入：bean对象中的所有属性，由容器来注入！
-
-【环境搭建】
-
-1. 复杂类型
-
-```java
-public class Address {
-    private String address;
-
-    public String getAddress() {
-        return address;
-    }
-
-    public void setAddress(String address) {
-        this.address = address;
-    }
-}
-```
-
-2. 真实测试对象
-
-```java
-public class Student {
-
-    private String name;
-    private Address address;
-    private String[] books;
-    private List<String> hobbies;
-    private Map<String,String> card;
-    private Set<String> games;
-    private String wife;
-    private Properties info;
-}
-```
-
-3. beans.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
-        https://www.springframework.org/schema/beans/spring-beans.xsd">
-
-    <bean id="student" class="com.kuang.pojo.Student">
-        <!--第一种：普通值注入，value        -->
-        <property name="name" value="黑心白莲"/>
-    </bean>
-</beans>
-```
-
-4. 测试类
-
-```java
-public class MyTest {
-    public static void main(String[] args) {
-        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
-
-        Student student = (Student) context.getBean("student");
-        System.out.println(student.getName());
-    }
-}
-```
-
-5. 完善注入信息
-
-```xml
-    <bean id="address" class="com.kuang.pojo.Address">
-        <property name="address" value="西安"/>
-    </bean>
-
-    <bean id="student" class="com.kuang.pojo.Student">
-        <!--第一种：普通值注入，value        -->
-        <property name="name" value="黑心白莲"/>
-
-        <!--第二种：        -->
-        <property name="address" ref="address"/>
-
-        <!--数组        -->
-        <property name="books">
-            <array>
-                <value>红楼梦</value>
-                <value>西游记</value>
-                <value>水浒传</value>
-                <value>三国演义</value>
-            </array>
-        </property>
-
-        <!--List        -->
-        <property name="hobbies">
-            <list>
-                <value>打篮球</value>
-                <value>看电影</value>
-                <value>敲代码</value>
-            </list>
-        </property>
-
-        <!--Map        -->
-        <property name="card">
-            <map>
-                <entry key="身份证" value="123456789987456321"/>
-                <entry key="银行卡" value="359419496419481649"/>
-            </map>
-        </property>
-
-        <!--Set        -->
-        <property name="games">
-            <set>
-                <value>LOL</value>
-                <value>COC</value>
-                <value>BOB</value>
-            </set>
-        </property>
-
-        <!--NULL        -->
-        <property name="wife">
-            <null/>
-        </property>
-
-        <!--Properties        -->
-        <property name="info">
-            <props>
-                <prop key="driver">20191029</prop>
-                <prop key="url">102.0913.524.4585</prop>
-                <prop key="user">黑心白莲</prop>
-                <prop key="password">123456</prop>
-            </props>
-        </property>
-
-    </bean>
-```
-
-## 6.3 、拓展方式注入
-
-我们可以使用p命名空间和c命名空间进行注入
-
-官方解释：
-
-![在这里插入图片描述](assets/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpNjQzOTM3NTc5,size_16,color_FFFFFF,t_70#pic_center.png)
-
-使用：
-
-```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"
-       xmlns:p="http://www.springframework.org/schema/p"
-       xmlns:c="http://www.springframework.org/schema/c"
-       xsi:schemaLocation="http://www.springframework.org/schema/beans
-        https://www.springframework.org/schema/beans/spring-beans.xsd">
-
-    <!--p命名空间注入，可以直接注入属性的值：property-->
-    <bean id="user" class="com.kuang.pojo.User" p:name="黑心白莲" p:age="20"/>
-
-    <!--c命名空间注入，通过构造器注入：constructor-args-->
-    <bean id="user2" class="com.kuang.pojo.User" c:name="狂神" c:age="22"/>
-
-</beans>
-```
-
-测试：
-
-```java
-    @Test
-    public void test2(){
-        ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
-
-        User user = context.getBean("user",User.class);
-        System.out.println(user);
-
-        User user2 = context.getBean("user2",User.class);
-        System.out.println(user2);
-    }
-```
-
-注意点：p命名空间和c命名空间不能直接使用，需要导入xml约束
-
-```xml
-       xmlns:p="http://www.springframework.org/schema/p"
-       xmlns:c="http://www.springframework.org/schema/c"
-```
-
-## 6.4 、bean的作用域
-
-![在这里插入图片描述](assets/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpNjQzOTM3NTc5,size_16,color_FFFFFF,t_70#pic_center.png)
-
-1. 单例模式（Spring默认机制）
-
-```xml
-<bean id="user2" class="com.kuang.pojo.User" c:name="狂神" c:age="22" scope="singleton"/>
-```
-
-2. 原型模式：每次从容器中get的时候，都会产生一个新对象！
-
-```xml
-<bean id="user2" class="com.kuang.pojo.User" c:name="狂神" c:age="22" scope="prototype"/>
-```
-
-3. 其余的request、session、application、这些只能在web开发中用到！
-
-# 7、bean的自动装配
-
-***
-
-- 自动装配是Spring满足bean依赖的一种方式
-- Spring会在上下文中自动寻找，并自动给bean装配属性
-
-在Spring中有三种装配的方式：
-
-1. 在xml中显式的配置；
-2. 在java中显式配置；
-3. 隐式的自动装配bean【重要】
-
-## 7.1 、测试
-
-环境搭建：创建项目，一个人有两个宠物！
-
-```xml
-    <bean id="cat" class="com.kuang.pojo.Cat"/>
-    <bean id="dog" class="com.kuang.pojo.Dog"/>
-
-    <bean id="people" class="com.kuang.pojo.People">
-        <property name="name" value="小白莲"/>
-        <property name="cat" ref="cat"/>
-        <property name="dog" ref="dog"/>
-    </bean>
-```
-
-## 7.2、 ByName自动装配
-
-```xml
-        <!--
-        byName：会自动在容器上下文中查找，和自己对象set方法后面的值对应的bean id！
-        这里的id值得是set后面的值，会自动转换为小写
-            -->
-        <bean id="people" class="com.kuang.pojo.People" autowire="byName">
-            <property name="name" value="小白莲"/>
-        </bean>
-```
-
-## 7.3 、ByType自动装配
-
-```xml
-        <!--
-        byType：会自动在容器上下文中查找，和自己对象属性类型相同的bean！
- 必须唯一，不能有两个
-            -->
-        <bean id="people" class="com.kuang.pojo.People" autowire="byType">
-            <property name="name" value="小白莲"/>
-        </bean>
-```
-
-小结：
-
-- ByName的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致！
-- ByType的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致！
-
-## 7.4 、使用注解实现自动装配
-
-jdk1.5支持的注解，Spring2.5就支持注解了！
-
-要使用注解须知：
-
-1. 导入约束
-
-2. 配置注解的支持
-
-   ```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"
-          xmlns:context="http://www.springframework.org/schema/context"
-          xsi:schemaLocation="http://www.springframework.org/schema/beans
-   	        https://www.springframework.org/schema/beans/spring-beans.xsd
-   	        http://www.springframework.org/schema/context
-   	        https://www.springframework.org/schema/context/spring-context.xsd">
-   		
-   		<!--开启注解的支持    -->
-           <context:annotation-config/>
-   </beans>
-   ```
-
-**@Autowired**
-
-直接在属性上使用即可！也可以在set方法上使用！
-
-使用Autowried我们就可以不用编写set方法了，前提是你这个自动配置的属性在IOC(Spring)容器中存在，且符合名字ByName！
-
-**科普：**
-
-> @Nullable 字段标记了了这个注解，说明这个字段可以为null;
-
-```java
-public @interface Autowired {
-    boolean required() default true;
-}
-```
-
-测试代码
-
-```java
-public class People {
-    //如果显式定义了Autowired的required属性为false，说明这个对象可以为null，否则不允许为空
-    @Autowired(required = false)
-    private Cat cat;
-    @Autowired
-    private Dog dog;
-    private String name;
-}
-```
-
-如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候，我们可以使用@Qualifier(value = “xxx”)去配置@Autowired的使用，指定一个唯一的bean对象注入！
-
-```java
-public class People {
-    @Autowired
-    @Qualifier(value = "cat111")
-    private Cat cat;
-    @Autowired
-    @Qualifier(value = "dog222")
-    private Dog dog;
-    private String name;
-}
-```
-
-**@Resource**
-
-```java
-public class People {
-
-    @Resource
-    private Cat cat;
-
-    @Resource
-    private Dog dog;
-}
-```
-
-小结：
-
-@Resource和@Autowired的区别：
-
-- 都是用来自动装配的，都可以放在属性字段上
-- @Autowired通过byType的方式实现，而且必须要求这个对象存在！【常用】
-- @Resource默认通过byName的方式实现，如果找不到名字，则通过byType实现！如果两个都找不到的情况下，就报错！【常用】
-- 执行顺序不同：@Autowired通过byType的方式实现。@Resource默认通过byName的方式实现
-
-# 8、使用注解开发
-
-***
-
-在Spring4之后，要使用注解开发，必须要保证aop的包导入了
-
-![image-20220320142136644](assets/image-20220320142136644.png)
-
-使用注解需要导入约束，配置注解的支持！
-
-```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"
-	       xmlns:context="http://www.springframework.org/schema/context"
-	       xsi:schemaLocation="http://www.springframework.org/schema/beans
-		        https://www.springframework.org/schema/beans/spring-beans.xsd
-		        http://www.springframework.org/schema/context
-		        https://www.springframework.org/schema/context/spring-context.xsd">
-			
-			<!--开启注解的支持    -->
-	        <context:annotation-config/>
-	</beans>
-```
-
-> **Bean的实现**
-
-我们之前都是使用 bean 的标签进行bean注入，但是实际开发中，我们一般都会使用注解！
-
-1. 配置扫描那些包下的注解
-
-```xml
-<!--指定注解扫描包-->
-<context:component-scan base-package="com.kuang.pojo"/>
-```
-
-2. 在指定包下编写类，增加注释
-
-```java
-@Component("user")
-// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
-public class User {
-   public String name = "秦疆";
-}
-```
-
-3. 测试
-
-```java
-@Test
-public void test(){
-   ApplicationContext applicationContext =
-       new ClassPathXmlApplicationContext("beans.xml");
-   User user = (User) applicationContext.getBean("user");
-   System.out.println(user.name);
-}
-```
-
-> **属性注入**
-
-使用注解注入属性
-
-1. 可以不用提供set方法，直接在直接名上添加@value("值")
-
-   ```java
-   @Component("user")
-   // 相当于配置文件中 <bean id="user" class="当前注解的类"/>
-   public class User {
-      @Value("秦疆")
-      // 相当于配置文件中 <property name="name" value="秦疆"/>
-      public String name;
-   }
-   ```
-
-2. 如果提供了set方法，在set方法上添加@value("值")
-
-   ```java
-   @Component("user")
-   public class User {
-   
-      public String name;
-   
-      @Value("秦疆")
-      public void setName(String name) {
-          this.name = name;
-     }
-   }
-   ```
-
-> **衍生注解**
-
-我们这些注解，就是替代了在配置文件当中配置步骤而已！更加的方便快捷！
-
-**@Component三个衍生注解**
-
-为了更好的进行分层，Spring可以使用其它三个注解，功能一样，目前使用哪一个功能都一样。
-
-- @Controller： web层
-- @Service：service层
-- @Repository：dao层
-
-写上这些注释，就相当于将这个类交给Spring管理装配了！
-
-> **自动装配注解**
-
-在Bean的自动装配已经讲过了，可以回顾！
-
-- @Autowired：自动装配通过类型，名字。如果Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value = "xxx")去配置。
-- @Nullable 字段标记了了这个注解，说明这个字段可以为null;
-- @Resource：自动装配通过名字，类型。
-
-> **作用域**
-
-@scope
-
-- singleton：默认的，Spring会采用单例模式创建这个对象。关闭工厂 ，所有的对象都会销毁。
-- prototype：多例模式。关闭工厂 ，所有的对象不会销毁。内部的垃圾回收机制会回收
-
-```java
-@Component
-@Scope("singleton")
-public class User {
-
-    //相当于  <property name="name" value="白莲"/>
-    @Value("白莲")
-    public String name;
-}
-```
-
-> **小结**
-
-**xml与注解：**
-
-- xml更加万能，适用于任何场合！维护简单方便
-- 注解不是自己类使用不了，维护相队复杂！
-
-**xml与注解最佳实践：**
-
-- xml用来管理bean；
-- 注解只负责完成属性的注入；
-- 我们在使用的过程中，只需要注意一个问题：必须让注解生效，就需要开启注解的支持
-
-```xml
-    <!--指定要扫描的包，这个包下的注解就会生效-->
-    <context:component-scan base-package="com.kuang"/>
-    <!--开启注解的支持    -->
-    <context:annotation-config/>
-```
-
-作用：
-
-- 进行注解驱动注册，从而使注解生效
-- 用于激活那些已经在spring容器里注册过的bean上面的注解，也就是显示的向Spring注册
-- 如果不扫描包，就需要手动配置bean
-- 如果不加注解驱动，则注入的值为null！
-
-# 9、使用Java的方式配置Spring
-
-***
-
-JavaConfig 原来是 Spring 的一个子项目，它通过 Java 类的方式提供 Bean 的定义信息，在 Spring4 的版本， JavaConfig 已正式成为 Spring4 的核心功能 。
-
-实体类
-
-```java
-//这里这个注解的意思，就是说明这个类被Spring接管了，注册到了容器中
-@Component
-public class User {
-    private String name;
-
-    public String getName() {
-        return name;
-    }
-
-    @Value("黑心白莲") //属性注入值
-    public void setName(String name) {
-        this.name = name;
-    }
-
-    @Override
-    public String toString() {
-        return "User{" +
-                "name='" + name + '\'' +
-                '}';
-    }
-}
-```
-
-配置文件
-
-```java
-// 这个也会Spring容器托管，注册到容器中，因为它本来就是一个@Component
-// @Configuration代表这是一个配置类，就和我们之前看的beans.xml
-@Configuration
-@ComponentScan("com.kuang.pojo")
-// 引入多个配置类，合并
-@Import(KuangConfig2.class)
-public class KuangConfig {
-
-    // 注册一个bean，就相当于我们之前写的一个bean标签
-    // 这个方法的名字，就相当于bean标签中id属性
-    // 这个方法的返回值，就相当于bean标签中的class属性
-    @Bean
-    public User user(){
-        return new User(); // 就是返回要注入到bean的对象！
-    }
-}
-```
-
-测试类
-
-```java
-public class MyTest {
-    public static void main(String[] args) {
-
-        //如果完全使用了配置类方式去做，我们就只能通过 AnnotationConfig 上下文来获取容器，通过配置类的class对象加载！
-        ApplicationContext context = new AnnotationConfigApplicationContext(KuangConfig.class);
-
-        User user = context.getBean("user", User.class);
-        System.out.println(user.getName());
-    }
-}
-```
-
-这种纯Java的配置方式，在SpringBoot中随处可见！
-
-# 10、代理模式 
-
-***
-
-为什么要学习代理模式？因为这就是SpringAOP的底层！【SpringAOP和SpringMVC】
-
-代理模式的分类：
-
-- 静态代理
-- 动态代理
-
-![image-20220320202519970](assets/image-20220320202519970.png)
-
-## 10.1、静态代理
-
-角色分析：
-
-- 抽象角色：一般会使用接口或者抽象类来解决
-- 真实角色：被代理的角色
-- 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
-- 客户：访问代理对象的人！
-
-代码步骤：
-
-1. 接口
-
-```java
-//租房
-public interface Rent {
-    public void rent();
-}
-```
-
-2. 真实角色
-
-```java
-//房东
-public class Host implements Rent{
-    public void rent() {
-        System.out.println("房东出租房子！");
-    }
-}
-```
-
-3. 代理角色
-
-```java
-public class Proxy implements Rent{
-    private Host host;
-
-    public Proxy() {
-    }
-
-    public Proxy(Host host) {
-        this.host = host;
-    }
-
-    public void rent() {
-        host.rent();
-        seeHouse();
-        sign();
-        fee();
-    }
-
-    //看房
-    public void seeHouse(){
-        System.out.println("中介带着看房子！");
-    }
-
-    //签合同
-    public void sign(){
-        System.out.println("和中介签署租赁合同！");
-    }
-
-    //收费用
-    public void fee(){
-        System.out.println("中介收取费用！");
-    }
-}
-```
-
-4. 客户端访问代理角色
-
-```java
-public class Client {
-    public static void main(String[] args) {
-        //房东要出租房子
-        Host host = new Host();
-//        host.rent();
-
-        //代理，中介帮房东出租房子，并且代理角色一般会有一些附属操作！
-        Proxy proxy = new Proxy(host);
-
-        //不用面对房东，直接找中介租房即可！
-        proxy.rent();
-    }
-}
-```
-
-代理模式的好处：
-
-- 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
-- 公共角色就交给代理角色！实现了业务的分工！
-- 公共业务发生扩展的时候，方便集中管理！
-
-缺点：
-
-- 一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率会变低~
-
-## 10.2、加深代理的理解
-
-代码步骤：
-
-1. 接口
-
-   ```java
-   public interface UserService {
-       public void add();
-       public void delete();
-       public void update();
-       public void query();
-   }
-   ```
-
-2. 真实角色
-
-   ```java
-   //真实角色
-   public class UserServiceImpl implements UserService{
-       public void add() {
-           System.out.println("增加了一个用户！");
-       }
-   
-       public void delete() {
-           System.out.println("删除了一个用户！");
-       }
-   
-       public void update() {
-           System.out.println("修改了一个用户！");
-       }
-   
-       public void query() {
-           System.out.println("查询了一个用户！");
-       }
-   }
-   ```
-
-3. 代理角色
-
-   ```java
-   public class UserServiceProxy implements UserService{
-       private UserServiceImpl userService;
-   
-       public void setUserService(UserServiceImpl userService) {
-           this.userService = userService;
-       }
-   
-       public void add() {
-           log("add");
-           userService.add();
-       }
-   
-       public void delete() {
-           log("delete");
-           userService.delete();
-       }
-   
-       public void update() {
-           log("update");
-           userService.update();
-       }
-   
-       public void query() {
-           log("query");
-           userService.query();
-       }
-   
-       public void log(String msg){
-           System.out.println("[Debug] 使用了一个"+msg+"方法");
-       }
-   }
-   ```
-
-4. 客户端访问代理角色
-
-   ```java
-   public class Client {
-       public static void main(String[] args) {
-           UserServiceImpl userService = new UserServiceImpl();
-   
-           UserServiceProxy proxy = new UserServiceProxy();
-           proxy.setUserService(userService);
-   
-           proxy.delete();
-       }
-   }
-   ```
-
-聊聊AOP
-
-![image-20220320205008091](assets/image-20220320205008091.png)
-
-## 10.3、动态代理
-
-- 动态代理和静态代理角色一样
-- 动态代理的代理类是动态生成的，不是我们直接写好的！
-- 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
-  - 基于接口 — JDK动态代理【我们在这里使用】
-  - 基于类：cglib
-  - java字节码实现：javassist
-
-需要了解两个类：Proxy：代理；InvocationHandler：调用处理程序。
-
-代码步骤：
-
-1. 接口
-
-   ```java
-   public interface Rent {
-       public void rent();
-   }
-   ```
-
-2. 真实角色
-
-   ```java
-   public class Host implements Rent{
-       public void rent() {
-           System.out.println("房东要出租房子！");
-       }
-   }
-   ```
-
-3. ProxyInvocationHandler类
-
-   ```java
-   //我们会用这个类，自动生成代理类！
-   public class ProxyInvocationHandler implements InvocationHandler {
-       //被代理的接口
-       private Rent rent;
-   
-       public void setRent(Rent rent) {
-           this.rent = rent;
-       }
-   
-       //生成得到代理类
-       public Object getProxy(){
-           return Proxy.newProxyInstance(this.getClass().getClassLoader(),
-                   rent.getClass().getInterfaces(),this);
-       }
-   
-       //处理代理实例，并返回结果
-       public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
-           //动态代理的本质，就是使用反射机制实现！
-           Object result = method.invoke(rent, args);
-           seeHose();
-           fee();
-           return result;
-       }
-   
-       public void seeHose(){
-           System.out.println("中介带着看房子！");
-       }
-   
-       public void fee(){
-           System.out.println("中介收取费用！");
-       }
-   }
-   ```
-
-4. 测试
-
-   ```java
-   public class Client {
-       public static void main(String[] args) {
-           //真实角色
-           Host host = new Host();
-   
-           //代理角色：现在没有
-           ProxyInvocationHandler pih = new ProxyInvocationHandler();
-   
-           //通过调用程序处理角色来处理我们要调用的接口对象！
-           pih.setRent(host);
-           Rent proxy = (Rent) pih.getProxy(); //这里的proxy就是动态生成的，我们并没有写
-           proxy.rent();
-   
-       }
-   }
-   ```
-
-在此，我们可以提炼出ProxyInvocationHandler作为工具类
-
-```java
-//用这个类自动生成代理类！
-public class ProxyInvocationHandler implements InvocationHandler {
-
-    //被代理的接口
-    private Object target;
-
-    public void setTarget(Object target) {
-        this.target = target;
-    }
-
-    //生成得到代理类
-    public Object getProxy(){
-        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
-                target.getClass().getInterfaces(),this);
-    }
-
-    //处理代理实例，并返回结果
-    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
-        log(method.getName());
-        Object result = method.invoke(target, args);
-        return result;
-    }
-
-    public void log(String msg){
-        System.out.println("[Debug] 使用了一个"+msg+"方法");
-    }
-}
-```
-
-动态代理的好处：
-
-- 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
-- 公共角色就交给代理角色！实现了业务的分工！
-- 公共业务发生扩展的时候，方便集中管理！
-- 一个动态代理类代理的是一个接口，一般就是对应的一类业务
-- 一个动态代理类可以代理多个类，只要是实现了同一个接口即可！
-
-# 11、AOP
-
-***
-
-## 11.1、什么是AOP
-
-AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
-
-![image-20220326151637541](assets/image-20220326151637541.png)
-
-## 11.2、AOP在spring中的作用
-
-提供声明式事务；允许用户自定义切面
-
-- 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志，安全，缓存，事务等等…
-- 切面（ASPECT）：横切关注点被模块化的特殊对象。即，它是一个类。
-- 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
-- 目标（Target）：被通知对象。
-- 代理（Proxy）：向目标对象应用通知之后创建的对象。
-- 切入点（PointCut）：切面通知执行的“地点”的定义。
-- 连接点（JointPoint）：与切入点匹配的执行点。
-
- ![image-20220326153800124](assets/image-20220326153800124.png)
-
-SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice：
-
-![image-20220326153843054](assets/image-20220326153843054.png)
-
-## 11.3、使用spring实现AOP
-
-【重点】使用AOP织入，需要导入一个依赖包！
-
-```xml
-<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
-<dependency>
-    <groupId>org.aspectj</groupId>
-    <artifactId>aspectjweaver</artifactId>
-    <version>1.9.4</version>
-</dependency>
-```
-
-**方式一：** 使用Spring的API接口【主要是SpringAPI接口实现】
-
-1. 在service包下，定义UserService业务接口和UserServiceImpl实现类
-
-```java
-public interface UserService {
-    public void add();
-    public void delete();
-    public void update();
-    public void select();
-}
-public class UserServiceImpl implements UserService {
-    public void add() {
-        System.out.println("增加了一个用户！");
-    }
-
-    public void delete() {
-        System.out.println("删除了一个用户！");
-    }
-
-    public void update() {
-        System.out.println("更新了一个用户！");
-    }
-
-    public void select() {
-        System.out.println("查询了一个用户！");
-    }
-}
-```
-
-2. 在log包下，定义我们的增强类，一个Log前置增强和一个AfterLog后置增强类
-
-```java
-public class Log implements MethodBeforeAdvice {
-
-    //method: 要执行的目标对象的方法
-    //args：参数
-    //target：目标对象
-    public void before(Method method, Object[] agrs, Object target) throws Throwable {
-        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
-    }
-}
-public class AfterLog implements AfterReturningAdvice {
-
-    //returnValue： 返回值
-    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
-        System.out.println("执行了"+method.getName()+"方法，返回结果为："+returnValue);
-    }
-}
-```
-
-3. 最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束，配置applicationContext.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"
-       xmlns:aop="http://www.springframework.org/schema/aop"
-       xsi:schemaLocation="http://www.springframework.org/schema/beans
-        https://www.springframework.org/schema/beans/spring-beans.xsd
-        http://www.springframework.org/schema/aop
-        https://www.springframework.org/schema/aop/spring-aop.xsd">
-
-    <!--注册bean-->
-    <bean id="userService" class="com.kuang.service.UserServiceImpl"/>
-    <bean id="log" class="com.kuang.log.Log"/>
-    <bean id="afterLog" class="com.kuang.log.AfterLog"/>
-
-    <!--方式一：使用原生Spring API接口-->
-    <!--配置aop:需要导入aop的约束-->
-    <aop:config>
-        <!--切入点：expression：表达式，execution(要执行的位置！* * * * *)-->
-        <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
-
-        <!--执行环绕增加！-->
-        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
-        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
-    </aop:config>
-
-</beans>
-```
-
-4. 测试
-
-```java
-public class MyTest {
-    public static void main(String[] args) {
-        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
-
-        //动态代理代理的是接口：注意点
-        UserService userService = (UserService) context.getBean("userService");
-
-        userService.add();
-//        userService.select();
-    }
-}
-```
-
-**方式二：** 自定义类来实现AOP【主要是切面定义】
-
-1. 在diy包下定义自己的DiyPointCut切入类
-
-```java
-public class DiyPointCut {
-    public void before(){
-        System.out.println("======方法执行前======");
-    }
-
-    public void after(){
-        System.out.println("======方法执行后======");
-    }
-}
-```
-
-2. 去spring中配置文件
-
-```xml
-    <!--方式二：自定义类-->
-    <bean id="diy" class="com.kuang.diy.DiyPointCut"/>
-
-    <aop:config>
-        <!--自定义切面，ref 要引用的类-->
-        <aop:aspect ref="diy">
-            <!--切入点-->
-            <aop:pointcut id="point" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
-            <!--通知-->
-            <aop:before method="before" pointcut-ref="point"/>
-            <aop:after method="after" pointcut-ref="point"/>
-        </aop:aspect>
-    </aop:config>
-```
-
-3. 测试
-
-**方式三：** 使用注解实现！
-
-1. 在diy包下定义注解实现的AnnotationPointCut增强类
-
-```java
-//声明式事务！
-@Aspect //标注这个类是一个切面
-public class AnnotationPointCut {
-
-    @Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
-    public void before(){
-        System.out.println("====方法执行前====");
-    }
-
-    @After("execution(* com.kuang.service.UserServiceImpl.*(..))")
-    public void after(){
-        System.out.println("====方法执行后====");
-    }
-
-    //在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点；
-    @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
-    public void around(ProceedingJoinPoint jp) throws Throwable{
-        System.out.println("环绕前");
-
-        Signature signature = jp.getSignature();// 获得签名
-        System.out.println("signature:"+signature);
-
-        Object proceed = jp.proceed(); //执行方法
-
-        System.out.println("环绕后");
-
-        System.out.println(proceed);
-    }
-
-}
-```
-
-2. 在Spring配置文件中，注册bean，并增加支持注解的配置。
-
-```xml
-    <!--方式三：使用注解-->
-    <bean id="annotationPointCut" class="com.kuang.diy.AnnotationPointCut"/>
-    <!--开启注解支持！ JDK(默认是 proxy-target-class="false")  cglib（proxy-target-class="true"）-->
-    <aop:aspectj-autoproxy/>
-```
-
-3. 测试
-
-# 12、整合Mybatis
-
-***
-
-步骤：
-
-1. 导入相关jar包
-   - junit
-   - mybatis
-   - mysql数据库
-   - spring相关
-   - aop织入器
-   - mybatis-spring整合包【重点】在此还导入了lombok包。
-   - 配置Maven静态资源过滤问题！
-
-```xml
-    <dependencies>
-        <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
-            <version>4.12</version>
-        </dependency>
-        <dependency>
-            <groupId>org.mybatis</groupId>
-            <artifactId>mybatis</artifactId>
-            <version>3.5.6</version>
-        </dependency>
-        <dependency>
-            <groupId>mysql</groupId>
-            <artifactId>mysql-connector-java</artifactId>
-            <version>5.1.47</version>
-        </dependency>
-        <dependency>
-            <groupId>org.springframework</groupId>
-            <artifactId>spring-webmvc</artifactId>
-            <version>5.2.0.RELEASE</version>
-        </dependency>
-        <!--Spring操作数据库的话，还需要一个spring-jdbc
-               -->
-        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
-        <dependency>
-            <groupId>org.springframework</groupId>
-            <artifactId>spring-jdbc</artifactId>
-            <version>5.2.0.RELEASE</version>
-        </dependency>
-        <dependency>
-            <groupId>org.aspectj</groupId>
-            <artifactId>aspectjweaver</artifactId>
-            <version>1.8.13</version>
-        </dependency>
-        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
-        <dependency>
-            <groupId>org.mybatis</groupId>
-            <artifactId>mybatis-spring</artifactId>
-            <version>2.0.2</version>
-        </dependency>
-        <dependency>
-            <groupId>org.projectlombok</groupId>
-            <artifactId>lombok</artifactId>
-            <version>1.18.10</version>
-        </dependency>
-    </dependencies>
-
-     <build>
-        <resources>
-            <resource>
-                <directory>src/main/java</directory>
-                <includes>
-                    <include>**/*.properties</include>
-                    <include>**/*.xml</include>
-                </includes>
-                <filtering>true</filtering>
-            </resource>
-        </resources>
-    </build>
-```
-
-2. 编写配置文件
-
-3. 测试
-
-## 12.1、回忆Mybatis
-
-1. 编写pojo实体类
-
-   ```java
-   @Data
-   public class User {
-       private int id;
-       private String name;
-       private String pwd;
-   }
-   ```
-
-2. 编写实现mybatis的配置文件
-
-   ```xml
-   <?xml version="1.0" encoding="UTF-8" ?>
-   <!DOCTYPE configuration
-          PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
-          "http://mybatis.org/dtd/mybatis-3-config.dtd">
-   <configuration>
-   
-      <typeAliases>
-          <package name="com.kuang.pojo"/>
-      </typeAliases>
-   
-      <environments default="development">
-          <environment id="development">
-              <transactionManager type="JDBC"/>
-              <dataSource type="POOLED">
-                  <property name="driver" value="com.mysql.jdbc.Driver"/>
-                  <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=utf8"/>
-                  <property name="username" value="root"/>
-                  <property name="password" value="123456"/>
-              </dataSource>
-          </environment>
-      </environments>
-   
-      <mappers>
-          <package name="com.kuang.dao"/>
-      </mappers>
-   </configuration>
-   ```
-
-3. 编写UserMapper接口
-
-   ```java
-   public interface UserMapper {
-       public List<User> selectUser();
-   }
-   ```
-
-4. 编写UserMapper.xml文件
-
-   ```xml
-   <?xml version="1.0" encoding="UTF-8" ?>
-   <!DOCTYPE mapper
-           PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
-           "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
-   
-   <mapper namespace="com.kuang.mapper.UserMapper">
-   
-       <!--sql-->
-       <select id="selectUser" resultType="user">
-           select * from mybatis.user
-       </select>
-   </mapper>
-   ```
-
-5. 测试
-
-   ```java
-   @Test
-   public void selectUser() throws IOException {
-   
-      String resource = "mybatis-config.xml";
-      InputStream inputStream = Resources.getResourceAsStream(resource);
-      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
-      SqlSession sqlSession = sqlSessionFactory.openSession();
-   
-      UserMapper mapper = sqlSession.getMapper(UserMapper.class);
-   
-      List<User> userList = mapper.selectUser();
-      for (User user: userList){
-          System.out.println(user);
-     }
-   
-      sqlSession.close();
-   }
-   ```
-
-## 12.2、Mybatis-Spring
-
-什么是MyBatis-Spring？
-
-MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。
-
-文档链接：http://mybatis.org/spring/zh/index.html
-
-如果使用 Maven 作为构建工具，仅需要在 pom.xml 中加入以下代码即可：
-
-```xml
-        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
-        <dependency>
-            <groupId>org.mybatis</groupId>
-            <artifactId>mybatis-spring</artifactId>
-            <version>2.0.2</version>
-        </dependency>
-```
-
-**整合实现一：**
-
-1. 引入Spring配置文件spring-dao.xml
-
-```xml
-<?xml version="1.0" encoding="GBK"?>
-<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
-        https://www.springframework.org/schema/beans/spring-beans.xsd">
-
-    
-
- </beans>
-```
-
-2. 配置数据源替换mybaits的数据源
-
-```xml
-    <!--DataSource:使用Spring的数据源替换Mybatis的配置 c3p0 dbcp druid
-    我们这里使用Spring提供的JDBC：-->
-    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
-        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
-        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
-        <property name="username" value="root"/>
-        <property name="password" value="123456"/>
-    </bean>
-```
-
-3. 配置SqlSessionFactory，关联MyBatis
-
-```xml
-    <!--sqlSessionFactory-->
-    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
-        <property name="dataSource" ref="dataSource" />
-        <!--关联mybatis配置文件-->
-        <property name="configLocation" value="classpath:mybatis-config.xml"/>
-        <property name="mapperLocations" value="classpath:com/kuang/mapper/*.xml"/>
-    </bean>
-```
-
-4. 注册sqlSessionTemplate，关联sqlSessionFactory
-
-```xml
-    <!--SqlSessionTemplate:就是我们使用的sqlSession-->
-    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
-        <!--只能使用构造器注入sqlSessionFactory，因为它没有set方法-->
-        <constructor-arg index="0" ref="sqlSessionFactory" />
-    </bean>
-```
-
-5. 需要UserMapper接口的UserMapperImpl 实现类，私有化sqlSessionTemplate
-
-```java
-public class UserMapperImpl implements UserMapper {
-
-    //我们的所有操作，都使用sqlSession来执行，在原来，现在都使用SqlsessionTemplate
-    private SqlSessionTemplate sqlSession;
-
-    public void setSqlSession(SqlSessionTemplate sqlSession) {
-        this.sqlSession = sqlSession;
-    }
-
-    public List<User> selectUser() {
-        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
-        return mapper.selectUser();
-    }
-}
-```
-
-6. 将自己写的实现类，注入到Spring配置文件中。
-
-```xml
-    <bean id="userMapper" class="com.kuang.mapper.UserMapperImpl">
-        <property name="sqlSession" ref="sqlSession"/>
-    </bean>
-```
-
-7. 测试使用即可！
-
-```java
-    @Test
-    public void test () throws IOException {
-
-        ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
-        
-        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
-        for (User user : userMapper.selectUser()) {
-            System.out.println(user);
-        }
-    }
-```
-
-结果成功输出！现在我们的Mybatis配置文件的状态！发现都可以被Spring整合！
-
-```xml
-结果成功输出！现在我们的Mybatis配置文件的状态！发现都可以被Spring整合！
-
-<?xml version="1.0" encoding="GBK" ?>
-<!DOCTYPE configuration
-        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
-        "http://mybatis.org/dtd/mybatis-3-config.dtd">
-<!--configuration core file-->
-<configuration>
-    
-    <typeAliases>
-        <package name="com.kuang.pojo"/>
-    </typeAliases>
-
-</configuration>
-```
-
-**整合实现二：**
-
-mybatis-spring1.2.3版以上的才有这个，官方文档截图：
-
-dao继承Support类 , 直接利用 getSqlSession() 获得 , 然后直接注入SqlSessionFactory . 比起整合方式一 , 不需要管理SqlSessionTemplate , 而且对事务的支持更加友好 . 可跟踪源码查看。
-
-![在这里插入图片描述](assets/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpNjQzOTM3NTc5,size_16,color_FFFFFF,t_70#pic_center.png)
-
-测试：
-
-1. 将我们上面写的UserMapperImpl修改一下
-
-```java
-public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {
-
-    public List<User> selectUser() {
-        
-        return getSqlSession().getMapper(UserMapper.class).selectUser();
-    }
-}
-```
-
-2. 注入到Spring配置文件中。
-
-```xml
-    <bean id="userMapper" class="com.kuang.mapper.UserMapperImpl">
-        <property name="sqlSessionFactory" ref="sqlSessionFactory" />
-    </bean>
-```
-
-3. 测试
-
-```java
-    @Test
-    public void test () throws IOException {
-
-        ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
-        
-        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
-        for (User user : userMapper.selectUser()) {
-            System.out.println(user);
-        }
-    }
-```
-
-# 13、声明式事务
-
-***
-
-## 13.1、回顾事务
-
-- 把一组业务当成一个业务来做；要么都成功，要么都失败！
-- 事务在项目开发中，十分的重要，涉及到数据的一致性问题，不能马虎！
-- 确保完整性和一致性。
-
-**事务ACID原则：**
-
-- 原子性（atomicity）
-  - 事务是原子性操作，由一系列动作组成，事务的原子性确保动作要么全部完成，要么完全不起作用。
-- 一致性（consistency）
-  - 一旦所有事务动作完成，事务就要被提交。数据和资源处于一种满足业务规则的一致性状态中。
-- 隔离性（isolation）
-  - 可能多个事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏。
-- 持久性（durability）
-  - 事务一旦完成，无论系统发生什么错误，结果都不会受到影响。通常情况下，事务的结果被写到持久化存储器中。
-
-**测试：**
-
-将上面的代码拷贝到一个新项目中
-在之前的案例中，我们给userMapper接口新增两个方法，删除和增加用户；
-
-```java
-//添加一个用户
-int addUser(User user);
-
-//根据id删除用户
-int deleteUser(int id);
-```
-
-UserMapper文件，我们故意把 deletes 写错，测试！
-
-```xml
-<insert id="addUser" parameterType="com.kuang.pojo.User">
-insert into user (id,name,pwd) values (#{id},#{name},#{pwd})
-</insert>
-
-<delete id="deleteUser" parameterType="int">
-deletes from user where id = #{id}
-</delete>
-```
-
-编写接口的UserMapperImpl实现类，在实现类中，我们去操作一波
-
-```java
-public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {
-
-
-    //增加一些操作
-    public List<User> selectUser() {
-        User user = new User(5, "小王", "185161");
-        UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
-        mapper.addUser(user);
-        mapper.deleteUser(5);
-
-        return mapper.selectUser();
-    }
-    
-    //新增
-    public int addUser(User user) {
-        return getSqlSession().getMapper(UserMapper.class).addUser(user);
-    }
-
-    //删除
-    public int deleteUser(int id) {
-        return getSqlSession().getMapper(UserMapper.class).deleteUser(id);
-    }
-}
-```
-
-测试
-
-```java
-    @Test
-    public void test(){
-        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
-
-        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
-
-        for (User user : userMapper.selectUser()) {
-            System.out.println(user);
-        }
-    }
-```
-
-报错：sql异常，delete写错了
-
-结果 ：数据库结果显示插入成功！
-
-没有进行事务的管理；我们想让他们都成功才成功，有一个失败，就都失败，我们就应该需要事务！
-
-以前我们都需要自己手动管理事务，十分麻烦！
-
-但是Spring给我们提供了事务管理，我们只需要配置即可；
-
-## 13.2、Spring中的事务管理
-
-Spring在不同的事务管理API之上定义了一个抽象层，使得开发人员不必了解底层的事务管理API就可以使用Spring的事务管理机制。Spring支持编程式事务管理和声明式的事务管理。
-
-**编程式事务管理**
-
-- 将事务管理代码嵌到业务方法中来控制事务的提交和回滚
-- 缺点：必须在每个事务操作业务逻辑中包含额外的事务管理代码
-
-**声明式事务管理**
-
-- 一般情况下比编程式事务好用。
-- 将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。
-- 将事务管理作为横切关注点，通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。
-
-**1. 使用Spring管理事务，注意头文件的约束导入 : tx**
-
-```xml
-xmlns:tx="http://www.springframework.org/schema/tx"
-
-http://www.springframework.org/schema/tx
-http://www.springframework.org/schema/tx/spring-tx.xsd">
-```
-
-**2. JDBC事务**
-
-```xml
-    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
-        <property name="dataSource" ref="dataSource"/>
-    </bean>
-```
-
-**3. 配置好事务管理器后我们需要去配置事务的通知**
-
-```xml
-    <!--结合AOP实现事务的织入-->
-    <!--配置事务通知-->
-    <tx:advice id="txAdvice" transaction-manager="transactionManager">
-        <!--给那些方法配置事务-->
-        <!--配置事务的传播特性： new -->
-        <tx:attributes>
-            <tx:method name="add" propagation="REQUIRED"/>
-            <tx:method name="delete" propagation="REQUIRED"/>
-            <tx:method name="update" propagation="REQUIRED"/>
-            <tx:method name="query" read-only="true"/>
-            <tx:method name="*" propagation="REQUIRED"/>
-        </tx:attributes>
-    </tx:advice>
-```
-
-**spring事务传播特性：**
-事务传播行为就是多个事务方法相互调用时，事务如何在这些方法间传播。spring支持7种事务传播行为：
-
-- propagation_requierd：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是最常见的选择。
-- propagation_supports：支持当前事务，如果没有当前事务，就以非事务方法执行。
-- propagation_mandatory：使用当前事务，如果没有当前事务，就抛出异常。
-- propagation_required_new：新建事务，如果当前存在事务，把当前事务挂起。
-- propagation_not_supported：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
-- propagation_never：以非事务方式执行操作，如果当前事务存在则抛出异常。
-- propagation_nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与propagation_required类似的操作。
-
-Spring 默认的事务传播行为是 PROPAGATION_REQUIRED，它适合于绝大多数的情况。
-
-就好比，我们刚才的几个方法存在调用，所以会被放在一组事务当中！
-
-**4. 配置AOP，导入aop的头文件**
-
-```xml
-    <!--配置事务切入-->
-    <aop:config>
-        <aop:pointcut id="txPointCut" expression="execution(* com.kuang.mapper.*.*(..))"/>
-        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
-    </aop:config>
-```
-
-**5. 删掉刚才插入的数据，再次测试！**
-
-```java
-    @Test
-    public void test(){
-        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
-
-        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
-
-        for (User user : userMapper.selectUser()) {
-            System.out.println(user);
-        }
-    }
-```
-
-**思考：**
-
-为什么需要事务？
-
-- 如果不配置事务，可能存在数据提交不一致的情况；
-- 如果我们不在Spring中去配置声明式事务，我们就需要在代码中手动配置事务！
-- 事务在项目的开发中十分重要，涉及到数据的一致性和完整性问题，不容马虎！
-

后端/spring/SpringMVC/SpringMVC.md

@@ -1,2786 +0,0 @@
-> [TOC]
-
-# 1、回顾MVC
-
-***
-
-## 1.1、什么是MVC
-
-- MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。
-- 是将业务逻辑、数据、显示分离的方法来组织代码。
-- MVC主要作用是**降低了视图与业务逻辑间的双向偶合**。
-- MVC不是一种设计模式，**MVC是一种架构模式**。当然不同的MVC存在差异。
-
-**Model（模型）**：数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或JavaBean组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据Dao） 和 服务层（行为Service）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。
-
-**View（视图）：**负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。
-
-**Controller（控制器）：**接收用户请求，委托给模型进行处理（状态改变），处理完毕后把返回的模型数据返回给视图，由视图负责展示。也就是说控制器做了个调度员的工作。
-
-**最典型的MVC就是JSP + servlet + javabean的模式。**
-
-![image-20220328145135568](assets/image-20220328145135568.png)
-
-## 1.2、Model1时代
-
-- 在web早期的开发中，通常采用的都是Model1。
-- Model1中，主要分为两层，视图层和模型层。
-
-![image-20220328145211236](assets/image-20220328145211236.png)
-
-Model1优点：架构简单，比较适合小型项目开发；
-
-Model1缺点：JSP职责不单一，职责过重，不便于维护；
-
-## 1.3、Model2时代
-
-Model2把一个项目分成三部分，包括**视图、控制、模型。**
-
-![image-20220328145306643](assets/image-20220328145306643.png)
-
-1. 用户发请求
-2. Servlet接收请求数据，并调用对应的业务逻辑方法
-3. 业务处理完毕，返回更新后的数据给servlet
-4. servlet转向到JSP，由JSP来渲染页面
-5. 响应给前端更新后的页面
-
-**职责分析：**
-
-**Controller：控制器**
-
-1. 取得表单数据
-2. 调用业务逻辑
-3. 转向指定的页面
-
-**Model：模型**
-
-1. 业务逻辑
-2. 保存数据的状态
-
-**View：视图**
-
-1. 显示页面
-
-这样不仅提高的代码的复用率与项目的扩展性，且大大降低了项目的维护成本。Model 1模式的实现比较简单，适用于快速开发小规模项目，Model1中JSP页面身兼View和Controller两种角色，将控制逻辑和表现逻辑混杂在一起，从而导致代码的重用性非常低，增加了应用的扩展性和维护的难度。Model2消除了Model1的缺点。
-
-## 1.4、回顾Servlet
-
-0. 新建一个Maven工程当做父工程！pom依赖！
-
-```xml
-<dependencies>
-   <dependency>
-       <groupId>junit</groupId>
-       <artifactId>junit</artifactId>
-       <version>4.12</version>
-   </dependency>
-   <dependency>
-       <groupId>org.springframework</groupId>
-       <artifactId>spring-webmvc</artifactId>
-       <version>5.1.9.RELEASE</version>
-   </dependency>
-   <dependency>
-       <groupId>javax.servlet</groupId>
-       <artifactId>servlet-api</artifactId>
-       <version>2.5</version>
-   </dependency>
-   <dependency>
-       <groupId>javax.servlet.jsp</groupId>
-       <artifactId>jsp-api</artifactId>
-       <version>2.2</version>
-   </dependency>
-   <dependency>
-       <groupId>javax.servlet</groupId>
-       <artifactId>jstl</artifactId>
-       <version>1.2</version>
-   </dependency>
-</dependencies>
-```
-
-1. 建立一个Moudle：springmvc-01-servlet ， 添加Web app的支持！
-
-2. 导入servlet 和 jsp 的 jar 依赖
-
-   ```xml
-   <dependency>
-      <groupId>javax.servlet</groupId>
-      <artifactId>servlet-api</artifactId>
-      <version>2.5</version>
-   </dependency>
-   <dependency>
-      <groupId>javax.servlet.jsp</groupId>
-      <artifactId>jsp-api</artifactId>
-      <version>2.2</version>
-   </dependency>
-   ```
-
-3. 编写一个Servlet类，用来处理用户的请求
-
-   ```java
-   package com.th.servlet;
-   
-   // 实现Servlet接口
-   public class HelloServlet extends HttpServlet {
-      @Override
-      protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
-          // 取得参数
-          String method = req.getParameter("method");
-          if (method.equals("add")){
-              req.getSession().setAttribute("msg","执行了add方法");
-         }
-          if (method.equals("delete")){
-              req.getSession().setAttribute("msg","执行了delete方法");
-         }
-          // 业务逻辑
-          // 视图跳转
-          req.getRequestDispatcher("/WEB-INF/jsp/hello.jsp").forward(req,resp);
-     }
-   
-      @Override
-      protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
-          doGet(req,resp);
-     }
-   }
-   ```
-
-4. 编写Hello.jsp，在WEB-INF目录下新建一个jsp的文件夹，新建hello.jsp
-
-   ```jsp
-   <%@ page contentType="text/html;charset=UTF-8" language="java" %>
-   <html>
-   <head>
-      <title>thshen</title>
-   </head>
-   <body>
-   ${msg}
-   </body>
-   </html>
-   ```
-
-5. 在web.xml中注册Servlet
-
-   ```xml
-   <?xml version="1.0" encoding="UTF-8"?>
-   <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
-           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-           xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
-           version="4.0">
-      <servlet>
-          <servlet-name>HelloServlet</servlet-name>
-          <servlet-class>com.th.servlet.HelloServlet</servlet-class>
-      </servlet>
-      <servlet-mapping>
-          <servlet-name>HelloServlet</servlet-name>
-          <url-pattern>/user</url-pattern>
-      </servlet-mapping>
-   
-   </web-app>
-   ```
-
-6. 配置Tomcat，并启动测试
-
-7. - localhost:8080/user?method=add
-   - localhost:8080/user?method=delete
-
-**MVC框架要做哪些事情**
-
-1. 将url映射到java类或java类的方法 .
-2. 封装用户提交的数据 .
-3. 处理请求--调用相关的业务处理--封装响应数据 .
-4. 将响应的数据进行渲染 . jsp / html 等表示层数据 .
-
-**说明：**
-
- 常见的服务器端MVC框架有：Struts、Spring MVC、ASP.NET MVC、Zend Framework、JSF；常见前端MVC框架：vue、angularjs、react、backbone；由MVC演化出了另外一些模式如：MVP、MVVM 等等....
-
-# 2、什么是SpringMVC
-
-***
-
-## 2.1、概述
-
-Spring MVC是Spring Framework的一部分，是基于Java实现MVC的轻量级Web框架。
-
-查看官方文档：https://docs.spring.io/spring/docs/5.2.0.RELEASE/spring-framework-reference/web.html#spring-web
-
-**我们为什么要学习SpringMVC呢?**
-
-Spring MVC的特点：
-
-1. 轻量级，简单易学
-2. 高效 , 基于请求响应的MVC框架
-3. 与Spring兼容性好，无缝结合
-4. 约定优于配置
-5. 功能强大：RESTful、数据验证、格式化、本地化、主题等
-6. 简洁灵活
-
-Spring的web框架围绕**DispatcherServlet** [ 调度Servlet ] 设计。
-
-DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解形式进行开发，十分简洁；
-
-正因为SpringMVC好 , 简单 , 便捷 , 易学 , 天生和Spring无缝集成(使用SpringIoC和Aop) , 使用约定优于配置 . 能够进行简单的junit测试 . 支持Restful风格 .异常处理 , 本地化 , 国际化 , 数据验证 , 类型转换 , 拦截器 等等…所以我们要学习 .
-
-**最重要的一点还是用的人多 , 使用的公司多 .**
-
-## 2.2、中心控制器
-
-- Spring的web框架围绕DispatcherServlet设计。DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解的controller声明方式。
-
-![image-20220330141737797](assets/image-20220330141737797.png)
-
-Spring MVC框架像许多其他MVC框架一样, **以请求为驱动** , **围绕一个中心Servlet分派请求及提供其他功能**，**DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)**。
-
-- SpringMVC的原理如下图所示：
-
-  当发起请求时被前置的控制器拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器，控制器使用模型与视图渲染视图结果，将结果返回给中心控制器，再将结果返回给请求者。
-
-  原图
-
-  ![在这里插入图片描述](assets/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYzNTE5OA==,size_16,color_FFFFFF,t_70.png)
-
-* 中文
-
-![image-20220407100739275](assets/image-20220407100739275.png)
-
-## 2.3、SpringMVC执行原理
-
-![image-20220407101110138](assets/image-20220407101110138.png)
-
-图为SpringMVC的一个较完整的流程图，实线表示SpringMVC框架提供的技术，不需要开发者实现，虚线表示需要开发者实现。
-
-**简要分析执行流程**
-
-1. DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截请求。
-   - 我们假设请求的url为 : http://localhost:8080/SpringMVC/hello
-   - **如上url拆分成三部分：**
-   - [http://localhost:8080](http://localhost:8080/) ------> 服务器域名
-   - SpringMVC ------> 部署在服务器上的web站点
-   - hello ------> 表示控制器
-   - 通过分析，如上url表示为：请求位于服务器localhost:8080上的SpringMVC站点的hello控制器。
-2. HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping,HandlerMapping根据请求url查找Handler。
-3. HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器为：hello。
-4. HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。
-5. HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。
-6. Handler让具体的Controller执行。
-7. Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。
-8. HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。
-9. DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。
-10. 视图解析器将解析的逻辑视图名传给DispatcherServlet。
-11. DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。
-12. 最终视图呈现给用户。
-
-# 3、第一个SpringMVC 程序
-
-***
-
-## 3.1、配置版
-
-1. 新建一个Moudle ， springmvc-02-hello ， 添加web的支持！
-
-2. 确定导入了SpringMVC 的依赖！
-
-3. 配置web.xml ， 注册DispatcherServlet
-
-   ```xml
-   <?xml version="1.0" encoding="UTF-8"?>
-   <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
-           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-           xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
-           version="4.0">
-   
-      <!--1.注册DispatcherServlet-->
-      <servlet>
-          <servlet-name>springmvc</servlet-name>
-          <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
-          <!--关联一个springmvc的配置文件:【servlet-name】-servlet.xml-->
-          <init-param>
-              <param-name>contextConfigLocation</param-name>
-              <param-value>classpath:springmvc-servlet.xml</param-value>
-          </init-param>
-          <!--启动级别-1-->
-          <load-on-startup>1</load-on-startup>
-      </servlet>
-   
-      <!--/ 匹配所有的请求；（不包括.jsp）-->
-      <!--/* 匹配所有的请求；（包括.jsp）-->
-      <servlet-mapping>
-          <servlet-name>springmvc</servlet-name>
-          <url-pattern>/</url-pattern>
-      </servlet-mapping>
-   
-   </web-app>
-   ```
-
-4. 编写SpringMVC 的 配置文件！名称：springmvc-servlet.xml : [servletname]-servlet.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">
-   
-   </beans>
-   ```
-
-5. 添加 处理映射器（可省略）
-
-   ```xml
-   <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
-   ```
-
-6. 添加 处理器适配器（可省略）
-
-   ```xml
-   <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
-   ```
-
-7. 添加 视图解析器
-
-   ```xml
-   <!--视图解析器:DispatcherServlet给他的ModelAndView-->
-   <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
-      <!--前缀-->
-      <property name="prefix" value="/WEB-INF/jsp/"/>
-      <!--后缀-->
-      <property name="suffix" value=".jsp"/>
-   </bean>
-   ```
-
-8. 编写我们要操作业务Controller ，要么实现Controller接口，要么增加注解；需要返回一个ModelAndView，装数据，封视图；
-
-   ```java
-   package com.th.controller;
-   
-   import org.springframework.web.servlet.ModelAndView;
-   import org.springframework.web.servlet.mvc.Controller;
-   
-   import javax.servlet.http.HttpServletRequest;
-   import javax.servlet.http.HttpServletResponse;
-   
-   //注意：这里我们先导入Controller接口
-   public class HelloController implements Controller {
-   
-      public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
-          //ModelAndView 模型和视图
-          ModelAndView mv = new ModelAndView();
-   
-          //封装对象，放在ModelAndView中。Model
-          mv.addObject("msg","HelloSpringMVC!");
-          //封装要跳转的视图，放在ModelAndView中
-          mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
-          return mv;
-     }
-   }
-   ```
-
-9. 将自己的类交给SpringIOC容器，注册bean
-
-   ```xml
-   <!--Handler-->
-   <bean id="/hello" class="nuc.ss.controller.HelloController"/>
-   ```
-
-10. 写要跳转的jsp页面，显示ModelandView存放的数据，以及我们的正常页面；
-
-    ```html
-    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
-    <html>
-    <head>
-       <title>他化自在</title>
-    </head>
-    <body>
-    ${msg}
-    </body>
-    </html>
-    ```
-
-11. 配置Tomcat 启动测试！
-
-![在这里插入图片描述](assets/20200719143435542.png)
-
-**可能遇到的问题：访问出现404，排查步骤：**
-
-1. 查看控制台输出，看一下是不是缺少了什么jar包。
-2. 如果jar包存在，显示无法输出，就在IDEA的项目发布中，添加lib依赖！
-3. 重启Tomcat 即可解决！
-
-**小结：我们来看个注解版实现，这才是SpringMVC的精髓。**
-
-## 3.2、*注解版(重点，配置代码)*
-
-**1、新建一个Moudle，springmvc-03-hello-annotation 。添加web支持！**
-
-2、由于Maven可能存在资源过滤的问题，我们将配置完善
-
-```xml
-<build>
-   <resources>
-       <resource>
-           <directory>src/main/java</directory>
-           <includes>
-               <include>**/*.properties</include>
-               <include>**/*.xml</include>
-           </includes>
-           <filtering>false</filtering>
-       </resource>
-       <resource>
-           <directory>src/main/resources</directory>
-           <includes>
-               <include>**/*.properties</include>
-               <include>**/*.xml</include>
-           </includes>
-           <filtering>false</filtering>
-       </resource>
-   </resources>
-</build>
-```
-
-3、在pom.xml文件引入相关的依赖：主要有Spring框架核心库、Spring MVC、servlet , JSTL等。我们在父依赖中已经引入了！
-
-**4、配置web.xml**
-
-```xml
-<?xml version="1.0" encoding="UTF-8"?>
-<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
-         version="4.0">
-    <!--注册servlet-->
-    <servlet>
-        <servlet-name>SpringMVC</servlet-name>
-        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
-        <!--初始化Spring配置文件的位置-->
-        <init-param>
-            <param-name>contextConfigLocation</param-name>
-            <param-value>classpath:springmvc-servlet.xml</param-value>
-        </init-param>
-        <!--启动顺序，数字越小，启动越早-->
-        <load-on-startup>1</load-on-startup>
-    </servlet>
-    <!--所有的请求都会被SpringMVC拦截-->
-    <servlet-mapping>
-        <servlet-name>SpringMVC</servlet-name>
-        <url-pattern>/</url-pattern>
-    </servlet-mapping>
-</web-app>
-<!--这是使用注解开发时固定的配置-->
-```
-
-> 注意点：
-
-**/ 和 /\* 的区别：**
-
-< url-pattern > / </ url-pattern > 不会匹配到.jsp， 只针对我们编写的请求；即：.jsp 不会进入spring的 DispatcherServlet类 。
-
-< url-pattern > /* </ url-pattern > 会匹配 *.jsp，会出现返回 jsp视图 时再次进入spring的DispatcherServlet 类，导致找不到对应的controller所以报404错。
-
-1. - 注意web.xml版本问题，要最新版!4.0
-   - 注册DispatcherServlet
-   - 关联SpringMVC的配置文件
-   - 启动级别为1
-   - 映射路径为 / 【不要用/*，会404】
-
-**5、添加Spring MVC配置文件**
-
-在resource目录下添加springmvc-servlet.xml配置文件，配置的形式与Spring容器配置基本类似，为了支持基于注解的IOC，设置了自动扫描包的功能，具体配置信息如下：
-
-```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"
-       xmlns:context="http://www.springframework.org/schema/context"
-       xmlns:mvc="http://www.springframework.org/schema/mvc"
-       xsi:schemaLocation="http://www.springframework.org/schema/beans
-       http://www.springframework.org/schema/beans/spring-beans.xsd
-       http://www.springframework.org/schema/context
-       https://www.springframework.org/schema/context/spring-context.xsd
-       http://www.springframework.org/schema/mvc
-       https://www.springframework.org/schema/mvc/spring-mvc.xsd">
-
-    <!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
-    <context:component-scan base-package="com.th.controller"/>
-    <!-- 让Spring MVC不处理静态资源 -->
-    <mvc:default-servlet-handler />
-    <!--
-    支持mvc注解驱动
-        在spring中一般采用@RequestMapping注解来完成映射关系
-        要想使@RequestMapping注解生效
-        必须向上下文中注册DefaultAnnotationHandlerMapping
-        和一个AnnotationMethodHandlerAdapter实例
-        这两个实例分别在类级别和方法级别处理。
-        而annotation-driven配置帮助我们自动完成上述两个实例的注入。
-     -->
-    <mvc:annotation-driven />
-
-    <!-- 视图解析器 -->
-    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
-          id="internalResourceViewResolver">
-        <!-- 前缀 -->
-        <property name="prefix" value="/WEB-INF/jsp/" />
-        <!-- 后缀 -->
-        <property name="suffix" value=".jsp" />
-    </bean>
-
-</beans>
-<!--这也是固定配置，需要修改的只有需要注入IOC的包-->
-```
-
-> ### **在视图解析器中我们把所有的视图都存放在/WEB-INF/目录下，这样可以保证视图安全，因为这个目录下的文件，客户端不能直接访问。**
-
-- 让IOC的注解生效
-- 静态资源过滤 ：HTML . JS . CSS . 图片 ， 视频 .....
-- MVC的注解驱动
-- 配置视图解析器
-
-**6、创建Controller**
-
-编写一个Java控制类：com.th.controller.HelloController , 注意编码规范
-
-```java
-package com.th.controller;
-
-import org.springframework.stereotype.Controller;
-import org.springframework.ui.Model;
-import org.springframework.web.bind.annotation.RequestMapping;
-
-@Controller
-@RequestMapping("/HelloController")
-public class HelloController {
-    //类上注册了@RequestMapping方法就自动下移，实际地址：项目名/HelloController/hello
-    @RequestMapping("/hello")
-    public String sayHello(Model model){
-        
-        //向模型中添加属性msg与值，可以在JSP页面中取出并渲染
-        model.addAttribute("msg","hello,SpringMVCAnnotation!");
-        
-        //web-inf/jsp/hello.jsp
-        return "hello";
-    }
-}
-```
-
-- @Controller是为了让Spring IOC容器初始化时自动扫描到；
-- @RequestMapping是为了映射请求路径，这里因为类与方法上都有映射所以访问时应该是/HelloController/hello；
-- 方法中声明Model类型的参数是为了把Action中的数据带到视图中；
-- 方法返回的结果是视图的名称hello，加上配置文件中的前后缀变成WEB-INF/jsp/**hello**.jsp。
-
-7、**创建视图层**
-
-```jsp
-<%@ page contentType="text/html;charset=UTF-8" language="java" %>
-<html>
-<head>
-   <title>SpringMVC</title>
-</head>
-<body>
-${msg}
-</body>
-</html>
-```
-
-在WEB-INF/ jsp目录中创建hello.jsp ， 视图可以直接取出并展示从Controller带回的信息；
-
-可以通过EL表示取出Model中存放的值，或者对象；
-
-**8、配置Tomcat运行**
-
-配置Tomcat ， 开启服务器 ， 访问 对应的请求路径！
-
-![image-20220407105922546](assets/image-20220407105922546.png)
-
-**OK，运行成功！**
-
-**小结**
-
-实现步骤其实非常的简单：
-
-1. 新建一个web项目
-2. 导入相关jar包
-3. 编写web.xml , 注册DispatcherServlet
-4. 编写springmvc配置文件
-5. 接下来就是去创建对应的控制类 , controller
-6. 最后完善前端视图和controller之间的对应
-7. 测试运行调试.
-
-使用springMVC必须配置的三大件：
-
-**处理器映射器、处理器适配器、视图解析器**
-
-通常，我们只需要**手动配置视图解析器**，而**处理器映射器**和**处理器适配器**只需要开启**注解驱动**即可，而省去了大段的xml配置
-
-# 4、控制器和RestFul风格
-
-***
-
-在上一节中，我们编写了我们的第一个SpringMVC程序！
-
-现在我们来看看里面的控制器和路径请求的具体内容吧！
-
-## 4.1、控制器Controller
-
-- 控制器复杂提供访问应用程序的行为，通常通过接口定义或注解定义两种方法实现。
-- 控制器负责解析用户的请求并将其转换为一个模型。
-- 在Spring MVC中一个控制器类可以包含多个方法
-- 在Spring MVC中，对于Controller的配置方式有很多种
-
-## 4.2、实现Controller接口
-
-Controller是一个接口，在org.springframework.web.servlet.mvc包下，接口中只有一个方法；
-
-```java
-//实现该接口的类获得控制器功能
-public interface Controller {
-   //处理请求且返回一个模型与视图对象
-   ModelAndView handleRequest(HttpServletRequest var1, HttpServletResponse var2) throws Exception;
-}
-```
-
-**测试**
-
-1. 新建一个Moudle，springmvc-04-controller 。将刚才的03 拷贝一份, 我们进行操作！
-
-2. - 删掉HelloController
-   - mvc的配置文件只留下 视图解析器！
-
-3. 编写一个Controller类，ControllerTest1
-
-   ```java
-   //定义控制器
-   //注意点：不要导错包，实现Controller接口，重写方法；
-   public class ControllerTest1 implements Controller {
-   
-      public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
-          //返回一个模型视图对象
-          ModelAndView mv = new ModelAndView();
-          mv.addObject("msg","Test1Controller");
-          mv.setViewName("test");
-          return mv;
-     }
-   }
-   ```
-
-4. 编写完毕后，去Spring配置文件中注册请求的bean；name对应请求路径，class对应处理请求的类
-
-   ```cpp
-   <bean name="/t1" class="com.th.controller.ControllerTest1"/>
-   ```
-
-5. 编写前端test.jsp，注意在WEB-INF/jsp目录下编写，对应我们的视图解析器
-
-   ```jsp
-   <%@ page contentType="text/html;charset=UTF-8" language="java" %>
-   <html>
-   <head>
-      <title>thshen</title>
-   </head>
-   <body>
-   ${msg}
-   </body>
-   </html>
-   ```
-
-6. 配置Tomcat运行测试，我这里没有项目发布名配置的就是一个 / ，所以请求不用加项目名，OK！
-
-![image-20220407111913155](assets/image-20220407111913155.png)
-
-**说明：**
-
-- 实现接口Controller定义控制器是较老的办法
-- 缺点是：一个控制器中只有一个方法，如果要多个方法则需要定义多个Controller；定义的方式比较麻烦；
-
-## 4.3、使用注解@Controller
-
-- @Controller注解类型用于声明Spring类的实例是一个控制器（在讲IOC时还提到了另外3个注解）；
-
-- Spring可以使用扫描机制来找到应用程序中所有基于注解的控制器类，为了保证Spring能找到你的控制器，需要在配置文件中声明组件扫描。
-
-  ```xml
-  <!-- 自动扫描指定的包，下面所有注解类交给IOC容器管理 -->
-  <context:component-scan base-package="com.th.controller"/>
-  ```
-
-- 增加一个ControllerTest2类，使用注解实现；
-
-  ```java
-  //@Controller注解的类会自动添加到Spring上下文中
-  @Controller
-  public class ControllerTest2{
-  
-     //映射访问路径
-     @RequestMapping("/t2")
-     public String index(Model model){
-         //Spring MVC会自动实例化一个Model对象用于向视图中传值
-         model.addAttribute("msg", "ControllerTest2");
-         //返回视图位置
-         return "test";
-    }
-  
-  }
-  ```
-
-- 运行tomcat测试
-
-![image-20220407112120658](assets/image-20220407112120658.png)
-
-**可以发现，我们的两个请求都可以指向一个视图，但是页面结果的结果是不一样的，从这里可以看出视图是被复用的，而控制器与视图之间是弱偶合关系。**
-
-**注解方式是平时使用的最多的方式！**
-
-## 4.4、RequestMapping
-
-**@RequestMapping**
-
-- @RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。
-
-- 为了测试结论更加准确，我们可以加上一个项目名测试 myweb
-
-- 只注解在方法上面
-
-- Model 和 ModelMap 的实例都是spirng mvc框架来自动创建并作为控制器方法参数传入，用户无需自己创建。
-
-- ModelAndView的实例是需要我们手动new的，这也是和ModelMap的一个区别。
-
-  ```java
-  @Controller
-  public class TestController {
-     @RequestMapping("/h1")
-     public String test(){
-         return "test";
-    }
-  }
-  ```
-
-  访问路径：[http://localhost:8080](http://localhost:8080/) / 项目名 / h1
-
-- 同时注解类与方法
-
-  ```java
-  @Controller
-  @RequestMapping("/admin")
-  public class TestController {
-     @RequestMapping("/h1")
-     public String test(){
-         return "test";
-    }
-  }
-  ```
-
-  访问路径：[http://localhost:8080](http://localhost:8080/) / 项目名/ admin /h1 , 需要先指定类的路径再指定方法的路径；
-
-## 4.5、RestFul 风格
-
-**概念**
-
-Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。
-
-**功能**
-
-资源：互联网所有的事物都可以被抽象为资源
-
-资源操作：使用POST、DELETE、PUT、GET，使用不同方法对资源进行操作。
-
-分别对应 添加、 删除、修改、查询。
-
-**传统方式操作资源** ：通过不同的参数来实现不同的效果！方法单一，post 和 get
-
- http://127.0.0.1/item/queryItem.action?id=1 查询,GET
-
- http://127.0.0.1/item/saveItem.action 新增,POST
-
- http://127.0.0.1/item/updateItem.action 更新,POST
-
- http://127.0.0.1/item/deleteItem.action?id=1 删除,GET或POST
-
-**使用RESTful操作资源** ：可以通过不同的请求方式来实现不同的效果！如下：请求地址一样，但是功能可以不同！
-
- http://127.0.0.1/item/1 查询,GET
-
- http://127.0.0.1/item 新增,POST
-
- http://127.0.0.1/item 更新,PUT
-
- http://127.0.0.1/item/1 删除,DELETE
-
-**学习测试**
-
-1. 在新建一个类 RestFulController
-
-   ```java
-   @Controller
-   public class RestFulController {
-   }
-   ```
-
-2. 在Spring MVC中可以使用 @PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量上。
-
-   ```java
-   @Controller
-   public class RestFulController {
-   
-      //映射访问路径
-      @RequestMapping("/commit/{p1}/{p2}")
-      public String index(@PathVariable int p1, @PathVariable int p2, Model model){
-          
-          int result = p1+p2;
-          //Spring MVC会自动实例化一个Model对象用于向视图中传值
-          model.addAttribute("msg", "结果："+result);
-          //返回视图位置
-          return "test";
-          
-     }
-      
-   }
-   ```
-
-3. 我们来测试请求查看下
-
-   ![image-20220408164945283](assets/image-20220408164945283.png)
-
-4. 思考：使用路径变量的好处？
-
-5. - 使路径变得更加简洁；
-
-   - 获得参数更加方便，框架会自动进行类型转换。
-
-   - 通过路径变量的类型可以约束访问参数，如果类型不一样，则访问不到对应的请求方法，如这里访问是的路径是/commit/1/a，则路径与方法不匹配，而不会是参数转换失败。
-
-     ![image-20220408165107341](assets/image-20220408165107341.png)
-
-6. 我们来修改下对应的参数类型，再次测试
-
-   ```java
-   //映射访问路径
-   @RequestMapping("/commit/{p1}/{p2}")
-   public String index(@PathVariable int p1, @PathVariable String p2, Model model){
-   
-      String result = p1+p2;
-      //Spring MVC会自动实例化一个Model对象用于向视图中传值
-      model.addAttribute("msg", "结果："+result);
-      //返回视图位置
-      return "test";
-   
-   }
-   ```
-
-   ![image-20220408165153592](assets/image-20220408165153592.png)
-
-**使用method属性指定请求类型**
-
-用于约束请求的类型，可以收窄请求范围。指定请求谓词的类型如GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE等
-
-我们来测试一下：
-
-- 增加一个方法
-
-  ```java
-      @RequestMapping(value = "/add/{a}/{b}",method = RequestMethod.DELETE)
-      public String test1(@PathVariable int a,@PathVariable String b, Model model) {
-          model.addAttribute("msg",a+b);
-          return "test";
-      }
-  ```
-
-- 我们使用浏览器地址栏进行访问默认是Get请求，会报错405：
-
-  ![image-20220408165611498](assets/image-20220408165611498.png)
-
-- 如果将POST修改为GET则正常了；
-
-  ```java
-  @RequestMapping(value = "/add/{a}/{b}",method = RequestMethod.GET)
-  public String test1(@PathVariable int a,@PathVariable String b, Model model) {
-      model.addAttribute("msg",a+b);
-      return "test";
-  }
-  ```
-
-  ![image-20220408165835037](assets/image-20220408165835037.png)
-
-**小结：**
-
-Spring MVC 的 @RequestMapping 注解能够处理 HTTP 请求的方法, 比如 GET, PUT, POST, DELETE 以及 PATCH。
-
-**所有的地址栏请求默认都会是 HTTP GET 类型的。**
-
-方法级别的注解变体有如下几个：组合注解
-
-```java
-@GetMapping
-@PostMapping
-@PutMapping
-@DeleteMapping
-@PatchMapping
-```
-
-@GetMapping 是一个组合注解，平时使用的会比较多！
-
-它所扮演的是 @RequestMapping(method =RequestMethod.GET) 的一个快捷方式。
-
-# 5、结果跳转方式
-
-***
-
-## 5.1、ModelAndView
-
-设置ModelAndView对象 , 根据view的名称 , 和视图解析器跳到指定的页面 .
-
-页面 : {视图解析器前缀} + viewName +{视图解析器后缀}
-
-```java
-<!-- 视图解析器 -->
-<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
-     id="internalResourceViewResolver">
-   <!-- 前缀 -->
-   <property name="prefix" value="/WEB-INF/jsp/" />
-   <!-- 后缀 -->
-   <property name="suffix" value=".jsp" />
-</bean>
-```
-
-对应的controller类
-
-```java
-public class ControllerTest1 implements Controller {
-
-   public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
-       //返回一个模型视图对象
-       ModelAndView mv = new ModelAndView();
-       mv.addObject("msg","ControllerTest1");
-       mv.setViewName("test");
-       return mv;
-  }
-}
-```
-
-## 5.2、ServletAPI
-
-通过设置ServletAPI , 不需要视图解析器 .
-
-1、通过HttpServletResponse进行输出
-
-2、通过HttpServletResponse实现重定向
-
-3、通过HttpServletResponse实现转发
-
-```java
-@Controller
-public class ModelTest1 {
-
-    @RequestMapping("/m1/t1")
-    public String test1(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
-        HttpSession session = req.getSession();
-        System.out.println(session.getId());
-
-        return "test";
-    }
-}
-```
-
-## 5.3、SpringMVC
-
-**通过SpringMVC来实现转发和重定向 - 无需视图解析器；**
-
-测试前，需要将视图解析器注释掉
-
-- 默认为forward转发（也可以加上）
-- redirect转发需特别加
-
-```java
-@Controller
-public class ResultSpringMVC {
-   @RequestMapping("/rsm/t1")
-   public String test1(){
-       //转发
-       return "/index.jsp";
-  }
-
-   @RequestMapping("/rsm/t2")
-   public String test2(){
-       //转发二
-       return "forward:/index.jsp";
-  }
-
-   @RequestMapping("/rsm/t3")
-   public String test3(){
-       //重定向
-       return "redirect:/index.jsp";
-  }
-}
-```
-
-**通过SpringMVC来实现转发和重定向 - 有视图解析器；**
-
-重定向 , 不需要视图解析器 , 本质就是重新请求一个新地方嘛 , 所以注意路径问题.
-
-可以重定向到另外一个请求实现 .
-
-- 默认为forward转发（不可以加上）
-- redirect转发需特别加
-
-```java
-@Controller
-public class ResultSpringMVC2 {
-   @RequestMapping("/rsm2/t1")
-   public String test1(){
-       //转发
-       return "test";
-  }
-
-   @RequestMapping("/rsm2/t2")
-   public String test2(){
-       //重定向
-       return "redirect:/index.jsp";
-       //return "redirect:hello.do"; //hello.do为另一个请求/
-  }
-
-}
-```
-
-# 6、数据处理
-
-***
-
-## 6.1、处理提交数据
-
-### 1、**参数名一致**
-
-提交数据 : http://localhost:8080/hello?name=thshen
-
-处理方法 :
-
-```java
-@RequestMapping("/hello")
-public String hello(String name){
-   System.out.println(name);
-   return "hello";
-}
-```
-
-后台输出 : thshen
-
-### **2、参数名不一致**
-
-提交的域名称和处理方法的
-
-提交数据 : http://localhost:8080/hello?username=thshen
-
-处理方法 :
-
-```java
-//@RequestParam("username") : username提交的域的名称 .
-@RequestMapping("/hello")
-public String hello(@RequestParam("username") String name){
-   System.out.println(name);
-   return "hello";
-}
-```
-
-后台输出 : thshen
-
-### **3、提交的是一个对象**
-
-要求提交的表单域和对象的属性名一致 , 参数使用对象即可
-
-1、实体类
-
-```java
-public class User {
-   private int id;
-   private String name;
-   private int age;
-   //构造
-   //get/set
-   //tostring()
-}
-```
-
-2、提交数据 : http://localhost:8080/mvc04/user?name=thshen&id=1&age=5
-
-3、处理方法 :
-
-```java
-@RequestMapping("/user")
-public String user(User user){
-   System.out.println(user);
-   return "hello";
-}
-```
-
-后台输出 : User { id=1, name='thshen', age=15 }
-
-说明：如果使用对象的话，前端传递的参数名和对象名必须一致，否则就是null。
-
-## 6.2、数据显示到前端
-
-### **第一种 : 通过ModelAndView**
-
-我们前面一直都是如此 . 就不过多解释
-
-```java
-public class ControllerTest1 implements Controller {
-
-   public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
-       //返回一个模型视图对象
-       ModelAndView mv = new ModelAndView();
-       mv.addObject("msg","ControllerTest1");
-       mv.setViewName("test");
-       return mv;
-  }
-}
-```
-
-### **第二种 : 通过ModelMap**
-
-ModelMap
-
-```java
-@RequestMapping("/hello")
-public String hello(@RequestParam("username") String name, ModelMap model){
-   //封装要显示到视图中的数据
-   //相当于req.setAttribute("name",name);
-   model.addAttribute("name",name);
-   System.out.println(name);
-   return "hello";
-}
-```
-
-### **第三种 : 通过Model**
-
-Model
-
-```java
-@RequestMapping("/ct2/hello")
-public String hello(@RequestParam("username") String name, Model model){
-   //封装要显示到视图中的数据
-   //相当于req.setAttribute("name",name);
-   model.addAttribute("msg",name);
-   System.out.println(name);
-   return "test";
-}
-```
-
-## 6.3、对比
-
-就对于新手而言简单来说使用区别就是：
-
-```undefined
-Model 只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解；
-
-ModelMap 继承了 LinkedMap ，除了实现了自身的一些方法，同样的继承 LinkedMap 的方法和特性；
-
-ModelAndView 可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。
-```
-
-当然更多的以后开发考虑的更多的是性能和优化，就不能单单仅限于此的了解。
-
-**请使用80%的时间打好扎实的基础，剩下18%的时间研究框架，2%的时间去学点英文，框架的官方文档永远是最好的教程。**
-
-# 7、乱码问题
-
-***
-
-测试步骤：
-
-1、我们可以在首页编写一个提交的表单
-
-```jsp
-<form action="/e/t" method="post">
- <input type="text" name="name">
- <input type="submit">
-</form>
-```
-
-2、后台编写对应的处理类
-
-```java
-@Controller
-public class Encoding {
-   @RequestMapping("/e/t")
-   public String test(Model model,String name){
-       model.addAttribute("msg",name); //获取表单提交的值
-       return "test"; //跳转到test页面显示输入的值
-  }
-}
-```
-
-3、输入中文测试，发现乱码
-
-不得不说，乱码问题是在我们开发中十分常见的问题，也是让我们程序猿比较头大的问题！
-
-以前乱码问题通过过滤器解决 , 而SpringMVC给我们提供了一个过滤器 , 可以在web.xml中配置 .
-
-修改了xml文件需要重启服务器！
-
-```xml
-<filter>
-   <filter-name>encoding</filter-name>
-   <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
-   <init-param>
-       <param-name>encoding</param-name>
-       <param-value>utf-8</param-value>
-   </init-param>
-</filter>
-<filter-mapping>
-   <filter-name>encoding</filter-name>
-   <url-pattern>/*</url-pattern>
-</filter-mapping>
-```
-
-但是我们发现 , 有些极端情况下.这个过滤器对get的支持不好 .
-
-处理方法 :
-
-1、修改tomcat配置文件 ：设置编码！
-
-```xml
-<Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
-          connectionTimeout="20000"
-          redirectPort="8443" />
-```
-
-**乱码通用过滤**
-
-**自定义过滤器**，然后在web.xml中配置一下就好
-
-```java
-package com.th.filter;
-
-import javax.servlet.*;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletRequestWrapper;
-import javax.servlet.http.HttpServletResponse;
-import java.io.IOException;
-import java.io.UnsupportedEncodingException;
-import java.util.Map;
-
-/**
-* 解决get和post请求 全部乱码的过滤器
-*/
-public class GenericEncodingFilter implements Filter {
-
-   @Override
-   public void destroy() {
-  }
-
-   @Override
-   public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
-       //处理response的字符编码
-       HttpServletResponse myResponse=(HttpServletResponse) response;
-       myResponse.setContentType("text/html;charset=UTF-8");
-
-       // 转型为与协议相关对象
-       HttpServletRequest httpServletRequest = (HttpServletRequest) request;
-       // 对request包装增强
-       HttpServletRequest myrequest = new MyRequest(httpServletRequest);
-       chain.doFilter(myrequest, response);
-  }
-
-   @Override
-   public void init(FilterConfig filterConfig) throws ServletException {
-  }
-
-}
-
-//自定义request对象，HttpServletRequest的包装类
-class MyRequest extends HttpServletRequestWrapper {
-
-   private HttpServletRequest request;
-   //是否编码的标记
-   private boolean hasEncode;
-   //定义一个可以传入HttpServletRequest对象的构造函数，以便对其进行装饰
-   public MyRequest(HttpServletRequest request) {
-       super(request);// super必须写
-       this.request = request;
-  }
-
-   // 对需要增强方法 进行覆盖
-   @Override
-   public Map getParameterMap() {
-       // 先获得请求方式
-       String method = request.getMethod();
-       if (method.equalsIgnoreCase("post")) {
-           // post请求
-           try {
-               // 处理post乱码
-               request.setCharacterEncoding("utf-8");
-               return request.getParameterMap();
-          } catch (UnsupportedEncodingException e) {
-               e.printStackTrace();
-          }
-      } else if (method.equalsIgnoreCase("get")) {
-           // get请求
-           Map<String, String[]> parameterMap = request.getParameterMap();
-           if (!hasEncode) { // 确保get手动编码逻辑只运行一次
-               for (String parameterName : parameterMap.keySet()) {
-                   String[] values = parameterMap.get(parameterName);
-                   if (values != null) {
-                       for (int i = 0; i < values.length; i++) {
-                           try {
-                               // 处理get乱码
-                               values[i] = new String(values[i]
-                                      .getBytes("ISO-8859-1"), "utf-8");
-                          } catch (UnsupportedEncodingException e) {
-                               e.printStackTrace();
-                          }
-                      }
-                  }
-              }
-               hasEncode = true;
-          }
-           return parameterMap;
-      }
-       return super.getParameterMap();
-  }
-
-   //取一个值
-   @Override
-   public String getParameter(String name) {
-       Map<String, String[]> parameterMap = getParameterMap();
-       String[] values = parameterMap.get(name);
-       if (values == null) {
-           return null;
-      }
-       return values[0]; // 取回参数的第一个值
-  }
-
-   //取所有值
-   @Override
-   public String[] getParameterValues(String name) {
-       Map<String, String[]> parameterMap = getParameterMap();
-       String[] values = parameterMap.get(name);
-       return values;
-  }
-}
-```
-
-这个也是我在网上找的一些大神写的，一般情况下，SpringMVC默认的乱码处理就已经能够很好的解决了！
-
-**然后在web.xml中配置这个过滤器即可！**
-
-乱码问题，需要平时多注意，在尽可能能设置编码的地方，都设置为统一编码 UTF-8！
-
-有了这些知识，我们马上就可以进行SSM整合了！
-
-# 8、Json交互处理（Jackson和fastjson）
-
-****
-
-## 8.1、什么是JSON？
-
-- JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式，目前使用特别广泛。
-- 采用完全独立于编程语言的**文本格式**来存储和表示数据。
-- 简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。
-- 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。
-
-在 JavaScript 语言中，一切都是对象。因此，任何JavaScript 支持的类型都可以通过 JSON 来表示，例如字符串、数字、对象、数组等。看看他的要求和语法格式：
-
-- 对象表示为键值对，数据由逗号分隔
-- 花括号保存对象
-- 方括号保存数组
-
-**JSON 键值对**是用来保存 JavaScript 对象的一种方式，和 JavaScript 对象的写法也大同小异，键/值对组合中的键名写在前面并用双引号 "" 包裹，使用冒号 : 分隔，然后紧接着值：
-
-```java
-{"name": "QinJiang"}
-{"age": "3"}
-{"sex": "男"}
-```
-
-很多人搞不清楚 JSON 和 JavaScript 对象的关系，甚至连谁是谁都不清楚。其实，可以这么理解：
-
-JSON 是 JavaScript 对象的字符串表示法，它使用文本表示一个 JS 对象的信息，本质是一个字符串。
-
-```java
-var obj = {a: 'Hello', b: 'World'}; //这是一个对象，注意键名也是可以使用引号包裹的
-var json = '{"a": "Hello", "b": "World"}'; //这是一个 JSON 字符串，本质是一个字符串
-```
-
-**JSON 和 JavaScript 对象互转**
-
-要实现从JSON字符串转换为JavaScript 对象，使用 JSON.parse() 方法：
-
-```swift
-var obj = JSON.parse('{"a": "Hello", "b": "World"}');
-//结果是 {a: 'Hello', b: 'World'}
-```
-
-要实现从JavaScript 对象转换为JSON字符串，使用 JSON.stringify() 方法：
-
-```javascript
-var json = JSON.stringify({a: 'Hello', b: 'World'});
-//结果是 '{"a": "Hello", "b": "World"}'
-```
-
-**代码测试**
-
-1、新建一个module ，springmvc-05-json ， 添加web的支持
-
-2、在web目录下新建一个 json-1.html ， 编写测试内容
-
-```html
-<!DOCTYPE html>
-<html lang="en">
-<head>
-   <meta charset="UTF-8">
-   <title>JSON_秦疆</title>
-</head>
-<body>
-
-<script type="text/javascript">
-   //编写一个js的对象
-   var user = {
-       name:"秦疆",
-       age:3,
-       sex:"男"
-  };
-   //将js对象转换成json字符串
-   var str = JSON.stringify(user);
-   console.log(str);
-   
-   //将json字符串转换为js对象
-   var user2 = JSON.parse(str);
-   console.log(user2.age,user2.name,user2.sex);
-
-</script>
-
-</body>
-</html>
-```
-
-3、在IDEA中使用浏览器打开，查看控制台输出！
-
-![image-20220408193003790](assets/image-20220408193003790.png)
-
-> Controller返回JSON数据
-
-Jackson应该是目前比较好的json解析工具了
-
-当然工具不止这一个，比如还有阿里巴巴的 fastjson 等等。
-
-> ## **我们这里使用Jackson，使用它需要导入它的jar包；**
-
-```xml
-<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
-<dependency>
-   <groupId>com.fasterxml.jackson.core</groupId>
-   <artifactId>jackson-databind</artifactId>
-   <version>2.9.8</version>
-</dependency>
-```
-
-配置SpringMVC需要的配置
-
-web.xml
-
-```xml
-<?xml version="1.0" encoding="UTF-8"?>
-<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
-        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-        xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
-        version="4.0">
-
-   <!--1.注册servlet-->
-   <servlet>
-       <servlet-name>SpringMVC</servlet-name>
-       <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
-       <!--通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
-       <init-param>
-           <param-name>contextConfigLocation</param-name>
-           <param-value>classpath:springmvc-servlet.xml</param-value>
-       </init-param>
-       <!-- 启动顺序，数字越小，启动越早 -->
-       <load-on-startup>1</load-on-startup>
-   </servlet>
-
-   <!--所有请求都会被springmvc拦截 -->
-   <servlet-mapping>
-       <servlet-name>SpringMVC</servlet-name>
-       <url-pattern>/</url-pattern>
-   </servlet-mapping>
-
-   <filter>
-       <filter-name>encoding</filter-name>
-       <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
-       <init-param>
-           <param-name>encoding</param-name>
-           <param-value>utf-8</param-value>
-       </init-param>
-   </filter>
-   <filter-mapping>
-       <filter-name>encoding</filter-name>
-       <url-pattern>/*</url-pattern>
-   </filter-mapping>
-
-</web-app>
-```
-
-springmvc-servlet.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"
-      xmlns:context="http://www.springframework.org/schema/context"
-      xmlns:mvc="http://www.springframework.org/schema/mvc"
-      xsi:schemaLocation="http://www.springframework.org/schema/beans
-       http://www.springframework.org/schema/beans/spring-beans.xsd
-       http://www.springframework.org/schema/context
-       https://www.springframework.org/schema/context/spring-context.xsd
-       http://www.springframework.org/schema/mvc
-       https://www.springframework.org/schema/mvc/spring-mvc.xsd">
-
-   <!-- 自动扫描指定的包，下面所有注解类交给IOC容器管理 -->
-   <context:component-scan base-package="com.th.controller"/>
-
-   <!-- 视图解析器 -->
-   <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
-         id="internalResourceViewResolver">
-       <!-- 前缀 -->
-       <property name="prefix" value="/WEB-INF/jsp/" />
-       <!-- 后缀 -->
-       <property name="suffix" value=".jsp" />
-   </bean>
-
-</beans>
-```
-
-我们随便编写一个User的实体类，然后我们去编写我们的测试Controller；
-
-```java
-package com.th.pojo;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-//需要导入lombok
-@Data
-@AllArgsConstructor
-@NoArgsConstructor
-public class User {
-
-   private String name;
-   private int age;
-   private String sex;
-   
-}
-```
-
-这里我们需要两个新东西，一个是@ResponseBody，一个是ObjectMapper对象，我们看下具体的用法
-
-编写一个Controller；
-
-```java
-@Controller
-public class UserController {
-
-   @RequestMapping("/json1")
-   @ResponseBody
-   public String json1() throws JsonProcessingException {
-       //创建一个jackson的对象映射器，用来解析数据
-       ObjectMapper mapper = new ObjectMapper();
-       //创建一个对象
-       User user = new User("秦疆1号", 3, "男");
-       //将我们的对象解析成为json格式
-       String str = mapper.writeValueAsString(user);
-       //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
-       return str;
-  }
-
-}
-```
-
-配置Tomcat ， 启动测试一下！
-
-http://localhost:8080/json1
-
-![image-20220408194053926](assets/image-20220408194053926.png)
-
-发现出现了乱码问题，我们需要设置一下他的编码格式为utf-8，以及它返回的类型；
-
-通过@RequestMaping的produces属性来实现，修改下代码
-
-```java
-//produces:指定响应体返回类型和编码
-@RequestMapping(value = "/json1",produces = "application/json;charset=utf-8")
-```
-
-再次测试， http://localhost:8080/json1 ， 乱码问题OK！
-
-![image-20220408194213357](assets/image-20220408194213357.png)
-
-【注意：使用json记得处理乱码问题】
-
-## 8.2、 乱码解决
-
-**乱码统一解决**
-
-上一种方法比较麻烦，如果项目中有许多请求则每一个都要添加，可以通过Spring配置统一指定，这样就不用每次都去处理了！
-
-我们可以在springmvc的配置文件上添加一段消息StringHttpMessageConverter转换配置！
-
-```xml
-<mvc:annotation-driven>
-   <mvc:message-converters register-defaults="true">
-       <bean class="org.springframework.http.converter.StringHttpMessageConverter">
-           <constructor-arg value="UTF-8"/>
-       </bean>
-       <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
-           <property name="objectMapper">
-               <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
-                   <property name="failOnEmptyBeans" value="false"/>
-               </bean>
-           </property>
-       </bean>
-   </mvc:message-converters>
-</mvc:annotation-driven>
-```
-
-**返回json字符串统一解决**
-
-在类上直接使用 **@RestController** ，这样子，里面所有的方法都只会返回 json 字符串了，不用再每一个都添加@ResponseBody ！我们在前后端分离开发中，一般都使用 @RestController ，十分便捷！
-
-```java
-@RestController
-public class UserController {
-
-   //produces:指定响应体返回类型和编码
-   @RequestMapping(value = "/json1")
-   public String json1() throws JsonProcessingException {
-       //创建一个jackson的对象映射器，用来解析数据
-       ObjectMapper mapper = new ObjectMapper();
-       //创建一个对象
-       User user = new User("秦疆1号", 3, "男");
-       //将我们的对象解析成为json格式
-       String str = mapper.writeValueAsString(user);
-       //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
-       return str;
-  }
-
-}
-```
-
-启动tomcat测试，结果都正常输出！
-
-## 8.3、测试集合输出
-
-增加一个新的方法
-
-```java
-@RequestMapping("/json2")
-public String json2() throws JsonProcessingException {
-
-   //创建一个jackson的对象映射器，用来解析数据
-   ObjectMapper mapper = new ObjectMapper();
-   //创建一个对象
-   User user1 = new User("秦疆1号", 3, "男");
-   User user2 = new User("秦疆2号", 3, "男");
-   User user3 = new User("秦疆3号", 3, "男");
-   User user4 = new User("秦疆4号", 3, "男");
-   List<User> list = new ArrayList<User>();
-   list.add(user1);
-   list.add(user2);
-   list.add(user3);
-   list.add(user4);
-
-   //将我们的对象解析成为json格式
-   String str = mapper.writeValueAsString(list);
-   return str;
-}
-```
-
-运行结果 : 十分完美，没有任何问题！
-
-![image-20220408194915059](assets/image-20220408194915059.png)
-
-## 8.4、输出时间对象
-
-增加一个新的方法
-
-```java
-@RequestMapping("/json3")
-public String json3() throws JsonProcessingException {
-
-   ObjectMapper mapper = new ObjectMapper();
-
-   //创建时间一个对象，java.util.Date
-   Date date = new Date();
-   //将我们的对象解析成为json格式
-   String str = mapper.writeValueAsString(date);
-   return str;
-}
-```
-
-运行结果 :
-
-![image-20220408195035464](assets/image-20220408195035464.png)
-
-- 默认日期格式会变成一个数字，是1970年1月1日到当前日期的毫秒数！
-- Jackson 默认是会把时间转成timestamps形式
-
-**解决方案：取消timestamps形式 ， 自定义时间格式**
-
-```java
-@RequestMapping("/json4")
-public String json4() throws JsonProcessingException {
-
-   ObjectMapper mapper = new ObjectMapper();
-
-   //不使用时间戳的方式
-   mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
-   //自定义日期格式对象
-   SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
-   //指定日期格式
-   mapper.setDateFormat(sdf);
-
-   Date date = new Date();
-   String str = mapper.writeValueAsString(date);
-
-   return str;
-}
-```
-
-运行结果 : 成功的输出了时间！
-
-![image-20220408195306184](assets/image-20220408195306184.png)
-
-## 8.5、抽取为工具类
-
-**如果要经常使用的话，这样是比较麻烦的，我们可以将这些代码封装到一个工具类中；我们去编写下**
-
-```java
-package com.th.utils;
-
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.SerializationFeature;
-
-import java.text.SimpleDateFormat;
-
-public class JsonUtils {
-   
-   public static String getJson(Object object) {
-       return getJson(object,"yyyy-MM-dd HH:mm:ss");
-  }
-
-   public static String getJson(Object object,String dateFormat) {
-       ObjectMapper mapper = new ObjectMapper();
-       //不使用时间差的方式
-       mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
-       //自定义日期格式对象
-       SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
-       //指定日期格式
-       mapper.setDateFormat(sdf);
-       try {
-           return mapper.writeValueAsString(object);
-      } catch (JsonProcessingException e) {
-           e.printStackTrace();
-      }
-       return null;
-  }
-}
-```
-
-我们使用工具类，代码就更加简洁了！
-
-```java
-@RequestMapping("/json5")
-public String json5() throws JsonProcessingException {
-   Date date = new Date();
-   String json = JsonUtils.getJson(date);
-   return json;
-}
-```
-
-大功告成！完美！
-
-## 8.6、FastJson（比较好）
-
-fastjson.jar是阿里开发的一款专门用于Java开发的包，可以方便的实现json对象与JavaBean对象的转换，实现JavaBean对象与json字符串的转换，实现json对象与json字符串的转换。实现json的转换方法很多，最后的实现结果都是一样的。
-
-fastjson 的 pom依赖！
-
-```xml
-<dependency>
-   <groupId>com.alibaba</groupId>
-   <artifactId>fastjson</artifactId>
-   <version>1.2.60</version>
-</dependency>
-```
-
-fastjson 三个主要的类：
-
-**JSONObject 代表 json 对象**
-
-- JSONObject实现了Map接口, 猜想 JSONObject底层操作是由Map实现的。
-- JSONObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用诸如size()，isEmpty()等方法获取"键：值"对的个数和判断是否为空。其本质是通过实现Map接口并调用接口中的方法完成的。
-
-**JSONArray 代表 json 对象数组**
-
-- 内部是有List接口中的方法来完成操作的。
-
-**JSON代表 JSONObject和JSONArray的转化**
-
-- JSON类源码分析与使用
-- 仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间的相互转化。
-
-**代码测试，我们新建一个FastJsonDemo 类**
-
-```java
-package com.th.controller;
-
-import com.alibaba.fastjson.JSON;
-import com.alibaba.fastjson.JSONObject;
-import com.th.pojo.User;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class FastJsonDemo {
-   public static void main(String[] args) {
-       //创建一个对象
-       User user1 = new User("秦疆1号", 3, "男");
-       User user2 = new User("秦疆2号", 3, "男");
-       User user3 = new User("秦疆3号", 3, "男");
-       User user4 = new User("秦疆4号", 3, "男");
-       List<User> list = new ArrayList<User>();
-       list.add(user1);
-       list.add(user2);
-       list.add(user3);
-       list.add(user4);
-
-       System.out.println("*******Java对象 转 JSON字符串*******");
-       String str1 = JSON.toJSONString(list);
-       System.out.println("JSON.toJSONString(list)==>"+str1);
-       String str2 = JSON.toJSONString(user1);
-       System.out.println("JSON.toJSONString(user1)==>"+str2);
-
-       System.out.println("\n****** JSON字符串 转 Java对象*******");
-       User jp_user1=JSON.parseObject(str2,User.class);
-       System.out.println("JSON.parseObject(str2,User.class)==>"+jp_user1);
-
-       System.out.println("\n****** Java对象 转 JSON对象 ******");
-       JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2);
-       System.out.println("(JSONObject) JSON.toJSON(user2)==>"+jsonObject1.getString("name"));
-
-       System.out.println("\n****** JSON对象 转 Java对象 ******");
-       User to_java_user = JSON.toJavaObject(jsonObject1, User.class);
-       System.out.println("JSON.toJavaObject(jsonObject1, User.class)==>"+to_java_user);
-  }
-}
-```
-
-这种工具类，我们只需要掌握使用就好了，在使用的时候在根据具体的业务去找对应的实现。和以前的commons-io那种工具包一样，拿来用就好了！
-
-Json在我们数据传输中十分重要，一定要学会使用！
-
-# 9、Ajax研究
-
-***
-
-## 9.1、简介
-
-- **AJAX = Asynchronous JavaScript and XML（异步的 JavaScript 和 XML）。**
-- AJAX 是一种在无需重新加载整个网页的情况下，能够更新部分网页的技术。
-- **Ajax 不是一种新的编程语言，而是一种用于创建更好更快以及交互性更强的Web应用程序的技术。**
-- 在 2005 年，Google 通过其 Google Suggest 使 AJAX 变得流行起来。Google Suggest能够自动帮你完成搜索单词。
-- Google Suggest 使用 AJAX 创造出动态性极强的 web 界面：当您在谷歌的搜索框输入关键字时，JavaScript 会把这些字符发送到服务器，然后服务器会返回一个搜索建议的列表。
-- 就和国内百度的搜索框一样!
-- 传统的网页(即不用ajax技术的网页)，想要更新内容或者提交一个表单，都需要重新加载整个网页。
-- 使用ajax技术的网页，通过在后台服务器进行少量的数据交换，就可以实现异步局部更新。
-- 使用Ajax，用户可以创建接近本地桌面应用的直接、高可用、更丰富、更动态的Web用户界面。
-
-## 9.2、伪造Ajax
-
-我们可以使用前端的一个标签来伪造一个ajax的样子。iframe标签
-
-1、新建一个module ：sspringmvc-06-ajax ， 导入web支持！
-
-2、编写一个 ajax-frame.html 使用 iframe 测试，感受下效果
-
-```html
-<!DOCTYPE html>
-<html>
-<head lang="en">
-   <meta charset="UTF-8">
-   <title>thshen</title>
-</head>
-<body>
-
-<script type="text/javascript">
-   window.onload = function(){
-       var myDate = new Date();
-       document.getElementById('currentTime').innerText = myDate.getTime();
-  };
-
-   function LoadPage(){
-       var targetUrl =  document.getElementById('url').value;
-       console.log(targetUrl);
-       document.getElementById("iframePosition").src = targetUrl;
-  }
-
-</script>
-
-<div>
-   <p>请输入要加载的地址：<span id="currentTime"></span></p>
-   <p>
-       <input id="url" type="text" value="https://www.baidu.com/"/>
-       <input type="button" value="提交" onclick="LoadPage()">
-   </p>
-</div>
-
-<div>
-   <h3>加载页面位置：</h3>
-   <iframe id="iframePosition" style="width: 100%;height: 500px;"></iframe>
-</div>
-
-</body>
-</html>
-```
-
-3、使用IDEA开浏览器测试一下！
-
-**利用AJAX可以做：**
-
-- 注册时，输入用户名自动检测用户是否已经存在。
-- 登陆时，提示用户名密码错误
-- 删除数据行时，将行ID发送到后台，后台在数据库中删除，数据库删除成功后，在页面DOM中将数据行也删除。
-- ....等等
-
-## 9.3、jQuery.ajax
-
-纯JS原生实现Ajax我们不去讲解这里，直接使用jquery提供的，方便学习和使用，避免重复造轮子，有兴趣的同学可以去了解下JS原生XMLHttpRequest ！
-
-Ajax的核心是XMLHttpRequest对象(XHR)。XHR为向服务器发送请求和解析服务器响应提供了接口。能够以异步方式从服务器获取新数据。
-
-jQuery 提供多个与 AJAX 有关的方法。
-
-通过 jQuery AJAX 方法，您能够使用 HTTP Get 和 HTTP Post 从远程服务器上请求文本、HTML、XML 或 JSON – 同时您能够把这些外部数据直接载入网页的被选元素中。
-
-jQuery 不是生产者，而是大自然搬运工。
-
-jQuery Ajax本质就是 XMLHttpRequest，对他进行了封装，方便调用！
-
-```java
-jQuery.ajax(...)
-      部分参数：
-            url：请求地址
-            type：请求方式，GET、POST（1.9.0之后用method）
-        headers：请求头
-            data：要发送的数据
-    contentType：即将发送信息至服务器的内容编码类型(默认: "application/x-www-form-urlencoded; charset=UTF-8")
-          async：是否异步
-        timeout：设置请求超时时间（毫秒）
-      beforeSend：发送请求前执行的函数(全局)
-        complete：完成之后执行的回调函数(全局)
-        success：成功之后执行的回调函数(全局)
-          error：失败之后执行的回调函数(全局)
-        accepts：通过请求头发送给服务器，告诉服务器当前客户端可接受的数据类型
-        dataType：将服务器端返回的数据转换成指定类型
-          "xml": 将服务器端返回的内容转换成xml格式
-          "text": 将服务器端返回的内容转换成普通文本格式
-          "html": 将服务器端返回的内容转换成普通文本格式，在插入DOM中时，如果包含JavaScript标签，则会尝试去执行。
-        "script": 尝试将返回值当作JavaScript去执行，然后再将服务器端返回的内容转换成普通文本格式
-          "json": 将服务器端返回的内容转换成相应的JavaScript对象
-        "jsonp": JSONP 格式使用 JSONP 形式调用函数时，如 "myurl?callback=?" jQuery 将自动替换 ? 为正确的函数名，以执行回调函数
-```
-
-**我们来个简单的测试，使用最原始的HttpServletResponse处理 , .最简单 , 最通用**
-
-1、配置web.xml 和 springmvc的配置文件，复制上面案例的即可 【记得静态资源过滤和注解驱动配置上】
-
-```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"
-      xmlns:context="http://www.springframework.org/schema/context"
-      xmlns:mvc="http://www.springframework.org/schema/mvc"
-      xsi:schemaLocation="http://www.springframework.org/schema/beans
-       http://www.springframework.org/schema/beans/spring-beans.xsd
-       http://www.springframework.org/schema/context
-       https://www.springframework.org/schema/context/spring-context.xsd
-       http://www.springframework.org/schema/mvc
-       https://www.springframework.org/schema/mvc/spring-mvc.xsd">
-
-   <!-- 自动扫描指定的包，下面所有注解类交给IOC容器管理 -->
-   <context:component-scan base-package="com.th.controller"/>
-   <mvc:default-servlet-handler />
-   <mvc:annotation-driven />
-
-   <!-- 视图解析器 -->
-   <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
-         id="internalResourceViewResolver">
-       <!-- 前缀 -->
-       <property name="prefix" value="/WEB-INF/jsp/" />
-       <!-- 后缀 -->
-       <property name="suffix" value=".jsp" />
-   </bean>
-
-</beans>
-```
-
-2、编写一个AjaxController
-
-```java
-@RestController
-public class AjaxController {
-    @RequestMapping("/t1")
-    public String test() {
-        return "hello";
-    }
-    @RequestMapping("/a1")
-    public void a1(String name, HttpServletResponse response) throws IOException {
-        if ("admin".equals(name)){
-            response.getWriter().print("true");
-        }else{
-            response.getWriter().print("false");
-        }
-    }
-
-
-}
-```
-
-3、导入jquery ， 可以使用在线的CDN ， 也可以下载导入
-
-```js
-<script src="https://code.jquery.com/jquery-3.1.1.js"></script>
-<script src="${pageContext.request.contextPath}/statics/js/jquery-3.1.1.js"></script>
-```
-
-4、编写index.jsp测试
-
-```html
-<%@ page contentType="text/html;charset=UTF-8" language="java" %>
-<html>
- <head>
-   <title>$Title$</title>
-  <%--<script src="https://code.jquery.com/jquery-3.1.1.min.js"></script>--%>
-   <script src="${pageContext.request.contextPath}/statics/js/jquery-3.1.1.js"></script>
-   <script>
-       function a1(){
-           $.post({
-               url:"${pageContext.request.contextPath}/a1",
-               data:{'name':$("#txtName").val()},
-               success:function (data,status) {
-                   alert(data);
-                   alert(status);
-              }
-          });
-      }
-   </script>
- </head>
- <body>
-
-<%--onblur：失去焦点触发事件--%>
-用户名:<input type="text" id="txtName" onblur="a1()"/>
-
- </body>
-</html>
-```
-
-5、启动tomcat测试！打开浏览器的控制台，当我们鼠标离开输入框的时候，可以看到发出了一个ajax的请求！是后台返回给我们的结果！测试成功！
-
-## 9.4、**Springmvc实现**
-
-实体类user
-
-```java
-@Data
-@AllArgsConstructor
-@NoArgsConstructor
-public class User {
-
-   private String name;
-   private int age;
-   private String sex;
-
-}
-```
-
-我们来获取一个集合对象，展示到前端页面
-
-```java
-@RequestMapping("/a2")
-public List<User> ajax2(){
-   List<User> list = new ArrayList<User>();
-   list.add(new User("秦疆1号",3,"男"));
-   list.add(new User("秦疆2号",3,"男"));
-   list.add(new User("秦疆3号",3,"男"));
-   return list; //由于@RestController注解，将list转成json格式返回
-}
-```
-
-前端页面
-
-```html
-<%@ page contentType="text/html;charset=UTF-8" language="java" %>
-<html>
-<head>
-    <title>Title</title>
-    <script src="${pageContext.request.contextPath}/statics/js/jquery-3.1.1.js"></script>
-    <script>
-
-        $(function () {
-            $("#btn").click(function () {
-                // console.log('点击事件成功')
-                // $.post(url,param,[可以省略],success)
-                $.post("${pageContext.request.contextPath}/a2", function (data) {
-                    console.log(data[0].name);
-                    let html = "";
-                    for (let i = 0; i < data.length; i++) {
-                        html += `<tr>
-                                    <td>${"${data[i].name}"}</td>
-                                    <td>${"${data[i].age}"}</td>
-                                    <td>${"${data[i].sex}"}</td>
-                                </tr>`
-                    }
-                    $("#content").html(html)
-                    console.log(html)
-                })
-            })
-        })
-    </script>
-</head>
-<body>
-<input type="button" value="加载数据" id="btn">
-<table>
-    <thead>
-    <tr>
-        <td>姓名</td>
-        <td>年龄</td>
-        <td>性别</td>
-    </tr>
-    </thead>
-    <tbody id="content">
-    <%--数据：后台--%>
-    </tbody>
-</table>
-</body>
-</html>
-```
-
-**成功实现了数据回显！可以体会一下Ajax的好处！**
-
-## 9.5、注册提示效果
-
-我们再测试一个小Demo，思考一下我们平时注册时候，输入框后面的实时提示怎么做到的；如何优化
-
-我们写一个Controller
-
-```java
-@RequestMapping("/a3")
-public String ajax3(String name,String pwd){
-   String msg = "";
-   //模拟数据库中存在数据
-   if (name!=null){
-       if ("admin".equals(name)){
-           msg = "OK";
-      }else {
-           msg = "用户名输入错误";
-      }
-  }
-   if (pwd!=null){
-       if ("123456".equals(pwd)){
-           msg = "OK";
-      }else {
-           msg = "密码输入有误";
-      }
-  }
-   return msg; //由于@RestController注解，将msg转成json格式返回
-}
-```
-
-前端页面 login.jsp
-
-```html
-<%@ page contentType="text/html;charset=UTF-8" language="java" %>
-<html>
-<head>
-   <title>ajax</title>
-   <script src="${pageContext.request.contextPath}/statics/js/jquery-3.1.1.min.js"></script>
-   <script>
-
-       function a1(){
-           $.post({
-               url:"${pageContext.request.contextPath}/a3",
-               data:{'name':$("#name").val()},
-               success:function (data) {
-                   if (data.toString()=='OK'){
-                       $("#userInfo").css("color","green");
-                  }else {
-                       $("#userInfo").css("color","red");
-                  }
-                   $("#userInfo").html(data);
-              }
-          });
-      }
-       function a2(){
-           $.post({
-               url:"${pageContext.request.contextPath}/a3",
-               data:{'pwd':$("#pwd").val()},
-               success:function (data) {
-                   if (data.toString()=='OK'){
-                       $("#pwdInfo").css("color","green");
-                  }else {
-                       $("#pwdInfo").css("color","red");
-                  }
-                   $("#pwdInfo").html(data);
-              }
-          });
-      }
-
-   </script>
-</head>
-<body>
-<p>
-  用户名:<input type="text" id="name" onblur="a1()"/>
-   <span id="userInfo"></span>
-</p>
-<p>
-  密码:<input type="text" id="pwd" onblur="a2()"/>
-   <span id="pwdInfo"></span>
-</p>
-</body>
-</html>
-```
-
-【记得处理json乱码问题】
-
-```xml
-<!--JSON乱码问题配置-->
-    <mvc:annotation-driven>
-        <mvc:message-converters register-defaults="true">
-            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
-                <constructor-arg value="UTF-8"/>
-            </bean>
-            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
-                <property name="objectMapper">
-                    <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
-                        <property name="failOnEmptyBeans" value="false"/>
-                    </bean>
-                </property>
-            </bean>
-        </mvc:message-converters>
-    </mvc:annotation-driven>
-```
-
-测试一下效果，动态请求响应，局部刷新，就是如此！
-
-# 10、拦截器
-
-***
-
-## 10.1、概述
-
-SpringMVC的处理器拦截器类似于Servlet开发中的过滤器Filter,用于对处理器进行预处理和后处理。开发者可以自己定义一些拦截器来实现特定的功能。
-
-**过滤器与拦截器的区别：**拦截器是AOP思想的具体应用。
-
-**过滤器**
-
-- servlet规范中的一部分，任何java web工程都可以使用
-- 在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截
-
-**拦截器**
-
-- 拦截器是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能使用
-- 拦截器只会拦截访问的控制器方法， 如果访问的是jsp/html/css/image/js是不会进行拦截的
-
-![image-20220409164214025](assets/image-20220409164214025.png)
-
-## 10.2、自定义拦截器
-
-那如何实现拦截器呢？
-
-想要自定义拦截器，必须实现 HandlerInterceptor 接口。
-
-1、新建一个Moudule ， springmvc-07-Interceptor ， 添加web支持
-
-2、配置web.xml 和 springmvc-servlet.xml 文件
-
-3、编写一个拦截器
-
-```java
-package com.th.interceptor;
-
-import org.springframework.web.servlet.HandlerInterceptor;
-import org.springframework.web.servlet.ModelAndView;
-
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-
-public class MyInterceptor implements HandlerInterceptor {
-
-   //在请求处理的方法之前执行
-   //如果返回true执行下一个拦截器
-   //如果返回false就不执行下一个拦截器
-   public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
-       System.out.println("------------处理前------------");
-       return true;
-  }
-
-   //在请求处理方法执行之后执行
-   public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
-       System.out.println("------------处理后------------");
-  }
-
-   //在dispatcherServlet处理后执行,做清理工作.
-   public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
-       System.out.println("------------清理------------");
-  }
-}
-```
-
-4、在springmvc的配置文件中配置拦截器
-
-```xml
-<!--关于拦截器的配置-->
-<mvc:interceptors>
-   <mvc:interceptor>
-       <!--/** 包括路径及其子路径-->
-       <!--/admin/* 拦截的是/admin/add等等这种 , /admin/add/user不会被拦截-->
-       <!--/admin/** 拦截的是/admin/下的所有-->
-       <mvc:mapping path="/**"/>
-       <!--bean配置的就是拦截器-->
-       <bean class="com.config.MyInterceptor"/>
-   </mvc:interceptor>
-</mvc:interceptors>
-```
-
-5、编写一个Controller，接收请求
-
-```java
-@RestController
-public class TestController {
-
-    @RequestMapping("/t1")
-    public String test() {
-        return "test";
-    }
-}
-```
-
-6、前端 index.jsp
-
-```html
-<a href="${pageContext.request.contextPath}/interceptor">拦截器测试</a>
-```
-
-7、启动tomcat 测试一下！
-
-## 10.3、验证用户是否登录 
-
-**实现思路**
-
-1、有一个登陆页面，需要写一个controller访问页面。
-
-2、登陆页面有一提交表单的动作。需要在controller中处理。判断用户名密码是否正确。如果正确，向session中写入用户信息。*返回登陆成功。*
-
-3、拦截用户请求，判断用户是否登陆。如果用户已经登陆。放行， 如果用户未登陆，跳转到登陆页面
-
-**测试：**
-
-1、编写一个登陆页面 login.jsp
-
-```html
-<%@ page contentType="text/html;charset=UTF-8" language="java" %>
-<html>
-<head>
-   <title>Title</title>
-</head>
-
-<h1>登录页面</h1>
-<hr>
-
-<body>
-<form action="${pageContext.request.contextPath}/user/login">
-  用户名：<input type="text" name="username"> <br>
-  密码：<input type="password" name="pwd"> <br>
-   <input type="submit" value="提交">
-</form>
-</body>
-</html>
-```
-
-2、编写一个Controller处理请求
-
-```java
-package com.th.controller;
-
-import org.springframework.stereotype.Controller;
-import org.springframework.web.bind.annotation.RequestMapping;
-
-import javax.servlet.http.HttpSession;
-
-@Controller
-@RequestMapping("/user")
-public class UserController {
-
-   //跳转到登陆页面
-   @RequestMapping("/jumplogin")
-   public String jumpLogin() throws Exception {
-       return "login";
-  }
-
-   //跳转到成功页面
-   @RequestMapping("/jumpSuccess")
-   public String jumpSuccess() throws Exception {
-       return "success";
-  }
-
-   //登陆提交
-   @RequestMapping("/login")
-   public String login(HttpSession session, String username, String pwd) throws Exception {
-       // 向session记录用户身份信息
-       System.out.println("接收前端==="+username);
-       session.setAttribute("user", username);
-       return "success";
-  }
-
-   //退出登陆
-   @RequestMapping("logout")
-   public String logout(HttpSession session) throws Exception {
-       // session 过期
-       session.invalidate();
-       return "login";
-  }
-}
-```
-
-3、编写一个登陆成功的页面 success.jsp
-
-```html
-<%@ page contentType="text/html;charset=UTF-8" language="java" %>
-<html>
-<head>
-   <title>Title</title>
-</head>
-<body>
-
-<h1>登录成功页面</h1>
-<hr>
-
-${user}
-<a href="${pageContext.request.contextPath}/user/logout">注销</a>
-</body>
-</html>
-```
-
-4、在 index 页面上测试跳转！启动Tomcat 测试，未登录也可以进入主页！
-
-```html
-<%@ page contentType="text/html;charset=UTF-8" language="java" %>
-<html>
- <head>
-   <title>$Title$</title>
- </head>
- <body>
- <h1>index</h1>
- <hr>
-<%--登录--%>
- <a href="${pageContext.request.contextPath}/user/jumplogin">登录</a>
- <a href="${pageContext.request.contextPath}/user/jumpSuccess">成功页面</a>
- </body>
-</html>
-```
-
-5、编写用户登录拦截器
-
-```java
-package com.th.interceptor;
-
-import org.springframework.web.servlet.HandlerInterceptor;
-import org.springframework.web.servlet.ModelAndView;
-
-import javax.servlet.ServletException;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-import javax.servlet.http.HttpSession;
-import java.io.IOException;
-
-public class LoginInterceptor implements HandlerInterceptor {
-
-   public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException {
-       // 如果是登陆页面则放行
-       System.out.println("uri: " + request.getRequestURI());
-       if (request.getRequestURI().contains("login")) {
-           return true;
-      }
-
-       HttpSession session = request.getSession();
-
-       // 如果用户已登陆也放行
-       if(session.getAttribute("user") != null) {
-           return true;
-      }
-
-       // 用户没有登陆跳转到登陆页面
-       request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request, response);
-       return false;
-  }
-
-   public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
-
-  }
-   
-   public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
-
-  }
-}
-```
-
-6、在Springmvc的配置文件中注册拦截器
-
-```xml
-    <!--关于拦截器的配置-->
-    <mvc:interceptors>
-        <mvc:interceptor>
-            <mvc:mapping path="/**"/>
-            <bean id="loginInterceptor" class="com.config.LoginInterceptor"/>
-        </mvc:interceptor>
-    </mvc:interceptors>
-```
-
-7、再次重启Tomcat测试！
-
-**OK，测试登录拦截功能无误.**
-
-
-
-# 11、文件上传和下载
-
-***
-
-## 11.1、准备工作
-
-文件上传是项目开发中最常见的功能之一 ,springMVC 可以很好的支持文件上传，但是SpringMVC上下文中默认没有装配MultipartResolver，因此默认情况下其不能处理文件上传工作。如果想使用Spring的文件上传功能，则需要在上下文中配置MultipartResolver。
-
-***前端表单要求：为了能上传文件，必须将表单的method设置为POST，并将enctype设置为multipart/form-data。***只有在这样的情况下，浏览器才会把用户选择的文件以二进制数据发送给服务器；
-
-**对表单中的 enctype 属性做个详细的说明：**
-
-- application/x-www=form-urlencoded：默认方式，只处理表单域中的 value 属性值，采用这种编码方式的表单会将表单域中的值处理成 URL 编码方式。
-- multipart/form-data：这种编码方式会以二进制流的方式来处理表单数据，这种编码方式会把文件域指定文件的内容也封装到请求参数中，不会对字符编码。
-- text/plain：除了把空格转换为 "+" 号外，其他字符都不做编码处理，这种方式适用直接通过表单发送邮件。
-
-```html
-<form action="" enctype="multipart/form-data" method="post">
-   <input type="file" name="file"/>
-   <input type="submit">
-</form>
-```
-
-一旦设置了enctype为multipart/form-data，浏览器即会采用二进制流的方式来处理表单数据，而对于文件上传的处理则涉及在服务器端解析原始的HTTP响应。在2003年，Apache Software Foundation发布了开源的Commons FileUpload组件，其很快成为Servlet/JSP程序员上传文件的最佳选择。
-
-- Servlet3.0规范已经提供方法来处理文件上传，但这种上传需要在Servlet中完成。
-- 而Spring MVC则提供了更简单的封装。
-- Spring MVC为文件上传提供了直接的支持，这种支持是用即插即用的MultipartResolver实现的。
-- Spring MVC使用Apache Commons FileUpload技术实现了一个MultipartResolver实现类：
-- CommonsMultipartResolver。因此，SpringMVC的文件上传还需要依赖Apache Commons FileUpload的组件。
-
-## 11.2、文件上传
-
-1、导入文件上传的jar包，commons-fileupload ， Maven会自动帮我们导入他的依赖包 commons-io包；
-
-```xml
-<!--文件上传-->
-<dependency>
-   <groupId>commons-fileupload</groupId>
-   <artifactId>commons-fileupload</artifactId>
-   <version>1.3.3</version>
-</dependency>
-<!--servlet-api导入高版本的-->
-<dependency>
-   <groupId>javax.servlet</groupId>
-   <artifactId>javax.servlet-api</artifactId>
-   <version>4.0.1</version>
-</dependency>
-```
-
-2、配置bean：multipartResolver
-
-【**注意！！！这个bena的id必须为：multipartResolver ， 否则上传文件会报400的错误！在这里栽过坑,教训！**】
-
-```xml
-<!--文件上传配置-->
-<bean id="multipartResolver"  class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
-   <!-- 请求的编码格式，必须和jSP的pageEncoding属性一致，以便正确读取表单的内容，默认为ISO-8859-1 -->
-   <property name="defaultEncoding" value="utf-8"/>
-   <!-- 上传文件大小上限，单位为字节（10485760=10M） -->
-   <property name="maxUploadSize" value="10485760"/>
-   <property name="maxInMemorySize" value="40960"/>
-</bean>
-```
-
-CommonsMultipartFile 的 常用方法：
-
-- **String getOriginalFilename()：获取上传文件的原名**
-- **InputStream getInputStream()：获取文件流**
-- **void transferTo(File dest)：将上传文件保存到一个目录文件中**
-
-我们去实际测试一下
-
-3、编写前端页面
-
-```html
-    <form action="${pageContext.request.contextPath}/upload" enctype="multipart/form-data" method="post">
-        <input type="file" name="file"/>
-        <input type="submit">
-    </form>
-```
-
-4、**Controller**
-
-### 法一
-
-```java
-package com.th.controller;
-
-import org.springframework.stereotype.Controller;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestParam;
-import org.springframework.web.multipart.commons.CommonsMultipartFile;
-
-import javax.servlet.http.HttpServletRequest;
-import java.io.*;
-
-@Controller
-public class FileController {
-   //@RequestParam("file") 将name=file控件得到的文件封装成CommonsMultipartFile 对象
-   //批量上传CommonsMultipartFile则为数组即可
-   @RequestMapping("/upload")
-   public String fileUpload(@RequestParam("file") CommonsMultipartFile file , HttpServletRequest request) throws IOException {
-
-       //获取文件名 : file.getOriginalFilename();
-       String uploadFileName = file.getOriginalFilename();
-
-       //如果文件名为空，直接回到首页！
-       if ("".equals(uploadFileName)){
-           return "redirect:/index.jsp";
-      }
-       System.out.println("上传文件名 : "+uploadFileName);
-
-       //上传路径保存设置
-       String path = request.getServletContext().getRealPath("/upload");
-       //如果路径不存在，创建一个
-       File realPath = new File(path);
-       if (!realPath.exists()){
-           realPath.mkdir();
-      }
-       System.out.println("上传文件保存地址："+realPath);
-
-       InputStream is = file.getInputStream(); //文件输入流
-       OutputStream os = new FileOutputStream(new File(realPath,uploadFileName)); //文件输出流
-
-       //读取写出
-       int len=0;
-       byte[] buffer = new byte[1024];
-       while ((len=is.read(buffer))!=-1){
-           os.write(buffer,0,len);
-           os.flush();
-      }
-       os.close();
-       is.close();
-       return "redirect:/index.jsp";
-  }
-}
-```
-
-5、测试上传文件，OK！
-
-**采用file.Transto 来保存上传的文件**
-
-1、编写Controller
-
-### 法二
-
-```java
-/*
-* 采用file.Transto 来保存上传的文件
-*/
-@RequestMapping("/upload2")
-public String  fileUpload2(@RequestParam("file") CommonsMultipartFile file, HttpServletRequest request) throws IOException {
-
-   //上传路径保存设置
-   String path = request.getServletContext().getRealPath("/upload");
-   File realPath = new File(path);
-   if (!realPath.exists()){
-       realPath.mkdir();
-  }
-   //上传文件地址
-   System.out.println("上传文件保存地址："+realPath);
-
-   //通过CommonsMultipartFile的方法直接写文件（注意这个时候）
-   file.transferTo(new File(realPath +"/"+ file.getOriginalFilename()));
-
-   return "redirect:/index.jsp";
-}
-```
-
-2、前端表单提交地址修改
-
-3、访问提交测试，OK！
-
-## 11.3、文件下载
-
-**文件下载步骤：**
-
-1、设置 response 响应头
-
-2、读取文件 -- InputStream
-
-3、写出文件 -- OutputStream
-
-4、执行操作
-
-5、关闭流 （先开后关）
-
-**代码实现：**
-
-```java
-@RequestMapping(value="/download")
-public String downloads(HttpServletResponse response ,HttpServletRequest request) throws Exception{
-   //要下载的图片地址
-   String  path = request.getServletContext().getRealPath("/upload");
-   String  fileName = "基础语法.jpg";
-
-   //1、设置response 响应头
-   response.reset(); //设置页面不缓存,清空buffer
-   response.setCharacterEncoding("UTF-8"); //字符编码
-   response.setContentType("multipart/form-data"); //二进制传输数据
-   //设置响应头
-   response.setHeader("Content-Disposition",
-           "attachment;fileName="+URLEncoder.encode(fileName, "UTF-8"));
-
-   File file = new File(path,fileName);
-   //2、 读取文件--输入流
-   InputStream input=new FileInputStream(file);
-   //3、 写出文件--输出流
-   OutputStream out = response.getOutputStream();
-
-   byte[] buff =new byte[1024];
-   int index=0;
-   //4、执行 写出操作
-   while((index= input.read(buff))!= -1){
-       out.write(buff, 0, index);
-       out.flush();
-  }
-   out.close();
-   input.close();
-   return null;
-}
-```
-
-前端
-
-```java
-<a href="/download">点击下载</a>
-```
-
-测试，文件下载OK，大家可以和我们之前学习的JavaWeb原生的方式对比一下，就可以知道这个便捷多了!
-
-拦截器及文件操作在我们开发中十分重要，一定要学会使用！