springmvc笔记回顾——持续更新

springmvc 概述


springmvc定义


基于spring的一个框架,实际上就是spring的一个模块,专门是做web开发的,理解为servlet的升级。web开发底层是servlet,框架是在servlet基础上面加入一些功能,让开发更方便。


spring和springmvc对比


spring:spring是容器,ioc能够管理对象,
使用< bean>,@Component,@Repository,@Service,@Controller 标签

springmvc:能够创建对象,放入到容器中(springmvc容器),spring容器中放的是控制器对象


springmvc简要流程


我们要做的是 使用 @Controller 创建控制器对象 ,把对象放入到springmvc 容器中,把创建的对象作为控制器使用。这个控制器对象能够接收用户的请求,显示处理结果,就当作是一个servlet使用。

使用 @Controller 注解创建的是一个普通的对象 ,不是servlet,springmvc赋予了控制器对象一些额外的功能。

web开发底层是servlet,springmvc中有一个对象是servlet:DispatcherServlet(中央调度器)
DispatcherServlet:负责接收用户的所有请求,用户把请求给了DispatcherServlet,之后DispatcherServlet把请求转发给我们的Controller对象,最后Controller对象处理请求。




开发步骤

index.jsp —> DispatcherServlet(中央调度器,类似servlet) ----> 转发,分配给Controller对象(@Controller 注解创建的对象)

需求:用户在页面发起一个请求,请求交给springmvc的控制器对象,并显示请求的处理结果

实现步骤:
1	新建web maven工程
2	加入依赖,spring-webmvc依赖,间接把spring的依赖加入到项目中,jsp,servlet依赖

3	重点:在web.xml中注册springmvc框架的核心对象 DispatcherServlet
	1)DispatcherServlet叫做:中央调度器,是一个servlet,他的父类继承 HttpServlet
	2)DispatcherServlet也叫做:前端控制器(from controller)
	3)DispatcherServlet:负责接收用户提交的请求,调用其他控制器对象,并把请求的处理结果显示给用户
	
4	创建一个发起请求的页面 index.jsp
5	创建控制器类
	1)在类的上面加入@Controller注解,创建对象,并放到springmvc容器中
	2) 在类中的方法上面加入@RequestMapping注解
    
6	创建一个作为结果的jsp,显示请求的处理结果。
7	创建springmvc的配置文件(和spring的配置文件一样)
	1)声明组件扫描器,指定@Controller注解所在的包名
	2)声明视图解析器,帮助处理视图

springmvc 开发流程:

1	发起some.do请求
2	tomcat (web.xml	从url-pattern知道 *.do 的请求给DispatcherServlet)
3	DispatcherServlet(根据spring.xml配置知道some.dodoSome()方法)
4	DispatcherServlet把some.do转发给MyController.doSome()方法
5	框架执行doSome()把得到的ModelAndView进行处理,转发到show.jsp	

简化流程:

some.do -> DispatcherServlet -> MyController

流程如图:
流程如图:



创建好web项目后,在pom.xml中加入servlet和springmvc依赖

<!--servlet-->
<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>javax.servlet-api</artifactId>
  <version>3.1.0</version>
  <scope>provided</scope>
</dependency>

<!--spring mvc-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>5.2.5.RELEASE</version>
</dependency>

发送some.do请求的页面 index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <p>第一个springmvc项目</p>
    <p><a href="some.do">发起some.do请求</a></p>
</body>
</html>

