SpringMVC学习笔记

最新推荐文章于 2024-07-14 22:26:46 发布

一个不会编程的程序猿

最新推荐文章于 2024-07-14 22:26:46 发布

阅读量100

点赞数

分类专栏： ssm框架 Java 文章标签： java spring intellij idea

本文链接：https://blog.csdn.net/qq_41935652/article/details/114332753

版权

Java 同时被 2 个专栏收录

10 篇文章 0 订阅

订阅专栏

ssm框架

4 篇文章 0 订阅

订阅专栏

SpringMVC学习笔记

文章目录

- SpringMVC学习笔记

1、HelloMVC

原理和配置版开发用不到，面试用到的，这里不多记录。

用开发中常用的注解方式实现！

新建空的Maven工程，建立子Module工程

将新建的子项目用idea右键单击Add Framework Support，选择Web Application即可。

在父项目pom.xml中导入相关依赖及静态资源过滤代码

<!--添加依赖-->
<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.2</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>2.5</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.1</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>
</dependencies>


<!--静态资源过滤问题-->
<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>

由于SpringMVC也是约定大于配置的，所以配置通用代码。

先后配置WEB-INF下的web.xml、在src->main->resources下自己手动创建的springmvc-servlet.xml

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">

  <!--注册DispatchServlet-->
  <servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--关联一个springmvc的配置文件:springmvc-servlet.xml-->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc-servlet.xml</param-value>
    </init-param>
    <!--启动级别-1-->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <!--"/"表示匹配除了.jsp的所有的请求；（不包括.jsp）-->
    <!--"/*"表示匹配所有的请求；（包括.jsp）-->
    <url-pattern>/</url-pattern>
  </servlet-mapping>

</web-app>

springmvc-servlet.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">

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


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

</beans>

上面的包名和前缀后缀视情况更改

在java下新建com.ljh.controller，建立HelloController类

package com.ljh.controller;

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

@Controller
public class HelloController {
  //在网址后添加/h1访问
  @RequestMapping("/h1")
  public String test(Model model) {
    model.addAttribute("msg","HelloControllerYa!");
    return "hello";//拼接出/WEB-INF/jsp/hello.jsp
  }
}

配置Tomcat，启动。

访问http://localhost:8080/h1，出现 HelloControllerYa!

访问路径：http://localhost:8080 / 项目名 / h1

报错：404，源服务器未能找到目标资源的表示或者是不愿公开一个已经存在的资源表示。

解决方法如下：

在这里插入图片描述

2、RestFul风格

传统方式操作资源 ：通过不同的参数来实现不同的效果！方法单一，post 和 get

http://127.0.0.1/item/queryItem.action?id=1 查询,GET

http://127.0.0.1/item/saveItem.action 新增,POST

http://127.0.0.1/item/updateItem.action 更新,POST

http://127.0.0.1/item/deleteItem.action?id=1 删除,GET或POST

使用RestFul操作资源 ：可以通过不同的请求方式来实现不同的效果！如下：请求地址一样，但是功能可以不同！

http://127.0.0.1/item/1 查询,GET

http://127.0.0.1/item 新增,POST

http://127.0.0.1/item 更新,PUT

http://127.0.0.1/item/1 删除,DELETE

在controller下新建RestFulController类

package com.ljh.controller;

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

@Controller
public class RestFulController {

  @RequestMapping("/add/{a}/{b}")
  public String test(@PathVariable int a,@PathVariable int b, Model model) {

    int result = a + b;
    model.addAttribute("msg","结果为："+result);

    return "hello";
  }
}

在地址栏输入http://localhost:8080/add/1/22会出现 “结果为：23”

上述代码的return默认为一个转发，若写为return "redirect:/index.jsp"会重定向到index.jsp的页面

在Spring MVC中可以使用 @PathVariable 注解，让方法参数的值对应绑定到一个URI模板变量上。

@RequestMapping("/add/{a}/{b}")中{a}不要写成${a}

@RequestMapping("/add/{a}/{b}")相当于@RequestMapping(value = “/add/{a}/{b}”,method = RequestMethod.GET)

所有的地址栏请求默认都会是 HTTP GET 类型的。

方法级别的注解变体有如下几个：

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

@GetMapping 是一个组合注解，平时使用的会比较多！

3、数据处理

