Spring+SpringMVC+MyBatis-教程、笔记-3

已于 2023-07-24 22:00:07 修改
阅读量109 收藏
点赞数
分类专栏： Spring+SpringMVC+MyBatis-教程-笔记 文章标签： spring mybatis 笔记
于 2023-07-24 21:29:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48269763/article/details/131905391
版权

base黑马，视频链接：https://www.bilibili.com/video/BV1WZ4y1P7Bp?t=94.4
此系列文章可以当做视频的配套笔记，也可以当做自学SSM框架的教程。

Spring集成web环境-基本三层架构环境搭建

在原来代码的基础上，添加web层相关的坐标

<!--    添加web层相关的坐标-->
<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>javax.servlet-api</artifactId>
  <version>3.0.1</version>
  <scope>provided</scope>
</dependency>

<dependency>
  <groupId>javax.servlet.jsp</groupId>
  <artifactId>javax.servlet.jsp-api</artifactId>
  <version>2.2.1</version>
  <scope>provided</scope>
</dependency>

编写web层的代码UserServlet 继承 HttpServlet

package com.lyh.web;

import com.lyh.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class UserServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ApplicationContext app= new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) app.getBean("userService");
        userService.save();
    }
}

在 web.xml文件中 配置Servlet

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

  <servlet>
    <servlet-name>UserServlet</servlet-name>
    <servlet-class>com.lyh.web.UserServlet</servlet-class>
  </servlet>

  <servlet-mapping>
    <servlet-name>UserServlet</servlet-name>
    <url-pattern>/userServlet</url-pattern>
  </servlet-mapping>

</web-app>

将项目发布到TomCat上
效果：image.png
image.png

Spring继承web环境-ContextLoaderListener监听器的分析

应用上下文的获取方式
在web层通过Spring容器获得Service，Service内部的Dao是在容器内部注入的
ApplicationContext app= new ClassPathXmlApplicationContext(“applicationContext.xml”);
上面的代码获得应用上下文的
web层有很多业务，有很多的servlet组件，而每个当中如果想去调用方法，都需要应用上下文去获取service，每一个doGet、doPost都得写上面的一句话，配置文件和容器得创建很多个。（没有意义）
所有的配置都是在xml中配置的，加载一次创建一个Spring容器供大家去使用就可以了。image.png
可以使用监听器。
ApplicationContext app= new ClassPathXmlApplicationContext(“applicationContext.xml”)，这句话放到服务器一启动就让它创建，创建好的应用上下文对象，放到最大的域当中，也就是ServletContext（ApplicationContext域）域中。
在web层任何Servlet当中都能拿到最大的ServletContext域当中的应用上下文，因为达到了数据共享。
为什么用监听器？
服务器一启动，项目一被加载就会创建ServletContext对象（代表Servlet上下文）。ServletContext对象一被创建，就会有一个监听器被执行，ServletContextListener这个监听器就会被执行（专门监听ServletContext对象创建的）。如果编写一个ServletContextListener就会监听服务器启动，可以把ApplicationContext app= new ClassPathXmlApplicationContext(“applicationContext.xml”)，这个代码放到监听器初始化方法当中，创建好的对象可以放到最大的域当中。
image.png

Spring集成web环境-自定义ContextLoaderLIstener1

编写监听器类 ContextLoaderListener 内容如下所示：

package com.lyh.listener;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class ContextLoaderListener implements ServletContextListener {
    //上下文初始化的方法
    @Override	
    public void contextInitialized(ServletContextEvent servletContextEvent) {
        ApplicationContext app= new ClassPathXmlApplicationContext("applicationContext.xml");
        //得放到一个位置，让别人能在web层拿到 所以
        //将Spring的应用上下文对象存储到最大的域当中ServletContext域中
        ServletContext servletContext = servletContextEvent.getServletContext();
        servletContext.setAttribute("app",app);
        System.out.println("Spring容器创建完毕。。。 ");
    }

    //上下文销毁的方法
    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {

    }
    
}

在web.xml中配置监听器

<!--  配置监听器-->
<listener>  
  	<listener-class>com.lyh.listener.ContextLoaderListener</listener-class>
</listener>

web层UserServlet类中的代码

package com.lyh.web;

import com.lyh.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class UserServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //这是一种获取方式
        //ServletContext servletContext = req.getServletContext();
        //另一种获取方式
        ServletContext servletContext = this.getServletContext();
        ApplicationContext app = (ApplicationContext) servletContext.getAttribute("app");
        UserService userService = (UserService) app.getBean("userService");
        userService.save();
    }
}