核心配置文件 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">

        <!--声明:注册springmvc的核心对象DispatcherServlet

        需要在tomcat服务器启动后,创建DispatcherServlet对象实例

        为什么要创建DispatcherServlet对象的实例呢?
        因为在DispatcherServlet创建过程中,会同时创建springmvc容器对象,
        读取springmvc的配置文件,把这个配置文件中的对象都配置好,
        当用户发起请求时就可以直接使用对象了。

        servlet的初始化会执行init()方法,DispatcherServlet在init()中{
            //创建容器,读取配置文件
            webApplicationContext ctx = new ClassPathXmlApplicationContext("springmvc.xml");
            //把容器对象放入到ServletContext中
            getServletContext().setAttribute(key,ctx);
         }
    -->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <!--自定义springmvc读取文件的位置-->
        <init-param>
            <!--springmvc配置文件的位置属性-->
            <param-name>contextConfigLocation</param-name>
            <!--指定自定义文件的位置-->
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>

        <!--表示在tomcat启动后,创建servlet对象
            数字表示启动后创建对象的顺序,数值越小,tomcat创建对象越早,要求大于等于0的整数
        -->
        <load-on-startup>1</load-on-startup>

    </servlet>

        <servlet-mapping>
            <servlet-name>springmvc</servlet-name>
            <!--
                使用框架的时候,url-pattern可以使用两种值
                1.使用扩展名方式,语法 *.xxxx , xxxx时自定义扩展名。常用的方式 *.do, *.action, *.mvc等等
                    http://localhost:8080/myweb/some.do
                    http://localhost:8080?myweb/other.do
                2.使用斜杠"/"
            -->
            <url-pattern>*.do</url-pattern>
        </servlet-mapping>
</web-app>

tomcat启动,创建DispatcherServlet对象,同时创建springmvc容器对象,读取springmvc配置文件,
这里配置文件的根地址 classpath = springmvc.xml
在spring.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"
       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">

    <!--声明组件扫描器-->
    <context:component-scan base-package="com.zh.controller"/>
    
     <!--声明 springmvc框架中的视图解析器,帮助开发人员设置视图文件的路径-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--前缀:视图文件位置-->
        <property name="prefix" value="/WEB-INF/view/"/>
        <!--后缀:视图文件的扩展名-->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

创建控制器类 MyController.java

package com.zh.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

/*
* @Controller:创建处理器对象,对象放在springmvc容器中
*
* 能处理请求的都是控制器(处理器):MyController能处理请求,
*                               叫做后端控制器(back controller)
* */
@Controller
public class MyController {
    /*
    * 处理用户提交的请求,springmvc中是使用方法来处理的。
    * 方法是自定义的,可以有多种返回值,多种参数,方法名称自定义
    * */

    /*
    * 准备使用doSome方法处理some.do请求。
    * @RequestMapping:请求映射,作用是把一个请求地址和一个方法绑定在一起。
    *                  一个请求指定一个方法处理。
    *             属性:1. value是一个String类型,表示请求的uri地址(这里是:some.do)
    *                     value值是唯一的,不能重复
    *             说明:使用@RequestMapping修饰的方法叫做处理器方法或者控制器方法
    *                   可以处理请求,类似servlet中的doGet,doPost
    * */

    /*
    * 返回值 ModelAndView 表示本次请求的处理结果
    *   model:数据,请求处理完后,要显示给用户的数据
    *   view:视图,比如jsp等
    * */
    @RequestMapping(value = "/some.do")
    public ModelAndView doSome(){
        //处理some.do请求,相当于service调用处理完成了
        ModelAndView mv = new ModelAndView();
        //添加数据,框架在请求的最后把数据放入到request作用域
        //request.setAttribute("msg","欢迎使用....");
        mv.addObject("msg","欢迎使用springmvc做web开发");
        mv.addObject("fun","执行的是doSome方法");

        //指定视图,指定视图的完整路径
        //框架对视图执行的forward操作,request.getRequestDispather("/show.jsp").forward(...)
        mv.setViewName("/show.jsp");
        return mv;
    }
    
    
    //在springmvc.xml配置视图解析器后,修改 setViewName()
    @RequestMapping(value = {"/other.do","/second.do"})
    public ModelAndView doOther(){
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","---------欢迎使用springmvc做web开发----------");
        mv.addObject("fun","执行的是doOther方法");
        
        //当配置了视图解析器后,可以使用逻辑名称(文件名),指定视图
        //框架会使用视图解析器的 前缀 + 逻辑名称 +后缀 组成完整路径
        mv.setViewName("other");
        return mv;
    }
}

对应的 show.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h3>show.jsp从request作用域获取数据</h3><br/>
    <h3>msg数据:${msg}</h3>
    <h3>fun数据:${fun}</h3>