3.1、提交的域名称和处理方法的参数名一致

@GetMapping("/r1")
public String test(String name, Model model) {
    System.out.println("输出："+name);
    model.addAttribute("msg",name);
    return "hello";
}

访问：http://localhost:8080/r1?name=ljh

前端显示：ljh

3.2、提交的域名称和处理方法的参数名不一致

//@RequestParam("username") : username提交的域的名称
@GetMapping("/r1")
public String test(@RequestParam("username") String name, Model model) {
    System.out.println("输出："+name);
    model.addAttribute("msg",name);
    return "hello";
}

访问http://localhost:8080/r1?username=ljh

前端显示：ljh

只需要加 @RequestParam(“xxx”) 就可以用username来访问值

做项目时最好加上便于了解这是前端的数据

3.3、提交的是一个对象

要求提交的表单域和对象的属性名一致 , 参数使用对象即可

新建com.ljh.pojo，新建User实体类

public class User {
  private int id;
  private String name;
  private int age;
  //get、set、toString、有参无参构造
}

controller

@GetMapping("/r2")
public String test2(User user,Model model) {
    System.out.println("输出："+user);
    model.addAttribute("msg",user);
    return "hello";
}

地址输入：http://localhost:8080/r2?id=1&name=ljh&age=17

前端页面显示： User{id=1, name=‘ljh’, age=17}

注意：如果使用对象的话，前端传递的参数名和对象名必须一致，否则就是null。

4、乱码问题

在web目录下新建login.jsp，不要在WEB-INF的jsp下创建jsp，直接访问不到

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="/e" method="post">
    <input type="text" name="name">
    <input type="submit">
</form>
</body>
</html>

新建EncodingController

package com.ljh.controller;

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

@Controller
public class EncodingController {

  @RequestMapping("/e")
  public String test(String name, Model model) {

    System.out.println(name);
    model.addAttribute("msg",name);
    return "hello";
  }
}

登录页输入中文提交后，前端显示会乱码，其实在后端就已经是乱码了

解决方法： SpringMVC给我们提供了一个过滤器 , 可以在web.xml中配置如下代码。

<!--配置SpringMVC的乱码过滤-->
<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>

5、Json交互

5.1、stringify 和 parse

要实现从JSON字符串转换为JavaScript 对象，使用 JSON.parse() 方法

要实现从JavaScript 对象转换为JSON字符串，使用 JSON.stringify() 方法

5.2、Controller返回JSON数据-jackson

在原先基础上在pom.xml中添加依赖

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.11.3</version>
</dependency>

注意：不要忘了在项目结构中添加lib及添加lib中的所有依赖！

前提：已有User实体类和前面所需配置

新建JsonController类

单个对象

@Controller
public class JsonController {

  @RequestMapping(value = "/j1",produces = "application/json;charset=utf-8")
  @ResponseBody
  public String json1() throws JsonProcessingException {
	//创建一个jackson的对象映射器，用来解析数据
    ObjectMapper mapper = new ObjectMapper();
    User user = new User(1,"李白",18);
    //将对象解析成为json格式
    String str = mapper.writeValueAsString(user);
    return str;
  }
}

注意：

@ResponseBody:不会走视图解析器，会直接返回一个字符串

@Controller会自动走视图解析器

@RestController不会走视图解析器，会直接返回一个字符串

如果要返回Json格式，可以把@Controller直接替换为@RestController，不用加@ResponseBody

上面@RequestMapping(value = “/j1”,produces = “application/json;charset=utf-8”)虽然也能解决乱码，但是每次写太麻烦，只需要在springmvc-servlet.xml中加入下面代码：

<mvc:annotation-driven>
   <mvc:message-converters register-defaults="true">
       <bean class="org.springframework.http.converter.StringHttpMessageConverter">
           <constructor-arg value="UTF-8"/>
       </bean>
       <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
           <property name="objectMapper">
               <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                   <property name="failOnEmptyBeans" value="false"/>
               </bean>
           </property>
       </bean>
   </mvc:message-converters>
</mvc:annotation-driven>

多个对象集合输出json格式

@RestController
public class JsonController {

