spring超详细介绍！

spring

1、Spring是什么？

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

1. 轻量级：指的是核心jar包比较小的。

2. 非侵入式的：框架代码不会侵入到业务代码，即业务代码的类不会实现或继承框架中接口或类。

3. IOC：Inversion Of Control 反转控制/控制反转，以前我们使用java对象，在哪使用就在哪里new，IOC思想就是对所有我们需要使用的对象进行封装管理（创建，功能增强，销毁），在哪使用我们就在哪里注入，耦合度降低。

4. AOC：面向切面编程，核心思想是将公共功能进行提取，然后统一代理调用。

5. 一站式框架：spring还对jdbc，对web层进行封装，对事务管理等等。

耦合度

道理很简单，耦合度很高的情况下，维护代码时修改一个地方会牵连到很多地方，如果修改时没有理清这些耦合关系，那么带来的后果可能会是灾难性的，特别是对于需求变化较多以及多人协作开发维护的项目，修改一个地方会引起本来已经运行稳定的模块错误，严重时会导致恶性循环，问题永远改不完，开发和测试都在各种问题之间奔波劳累，最后导致项目延期，用户满意度降低，成本也增加了，这对用户和开发商影响都是很恶劣的，各种风险也就不言而喻了。

2、Spring搭建

1. 首先先在Pom.xml中带入jar包（默认我们使用的是maven），也可以自己下载jar包自行导入

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

2. 在resources目录下创建spring.xml，即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>

其中的<bean>标签就是我们需要使用的对象的配置。

3.测试

先创建一个测试类，我们这次不使用new的方式创建这个类的对象，我们通过配置spring中的bean，来创建对象

public class Admin {
    private  Integer id;
    private String  account;    
    public Admin() {    }    
    public Integer getId() {        
        return id;    }    
    public void setId(Integer id) {        
        this.id = id;    }    
    public String getAccount() {        
        return account;    }    
    public void setAccount(String account) {        t
        his.account = account;    }    
    @Override    
    public String toString() {        
        return "Admin{" +                "id=" + id +                ", account='" + account + '\'' +                '}';    }}
//注意，这个类必须要有每个属性的get、set方法

然后配置对应的<bean>

<bean id="admin" class="com.ffyc.spring.model.Admin"></bean>

创建admin对象：

    public void test(){
        ApplicationContext app=new ClassPathXmlApplicationContext("spring.xml");
        Admin admin= app.getBean("admin", Admin.class);//获取到admin对象,前面的参数是bean的id
        System.out.println(admin);
    }

3、Spring IOC

即 Inversion of Control，缩写为 IOC，就是由 Spring IoC 容器管理对象，而

非传统实现中由程序代码直接操控.

1.基于xml管理

即就是我们上面使用的在spring.xml中对bean进行管理，在beans中我们对每一个需要使用的对象进行管理配置

bean：指的是spring管理的对象，与我们自己new的对象不一样，spring可以对其添加额外功能。

bean中的属性介绍：

1. id： 生成的对象名class 全类名

2. name： 对象别名,可以为多个

3. scope:

• singleton(默认值):在 Spring 中只存在一个 bean 实例, 单例模式.

• prototype:原型getBean()的时候都会 new Bean()

• request:每次 http请求都会创建一个 bean, 仅用于 WebApplicationContext环境

• session:同一个 httpsession 共享一个 Bean, 不同 Session 使用不同的 Bean, 使用环境同上

  创建对象时注入数据的方式：

  set 方法注入 ：在set方法中进行注入

  构造方法注入：在bean中进行注入

      <bean id="admin" class="com.ffyc.spring.model.Admin">
          <property name="account" value="1"></property>
          <property name="id" value="2"></property>
      </bean>

2.注解方式实现

这里的关系是：依赖注入包括属性注入和注解注入，属性注入又分为set方法注入和construct注入，注解注入不需要在spring.xml中配置bean。

但是我们需要在spring.xml中加入配置，用来开启spring框架扫描，这个包下的所有类都加入管理。

