SpringMVC学习笔记

最新推荐文章于 2024-07-15 15:14:58 发布

I can丶

最新推荐文章于 2024-07-15 15:14:58 发布

阅读量116

点赞数

分类专栏：后端框架文章标签： spring springmvc java 框架 SSM

本文链接：https://blog.csdn.net/zhq9695/article/details/109692171

版权

后端框架专栏收录该内容

12 篇文章 0 订阅

订阅专栏

1 三层架构

表现层：用于展示数据

业务层：用于处理业务需求

持久层：用于和数据库交互

2 SpringMVC介绍

SpringMVC是基于Java实现的MVC设计模型的表现层框架，轻量级WEB框架

MVC：Model View Controller 模型视图控制器

Model：数据模型，指JavaBean的类

View：指用于展示数据给用户的JSP、HTML

Controller：用于接收用户请求，整个流程的控制器

SpringMVC和Struts2的对比

共同点：都是表现层框架，都是基于MVC，底层都是Servlet，处理请求的机制都是核心控制器
区别：SpringMVC的入口是Servlet，而Struts2是Filter
区别：SpringMVC是基于方法设计的，Struts2是基于类，SpringMVC执行速度比Struts2稍快
区别：SpringMVC使用更加简洁，处理ajax请求更方便
区别：Struts2的OGNL表达式使页面开发效率比SpringMVC高，但执行效率没有SpringMVC的JSTL高

3 Maven中配置SpringMVC

使用Maven下的webapp工程

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.0.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-web</artifactId>
  <version>5.0.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>5.0.2.RELEASE</version>
</dependency>
<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>

4 配置文件

SpringMVC框架基于组件的方式执行

前端控制器 DispatcherServlet：控制整个流程执行
处理器映射器 HandlerMapping：找到具体哪个类哪个方法（Handler）执行
处理器适配器 HandlerAdapter：执行方法
视图解析器 ViewResolver：跳转到具体的页面

启动服务器时做的事情

前端控制器DispatcherServlet对象被创建
加载springmvc.xml
配置过的bean对象加入spring的IoC容器

发送请求时做的事情

客户端发送request请求，到达前端控制器
前端控制器请求处理器映射器查找Handler，返回执行链（需要执行的方法）
前端控制器请求处理器适配器执行方法，处理器适配器执行Handler，返回ModelAndView（在这里就是success.jsp）
前端控制器请求视图解析器进行视图解析，得到View
前端控制器进行视图渲染，将模型数据填充到request域
前端控制器返回response响应给客户端

4.1 /WEB-INF/web.xml

<!-- 前端控制器（SpringMVC核心控制器） -->
<servlet>
	<servlet-name>dispatcherServlet</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 配置初始化参数，用于读取SpringMVC配置文件 -->
	<init-param>
  		<param-name>contextConfigLocation</param-name>
  		<param-value>classpath:springmvc.xml</param-value>
	</init-param>
    <!-- 配置servlet的对象创建时间点，非0正整数表示启动顺序 -->
	<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
	<servlet-name>dispatcherServlet</servlet-name>
	<url-pattern>/</url-pattern>
</servlet-mapping>

<!-- 配置解决中文乱码的过滤器 -->
<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 resources/springmvc.xml

文件头

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       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
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
        
    ....
    
</beans>

配置视图解析器

property标签prefix：用于指定跳转页面的前缀
property标签suffix：用于指定跳转页面的后缀
例如，controller返回值是success，则跳转页面是/WEB-INF/pages/success.jsp

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

配置spring注解

<context:component-scan base-package="com.zhq"/>

配置springmvc注解，当配置了这个注解后，会自动加载处理器映射器和处理器适配器

<mvc:annotation-driven/>

配置前端控制器不拦截的资源

<mvc:resources location="/js/" mapping="/js/**"></mvc:resources>
<mvc:resources location="/css/" mapping="/css/**"></mvc:resources>
<mvc:resources location="/images/" mapping="/images/**"></mvc:resources>

