Spring总结

一、Spring是什么？

Spring 是于 2003 年兴起的一个非侵入式轻量级的，IOC和AOP的 Java 开发框架。他是为了简化企业级应用开发而生。

非侵入式： 我们的业务代码不需要实现或继承Spring中任何的类或接口
轻量级的： Spring框架使用的jar包都比较小，一般在1M以下或者几百kb。Spring核心功能所需的jar总共在3M左右。Spring框架运行占用的资源少，运行效率高
一站式框架：
1.提供核心功能，主要是IOC，创建管理对象
2.提供面向切面编程，增强程序扩展
3.对数据访问层进行了封装（重点在于事务管理）
4.对web层进行封装，使得请求更加便捷
IOC： 就是Inversion of Control，缩写为IOC，就是将创建对象的控制权反转给Spring容器
AOP： 面向切面编程，将一些公共的功能进行抽取，但是不需要我们在自己的方法种直接显示调用，而是通过一个代理对象去调用，然后再调用我们的方法时，可以将一个公共的方法横切进来

---

二、Spring搭建

1.导入spring核心基础jar

<!-- spring-context -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.2.RELEASE</version>
</dependency>

2.编写spring配置文件

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

---

三、IOC

读作“反转控制”更好理解，IOC就是将原本在程序中手动创建对象的控制权交给Spring来管理。
  IOC容器是具有依赖注入功能的容器，负责对象的实例化、对象的初始化、对象和对象之间依赖关系配置、对象的销毁、对外提供对象的查找等操作，对象的整个声明周期都是由容器来控制。我们需要的对象都是由IOC容器进行管理，不需要我们手动的通过new的方式去创建对象，由IOC容器帮助我们组装好，当我们需要的时候直接从IOC容器中直接获取即可。

---

四、Spring Bean 管理

1. 基于XML配置的方式

配置需要Spring管理的类，通过id标识生成的对象名，class配置需要管理的对象的类地址，name配置对象别名，可以为多个，例如下面的 bean 配置：为了区分，我特意为Admin对象设置id为admin1，设置别名为admin2

<bean id="admin1" name="admin2" class="com.ffyc.ssm.model.Admin"></bean>

测试代码：

 ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("spring.xml");
 Admin admin1 = app.getBean("admin1",Admin.class);
 Admin admin2 = app.getBean("admin2",Admin.class);
 System.out.println(admin1);
 System.out.println(admin2);

运行结果显示：

我们发现这两个对象地址一致，也就是说默认的bean管理是单例模式。下面再介绍bean标签种的一种属性scope，用来设置Bean的作用域，其实scope的值有很多，我这里只介绍两种

singleton：单例的，是默认是Bean作用域，是单例Bean，始终只会创建一个bean对象，在容器启动时创建
prototype：原型的、多例的，每次获取bean是都会创建一个bean对象，在每次获取时创建对象

2. XML配置方式依赖注入

依赖注入：Spring框架为我们创建对象的时候，对象中有属性，关联一些其他对象，Spring为这些属性关联的对象进行赋值，这个过程称为依赖注入。实现IOC需要DI支持。注入的方式：set方法注入，构造方法注入

2.1 set方法注入

这里注意，我们这种方式通过属性set方法注入，所以在对象中必须提供改属性的set方法，否则会报异常

    <bean id="admin1" name="admin2" class="com.ffyc.ssm.model.Admin">
        <property name="id" value="100"></property>
        <property name="account" value="super"></property>
    </bean>

上述注入基本属性，我们下面来注入引用属性
下面可以理解为一个添加用户的场景，在UserService中需要调用UserDao中的方法，所以需要为UserService中的属性UserDao依赖注入，我们首先完成UsrDao配置，然后完成了在配置UserService的时候，将UserDao作为属性赋值给UserService，注意下面不可以想基本数据类型一样，使用value进行赋值，value属性只能填写基本数据类型。在这里我们需要注入的是一个引用对象，所以需要使用ref属性

    <bean id="userService" class="com.ffyc.ssm.service.UserService">
        <property name="userDao" ref="userDao"></property>
    </bean>

    <bean id="userDao" class="com.ffyc.ssm.dao.UserDao"></bean>

2.1 构造方法注入