<context:component-scan base-package="包名"> </context:component-scan>

将类的管理权交给spring：使用xml中bean配置或通过注解标签(在类上面加@)

常用的注解标签：

@Component(value=“user”) 就相当于 <bean id="user" class=""></bean>

@Service

@Repository

以上三种注解实际作用都是一致的，都是将类交由spring管理。不一样的是为了后续扩展作用，不同作用的层上放不同的类，比如service类型还有Dao类。

上面三种标签都只是将控制权交给spring，那么我们要如何利用注解来创建对象注入属性呢？

@Autowired byType 自动注入

@Qualifier(value="对象名")，对象名是要匹配对应bean的id Byname注入

@Resource：Spring 提供了对 jdk 中@Resource 注解的支持。@Resource 注解既可以按名

称匹配 Bean，也可以按类型匹配 Bean。默认按照 ByName 自动注入

以上都要求我们注入的对象不能为空，即要注入的类必须存在。

3.注解与 XML 的对比 ：

• 注解优点： 方便,直观,高效（代码少，没有配置文件的书写那么复杂）。

• 注解缺点：以硬编码的方式写入到 Java 代码中，修改是需要重新编译代码的。

• xml 优点是： 配置和代码是分离的,在 xml 中做修改，无需编译代码，只需重启服务器即可将新的配置加载。

• xml 的缺点是：编写麻烦，效率低，大型项目过于复杂。

4.创建被spring管理的对象要怎么进行赋值：

1.bean标签创建的对象

ApplicationContext app=new ClassPathXmlApplicationContext("spring.xml");
Admin admin= app.getBean("admin", Admin.class);

此时创建的对象赋值情况就是在bean标签中的配置，

set方式注入

   <bean id="admin" class="com.ffyc.spring.model.Admin">
       <property name="account" value="1"></property>
        <property name="id" value="2"></property>
   </bean>

或者构造方法注入

2.由@Autouried方式创建的对象并不能对其赋值，但是能创建对象。

4.Spring JDBC

Spring 是个一站式框架：Spring 自身也提供了控制层的 SpringMVC 和 持久层的 Spring JdbcTemplate。‘

要想在spring中使用jdbc，我们需要先进行以下配置：

1.配置

首先导入两个jar包：

spring数据访问层功能，提供Jdbctemplate封装的

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

方法操作数据库，主要我们要用的是事务管理功能，其他与数据库进行交互的我们使用这方面功能更强大的Mybatis框架。

然后是阿里巴巴开源的数据源管理组件，音译德鲁伊，提供与数据库连接实现，还提供数据库连接池功能。

数据库连接池：因为频繁的创建销毁数据库连接对象（connection），开销较大，提出池的概念，事先缓存一部分连接对象，用完不销毁，还会回到池中，减少创建及销毁的事件开销。

<!-- 阿里数据源 --> 
<dependency> 
<groupId>com.alibaba</groupId> 
<artifactId>druid</artifactId> 
<version>1.1.10</version> 
</dependency>

然后是导入属性文件config.properties，写在resources下面的属性文件

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

管理数据源对象 ，spring 管理与数据库链接 (数据源)

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${driver}"></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>

然后创建JdbcTemplate，它提供了操作的方法

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

注意：因为我们以上操作配置全部放在spring.xml中，难免会太多，不好管理，所以我们可以将jdbc有关配置全部放在另外一个xml（如db.xml）文件中，然后我们在spring将其引入即可，同理，其他功能的配置我们也可以将其分出去，然后在引入即可。

<import resource="classpath:db.xml"></import>

2.简单的使用

在类中获得 JdbcTemplate 对象，就可以直接使用。 我们可以直接使用注解的方式获得jdbcTemplate对象。也可使用getbean的方法获得对象。

获得JdbcTemplate的两种方式：

     ApplicationContext app=new ClassPathXmlApplicationContext("spring.xml");
     JdbcTemplate jdbcTemplate=app.getBean("jdbcTemplate",JdbcTemplate.class);