配置自定义类型转换器

如果有自定义类型转换，则配置，springmvc注解需要配置conversion-service属性
property标签的converters是一个set集合，通过set标签增加自己的类型转换类

<mvc:annotation-driven conversion-service="conversionServiceFactoryBean"/>

<bean id="conversionServiceFactoryBean" class="org.springframework.context.support.ConversionServiceFactoryBean">
    <property name="converters">
        <set>
            <bean class="com.zhq.utils.String2DateConverter"></bean>
        </set>
    </property>
</bean>

5 Controller控制类

5.1 注解

5.1.1 RequestMapping注解

JSP页面，最开头不需要加/

<a href="user/hello">Hello</a>

Controller类

Controller注解：将Controller类加入Spring的IoC核心容器
RequestMapping注解：建立请求url和处理方法的对应关系，放在类上可以设置方法的父路径
String返回值：视图解析器会拼接路径，跳转至对应页面

@Controller
@RequestMapping(path = "/user")
public class HelloController {

    @RequestMapping(path = "/hello")
    public String sayHello(){
        ...
        return "success";
    }
}

RequestMapping注解的属性

value和path：相同的，用于指定请求url路径
method：用于指定当前方法可以接受什么类型请求（get、post），例如method = {RequestMethod.GET, RequestMethod.POST}
params：用于限制请求必须包含的参数，例如params = {“username”}或者params = {“username==123”}
headers：用于限制请求头必须包含的属性，例如headers={“Accept”}

5.1.2 RequestParam注解

<a href="anno/testRequestParam?username=haha">RequestParam</a><br/>

// 用于指定控制类方法参数名与request请求参数名称的映射
@RequestMapping("/testRequestParam")
public String testRequestParam(@RequestParam("username") String name){
    ...
    return "success";
}

5.1.3 RequestBody注解

<form action="anno/testRequestBody" method="post">
    姓名：<input type="text" name="uname"/><br/>
    年龄：<input type="text" name="age"/><br/>
    <input type="submit" value="提交"/>
</form><br/>

// 用于获取整个请求体（key=value&key=value...），不适用于get请求，如果用post请求，可以将其参数都封装到一个对象，也可以通过RequestBody注解直接获取整个请求体
@RequestMapping("/testRequestBody")
public String testRequestBody(@RequestBody String body){
    ...
    return "success";
}

5.1.4 PathVariable注解

<a href="anno/testPathVariable/10">testPathVariable</a><br/>

// 在request请求的时候直接在后面加参数，RequestMapping注解也增加占位符，PathVariable注解用于指定获取这个占位符的值
@RequestMapping("/testPathVariable/{sid}")
public String testPathVariable(@PathVariable(name = "sid") String id){
    ...
    return "success";
}

5.1.5 RequestHeader注解

// 获取请求头信息
@RequestMapping("/testRequestHeader")
public String testRequestHeader(@RequestHeader("Accept") String header){
    ...
    return "success";
}

5.1.6 CookieValue注解

// 获取cookie对象
@RequestMapping("/testCookieValue")
public String testCookieValue(@CookieValue("JSESSIONID") String cookie){
    ...
    return "success";
}

5.1.7 ModelAttribute注解

<form action="anno/testModelAttribute" method="post">
    姓名：<input type="text" name="uname"/><br/>
    年龄：<input type="text" name="age"/><br/>
    <input type="submit" value="提交"/>
</form><br/>

@RequestMapping("/testModelAttribute")
public String testModelAttribute(User user){
    ...
    return "success";
}

// 注解在方法上，会优先与其他控制类的方法执行，并且也可以获取request请求的参数，并设定返回值，Controller的方法可以获取这个返回值
@ModelAttribute
public User showUser(String uname){
    // 提前获取用户名，通过用户查询数据库
    User user = new User();
    ...
    return user;
}

