Spring MVC

一笑知语

已于 2023-03-18 00:08:40 修改

阅读量131

点赞数

文章标签： spring mvc java

于 2023-03-18 00:01:58 首次发布

本文链接：https://blog.csdn.net/qq_44005434/article/details/129630561

版权

Spring MVC

志合者，不以山海为远；道乖者，不以咫尺为近

1. MVC简介

1.1 定义

MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范，MVC不是一种设计模式，MVC是一种架构模式

1.2 背景

Model1时代：主要分为两层，视图层和模型层。逻辑基本在jsp上。jsp本质是一个Servlet
Model2时代：MVC：模型(dao、service) 视图(jsp) 控制器(Servlet)，最典型的MVC就是JSP + servlet + javabean的模式。

1.3 功能

将url映射到java类或java类的方法
封装用户提交的数据
处理请求–调用相关的业务处理–封装响应数据
将响应的数据进行渲染 . jsp / html 等表示层数据

1.4 常见框架

常见的服务器端MVC框架有：Struts、Spring MVC、ASP.NET MVC、Zend Framework、JSF
常见前端MVC框架：vue、angularjs、react、backbone；
MVC演化出了另外一些模式如：MVP、MVVM【前后端分离核心】等

2. Spring MVC概述

2.1 定义

官网

Spring MVC是Spring Framework的一部分，是基于Java实现MVC的轻量级Web框架。

2.2 特点

与Spring无缝结合，可以将mvc的bean注册到Spring，使用人多
约定优于配置
功能多：RESTful、数据验证、格式化、本地化、主题等
Spring的web框架围绕DispatcherServlet [ 调度Servlet ] 设计，DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类）

