SpringMVC

最新推荐文章于 2024-11-11 00:03:55 发布
最新推荐文章于 2024-11-11 00:03:55 发布
阅读量83 收藏
点赞数
分类专栏： 框架 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53855503/article/details/121088339
版权

SpringMVC

  • 介绍
    SpringMVC框架属于Spring框架中的一个核心组件，与Spring框架无缝衔接，SpringMVC是属于视图层框架的，是开发Web应用的核心框架，SpringMVC实际上出现的目的是为了替换掉servlet，也就是说SpringMVC是对servlet的一个深入封装，作用就是用来接收请求，处理响应的框架。它与Strust2不同，Strust2是基于实体Bean映射的，SpringMVC是基于方法映射的，更轻便，快捷，所以Strust2淘汰了。最早是SSH(Strust Spring Hibernate)整合开发，现在是SSM(SpringMVC+Spring+MyBatis)整合开发的。

入门程序：

1.1创建工程导入jar包：

创建Java Enterpise项目，勾选Web Application；将项目部署到Tomcat服务器上，在WEB-INF文件夹下创建lib文件夹，导入jar包：spring-web.jar、spring-webmvc.jar、spring-core.jar、spring-aop.jar、spring-express.jar、spring-context.jar、spring-bean.jar、common-logging.jar

1.2配置web.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!-- 配置前台控制器DispatcherServlet 相当于一个调度中心 -->
    <servlet>
        <servlet-name>SpringMvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <!-- 加载 springMvc自己的配置文件 Ioc ，DI
             init-param的作用就是用来加载配置文件的
        -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>

        <!--
            当tomcat服务器启动时 要加载这个类,如果没有这个配置
            那么只有发送请求时 ，容器才会实例化这个DispatcherServlet
         -->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>SpringMvc</servlet-name>
        <!-- 所有的请求路径都要以.do 结尾
            这样前台控制器才会拦截
            /* : 拦截所有请求 ，只能在过滤器中使用 ，要不然就是404
            /  : 拦截静态资源css ， js ，jpg ，png结尾的文件，自动放行.jsp结尾文件
            *.do : 放行所有请求，一个都不拦截
        -->
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
</web-app>

1.3Spring-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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <!--  1.处理器映射器 : 作用就是根据名字映射url地址   -->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean>

    <!--  2.处理器是适配器 -->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"></bean>

    <!--  3.视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 前缀 -->
        <property name="prefix" value="/"></property>
        <!-- 后缀 -->
        <property name="suffix" value=".jsp"></property>
    </bean>
  
     <!-- 实例化自己的HelloController -->
    <bean name="/hello.do" class="com.oracle.controller.HelloController"></bean>
</beans>

1.4控制器

package com.oracle.controller;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class HelloController implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        /**
         * ModelAndView : model模型数据   View视图  就是jsp
         */
        ModelAndView modelAndView = new ModelAndView();

        String username = request.getParameter("username");
        String password = request.getParameter("password");

        System.out.println(username);
        System.out.println(password);

        //添加数据
        modelAndView.addObject("user",username);

        //设置了视图的名字
        modelAndView.setViewName("main");

        return modelAndView;
    }
}

1.5页面

index.jsp页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
     <a href="/hello.do?username=admin&password=123">跳转第一个Controller</a>
  </body>
</html>

main.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
   欢迎 ${user} 登录
</body>
</html>

SpringMVC的执行流程

  • SpringMVC 的执行流程如下：
    1.用户点击某个请求路径，发起一个HTTP协议的请求，该请求会被提交到DispatcherServlet(前台控制器)中
    2.前台控制器接收到请求后，去找一个或多个HandlerMapping(处理映射器)，并返回一个执行链(HandlerExcecutionChain)
    3.DispatcherServlet将执行链中的Handler(Controller)的信息发送给HandelerAdapter处理器适配器；
    4.HandlerAdapter处理器适配器根据Handler的信息找到真正的Controller；
    5.Controller执行方法返回ModelAndView对象给HandlerAdapter，这个对象是SpringMVC底层对象，包括Mode数据和View视图名(逻辑视图)
    6.HandlerAdpater接收到ModelAndView对象，在返回给DispathcherServlet
    7.DispatcherServlet接收到ModelAndView对象，在发送给视图解析器(InternalResourceViewResolver)
    8.InternalResourceViewResolver视图解析器，解析逻辑视图View，在返回前台控制器DispatcherServlet
    9.DispatcherServlet拿着View，进行渲染，讲逻辑视图View，变成真正的物理视图，main.jsp，这个main.jsp就是字符串拼接出来的，前缀prefix和后缀suffix
    10.视图将View变成真正的页面并返回给客户端
    在这里插入图片描述