</body>
</html>




springmvc注解式开发



@RequestMapping 定义请求规则



放在类上面使用

/*
* @RequestMapping
* 	value:所有请求的公共部分,叫做模块名称
*   位置:在类的上面
* */

@Controller
@RequestMapping("/user")
//或者@RequestMapping("/test")
public class MyController {

    @RequestMapping(value = "/some.do")
    public ModelAndView doSome(){
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","欢迎使用springmvc做web开发");
        mv.addObject("fun","执行的是doSome方法");
        mv.setViewName("show");
        return mv;

    }
}

理解为在该方法在 user或者test模块下

在这里插入图片描述


method 属性 指定请求方式

@Controller
@RequestMapping("/test")
public class MyController {
    /*
    * @RequestMapping(value = "",method = )
    * 	属性:method 表示请求的方式,它的值是RequestMethod类枚举值
    *
    * 	get请求方式, method = RequestMethod.GET
    * 	post请求方式,method = RequestMethod.POST
    * 
    * */

    //指定some.do用get请求获取
    @RequestMapping(value = "/some.do",method = RequestMethod.GET)
    public ModelAndView doSome(){
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","欢迎使用springmvc做web开发");
        mv.addObject("fun","执行的是doSome方法");
        mv.setViewName("show");
        return mv;
    }

    //指定other.do 用post请求获取
    @RequestMapping(value = "/other.do",method = RequestMethod.POST)
    public ModelAndView doOther(){
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","---------欢迎使用springmvc做web开发----------");
        mv.addObject("fun","执行的是doOther方法");
        mv.setViewName("other");
        return mv;
    }

对应的index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <p>第一个springmvc项目</p>
    <p><a href="test/some.do">发起some.do的get请求</a></p>
    <br/>

    <form action="test/other.do" method="post">
        <input type="submit" value="post请求other.do">
    </form>

<%--    <p><a href="user/other.do">发起other.do请求</a></p>--%>
</body>
</html>


处理器方法的参数



处理器方法可以包含以下四类参数,这些参数会在系统调用时由系统自动赋值,即程序员可以在方法中直接使用。

1	HttpServletRequest		 请求
2	HttpServletResponse		 应答
3	HttpSession				会话
4	请求中所携带的请求参数		

前三类参数使用方式


@Controller
public class MyController {
    @RequestMapping(value = "/some.do")
    public ModelAndView doSome(HttpServletRequest request,
                               HttpServletResponse response,
                               HttpSession session){
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","欢迎使用springmvc做web开发" + request.getParameter("name"));
        mv.addObject("fun","执行的是doSome方法");
        mv.setViewName("show");
        return mv;
    }

在这里插入图片描述


逐个参数接收

接收用户提交的参数:处理器(控制器)方法的形参名和请求中的参数必须一致

@Controller
public class MyController {
    /*
    * 逐个接收请求参数:
    *   要求:处理器(控制器)方法的形参名和请求中的参数必须一致
    *         同名的请求参数赋值给同名的参数
    *
    * 框架接收请求参数:
    * 1 使用request对象接收请求参数
    *   String strName = request.getParameter("name");
    *   String strAge = request.getParameter("age");
    * 2 springmvc框架通过dispatcherServlet 调用MyController的doSome方法
    *   调用方法时,按名称对应,把接收的参数赋值给形参 doSome(strName,Integer.valueOf(strAge))
    *   框架会提供类型转换的功能,把String转换为 int ,long ,float ,double等
    *
    * */
    @RequestMapping(value = "/some.do")
    public ModelAndView doSome(String name,Integer age){
        System.out.println("dosome方法的,name="+name+", age="+age);

        ModelAndView mv = new ModelAndView();
        mv.addObject("myname",name);
        mv.addObject("myage",age);
        mv.setViewName("show");
        return mv;
    }
}

对应的index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<p>提交参数给Controller</p>

<form action="some.do" method="post">
    姓名:<input type="text" name="name"><br/>
    年龄:<input type="text" name="age"><br/>
    <input type="submit" value="提交参数">
</form>

<%--    <p><a href="user/other.do">发起other.do请求</a></p>--%>
</body>
</html>

注意:在提交请求参数的时候,get请求方式中文没有乱码;post请求方式中文有乱码,需要使用过滤器处理乱码问题。

//在web.xml配置过滤器
<!--注册声明过滤器,解决post请求乱码的问题-->
<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>