同样，这里也要保证有含这两个参数的构造方法

    <bean id="admin1" name="admin2" class="com.ffyc.ssm.model.Admin">
        <constructor-arg name="id" value="100"></constructor-arg>
        <constructor-arg name="account" value="common"></constructor-arg>
    </bean>

3. 注解方式实现Bean管理

我们上面讲述了通过XML配置的方式管理Bean，Spring框架还提供了注解方式来实现Bean管理

3.1 开启包扫描

注解开发需要导入jar包，注解功能封装在AOP包中，导入Spring AOP包即可，然后再Spring配置文件中配置开启注解扫描，扫描工程下面所有的类

<context:component-scan base-package="com.ffyc.ssm"> </context:component-scan>

3.2 注解使用

上面XML配置bean是通过标签的方式管理Bean，使用注解如下，将@Component写在希望Spring进行管理的类上，@Scope标签用来定义Bean的作用域
并且Spring为每个层都有特殊的标识，以管理不同层的Bean
@Controller，用来标识Controller层的Bean对象
@Service，用来标识Service层的Bean对象
@Repository，用来标识dao层的Bean对象

@Component(value = "admin")
@Scope(value = "prototype")
public class Admin {}
// 上述注解相当于XML 
// <bean id="admin" class="com.ffyc.ssm.model.Admin" scope="prototype"></bean>

4. 注解方式注入属性

4.1 @Autowired

@Autowired注解是Spring提供的注解，可以写在字段和setter方法上。如果写在字段上，就不需要编写setter方法。默认情况下要求依赖对象必须存在，如果允许null值，可以设置标签的required属性为false表示不强制属性注入，但是在使用到给属性的地方，会报空指针异常
@Autowired有两种方式完成属性注入
第一种：byType注入
注解默认使用的注入方式，只要IOC容器中管理着该类的Bean就会完成注入
第二种：byName注入
如果想通过名称来匹配，可以结合@Qualifier注解一起使用。@Qualifier的value属性用于指定Bean的id值

4.2 @Resource

Spring提供了对Jdk中@Resource注解的支持。@Resource既可以按照名称匹配Bean，也可以按照类型匹配Bean。默认按照ByName自动注入
ByName注入：@Resource需要指定Bean的name属性
ByType注入：不需要吧指定name属性，这样就会根据类型注入

---

五、Spring集成JDBC

Spring是一个一站式框架，本身提供了持久层的JdbcTemplate
1.首先导入Jdbc相关的jar

<!-- spring-jdbc -->
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-jdbc</artifactId>
	<version>5.2.2.RELEASE</version>
</dependency>
<!-- 阿里数据源 -->
<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>druid</artifactId>
	<version>1.1.10</version>
</dependency>

2.导入属性配置文件

我们可以在新创建一个properties文件，用来统一管理项目中的数据库连接信息

<context:property-placeholder location="config.properties"/>

3.管理数据源对象

<bean id="dataSource"class="com.alibaba.druid.pool.DruidDataSource">
	<property name="driverClassName" value="${driverClassName}"></property>
	<property name="url" value="${url}"></property>
	<property name="username" value="${uname}"></property>
	<property name="password" value="${pwd}"></property>
	<property name="initialSize" value="10"></property>
	<property name="minIdle" value="5"></property>
	<property name="maxActive" value="20"></property>
</bean>

4.在配置文件中创建JdbcTemplate

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
	<property name="dataSource" ref="dataSource"></property>
</bean>

上述配置完成之后，在类中获得JdbcTemplate对象，就可以直接使用

@Autowired
JdbcTemplate jdbcTemplate

JdbcTemplate中常用的方法
execute：无返回值，可执行 ddl，增删改语句
update：执行新增、修改、删除语句；
queryForXXX：执行查询相关语句；

---

六、AOP

  在以前解决问题的过程中，我们都是通过调用对应的方法解决某个问题。在开发中，可能在一个方法中同时存在异常处理、日志、事务等等功能，试想一想如果在业务复杂的情况下，我们的代码就会非常赘余，很多代码与我们的业务无关，但是必须调用。有没有一种方式可以做到既调用方法增强功能又不显式调用，这样我们的代码就会非常的优雅。
  OOP是面向对象编程，是对整个程序的全局的一种架构设计（战略层面）。AOP是OOP的补充，是一种战术层面的。AOP是将程序中的非业务代码进行抽取，将非业务代码和业务代码相隔离，降低了代码的耦合度。然后通过代理对象在业务代码中调用非业务代码，提高了代码的灵活性，提高了开发效率。AOP思想的核心就是使用代理对象，在中间帮忙调用，增强程序的功能。AOP不是Spring特有的