1. public class DispatcherServlet extends FrameworkServlet
2. public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {
3. public abstract class HttpServletBean extends HttpServlet implements EnvironmentCapable, EnvironmentAware {

2.3 Spring MVC原理和流程

当发起请求时被前置的控制器拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器，控制器使用模型与视图渲染视图结果，将结果返回给中心控制器，再将结果返回给请求者

Spring MVC原理和流程图

DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截请求。
- web.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">

    <!--配置DispatcherServlet ：这个是SpringMVC的核心：请求分发器，前端控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--DispatcherServlet要绑定Spring 的配置文件-->
        <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>
    <!--
       在SpringMVC中 ，/  /*
       /：只匹配所有的请求，不包括jsp页面
       /*：匹配所有的请求，包括jsp页面,可能会404不建议
   -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

<!--    <servlet>-->
<!--        <servlet-name>hello</servlet-name>-->
<!--        <servlet-class>cn.xxy.servlet.HelloServlet</servlet-class>-->
<!--    </servlet>-->
<!--    <servlet-mapping>-->
<!--        <servlet-name>hello</servlet-name>-->
<!--        <url-pattern>/hello</url-pattern>-->
<!--    </servlet-mapping>-->
    
<!--    <session-config>-->
<!--        <session-timeout>15</session-timeout>-->
<!--    </session-config>-->
<!--    -->
    <welcome-file-list>
        <welcome-file>form.jsp</welcome-file>
    </welcome-file-list>
</web-app>

HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping,HandlerMapping根据请求url查找Handler。
- springmvc-servlet.xml【接口版】
缺点：一个控制器中只有一个方法handleRequest，不方便

@FunctionalInterface
public interface Controller {
    @Nullable
    ModelAndView handleRequest(HttpServletRequest var1, HttpServletResponse var2) throws Exception;
}

<?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 class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    <!--添加 处理器适配器-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
    <!--视图解析器:DispatcherServlet给他的ModelAndView
     视图解析器：模板引擎 Thymeleaf  Freemarker ...
     -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
    <!--Handler-->
    <bean id="/hello" class="cn.xxy.controller.HelloController"/>

</beans>

springmvc-servlet.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="1http://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.kuang.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>

HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器为：hello
HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。
HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。
Handler让具体的Controller执行。
- HelloController【接口版】

package cn.xxy.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;
    }

}

HelloController【注解版】

package cn.xxy.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;


@Controller
@RequestMapping("/hello2")
public class HelloController2 {
    @RequestMapping("/h2")
    public String hello(Model model) {
        model.addAttribute("msg", "helloannotion");
        return "hello";
    }

}

Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。
HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。
DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名
视图解析器将解析的逻辑视图名传给DispatcherServlet。
DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。
最终视图呈现给用户

2.4 RestFul 风格【不是标准】

Restful就是一个资源定位及资源操作的风格。请求地址一样，但是功能可以不同！不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制

资源操作：使用POST、DELETE、PUT、GET，使用不同方法对资源进行操作，分别对应添加、删除、修改、查询。
注解有：

@PathVariable //路经变量，放参数旁边
@RequestMapping(value = "/add/{p1}/{p2}")
    @GetMapping("/add/{p1}/{p2}") // 等同于   @RequestMapping(value = "/add/{p1}/{p2}",method = RequestMethod.GET)，下面同理
    @PostMapping("/add/{p1}/{p2}")
    @DeleteMapping("/add/{p1}/{p2}")
    @PutMapping("/add/{p1}/{p2}")

2.5 页面跳转方式

ModelAndView： {视图解析器前缀} + viewName +{视图解析器后缀}

没有解耦

<!-- 视图解析器 -->
 <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
      id="internalResourceViewResolver">
    <!-- 前缀 -->
    <property name="prefix" value="/WEB-INF/jsp/" />
    <!-- 后缀 -->
    <property name="suffix" value=".jsp" />
 </bean>

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;
   }
 }

ServletAPI

不需要视图解析器 ,不建议使用,通过HttpServletResponse进行输出,通过HttpServletResponse实现重定向,通过HttpServletResponse实现转发

@Controller
 public class ResultGo {
 
    @RequestMapping("/result/t1")
    public void test1(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
        rsp.getWriter().println("Hello,Spring BY servlet API");
   }
 
    @RequestMapping("/result/t2")
    public void test2(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
        rsp.sendRedirect("/index.jsp");
   }
 
    @RequestMapping("/result/t3")
    public void test3(HttpServletRequest req, HttpServletResponse rsp) throws Exception {
        //转发
        req.setAttribute("msg","/result/t3");
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,rsp);
   }
 
 }

SpringMVC

无视图解析器

@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";
   }
 }

有视图解析器

@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为另一个请求/
   }
 
 }

对比Model ，ModelMap ，ModelAndView

序号	名称	功能
1	Model	只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解；
2	ModelMap	继承了 LinkedMap ，除了实现了自身的一些方法，同样的继承 LinkedMap 的方法和特性
3	ModelAndView	可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转，但没有解耦

2.6 接收参数并绑定

注解

通过如HttpServletRequest等API得到请求数据，但推荐使用注解方式

序号	注解	功能
1	@RequestParam	绑定单个请求参数值
2	@PathVariable	绑定URI模板变量值
3	@CookieValue	绑定Cookie数据值
4	@RequestHeader	绑定请求头数据
5	@ModelValue	绑定参数到命令对象
6	@SessionAttributes	绑定命令对象到session
7	@RequestBody	绑定请求的内容区数据并能进行自动类型转换等,例如JSON和RESTful风格
8	@RequestPart	绑定“multipart/data”数据，一般上传和下载

单个请求参数值

@RequestParam(value=“user_id”)

@RequestMapping("/selectUser")
public String selectUser(@RequestParam(value="user_id")Integer id) {
    System.out.println("id="+id);
    return "success";
}

对象实体

直接对象放入参数User user,前端传递的参数名和对象名必须一致

@RequestMapping("/registerUser")
public String registerUser(User user) {
    	System.out.println(user);
       return "success";
}

2.7 乱码

前端乱码【过滤器】

    <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>

Tomcat乱码【修改配置文件】

<Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
           connectionTimeout="20000"
           redirectPort="8443" />

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>

自定义编码

package cn.xxy.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;
   }
 }

2.8 JSON

定义

JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式,独立于编程语言的文本格式来存储和表示数据

格式

var obj = {a: 'Hello', b: 'World'}; //这是一个对象，注意键名也是可以使用引号包裹的
 var json = '{"a": "Hello", "b": "World"}'; //这是一个 JSON 字符串，本质是一个字符串
var obj = JSON.parse('{"a": "Hello", "b": "World"}');//JSON字符串转换为JavaScript 对象
var json = JSON.stringify({a: 'Hello', b: 'World'});//JavaScript 对象转换为JSON字符串

注解

序号	名称	功能
1	@ResponseBody	直接返回json对象，用于method
2	@RequestBody	用于请求的数据绑定到方法的形参中，用于形参上
3	@RestController	里面所有的方法都只会返回 json 字符串，不用再每一个方法都添加@ResponseBody

开发测试

导包【jackson\fastjson】

<dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson-databind.version}</version>
        </dependency>

实体类

package cn.xxy.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private int age;
    private String sex;

}

Controller类

package cn.xxy.controller;


import cn.xxy.pojo.User;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/json1")
    //不会走视图解析器，会直接返回一个字符串,配合Controller使用！
    @ResponseBody
    public String json1() throws JsonProcessingException {
        //创建一个jackson的对象映射器，用来解析数据 jackson  ObjectMapper
        ObjectMapper mapper = new ObjectMapper();
        //创建一个对象
        User user = new User("xxy", 3, "男");
        //将我们的对象解析成为json格式
        String str = mapper.writeValueAsString(user);
        //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
        return str;
    }
}

json乱码
- 第一种解决

//produces:指定响应体返回类型和编码
 @RequestMapping(value = "/json1",produces = "application/json;charset=utf-8")

第二种解决

<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>

日期优化(getjson作为一个工具类)

package cn.xxy.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

import java.text.SimpleDateFormat;
import java.util.logging.SimpleFormatter;

public class JsonUtil {
//重载
    public static String getJson(Object object) {
        return getJson(object,"yyyy-MM-dd HH:mm:ss");
    }

    private static String getJson(Object object, String s) {
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(s);
        objectMapper.setDateFormat(simpleDateFormat);
        try {
            return objectMapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }
}

fastjson
- 导包

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
        </dependency>

测试

package cn.xxy.controller;


import cn.xxy.pojo.User;
import cn.xxy.utils.JsonUtil;
import com.alibaba.fastjson.JSON;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;

@RestController
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/json1")
    //不会走视图解析器，会直接返回一个字符串,配合Controller使用！
    public String json1() throws JsonProcessingException {
        //创建一个对象
//        User user = new User("xxy", 3, "男");
        Date date = new Date();
        //将我们的对象解析成为json格式
        String str = JsonUtil.getJson(date);
        //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
        return str;
    }
    @RequestMapping("/json2")
    public String json2() {
        User user = new User("xxy", 3, "男");
        return JSON.toJSONString(user);
    }
}

2.9 Ajax【 Asynchronous JavaScript and XML】

概述

使用ajax技术的网页，通过在后台服务器进行少量的数据交换，就可以实现异步局部更新,框架一般用AXIOS库来使用ajax

jQuery库的ajax

jQuery Ajax本质就是 XMLHttpRequest，对他进行了封装，

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 将自动替换 ? 为正确的函数名，以执行回调函数

测试

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
  <title>$Title$</title>
  <%--加载动态的JQ资源--%>
  <script src="https://code.jquery.com/jquery-3.4.1.js"></script>
  <script>
    /*
    AJax后盾必须懂的东西：
    url：后端接受的地址
    data：后端接受到的请求参数，json数据格式=前后端分离时候，后端传的数据便于前端接受就是json数据
    success:后端接受成功返回的函数
    error:后盾失败接受返回的函数
    */
    function username() {
      $.post({
        url: "${pageContext.request.contextPath}/a1",
        data: {"name": $("#username").val()},
        success: function (data, status) {
          alert(data);
          console.log("data:" + data);
          console.log("status:" + status);
        },
        error:function (e){
          alert("error" + e);
        }
      })
    }

  </script>
</head>
<body>
<%--实现Ajax异步请求
1 绑定单击事件
2 单击事件函数使用Jq：$.post({})
--%>
用户名:<input type="text" id="username" onclick="username()">
</body>
</html>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
  <title>$Title$</title>
  <%--加载动态的JQ资源--%>
  <script src="https://code.jquery.com/jquery-3.4.1.js"></script>
  <script>
    /*
    AJax后盾必须懂的东西：
    url：后端接受的地址
    data：后端接受到的请求参数，json数据格式=前后端分离时候，后端传的数据便于前端接受就是json数据
    success:后端接受成功返回的函数
    error:后盾失败接受返回的函数
    */
    function username() {
      $.post({
        url: "${pageContext.request.contextPath}/a1",
        data: {"name": $("#username").val()},
        success: function (data, status) {
          alert(data);
          console.log("data:" + data);
          console.log("status:" + status);
        },
        error:function (e){
          alert("error" + e);
        }
      })
    }

  </script>
</head>
<body>
<%--实现Ajax异步请求
1 绑定单击事件
2 单击事件函数使用Jq：$.post({})
--%>
用户名:<input type="text" id="username" onclick="username()">
</body>
</html>

@Controller
public class AjaxController {
    @RequestMapping("/a1")
    public void ajax1(String name , HttpServletResponse response) throws IOException {
        if ("admin".equals(name)){
            response.getWriter().print("true");
        }else{
            response.getWriter().print("false");
        }
    }
}

2.10 拦截器

必须实现 HandlerInterceptor 接口

概述

拦截器类似于Servlet开发中的过滤器Filter,用于对处理器进行预处理和后处理

2.过滤器与拦截器的区别

拦截器是AOP思想的具体应用
过滤器在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截，任何java web工程都可以使用
拦截器只会拦截访问的控制器方法，如果访问的是jsp/html/css/image/js是不会进行拦截的，只有使用了SpringMVC框架才能使用

测试

public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //return true：执行下一个拦截器
        System.out.println("===========处理前,这里进行拦截处理=================");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("===========处理后，通常进行日志管理=================");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("===========清洁中=================");
    }
}