3基于注解开发SpringMVC

3.1web.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">
    <!-- 1.配置前台控制器 -->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <!-- 扫描 springmvc.xml 配置文件 位置-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-mvc.xml</param-value>
        </init-param>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>

</web-app>

3.2springMVC.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:aop="http://www.springframework.org/schema/aop"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/mvc
        https://www.springframework.org/schema/mvc/spring-mvc.xsd">

     <!-- 1.注解开发 -->
    <context:component-scan base-package="com.oracle.controller"/>

    <!-- 2. 开启mvc 注解驱动
             这个注解驱动替代了 处理器映射器， 处理器适配器
    -->
    <mvc:annotation-driven/>

    <!--3.配置视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/"></property>
            <property name="suffix" value=".jsp"></property>
    </bean>
</beans>

3.3Controller的编写

package com.oracle.controller;

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

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

@Controller // 相当于<bean name="/user.do" class="com.oracle.controller.UserContoller">
public class UserController {

    /**
     * 方法一定要有返回值，默认应该是String类型
     * 为什么是String类型 ，因为必须返回逻辑视图名
     * @return  视图名
     */
    @RequestMapping("/hello.do")
    public String login(HttpSession session){

        session.setAttribute("username","李四");

        System.out.println("我是注解开发的springMvc");

        return "main";
    }
}

3.4jsp页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
    <a href="/hello.do">登录</a>
  </body>
</html>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    欢迎${username}登录
</body>
</html>

4.SpringMVC的注解

4.1@Controller注解(用于类上)

这个注解本身不是SpringMVC的注解，是Spring框架的注解，是component的衍生注解用于IOC操作

4.2@RequestMapping注解(用于方法和类上)

接收请求的，但是要记住的是一个Controller中会有一个或多个请求的方法，那么就会有多个@RequestMapping注解，例如UserController中可以有添加用户，修改用户，删除用户，查询用户，每一个方法都是负责不同的操作；

  • 注解的属性
    1.value：是这个注解的默认属性，代表了当前请求的路径，如果一个属性的话就可以省略掉
    2.name：属性就是相当于注释的意思，解释说明@RequestMapping(value="/hello.do",name=“这是一个方法”
    3.method：这个属性代表了当前这个方法能接收什么样的请求，默认普通方法的请求方式就只有：GET，POST，(不区分什么操作的)。RESTful风格的请求方式：GET(查询)、 POST(添加) 、PUT(修改)、 DELETE(删除)

4.3@RequestParam注解(用于修饰方法入参)

在页面标签中的name属性的名字和方法入参的名字不一直时候，使用这个注解接收页面传递的参数值

@RequestMapping(value = "/hello.do")
public String login(@RequestParam("username") String a,
                    @RequestParam("password") String b){
  System.out.println("我是SpringMvc的自动映射");
  System.out.println(a);
  System.out.println(b);
  return "main";
}

4.4@Path Variable注解(用于修饰方法入参)

前提：如果你的url配置路径是*.do那么这个住就是失效了，所以只能是/，作用是用来接收URL地址栏中的参数请求；

<a href="/delete/admin/23/哈尔滨">删除用户</a>

@RequestMapping("/delete/{name}/{id}/{address}")
public String deleteUserById(@PathVariable String name,
                             @PathVariable Integer id,
                             @PathVariable String address){

      System.out.println("要删除的id为： " + id);
      System.out.println("要删除的name为： " + name);
      System.out.println("要删除的address为： " + address);
      return "main";
}

4.5@ModelArribute注解用于方法入参

作用是用来接收请求参数的，可以自动将接受的参数封装到实体对象中，并直接存储到Model的域对象中，不需要程序员手动的addAttribute方法添加，如果没有这个注解，就自动映射实体后，调用model.addAttribute(“user”,user);方法手动添加，相比而言更加自动化，方便

/**
  * 注册操作
  * @return 返回主页
  */
@RequestMapping("/register")
public String register(@ModelAttribute("user") User user){
   System.out.println(user);
   //这里接收到用户信息后 老师没 添加到 域对象中 ，但是页面会自动取出
   return "main";
}


<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    ${user} 
</body>
</html>
  • 拓展：一定要知道SpringMVC控制器的方法的入参类型有多少种？
    1.可以添加实体类Bean的映射；前提是页面的name属性名一定要和java实体Bean的属性名一致
    2.可以使用方法的形参形式接收请求参数
    3.可以使用原始的HttpServletRequest对象的getparameter；方法获取参数
    4.可以使用@RequestParam接收参数
    5.可以使用@PathVarible接收URL中的请求参数，属于RESTful风格的请求方式
    6.可以使用@ModelAttribute(“user”)注解接收参数，并自动存储域对象

5.SpringMVC的转发和重定向

  • forward 和 redirect :
    springMvc请求中，请求方式有两种： 分别是forward和redirect ，用在Controller方法的返回值处;
    转发属于服务器行为（发生在服务器内部) ，转发地址栏不会改变
    重定向数据客户端行为 (发生在服务器外部) ， 重定向地址栏会改变
    转发: 可以携带参数