//上面是xml方式，下面是注解方式

     @Autowired
     static AdminService adminService;

JdbcTemplate 中常用的方法

execute：无返回值，可执行'ddl，增删改语句

update：执行新增、修改、删除语句；

queryForXXX：执行查询相关语句；

例如我们新增一个管理员：

  jdbcTemplate.update("insert into admin(account,password,gender) values(?,?,?)", "sdf","adf","男");

5.Spring Aop

1.Aop概述

在业务开发中，总有一些功能与业务代码耦合度不高（例如保存日志，提交事务，权限验证，异常处理等），我们就可以将它们提取到一个工具类中进行管理，在哪使用时就在哪调用。（这是我们以前的做法）

弊端：

这样代码已经开发完成，后期需要添加公共性功能，就需要改动原来的代码，在每个需要调用它的地方都调用以下，一旦调用量变大，就十分麻烦。

需求：

基于以上问题，我们能不能在不修改原来代码的情况下，额外的添加其他公共功能？

解决办法：

我们引入Aop面向切面编程，使用代理对象（需要配置，动态代理模式），我们需要注意，AOP并不是spring特有的设计思想。

面向切面编程：

AOP 为 Aspect Oriented Programming 的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP 是 OOP 的延续，是软件开发中的一个热点，是 java 开发中的一个重要内 容。利用 AOP 可以对业务逻辑和非业务逻辑进行隔离，从而使得各部分之间的 耦合度降低，提高程序的可重用性，同时提高了开发的效率。 AOP、OOP 在字面上虽然非常类似，但却是面向不同领域的两种设计思想。OOP （面向对象编程）针对业务处理过程的实体及其属性和行为进行抽象封装，以获 得更加清晰高效的逻辑单元划分。 而 AOP 则是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的 某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。这两种设计思想在目标上有着本质的差异。

面向切面编程优点：

代码复用、降低模块间的耦合度、专注业务。

例如下图：共用的代码（打印日志、事务模块）

 

总结：

面向对象编程(OOP)的出现让开发者能够实现纵向的业务逻辑处理，但面向对象编程(OOP)并不适合用于定义横向业务逻辑的关系，这样的设计会导致系统出现大量重复代码，复用性极差，如最常用的日志以及事务功能，它们都可能是横向的分布在不通的业务层级(对象层级)中，但是又和具体的核心业务无直接关系，诸如这样类型的代码，在程序中被称作横切(cross cutting)，我们应该考虑将这一类代码进行统一管理，提高复用性。

  面向切面编程(AOP)就是将这类与核心业务无关的，但又影响着多个类的公共行为抽取、封装到一个可重用模块，从而实现代码复用和模块解耦的目的，这种开发思想则被称为面向切面编程。

2.Aop基本概念

• 连接点（Joinpoint）：类中可以被增强的方法，这个方法就被称为连接点

• 切入点（pointcut）：类中有很多方法可以被增强，但实际中只有 add 和 update 被增了，那么 add 和 update 方法就被称为切入点（即实际实现的连接点）

• 通知(Advice): 通知是指一个切面在特定的连接点要做的事情(增强的功能)。通知分为方法执行前通知，方法执行后通知，环绕通知等.

• 切面(Aspect):把通知添加到切入点的整个过程称为切面.

• 目标(Target): 代理的目标对象(连接点,切入点所在类)

• 代理(Proxy): 向目标对象应用通知时创建的代理对象

3.Aop实现

对于 AOP 这种编程思想，很多框架都进行了实现。Spring 就是其中之一，可以完成面向切面编程。 AspectJ 是一个基于 Java 语言的 AOP 框架，它提供了强大的 AOP 功能,且其实现方式更为简捷，使用更为方便， 而且还支持注解式开发。所以，Spring 又将 AspectJ 的对于 AOP 的实现也引入到了自己的框架中。

1.配置

首先导入jar包

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

基于xml的Aop实现配置

