SpringMVC-02-HelloSpringMVC

字数统计: 3.6k字   |   阅读时长≈ 16分钟

SpringMVC-02-HelloSpringMVC

1. 配置版实现（不使用）

  1. 新建一个Moudle ， 添加web的支持！
  2. 确定导入了SpringMVC 的依赖！
  3. 配置web.xml ， 注册DispatcherServlet
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<?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">
    
<!--配置DispatchServlet:这个是SpringMVC的核心，请求分发器，前端控制器-->
    
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--DispatcherServlet要绑定Spring的配置文件-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
<!--启动级别：初始化启动-->
        <load-on-startup>1</load-on-startup>
    </servlet>

<!--在Springmvc中 / 和 /*的区别
/: 只匹配所有的请求，不会匹配JSP页面
/*:匹配所有的请求，包括jsp页面-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    
</web-app>
  1. 编写SpringMVC 的 配置文件！
    • 名称：springmvc-servlet.xml : [servletname]-servlet.xml说明，这里的名称要求是按照官方来的
1
2
3
4
5
6
7
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>
  1. 添加处理器映射
1
2
<!--处理器映射器-->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
  1. 添加处理器适配器
1
2
<!--处理器适配器-->
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
  1. 添加视图解析器
1
2
3
4
5
6
<!--视图解析器 以后模板引擎会使用：Thymeleaf Freemarker-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
<!-- 前缀和后缀-->
        <property name="prefix" value="/WEB-INF/JSP/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
  1. 编写我们要操作业务的Controller，要么实现Controller接口，要么增加注解；（需要返回一个ModelandView，封装数据，转发视图）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.zhuuu.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 {
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        
        ModelAndView mv = new ModelAndView();

        //业务代码：封装数据
        String result = "HelloSpringMVC";
        mv.addObject("msg",result);

        //视图跳转
        mv.setViewName("test");

        //返回model and view
        return mv;
    }
}
  1. 将自己的类交给SpringIOC容器，注册bean
1
2
<!--BeanNameUrlHandlerMapping:bean-->
    <bean id="/hello" class="com.zhuuu.Controller.HelloController"/>
  1. 编写需要跳转的页面
1
2
3
4
5
6
7
8
9
10
11
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>

${msg}

</body>
</html>
  1. 配置Tomcat 启动测试！

1.1 404 error 问题

可能遇到的问题：访问出现404，排查步骤：

  1. 查看控制台输出，看一下是不是缺少了什么jar包。
  2. 如果jar包存在，显示无法输出，就在IDEA的项目发布中，添加lib依赖！
  3. 重启Tomcat 即可解决！

2. 注解版实现(使用)

  • 第一步:新建一个Moudle , 添加web支持！

  • 第二步:由于Maven可能存在资源过滤的问题，我们将配置完善

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
</build>

  • 第三步:在pom.xml文件引入相关的依赖：

    • 主要有Spring框架核心库、Spring MVC、servlet , JSTL等。我们在父依赖中已经引入了！

  • 第四步: 配置web.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<?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>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!-- 启动顺序，数字越小，启动越早 -->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--所有请求都会被springmvc拦截 -->
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

第五步 : 添加Spring MVC配置文件

  • 让IOC的注解生效
  • 静态资源过滤 ：HTML . JS . CSS. 图片 ， 视频 …..
  • MVC的注解驱动
  • 配置视图解析器
  • 在resource目录下添加springmvc-servlet.xml配置文件，配置的形式与Spring容器配置基本类似，为了支持基于注解的IOC，设置了自动扫描包的功能，具体配置信息如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
<?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
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
    <context:component-scan base-package="com.zhuuu.controller"/>
    <!-- 让Spring MVC不处理静态资源 .css .js .html .mp3 .mp4-->
    <mvc:default-servlet-handler />
    <!--
    支持mvc注解驱动
        在spring中一般采用@RequestMapping注解来完成映射关系
        要想使@RequestMapping注解生效
        必须向上下文中注册DefaultAnnotationHandlerMapping
        和一个AnnotationMethodHandlerAdapter实例
        这两个实例分别在类级别和方法级别处理。
        而annotation-driven配置帮助我们自动完成上述两个实例的注入。
     -->
    <mvc:annotation-driven />

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

</beans>
  • 在视图解析器中我们把所有的视图都存放在/WEB-INF/目录下，这样可以保证视图安全，因为这个目录下的文件，客户端不能直接访问。

第六步 : 创建Controller

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.zhuuu.controller;

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

@Controller													// 直接注入到ioc容器中										
public class HelloController{
    @RequestMapping("/hello")				// 1. url怎么请求过来
    public String hello(Model model){
        model.addAttribute("msg","hello,Spring MVC annatation");		// 2. 返回数据
        return "hello"; // 会被视图解析器处理 /WEB-INFO/hello.jsp      // 3. 返回视图，被视图解析器处理
    }
}

  • @Controller ： 为了让Spring IOC容器初始化时达到自动扫描的目的

    • @Controller : 这个类会被视图解析器解析
    • @RestController:这个类不会被视图解析器解析，只会返回一个字符串（JSON）

  • @RequestMapping ：是为了映射请求路径

第七步:创建视图层

  • 在WEB-INF/ jsp目录中创建hello.jsp ， 视图可以直接取出并展示从Controller带回的信息；

  • 可以通过EL表示取出Model中存放的值，或者对象；

1
2
3
4
5
6
7
8
9
10
11
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>

${msg}

</body>
</html>

第八步:配置Tomcat运行

OK，运行成功！

2.1 注意事项

1
2
3
4
5
**/ 和 /\* 的区别：**
< url-pattern > / </ url-pattern > 不会匹配到.jsp， 只针对我们编写的请求；
即：.jsp 不会进入spring的 DispatcherServlet类 。
< url-pattern > /* </ url-pattern > 会匹配 *.jsp，
会出现返回 jsp视图 时再次进入spring的DispatcherServlet 类，导致找不到对应的controller所以报404错。

3. @RequestMapping

  • 在Spring MVC 中使用 @RequestMapping 来映射请求，也就是通过它来指定控制器可以处理哪些URL请求，相当于Servlet中在web.xml中配置
1
2
3
4
5
6
7
8
<servlet>
    <servlet-name>servletName</servlet-name>
    <servlet-class>ServletClass</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>servletName</servlet-name>
    <url-pattern>url</url-pattern>
</servlet-mapping>
  • 让我们先看一下RequestMapping注解类的源码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Mapping
public @interface RequestMapping {
	String name() default "";
	String[] value() default {};
	String[] path() default {};
	RequestMethod[] method() default {};
	String[] params() default {};
	String[] headers() default {};
	String[] consumes() default {};
	String[] produces() default {};
}

1）在@Target中有两个属性，分别为 ElementType.METHOD和ElementType.TYPE，也就是说 @RequestMapping 可以在方法和类的声明中使用

2）可以看到注解中的属性除了 name() 返回的字符串，其它的方法均返回数组，也就是可以定义多个属性值，例如 value() 和 path() 都可以同时定义多个字符串值来接收多个URL请求

  • 测试 @RequestMapping 的 method 属性
  1. @RequestMapping 中的 method 主要用来定义接收浏览器发来的何种请求。在Spring中，使用枚举类
  2. Http规范定义了多种请求资源的方式，最基本的有四种，分别为：GET（查）、POST（增）、PUT（改）、DELETE（删），而URL则用于定位网络上的资源相当于地址的作用，配合四种请求方式，可以实现对URL对应的资源的增删改查操作。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// @RequestMapping(value="/login",method=RequestMethod.GET) 来指定 login()方法 仅处理通过 GET 方式发来的请求

@Controller
@RequestMapping(path = "/user")
public class UserController {
 
	@RequestMapping(path = "/login", method=RequestMethod.GET)
	public String login() {
		return "success";
	}
}

//这时，如果浏览器发来的请求不是GET的话，将收到浏览器返回的错误提示，也就是得通过链接的方式而不是表单的方式：
//由于在 RequestMapping 注解类中 method() 方法返回的是 RequestMethod 数组，所以可以给 method 同时指定多个请求方式，例如：

@Controller
@RequestMapping(path = "/user")
public class UserController {
        // 该方法将同时接收通过GET和POST方式发来的请求
	@RequestMapping(path = "/login", method={RequestMethod.POST,RequestMethod.GET})
	public String login() {
		return "success";
	}
}
  • 测试 @RequestMapping 的 params 属性，该属性表示请求参数，也就是追加在URL上的键值对，多个请求参数以&隔开，例如：

http://localhost/SpringMVC/user/login?username=kolbe&password=123456

  1. 则这个请求的参数为username=kolbe以及password=123456，@RequestMapping 中可以使用 params 来限制请求参数，来实现进一步的过滤请求，举个例子：
1
2
3
4
5
6
7
8
9
10
11
12
@Controller
@RequestMapping(path = "/user")
public class UserController {
        
        // 该方法将接收 /user/login 发来的请求，且请求参数必须为 username=kolbe&password=123456
	@RequestMapping(path = "/login", params={"username=kolbe","password=123456"})
	public String login() {
		return "success";
	}
}

//该例中则表示 UserController 中的 login() 方法仅处理 /user/login 发来的请求，且必须带有 username=kolbe&password=123456 的请求参数，否则浏览器将返回HTTP 404的错误
  • @RequestMapping 的 headers 属性，该属性表示请求头
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
用于HTTP协义交互的信息被称为HTTP报文，客户端发送的HTTP报文被称为请求报文，服务器发回给客户端的HTTP报文称为响应报文，报文由报文头部和报文体组成。

请求头部（Request Headers）：请求头包含许多有关客户端环境和请求正文的信息，例如浏览器支持的语言、请求的服务器地址、客户端的操作系统等。

响应头部（Rsponse Headers）：响应头也包含许多有用的信息，包括服务器类型、日期、响应内容的类型及编码，响应内容的长度等等。

//如果你安装的是Chrome浏览器，可以通过在网页中  右击鼠标---->审查元素---->Network---->Name中点击网页---->右侧查看Headers即可，如果Name中没有出现网页，可以刷新一下即可，下边是我电脑中的一个请求头部示例：

Request Headers
 Accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
    Accept-Encoding:gzip, deflate, sdch
    Accept-Language:zh-CN,zh;q=0.8
    Cache-Control:max-age=0
    Connection:keep-alive
    Cookie:JSESSIONID=210075B5E521CWE3CDE938076295A57A
    Host:localhost:8080
    Upgrade-Insecure-Requests:1
    User-Agent:Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.2454.93
  1. 回规正题，通过 @RequestMapping 中的 headers 属性，可以限制客户端发来的请求
1
2
3
4
5
6
7
8
9
@Controller
@RequestMapping(path = "/user")
public class UserController {
        // 表示只接收本机发来的请求
	@RequestMapping(path = "/login", headers="Host=localhost:8080")
	public String login() {
		return "success";
	}
}
  • 带占位符的URL
1
2
3
4
5
6
7
8
9
10
@Controller
@RequestMapping(path = "/user")
public class UserController {
   // value : 占位符
   // @PathVariable : 占位具体的变量
	@RequestMapping(value="/{id}", method=RequestMethod.GET)
	public String show(@PathVariable("id") Integer id) {
		return "success";
	}
}
  • 采用 REST 风格的 URL 请求

REST 风格的 URL 请求

1
2
3
4
5
6
7
8
 请求路径        请求方法           作用
-/user/1        HTTP GET        得到id为1的user

-/user/1        HTTP DELETE     删除id为1的user

-/user/1        HTTP PUT        更新id为1的user

-/user          HTTP POST       新增user
  1. 由于浏览器表单只支持 GET 和 POST 请求，
  2. 为了实现 DELETE 和 PUT 请求，Spring 为我们提供了一个过滤器org.springframework.web.filter.HiddenHttpMethodFilter，可以为我们将 GET 和 POST 请求通过过滤器转化成 DELETE 和 PUT 请求。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package cn.kolbe.spring.mvc.controller;
 
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
@RequestMapping(path = "/user")
public class UserController {
 
	@RequestMapping(value="/{id}", method=RequestMethod.GET)
	public String show(@PathVariable("id") Integer id) {
		System.out.println("查看id为：" + id + "的user");
		return "success";
	}
	
	
	@RequestMapping(value="/{id}", method=RequestMethod.PUT)
	public String update(@PathVariable("id") Integer id) {
		System.out.println("更新id为：" + id + "的user");
		return "success";
	}
	
	@RequestMapping(value="/{id}", method=RequestMethod.DELETE)
	public String destroy(@PathVariable("id") Integer id) {
		System.out.println("删除id为：" + id + "的user");
		return "success";
	}
	
	@RequestMapping(value="", method=RequestMethod.POST)
	public String create() {
		System.out.println("新建user");
		return "success";
	}
}

4. 小结

实现步骤其实非常简单：

  1. 新建一个web项目
  2. 导入相关jar包
  3. 编写web.xml，注册DispatchterServlet
  4. 编写SpringMVC配置文件
  5. 接下来就要使去创建对应的控制类，controller
  6. 最后完善前端试图和controller之间的对应
  7. 测试运行调试

使用springMVC必须配置的三大件：

  • 处理器映射器、处理器适配器、视图解析器

  • 通常，我们只需要手动配置视图解析器，而处理器映射器和处理器适配器只需要开启注解驱动即可，而省去了大段的xml配置

打赏
  • 版权声明： 本博客所有文章除特别声明外，均采用 Apache License 2.0 许可协议。转载请注明出处！
  • © 2019-2022 Zhuuu
  • PV: UV:

请我喝杯咖啡吧~

支付宝
微信