优点： 减少重复，专注业务
核心原理： 使用动态代理的方式在执行方法前后或者出现异常的时候假如相关的逻辑
使用案例：
事务处理：开启事务，关闭事务，出现异常后回滚事务
权限判断：在执行方法前，判断是否具有权限
日志：在执行方法是日志处理

1. AOP的相关概念

连接点：类中可以被增强的方法，这个方法就被称为连接点
切入点：类中又很多方法可以增强，但实际上只有部分方法被增强了，增强功能的方法就被称为切入点
通知：通知是指一个切面在特定的连接点要做的事情。通知分为方法执行前通知，方法执行后通知，环绕通知等。
切面：把通知添加到切入点的整个过程称为切面
目标：代理的目标对象，连接点，切入点所在类
代理：向目标对象应用通知时创建的代理对象

2. AOP的实现

对于AOP这种编程思想，很多框架都进行了实现。Spring就是其中之一，可以完成面向切面编程。
AspectJ是一个基于Java语言的AOP框架，它提供了强大的AOP功能，且实现方式简单，并且支持注解式开发。所以Spring将AspectJ对于AOP的实现引入到了自己的框架中。
首先要引入AOP的jar

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-aspects</artifactId>
	<version>5.2.2.RELEASE</version>
</dependency>

2.1 基于XML配置实现

首先创建一个公共的通知类，将通知都写在这个通知类中，这个类可以被视为工具类。
例如：

import org.aspectj.lang.JoinPoint;

import java.util.Arrays;
import java.util.Date;

public class UserAOP {

	// JoinPoint可以拿到方法参数，
	// 前置通知在方法执行前调用
    public void before(JoinPoint joinPoint) {
        Object[] args = joinPoint.getArgs();
        System.out.println(Arrays.toString(args));
        System.out.println("前置通知"+new Date());
    }
	
	// 后置通知在方法执行后调用
    public void afterReturn() {
        System.out.println("后置通知"+new Date());
    }

	// 最终通知，无论方法是否正常执行，都会调用
    public void after() {
        System.out.println("最终通知"+new Date());
    }
	
	// Throwable可以难倒异常类型
	// 异常通知，在方法出现异常的时候调用
    public void afterThrow(Throwable e) {
        System.out.println("异常通知"+new Date());
        System.out.println("发生异常"+e.getMessage());
    }

}

然后在配置文件中配置，切入点和通知的对应关系

    <!--把通知交给Spring框架管理，这个Bean就是我们上述例子的UserAOP，用来放置通知-->
    <bean id="userAop" class="com.ffyc.ssm.util.UserAOP"></bean>
    <aop:config>
        <!--配置切入点，第一个星号代表任意返回值类型，UserDao位置为星号代表dao包中的所有方法
        都配置成切入点，saveUser为星号代表UserDao中的所有方法都配置成切入点，括号中的..表示
        任意参数类型-->
        <aop:pointcut id="save" expression="execution(* com.ffyc.ssm.dao.UserDao.saveUser(..))"/>
        <!--将通知与切入点进行配置-->
        <aop:aspect ref="userAop">
            <!--前置通知-->
            <aop:before method="before" pointcut-ref="save"></aop:before>
            <!--后置通知-->
            <aop:after-returning method="afterReturn" pointcut-ref="save"></aop:after-returning>
            <!--最终通知，无论方法是否成功执行，都会被调用-->
            <aop:after method="after" pointcut-ref="save"></aop:after>
            <!--异常通知-->
            <aop:after-throwing method="afterThrow" pointcut-ref="save" throwing="e"></aop:after-throwing>
        </aop:aspect>
    </aop:config>