重启服务器的效果：
image.png
image.png
image.png

Spring集成web环境-自定义ContextLoaderListener2

优化：
优化点1：
ContextLoaderListener类中的
ApplicationContext app= new ClassPathXmlApplicationContext(“applicationContext.xml”);
这行代码是写死的。具体点说就是applicationContext.xml这个代码是写死的。
可以把这个东西提升配置文件解耦，web.xml本身就是配置文件。
web.xml文件中的配置

<!--Web工程中的全局初始化参数-->
<!--  其中的名字和值可以自己定义-->
<context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>applicationContext.xml</param-value>
</context-param>
<!-- 这里会有一个爆红，但是不要紧 -->

ContextLoaderListener类中的内容

package com.lyh.listener;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class ContextLoaderListener implements ServletContextListener {
    //上下文初始化的方法
    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {
        ServletContext servletContext = servletContextEvent.getServletContext();
        //读取web.xml中的全局参数
        String contextConfigLocation = servletContext.getInitParameter("contextConfigLocation");
        ApplicationContext app = new ClassPathXmlApplicationContext(contextConfigLocation);

        //得放到一个位置，让别人能在web层拿到 所以
        //将Spring的应用上下文对象存储到最大的域当中ServletContext域中
        servletContext.setAttribute("app",app);
        System.out.println("Spring容器创建完毕。。。 ");
    }

    //上下文销毁的方法
    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {

    }
}

如果后期的配置文件的名字不叫applicationContext.xml这个名字，直接在web.xml配置文件中进行更改就可以了。
重启服务器…
效果：
image.png
是可以进行下去的

优化点2：
在web层的UserServlet类中

package com.lyh.web;

import com.lyh.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class UserServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = this.getServletContext();
         //这个app这个名字也是耦合死的，每次都得需要客户端去记住这个app这个名字（不太好）
        ApplicationContext app = (ApplicationContext) servletContext.getAttribute("app");
        UserService userService = (UserService) app.getBean("userService");
        userService.save();
    }
}

在listener包下面创建WebApplicationContextUtils类，内容如下：

package com.lyh.listener;

import org.springframework.context.ApplicationContext;
import javax.servlet.ServletContext;

public class WebApplicationContextUtils {
    //建立工具方法
    public static ApplicationContext getWebApplicationContext(ServletContext servletContext){
        return (ApplicationContext) servletContext.getAttribute("app");
    }
}

web层中的UserServlet中的代码

package com.lyh.web;

import com.lyh.listener.WebApplicationContextUtils;
import com.lyh.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
//这里需要仔细思考
public class UserServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = this.getServletContext();
        //ApplicationContext app = (ApplicationContext) servletContext.getAttribute("app");
        //也就是这里的servletContext.getAttribute("app");过程交给了一个方法去执行
        //这里就不具体的字符串了
        ApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(servletContext);
        UserService userService = (UserService) app.getBean("userService");
        userService.save();
    }
}

效果:
image.png
image.png
image.png

Spring集成web环境-Spring集成web环境代码实现

Spring提供获取应用上下文的工具
image.png
Spring提供的工具和自己手动写的是一样的。
image.png
导入坐标：

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-web</artifactId>
  <version>5.0.5.RELEASE</version>
</dependency>

在web.xml文件中进行配置

<!--全局初始化参数-->
<context-param>
  <param-name>contextConfigLocation</param-name>
  <!--需要指定文件的位置，这个文件在类加载路径当中-->
  <param-value>classpath:applicationContext.xml</param-value>
</context-param>

<!--  配置监听器-->
<listener>
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

测试代码，UserServlet类中的代码

package com.lyh.web;

import com.lyh.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class UserServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext servletContext = this.getServletContext();
        //ApplicationContext app = (ApplicationContext) servletContext.getAttribute("app");
        //这里就不具体的字符串了
        //ApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(servletContext);
        //WebApplicationContext 是 ApplicationContext 的 子
        //WebApplicationContext、ApplicationContext 这两个接收都是可以的
        ApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(servletContext);
        UserService userService = (UserService) app.getBean("userService");
        userService.save();
    }
}

重启服务器
效果：
image.png

SpringMVC简介-SpringMVC概述