return "forward:/getAll?pageNo=1&like=李";

重定向: 可以携带参数

return "redirect:/getAll?pageNo=1&like=张";

6.SpringMVC注解@ModelAttribute

1.第一个功能就是作为方法的入参，会自动绑定数据到实体中，并将数据放到域对象中

@RequestMapping("/register")
public String register(@ModelAttribute("user") User user){
  System.out.println(user);
  //这里接收到用户信息后 老师添加到 域对象中
  return "forward:/getAll?pageNo=1&like=李";
}

2.可以放在一个无返回值的方法上，会优先执行，放在执行目标之前。

@ModelAttribute
public void myModel(@RequestParam String name,Model model){
    //手动的存储到域对象中
    model.addAttribute("name",name);
    System.out.println("我是myModel方法");
}
/**
     * 方法一定要有返回值，默认应该是String类型
     * 为什么是String类型 ，因为必须返回逻辑视图名
     * @return  视图名
     */
@RequestMapping(value = "/hello")
public String login(Model model){
    System.out.println("我是hello请求");
    Object name = model.getAttribute("name");
    System.out.println("我是从model中获取的名字:"+name);
    return "main";
}

3.修饰有返回值的方法，会自动的将返回值存储到域对象中，其他方法可以通过getattribute获取

@Controller
public class PersonController {
    /**
     * 优先执行     ，会自动将数据存储到域对象中，返回就是域对象的值
     * @param name   域对象的 key
     * @return   域对象的值
     */
    @ModelAttribute("name")
    public String myModel(@RequestParam String name){
        System.out.println("myModel方法");
        return name;
    }
    @RequestMapping("/person")
    public String model(){
        System.out.println("model方法");
        return "main";
    }
}

7.SpringMVC与JSON数据交互

1.配置字符集过滤器：
springMVC提供的一个固定字符集过滤器：在web.xml中配置

 <!-- 配置字符集过滤器 -->
<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>

2.Controller中的字符集处理方式：produce=“text/html;charset=UTF-8”

/**
     * 这个注解中有 value， name ， method
     * response.setContentType("text/html;charset=UTF-8");
     * @return
     */
    @RequestMapping(value = "/person",produces = "text/html;charset=UTF-8" )
    public String model(){
        System.out.println("model方法");
        return "main";
    }

3.SpringMvc配置静态资源放行:

<script type="text/javascript" src="js/jquery-1.9.1.min.js"></script>
<script type="text/javascript">
    //页面加载函数
    $(function(){

        $("button").click(function(){
            alert("-====");
        })
    })
</script>

4.静态资源放行有三种，这是其中两种

<!-- 静态资源放行js, css, img ，记得清缓存-->
<mvc:default-servlet-handler/>