// Controller方法通过ModelAttribute注解获取对象
@RequestMapping("/testModelAttribute")
public String testModelAttribute(@ModelAttribute("abc") User user){
    ...
    return "success";
}

// ModelAttribute注解的第二种用法，通过Map参数，把用户对象加入Map中
@ModelAttribute
public void showUser(String uname, Map<String, User> map){
    // 提前获取用户名，通过用户查询数据库
    User user = new User();
    ...
    map.put("abc", user);
}

5.1.8 SessionAttributes注解

<a href="anno/testSessionAttributes">testSessionAttributes</a><br/>
<a href="anno/getSessionAttributes">getSessionAttributes</a><br/>
<a href="anno/delSessionAttributes">delSessionAttributes</a><br/>

// 将request域对象存储到session中
@SessionAttributes(value = {"msg"})
public class AnnoController {

	@RequestMapping("/testSessionAttributes")
    public String testSessionAttributes(Model model){
        // 存储到request域对象中
        model.addAttribute("msg", "123");
        return "success";
    }

    @RequestMapping("/getSessionAttributes")
    public String getSessionAttributes(ModelMap model){
        // 从session域取对象
        String msg = (String) model.get("msg");
        return "success";
    }

    @RequestMapping("/delSessionAttributes")
    public String delSessionAttributes(SessionStatus status){
        // 从session域清除对象
        status.setComplete();
        return "success";
    }
}

<%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %>
...
<%--    获取request域对象--%>
${requestScope.msg}
${user.username}
${user.password}
<%--    获取session域对象--%>
${sessionScope}

5.1.9 ResponseBody注解

<script src="js/jquery.min.js"></script>

<script>
    // 页面加载，绑定单击事件
    $(function (){
        $("#btn").click(function (){
            // 发送ajax请求
            $.ajax({
                // json格式
                url: "user/testAjax",
                contentType: "application/json;charset=UTF-8",
                data: '{"username": "hehe", "password": "123", "age": 30}',
                dataType: "json",
                type: "post",
                success: function (data){
                    // data服务器端相应的json数据
                    alert(data.username);
                    alert(data.password);
                    alert(data.age);
                }
            });
        });
    });
</script>

// 客户端发送ajax请求，data传的是json格式的字符串，封装到User对象中
// 在返回值上加注解ResponseBody，会将对象自动转成json格式发送会ajax回调中
@RequestMapping("/testAjax")
public @ResponseBody User testAjax(@RequestBody User user) {
    // 模拟去数据库查数据
    ...
    return user;
}

5.2 参数绑定

5.2.1 带参数get请求

<a href="param/testParam?username=zhq&password=123">请求参数绑定</a>

// springmvc框架内部会自动进行类型转换
@RequestMapping("/testParam")
public String testParam(String username, String password){
    ...
    return "success";
}

5.2.2 post请求封装到JavaBean对象

<%-- name属性的名称应该与实体类的成员属性名称相同 --%>
<form action="param/saveAccount" method="post">
    姓名：<input type="text" name="username"/><br/>
    密码：<input type="text" name="password"/><br/>
    金额：<input type="text" name="money"/><br/>
    <%-- JavaBean属性是另一个JavaBean的情况 --%>
    用户姓名：<input type="text" name="user.uname"/><br/>
    用户年龄：<input type="text" name="user.age"/><br/>
    <input type="submit" value="提交"/>
</form>

// springmvc框架会自动封装到JavaBean对象中
@RequestMapping("/saveAccount")
public String saveAccount(Account account){
    ...
    return "success";
}

5.2.3 post请求封装复杂属性

<%-- 封装复杂对象 --%>
<form action="param/saveCompli" method="post">
    用户姓名：<input type="text" name="list[0].uname"/><br/>
    用户年龄：<input type="text" name="list[0].age"/><br/>

    用户姓名：<input type="text" name="list[1].uname"/><br/>
    用户年龄：<input type="text" name="list[1].age"/><br/>

    用户姓名：<input type="text" name="map['one'].uname"/><br/>
    用户年龄：<input type="text" name="map['one'].age"/><br/>
    <input type="submit" value="提交"/>