image.png
M：Model，主要用于数据封装和业务逻辑处理
V：View，视图，主要用于数据的展示
C：Controller，控制器，主要用于分发，指派的工作。
Servlet内部有很多行为都是重复的。
一般Servlet内部执行的动作就是，接收请求参数、封装实体、访问业务层、接收返回结果、指派页面
可以将重复的行为给抽取出来。
抽取的部分一般是web层的框架，帮助完成的操作。image.png
在web应用的内部是web层的组件负责接收请求，比如就是Servlet。
客户端发送请求，首先接收请求的是TomCat服务器中的引擎。
TomCat引擎第一步要做的事情，是接收客户端的请求
然后将请求中的数据进行封装
HTTP请求、请求行、请求头、请求体等这些数据都会被TomCat进行封装。
第二步TomCat会封装一个代表请求的request对象 和 一个代表响应的response对象
现在请求是有数据的，而响应是没有数据的
第三步TomCat这个引擎会帮助去调用对应的资源（根据请求的地址）
共有行为：接收数据、封实体、指派视图等这些都是公有行为。
特有行为：每一个Servlet负责的功能不一致。
请求再过去会找共有行为的Servlet，内部再去调用特有行为的资源，特有行为的资源不一定是Servlet了，是一个普通的POJO就行。
共有行为一般是框架帮忙封装的，一般称之为前端控制器。（前端控制器这种思想是web层的框架基本都有的）
不同的框架充当前端控制器的技术是不一样的。
SpringMVC充当前端控制器的技术就是一个Servlet
Struts2充当前端控制器的技术是Filter
前端控制器内部的代码十分复杂。

SpringMVC简介-SpringMVC的开发步骤

前端控制器是SpringMVC的核心。
1、导入SpringMVC的包
2、配置Servlet（TomCat的请求过去之后，每个请求都让找这个共有行为的Servlet，再去分发特有行为的，配置一个 / ,表示每个请求都要过这个共有行为的前端控制器）
3、编写POJO、在SpringMVC中习惯把这个POJO简单的称之为Controller。
POJO可以通过Bean标签配置到Spring容器当中，也可以使用注解
SpringMVC主张使用注解的方式
4、将Controller使用注解配置到Spring容器当中，使用@Controller注解
5、配置组件扫描，可以配置到Spring的配置文件当中，但是SpringMVC有一个自己的配置文件
配置Spring-mvc.xml文件（配置组件扫描）
6、执行访问的测试。image.png
image.png

SpringMVC简介-SpringMVC快速入门代码实现

1、导入相关坐标，导完之后，内部就有了前端控制器了。

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

2、在web.xml文件中配置SpringMVC的前端控制器

<!--  配置SpringMVC的前端控制器-->
<servlet>
  <servlet-name>DispatcherServlet</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <!--    代表服务器启动时就加载这个Servlet创建对象-->
  <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
  <servlet-name>DispatcherServlet</servlet-name>
  <!-- / 代表缺省的servlet，每次在访问时，任何请求都要走这个servlet-->
  <!--在开发中有的是 *.xxx类型的，意味着这个请求的资源的扩展名是xxx的时才会走这个servlet-->
  <url-pattern>/</url-pattern>
</servlet-mapping>

3、编写视图，在webapp下面创建一个jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
  <html>
    <head>
      <title>Title</title>
    </head>
    <body>
      <h1>Success!</h1>
    </body>
  </html>

4、编写controller层的UserController

package com.lyh.controller;

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

//放到Spring容器当中
@Controller
    public class UserController {
        //在请求的时候，我请求的地址和方法之间有一个映射关系，这个映射关系用注解去替代
        //请求映射
        @RequestMapping("/quick")
        public String save(){
            System.out.println("Controller save running...");
            return "success.jsp";
        }

    }

5、创建SpringMVC的配置文件spring-mvc.xml。可以在applicationContext.xml中进行包扫描，但是要分开的，SpringMVC的配置是要配置到SpringMVC的配置文件中。

<?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 http://www.springframework.org/schema/context/spring-context.xsd">
  <!--这个配置文件中只扫描web层的，也就是controller层的-->
  <!--service层和dao层注解的扫描放到Spring的配置文件applicationContext.xml这个文件中进行组件的扫描-->
  <!--    Controller的组件扫描-->
  <context:component-scan base-package="com.lyh.controller"/>
</beans>

但是现在还有一个问题，spring-mvc.xml的文件没有被加载。SpringMVC的配置文件得告诉是在哪里的。
SpringMVC的配置文件是前端控制器来用，所以得告诉这个控制器，SpringMVC的配置文件是在那里。

所以在web.xml文件中的前端控制器中添加

 <init-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring-mvc.xml</param-value>
  </init-param>

