05、spring

最新推荐文章于 2022-05-22 23:36:12 发布

weixin_30824277

最新推荐文章于 2022-05-22 23:36:12 发布

阅读量107

点赞数

文章标签：测试后端前端 ViewUI

原文链接：http://www.cnblogs.com/xiangyuqi/p/8656059.html

版权

Spring MVC

1. Spring MVC 概述 1-2

1.1. 企业级应用基本架构 1-2

1.2. Web MVC架构及分析 1-3

1.3. Spring MVC 架构及分析 1-4

2. Spring MVC 编程基础 2-5

2.1. 编程基本步骤 2-5

2.2. 基于xml编程实现 2-5

2.2.1. 创建Maven WEB 项目 2-5

2.2.2. 添加Spring MVC 项目依赖及配置文件 2-5

2.2.3. 配置前端控制器 2-7

2.2.4. 创建后端控制器 2-7

2.2.5. 创建JSP页面 2-8

2.2.6. 配置后端控制及视图解析 2-8

2.2.7. 部署到tomcat运行 2-9

2.2.8. 运行原理分析 2-9

2.3. 基于注解编程实现 2-10

2.3.1. 创建Maven WEB 项目 2-10

2.3.2. 添加Spring MVC 项目依赖及配置文件 2-10

2.3.3. 配置前端控制器 2-11

2.3.4. 创建后端控制器 2-12

2.3.5. 配置组件扫描与视图解析 2-12

2.3.6. 部署与运行 2-12

3. Spring MVC 编程请求处理进阶 3-13

3.1. 请求路径映射 3-13

3.1.1. 普通url映射 3-13

3.1.2. Rest风格url映射 3-13

3.2. 请求方式映射 3-14

3.2.1. 请求方式限定 3-14

3.2.2. 请求方式组合 3-14

3.3. 请求参数映射(重点) 3-14

3.3.1. 标准Servlet API 3-14

3.3.2. 直接量存储 3-15

3.3.3. Java bean对象 3-15

3.3.4. Rest url数据 3-16

3.3.5. 请求头数据 3-16

4. Spring MVC 响应处理进阶 4-17

4.1. 响应数据封装 4-17

4.1.1. ModelAndView 对象 4-17

4.1.2. Model对象 4-17

4.1.3. Map对象 4-18

4.2. 响应数据转换JSON 4-18

4.2.1. JSON 应用概述 4-18

4.2.2. 客户端JSON数据操作 4-19

4.2.3. JAVA端JSON数据操作 4-19

4.2.4. Spring 集成jackson库 4-23

4.2.5. Spring 集成fastjson库 4-24

5. Spring 拦截器应用 5-25

5.1. 拦截器概述 5-25

5.2. 拦截器编写及配置 5-26

6. Spring MVC异常处理 6-28

6.1. Spring MVC 异常概述 6-28

6.2. Spring MVC 异常处理 6-29

7. 总结 7-29

7.1. 重点和难点分析 7-29

7.2. 常见FAQ 7-30

7.3. 作业 7-30

1. Spring MVC 概述

　　1.1. 企业级应用基本架构

　　　　企业级应用基本架构（C/S）以及SPRING在架构中的作用。

　　　　此架构图中spring要解决什么问题？

　　　　　　1）对象的构建，对象的依赖管理。(重点是从资源使用角度进行分析)

　　　　　　2）扩展业务的动态切入。（基于OCP更好实现功能扩展，同时进行解耦）

　　　　　　3）简化传统web mvc架构中的一些细节处理问题（参数获取，校验，值的注入，响应方式及数据格式的转换）。

　　　　问题：

　　　　　　1）我们一般说的解耦是没有耦合吗？不是，所有软件系统中的对象之间都会存在耦合，只是要把耦合降低。

　　　　　　2）降低耦合的最主要目的是什么？就是要提高系统的可维护性，便于系统进行更好的升级扩展。

　　　　　　3）降低耦合的主要实现方式？

　　　　　　3.1）对象之间的耦合尽量耦合与接口与工厂

　　　　　　3.2）代码的重用尽量使用组合而非继承。（has a 取代 is a）

　　1.2. Web MVC架构及分析

　　　　　　基于servlet，jsp，javabean技术实现的MVC架构

　　　　问题：

　　　　　　1）假如我们没有使用spring mvc，你如何对系统采用mvc思想进行分层？（参考jsp+servlet+javabean奇数）

　　　　　　2）传统的web mvc 编程架构中有什么优势，劣势？

　　　　　　　　优势：结构层次更加清晰，可读性，可维护性相对较好

　　　　　　　　劣势：参数获取，类型转换，流程调用相对都比较复杂

　　　　　　3）市场上相对比较成熟的mvc框架：spring mvc，struts2，….