<!-- location属性代表本地文件夹下的资源
     mapping 是映射，/** 代表可见    -->
<mvc:resources mapping="/**" location="/js/"></mvc:resources>
<mvc:resources mapping="/**" location="/css/"></mvc:resources>
<mvc:resources mapping="/**" location="/img/"></mvc:resources>

5.通过@ResponseBoby响应json格式的数据：这个注解相应的数据，会自动变成json格式。@RequestBody接收的数据：必须是josn格式的字符串
6.导入jackson的jar包：jackson是SpringMVC处理json格式数据的第三方插件，他还支持Gson，阿里巴巴的fastJson，但是需要配置麻烦，但是json内部继承，不需要配置，一个<mvc:anntaton-driven>就已经解决了
7.编写Controller：使用@RequestBody接收json格式的字符串，@ResponseBody响应一个对象，他就回变成json格式

@ResponseBody  //这个注解响应的数据，会自动变成json格式
@RequestMapping(value = "/login",produces = "application/json;charset=UTF-8")
public User getJsonAndResponseJson(@RequestBody User user){

  System.out.println(user);

  System.out.println("我是用来接收json格式，和 响应json格式的方法");

  return user;
}

@RequestMapping(value = "/login",produces = "application/json;charset=UTF-8")
public @ResponseBody User getJsonAndResponseJson(@RequestBody User user){

  System.out.println(user);

  System.out.println("我是用来接收json格式，和 响应json格式的方法");

  return user;
}

8.编写Ajax代码：

<script type="text/javascript" src="js/jquery-1.9.1.min.js"></script>
<script type="text/javascript">
    //页面加载函数
    $(function(){
        $("button").click(function(){
            var a = $("input[name='username']").val();
            var b = $("input[name='password']").val();
            //手动拼接成json格式
            var person = { username: a, password : b};
            alert(person);
            //万能的 异步请求的方式
            $.ajax({
                url: "/login",// 请求路径
                type: "post", //请求方式
                data: JSON.stringify(person), //发送的是json格式的字符串
                contentType: "application/json;charset=UTF-8", //发送json格式
                dataType: "json", //返回值的格式 json
                success: function(data){
                    alert(data.username);
                    alert(data.password);
                }
            })
        })
    })
</script>
  • 注意：在SpringMVC使用jackson处理json格式的时候一定是高版本的，要不然jar包版本不兼容

8.SpringMVC使用RESTful风格请求方式

  • RESTful(Representatonal State Transfer)，意思：使用URL路径形式传递参数，他的结构清晰，易于理解，但是这个概念比较复杂，SpringMVC支持，为SPringleBoot打基础。
  • 传统的URL：http://localhost:8080/login?username=admin&password=123
    RESTful风格：http://localhost:8080/login/admin/123，@PathVariable注解接收数据
  • SpringMVC的REST风格可以理解为：使用URL表示资源时，每个操作都要用独一无二的URL来表示；传统的请求方式有两种：GET、POST。REST风格的请求方式有四种：GET、 POST、 PUT、 DELETE。两种要结合才能达到最好的效果。本身HTTP请求默认是不支持PUT和DELETE的。
    1.只能将DELETE和PUT请求转化成POST请求，
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>测试RESTful风格的请求方式</title>
</head>
<body>
    <h4>发送GET请求</h4>
    <a href="user/1">GET</a>

    <h4>发送POST请求</h4>
    <form action="user" method="post">
        用户名:  <input type="text" name="username">
        密码: <input type="password" name="password">
        <input type="submit" value="POST请求">
    </form>

    <h4>发送PUT请求</h4>
    <form action="user" method="post">
                <input type="hidden" name="_method" value="PUT">
        用户名:  <input type="text" name="username">
        密码: <input type="password" name="password">
        <input type="submit" value="PUT请求">
    </form>

    <h4>发送DELETE请求</h4>
    <form action="user" method="post">
        <input type="hidden" name="_method" value="DELETE">
        用户名:  <input type="text" name="username">
        密码: <input type="password" name="password">
        <input type="submit" value="DELETE">
    </form>
</body>
</html>

2.在web.xml中配置一个过滤器

<!-- 设置 RESTful风格的请求方式-->
<filter>
  <filter-name>hiddenHttpMethodFilter</filter-name>
  <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
</filter>

<filter-mapping>
  <filter-name>hiddenHttpMethodFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

3.Controller:处理器

package com.oracle.controller;

import com.oracle.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
public class RESTController {
  
    //现在用的是RESTful风格的请求方式，那么就必须指定请求方式
    @RequestMapping(value = "/user/{id}",method = RequestMethod.GET)
    public String get(@PathVariable Integer id){
        System.out.println("get请求的id: " + id+" 我是查询操作");
        return "main";
    }

    @RequestMapping(value = "/user",method = RequestMethod.POST)
    public String post(){
        System.out.println("我是post请求，是添加操作");
        return "main";
    }

    @RequestMapping(value = "/user",method = RequestMethod.PUT)
    public String put(User user){
        System.out.println(user);
        System.out.println("我是put请求，是修改操作");
        return "main";
    }

    @RequestMapping(value="/user",method = RequestMethod.DELETE)
    public String delete(User user){
        System.out.println(user);
        System.out.println("我是delete请求，是删除操作");
        return "main";
    }
}

结果：

我是delete请求，是删除操作
我是put请求，是修改操作
我是post请求，是添加操作
我是get请求，id:1 是查询操作
  • 总结
    1.form表单的method属性的值必须是POST请求
    2.web.xml必须添加过滤器的HiddenHttpMethodFilter
    3.Controller中的方法必须指定请求类型。例如：@RequestMapping(value="/login",method = RequestMethod.POST)
    4.如果Controller返回的页面出现了405那么就在这个页面的头部添加isErrorPage=“true”

9.SpringMVC拦截器

  • SpringMVC拦截器提供了一个Intercepter拦截器的技术点，与servlet阶段中的Filter过滤器相似，但是不是同一个东西，所处位置也不同
  • 作用：一般用于登录时检查用户权限，或者请求信息的时候记录到日志中，还有登录拦截。例如：不登陆不可以访问主页，体现的就是预处理和后处理.
    1.拦截器
package com.oracle.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class TestInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("在执行控制器的方法之前执行，返回true就是放行,返回false是拦截");

        return true;    //返回false是拦截， 返回true放行
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("在执行视图解析器之前执行，获取域对象中的数据，预备工作");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("在视图解析器执行完毕后 执行，一般用于资源关闭，记录日志");
    }
}

2.拦截器的配置：

 <!-- 拦截器 -->
<mvc:interceptors>

  <!-- 全局的拦截器，拦截所有请求-->
  <bean class="com.oracle.interceptor.TestInterceptor"></bean>

</mvc:interceptors>

9.1拦截案例

  • 条件：不登陆不可以直接访问主页，必须登录后，才可以随便访问主页
    1.Controller
package com.oracle.controller;

import com.oracle.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

@Controller
public class UserController {

    @RequestMapping("/toLogin")
    public String toLogin(){
        return "forward:/index.jsp";
    }
    @RequestMapping("/login")
    public String login(User user, HttpSession session, Model model){
        String username = user.getUsername();
        String password = user.getPassword();
        if("admin".equals(username) && "123".equals(password)){
            //存储session
            session.setAttribute("user",user);
            return "forward:/main";
        }
        //登录失败,存储提示信息
        model.addAttribute("msg","用户名或密码错误，请重新登录");

        return "forward:/toLogin";
    }
    @RequestMapping("/main")
    public String toMain(){
        return "main";
    }
    @RequestMapping("/logOut")
    public String logOut(HttpSession session){

        //主动退出，session就不存储在了 ,清除session
        session.invalidate();

        return "forward:/index.jsp";
    }
}

2.拦截器Intercepter：

package com.oracle.interceptor;

import com.oracle.pojo.User;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class LoginInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //先做指定路径放行
        String path = request.getRequestURI();
        if(path.endsWith("/toLogin") || path.endsWith("/login")){
            //放行
            return true;
        }
        //如果直接访问main的化 就的验证了
        HttpSession session = request.getSession();
        User user = (User)session.getAttribute("user");
        if(user != null){
            //放行  刚刚登录完，没退出
            return true;
        }
        //没登录呢，必须登录，才能访问主页
        request.setAttribute("msg","还没登录，请先登录");
        request.getRequestDispatcher("index.jsp").forward(request,response);
        return false;
    }
}

3.配置Spring-mvc.xml配置文件：添加拦截器

 <!-- 拦截器 -->
<mvc:interceptors>

  <!-- 全局的拦截器，拦截所有请求-->
  <bean class="com.oracle.interceptor.TestInterceptor"></bean>

  <!-- 登录验证拦截器 -->
  <mvc:interceptor>
    <!-- 需要拦截的请求  /** 拦截所有  -->
    <mvc:mapping path="/**"/>
    <!-- 除去 哪些路径 -->               
	<mvc:exclude-mapping path="/login"/>
    <!-- 指定拦截器 -->
    <bean class="com.oracle.interceptor.LoginInterceptor"></bean>
  </mvc:interceptor>
  <mvc:interceptor>
  		....
  </mvc:interceptor>
</mvc:interceptors>

登录页面：index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
   <%-- <a href="/login">测试拦截器</a>--%>

    <form action="/login" method="post">
        用户:<input type="text" name="username">
        密码:<input type="password" name="password">
        <input type="submit" value="登录">
    </form>
    <div style="color: red">${msg}</div>
  </body>
</html>

主页面: main.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
	欢迎${user.username}登录本小店 <a href="/logOut">退出</a>
</body>
</html>

10.SpringMVC图片上传

  • SpringMVC框架的文件是基于commons-fileupload组件完成的，只不过是简化了过程，为了实现这一个功能SpringMVC提供了一个接口MultipartResolver
    1.导入图片上传的jar包：
    commons-fileupload.jar，commons-io.jar
    2.配置Spring-mvc.xml文件
 <!-- 图片上传   使用二进制的形式进行图片上传  其中这个id属性必须加，不加就是NullPointException -->
<bean id="multipartResolver"        			   class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
  <!-- 设置图片上传的大小 单位是字节-->
  <property name="maxUploadSize" value="5000000"></property>
  <!--设置字符集-->
  <property name="defaultEncoding" value="UTF-8"></property>
</bean>

3.JSP 页面提交:

<!-- 要支持 多媒体上传  不加 就不能完成图片上传 -->
<form action="/uploadFile" method="post" enctype="multipart/form-data">
  文件: <input type="file" name="myFile">
  <input type="submit" value="上传">
</form>

4.UploadController

package com.oracle.controller;

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

import java.io.File;
import java.io.IOException;

@Controller
public class UploadController {
    /**
     * 后台必须有一个指定类型接收它
     * 入参myFile  必须和 input标签的name属性名一致
     */
    @RequestMapping("/uploadFile")
    public String uploadFile(MultipartFile myFile) throws IOException {
        //System.out.println(originalFilename);

        /*byte[] bytes = myFile.getBytes();
        System.out.println("内容: "+bytes);

        long size = myFile.getSize();
        System.out.println("文件大小： " + size);*/

        String originalFilename = myFile.getOriginalFilename();

        String path = "C:\\Users\\GaoYuanze\\IdeaProjects\\SpringMvc_Interceptor\\web\\img\\";

        //路径，文件名
        File file = new File(path,originalFilename);

        //如果不存在 ，记住有叹号
        if(!file.exists()){
            file.mkdirs();
        }
        //上传
        myFile.transferTo(file);
        return "success";
    }
}