在web.xml文件中新加的内容

<!--  配置SpringMVC的前端控制器-->
<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:spring-mvc.xml</param-value>
  </init-param>
  <!--    代表服务器启动时就加载这个Servlet创建对象-->
  <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
  <servlet-name>DispatcherServlet</servlet-name>
  <!-- / 代表缺省的servlet，每次在访问时，任何请求都要走这个servlet-->
  <!--在开发中有的是 *.xxx类型的，意味着这个请求的资源的扩展名是xxx的时才会走这个servlet-->
  <url-pattern>/</url-pattern>
</servlet-mapping>

6、进行测试
结果：
image.png
image.png

SpringMVC简介-快速入门的流程和小结

代码角度的一个过程
image.png
image.png
Service就是配置的那个前端控制器，前端控制器就是一个Servlet，Servlet内部直接接收请求就是Serviceimage.png

SpringMVC组件解析-SpringMVC执行流程

image.png
很多工作都是前端控制器进行封装，其实不是的，这个前端控制器只是负责调度，进行相应的组件调用。
在SpringMVC内部，很多功能，都有对应的组件帮助我们去完成，就是分工很明确。
DispatcherServlet，得知道根据请求去找那个资源
找资源解析资源的过程不是DispatcherServlet完成的
DispatcherServlet 会去请求 HandlerMapper（处理器映射器） 这个组件
HandlerMapper（处理器映射器）负责对请求进行解析，知道最终要找谁
HandlerMapper返回的并不是某一个资源的地址 而是 一串资源的地址
SpringMVC后期要学习 interceptor拦截器，有可能在执行到 目标Controller之前，要执行很多的Interceptor
所以，在执行的过程中，要执行很多的资源，最终才能到达目标Controller
HandlerMapper 会返回一个 HandlerExecutionChain（返回处理器执行链）
这个 链对象 内部封装着 要执行的 很多资源的顺序
HandlerAdapter（处理器适配器）负责去执行 调度 要被执行的资源
这里的Handler（处理器），可以认为这个是自己写的Controller
ViewResolver（视图解析器），负责从ModelAndView中 把视图对象给解析出来
目前接触最多的就是JSP，是一种视图对象类型
对这个视图要进行，解析渲染，最终把内容返回给客户端。image.png

SpringMVC组件解析-SpringMVC注解解析

image.png

package com.lyh.controller;

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

    //放到Spring容器当中
    @Controller
    @RequestMapping("/user")
    public class UserController {
        //在请求的时候，我请求的地址和方法之间有一个映射关系，这个映射关系用注解去替代
        //请求映射
        //请求地址 http://localhost:8080/spring_demo_01/user/quick
        @RequestMapping("/quick")
        public String save(){
            System.out.println("Controller save running...");
            //当前访问的是quick这个资源，所在的地址是前面的user
            //所以会去找http://localhost:8080/spring_demo_01/user 下面的jsp
            //这里是一个相对地址，相对当前资源所在地址，加上一个 / 就没有问题了
            return "/success.jsp";
        }

    }

错误的效果：
image.png
正常的效果：
image.png
@RequestMapping中的属性
value属性：如果这个属性只写一个并且这个属性的名称是value的话，可以省略掉，多个属性就不能省略掉
@RequestMapping(value = “/quick”)
method属性：可以指定请求方式，method的值是枚举方式的
@RequestMapping(value = “/quick”,method = RequestMethod.POST)
当前访问quick的请求方式必须是post的方式才可以访问到
再次访问会出现错误
image.png
当请求方式是 Get 的方式时
@RequestMapping(value = “/quick”,method = RequestMethod.GET)
效果：
image.png
params属性：限定请求参数条件的。
比如在请求的时候，必须得携带个什么参数，或者不要是什么参数，或者是不要是什么值。
@RequestMapping(value = “/quick”,method = RequestMethod.GET,params = {“username”})
params的值可以是数组，可以组织多个参数的限制条件。
此时表示在请求quick时，必须携带username参数，如果不携带，这个资源是不能让访问到的。
出问题的效果：
image.png
正确的效果：
image.png

SpringMVC组件解析-SpringMVC组件扫描

<!--    Controller的组件扫描-->
<context:component-scan base-package="com.lyh">
  <!-- include-filter-->
  <!-- 将 @Controller 注解的全茂名写到下面 表示只扫描com.lyh包下面的@Controller注解-->
  <!-- exclude-filter -->
  <!-- 扫描com.lyh 这个包下面的不包括 @Controller注解 -->
  <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