　　1.3. Spring MVC 架构及分析

　　　　　　Spring MVC是MVC架构模式的一种完美实现，它简化了Java WEB 中基于MVC架构的编程过程，是Spring中的WEB应用模块。其官方MVC概要架构图如下：

　　　　Spring MVC 底层核心架构图及工作流程（先了解，写完项目案例再重点强化）

　　Spring MVC 中的核心组件：

　　　　1) DispatcherServlet （前端控制器, 处理请求的入口）

　　　　2) HandlerMapping （映射器对象, 用于管理url与对应controller的映射关系）

　　　　3) Controller （后端控制器, 负责处理请求的控制逻辑）

　　　　4) ModelAndView （模型, 封装业务处理结果和视图）

　　　　5) ViewResolver（视图解析器,解析对应的视图关系：前缀+view+后缀）

　　　　备注：假如希望了解Spring MVC的详细处理流程可以基于断点调试法进行跟踪。

2. Spring MVC 编程基础

　　2.1. 编程基本步骤

　　　　Step01：创建maven web 项目并解决项目中的错误问题

　　　　Step02：添加项目依赖（spring-webmvc）及spring核心配置文件

　　　　Step03：配置前端控制器DispatcherServlet（web.xml）

　　　　Step04：创建后端控制器（Controller）及页面

　　　　Step05：spring配置文件中配置核心应用组件

　　　　Step06：部署及测试springmvc 应用。

　　2.2. 基于xml编程实现

　　　　2.2.1. 创建Maven WEB 项目

　　　　　　Web项目打包方式为war方式

　　　　　　Web项目的target runtimes为tomcat

　　　　　　Web 项目的编译版本为JDK1.8

　　　　可能会遇到的问题：

　　　　　　1） war项目默认不会创建web.xml(需要自己生成)

　　　　　　2）项目创建好需要设置运行时环境tomcat(多个tomcat时选哪个)

　　　　　　3）统一编译版本(版本不统一很有可能会出现项目不编译)

　　　　　　4）统一编码(UTF-8)

　　　　　　5）假如创建的项目还有问题，可对项目进行clean操作

2.2.2. 添加Spring MVC 项目依赖及配置文件

打开项目的pom.xml文件，然后添加依赖（选择组groupId为org.springframework）

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

假如添加好了依赖,都没有找到对应的jar依赖,先检测网络是否是通的.假如网络是通的,还没有下载到具体的依赖,此时要右键项目,选择maven/upate maven project/fore update…进行maven强制更新操作.

在项目的resource的目录中添加核心配置文件applicationContext.xml,例如：

<?xml version="1.0" encoding="UTF-8"?>
<beans default-lazy-init="true"
    xmlns="http://www.springframework.org/schema/beans" 
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:util="http://www.springframework.org/schema/util"
    xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    xsi:schemaLocation="  
       http://www.springframework.org/schema/beans   
       http://www.springframework.org/schema/beans/spring-beans-4.3.xsd  
       http://www.springframework.org/schema/mvc   
       http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd   
       http://www.springframework.org/schema/tx   
       http://www.springframework.org/schema/tx/spring-tx-4.3.xsd   
       http://www.springframework.org/schema/aop 
       http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
       http://www.springframework.org/schema/util 
       http://www.springframework.org/schema/util/spring-util-4.3.xsd
       http://www.springframework.org/schema/data/jpa 
       http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-4.3.xsd" >
       
</beans>

　　　　说明：配置文件的名字需要自己定义，当这个空的配置文件中的某行有相关错误

　　　　时，先去检测网络是不是通的。

　　2.2.3. 配置前端控制器

　　　　打开web.xml，配置DispatcherServlet对象

<servlet>
     <servlet-name>dispatcherServlet</servlet-name>
     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
     <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
     </init-param>
     <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
     <servlet-name>dispatcherServlet</servlet-name>
     <url-pattern>*.do</url-pattern>
  </servlet-mapping>

　　前端控制器是spring mvc处理请求的入口，是springmvc的核心，这个控制器一般需要在服务器启动时即初始化。

　　　　其中

　　　　　　1) load-on-startup 表示启动时则加载此servlet

　　　　　　2) init-param 中的参数名不能变（此名字在DispatcherServlet父类中定义）

　　　　2.2.4. 创建后端控制器

　　　　　　后端控制器编写时可以实现Controller接口，然后重写handleRequest方法处理请求

　　　　　　public class HelloController implements Controller{}

　　　　　　其中:

　　　　　　　　ModelAndView对象为一个模型与视图对象，内置一个map对象，主要用于封装业务数据和视图名。

　　　　　　　　ModelAndView构造方法中传递的为视图名，addObject方法可以以key/value形式存储数据。