<!--让spring管理装有增强功能的类-->
<bean id="commonUtil" class="com.ffyc.spring.util.CommonUtil"></bean>


<aop:config> 
    <!-- 配置切入点 -->
 <aop:pointcut expression="execution(*com.ffyc.spring.dao.AdminDao.saveAdmin(..))" id="saveAdmin"/>
 <aop:pointcut expression ="execution(*com.ffyc.spring.dao.AdminDao.updateAdmin(..))" id="updateAdmin"/>
    <!-- 配置通知和切入点 -->
 <aop:aspect ref="commonUtil">
 <aop:before method="savelog" pointcut-ref="saveAdmin"/>
 <aop:after method="savelog" pointcut-ref="updateAdmin"/></aop:aspect>
 </aop:config>

 

配置切入点应注意：

AspectJ 中常用的通知有五种类型：

前置通知before,方法执行前的通知

后置通知after,方法执行后的通知

异常通知after exception,方法出现异常后的通知

环绕通知around，包括了以上三个通知，有环绕通知就不需要上面三个通知。

最终通知.

基于注解方式的AOP实现

首先启动 AspectJ 支持:（在spring.xml中）

<aop:aspectj-autoproxy />

定义通知：

注：通知所在的类需要有

@Component @Aspect

@Component
@Aspect
public class CommonUtil {

    //称为通知，指实际要增强的功能
    
    //前置通知
    //下面的配置具体含义：在AdminDao类中的每个方法执行之前都会先执行savelog方法
    @Before("execution(* com.ffyc.spring.dao.AdminDao.*(..))")
    public void savelog(){
        System.out.println("保存日志");
    }

    //异常通知
    //下面的配置具体含义：在AdminDao类中的每个方法执行时出现异常都会执行此方法
    @AfterThrowing(value = "execution(* com.ffyc.spring.dao.AdminDao.*(..))",throwing = "e")
    public void exception(Throwable e){
        System.out.println("系统错误");
        System.out.println(e.getMessage());
    }

    //环绕通知
    //下面的配置具体含义：在AdminDao类中的每个方法执行时会先执行point.proceed()前的前置通知，然后就是执行point.proceed(),指的就是我们的业务代码，出现异常就执行catch中代码，继续向下执行，即后置通知
    @Around("execution(* com.ffyc.spring.dao.AdminDao.*(..))")
    public void around(ProceedingJoinPoint point){
        System.out.println("之前");
        try {
            point.proceed();//实际上执行的就是saveAdmin()
        } catch (Throwable e) {
            e.printStackTrace();
            System.out.println("系统错误");
            System.out.println(e.getMessage());
        }
        System.out.println("之后");
    }
}

注：同一个通知上只能加一个注解，即一个通知只能是一种类型。

切入点：

@Repository
public class AdminDao {

    @Autowired
    JdbcTemplate jdbcTemplate;
//这些方法都可以被增强（即添加其他功能，称为连接点）
//    saveadmin实际被增强了，那么他就称为切入点

    public void saveAdmin(){
       // jdbcTemplate.update("insert into admin(account,password,gender) values(?,?,?)", "sdf","adf","男");
        System.out.println("保存admin");
        System.out.println(10/0);//当出现异常时，会走异常通知
    }

    public void updateAdmin(){
        System.out.println("修改admin");
    }

    public void add(){
        jdbcTemplate.update("UPDATE personvalue SET money=money+10 WHERE id=1" );
    }

    public void sub(){
        jdbcTemplate.update("UPDATE personvalue SET money=money-10 WHERE id=2" );
    }
}

以上就是AOP在spring中的具体实现，我们通常使用注解形式来实现AOP，便捷并且不直接对业务代码进行操作，只对特定功能即通知处进行注解配置即可。

6.事务管理

1.数据库事务概述

一次对数据库的操作，其中用可能有多条sql执行，数据库要保证多条sql一起执行成功，要么都执行，右面都不执行，数据库对整个过程进行控制，称为数据库事务管理。事务是属于数据库的特性。