<!--    Controller的组件扫描-->
<context:component-scan base-package="com.lyh.controller"/>

SpringMVC组件解析-SpringMVC的XML配置解析（资源解析器）

SpringMVC底层在操作时，有很多的组件：处理器映射器、处理器适配器、视图解析器，这些都可以进行配置。
这些是有默认的，不去配置也是可以完成的。
image.png
这个组件内部配置的都是一些默认的组件。

# Default implementation classes for DispatcherServlet's strategy interfaces.
# Used as fallback when no matching beans are found in the DispatcherServlet context.
# Not meant to be customized by application developers.

org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver

org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver

org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping

org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter

org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver,\
org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver

org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator

org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver

org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager

但是此时可以对内部的功能做指定的增强
image.png
进入上面的资源里面
image.png
image.png
image.png

	@RequestMapping(value = "/quick",method = RequestMethod.GET,params = {"username"})
    public String save(){
        System.out.println("Controller save running...");
        //这里将forward:省略掉了，forward:可以省略
        //地址没有变化，又可以看到对应的视图，是转发的行为。
        return "forward:/success.jsp";
    }

forward（转发）：地址没有变化，又可以看到对应的视图，是转发的行为。
redirect（重定向）：如果地址有变化，又可以看到对应的视图，是重定向的行为。

转发效果：地址没有发生改变
image.png
重定向效果：地址发生了改变
image.png
image.png
有对应的set方法
set前缀、set后缀
对于这些，我们可以在配置文件中复写一下视图解析器，重新配置一下视图解析器，指定前缀和后缀。
image.png设置这样的目录结构

	@RequestMapping(value = "/quick",method = RequestMethod.GET,params = {"username"})
    public String save(){
        System.out.println("Controller save running...");
        return "/jsp/success.jsp";
    }

效果：
image.png
也是可以的。

image.png
image.png

<!--    配置内部资源视图解析器-->
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!-- /jsp/ success .jsp    -->
  <property name="prefix" value="/jsp/"/>
  <property name="suffix" value=".jsp"/>
</bean>

package com.lyh.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

	//放到Spring容器当中
	@Controller
    @RequestMapping("/user")
    public class UserController {
        @RequestMapping(value = "/quick",method = RequestMethod.GET,params = {"username"})
        public String save(){
            System.out.println("Controller save running...");
            return "success"; //这里就可以这样写了
        }

    }

效果：也是可以的
image.png

SpringMVC组件解析

image.png

SpringMVC的数据响应-数据响应方式

image.png

SpringMVC的数据响应-页面跳转-返回字符串形式

image.png
image.png
重定向代表客户端再次访问，而 WEB-INF 属于受保护的文件夹，外界不能直接访问到WEB-INF，要想重定向，资源必须处在一个可以有权限被访问的位置。

SpringMVC的数据响应-页面跳转-返回ModelAndView形式1

	@RequestMapping(value = "/quick2")
    public ModelAndView save2(){
        /*
        Model:模型 作用是封装数据的
        View：视图 作用是展示数据的
		*/
        ModelAndView modelAndView = new ModelAndView();
        //可以单独只给一个视图
        modelAndView.setViewName("success");
        return  modelAndView;
    }

效果：
image.png

	@RequestMapping(value = "/quick2")
    public ModelAndView save2(){
        /*
            Model:模型 作用是封装数据的
            View：视图 作用是展示数据的
         */
        ModelAndView modelAndView = new ModelAndView();
        //设置模型数据，这个数据就相当于放到了域当中了
        modelAndView.addObject("username","李永恒");//这里不止能写字符串 还 可以写其他类型的数据
        //设置视图名称，可以单独只给一个视图
        modelAndView.setViewName("success");
        return  modelAndView;
    }

success.jsp页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
  <html>
    <head>
      <title>Title</title>
    </head>
    <body>
      <%--用EL表达式 取 键值对 的 键的名称--%>
        <h1>Success!${username}</h1>
    </body>
  </html>

效果：
image.png

SpringMVC的数据响应-页面跳转-返回ModelAndView形式2

	@RequestMapping(value = "/quick3")
    public ModelAndView save3(ModelAndView modelAndView){
        modelAndView.addObject("username","LiYongHeng");
        modelAndView.setViewName("success");
        return  modelAndView;
	}