　　　　　　　　ModelAndView 对象返回时会被spring mvc自动存储到请求作用域，在对应的视图页面可以直接从此作用域获取对应的值。

　　　　2.2.5. 创建JSP页面

　　　　　　在项目的WEB-INF/pages文件夹下创建hello.jsp文件，然后设置其内容，例如

　　　　2.2.6. 配置后端控制及视图解析

　　　　　　在spring mvc 核心配置文件中添如下配置。

<!-- 将Controller这个Bean对象交给Spring管理 -->
<bean id="helloController" class="spring.controller.XmlHelloController">
</bean>
<!-- 配置HandlerMapping 映射处理器配置url到具体的Controller之间的映射-->
 <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
             <property name="mappings">
                  <props>
                      <prop key="/hello.do">helloController</prop>
                  </props>
             </property>
  </bean>
  <!-- 配置视图解析器 -->
 <bean  id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/pages/"/>
            <property name="suffix" value=".jsp"/>
</bean>

　　　　2.2.7. 部署到tomcat运行

　　　　　　将项目部署到tomcat，然后启动运行，在地址栏输入具体url访问对应controller。

　　　　　　问题：

　　　　　　　　1） tomcat启动时出现ClassNotFoundException，而这个class又不是我们自己的类，此时要重新maven update，重新发布(右键tomcat 重新publish)，多次尝试还是不可以，此时重启eclipse。

　　　　　　　　2） 404异常，一般表示服务端资源没找到,首先检测访问路径是否正确，然后还可以在项目的部署目录中去查找对应的资源，必须确保资源是存在的，假如资源不存在，说明代码没有正常编译。（很常见）

　　　　　　　3）如何解决这种项目不编译的问题？

　　　　　　　　step01) 将tomcat下的项目移除，clean你的tomcat服务器

　　　　　　　　step02) 将项目的jre从buildpath移除，然后重新添加

　　　　　　　　step03) 对项目先进行maven clean操作(清除原先编译结构，然后重新编译)

　　　　　　　　step04) 再次对项目进行clean操作

　　　　　　　　step05) 重新部署项目，启动tomcat运行

　　　　　　4）运行项目时尽量不要右键运行选在run as /run on server

　　　　2.2.8. 运行原理分析

　　　　　　本应用的简易处理流程如下：

4.2. 响应数据转换JSON

4.2.1. JSON 应用概述

JSON(JavaScript Object Notation):一种轻量级数据交换格式,通常用于实现客户端与服务端之间的数据传输.

企业级Java项目数据传输方式：

5. Spring 拦截器应用

　　5.1. 拦截器概述

　　　　拦截器是SpringMVC中的一个核心应用组件,主要用于处理多个Controller的共性问题.当我们的请求由DispatcherServlet派发到具体Controller之前首先要执行拦截器中一些相关方法,在这些方法中可以对请求进行相应预处理(例如权限检测,参数验证),这些方法可以决定对这个请求进行拦截还是放行.通过spring mvc 架构图分析,拦截器在Spring MVC中处理流程中的一个位置

　　　　回顾Spring MVC详细架构图

　　思考:假如对请求数据进行编码,是应在过滤器还是拦截器?

　　5.2. 拦截器编写及配置

　　　　拦截器如何编写?

　　　　我们自己编写Spring MVC拦截器需要实现HandlerInterceptor接口或者继承此接口的实现类 HandlerInterceptorAdapter（继承这个类时可根据需求重写必要的方法）

public class SysUserInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(
            HttpServletRequest request,
            HttpServletResponse response, Object handler)
            throws Exception {
            System.out.println("preHandle");
        return true;//表示放行
    }
    @Override
    public void postHandle(
            HttpServletRequest request,
            HttpServletResponse response,
            Object handler,
            ModelAndView modelAndView) 
            throws Exception {
            System.out.println("postHandler"
                + ".modelAndView="+modelAndView);
    }
    @Override
    public void afterCompletion(
            HttpServletRequest request,
            HttpServletResponse response, 
            Object handler,
            Exception ex)
            throws Exception {
             System.out.println("afterCompletion.handler="+
            handler.getClass());
    }
}

这些方法的简易执行流程点如下图所示：

这些方法的详细的执行时间点如下：

我们自己的拦截器编写完成以后需要在spring配置文件中进行配置,，

例如:

<mvc:interceptors>
           <mvc:interceptor>
             <!-- 指定拦截哪些请求路径 -->
             <mvc:mapping path="/**"/>
             <!-- 排除要拦截的路径 -->
             <mvc:exclude-mapping path="/sys/doLogin.do"/>
             <!-- 拦截器 -->
             <bean class="cn.spring.mvc.interceptor.SysUserInterceptor"/>
           </mvc:interceptor>
</mvc:interceptors>