<!--拦截器配置-->
<mvc:interceptors>
    <mvc:interceptor>
        <!--
                /**是拦截之后所有的请求，比如/admin/a1/2131
            -->
        <mvc:mapping path="/**"/>
        <bean class="com.ssl.config.MyInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

2.11 文件上传下载

Spring MVC为文件上传提供了直接的支持，这种支持是用即插即用的MultipartResolver实现的。

概述

前端表单设置enctype为multipart/form-data，浏览器即会采用二进制流的方式来处理表单数据，而对于文件上传的处理则涉及在服务器端解析原始的HTTP响应。在2003年，Apache Software Foundation发布了开源的Commons FileUpload组件，其很快成为Servlet/JSP程序员上传文件的最佳选择。

测试上传

pom.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>

index.jsp

<form action="/upload" enctype="multipart/form-data" method="post">
  <input type="file" name="file"/>
  <input type="submit" value="upload">
 </form>

springmvc-servlet.xml

id不能变，必须是multipartResolver

<!--文件上传配置-->
 <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>

序号	CommonsMultipartResolver类的方法	功能
1	String getOriginalFilename()	获取上传文件的原名
2	InputStream getInputStream()	获取文件流
3	void transferTo(File dest)	将上传文件保存到一个目录文件中

FileController

package cn.xxy.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:/WEB-INF/jsp/shangchuan.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";
    }
    /*
     * 采用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";
    }
}

测试下载

  @RequestMapping(value = "/download")
    public String downLoad(HttpServletResponse response, HttpServletRequest request) throws IOException {
        //手动设置，要下载的图片地址
        String path = request.getServletContext().getRealPath("/upload");
        String fileName = "1.png";
        //设置响应头
        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);
        //读取文件-输入流
        InputStream input = new FileInputStream(file);
        //写入文件-输出流
        OutputStream out = response.getOutputStream();
        byte[] buff = new byte[1024];
        int index = 0;
        while ((index = input.read(buff)) != -1) {
            out.write(buff,0,index);
            out.flush();
        }
        input.close();
        out.close();
        return "redirect:/index.jsp";
    }

<a href="${pageContext.request.contextPath}/static/1.png">图片下载</a>

3. 总结

本次完成Spring MVC的复习，重点在原理和流程的掌握，三部分：映射器+适配器+前端显示

一笑知语

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring MVC

spring mvc
复制链接

扫一扫

Spring MVC

Spring MVC

1. MVC简介

1.1 定义

1.2 背景

1.3 功能

1.4 常见框架

2. Spring MVC概述

2.1 定义

2.2 特点

2.3 Spring MVC原理和流程

2.4 RestFul 风格【不是标准】

2.5 页面跳转方式

2.6 接收参数并绑定

2.7 乱码

2.8 JSON

2.9 Ajax【 Asynchronous JavaScript and XML】

2.10 拦截器

2.11 文件上传下载

3. 总结

“相关推荐”对你有帮助么？