效果：
image.png
SpringMVC对方法的参数，可以帮你进行相应的注入。
SpringMVC在解析这个方法的时候发现参数
有一个ModelAndView需要SpringMVC框架提供，那这个SpringMVC就为你提供一个ModelAndView对象。
所以在内部可以直接使用。

	@RequestMapping(value = "/quick4")
    public String save4(Model model){
        model.addAttribute("username","LYH");
		return "success";
	}

效果：
image.png

SpringMVC的数据响应-页面跳转-返回ModelAndView形式3

用原始的方式，往域当中存数据。

	//这个方法是SpringMVC框架帮忙调用的
    //在调用时，常用的一些对象，能想到的，基本上框架的编写者都想到了
    //如果想用Request对象 加入形参 SpringMVC框架帮忙注入
	//这种方式不常用
    @RequestMapping(value = "/quick5")
    public String save5(HttpServletRequest request){
        //request 是 TomCat服务器帮忙创建的request对象
        //request对象内部是有东西的，Http请求的数据，都在这里封装着，请求行、请求头、请求体等
        request.setAttribute("username","RedmiBook14 锐龙版");
    	return "success";
	}

效果：
image.png

SpringMVC的数据响应-回写数据-直接回写字符串

image.png

	@RequestMapping(value = "/quick6")
    public void save6(HttpServletResponse response) throws IOException {
        response.getWriter().println("Hello RedmiBook");
    }

效果：
image.png
image.png

	@RequestMapping(value = "/quick7")
    //告知SpringMVC框架 该方法 不进行视图跳转 直接进行 数据响应 
    //响应的数据以HTTP响应体的方式回写
    @ResponseBody 
    public String save7(){
        return "Hello~~RedmiBook";
    }

效果：
image.png

SpringMVC的数据响应-回写数据-直接回写json格式字符串

	@RequestMapping(value = "/quick8")
    @ResponseBody
    public String save8(){
        return "{\"username\":\"zhangsan\",\"age\":18}";
    }

效果：
image.png
使用Jackson工具的方式转换JSON
创建User类

package com.lyh.domain;

public class User {
    private String username;
    private int age;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
            "username='" + username + '\'' +
            ", age=" + age +
            '}';
    }
}

pom.xml文件中导入相关依赖

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

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-annotations</artifactId>
  <version>2.9.0</version>
</dependency>

controller层的代码

	@RequestMapping(value = "/quick9")
    @ResponseBody
    public String save9() throws JsonProcessingException {
        //模拟一下对象
        User user = new User();
        user.setAge(18);
        user.setUsername("lisi");
        //需要把 user 对象转换成 JSON 返回
        //使用JSON的转换工具 将 对象转换成JSON格式的字符串 再返回
        ObjectMapper objectMapper = new ObjectMapper();
        String json = objectMapper.writeValueAsString(user);
        return json;
	}

效果：
image.png

SpringMVC的数据响应-回写数据-返回对象或集合

返回对象或集合
image.png
现在用的处理器适配器就是这个处理器适配器
但是现在这个处理器适配器默认情况下，不能帮忙转换
我需要在用到这个处理器适配器的时候，告诉它，我内部需要用到这个JSON转换工具去转换

里面有这样的一个方法
image.png
在配置适配器时，可以让你指定多个消息转换器
可以自己在配置转换器的时候，指定一个JSON转换的转换器。

在 spring-mvc.xml 中进行相关的配置

<!--    在这里配置一下 处理器适配器 并且在内部进行参数设置 告诉其 使用Jackson进行转换-->
<!--    配置处理器映射器-->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
  <property name="messageConverters">
    <list>
      <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
    </list>
  </property>
</bean>

UserController类中的

	@RequestMapping(value = "/quick10")
    @ResponseBody
    //期望SpringMVC自动把User转换成JSON字符串
    public User save10() throws JsonProcessingException {
        User user = new User();
        user.setAge(22);
        user.setUsername("WangWu");
        return user;
    }

效果：
image.png

SpringMVC的数据响应-回写数据-返回对象或集合2

<!--    在这里配置一下 处理器适配器 并且在内部进行参数设置 告诉其 使用Jackson进行转换-->
<!--    配置处理器映射器-->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
  <property name="messageConverters">
    <list>
      <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
    </list>
  </property>
</bean>

以上的配置相对来说是比较麻烦的。image.png
image.png

spring-mvc.xml文件中的修改

<!--    在这里配置一下 处理器适配器 并且在内部进行参数设置 告诉其 使用Jackson进行转换-->
<!--    配置处理器映射器-->
<!--    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">-->
<!--        <property name="messageConverters">-->
<!--            <list>-->
<!--                <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>-->
<!--            </list>-->
<!--        </property>-->
<!--    </bean>-->

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