我们在开发企业应用时，对于业务人员的一个操作实际是对数据读写的多步操作的结合。由于数据操作在顺序执行的过程中，任何一步操作都有可能发生异常， 异常会导致后续操作无法完成，此时由于业务逻辑并未正确的完成，之前成功操作数据的并不可靠，需要在这种情况下进行回退。事务的作用就是为了保证用户的每一个操作都是可靠的，事务中的每一步操作都必须成功执行，只要有发生异常就回退到事务开始未进行操作的状态,这些操作要么都完成，要么都取消，从而保证数据满足一致性的要求。

2.spring事务管理

spring事务管理分为两种：编程式管理和声明式管理。

编程式事务管理

在业务代码中进行事务管理控制。在项目中很少使用 , 这种方式需要注入一个事务管理对象 TransactionTemplate ,然后在我们代码中需要提交事务或回滚事务时自己写代 码实现.在这里我们不过多关注。

声明式事务管理

可以通过（AOP思想）注解方式，对业务方法进行事务管理控制。我们在此使用注解方式实现声明式事务管理。

配置

事务管理器：

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

注解方式：

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

注解方式实现

配置完成后，在service类中对其中方法进行事务管理。

@Transactional：@Transactional加在类上表示类中所有方法都在spring事务管理中，加在单个方法上表示只有这个方法在事务管理中。

注意，这个@Transactional不加在Dao层，而是加在Service层，因为service中一个方法就表示一个业务，我们在别处调用业务时，应该让业务处于事务管理中。

不要将事务管理与AOP搞混，二者几乎没有关系，只是在实现AOP的基础下也可以进行事务管理。

总之，如果想对哪些方法或者哪个类中所有方法进行事务管理，就在上面加入@Transactional，就会将其加入spring事务管理。

 

3.spring事务管理失效的情况

@Transactional注解的事务管理会在以下几种情形中失效：

1. 应用在非public修饰的方法上。即就是让这个方法加入事务，此时事务会失效。

2. 事务中sql语句出现的异常被catch捕获，所以就不会回滚，全部执行了（认为方法没有异常，事务正常提交）

3. 出现编译期异常也会默认正常执行，不会回滚。可以通过设置修改，@Transcational(rollBackFor=Exception.class)，这个时候出现异常事务就会正常回滚，事务正常执行。

4. 数据库引擎不支持事务。mysql只有InnoDB引擎支持事务。

5. 在同一个类的非事务方法中，通过this调用了事务方法，此时是通过非代理对象调用的事务方法，这个对象不由spring管理，所以也就不会运行事务，事务失效。

6. 事务传播行为设置错误（重要）

传播：指的是方法之间相互调用。

事务传播行为：当A方法（有事务）调用B方法，B方法应该如何执行，例如B方法添加到A方法事务中还是B方法继续是一个独立的事务。（此情形下我们重点关注B方法）

并且事务传播行为是spring框架独有的事务增强特性，与数据库无关，有七种事务传播行为：

 

注意，若A调用B，此处的情形是我们认定被调用B方法是有事务的，并且是以上类型的事务传播行为，所以B方法一定是有事务的常量，而A方法有无事务是我们这里的变量。

1.required（若B方法是事务传播类型为required的事务管理）

当一个有事务的方法A调用了传播行为为required的方法，则被调用的方法会合并对它的事务中。

当一个没有事务的方法调用了有事务且传播行为为required的方法，则被调用方法单独开启执行自己的事务。

2.supports

当一个有事务方法调用了一个传播行为为supports的方法，则两方法共用一个事务。

当一个无事务的方法调用了一个传播行为supports事务的方法，则两方法都没有事务。（即事务传播行为设置错误，导致事务失效）

3.requires-new

无论A方法中是否有事务，调用一个传播行为requites-new的方法B，A方法都会单独创建一个新的事务。