11.日期处理

1.使用注解@DataTimeFormat(pattrt = “yyyy-MM-dd”)注解，在指定的实体中的Date类型上使用

public class User {

    private String username;
    private String password;

    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date birthDay;
  
    //省略getter， setter方法
}

2.使用@InitBinder 注解处理日期格式： 数据绑定 ,它只针对当前的@Controller有用

package com.oracle.controller;

@Controller
public class UserController {
    /**
     * 优先执行与 目标方法
     *
     * 使用数据绑定技术，完成日期格式化的处理
     */
    @InitBinder
    public void initBinder(WebDataBinder binder){

        //可以处理掉 字符串两边的空格
        binder.registerCustomEditor(String.class,
                new StringTrimmerEditor(true));

        //参数1，传入的是Date的反射对象，
        //参数2.创建一个编辑器，将SimpleDateFormat格式作用于参数中的birthDay
        //参数3，不允许为null
        binder.registerCustomEditor(Date.class,
                new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"),
                        false));
    }
  
  	/**
  	  * 注册操作
  	  */
    @RequestMapping("/register")
    public String register(User user){
        System.out.println(user);
        return "main";
    }
  
}

输出结果：

User{username='admin', password='123', birthDay=Mon Nov 01 00:00:00 CST 2021}

3.全局数据绑定： @ControllerAdvice