    <!--强制请求对象(HttpServletRequest)使用encoding编码的值-->
    <init-param>
        <param-name>forceRequestEncoding</param-name>
        <param-value>true</param-value>
    </init-param>

    <!--强制应答对象(HttpServletResponse)-->
    <init-param>
        <param-name>forceResponseEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>

<filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <!--
    /*  : 表示强制所有的请求先通过过滤器处理
    -->
    <url-pattern>/rl-pattern>
</filter-mapping>

补充:springMVC 中的 M-model,V-view,C-controller

在这里插入图片描述



请求参数名和处理器方法的形参名不一样,使用 @RequestParam 注解


首页 index.jsp 的参数名是 iname 和 iage

<p>请求参数名和处理器方法的形参名不一样</p>
<form action="other.do" method="post">
    姓名:<input type="text" name="iname"><br/>
    年龄:<input type="text" name="iage"><br/>
    <input type="submit" value="提交参数">
</form>

控制器方法的 doOther 方法形参为 name 和 age

/*
* 请求参数名和处理器方法的形参名不一样
* @RequestParam:定义在处理器方法的形参前面
*   属性:1. value,请求参数名,可省略
*        2. required,是一个Boolean类型,默认为true,表示必须包含参数
* */
@RequestMapping(value = "/other.do")
public ModelAndView doOther(@RequestParam("iname" ) String name,
                            @RequestParam("iage") Integer age){
    System.out.println("doOther方法的,name="+name+", age="+age);

    ModelAndView mv = new ModelAndView();
    mv.addObject("myname",name);
    mv.addObject("myage",age);
    mv.setViewName("show");
    return mv;
}

但是有一个问题,当不通过首页传入参数,直接加载网址:http://localhost:8080/03_recevieparam/other.do ,将会报400的错,说明请求端输入有问题,如下图

在这里插入图片描述


此时将@RequestParam标签的属性required改为 fslse,不用参数也可以显示show.jsp。
当然我们希望required=true,作为前端限制。

public ModelAndView doOther(@RequestParam(value = "iname",required=false) String name,
                            @RequestParam(value = "iage",required = false) Integer age){

在这里插入图片描述



对象参数接收

将处理器方法的参数定义为一个对象,对象的属性名要求和请求中参数名一致


先在vo包下定义一个Student 类

在这里插入图片描述

//保存请求参数值的普通类
public class Student {
    //属性值要和请求参数值一样
    private String name;
    private int age;
    
    public Student() { System.out.println("---------Student的无参构造方法--------"); }
    public String getName() {return name;}
    public void setName(String name) {System.out.println("setName= "+name);this.name = name;}
    public int getAge() {return age;}
    public void setAge(int age) {System.out.println("setAge= "+age);this.age = age;}
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

主页index.jsp

<p>使用java对象接收参数</p>
<form action="object.do" method="post">
    姓名:<input type="text" name="name"><br/>
    年龄:<input type="text" name="age"><br/>
    <input type="submit" value="提交参数">
</form>

处理器方法

/*
* 处理器方法的形参是java对象,这个对象的属性名要求和请求中参数名一致
* 框架会创建形参的java对象,给属性赋值。请求中的参数是name,框架会调用setName()完成赋值
* */
@RequestMapping(value = "/object.do")
public ModelAndView doObject(Student student){
    System.out.println("doObject方法的,name="+student.getName()+", age="+student.getAge());

    ModelAndView mv = new ModelAndView();
    mv.addObject("myname",student.getName());
    mv.addObject("myage",student.getAge());
    mv.addObject(student);
    mv.setViewName("show");
    return mv;
}

页面结果

在这里插入图片描述


后台结果

在这里插入图片描述


处理器方法返回值



ModelAndView 返回值

若处理器方法处理完后,需要跳转到其他资源,且又要在跳转的资源间传递数据,此时处理器方法返回 ModelAndView 比较好。当然,若要返回 ModelAndView,则处理器方法中需要定义 ModelAndView对象。


返回值 String ,表示逻辑视图名称或完整视图路径

@Controller
public class MyController {
    /*
    * 处理器方法返回String,表示逻辑视图名称,需要配置视图解析
    * */
    @RequestMapping(value = "/returnString-view.do")
    public String doReturnView(HttpServletRequest request,String name, Integer age) {
        System.out.println("dosome方法的,name=" + name + ", age=" + age);

        //手动添加数据到request作用域
        request.setAttribute("myname",name);
        request.setAttribute("myage",age);
        /*
        * show:逻辑视图名称
        * 框架对视图执行forward转发操作
        * */
        return "show";
    }

    //处理器方法返回 String,表示完整视图路径,此时不能配置视图解析器
    @RequestMapping(value = "/returnString-view2.do")
    public String doReturnView2(HttpServletRequest request,String name, Integer age) {
        System.out.println("---doReturnView2方法---,name=" + name + ", age=" + age);

        //手动添加数据到request作用域
        request.setAttribute("myname",name);
        request.setAttribute("myage",age);
        /*
         * 完整视图路径,项目中不能配置视图解析器
         * 框架对视图执行forward转发操作
         * */
        return "WEB-INF/view/show.jsp";
    }

}

返回值 void ,了解

void:不能表示数据,也不能表示视图。在处理ajax的时候,可以使用void返回值。通过HttpServletResponse输出数据。响应ajax请求。ajax请求服务器端返回的就是数据,和视图无关。


返回值 object 对象

object:例如String,Integer,Map,List,Student 等等都是对象,对象有属性,属性就是数据。所以返回 object 表示数据,和视图无关。可以使用对象表示的数据,响应ajax请求。


现在做 ajax,主要使用 json的数据格式。
面试:springmvc开发中,返回值是object类型,如何转换为 json ?实现步骤

1	加入处理json的工具库的依赖,springmvc默认使用的jackson

	pom.xml 加入jackson依赖

	<!--jackson依赖-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.9.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.0</version>
    </dependency>

2	在springmvc配置文件之间加入 <mvc:annotation-driven> 注解驱动
    
    主配置文件 springmvc.xml 加入:
    
    <!--@ResponseBody注解驱动-->
    <mvc:annotation-driven/>
    
3	在处理器方法的上面加上 @ResponseBody
3	在处理器方法的上面加上 @ResponseBody
    
控制器方法 MyController.java

//处理器方法返回一个Student,通过框架转为json,响应ajax请求
//@ResponseBody 作用:把处理器方法返回对象转为json后,通过HttpServletResponse输出给浏览器
@ResponseBody
@RequestMapping(value = "returnStudentJson.do")
public Student doStudentJsonObject(String name,Integer age){

    Student student = new Student();
    student.setName("lisi");
    student.setAge(10);
    return student; //会被框架转为json
}

当返回值是多个参数(用的比较普遍),返回类型改为List集合,其他不变

@RequestMapping(value ="returnStudentJsonArray.do" )
@ResponseBody
public List<Student> doStudentJsonObjectArray(String name,Integer age){

    List<Student> list = new ArrayList<>();
    Student student = new Student();
    student.setName("wangwu");
    student.setAge(22);
    list.add(student);

    student = new Student();
    student.setName("tianmao");
    student.setAge(10);
    list.add(student);

    return list;
}

前端页面 index.jsp ,返回 json 格式为:[{“name”:“wangwu”,“age”:22},{“name”:“tianmao”,“age”:10}]

<head>
    <title>Title</title>
    <script type="text/javascript" src="js/jquery-3.5.1.js"></script>
    <script type="text/javascript">
        $(function () {
            $("button").click(function () {
                // alert("button click");
               $.ajax({
                   
                   // url:"returnVoid-ajax.do",
                   // url:"returnStudentJson.do",
                   url:"returnStudentJsonArray.do",
                   
                   data:{
                       name:"zhangsan",
                       age:20
                   },
                   type:"post",
                   dataType:"json",
                   success:function(resp) {

                       // alert(resp.name+"   "+resp.age);

                       //[{"name":"wangwu","age":22},{"name":"tianmao","age":10}]
                       $.each(resp,function (i,n) {
                            alert(n.name+"  "+n.age);
                       })
                   }
               })
            })
        })
    </script>
</head>

处理器方法返回的是 String,表示数据,不是视图

/*
* 处理器方法返回的是String,String表示数据的,不是视图。
* 区分返回值类型String是数据,还是视图,看看有没有@ResponseBody注解
* 如果有@ResponseBody注解,返回String就是数据,反之就是视图
* */


@ResponseBody
public String doStringData(String name,Integer age){
    return "返回对象,表示数据";
}

springmvc 处理器方法返回 object,可以转为 json输出到浏览器,响应 ajax 的内部原理

1 	<mvc:annotation-driven> 注解驱动
	注解驱动实现的功能是:完成java对象到 json,xml,test,二进制等数据格式的转换
	HttpMessageConverter接口:消息转换器
	功能:定义了java转json,xml等数据格式的方法。这个接口有很多实现类
		这些实现类完成了java对象到json,Java对象到xml,Java对象到二进制数据的转换

2	HttpMessageConverter接口的两个方法是:控制器类把结果输出给浏览器时使用的
		boolean canWrite(Class<?> var1, @Nullable MediaType var2);
		void write(T var1, @Nullable MediaType var2, HttpOutputMessage var3)
	
    	1) canWrite:检查处理器方法返回值,能不能转为var2的数据格式
    	2) write:把处理器方法的返回值对象,调用jackson中的ObjectMapper转为json字符串

3	ResponseBody 注解
    放在处理器方法的上面,通过HttpServletResponse输出结果,响应ajax请求
            



解读中央调度器 < url-pattern/ >


1 .do

在没有特殊要求的情况下,springmvc 的中央调度器 DispatcherServlet 的< url-pattern/ >常使用后缀匹配方式,如写为 *.do 或者 *.action , *.mvc 等


2 /

可以写为 / ,因为DispatcherServlet会将向静态资源的获取请求,例如 .css .js .jpg .png 等资源的获取请求,作为是一个普通的Controller请求。中央调度器会调用处理器映射器为其查找相应的处理器。当然也是找不到的,所以在这种情况下,所有的静态资源获取请求也均会报404错误。


发起的请求是由哪些服务器处理的:

http: //localhost:8080/05_url_pattern/index.jsp		tomcat
http: //localhost:8080/05_url_pattern/images/1.jpg	  tomcat
http: //localhost:8080/05_url_pattern/html/test.html	tomcat
http: //localhost:8080/05_url_pattern/some.do	springmvc框架(DispatcherServlet)

tomcat本身能处理静态资源的访问,像html,图片,js文件等都是静态资源


tomcat的web.xml文件有一个 servlet 名称为 default,在服务器启动时创建。如下:

<servlet>
    <servlet-name>default</servlet-name> 
    <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
    <init-param>
        <param-name>debug</param-name>
        <param-value>0</param-value>
    </init-param>
    <init-param>
        <param-name>listings</param-name>
        <param-value>false</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>/</url-pattern>	// "/" 表示静态资源和未映射的请求都给这个default处理
</servlet-mapping>

这个名叫 default 的 servlet 作用:
1 处理静态资源
2 处理未映射到其它servlet的请求


使用 ” / “ 后,无法访问静态资源,可以访问动态资源

// web.xml
<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <!--
   		使用框架的时候,url-pattern可以使用两种方式
    1.使用扩展名方式,语法 *.xxxx , xxxx时自定义扩展名。常用的方式 *.do, *.action, *.mvc等等
        http://localhost:8080/myweb/some.do
        http://localhost:8080?myweb/other.do

