精华内容
下载资源
问答
  • 2021-08-11 21:40:33

    目录

    1.SpringMVC框架概述

    1.1 SpringMVC框架的基本说明

    1.2  SpringMVC 框架的优点

     1.3 SpringMVC实现步骤

    2.第一个注解的SpringMVC程序

    2.1 IDEA中使用maven创建一个web项目

     2.2 在pom.xml中加入相关依赖

    2.3 在web.xml中声明DispatcherServlet对象

    2.4 创建一个发起请求的jsp页面(index.jsp)

    2.5 创建一个普通的类,作为控制器使用,代替之前的servlet

    2.6 创建显示处理结果的jsp页面(webapp\WEB-INF\view\show.jsp)

    2.7 创建springmvc的配置文件

    2.8 配置Tomcat并且启动测试

    2.9 目录结构

     3.使用SpringMVC框架处理web请求的顺序


    1.SpringMVC框架概述

    1.1 SpringMVC框架的基本说明

    SpringMVC是基于Spring的,是Spring中的一个模块,专门用来做web开发使用的。 

    SpringMVC 也叫 Spring web mvc。是 Spring 框架的一部分,是在Spring3.0 后发布的。基于 MVC 架构,功能分工明确、解耦合。

    SpringMVC也是一个容器,使用IoC核心技术,管理界面层中的控制器对象。SpringMVC的底层就是servlet,以servlet为核心,接收请求、处理请求,显示处理结果给用户。在此之前这个功能是由Servlet来实现的,现在使用SpringMVC来代替Servlet行驶控制器的角色和功能。

    其核心Servlet是:DispatcherServlet

    1.2  SpringMVC 框架的优点

    优点:

     1. 基于 MVC 架构,功能分工明确。解耦合。

    2.容易理解,上手快;使用简单。就可以开发一个注解的 SpringMVC 项目,SpringMVC 也是轻量级的,jar 很小。不依赖的特定的接口和类。

    3.作为 Spring 框架一部分,能够使用 Spring 的 IoC 和 Aop。方便整合Strtus,MyBatis,Hiberate, JPA 等其他框架。

    4.SpringMVC 强化注解的使用,在控制器,Service,Dao 都可以使用注解。方便灵活。使用@Controller 创建处理器对象,@Service 创建业务对象,@Autowired 或者@Resource 在控制器类中注入 Service, Service 类中注入Dao。

     1.3 SpringMVC实现步骤

    servlet 的实现方式: jsp发起-----servlet-----jsp显示结果
    步骤:1)创建web应用
         2)加入web依赖   Spring-webmvc(springmvc框架依赖) ,servlet依赖
         3)声明springmvc核心对象DispatcherServlet   
            1.DispatcherServlet是一个servlet对象    
            2.DispatcherServlet叫做前端控制器(front controller) 
            3.DispatcherServlet作用:在servlet的init()方法中,创建springmvc中的容器对象    作为servlet,接收请求
         4)创建一个jsp,发起请求
         5)创建一个普通类,作为控制器使用(代替之前的servlet)  
            1.在注解上面加入@Controller注解  
            2.在类中定义方法,方法上面加入@RequestMapping注解方式处理请求,相当于servlet得doGet,doPost
        6)创建作为结果得jsp页面
        7)创建springmvc得配置文件(spring的配置文件一样)  
            1.声明组件扫描器,指定@Controller注解所在的包名  
            2.声明视图解析器对象
    

    2.第一个注解的SpringMVC程序

    2.1 IDEA中使用maven创建一个web项目

     

     2.2 在pom.xml中加入相关依赖

    <!-- springmvc依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.5.RELEASE</version>
    </dependency>
    <!-- servlet依赖 -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.1.0</version>
    </dependency>
    <!-- jsp依赖 -->
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>javax.servlet.jsp-api</artifactId>
        <version>2.3.1</version>
    </dependency>
    

    2.3 在web.xml中声明DispatcherServlet对象

    <?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的核心对象
            访问mymvc地址后,报错,文件没有找到。找到文件是/WEB-INF/springmvc-servlet.xml或者myweb-servlet.xml(这个)
            错误原因:在Servlet的init()方法中,创建springmvc使用的容器对象WebApplicationContext
            WebApplicationContext ctx=new ClassPathXmlApplicationContext(配置文件)
            配置文件的默认路径:/WEB-INF/<servlet-name>-servlet.xml
    
            DispatcherServlet作用:
            1.在init()中创建springmvc的容器对象 WebApplicationContext,创建springmvc配置文件的所有Java对象。
                java对象就是Controller对象
            2.DispatcherServlet 是一个Servlet,能够接受请求。
    -->
        <servlet>
            <servlet-name>springmvc</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--        如果是自定义的文件,需要在这写自定义配置文件的位置    和监听器的是一样的-->
            <init-param>
                <param-name>contextConfigLocation</param-name>
                <param-value>classpath:springmvc.xml</param-value>
            </init-param>
    
    <!--        在服务器启动时候创建对象,和容器的顺序    在启动时装载对象 随意给个值要求大于等于0  数值越小,创建的越早-->
            <load-on-startup>1</load-on-startup>
        </servlet>
        <servlet-mapping>
            <servlet-name>springmvc</servlet-name>
    <!--        url-pattern 作用:把一些请求交给servlet处理   就例如将/mymvc交给springmvc处理
                使用中央调度器(DispatcherServlet)  1.使用扩展名方式,格式/*.xxx  例如:xxx.xml表示以xml结尾的都算
    -->
            <url-pattern>*.do</url-pattern>
        </servlet-mapping>
    </web-app>
    

    2.4 创建一个发起请求的jsp页面(index.jsp)

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

    2.5 创建一个普通的类,作为控制器使用,代替之前的servlet

    package com.liuhaiyang.controller;
    
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.servlet.ModelAndView;
    
    /**  @Controller: 创建控制器(处理器)对象
     *  控制器:叫做后端控制器(back controller),自定义的类处理请求的。
     *  位置:在类的上面,表示创建此类的对象,对象放在springmvc的容器中
     *
     */
    @Controller
    public class MyController {
        /*
            Springmvc框架使用 ,使用控制器类中的方法,处理请求
            方法的特点: 1.方法的形参,表示请求中的参数   2.方法的返回值,表示本次请求的处理请求
         */
    
        /**
         * @RequestMapping :请求映射
         *  属性:value 请求中的uri地址,唯一值,以"/"开头
         *  位置:1.在方法上面(必须) 2.在类定义的上面(可选)
         *  作用:指定的请求,交给指定的方法处理,等同于url-pattern(个人理解 相当于可以做doget相关的操作)
         *  返回值ModelAndView:表示本次请求的处理结果(数据和视图) model:表示数据   view:表示视图
         */
        //可以在一个类中定义多个方法使用多个@RequestMapping注解
        @RequestMapping(value = {"/some.do","/first.do"})  //value是一个数组,可以有多个值,相当于将该方法起一个名字
        public ModelAndView doSome(){  //doGet()
        //使用这个方法处理请求,能够处理请求的方法叫做控制器方法
            //调用service对象,处理请求,返回数据
            ModelAndView mv=new ModelAndView();
            //添加数据
            mv.addObject("msg","在ModelAddView中处理了some.do的请求");
            mv.addObject("fun","执行了dosome的方法");
            //指定视图,setviewName("视图路径")  相当于请求转发request.getRequestDis...("/show.jsp").forward(..)
    //        mv.setViewName("/WEB-INF/view/show.jsp");
            //当配置了视图解析器,使用文件名称作为视图名使用,叫做视图逻辑名称
            //使用了逻辑名称,框架使用配置文件中视图解析器的前缀和后缀,拼接为完整地视图路径 ,例如/WEB-INF/view/ + show + .jsp
            mv.setViewName("show");
    
    
            /*
            当框架调用完dosome方法后,得到返回中modelandview  框架会在后续的处理逻辑值,处理mv对象里的数据和视图
            对数据执行requert,setAttribute(“msg”,“处理了some.do请求”);把数据放到request作用域中
            对视图进行转发操作
             */
            return  mv;
        }
    }
    

    2.6 创建显示处理结果的jsp页面(webapp\WEB-INF\view\show.jsp)

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>Title</title>
    </head>
    <body>
            /show.jsp,显示request作用域中的数据<br>
            <h2>msg数据:<%=request.getAttribute("msg")%></h2>
            <h2>fun数据:${fun}</h2>
    </body>
    </html>
    

    2.7 创建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 https://www.springframework.org/schema/context/spring-context.xsd">
    <!--spring的配置文件  声明组件扫描器-->
        <context:component-scan base-package="com.liuhaiyang.controller"/>
    <!--    声明视图解析器;帮助处理视图  主要帮助我们处理重复的多余的冗余路径等-->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!--        前缀:指定试图文件的路径-->
            <property name="prefix" value="/WEB-INF/view/"/>
    <!--        后缀,试图文件的扩展名-->
            <property name="suffix" value=".jsp"/>  <!--表示所有的jsp文件-->
        </bean>
    </beans>

    2.8 配置Tomcat并且启动测试

     

    2.9 目录结构

     3.使用SpringMVC框架处理web请求的顺序

    SpringMVC 执行流程

     

    更多相关内容
  • springmvc 框架

    2018-09-05 13:39:47
    springmvc 支持动态定义导入 导出模板,数据模型的 也可用做简单的小工具,进行数据的任务流转
  • SpringMvc框架

    2018-12-31 17:10:23
    SpringMvc框架深度解析,整套开发视频源码以及开发文档。
  • 通过Springboot+MyBatis+SpringMVC框架创建项目,框架入门: 1、通过idea创建springboot项目 2、针对业务做表设计和实体类的创建entity-Area 3、配置pom.xml用maven做jar包管理,使用本地仓库 4、配置最底层dao...
  • springmvc框架源码.zip

    2021-12-18 17:35:48
    springmvc框架源码(自己用的)
  • SpringMVC框架实现文件的上传和下载.rar.rar
  • springMvc框架

    2022-05-09 21:24:30
    使用简单的springmvc框架实现与数据库相连的员工管理系统
  • NULL 博文链接:https://zhao103804.iteye.com/blog/2254486
  • SpringMVC框架

    2020-05-22 15:43:45
    SpringMVC作为目前JavaEE企业级应用开发中使用最为广泛的控制器层框架,一直以来受到了各大互联网公司和广大... 每一个案例都经过了精心的打磨和设计,跟着老师的节奏,你将快速全面的掌握 SpringMVC框架的实战应用。
  • springmvc框架demo

    2017-11-07 11:39:50
    一个springmvc框架小demo,框架的包目录结构,包含登录,增删查改,分页,jsp文件放在WEN-INF下等的简单实现,有数据库文件,源代码,结果视频。
  • 本例实现了springmvc框架,通过这个框架技术来访问项目中的一个简单页面,话不多说,直接上项目
  • 文章目录一、SpringMVC支持文件下载二、SpringMVC支持文件上传1.导入文件上传的两个jar包2.index.jsp前端页面3.配置文件上传解析器4.文件上传请求处理三、多文件上传 一、SpringMVC支持文件下载 假设要下载项目中的...
  • springMVC简单框架
  • SpringMVC框架理解

    万次阅读 2021-12-15 12:39:12
    } 4.1.6 SpringMVC的数据响应-回写数据-直接回写字符串(应用) 通过SpringMVC框架注入的response对象,使用response.getWriter().print(“hello world”) 回写数据,此时不需要视图跳转,业务方法返回值为void 将...

    1. Spring与Web环境集成

    1.1 ApplicationContext应用上下文获取方式

    应用上下文对象是通过new ClasspathXmlApplicationContext(spring配置文件) 方式获取的,但是每次从容器中获得Bean时都要编写new ClasspathXmlApplicationContext(spring配置文件) ,这样的弊端是配置文件加载多次,应用上下文对象创建多次。

    在Web项目中,可以使用ServletContextListener监听Web应用的启动,我们可以在Web应用启动时,就加载Spring的配置文件,创建应用上下文对象ApplicationContext,在将其存储到最大的域servletContext域中,这样就可以在任意位置从域中获得应用上下文ApplicationContext对象了。

    1.2 手写案例

     ① 创建监听器

    package com.terence.listener;
    
    import com.terence.service.UserService;
    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 {
    
        public void contextInitialized(ServletContextEvent servletContextEvent) {
            ServletContext servletContext = servletContextEvent.getServletContext();
            //读取web.xml中的全局参数
            String contextConfigLocation = servletContext.getInitParameter("contextConfigLocation");
            ApplicationContext app = new ClassPathXmlApplicationContext(contextConfigLocation);
            //将Spring的应用上下文对象存储到ServletContext域中
            servletContext.setAttribute("app",app);
            System.out.println("spring容器创建完毕....");
        }
    
        public void contextDestroyed(ServletContextEvent servletContextEvent) {
    
        }
    }

     ② 创建获取pplicationContext对象的工具类

    package com.terence.listener;
    
    import org.springframework.context.ApplicationContext;
    
    import javax.servlet.ServletContext;
    
    public class WebApplicationContextUtils {
    
        public static ApplicationContext getWebApplicationContext(ServletContext servletContext){
            return (ApplicationContext) servletContext.getAttribute("app");
        }
    
    }
    

    ③ 创建servlet的测试类

    package com.terence.web;
    
    import com.terence.listener.WebApplicationContextUtils;
    import com.terence.service.UserService;
    import org.springframework.context.ApplicationContext;
    
    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);
            UserService userService = app.getBean(UserService.class);
            userService.save();
        }
    }
    

      ④ 配置webapp/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">
        <!--全局初始化参数-->
        <context-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
        </context-param>
    
        <!--配置监听器-->
        <listener>
            <listener-class>com.terence.listener.ContextLoaderListener</listener-class>
        </listener>
    
        <!--配置测试用的servlet-->
        <servlet>
            <servlet-name>UserServlet</servlet-name>
            <servlet-class>com.terence.web.UserServlet</servlet-class>
        </servlet>
        <servlet-mapping>
            <servlet-name>UserServlet</servlet-name>
            <url-pattern>/userServlet</url-pattern>
        </servlet-mapping>
    </web-app>

    ⑤测试

    浏览器访问

    http://localhost:8080/spring_mvc/userServlet

     控制台成功输出

    1.3 Spring提供获取应用上下文的工具

    上面的手写案例只是为了方便大家理解,Spring提供了一个监听器ContextLoaderListener就是对上述功能的封装,该监听器内部加载Spring配置文件,创建应用上下文对象,并存储到ServletContext域中,提供了一个客户端工具WebApplicationContextUtils供使用者获得应用上下文对象。

    所以我们需要做的只有两件事:

    ①在web.xml中配置ContextLoaderListener监听器(导入spring-web坐标)

    ②使用WebApplicationContextUtils获得应用上下文对象ApplicationContext

    1.3.1 导入Spring集成web的坐标

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

    1.3.2 配置ContextLoaderListener监听器

    <!--全局初始化参数-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    
    <!--Spring的监听器-->
    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>

    1.3.3 使用WebApplicationContextUtils获得应用上下文对象

    ApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(servletContext);
    UserService userService = app.getBean(UserService.class);

    2. SpringMVC的简介

    2.1 SpringMVC概述

    SpringMVC 是一种基于 Java 的实现 MVC 设计模型的请求驱动类型的轻量级 Web 框架,属于SpringFrameWork 的后续产品,已经融合在 Spring Web Flow 中。

    SpringMVC 已经成为目前最主流的MVC框架之一,并且随着Spring3.0 的发布,全面超越 Struts2,成为最优秀的 MVC 框架。它通过一套注解,让一个简单的 Java 类成为处理请求的控制器,而无须实现任何接口。同时它还支持 RESTful 编程风格的请求。

    2.2 SpringMVC快速入门

    需求:客户端发起请求,服务器端接收请求,执行逻辑并进行视图跳转。

    开发步骤实现

    ①导入SpringMVC相关坐标

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.5.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>5.0.5.RELEASE</version>
    </dependency>
    <!--SpringMVC坐标-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.0.5.RELEASE</version>
    </dependency>
    <!--Servlet坐标-->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>3.0.1</version>
        <scope>provided</scope>
    </dependency>
    <!--Jsp坐标-->
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>javax.servlet.jsp-api</artifactId>
        <version>2.2.1</version>
        <scope>provided</scope>
    </dependency>

    ②配置SpringMVC核心控制器DispathcerServlet

    <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>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    ​③创建Controller类和success.jsp 视图页面

    public class UserController {
        public String save(){
            System.out.println("Controller save running....");
            return "success.jsp";
        }
    }
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>Title</title>
    </head>
    <body>
        <h1>Success!</h1>
    </body>
    </html>
    

    ④使用注解配置Controller类中业务方法的映射地址

    @Controller
    public class UserController {
        // 请求地址  http://localhost:8080/user/quick
        @RequestMapping(value="/quick")
        public String save(){
            System.out.println("Controller save running....");
            return "success.jsp";
        }
    }

    ⑤配置SpringMVC核心文件 spring-mvc.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.alibaba.com/schema/stat"
           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 http://www.alibaba.com/schema/stat http://www.alibaba.com/schema/stat.xsd">
        <!--Controller的组件扫描-->
        <context:component-scan base-package="com.terence"></context:component-scan>
    </beans>

    ⑥客户端发起请求测试

    http://localhost:8080/spring_mvc/quick 

    控制台打印

     页面显示

    2.3 SpringMVC流程图示

    2.4 知识要点

    SpringMVC的开发步骤

    ①导入SpringMVC相关坐标

    ②配置SpringMVC核心控制器DispathcerServlet

    ③创建Controller类和视图页面

    ④使用注解配置Controller类中业务方法的映射地址

    ⑤配置SpringMVC核心文件 spring-mvc.xml

    ⑥客户端发起请求测试

    3. SpringMVC的组件解析

    3.1 SpringMVC的执行流程

    ①用户发送请求至前端控制器DispatcherServlet。

    ②DispatcherServlet收到请求调用HandlerMapping处理器映射器。

    ③处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找),生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。

    ④DispatcherServlet调用HandlerAdapter处理器适配器。

    ⑤HandlerAdapter经过适配调用具体的处理器(Controller,也叫后端控制器)。

    ⑥Controller执行完成返回ModelAndView。

    ⑦HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。

    ⑧DispatcherServlet将ModelAndView传给ViewReslover视图解析器。

    ⑨ViewReslover解析后返回具体View。

    ⑩DispatcherServlet根据View进行渲染视图(即将模型数据填充至视图中)。DispatcherServlet响应用户。

    3.2 SpringMVC组件解析

    3.2.1 前端控制器:DispatcherServlet

    用户请求到达前端控制器,它就相当于 MVC 模式中的 C,DispatcherServlet 是整个流程控制的中心,由

    它调用其它组件处理用户的请求,DispatcherServlet 的存在降低了组件之间的耦合性。

    3.2.2 处理器映射器:HandlerMapping

    HandlerMapping 负责根据用户请求找到 Handler 即处理器,SpringMVC 提供了不同的映射器实现不同的

    映射方式,例如:配置文件方式,实现接口方式,注解方式等。

    3.2.3 处理器适配器:HandlerAdapter

    通过 HandlerAdapter 对处理器进行执行,这是适配器模式的应用,通过扩展适配器可以对更多类型的处理

    器进行执行。

    3.2.4 处理器:Handler

    它就是我们开发中要编写的具体业务控制器。由 DispatcherServlet 把用户请求转发到 Handler。由

    Handler 对具体的用户请求进行处理。

    3.2.5 视图解析器:View Resolver

    View Resolver 负责将处理结果生成 View 视图,View Resolver 首先根据逻辑视图名解析成物理视图名,即具体的页面地址,再生成 View 视图对象,最后对 View 进行渲染将处理结果通过页面展示给用户。

    3.2.6 视图:View

    SpringMVC 框架提供了很多的 View 视图类型的支持,包括:jstlView、freemarkerView、pdfView等。最常用的视图就是 jsp。一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户,需要由程序员根据业务需求开发具体的页面

    3.3 SpringMVC注解解析

    3.3.1 @RequestMapping

    作用:用于建立请求 URL 和处理请求方法之间的对应关系

    位置:

    类上,请求URL 的第一级访问目录。此处不写的话,就相当于应用的根目录

    方法上,请求 URL 的第二级访问目录,与类上的使用@ReqquestMapping标注的一级目录一起组成访问虚拟路径

    属性:

    value:用于指定请求的URL。它和path属性的作用是一样的

    method:用于指定请求的方式

    params:用于指定限制请求参数的条件。它支持简单的表达式。要求请求参数的key和value必须和配置的一模一样

    例如:

    params = {"accountName"},表示请求参数必须有accountName

    params = {"moeny!100"},表示请求参数中money不能是100

    3.3.2 组件扫描

    1.mvc命名空间引入

    命名空间:xmlns:context="http://www.springframework.org/schema/context"
            xmlns:mvc="http://www.springframework.org/schema/mvc"
    约束地址:http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd
            http://www.springframework.org/schema/mvc 
            http://www.springframework.org/schema/mvc/spring-mvc.xsd

    SpringMVC基于Spring容器,所以在进行SpringMVC操作时,需要将Controller存储到Spring容器中,如果使用@Controller注解标注的话,就需要使用<context:component-scan base-package=“com.terence.controller"/>进行组件扫描。

    <!--Controller的组件扫描-->
    <context:component-scan base-package="com.terence">
        <!--只扫描com.terence包下的Controller注解-->
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
        <!--不扫描com.terence包下的Controller注解
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>-->
    </context:component-scan>

    3.4 SpringMVC的XML配置解析

    SpringMVC有默认组件配置,默认组件都是DispatcherServlet.properties配置文件中配置的,该配置文件地址org/springframework/web/servlet/DispatcherServlet.properties,该文件中配置了默认的视图解析器,如下:

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

    翻看该解析器源码,可以看到视图解析器的默认设置,如下:

    REDIRECT_URL_PREFIX = "redirect:"  --重定向前缀
    FORWARD_URL_PREFIX = "forward:"    --转发前缀(默认值)
    prefix = "";     --视图名称前缀
    suffix = "";     --视图名称后缀

    我们可以通过属性注入的方式修改视图的的前后缀

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

    4. SpringMVC的请求和响应

    4.1 SpringMVC的数据响应

    4.1.1 SpringMVC的数据响应-数据响应方式(理解)

    ①页面跳转

            直接返回字符串

            通过ModelAndView对象返回

    ②回写数据

            直接返回字符串

            返回对象或集合

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

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

    在Controller中方法返回ModelAndView对象,并且设置视图名称

    @RequestMapping(value="/quick2")
    public ModelAndView save2(){
        /*
            Model:模型 作用封装数据
            View:视图 作用展示数据
         */
        ModelAndView modelAndView = new ModelAndView();
        //设置模型数据
        modelAndView.addObject("username","itcast");
        //设置视图名称
        modelAndView.setViewName("success");
    
        return modelAndView;
    }

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

    n在Controller中方法形参上直接声明ModelAndView,无需在方法中自己创建,在方法中直接使用该对象设置视图,同样可以跳转页面

    @RequestMapping(value="/quick3")
    public ModelAndView save3(ModelAndView modelAndView){
        modelAndView.addObject("username","itheima");
        modelAndView.setViewName("success");
        return modelAndView;
    }
    
    @RequestMapping(value="/quick4")
    public String save4(Model model){
        model.addAttribute("username","博学谷");
        return "success";
    }

    4.1.5 SpringMVC的数据响应-页面跳转-返回ModelAndView3(应用)

    在Controller方法的形参上可以直接使用原生的HttpServeltRequest对象,只需声明即可

    @RequestMapping(value="/quick5")
    public String save5(HttpServletRequest request){
        request.setAttribute("username","酷丁鱼");
        return "success";
    }

    4.1.6 SpringMVC的数据响应-回写数据-直接回写字符串(应用)

    通过SpringMVC框架注入的response对象,使用response.getWriter().print(“hello world”) 回写数据,此时不需要视图跳转,业务方法返回值为void

    将需要回写的字符串直接返回,但此时需要通过@ResponseBody注解告知SpringMVC框架,方法返回的字符串不是跳转是直接在http响应体中返回

    @RequestMapping(value="/quick6")
    public void save6(HttpServletResponse response) throws IOException {
        response.getWriter().print("hello itcast");
    }
    
    @RequestMapping(value="/quick7")
    @ResponseBody  //告知SpringMVC框架 不进行视图跳转 直接进行数据响应
    public String save7() throws IOException {
        return "hello itheima";
    }

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

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

    手动拼接json格式字符串的方式很麻烦,开发中往往要将复杂的java对象转换成json格式的字符串,我们可以使用web阶段学习过的json转换工具jackson进行转换,通过jackson转换json格式字符串,回写字符串

    @RequestMapping(value="/quick9")
    @ResponseBody
    public String save9() throws IOException {
        User user = new User();
        user.setUsername("lisi");
        user.setAge(30);
        //使用json的转换工具将对象转换成json格式字符串在返回
        ObjectMapper objectMapper = new ObjectMapper();
        String json = objectMapper.writeValueAsString(user);
    
        return json;
    }

    4.1.8 SpringMVC的数据响应-回写数据-返回对象或集合(应用)

    通过SpringMVC帮助我们对对象或集合进行json字符串的转换并回写,为处理器适配器配置消息转换参数,指定使用jackson进行对象或集合的转换,因此需要在spring-mvc.xml中进行如下配置:

    <!--配置处理器映射器-->
    <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>
    @RequestMapping(value="/quick10")
    @ResponseBody
    //期望SpringMVC自动将User转换成json格式的字符串
    public User save10() throws IOException {
        User user = new User();
        user.setUsername("lisi2");
        user.setAge(32);
    
        return user;
    }

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

    在方法上添加@ResponseBody就可以返回json格式的字符串,但是这样配置比较麻烦,配置的代码比较多,因此,我们可以使用mvc的注解驱动代替上述配置

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

    在 SpringMVC 的各个组件中,处理器映射器、处理器适配器、视图解析器称为 SpringMVC 的三大组件。

    使用<mvc:annotation-driven />自动加载 RequestMappingHandlerMapping(处理映射器)和

    RequestMappingHandlerAdapter( 处 理 适 配 器 ),可用在Spring-xml.xml配置文件中使用

    <mvc:annotation-driven />替代注解处理器和适配器的配置。

    同时使用<mvc:annotation-driven />

    默认底层就会集成jackson进行对象或集合的json格式字符串的转换

    4.1.10 SpringMVC的数据响应-知识要点小结(理解,记忆)

    1) 页面跳转

    直接返回字符串

    通过ModelAndView对象返回

    2) 回写数据

    直接返回字符串

    HttpServletResponse 对象直接写回数据,HttpServletRequest对象带回数据,Model对象带回数据或者@ResponseBody将字符串数据写回

    返回对象或集合

    @ResponseBody+<mvc:annotation-driven/>

    4.2 SpringMVC的请求

    4.2.1 SpringMVC的请求-获得请求参数-请求参数类型(理解)

    客户端请求参数的格式是:name=value&name=value……

    服务器端要获得请求的参数,有时还需要进行数据的封装,SpringMVC可以接收如下类型的参数

    基本类型参数

    POJO类型参数

    数组类型参数

    集合类型参数

    4.2.2 SpringMVC的请求-获得请求参数-获得基本类型参数(应用)

    Controller中的业务方法的参数名称要与请求参数的name一致,参数值会自动映射匹配。并且能自动做类型转换;

    自动的类型转换是指从String向其他类型的转换

    http://localhost:8080/itheima_springmvc1/quick9?username=zhangsan&age=12

    @RequestMapping(value="/quick11")
    @ResponseBody
    public void save11(String username,int age) throws IOException {
        System.out.println(username);
        System.out.println(age);
    }

    4.2.3 SpringMVC的请求-获得请求参数-获得POJO类型参数(应用)

    Controller中的业务方法的POJO参数的属性名与请求参数的name一致,参数值会自动映射匹配。

    package com.terence.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 +
                    '}';
        }
    }
    
    @RequestMapping(value="/quick12")
    @ResponseBody
    public void save12(User user) throws IOException {
        System.out.println(user);
    }

    4.2.4 SpringMVC的请求-获得请求参数-获得数组类型参数(应用)

    Controller中的业务方法数组名称与请求参数的name一致,参数值会自动映射匹配。

    @RequestMapping(value="/quick13")
    @ResponseBody
    public void save13(String[] strs) throws IOException {
        System.out.println(Arrays.asList(strs));
    }

    4.2.5 SpringMVC的请求-获得请求参数-获得集合类型参数1(应用)

    获得集合参数时,要将集合参数包装到一个POJO中才可以。

    <form action="${pageContext.request.contextPath}/user/quick14" method="post">
        <%--表明是第一个User对象的username age--%>
        <input type="text" name="userList[0].username"><br/>
        <input type="text" name="userList[0].age"><br/>
        <input type="text" name="userList[1].username"><br/>
        <input type="text" name="userList[1].age"><br/>
        <input type="submit" value="提交">
    </form>
    package com.terence.domain;
    
    import java.util.List;
    
    public class VO {
    
        private List<User> userList;
    
        public List<User> getUserList() {
            return userList;
        }
    
        public void setUserList(List<User> userList) {
            this.userList = userList;
        }
    
        @Override
        public String toString() {
            return "VO{" +
                    "userList=" + userList +
                    '}';
        }
    }
    
    @RequestMapping(value="/quick14")
    @ResponseBody
    public void save14(VO vo) throws IOException {
        System.out.println(vo);
    }

    4.2.6 SpringMVC的请求-获得请求参数-获得集合类型参数2(应用)

    当使用ajax提交时,可以指定contentType为json形式,那么在方法参数位置使用@RequestBody可以直接接收集合数据而无需使用POJO进行包装

    <script src="${pageContext.request.contextPath}/js/jquery-3.3.1.js"></script>
    <script>
        var userList = new Array();
        userList.push({username:"zhangsan",age:18});
        userList.push({username:"lisi",age:28});
        
        $.ajax({
            type:"POST",
            url:"${pageContext.request.contextPath}/user/quick15",
            data:JSON.stringify(userList),
            contentType:"application/json;charset=utf-8"
        });
    
    </script>
    @RequestMapping(value="/quick15")
    @ResponseBody
    public void save15(@RequestBody List<User> userList) throws IOException {
        System.out.println(userList);
    }

    4.2.7 SpringMVC的请求-获得请求参数-静态资源访问的开启(应用)

    当有静态资源需要加载时,比如jquery文件,通过谷歌开发者工具抓包发现,没有加载到jquery文件,原因是SpringMVC的前端控制器DispatcherServlet的url-pattern配置的是/,代表对所有的资源都进行过滤操作,我们可以通过以下两种方式指定放行静态资源:

    方式一:在spring-mvc.xml配置文件中指定放行的资源

    <!--开发资源的访问-->
    <mvc:resources mapping="/js/**" location="/js/"/>
    <mvc:resources mapping="/img/**" location="/img/"/>

    方式二:使用<mvc:default-servlet-handler/>标签

    <mvc:default-servlet-handler/>

    4.2.8 SpringMVC的请求-获得请求参数-配置全局乱码过滤器(应用)

    当post请求时,数据会出现乱码,我们可以设置一个过滤器来进行编码的过滤。

    <!--配置全局过滤的filter-->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    4.2.9 SpringMVC的请求-获得请求参数-参数绑定注解@RequestParam(应用)

    当请求的参数名称与Controller的业务方法参数名称不一致时,就需要通过@RequestParam注解显示的绑定

    <form action="${pageContext.request.contextPath}/quick16" method="post">
        <input type="text" name="name"><br>
        <input type="submit" value="提交"><br>
    </form>
    @RequestMapping(value="/quick16")
    @ResponseBody
    public void save16(@RequestParam(value="name",required = false,defaultValue = "itcast") String username) throws IOException {
        System.out.println(username);
    }

    4.2.10 SpringMVC的请求-获得请求参数-Restful风格的参数的获取(应用)

    Restful是一种软件架构风格、设计风格,而不是标准,只是提供了一组设计原则和约束条件。主要用于客户端和服务器交互类的软件,基于这个风格设计的软件可以更简洁,更有层次,更易于实现缓存机制等。

    Restful风格的请求是使用“url+请求方式”表示一次请求目的的,HTTP 协议里面四个表示操作方式的动词如下:

    GET:用于获取资源

    POST:用于新建资源

    PUT:用于更新资源

    DELETE:用于删除资源

    例如:

    /user/1 GET : 得到 id = 1 的 user

    /user/1 DELETE: 删除 id = 1 的 user

    /user/1 PUT: 更新 id = 1 的 user

    /user POST: 新增 user

    上述url地址/user/1中的1就是要获得的请求参数,在SpringMVC中可以使用占位符进行参数绑定。地址/user/1可以写成/user/{id},占位符{id}对应的就是1的值。在业务方法中我们可以使用@PathVariable注解进行占位符的匹配获取工作。

    // localhost:8080/user/quick17/zhangsan
    @RequestMapping(value="/quick17/{name}")
    @ResponseBody
    public void save17(@PathVariable(value="name") String username) throws IOException {
        System.out.println(username);
    }
     
    

    4.2.11 SpringMVC的请求-获得请求参数-自定义类型转换器(应用)

    SpringMVC 默认已经提供了一些常用的类型转换器,例如客户端提交的字符串转换成int型进行参数设置。

    但是不是所有的数据类型都提供了转换器,没有提供的就需要自定义转换器,例如:日期类型的数据就需要自定义转换器。

    package com.terence.converter;
    
    import org.springframework.core.convert.converter.Converter;
    
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class DateConverter implements Converter<String, Date> {
        public Date convert(String dateStr) {
            //将日期字符串转换成日期对象 返回
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            Date date = null;
            try {
                date = format.parse(dateStr);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            return date;
        }
    }
    @RequestMapping(value="/quick18")
    @ResponseBody
    public void save18(Date date) throws IOException {
        System.out.println(date);
    }

    4.2.12 SpringMVC的请求-获得请求参数-获得Servlet相关API(应用)

    SpringMVC支持使用原始ServletAPI对象作为控制器方法的参数进行注入,常用的对象如下:

    HttpServletRequest

    HttpServletResponse

    HttpSession

    @RequestMapping(value="/quick19")
    @ResponseBody
    public void save19(HttpServletRequest request, HttpServletResponse response, HttpSession session) throws IOException {
        System.out.println(request);
        System.out.println(response);
        System.out.println(session);
    }

    4.2.13 SpringMVC的请求-获得请求参数-获得请求头信息(应用)

    使用@RequestHeader可以获得请求头信息,相当于web阶段学习的request.getHeader(name)

    @RequestHeader注解的属性如下:

    value:请求头的名称

    required:是否必须携带此请求头

    @RequestMapping(value="/quick20")
    @ResponseBody
    public void save20(@RequestHeader(value = "User-Agent",required = false) String user_agent) throws IOException {
        System.out.println(user_agent);
    }

    使用@CookieValue可以获得指定Cookie的值

    @CookieValue注解的属性如下:

    value:指定cookie的名称

    required:是否必须携带此cookie

    @RequestMapping(value="/quick21")
    @ResponseBody
    public void save21(@CookieValue(value = "JSESSIONID") String jsessionId) throws IOException {
        System.out.println(jsessionId);
    }

    5.SpringMVC的文件上传

    5.1 SpringMVC的请求-文件上传-客户端表单实现(应用)

    文件上传客户端表单需要满足:

    表单项type=“file”

    表单的提交方式是post

    表单的enctype属性是多部分表单形式,及enctype=“multipart/form-data”

    <form action="${pageContext.request.contextPath}/user/quick22" method="post" enctype="multipart/form-data">
        名称<input type="text" name="username"><br/>
        文件1<input type="file" name="uploadFile"><br/>
        文件2<input type="file" name="uploadFile2"><br/>
        <input type="submit" value="提交">
    </form>

    5.2 SpringMVC的请求-文件上传-文件上传的原理(理解)

    5.3 SpringMVC的请求-文件上传-单文件上传的代码实现1(应用)

    添加依赖

    <dependency>
        <groupId>commons-fileupload</groupId>
        <artifactId>commons-fileupload</artifactId>
        <version>1.3.1</version>
    </dependency>
    <dependency>
        <groupId>commons-io</groupId>
        <artifactId>commons-io</artifactId>
        <version>2.3</version>
    </dependency>

    配置多媒体解析器

    <!--配置文件上传解析器-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="defaultEncoding" value="UTF-8"/>
        <property name="maxUploadSize" value="500000"/>
    </bean>

    后台程序

    @RequestMapping(value="/quick22")
    @ResponseBody
    public void save22(String username, MultipartFile uploadFile) throws IOException {
        System.out.println(username);
        System.out.println(uploadFile);
    }

    5.4 SpringMVC的请求-文件上传-单文件上传的代码实现2(应用)

    完成文件上传

    @RequestMapping(value="/quick22")
    @ResponseBody
    public void save22(String username, MultipartFile uploadFile,MultipartFile uploadFile2) throws IOException {
        System.out.println(username);
        //获得上传文件的名称
        String originalFilename = uploadFile.getOriginalFilename();
        uploadFile.transferTo(new File("C:\\upload\\"+originalFilename));
        String originalFilename2 = uploadFile2.getOriginalFilename();
        uploadFile2.transferTo(new File("C:\\upload\\"+originalFilename2));
    }

    5.5 SpringMVC的请求-文件上传-多文件上传的代码实现(应用)

    多文件上传,只需要将页面修改为多个文件上传项,将方法参数MultipartFile类型修改为MultipartFile[]即可

    <form action="${pageContext.request.contextPath}/user/quick23" method="post" enctype="multipart/form-data">
        名称<input type="text" name="username"><br/>
        文件1<input type="file" name="uploadFile"><br/>
        文件2<input type="file" name="uploadFile"><br/>
        <input type="submit" value="提交">
    </form>
    @RequestMapping(value="/quick23")
    @ResponseBody
    public void save23(String username, MultipartFile[] uploadFile) throws IOException {
        System.out.println(username);
        for (MultipartFile multipartFile : uploadFile) {
            String originalFilename = multipartFile.getOriginalFilename();
            multipartFile.transferTo(new File("C:\\upload\\"+originalFilename));
        }
    }

    5.6 SpringMVC的请求-知识要点(理解,记忆)

    6. SpringMVC的拦截器

    6.1 SpringMVC拦截器-拦截器的作用(理解)

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

    将拦截器按一定的顺序联结成一条链,这条链称为拦截器链(InterceptorChain)。在访问被拦截的方法或字段时,拦截器链中的拦截器就会按其之前定义的顺序被调用。拦截器也是AOP思想的具体实现。

    6.2 SpringMVC拦截器-interceptor和filter区别(理解,记忆)

    关于interceptor和filter的区别,如图所示:

    6.3 SpringMVC拦截器-快速入门(应用)

    自定义拦截器很简单,只有如下三步:

    ①创建拦截器类实现HandlerInterceptor接口

    ②配置拦截器

    ③测试拦截器的拦截效果

    编写拦截器:

    public class MyInterceptor1 implements HandlerInterceptor {
        //在目标方法执行之前 执行
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException {
            System.out.println("preHandle.....");
            String param = request.getParameter("param");
            if("yes".equals(param)){
                return true;
            }else{
                request.getRequestDispatcher("/error.jsp").forward(request,response);
                return false;//返回true代表放行  返回false代表不放行
            }
        }
    
        //在目标方法执行之后 视图对象返回之前执行
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
            modelAndView.addObject("name","itheima");
            System.out.println("postHandle...");
        }
    
        //在流程都执行完毕后 执行
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
            System.out.println("afterCompletion....");
        }
    }
    

    配置:在SpringMVC的配置文件中配置

    <!--配置拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
            <!--对哪些资源执行拦截操作-->
            <mvc:mapping path="/**"/>
            <bean class="com.terence.interceptor.MyInterceptor1"/>
        </mvc:interceptor>
    </mvc:interceptors>

    编写测试程序测试:

    编写Controller,发请求到controller,跳转页面

    @Controller
    public class TargetController {
        @RequestMapping("/target")
        public ModelAndView show(){
            System.out.println("目标资源执行......");
            ModelAndView modelAndView = new ModelAndView();
            modelAndView.addObject("name","itcast");
            modelAndView.setViewName("index");
            return modelAndView;
        }
    }

    jsp页面

    <html>
    <body>
    <h2>Hello World! ${name}</h2>
    </body>
    </html>
    

    浏览器访问controller

    http://localhost:8080/spring_interceptor_war_exploded/target?param=yes

    6.4 SpringMVC拦截器-快速入门详解(应用)

    拦截器在预处理后什么情况下会执行目标资源,什么情况下不执行目标资源,以及在有多个拦截器的情况下拦截器的执行顺序是什么?

    再编写一个拦截器2,

    public class MyInterceptor2 implements HandlerInterceptor {
        //在目标方法执行之前 执行
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException {
            System.out.println("preHandle22222.....");
            return true;
        }
    
        //在目标方法执行之后 视图对象返回之前执行
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
            System.out.println("postHandle2222...");
        }
    
        //在流程都执行完毕后 执行
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
            System.out.println("afterCompletion2222....");
        }
    }

    配置拦截器2

    <!--配置拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
            <!--对哪些资源执行拦截操作-->
            <mvc:mapping path="/**"/>
            <bean class="com.terence.interceptor.MyInterceptor2"/>
        </mvc:interceptor>
        <mvc:interceptor>
            <!--对哪些资源执行拦截操作-->
            <mvc:mapping path="/**"/>
            <bean class="com.terence.interceptor.MyInterceptor1"/>
        </mvc:interceptor>
    </mvc:interceptors>

     测试效果如下

    preHandle22222.....
    preHandle.....
    目标资源执行......
    postHandle...
    postHandle2222...
    afterCompletion....
    afterCompletion2222....
    

    结论:

    当拦截器的preHandle方法返回true则会执行目标资源,如果返回false则不执行目标资源

    多个拦截器情况下,配置在前的先执行,配置在后的后执行

    拦截器中的方法执行顺序是:preHandler-------目标资源----postHandle---- afterCompletion

    6.5 SpringMVC拦截器-知识小结(记忆)

    拦截器中的方法说明如下

    6.6 SpringMVC拦截器-用户登录权限控制分析(理解)

    在day06-Spring练习案例的基础之上:用户没有登录的情况下,不能对后台菜单进行访问操作,点击菜单跳转到登录页面,只有用户登录成功后才能进行后台功能的操作

    需求图:

    6.7 SpringMVC拦截器-用户登录权限控制代码实现1(应用)

    判断用户是否登录 本质:判断session中有没有user,如果没有登陆则先去登陆,如果已经登陆则直接放行访问目标资源

    先编写拦截器如下:

    public class PrivilegeInterceptor implements HandlerInterceptor {
    
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws IOException {
            //逻辑:判断用户是否登录  本质:判断session中有没有user
            HttpSession session = request.getSession();
            User user = (User) session.getAttribute("user");
            if(user==null){
                //没有登录
                response.sendRedirect(request.getContextPath()+"/login.jsp");
                return false;
            }
    
            //放行  访问目标资源
            return true;
        }
    }

    然后配置该拦截器:找到项目案例的spring-mvc.xml,添加如下配置:

    <!--配置权限拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
            <!--配置对哪些资源执行拦截操作-->
            <mvc:mapping path="/**"/>
            <bean class="com.terence.interceptor.PrivilegeInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

    6.8 SpringMVC拦截器-用户登录权限控制代码实现2(应用)

    在登陆页面输入用户名密码,点击登陆,通过用户名密码进行查询,如果登陆成功,则将用户信息实体存入session,然后跳转到首页,如果登陆失败则继续回到登陆页面

    在UserController中编写登陆逻辑

    @RequestMapping("/login")
    public String login(String username,String password,HttpSession session){
        User user = userService.login(username,password);
        if(user!=null){
            //登录成功  将user存储到session
            session.setAttribute("user",user);
            return "redirect:/index.jsp";
        }
        return "redirect:/login.jsp";
    }

    service层代码如下:

    public User login(String username, String password) {
        User user = userDao.findByUsernameAndPassword(username,password);
        return user;
    }

    dao层代码如下:

    public User findByUsernameAndPassword(String username, String password) throws EmptyResultDataAccessException{
        User user = jdbcTemplate.queryForObject("select * from sys_user where username=? and password=?", new BeanPropertyRowMapper<User>(User.class), username, password);
        return user;
    }

    此时仍然登陆不上,因为我们需要将登陆请求url让拦截器放行,添加资源排除的配置

    <!--配置权限拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
            <!--配置对哪些资源执行拦截操作-->
            <mvc:mapping path="/**"/>
    
            <!--配置哪些资源排除拦截操作-->
            <mvc:exclude-mapping path="/css/**"/>
            <mvc:exclude-mapping path="/plugins/**"/>
            <mvc:exclude-mapping path="/img/**"/>
            <mvc:exclude-mapping path="/user/login"/>
            <bean class="com.terence.interceptor.PrivilegeInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

    6.9 SpringMVC拦截器-用户登录权限控制代码实现3(应用)

    JdbcTemplate.queryForObject对象如果查询不到数据会抛异常,导致程序无法达到预期效果,如何来解决该问题?

    在业务层处理来自dao层的异常,如果出现异常service层返回null,而不是将异常抛给controller

    因此改造登陆的业务层代码,添加异常的控制

    public User login(String username, String password) {
        try {
            User user = userDao.findByUsernameAndPassword(username,password);
            return user;
        }catch (EmptyResultDataAccessException e){
            return null;
        }
    }

    7 SpringMVC异常处理机制

    7.1 异常处理的思路

    系统中异常包括两类:预期异常和运行时异常RuntimeException,前者通过捕获异常从而获取异常信息,后者主要通过规范代码开发、测试等手段减少运行时异常的发生。

    系统的Dao、Service、Controller出现都通过throws Exception向上抛出,最后由SpringMVC前端控制器交由异常处理器进行异常处理,如下图:

    7.2 异常处理两种方式

    ① 使用Spring MVC提供的简单异常处理器SimpleMappingExceptionResolver

    ② 实现Spring的异常处理接口HandlerExceptionResolver 自定义自己的异常处理器

    7.3 简单异常处理器SimpleMappingExceptionResolver

    SpringMVC已经定义好了该类型转换器,在使用时可以根据项目情况进行相应异常与视图的映射配置

    <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
        <!--<property name="defaultErrorView" value="error"/>-->
        <property name="exceptionMappings">
            <map>
                <entry key="java.lang.ClassCastException" value="error1"/>
                <entry key="com.terence.exception.MyException" value="error2"/>
            </map>
        </property>
    </bean>

    7.4 自定义异常处理步骤

    ①创建异常处理器类实现HandlerExceptionResolver

    public class MyExceptionResolver implements HandlerExceptionResolver {
        /*
            参数Exception:异常对象
            返回值ModelAndView:跳转到错误视图信息
         */
        public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
            ModelAndView modelAndView = new ModelAndView();
            if(e instanceof MyException){
                modelAndView.addObject("info","自定义异常");
            }else if(e instanceof ClassCastException){
                modelAndView.addObject("info","类转换异常");
            }
            modelAndView.setViewName("error");
            return modelAndView;
        }
    }

    ②配置异常处理器

    <!--自定义异常处理器-->
    <bean class="com.terence.resolver.MyExceptionResolver"/>

    ③编写异常页面

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>Title</title>
    </head>
    <body>
        <h1>通用的错误提示页面</h1>
        <h1>${info}</h1>
    </body>
    </html>
    

    ④测试异常跳转

    public class DemoServiceImpl implements DemoService {
        public void show1() {
            System.out.println("抛出类型转换异常....");
            Object str = "zhangsan";
            Integer num = (Integer)str;
        }
    
        public void show2() {
            System.out.println("抛出除零异常....");
            int i = 1/0;
        }
    
        public void show3() throws FileNotFoundException {
            System.out.println("文件找不到异常....");
            InputStream in = new FileInputStream("C:/xxx/xxx/xxx.txt");
        }
    
        public void show4() {
            System.out.println("空指针异常.....");
            String str = null;
            str.length();
        }
    
        public void show5() throws MyException {
            System.out.println("自定义异常....");
            throw new MyException();
        }
    }
    @Controller
    public class DemoController {
        @Autowired
        private DemoService demoService;
        @RequestMapping(value = "/show")
        public String show() throws FileNotFoundException, MyException {
            System.out.println("show running......");
            //demoService.show1();
            //demoService.show2();
            //demoService.show3();
            //demoService.show4();
            demoService.show5();
            return "index";
        }
    }

     访问controller进行测试,效果如下

    http://localhost:8080/spring_exception_war_exploded/show

    展开全文
  • SpringMVC框架架构介绍

    2013-11-26 11:04:09
    六、springMVC-mvc.xml 配置文件片段讲解 七、spring mvc 如何访问到静态的文件,如jpg,js,css? 八、spring mvc 请求如何映射到具体的Action中的方法? 九、spring mvc 中的拦截器: 十、spring mvc 如何使用拦截...
  • springmvc框架源码搭建

    2019-03-01 15:39:23
    新搭建的springMvc+maven+mybaits框架源码,拿去就可以直接运行了,框架支持多种数据库,有什么问题请联系我
  • springMVC框架

    2018-05-09 16:30:26
    简单的springMVC框架集合传值学习代码,前台和后台通过参数进行数据绑定 前提: 参数名 和 表单name保持一致,前台和后台通过参数进行数据绑定 bean绑定方式
  • 手写的springmvc框架

    2018-10-26 09:55:30
    手写的springmvc框架。有些瑕疵,还需要进一步的完善代码
  • 搭建SpringMVC框架

    2022-02-21 09:47:01
    搭建SpringMVC框架

    搭建SpringMVC框架

    1. 在idea中建立一个Maven项目

    2.创建WEB工程,引入开发的jar包

     2.1 具体的坐标如下

    <!--版本锁定-->
    <properties>
        <spring.version>5.0.2.RELEASE</spring.version>
    </properties>
    
    <dependencies>
    
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
    
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
    
        <!--SpringMVC-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
    
        <!--servlet API-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>
    
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.0</version>
            <scope>provided</scope>
        </dependency>
    
        <!--日志-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
    
    </dependencies>

    3. 添加web模块

     

    3.1 更改下路径

     会看到

     4. 配置DispatcheServlet

    Spring MVC是基于原生的servlet,通过强大的前端控制器DispatcheServlet,对请求和响应进行统一处理。

    Spring MVC的本质就是一个servlet,是对原生的servlet进行了封装。在以前我们浏览器的每一次请求都需要我们写一个对应的servlet,现在我们只需要将浏览器的请求和响应交给DispatcheServlet进行统一的处理。

    在web.xml配置文件中核心控制器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">
    
        <servlet> 
            <!--对文件进行配置-->
            <servlet-name>dispatcherServlet</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    
            <!--加载springMVC.xml-->
            <init-param>
                <param-name>contextConfigLocation</param-name>
                <param-value>classpath:springMVC.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>
        
    
    </web-app>

    5.  配置springMVC.xml

     


    6. 编写index.html页面

    <html>
    <head>
    <meta charset="utf-8">
    <title>入门程序</title>
    </head>
    <body>
    <h3>入门</h3><a href="/SpringMVCDemo/hello.do" >入门程序</a>
    </body>
    </html>

    7. 编写suc.html页面

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>成功</title>
    </head>
    <body>
    <h3>入门成功了2...</h3>
    </body>
    </html>

    8. 编写Controller类和方法

    package com.qcby.Controller;
    
    
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    
    @Controller
    public class HelloController {
    
        /**
         * 处理超链接发送出来的请求
         * @return
         */
        @RequestMapping(path = "/hello.do")
        public String sayHello(){
            System.out.println("入门方法执行了2...");
            return "suc";
        }
    }
    

    9. 编写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"
           xmlns:mvc="http://www.springframework.org/schema/mvc"
           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 http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">
        <!--配置spring创建容器时要扫描的包-->
        <context:component-scan base-package="com.qcby"></context:component-scan>
    
         <!--配置视图解析器-->
        <!-- 定义跳转的文件的前后缀 ,视图模式配置-->
        <!--识别suc为suc.html-->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <!-- 这里的配置我的理解是自动给后面action的方法return的字符串加上前缀和后缀,变成一个 可用的url地址 -->
            <property name="prefix" value="/html/" />
            <property name="suffix" value=".html" />
        </bean>
        <!-- 配置spring开启注解mvc的支持  默认就是开启的 ,要想让其他组件(不包含映射器、适配器、处理器)生效就必须需要配置了-->
        <mvc:annotation-driven></mvc:annotation-driven>
    
    </beans>

    展开全文
  • Maven搭建的SpringMVC+Mybatis框架。Maven搭建的SpringMVC+Mybatis框架
  • SpringMVC框架案例

    2015-03-30 12:52:17
    SpringMVC是java开发主流技术,初学者可以好好看里面的配置,以及更多的相关技术。
  • springmvc框架

    2013-12-01 23:16:57
    springmvc框架
  • springmvc框架的简单应用,供初学者用来学习。里面的基础知识只是最初版本。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 170,555
精华内容 68,222
关键字:

springmvc框架

spring 订阅
友情链接: Demo.rar