/**
 * Global全局Controller
 */
@ControllerAdvice
public class GlobalContrller {

    /**
     * 优先执行与 目标方法
     *
     * 使用数据绑定技术，完成日期格式化的处理
     */
    @InitBinder
    public void initBinder(WebDataBinder binder){

        //可以处理掉 字符串两边的空格
        binder.registerCustomEditor(String.class,
                new StringTrimmerEditor(true));

        //参数1，传入的是Date的反射对象，
        //参数2.创建一个编辑器，将SimpleDateFormat格式作用于参数中的birthDay
        //参数3，不允许为null
        binder.registerCustomEditor(Date.class,
                new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"),
                        false));
    }

}

/**
 * Global全局Controller
 */
@ControllerAdvice
public class GlobalContrller {

    /**
     * 优先执行与 目标方法
     *
     * 使用数据绑定技术，完成日期格式化的处理
     */
    @InitBinder
    public void initBinder(WebDataBinder binder){

        //可以处理掉 字符串两边的空格
        binder.registerCustomEditor(String.class,
                new StringTrimmerEditor(true));

        //参数1，传入的是Date的反射对象，
        //参数2.创建一个编辑器，将SimpleDateFormat格式作用于参数中的birthDay
        //参数3，不允许为null
        binder.registerCustomEditor(Date.class,
                new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"),
                        false));
    }

}