注：A方法中调用了B方法，若A方法B方法都有事务，A方法中出现异常，B方法因为有自己的事务，所以不会被影响（前提是异常在调用B方法之后，若异常在调用B之前，则AB都执行不了）；但是如果B方法中出现异常，因为B方法在A方法中，所以也导致A方法中出现异常，会进行回滚，结果就是AB都执行失败。

异常在saveLog（）即B方法前，则直接回滚，saveAdmin（）即A方法中所有方法都不能执行。

7.spring MVC

目前spring的后端架构：

web层：servlet

数据访问层：Dao

业务逻辑层：service

SpringMVC 概述

springMVC 是 spring 框架的一个模块，springMVC 和 spring 无需通过中间整合层进行整合。

springmvc 是一个基于 mvc 的 web 框架,方便前后端数据的传输.

Spring MVC 拥有控制器，接收外部请求，解析参数传给服务层.

SpringMVC运行流程

1.用 户 向 服 务 器 发 送 请 求 ， 请 求 被 Spring 前 端 控 制 Servelt DispatcherServlet 捕获；

它是springweb的核心，用来接收所有前端发送的请求，统一进行分发调度。

2.前端控制器DispatcherServlet接收请求后，调用处理器映射 HandlerMapping。 处理器映射器 HandlerMapping 根据请求的 url 找到处理该请求的处理器 Handler （ 即 Controller ） ， 将 处 理 器 Handler 返 回 给 前 端 控 制 器DispatcherServlet。

1. DispatcherServlet 根 据 获 得 的 Handler ， 选 择 一 个 合 适 的HandlerAdapter。 在填充 Handler 的入参过程中，根据你的配置，Spring 将帮你做一些额外的工作：

HttpMessageConveter： 将请求消息（如 Json、xml 等数据）转换成一 个对象，将对象转换为指定的响应信息 。

数据转换：对请求消息进行数据转换。如 String 转换成 Integer、Double 等 。

数据根式化：对请求消息进行数据格式化。 如将字符串转换成格式化数字或格式化日期等 。

数据验证： 验证数据的有效性（长度、格式等），验证结果存储到BindingResult 或 Error 中。

1. Handler(自己的控制器)执行完成后，向 DispatcherServlet 返回一个ModelAndView 对象；

2. 根据返回的 ModelAndView，选择一个适合的 ViewResolver（必须是已经注册到 Spring 容器中的 ViewResolver)返回给 DispatcherServlet ；

3. ViewResolver 结合 Model 和 View，来渲染视图 。

4. 将渲染结果返回给客户端。

SpringMVC 组件

1. DispatcherServlet:Spring 中提供了 org.springframework.web.servlet.DispatcherServlet 类，它从 HttpServlet 继承而来，它就是 Spring MVC 中的前端控制器(Frontcontroller)。

2. HandlerMapping: DispatcherServlet 自己并不处理请求，而是将请求交给 页面控制器。那么在 DispatcherServlet 中如何选择正确的页面控制器呢？ 这件事情就交给 HandlerMapping 来做了，经过了 HandlerMapping 处理 之后，DispatcherServlet 就知道要将请求交给哪个页面控制器来处理了。

3. HandlerAdapter：经过了 HandlerMapping 处理之后，DispatcherServlet 就获取到了处理器，但是处理器有多种，为了方便调用，DispatcherServlet 将这些处理器包装成处理器适配器 HandlerAdapter，HandlerAdapter 调 用真正的处理器的功能处理方法，完成功能处理；并返回一个 ModelAndView 对象（包含模型数据、逻辑视图名）。

搭建SpringMVC

1.导入jar包：

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

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

    <servlet>
        <servlet-name>spring</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>spring</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

3.开启 springmvc 注解 （主要需要在springmvc.xml中进行配置）

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

4.控制器类搭建

@Controller 用于标记在一个类上，使用它标记的类就是一个 SpringMVC Controller 对象.

Spring 配置中指定了自动扫描的 basepackage 后，Spring 会扫描这些包以及 子包中的使用了@Controller 标识的类，然后将类加入到 Spring IOC 容器中,注入依赖。