</form>

// springmvc框架会自动封装到JavaBean对象中
@RequestMapping("/saveCompli")
public String saveCompli(Compli compli){
    ...
    return "success";
}

5.2.4 自定义类型转换

<%-- 封装自定义格式类型 --%>
<form action="param/saveUser" method="post">
    用户姓名：<input type="text" name="uname"/><br/>
    用户年龄：<input type="text" name="age"/><br/>
    用户生日：<input type="text" name="date"/><br/>
    <input type="submit" value="提交"/>
</form>

@RequestMapping("/saveUser")
public String saveUser(User user){
    ...
    return "success";
}

// 定义自定义类型转换类
public class String2DateConverter implements Converter<String, Date> {

    @Override
    public Date convert(String s) {
        ...
    }
}

<mvc:annotation-driven conversion-service="conversionServiceFactoryBean"/>

<!-- springmvc.xml中配置自定义类型转换器 -->
<bean id="conversionServiceFactoryBean" class="org.springframework.context.support.ConversionServiceFactoryBean">
    <property name="converters">
        <set>
            <bean class="com.zhq.utils.String2DateConverter"></bean>
        </set>
    </property>
</bean>

5.3 返回值

5.3.1 String返回值

视图解析器拼接跳转路径，跳转至对应页面

5.3.2 void无返回值

例如使用注解RequestMapping("/testVoid")，则会默认跳转到/testVoid路径

5.3.3 ModelAndView返回值

可以设置存储request域中的数据，可以设置跳转页面

@RequestMapping("/testModelAndView")
public ModelAndView testModelAndView() {
    // 模拟从数据库中查询出User对象
    User user = new User();
    ...

    // 创建ModelAndView对象
    ModelAndView mv = new ModelAndView();
    // 把user对象存储至mv对象中，底层也会将对象存入request域中
    mv.addObject("user", user);
    // 设置跳转页面，会使用视图解析器
    mv.setViewName("success");

    return mv;
}

5.4 使用Servlet原生API

<a href="param/testServlet">servlet原生的api</a>

// 直接在参数中增加HttpServletRequest和HttpServletResponse
@RequestMapping("/testServlet")
public String testServlet(HttpServletRequest request, HttpServletResponse response){
    ...
    return "success";
}

5.5 手动跳转页面

@RequestMapping("/testForwardOrRedirect")
public void testForwardOrRedirect(HttpServletRequest request, HttpServletResponse response) throws Exception {
    // 使用请求转发或者重定向，不会经过视图解析器

    // 请求转发
    request.getRequestDispatcher("/WEB-INF/pages/success.jsp").forward(request, response);

    // 重定向，重定向不能访问WEB-INF目录，且需要写项目名称
    response.sendRedirect(request.getContextPath() + "/index.jsp");

    // 直接进行响应，解决中文乱码
    response.setCharacterEncoding("UTF-8");
    response.setContentType("text/html;charset=UTF-8");
    response.getWriter().println("hello");

    return;
}

@RequestMapping("/testForwardOrRedirect")
public String testForwardOrRedirect() {

    // 请求转发
    return "forward:/WEB-INF/pages/success.jsp";
    // 重定向，使用关键字的重定向，框架底层帮我们加了项目名称
    return "redirect:/index.jsp";
}

5.6 Restful风格

多个方法的RequestMapping的请求地址设置一样，但是其他参数（请求方式、占位符，不同），由spring去判断执行哪个方法

6 SpringMVC拦截器

SpringMVC中的拦截器类似Servlet中的过滤器，用于对处理器方法进行预处理和后处理，区别

