人工智能uu

这个屌丝很懒，什么也没留下！

热门标签

Spring与Spring MVC整合_你是如何整合spring和springmvc的

作者：人工智能uu | 2024-08-03 06:44:43

踩

你是如何整合spring和springmvc的

在这里插入代码片
1

Spring MVC

文章目录

Spring MVC

1 什么是MVC

MVC:模型(service,dao,entity)、视图、控制器(Servlet)
1

# MVC是模型(model)，视图(view)，控制器(Controller)的简写，是一种软件设计规范。

# 是将业务逻辑、数据、显示分离的方法来组织代码。

# MVC主要作用是降低了视图与业务逻辑间的双向耦合。

# MVC不是一种设计模式，mvc是一种架构模式。当然不同的mvc存在差异。
1
2
3
4
5
6
7

1.1 Model 模型

数据模型,提供要展示的数据,英雌包含数据和行为,可以认为是领域模型或JavaBean组件(包含数据和行为).不过现在一般都分离开来,Value Object(数据DAO) 和服务层(行为Service). 也就是模型提供了模型数据查询和模型数据的状态更新等功能.包括数据和业务.
1

1.2 视图

负责进行模型的展示,一般就是我们见到的用户界面,客户想看到的东西

jsp/html
1
2
3

1.3 控制器

接受用户请求,委托给模型进行处理(状态改变),处理完毕后把返回的模型数据返回给视图,由视图负责展示.也就是说控制器做了个调度员的工作.
1

1.4 Model 1

1.5 Model 2

拓展

慢慢演进而来的

2 职责分析

2.1Controller 控制器

Controller 控制器
1. 取得表单数据
2. 调用业务逻辑
3. 转向指定的页面
1
2
3
4

2.2 Model 模型

1. 业务逻辑
2. 保存数据的状态
1
2

2.3 View 视图

1. 显示页面
1

3 回顾Servlet

4 MVC需要做哪些事情

1. 将url映射到java类或java类的方法
2. 封装用户提交的数据.
3. 处理请求--调用相关的业务处理,封装响应数据.
4. 将响应的数据进行渲染.jsp/html等表示层数据.
1
2
3
4

MVVM: M V VM ViewModel:双向绑定

5 什么是Spring MVC

1. 什么是SpringMVC 
# Spring MVC 是 Spring Framework 的一部分,是基于Java实现MVC的轻量级Web框架.


1
2
3
4

5.1 为什么要学习Spring MVC

Spring:大杂烩,我们可以将Spring MVC中所有要用到的bean,注册到Spring中!

5.2 中心控制器

Spring的web框架围绕DispatcherServlet设计.DispatcherServlet的作用是将请求分发到不同的处理器.从Spring 2.5开始,使用Java 5 或者以上版本的用户可以采用基于注解的controller声明方式.
Spring MVC框架像许多其他MVC框架一样,以请求为驱动,围绕一个中心Servlet分派请求及提供其他功能,DispatcherServlet是一个实际的Servlet(它继承自HttpServlet基类).
1
2

原理:

5.2.1 简要分析执行流程

1. DispatcherServlet表示前置控制器,是整个SpringMVC的控制中心.用户发出请求,DispatcherServlet接收请求并拦截请求.

2. HandlerMapping为处理器映射.DispatcherServlet调用HandlerMapping,HandlerMapping根据请求url查找Handler

3. HandlerExecution表示具体的处理器,其主要作用是根据url查找控制器,如上url被查找控制器为:hello.

4. HandlerExecution将解析后的信息传递给DispatcherServlet如解析控制器映射等.

5. HandlerAdapter 表示处理器适配器, 其按照特定的规矩去执行Handler

6. Handler 让具体的Controller执行.

7. Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView.

8. HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet.

9. DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名.

10. 视图解析器将解析的逻辑视图名传给DispatcherServlet.

11. DispatcherServlet根据视图解析器解析的试图结果,调用具体的视图.

12. 最终视图呈现给用户.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

6 Spring MVC 环境搭建

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
        </dependency>
    </dependencies>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

7 Spring MVC 接口版

7.1 web.xml中配置DispatcherServlet

<listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-web.xml</param-value>
    </context-param>
    <!--配置dispatcherServlet，这个是spring MVC 的核心，请求分发器，前端控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--绑定Spring配置文件-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            
            <!--此处自闭和,因为已使用contextloaderlinstener加载Spring工厂-->
            <param-value/>

        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <!-- /  不匹配 .jsp-->
        <!-- /* 匹配 .jsp -->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
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

7.2 spring-web.xml 配置相关bean

    <!--处理器映射器-->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    <!--处理器适配器-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <property name="prefix" value = "/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
    <!-- 创建Controller的bean 。使用的是bean名称url处理器映射， 所以请求的url地址会去查找相关bean的id， -->
    <!--BeanNameUrlHandlerMapping-bean-->
    <bean id="/hello" class="controller.HelloController"/>
1
2
3
4
5
6
7
8
9
10
11
12

7.3 Java代码

public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView modelAndView = new ModelAndView();
        
        //业务代码逻辑
        String result = "HelloSpringMVC";
        modelAndView.addObject("msg",result);
        modelAndView.setViewName("test");
        //视图跳转


        return modelAndView;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

但是实际开发中一般不会使用此方法

8 Spring MVC注解版

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

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

8.1 配置web.xml

<listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-web.xml</param-value>
    </context-param>
    <!--配置dispatcherServlet，这个是spring MVC 的核心，请求分发器，前端控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--绑定Spring配置文件-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            
            <!--此处自闭和,因为已使用contextloaderlinstener加载Spring工厂-->
            <param-value/>

        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <!-- /  不匹配 .jsp-->
        <!-- /* 匹配 .jsp -->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
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

8.2 spring-web.xml

    <!--扫描指定包下的component注解-->
    <context:component-scan base-package="com.leetao"/>
    <!--默认的资源过滤 .css,.js .... -->
    <mvc:default-servlet-handler/>
    <!--视图解析器-->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!-- 支持mvc注解驱动
        在spring中一般采用@RequestMapping注解开完成映射关系
        想要使@RequestMapping注解生效
        必须向上下文注册这侧DefaultAnnotationHandlerMapping
        和一个AnnotationMethodHandlerAdapter实例
        这两个实例分别在类级别和方法级别处理。
        而annotation-driven配置帮助我们自动完成上述两个实例的注入
        四维一体：基于schema方式
    -->
    <mvc:annotation-driven/>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

8.3 创建Controller·

@Controller
@RequestMapping("/hello")
public class HelloController {

	//RestFul风格
    @RequestMapping("/h1/{id}/{name}")
    public String hello(Model model,@PathVariable String name, @PathVariable String id){
        System.out.println(name);
        System.out.println(id);
        //封装数据
        model.addAttribute("msg","Hello,SpringBoot");
        //会被视图解析器处理
        return "hello";
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

8.4 小结

@RestController 仅返回json

9 Controller 控制器

9.1 介绍

# 控制器负责提供访问应用程序的行为，通常通过接口定义或注解定义两种方式实现

# 控制器负责解析用户的请求并将其转换为一个模型。

# 在Spring MVC中一个控制器类可以包含多个方法

# 在Spring MVC中,对于Controller的配置方式有很多种

1
2
3
4
5
6
7
8

实现接口Controller定义控制器是较老的办法
缺点：一个控制器只能有一个方法，如果要多个方法则需要定义多个Controller;定义的的方式比较麻烦;

9.2 实现方式

基于接口

# spring-mvc.xml
<!--处理器映射器-->
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
<!--处理器适配器-->
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
<!--视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
    <property name="prefix" value = "/"/>
    <property name="suffix" value=".jsp"/>
</bean>
<!--BeanNameUrlHandlerMapping-bean-->
<bean id="/hello" class="controller.HelloController"/>

1
2
3
4
5
6
7
8
9
10
11
12
13

/* java */
public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView modelAndView = new ModelAndView();
        
        //业务代码逻辑
        String result = "HelloSpringMVC";
        modelAndView.addObject("msg",result);
        modelAndView.setViewName("test");
        //视图跳转


        return modelAndView;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

基于注解(推荐)

@Controller 注解类型用于声明Spring类的实例是一个控制器
Spring可以使用扫描机制来找到应用程序中所有基于注解的控制器类，为了保证Spring能找到你的控制器，需要在配置文件中声明组件扫描。

 <!-- spring-web.xml -->
 <!--扫描指定包下的component注解-->
 <context:component-scan base-package="com.leetao"/>
 <!--默认的资源过滤 .css,.js .... -->
 <mvc:default-servlet-handler/>
 <!--视图解析器-->
 <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
 <property name="prefix" value="/jsp/"/>
 <property name="suffix" value=".jsp"/>
 </bean>