UserController类中的代码

	@RequestMapping(value = "/quick10")
    @ResponseBody
    //期望SpringMVC自动把User转换成JSON字符串
    public User save10() throws JsonProcessingException {
        User user = new User();
        user.setAge(22);
        user.setUsername("WangWu");
        return user;
	}

效果：
image.png
也是可以的

SpringMVC的数据响应-知识要点小结

image.png

夏天的冬雪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
微服务实战项目-学成在线-认证授权模块（有项目实战实现）
爪蛙毁一生的博客
07-22 3125
截至目前，项目已经完成了课程发布功能，课程发布后用户通过在线学习页面点播视频进行学习。如何去记录学生的学习过程呢？要想掌握学生的学习情况就需要知道用户的身份信息，记录哪个用户在什么时间学习什么课程，如果用户要购买课程也需要知道用户的身份信息。所以，去管理学生的学习过程最基本的要实现用户的身份认证。认证授权模块实现平台所有用户的身份认证与用户授权功能。什么是用户身份认证？用户身份认证即用户去访问系统资源时系统要求验证用户的身份信息，身份合法方可继续访问。常见的用户身份认证的表现形式有：用户名密码登录，微信扫码
JSONException（JSON解析异常）可能的原因和解决方法
最新发布
Java开源程序猿
12-29 6067
时，适当地检查异常的类型，并采取适当的处理措施。详细的错误日志和异常堆栈信息对于定位和解决问题非常有帮助。时，适当地检查异常的类型，并采取适当的处理措施。详细的错误日志和异常堆栈信息对于定位和解决问题非常有帮助。表示在 JSON 解析过程中发生异常。
【限流】4 种常见的限流实现方案
sco5282的博客
07-22 2526
自定义一个限流用的注解，后面在需要限流的方法或接口上面只需添加该注解即可// 限制类型 String limitType();// 每秒 5 个请求 double limitCount() default 5d;// 限制类型 String resourceName();// 每秒 5 个 int limitCount() default 5;
JavaWeb-请求响应
weixin_73675796的博客
07-23 257
浏览器发出请求时，会携带请求数据（Get xxx xxx，Accept：xxx，Accept-Encoding：xxx这类的），Web服务器会对这些请求数据进行解析，然后将解析的结果封装到一个对象中，这个对象就是HttpServletRequest，也叫请求对象。前后端人员只需要根据一份接口文档做出相应的开发即可，但我们每开发完一个工程就要对其进行测试，但由于是前后端分离开发，后端测试的时候是看不到页面的，对于GET方式的还行，直接。简单参数：参数名与形参变量名相同，定义形参即可接收参数。
一键批量JSON标注转PNG图片工具V1.1，支持labelme快捷矩形、圆以及轮廓标注
陶小桃Blog
07-23 470
（1）最主要的功能是支持批量转换。大道至简，软件界面有用的东西就三个按钮（加上开关按钮就是4个按钮）选择JSON文件夹，程序会自动筛选文件夹里的json文件进行读取。
Java EE 框架整合 开发入门到实战-Spring+Spring MVC+MyBatis微课版复习笔记
06-05
Java EE 框架整合 开发入门到实战-Spring+Spring MVC+MyBatis微课版复习笔记
【Spring+Mybatis+SpringMVC笔记】.zip
05-18
自己做的Spring+Mybatis+SpringMVC笔记------------------------------------------------------------------------------------------------------------------------ QQ：1017834057
Spring+SpringMVC+Mybatis整合
09-23
SSM指的是Spring+SpringMVC+MyBatis集成的一个Web应用程序开源框架，个人整合SSM的源码以及笔记，该有的注释都写的很详细了，应该能看懂，之前发布过一个，但是因为是自己写的生成代码生成的mapper，有点错误，在...
Spring+SpringMVC+MyBatis深入学习及搭建(一)之MyBatis的基础知识
08-30
主要介绍了Spring+SpringMVC+MyBatis深入学习及搭建(一)之MyBatis的基础知识,需要的朋友可以参考下
spring+springmvc+mybatis
03-28
自己写的ssm笔记
基于javaweb+mysql的ssm+maven人事crm管理系统(java+ssm+jsp+layui+jquery+mysql)
m0_71095879的博客
07-22 171
3.tomcat环境：Tomcat 7.x,8.x,9.x版本均可 4.硬件环境：windows 7/8/10 1G内存以上；若包含，则为maven项目，否则为非maven项目 6.数据库：MySql 5.7版本；CRM人事管理系统，主要功能有： 用户管理：用户查询、添加用户、编辑、删除；员工管理：员工查询、添加员工、编辑、删除；公告管理：公告查询、添加公告、删除；基于javaweb+mysql的ssm+maven人事crm管理系统(java+ssm+jsp+layui+jquery+mysql)
【微信小程序】从网络请求返回值res.data获取并解析一个Array
资深全栈开发工程师
07-24 2049
获取到请求返回的数据。如果返回的数据是一个数组，您可以直接对其进行操作。如果不是一个数组，我们可以根据实际需求进行错误处理。如果是一个数组，我们可以对其进行操作，比如使用。以下是一个示例代码，演示了如何从。在上述代码中，我们首先判断。在微信小程序中，可以通过。是否为一个数组，使用。
【第二套】Java面试题
m0_46459413的博客
07-27 869
JavaScript中if语句求值其实使用eval函数，eval(function f(){}) 返回 function f(){} 也就是 true。下面我们可以把代码改造下，变成其等效代码。上面的代码输出其实就是 1undefined。为什么那？我们查看下 eval() 说明文档即可获得答案该方法只接受原始字符串作为参数，如果 string 参数不是原始字符串，那么该方法将不作任何改变地返回。恰恰，所以一切都说通了。注意上面代码和以下代码不同。
告别混乱代码：SpringBoot 后端接口规范
zhaoshuangjian
07-24 385
告别混乱代码：SpringBoot 后端接口规范
基于java+mysql的swing+mysql物业收费系统(java+gui)
m0_71414071的博客
07-26 186
基于java+mysql的swing+mysql物业收费系统(java+gui)基于java+mysql的Swing+MySQL物业收费系统(java+gui)用户登陆、用户注册、收费记录、生成业单、用户管理、查询缴费、历史账单、资料设置。eclipse/idea/myeclipse/sts等均可配置运行。课程设计，大作业，毕业设计，项目练习，学习演示等。
SpringBoot学习(二)
weixin_45495161的博客
07-26 299
YAML，用来表达数据序列化的格式。是"YAML Ain’t a Markup Language"（YAML不是一种标记语言）的递归缩写。在开发的这种语言时，YAML的意思其实是：“Yet Another Markup Language”（仍是一种标记语言），但为了强调这种语言以数据做为中心，而不是以标记语言为重点，而用反向缩略语重命名。YAML非常适合用来做以数据为中心的配置文件。favicon.ico放在静态资源目录下即可。
硅谷甄选【项目构建笔记】
weixin_58017233的博客
07-24 1768
,pnpm run format // 将代码进行格式化。
从ES7到ES12，了解JavaScript的新特性与语法演变
linwu的博客
07-24 358
是一个用于判断数组是否包含特定元素的方法。它返回一个布尔值，表示数组中是否存在指定的值。是一个用于进行指数运算的运算符，它允许将一个数值（底数）进行指定次数的乘方运算。是async声明的函数，async函数是构造函数的实例，其中允许使用await关键字。如果你想要添加新的属性，并且在上一行已经使用了尾后逗号，你可以仅仅添加新的一行，而不需要修改上一行。padStart()用另一个字符串填充当前字符串。padEnd()方法会用一个字符串填充当前字符串（如果需要的话则重复填充）。
几张图教你电商入门：如何做数据分析
电商数据Girl的博客
07-27 238
电商API也为电商平台本身带来了诸多好处。首先，API的存在促进了电商平台与其他系统的集成，如物流系统、支付系统、客服系统等。这样，平台可以及时获得与这些系统有关的信息，实现订单状态实时追踪，提高物流配送效率，优化客户服务体验等。电商API和电商数据分析作为相辅相成的一对利器，为电商平台提供了强大的支持。通过API调用和数据分析，电商平台能够提供更丰富、更便捷的购物体验，提高运营效率，优化营销策略，实现可持续的发展。电商API和电商数据分析是相辅相成的，它们一起为电商平台的发展和运营提供了重要支持。
无法删除工程D:\IDEA\新Spring\springMvc\springmvc03-requestMapping\target\tomcat\logs\access_log.2023-08-22: 另一个程序正在使用此文件，进程无法访问。
08-23
- *1* *3* [SSM 框架 (Spring+SpringMVC+MyBatis) --学习笔记](https://blog.csdn.net/qq_22465297/article/details/83793440)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_...

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值