上述分别介绍了前置，后置，异常，最终通知的配置，还有一种通知是环绕通知，它可以代替上述所有的通知。下面是环绕通知的配置
首先，在通知类中创建环绕通知的方法：

    public void around(ProceedingJoinPoint proceedingJoinPoint) {
        System.out.println("前置通知");
        try{
        	// 拿到方法参数
            Object[] objects = proceedingJoinPoint.getArgs();
            System.out.println(Arrays.toString(objects));
            // 调用切入点，执行方法
            proceedingJoinPoint.proceed();
            System.out.println("后置通知");
        }catch (Throwable e) {
            System.out.println("异常通知"+e.getMessage());
        }
        System.out.println("最终通知");
    }

在Spring配置文件中配置环绕通知

    <!--把通知交给Spring框架管理-->
    <bean id="userAop" class="com.ffyc.ssm.util.UserAOP"></bean>
    <aop:config>
        <!--配置切入点-->
        <aop:pointcut id="save" expression="execution(* com.ffyc.ssm.dao.UserDao.saveUser(..))"/>
        <!--将通知与切入点进行配置-->
        <aop:aspect ref="userAop">
        	<!--环绕通知功能强大-->
            <aop:around method="around" pointcut-ref="save"></aop:around>
        </aop:aspect>
    </aop:config>

2.2 基于注解方式实现

使用注解方式实现AOP，必须要现在Spring配置文件中配置

    <!--开启自动代理-->
    <aop:aspectj-autoproxy />

然后，还是类似的做法，先创建通知类，用来定义通知方法。
类的定义：

@Component // 表示该对象交给Spring管理，xml配置的方式，也进行过配置
@Aspect // 表示该类是一个切面
public class UserAOP { }

下面是通知类中各种通知的定义

前置通知

    @Before("execution(* com.ffyc.ssm.dao.UserDao.saveUser(..))")
    public void before(JoinPoint joinPoint) {
        Object[] args = joinPoint.getArgs();
        System.out.println(Arrays.toString(args));
        System.out.println("前置通知"+new Date());
    }

后置通知

    @AfterReturning("execution(* com.ffyc.ssm.dao.UserDao.saveUser(..))")
    public void afterReturn() {
        System.out.println("后置通知"+new Date());
    }

最终通知

    @After("execution(* com.ffyc.ssm.dao.UserDao.saveUser(..))")
    public void after() {
        System.out.println("最终通知"+new Date());
    }

异常通知

    @AfterThrowing(value = "execution(* com.ffyc.ssm.dao.UserDao.saveUser(..))", throwing = "e")
    public void afterThrow(Throwable e) {
        System.out.println("异常通知"+new Date());
        System.out.println("异常类型"+e.getMessage());
    }

后置通知

    @Around("execution(* com.ffyc.ssm.dao.UserDao.saveUser(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) {
        System.out.println("前置通知");
        try{
            Object[] objects = proceedingJoinPoint.getArgs();
            System.out.println(Arrays.toString(objects));
            // 调用切入点
            proceedingJoinPoint.proceed();

            System.out.println("后置通知");
        }catch (Throwable e) {
            System.out.println("异常通知"+e.getMessage());
        }
        System.out.println("最终通知");
    }

---

七、Spring事务管理

  在开发中，可能会遇到一次操作通过多个数据库操作实现的业务。在执行多个数据库操作的过程中，可能会发生异常，导致后续的操作没有完成，这时业务逻辑并未正确的完成，需要进行回滚。Spring中也对事务管理进行了支持。
  Spring中的事务管理分为两种形式，一种是编程式事务管理，一种是声明式事务管理。
  编程式事务管理在项目中很少使用，这种方式需要注入一个事务管理对象TransactionTemplate，然后在我们代码中需要提交事务或回滚事务时自己写代码实现。
  声明式事务管理建立在AOP基础上，本质上是对方法前后进行拦截，所以声明式事务管理是方法级别的。
Spring声明式事务管理方式有两种：基于XML配置，基于注解实现
  Spring针对不同的持久层框架，提供了不同的实现类，MyBatis事务管理实现类是DataSourceTransactionManager。要进行事务管理必须先配置事务管理起。
配置事务管理器

<!-- 配置 spring 事务管理类, 并注入数据源 -->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>

1. 编程式事务管理