过滤器是servlet规范的一部分，任何JavaWeb工程都可以使用，拦截器是SpringMVC框架的
过滤器在url-parttern中配置了/*之后，对所有访问的资源拦截，拦截器只会拦截访问控制器的方法

拦截器也是AOP思想的一种实现

拦截器类需要实现HandlerInterceptor接口
preHandle方法：预处理，controller方法执行前执行，return true放行执行下一个拦截器，如果没有拦截器则执行controller方法，return false不放行，则可以使用request或者response跳转到别的页面
postHandle方法：后处理，controller方法执行后执行，也可以使用request或者response跳转到别的页面
afterCompletion方法：controller方法跳转的页面执行后执行
多个拦截器执行顺序：preHandle1，preHandle2，controller，postHandle2，postHandle1，controller跳转页面执行，afterCompletion2，afterCompletion1

public class MyInterceptor1 implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        ...
        return true;
    }
    
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        ...
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        ...
    }
}

在springmvc.xml中配置拦截器

<mvc:interceptors>
    <mvc:interceptor>
        <!-- 要拦截的具体方法 -->
        <mvc:mapping path="/user/**"/>
        <!-- 不要拦截的具体方法 -->
<!--            <mvc:exclude-mapping path=""/>-->
        <!-- 配置拦截器对象 -->
        <bean class="com.zhq.interceptor.MyInterceptor1"></bean>
    </mvc:interceptor>
</mvc:interceptors>

7 SpringMVC异常处理

在SSM开发中，Dao层、Service层、Controller层遇到以上都向前抛出，由SpringMVC的前端控制器捕获，跳转至异常处理器处理

定义异常处理器

需要实现HandlerExceptionResolver接口
覆盖resolveException方法，实现异常处理逻辑
通过ModelAndView设定跳转页面

public class SysExceptionResolver implements HandlerExceptionResolver {

    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object handler, Exception ex) {
        ...
        // 创建ModelAndView
        ModelAndView mv = new ModelAndView();
        ...
        mv.setViewName("error");
        return mv;
    }
}

在springmvc.xml中配置异常处理器

<bean id="sysExceptionResolver" class="com.zhq.exception.SysExceptionResolver"></bean>

8 SpringMVC文件上传

在springmvc.xml中配置文件解析器

<!-- id必须叫做multipartResolver -->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <!-- 最大文件大小 -->
    <property name="maxUploadSize" value="10485760"></property>
</bean>

JSP页面

<form action="file/fileupload2" method="post" enctype="multipart/form-data">
    选择文件：<input type="file" name="upload"/><br/>
    <input type="submit" value="submit"/>
</form>

Controller类方法

// MultipartFile upload的参数名称upload必须和上传input的name相同
@RequestMapping("/fileupload2")
public String fileUpload2(HttpServletRequest request, MultipartFile upload) throws Exception {
    System.out.println("fileUpload2");

    // 指定上传位置
    String path = request.getSession().getServletContext().getRealPath("/uploads/");
    System.out.println(path);
    // 判断该路径是否存在
    File file = new File(path);
    if (!file.exists()){
        file.mkdirs();
        System.out.println("mkdirs");
    }

    // 获取上传文件名称
    String filename = upload.getOriginalFilename();
    // 把文件名称设置成唯一的
    String uuid = UUID.randomUUID().toString().replace("-", "");
    filename = uuid + "_" + filename;
    System.out.println(filename);
    // 文件上传
    upload.transferTo(new File(path, filename));

    return "success";
}

I can丶

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringMVC学习笔记

文章目录1 三层架构2 SpringMVC介绍3 Maven中配置SpringMVC4 配置文件4.1 /WEB-INF/web.xml4.2 resources/springmvc.xml5 Controller控制类5.1 注解5.1.1 RequestMapping注解5.1.2 RequestParam注解5.1.3 RequestBody注解5.1.4 PathVariable注解5.1.5 RequestHeader注解5.1.6 CookieValue注解5.1.7 ModelAttribut
复制链接

扫一扫