<!-- 支持mvc注解驱动
在spring中一般采用@RequestMapping注解开完成映射关系
想要使@RequestMapping注解生效
必须向上下文注册这侧DefaultAnnotationHandlerMapping
和一个AnnotationMethodHandlerAdapter实例
这两个实例分别在类级别和方法级别处理。
而annotation-driven配置帮助我们自动完成上述两个实例的注入
四维一体：基于schema方式
-->
<mvc:annotation-driven/>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

/* java */
// 代表这个类会被Spring接管
// 被这个注解的类中的所有方法，如果返回值是String，并且有具体页面可以跳转，那么就会被视图解析器解析
@Controller 
@RequestMapping("/hello")
public class HelloController {


    @RequestMapping("/h1/{id}/{name}")
    public String hello(Model model,@PathVariable String name, @PathVariable String id){
        System.out.println(name);
        System.out.println(id);
        //封装数据
        model.addAttribute("msg","Hello,SpringBoot");

        //会被视图解析器处理
        return "hello";
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

可以发现，我们两个请求都可以指向一个视图，但是页面结果的结果是不一样的，从这里可以看出视图是被复用的，而控制器与视图之间是弱耦合关系

10 ReqestMap…

RequestMapping

@RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

# 当@RequestMapping定义到类时,想要前端访问具体的内容必须加上类名的requestMapping+方法的requestMapping.
	类名的requestMapping 是父路径。
	如果类指定requestMapping，方法不指定requestMapping 那么直接通过访问父路径就可以进入到方法
	
1
2
3
4
5
6

11 RestFul 风格

概念

RestFul就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。
1

// 安全、简介、高效
//原来的 http://localhost:8080/add?a=1&b=3
//RestFul http://localhost:8080/add/1/2
@GetMapping(value="/add/{a}/{b}")
public String test(@PathVariable int a, @PathVariable int b, Model model) {
    model.addAttribute("msg",a+"菅江晖"+b);
    return "hello";
}
1
2
3
4
5
6
7
8

@RequestMapping 下还有很多细分的Mapping

# @GetMapping 只接受get请求

# @PostMapping 只接受post请求 

1
2
3
4
5
6

如果使用此方式，如果缺少参数，将抛出404 地址不存在异常

12 结果跳转方式

ModelAndView

设置ModelAndView对象,根据View的名称,和视图解析器跳到指定的页面.
1

原生的ServletAPI

SpringMVC

重定向只需要添加 redirect: .他不会经过视图解析器

13 Spring 数据处理

·规范：@RequestParam("username") 前端传过来的数据最好使用此注解显式声明，后期维护友好…shiyong

如果是提交的是对象参数

接收前端用户的参数，方法形参上使用对象。如果前端传入的参数名对应对象的属性名。则匹配成功注入，否则为null

数据显示到前端

14 乱码问题

get乱码

# 如果是tomcat服务器的话
	在server.xml 文件中配置
	在tomcat的server.xml里把

<Connector connectionTimeout="50000" port="8080" protocol="HTTP/1.1" redirectPort="8443"/>

修改为

<Connector connectionTimeout="50000" port="8080" protocol="HTTP/1.1" redirectPort="8443" URIEncoding="UTF-8"/>
1
2
3
4
5
6
7
8
9

post乱码

# 1.过滤器解决乱码
1

# 2.Spring自带的过滤器
1

<filter>
	<filter-name>encoding</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>encoding</filter-name>
	<url-pattern>/*</url-pattern>
</filter-mapping>
1
2
3
4
5
6
7
8
9
10
11
12

15 JSON

前后端分离时代:

后端部署后端，提供接口，提供数据

JSON
前端部署前端，负责渲染后端的数据

JSON(JavaScript Object Notation,js对象标记) 是一种轻量级的数据交换格式，目前使用特别广泛.

采用完全独立于编程语言的文本格式来存储和表示数据。
简洁和清晰的层次结构使得JSON成为理想的数据交换语言。
易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。

在JavaScript语言中，一切都是对象。因此，任何JavaSript支持的类型都可以通过JSON来表示，例如字符串，数字，对象，数组。

JSON键值对是用来保存JavaScript对象的一种方式，和JavaScript对象的写法也大同小异，键/值对组合中的键名写在前面并用双引号""包裹，使用冒号:分隔，然后紧接着值:

16 Jackson

Jackson 是一个 Java 的用来处理 JSON 格式数据的类库，性能非常好。

package com.leetao.jackson.controller;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.leetao.jackson.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * @author 菅江晖
 * @date 2020/10/28 - 15:09
 */
@Controller
public class UserController {

    @ResponseBody
    @RequestMapping(value="/j1",produces = "application/json; charset=UTF-8")
    public Object json1() throws JsonProcessingException {
        User user = new User(1,"菅江晖","男");
        ObjectMapper objectMapper = new ObjectMapper();
        String s = objectMapper.writeValueAsString(user);
        return s;
    }
}

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

17 FastJson

fastjson.jar是阿里开发的一款专门用于Java开发的包，可以方便的实现json对象与JavaBean对象的转换，实现JavaBean对象与json字符串的转换。实现json的转换方法很多，最后实现结果都是一样的

18 AJAX

xhr ajax请求

jQuery 是一个库

19 SpringMVC 拦截器

概述

SpringMVC的处理器拦截器类似于Servlet开发中的过滤器Filter，用于对处理器进行预处理和后处理。开发者可以自己定义一些蓝机器来实现特定的功能。

拦截器与过滤器的区别：拦截器是AOP思想的具体应用。

过滤器
- servlet规范中的一部分，任何java web工程都可以使用
- 在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截
拦截器
- 拦截器是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能使用
- 拦截器只会拦截访问的控制器方法，如果访问的是jsp/html/css/image/js是不会进行拦截的

# 拦截器使用了aop.但并不是对Controller进行代理，[是对HandlerMapping]进行映射
1

20 Spring MVC文件上传

文件上传是项目开发中最常见的功能之一，SpringMVC可以很好的支持文件上传，但是SpirngMVC上下文中默认没有装配MultipartResolver，因此默认情况下其不能处理文件上传工作。如果想使用Spring的文件上传功能，则需要在上下文中配置MultipartResolver。

前端表单要求:为了能上传文件，必须将表单的method设置为post，并将enctype设置为multipart/form-data。只有在这样的情况下，浏览器才会把用户选择的文件以二进制数据发送给服务器；

对表单的enctype属性做个详细的说明：

application/x-www=form-urlencoded:默认方式，只处理表单域中的value属性值，采用这种编码方式的表单会将表单域中的值处理成url编码方式
multipart/form-data:这种编码方式会以二进制流的方式来处理表单数据，这种编码方式会把文件域指定文件的内容也封装到请求参数中，不会对字符编码。

text/plain:除了把空格转换为"+"号外，其他字符都不做编码处理，这种方式适用直接通过表单发送邮件。

<form action="" enctype="multipart/form-data" method="post">
    <input type = "file" name="file"/>
    <input type = "submit"/>
</form>
1
2
3
4

pom.xml

<!--文件上传-->
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.3</version>
</dependency>
<!--servlet 高版本-->
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
</dependency>
1
2
3
4
5
6
7
8
9
10
11

application-mvc.xml

<!--文件上传配置-->
<bean id = "multipartResolver" class = "org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <property name = "defaultEncoding" value="utf-8"/>
    <!-- 文件上传大小控制-->
    <property name = "maxUploadSize" value="10485760"/>
</bean>
1
2
3
4
5
6

 @RequestMapping("/update")
    public String fileUpload(@RequestParam("file")CommonsMultipartFile file, HttpServletRequest request) throws IOException {
        
        
        /*获取源文件名*/
        String oldFileName = file.getOriginalFilename();
        /*文件名为空时....*/
        if(oldFileName == null || "".equals(oldFileName)/*or StringUtlis.isEmpty*/){
            //do thing...
        }
        
        
        //文件拓展名
        String extension = FilenameUtils.getExtension(oldFileName);
       
		/*检查是否符合龟腚拓展*/
		// or FilenameUtils.isExtension(filename,extension)
        if(!extension.equals("txt")){
            // do thing .....
        }
        
        
        /*获取上传文件大小*/
        long size = file.getSize();
        /*文件大小是否合格*/
        if(size>100000){
            //do thing ..
        }

        
        /*上传文件路径*/
        String path = request.getServletContext().getRealPath("/upload");
        File realFile = new File(path,oldFileName);
        /*如果路径不存在,创建一个*/
        if(!realFile.getParentFile().exists()){
            realFile.getParentFile().mkdirs();//创建父级文件路径
            realFile.createNewFile();//创建文件
        }
        
        
        
        /*将传入文件的数据写入指定的文件*/
        file.transferTo(realFile);
        return "success";
    }
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
38
39
40
41
42
43
44
45

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】