编程式事务管理的实现过于粗糙，仅仅只是本人进行了一个简单的转账测试，这部分内容我不想深究，所以写的比较简略。在Spring框架中，编程式事务管理主要通过使用TransactionTemplate或者PlatformTransactionManager来实现。

1.1 TransactionTemplate实现

首先需要配置TransactionTemplate

    <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
        <property name="transactionManager" ref="transactionManager"/>
    </bean>

然后就可以写代码实现编程式事务管理了，我这里通过一个转账的场景实现，下面是service层和dao层主要代码：
Service层

    @Autowired
    UserDao userDao;

    @Autowired
    TransactionTemplate transactionTemplate;
    // 假设有个转账场景，id1向id2转账money
    public void transferAccounts(int id1, int id2, int money) {
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
                try {
                    userDao.updateMoney(id1,-money);
                    System.out.println(10/0);
                    userDao.updateMoney(id2,money);
                } catch (Exception e) {
                    // 出现异常回滚事务
                    transactionStatus.setRollbackOnly();
                    System.out.println("转账事务异常，回滚原因"+e.getMessage());
                }
            }
        });
    }

dao层

    @Autowired
    JdbcTemplate jdbcTemplate;

    public void updateMoney(int id, int money) {
        jdbcTemplate.update("UPDATE admin SET money = money + ? WHERE id = ?", money, id);
    }

当我在转账的中间添加异常的话，事务全部回滚，两个人的账户都没有发生变化，当执行正常，则转账无异常。

1.2 PlatformTransactionManager实现

PlatformTransactionManager实现方式不需要配置Bean
下面是实现代码

    @Autowired
    PlatformTransactionManager platformTransactionManager;
    // 假设有个转账场景，id1向id2转账money
    public void transferAccounts(int id1, int id2, int money) {
        // 创建事务定义
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        // 获取事务状态
        TransactionStatus staus = platformTransactionManager.getTransaction(def);
        try {
            userDao.updateMoney(id1,-money);
            System.out.println(10/0);
            userDao.updateMoney(id2,money);
            platformTransactionManager.commit(staus);
        } catch (Exception e) {
            // 出现异常回滚事务
            platformTransactionManager.rollback(staus);
            System.out.println("转账事务异常，回滚原因"+e.getMessage());
        }
    }

上面就是通过两种方式实现编程式事务管理，虽然可以实现事务管理，但是在业务代码中出现了太多非业务代码，并且代码耦合度太低，所以在开发中较少使用

2. 声明式事务管理

声明式事务管理有两种方式，通过XML配置的方式我这里没有赘述，太麻烦了，这里只介绍通过注解方式实现声明式事务管理。
在进行注解实现事务管理前需要一段配置

        <!-- 开启注解事务管理器 -->
        <tx:annotation-driven transaction-manager="transactionManager"/>

通过注解方式改进通过编程式事务管理实现转账事务

    @Transactional
    // 假设有个转账场景，id1向id2转账money
    public void transferAccounts(int id1, int id2, int money) {
        userDao.updateMoney(id1,-money);
        userDao.updateMoney(id2,money);
    }

代码十分精简，只比以前多一个注解，所以说框架牛逼

声明式事务管理失效的场景
1.@Transactional 应用在非public方法上
2.异常被捕获导致失败
3.出现编译期异常
@Transactional注解默认的回滚异常类型是运行时异常（RuntimeException），我们可以将将属性修改为@Transactional(rollbackFor = Exception.class)，这样发生编译器异常也可以进行回滚
4.@Transactional事务传播行为设置问题
5.数据库引擎不支持事务
6.同一个类中，非事务方法调用this.事务方法

---

八、Spring事务传播行为

既然是传播，那么至少要有两个东西，才可以发生传播。单体不会产生传播这个行为。
事务传播行为是Spring框架独有的事务增强属性，不属于事务实际提供方数据库行为。事务传播行为是指当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行
Spring定义了7中传播行为：

事务传播行为类型	说明
PROPAGATION_REQUIRED	如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。
PROPAGATION_SUPPORTS	支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY	使用当前的事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW	新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED	以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER	以非事务方式执行，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED	如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与 PROPAGATION_REQUIRED 类似的操作。

因为时间比较紧迫，我这里只讲述REQUIRED，SUPPORTS，REQUIRES_NEW其他分析