    2.使用斜杠 "/"
        当你的项目使用了 / ,它会替换 tomcat 中的 default.
        导致所有的静态资源都给DispatcherServlet处理,默认情况下DispatcherServlet没有处理静态资源的能力,
        没有控制器对象能处理静态资源的访问,所以静态资源(html,js,图片,css)都是404

        动态资源some.do可以访问,原因时我们程序中有MyController控制器对象,能处理some.do请求
    -->
    <url-pattern>/</url-pattern>
</servlet-mapping>

让静态资源可以访问的两种方式

1 使用 < mvc:default-servlet-handler > 和 < mvc:annotation-driven/ >


// springmvc.xml

<!--@ResponseBody注解驱动-->
<mvc:annotation-driven/>

<!--第一种处理静态资源的方式:<mvc:default-servlet-handler/>

    需要在springmvc配置文件加入 <mvc:default-servlet-handler>
    原理是:加入这个标签后,框架会创建控制器对象(类似自己创建的MyController),
    这个对象可以把接收到的请求转发给tomcat的名字叫default的servlet
-->
<mvc:default-servlet-handler/>

2 使用 < mvc:resources /> 需要掌握

在 spring3.0 版本后,spring定义了专门用来处理静态资源访问请求的处理器 ResourceHttpRequestHandler。并且添加了< mvc:resources />标签,专门用于解决资源无法访问问题。需要在springmvc配置文件中添加如下形式的配置:


   //springmvc.xml

	<!--第二种处理静态资源的方式
        mvc:resources加入后框架会创建 ResourceHttpRequestHandler这个处理器对象
        让这个对象处理静态资源的访问,不依赖tomcat服务器。
        mapping:访问静态资源的uri地址,使用通配符 **
        location:静态资源在你的项目中的目录位置
	-->
    <mvc:resources mapping="/images/**" location="/images/" />
    <mvc:resources mapping="/html/**" location="/html/" />
    <mvc:resources mapping="/js/**" location="/js/" />

为了方便,一般把静态资源统一放在 static 文件夹下

在这里插入图片描述

所以一个标签语句就可以指定多个静态资源的访问路径(重点):

<mvc:resources mapping="/static/**" location="/static/" />



地址分类


1 绝对地址:带有协议名称的,例如:http://www/baidu.com

2 相对地址,没有协议开头的,例如:user/some.do,/user/some.do
相对地址不能独立使用,必须有一个参考地址。通过参考地址+相对地址本身才能指定资源


3 参考地址

在你的页面中,访问地址不加 " / "

访问地址:http: //localhost:8080/06_path/index.jsp
路径:http: //localhost:8080/06_path/
资源:index.jsp

在index.jsp发起 user/some.do请求,访问地址变为http: //localhost:8080/06_path/test/some.do
在你的地址没有斜杠开头,例如:user/some.do,当你点击链接时,访问地址就是当前页面加上链接的地址
http: //localhost:8080/06_path/ + user/some.do


在你的页面中,访问地址加 " / "

访问地址:http: //localhost:8080/06_path/index.jsp
路径:http: //localhost:8080/06_path/
资源:index.jsp

点击 /user/some.do,访问地址变为:http: //localhost:8080/test/some.do
参考地址是你的服务器地址,也就是http: //localhost:8080

在这里插入图片描述


如果你的资源不能访问,加上:${pageContext.request.contextPath},修改如下


//index.jsp
<body>
    <p>第一个springmvc项目</p>
    <p><a href="/test/some.do">发起/test/some.do的get请求</a></p>
    <br/>
</body>

//修改为
<body>
    <p>第一个springmvc项目</p>
    <p><a href="${pageContext.request.contextPath}/test/some.do">发起test/some.do的get请求</a></p>
    <br/>
</body>

则在网页访问:http: //localhost:8080/06_path/index.jsp 时,网页源码如下

在这里插入图片描述

此时点击请求,动态获取项目地址(06_path),页面正确显示如下:

在这里插入图片描述

springmvc核心技术补充链接

https://blog.csdn.net/weixin_40350981/article/details/110039665

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 游动-白 设计师:上身试试 返回首页