　　　　当我们系统中有多个拦截器时,这些拦截器可以构成一个拦截器链.其原理类似过滤器中的过滤链。在多个拦截器应用中仅当所有匹配的拦截器的preHandle()都执行之后，才会调用Controller中处理请求的方法，然后再执行所有匹配的拦截器的postHandler()，再执行所有匹配的拦截器的afterCompletion()。

　　　　在拦截器链中，各拦截器的执行先后顺序取决于配置文件中配置的节点的先后顺序！

6. Spring MVC异常处理

　　6.1. Spring MVC 异常概述

　　　　实际项目中我们经常会采用分层架构设计程序,每一层都可能会有异常,假如异常信息没有处理,可能会选择抛出,假如这些被抛出的异常与具体业务相关,那到控制层以后我们一般都进行相应的处理(处理方式应该相对友好)

　　　　在Spring mvc 项目中,边界出现异常以后我们通常会在Controller中进行处理,常用分层架构中的异常分析:

　　　　在分层架构中，异常可能会从DAO层逐步抛出到控制层，可以在控制层对异常进行相关处理。

6.2. Spring MVC 异常处理

　　在spring中处理异常时,通常会在Controller中定义具体的异常处理方法,这个方法上使用@HandlerException注解进行描述.例如在指定Controller中定义异常处理方法:

@ExceptionHandler(value=Exception.class)
@ResponseBody
public String handleException(Exception e){
    System.out.println("局部异常处理");
    return e.getMessage();
}

当Spring的controller中没有定义具体的异常方法,我们外部定义一个全局的异常处理类,这个类使用@ControllerAdvice注解进行修饰.然后在这个类中定义具体的异常处理方法,这些方法再使用@HandlerExcpeiton进行修饰,例如

@ControllerAdvice
public class AdviceExceptionHandler {
    @ExceptionHandler(Throwable.class)
    @ResponseBody
    public String handlerException(Throwable e){
        System.out.println("全局的异常处理");
        return e.getMessage();
    }
}

1. Spring MVC 文件上传

　　1.1. 文件上传业务场景

　　　　在电子商务系统中对具体商品采用图片方式进行描述，这个图片需要上传到服务器等等。

　　1.2. Spring MVC 文件上传基本步骤

　　　　Step01: 添加文件上传相关依赖（jar包：commons-fileupload）

　　　　Step02: 配置对上传文件对象的解析(spring的核心配置文件)

　　　　Step03: 编写文件上传表单(请求方式为post,enctype必须为multipart/form-data)

　　　　Step04: 编写对应的控制层对象处理文件上传(通过mutilpartFile参数接收文件)

　　1.2.1. 添加依赖

<dependency>
   <groupId>commons-fileupload</groupId>
   <artifactId>commons-fileupload</artifactId>
   <version>1.3.3</version>
  </dependency>

1.2.2. 配置对象解析

在spring的核心配置文件中添加对象解析

<bean id="multipartResolver" 
         class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- 配置文件编码处理 -->
        <property name="defaultEncoding" value="utf-8"/>
        <!-- 配置文件大小限制 -->
        <property name="maxUploadSize" value="4096000000"/>
        <!-- 配置内存缓冲区大小 -->
        <property name="maxInMemorySize" value="1024000"/>
   </bean>

说明：配置对象解析时，bean的id一定要指定，而且官方规定必须为multipartResolver

1.2.3. 定义upload.jsp

在WEB-INF/pages目录下创建一个upload.jsp,然后创建上传表单

<body>
   <h1>文件上传</h1>
   <h1>${msg}</h1>
   <form action="doUpload.do" 
         method="post"
         enctype="multipart/form-data">
        <input type="file" name="upfile"/>
        <br/>
        <input type="submit" value="upload"> 
   </form>
</body>

说明：定义表单时，提交方式必须为post，enctype必须为multipart/form-data

1.2.4. 定义UploadController

@RequestMapping("/upload/")
@Controller
public class UploadController {
       @RequestMapping("uploadUI")
       public String uploadUI(){
           return "upload";
       }
      
       @RequestMapping("doUpload")
       public ModelAndView doUpload(MultipartFile upfile)
                throws IOException{
           //获取文件名以及文件大小，检测是否获得文件相关数据
           String fileName=upfile.getOriginalFilename();
           long size=upfile.getSize();
           System.out.println(fileName+"/"+size);
            //构建文件目标对象，这个对象对应的文件路径必须是存在的或者通过file对象自己创建
           File dest=new File("D:/SSMWORK/"+fileName);
           //transferto实现文件上传
           upfile.transferTo(dest);
           //封装数据返回
           ModelAndView mv=new ModelAndView("upload");
           mv.addObject("msg", "upload ok");
           return mv;
       }
}