PROPAGATION_REQUIRED
1.A没有事务，B有事务，A方法异常不影响B方法执行，前提是B方法得在异常出现之前就被调用，否则A方法出现异常，B方法没有执行程序就退出了
2.A有事务，B有事物，则B事务会加入到A事务中，任意一方出现异常都会回滚

PROPAGATION_REQUIRES_NEW
1.A没有事务，B有事务，A，B两方法互相不影响
2.A有事务，B有事物，A方法出现异常不影响B方法执行，B方法出现异常会影响A方法

PROPAGATION_SUPPORTS
1.A没有事务，B有事务，无论哪方出现异常都互相不影响
2.A有事务，B有事务，无论哪方出现异常都会影响对方

---

九、SpringWeb

SpringWeb是Spring框架中的一个模块，对Servlet进行了封装。

1. SpringWeb特点

SpringWeb是Spring家族的原生产品，与Spring无缝对接
基于原生的Servlet，提供了一个前端控制器DispatcherServlet
可以根据输入正确转化数据类型
代码清新简洁，大幅度提升开发效率
内部组件化程度高，可插拔式组件即插即用
性能卓著，尤其适合现代大型、超大型互联网项目要求

2.SpringWeb运行流程

下面是SpringWeb的运行流程图

首先来讲一下，SpringWeb的运行流程
用户发送请求到前端控制器DispatcherServlet。DispatcherServlet接受请求调用HandlerMapping。HandlerMapping找到具体的处理器（可查找XML配置或注解配置），再返回给DispatcherServlet，DispatcherServlet调用HandlerAdapter，HandlerAdapter经过适配调用具体的处理器，处理器执行完成后向前端相应结果

下面来讲各组件的作用

前端控制器：DispatcherServlet
不需要程序员开发，由框架提供，在web.xml中配置
作用： 统一处理请求和响应，是整个流程控制的中心，由它调用其他组件处理用户的请求。

处理器映射器：HandlerMapping
不需要程序员开发，由框架提供
作用： 根据用户请求地址查找对应的处理器

处理器适配器：HandlerAdapter
不需要程序员开发，由框架提供
作用： 按照特定的规则（HandAdapter要求的规则）去执行Handler

处理器：Handler
需要程序员开发
作用： 接收用户的请求信息，调用业务方法处理请求，也称之为后端处理器

3. SpringWeb搭建

1.首先导入Webjar

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-webmvc</artifactId>
	<version>5.2.2.RELEASE</version>
</dependency>

2.配置DispatcherServlet
在 web.xml 文件中配置 DispatcherServlet，配置 spring 核心请求分发器

<servlet>
	<servlet-name>application</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	<init-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:spring.xml</param-value>
	</init-param>
	<load-on-startup>0</load-on-startup>
</servlet>
<!-- 请求映射 -->
<servlet-mapping>
	<servlet-name>application</servlet-name>
	<url-pattern>/</url-pattern>
</servlet-mapping>

3.开启SpringWeb注解

<mvc:annotation-driven></mvc:annotation-driven>

4.处理器类搭建
@RestController注解使用在类上，使用它标注的类是一个SpringWeb控制器类
Spring配置中指定了自动扫描的基包，Spring会扫描这些包及其子包中使用了@RestController注解的类，然后将类加入到Spring IOC容器中，注入依赖。

接收请求
@RequestMapping是一个用来为处理器地址映射的注解，可用在类和方法上。作用在类上，在整个项目中不能重复，作用在方法上，整个类中方法地址不能重复
常用属性 path， value， method
path和value用来定义地址：两者功能相同，只不过value是默认属性，可以不写，直接只写地址，而method用来定义请求方式，也可以通过GetMapping，PostMapping来指定请求方式

获取请求数据
SpringWeb支持对多种类型的请求参数进行封装
1.使用request对象接收

@GetMapping(path = "/test")
public voidtset(HttpServletRequest request){
	System.out.println(request.getParameter("num"));
}

在处理器中如果需要HttpServletRequest对象只需要定义即可。
2.Spring自动封装

@RequestMapping("/save")
public void save(String userName,Integer age){
}

Spring会自动进行数据封装，要注意，处理器接收的参数必须和前端传递的参数保持一致，否则接收失败
3.使用RequestParam(“”)，@Requestheader(“”)进行参数绑定