@RequestMapping 注解是一个用来处理请求地址映射的注解，可用于类或方法上。

相关注解介绍

@controller 表示此类是控制层类，spring生成对象，方法返回值，默认是jsp的形式

@Restcontroller 表示此类是控制层类，里面包含@ResponseBody注解，为ajax注解，将数据写到响应体内，并且能将对象转换为json，以供前端使用。

处理前端传来数据的方法参数可以是多变的，可以是：@RequestHeader("User-Agent")请求头、@RequestParam("name")、String name （绑定好后直接将赋值）、Admin admin （甚至还可以将前端传来的数据直接封装到一个对象中，前提是属性名等数据匹配）

@RequestMapping 用来定义类、方法的映射地址（value或者path），定义不同类的地址不能相同，并且在同一个类中不能有相同的方法映射地址。

属性：methed=requestMethod.POST,意思是这个方法或类只能是post请求或get请求，也可以直接将整个@RequestMapping换成@PostMapping或@GetMapping

中文乱码处理

我们发现在提交请求的时候，如果输入的是中文，处理器方法获取到之后是 乱码。乱码产生的原因在 Java Web 课程中已经讲解过了，解决的方法就是添加一个过滤器，为 request 对象设置编码集。SpringMVC 中已经为我们提供了这个过滤器，只需要在 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>

Ajax 返回 JSON

我们需要实现将后端响应回前端的数据转换成json类型，通过导入jar包，spring会自动帮我们实现。

<dependency> 
    <groupId>com.google.code.gson</groupId> 
    <artifactId>gson</artifactId> 
    <version>2.8.6</version> 
</dependency>

拦截器

SpringMVC 定义了拦截器接口 HandlerInterceptor ，该接口中定义了三个方法,这三个方法的调用时在 SpringMVC 框架内部完成的，调用这个三个方法的时候，其参数的值也是从框架内部传递进来的。

boolean preHandle

预处理方法，实现处理器方法的预处理，就是在处理器方法执行之前这个方法会被执行，相当于拦截了处理器方法，框架会传递请求和响应对象给该方法，第三 个参数为被拦截的处理器方法。如果 preHandle 方法返回 true 表示继续流程（如 调用下一个拦截器或处理器方法），返回 false 表示流程中断，不会继续调用其他的拦截器或处理器方法，此时我们需要通过 response 来产生响应；

void postHandle

后处理方法，实现处理器方法的后处理，就是在处理器方法调用完成，但在渲染视图之前，该方法被调用，此时我们可以通过 modelAndView（模型和视图对象）对模型数据进行处理或对视图进行理。

afterCompletion

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

拦截器的实现：

我们需要编写一个类，继承 HandlerInterceptorAdapter

 

然后注册拦截器（注意需要注册在Springmvc.xml文件中）：

    <!--注册拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>    <!--指定那些可以进入拦截器-->
            <!-- <mvc:exclude-mapping path="/loginCtl/checklogin"/> 指定那些不可以进入拦截器 -->
            <bean id="demoInterceptor" class="com.ffyc.spring.config.DemoInterceptor"></bean>
        </mvc:interceptor>
    </mvc:interceptors>

即可注册完成。

8.前端后端的数据转换方式及问题

注：从后端将string对象传到后端需要传json，这个我们可以由@restcontroller实现

从前端将json对象传到后端，我们以前是只能在前端使用 jsontoString方法转成string再传到后端，后端目前没有办法将前端传来得json对象转为string对象。

 

但是我们使用了spring以后，只需要在接收前端发来的数据时，给参数加上@RequestBody注解即可，这样我们就可以实现将前端发来的json转换成键值对形式。

 

前端能够识别的数据类型是json（spring会通过@RequestBody自动转），后端需要的是键值对，对象。当前端响应回数据时，需要是json，这个我们可以由@restcontroller实现，前提我们需要导入gson jar包。