  //单个对象
  @RequestMapping("/j1")
  public String json1() throws JsonProcessingException {

    ObjectMapper mapper = new ObjectMapper();
    User user = new User(1,"李白",18);
    return mapper.writeValueAsString(user);
  }
  //多个对象以集合List方式
  @RequestMapping("/j2")
  public String json2() throws JsonProcessingException {

    ObjectMapper mapper = new ObjectMapper();
    User user = new User(1,"李白",18);
    User user2 = new User(2,"李白",18);
    User user3 = new User(3,"李白",18);
    User user4 = new User(4,"李白",18);
    List<User> users = new ArrayList<User>();
    users.add(user);
    users.add(user2);
    users.add(user3);
    users.add(user4);
    return mapper.writeValueAsString(users);
  }
}

输出时间对象

@RequestMapping("/j3")
public String json3() throws JsonProcessingException {

    ObjectMapper mapper = new ObjectMapper();
    
    //不使用时间戳的方式
    mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
    //自定义日期格式对象
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
    //指定日期格式
    mapper.setDateFormat(sdf);

    Date date = new Date();
    return mapper.writeValueAsString(date);
}

前端显示： “2021年02月02日 20:29:36”

5.3、封装json工具类

com.ljh.utils新建JsonUtils类

package com.ljh.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

import java.text.SimpleDateFormat;

public class JsonUtils {

  public static String getJson(Object object) {
    //设置默认日期格式为"yyyy年MM月dd日 HH:mm:ss"
    return getJson(object,"yyyy年MM月dd日 HH:mm:ss");
  }

  /**
   *获取Json的工具类
   * @param object 确定特定格式转换为json
   * @param dateFormat 日期格式
   * @return 返回一个Json字符串
   */
  public static String getJson(Object object, String dateFormat) {
    ObjectMapper mapper = new ObjectMapper();
    //不使用时间戳的方式
    mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
    //自定义日期格式对象,dateFormat为日期格式
    SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
    //指定日期格式
    mapper.setDateFormat(sdf);

    try {
      return mapper.writeValueAsString(object);
    } catch (JsonProcessingException e) {
      e.printStackTrace();
    }
    return null;
  }
}

使用

@RestController
public class JsonController {

  @RequestMapping("/j4")
  public String json4() throws JsonProcessingException {

    User user = new User(1, "小白", 26);
    User user1 = new User(2, "小白", 28);
    User user2 = new User(13, "小白", 26);
    User user3 = new User(14, "小白", 86);
    ArrayList<User> users = new ArrayList<User>();
    users.add(user);
    users.add(user1);
    users.add(user2);
    users.add(user3);

    return JsonUtils.getJson(users);
  }

  @RequestMapping("/j5")
  public String json5() throws JsonProcessingException {

    Date date = new Date();
    String dateFormat = "yyyy-MM-dd HH:mm:ss";
    return JsonUtils.getJson(date, dateFormat);//"2021-02-02 20:59:40"
  }
}

5.4、fastjson

导入依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.75</version>
</dependency>

fastjson 三个主要的类：

JSONObject 代表 json 对象
JSONArray 代表 json 对象数组
JSON代表 JSONObject和JSONArray的转化

@RequestMapping("/j1")
public String json1() throws JsonProcessingException {

    User user = new User(1, "李白", 18);
    return JSON.toJSONString(user);
}

@RequestMapping("/j2")
public String json2() throws JsonProcessingException {

    User user = new User(1, "李白", 18);
    User user2 = new User(2, "李白", 18);
    User user3 = new User(3, "李白", 18);
    User user4 = new User(4, "李白", 18);
    List<User> users = new ArrayList<User>();
    users.add(user);
    users.add(user2);
    users.add(user3);
    users.add(user4);
    return JSON.toJSONString(users);
}

@RequestMapping("/j3")
public String json3() throws JsonProcessingException {

    Date date = new Date();
    return JSON.toJSONStringWithDateFormat(date,"yyyy-MM-dd HH:mm:ss");
}

一个不会编程的程序猿

关注

0
点赞
踩
0

收藏

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

SpringMVC学习笔记1、HelloMVC原理和配置版开发用不到，面试用到的，这里不多记录。用开发中常用的注解方式实现！新建空的Maven工程，建立子Module工程将新建的子项目用idea右键单击Add Framework Support，选择Web Application即可。在父项目pom.xml中导入相关依赖及静态资源过滤代码<dependencies> <dependency> <group
复制链接

扫一扫