总结：必须熟练定义方法的入参 并使用，熟练使用SpringMVC提供的注解，熟练使用Ajax与SpringMvc交互;

SpringMVC篇
qq_46423017的博客
10-28 1406
1、SpringMVC的工作流程（重点） 2、SpringMVC的主要组件 3、什么是SpringMVC？简单介绍下你对SpringMVC的理解 4、SpringMVC的优点 5、SpringMVC常用的注解 6、SpringMVC怎么设定重定向和转发的 7、SpringMVC和Struts2的区别有哪些？ 8、如何解决POST请求中文乱码问题? 9、GET请求乱码怎么解决 10、springMVC里面拦截器是怎么写？ 11、SpringMvc的控制器是不是单例模式，如果是，有什么问题，怎么解决？
springMVC介绍
qq_45796208的博客
01-16 2629
springMVC简介 springMVC又 叫Spring web mvc。是Spring框架中的一部分，是Spring3.0后发布的。 SpringMVC框架的优点 1、基于MVC架构模式：MVC架构模式 2、容易理解上手快，使用简单：可以开发一个注解的SpringMVC项目，SpringMVC也是轻量级的框架，jar包很小，不依赖特定的接口和类。 3、作为Spring的一部分，能够使用Spring框架的IOC容器和Aop编程。方便整合Strtus、MyBatis、Hibernate、JPA等
SpringMVC常见面试题总结（超详细回答）
热门推荐
张维鹏的博客
07-08 57万+
1、什么是Spring MVC ？简单介绍下你对springMVC的理解? SpringMVC是一个基于Java的实现了MVC设计模式的请求驱动类型的轻量级Web框架，通过把Model，View，Controller分离，将web层进行职责解耦，把复杂的web应用分成逻辑清晰的几部分，简化开发，减少出错，方便组内开发人员之间的配合。 2、SpringMVC的流程？ （1）用户发送请...
SpringMvc
qq_45009608的博客
06-08 880
SpringMVC是一种基于Java实现MVC模型的轻量级Web框架（代替JavaWeb的表现层Servlet) 优点1.创建Maven项目 2.补全目录结构 3.导入jar包 将pom.xml中多余的内容删除掉，再添加SpringMVC需要的依赖 4.创建配置类 5.创建Controller类 6.使用配置类替换web.xml 将web.xml删除，换成ServletContainersInitConfig web.xml是管理servlet的 7.配置Tomcat环境 注意事项 Spri
SpringMVC简介
sssxlxwbwz的博客
03-26 2293
一、MVC简介 MVC是一种软件架构地思想，将软件按照模型(Model)、视图(View)、控制器(Control)来划分。
简述Spring、SpringMvc和SpringBoot的区别
王小二(海阔天空)
04-11 9万+
SpringBoot：简述SpringBoot和Spring的区别 一、Spring的介绍    简而言之，Spring框架为开发Java应用程序提供了全面的基础架构支持。 它包含一些很好的功能，如依赖注入和开箱即用的模块，如： Spring JDBC Spring MVC Spring Security Spring AOP Spring ORM Spring ...
SpringMVC的数据请求
楠黎倾风的博客
12-27 3万+
SpringMVC 默认已经提供了一些常用的类型转换器，例如客户端提交的字符串转换成int型进行参数设置。但是不是所有的数据类型都提供了转换器，没有提供的就需要自定义转换器，例如：日期类型的数据就需要自定义转换器。//将日期字符串转换成日期对象 返回 SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");try {} }}
【SpringMVC】| SpringMVC 入门
m0_61933976的博客
04-25 3449
【SpringMVC】| SpringMVC 入门
SpringMVC原理
笔记别偷看
06-19 5278
Spring MVC的功能组件 Spring通过一系列组件实现功能，这些组件包括DispatcherServlet（前端控制器）、HandlerMapping（处理器映射器）Handler(处理器)、HandlAdapter（处理器适配器）、ViewResolver（视图解析器）等。 DispatcherServlet（前端控制器） 前端控制器负责拦截客户端请求并分发给其他组件，它是整个流程控制的中心，负责调度其他组件的执行，降低各组件之间的耦合，提升整体效率。前端控制器由框架提供，在程序运行过程中自动实
SpringMVC 入门
AwayFuture的博客
03-23 641
SpringMVC学习的源代码，学习的每个知识点都在注释中讲解了，详细请CLICK我的GitHub：Go to AwayFuture’s GitHub
Spring+SpringMVC+Mybatis框架整合例子(SSM) 下载
07-21
Spring、SpringMVC和Mybatis是Java开发中最常用的三大开源框架，它们的整合使用，通常被称为SSM框架。这个框架组合提供了完整的后端服务解决方案，包括依赖注入（DI）、面向切面编程（AOP）、模型-视图-控制器（MVC...
SpringMVC demo 完整源码实例下载
05-02
SpringMVC是一款强大的Java web开发框架，用于构建高效、可维护的Web应用程序。在这个"SpringMVC demo 完整源码实例下载"中，我们能够深入理解并学习SpringMVC的核心概念和实际应用。 首先，SpringMVC是Spring框架...
SpringMVC+Spring+Mybatis集成开发环境
04-28
在IT行业中，SpringMVC、Spring和Mybatis是三大核心框架，它们的集成使用是Java Web开发中的常见实践。这个集成开发环境旨在提供一个高效、灵活的开发平台，以实现业务逻辑与数据访问的分离，提高代码的可维护性和可...
springmvc思维导图
07-25
springmvc的概念、springmvc的运行原理（前端控制器、处理器映射器、处理器适配器、处理器、视图解析器）、同步请求的方式（ModelAndView、String、无返回值、默认的绑定值）、异步请求的注解、请求参数的封装（简单...
Java基础07
最新发布
m0_74977981的博客
11-11 475
如图下图：每个case中都有一个break，如果没有这个break，就不会跳出case，直到遇见break为止。
JAVA-01-变量
LJH_laura_li的博客
11-08 332
在方法、构造函数或块内部定义的变量。
Java基于小程序公考学习平台的设计与实现（附源码，文档）
chusheng1840的博客
11-09 835
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 638
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
深入理解SpringMvc框架
"本次讲解的主题是SpringMvc，它是一个用于构建Web应用程序的Java框架，尤其在企业级开发中广泛使用。课程将深入讲解SpringMvc的核心概念和技术，帮助开发者提升技能水平。课程涉及到的关键库包括了SpringMvc的相关...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值