@RequestMapping("/save")
public voidsave(@RequestParam("userName") String name,
	@RequestParam("userAge") Integer age){
}

前端的参数值可以和控制器中的参数名不一致，但是@RequestParam注解的value值必须和前端参数保持一致
另外，@RequestParam注解还有两个属性：
required：参数是否必须。代表页面是否必须传递该参数。如果该值为true，但没有传递参数，则会报错
defaultValue：默认值。如果页面没有传递参数，使用defalutValue的值顶替

@RequestMapping("/save")
public void save(@RequestParam(value = "userName",
	required = true,defaultValue = "jim") String name){
}

@RequestHeader注解和@RequestParam类似，用来接收请求中指定名字的参数，只不过@RequestHeader接收的是请求头中的指定参数
4.使用实体对象接收

@RequestMapping("/save")
public void save(Admin admin){
}

性类型为 Date 类型需要指定转换格式
@DateTimeFormat(pattern = “yyyy-MM-dd”)
private Date birthday;

如果前端传递的是json格式，使用@RequestBody将json字符串转换为Java对象

中文乱码处理
SpringWeb中已经为我们提供了过滤器，只需要在web.xml中配置即可

<filter>
<filter-name>characterEncodingFilter</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>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

返回json
SpringWeb中向前端返回数据为json时，只需要在方法上添加@RequestBody注解即可，由于类上已经使用了@RestController注解，所以不需要再次添加，因为@RestController注解中包括了@Controller注解和@RestController注解，同时必须在项目中导入相应的转 json 组件才可以直接将响应的对象转为 json

<!--jackson-->
<dependency>
	<groupId>com.fasterxml.jackson.core</groupId>
	<artifactId>jackson-databind</artifactId>
	<version>2.13.3</version>
</dependency>

4. 拦截器

  SpringWeb中的拦截器类似于Servlet中的过滤器，它主要用于拦截用户请求并作出相应的处理。Spring中拦截器和过滤器本质上的区别是，过滤器是Servlet规范中定义并实现的，在进入Servlet前捕获请求。而拦截器是Spring中定义的一种拦截机制，是对进入到处理器的请求进行拦截。
  SpringMVC定义了拦截器接口HandlerInterceptor，该接口中定义了三个方法，这三个方法的调用是在SpringMVC框架内部完成的，调用这三个方法时，其参数的值是从框架内部传递过来的。
boolean preHandle 预处理方法，实现了处理器方法的预处理，就是在处理器方法执行之前这个方法会被执行，相当于拦截了处理器方法，框架会传递请求和相应对象给该方法，第三个参数为被拦截的处理器方法。如果preHandle返回true表示继续流程（调用下一个拦截器或者处理器方法），返回false表示流程中断，不能继续调用其他拦截器或处理器方法，此时需要通过response来响应

 default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
     return true;
 }

void postHandle 后处理方法，实现处理器方法的后处理，就是在处理器方法调用完成，但是在渲染视图之前，该方法被调用，可以通过模型和视图对模型数据进行处理或对视图进行处理

default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
}

void afterCompletio 整个请求处理完毕，即在视图渲染完毕时该方法被执行

default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
}

拦截器的实现
1.编写一个类，继承 HandlerInterceptorAdapter

public class DemoInterceptor implements HandlerInterceptor{
/* 当请求到达控制器之前被执行
true--继续向下执行,到达下一个拦截器,或控制器
false--不会继续向下执行*/
public boolean preHandle(HttpServletRequest request, HttpServletResponse
	response, Object handler)throws Exception {
	System.out.println("之前执行");
	return false;
}

2.注册拦截器，在Spring-mvc的配置文件中进行配置

<mvc:interceptors>
	<mvc:interceptor>
		<mvc:mapping path="/**"/>
		<mvc:exclude-mapping path="/statics/**"/>
		<mvc:exclude-mapping path="/loginCtl/checklogin"/>
		<bean id="demo" class="com.ff.springMVC.util.DemoInterceptor"></bean>
	</mvc:interceptor>
</mvc:interceptors>

待续，后面写完Java进阶相关笔记就会回来更新

真正的大师永远都怀着一颗求学的心