JavaEE开发之SpringMVC框架整合1

最新推荐文章于 2023-01-08 18:44:10 发布

nuist__NJUPT

最新推荐文章于 2023-01-08 18:44:10 发布

阅读量363

点赞数 1

分类专栏： SSM框架整合文章标签： java-ee java spring SpringMVC mybatis

本文链接：https://blog.csdn.net/nuist_NJUPT/article/details/126631429

版权

SSM框架整合专栏收录该内容

45 篇文章 4 订阅

订阅专栏

SpringMVC是处于Web层的框架，所以其主要的作用就是用来接收前端发过来的请求和数据然后经过处理并将处理的结果响应给前端，所以如何处理请求和响应是SpringMVC中非常重要的一块内容。REST是一种软件架构风格，可以降低开发的复杂性，提高系统的可伸缩性，后期的应用也是非常广泛。SSM整合是把咱们所学习的SpringMVC+Spring+Mybatis整合在一起来完成业务开发，是对我们所学习这三个框架的一个综合应用。

对于SpringMVC的学习，最终要达成的目标:
1. 掌握基于SpringMVC获取请求参数和响应json数据操作
2. 熟练应用基于REST风格的请求路径设置与参数传递
3. 能够根据实际业务建立前后端开发通信协议并进行实现
4. 基于SSM整合技术开发任意业务模块功能

一、SpringMVC概述及入门案例

1.1、SpringMVC概述

SpringMVC是处于Web层的框架，所以其主要的作用就是用来接收前端发过来的请求和数据然后经过处理并将处理的结果响应给前端，SpringMVC就是途中的Controller部分。

1.2、 SpringMVC入门案例

1）首先创建maven项目的web项目，在pom.xml中导入springMVC相关依赖。

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.example</groupId>
  <artifactId>WebMVC1</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>WebMVC1 Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.10.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.1</version>
      </plugin>
    </plugins>
  </build>
</project>

2）创建spring配置类，对指定的包进行扫描。

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com")
public class SpringMvcConfig {

}

3）创建controller类，在该层完后请求并给出响应。

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

@Controller
public class UserController {
    @RequestMapping("/save")
    @ResponseBody
    public String save(){
        System.out.println("controller save ...");
        return "{'info':'springMvc}" ;
}
}

4）使用配置类替代web.xml文件去设置配置文件的位置以及控制器的请求映射路径。

import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.support.AbstractDispatcherServletInitializer;

public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    @Override
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext ac = new AnnotationConfigWebApplicationContext() ;
        ac.register(SpringMvcConfig.class);
        return ac ;
    }

    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    @Override
    protected WebApplicationContext createRootApplicationContext() {
        return null;
    }
}

5）配置tomcat，启动运行，并在浏览器访问即可。

1.3、SpringMvc加载bean

加载Spring控制的bean的时候排除掉SpringMVC控制的bean。
具体该如何排除：
方式一:Spring加载的bean设定扫描范围为精准范围，例如service包、dao包等。
方式二:Spring加载的bean设定扫描范围为com,排除掉controller包中的bean。

方式1：如下

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan({"com.dao","com.service"})
public class SpringConfig {
}

方式2：如下，这种方式需要把SpringMVC的@Configration的注解去掉，防止排除失败

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;

@Configuration
@ComponentScan(value = "com",excludeFilters = @ComponentScan.Filter
        (type = FilterType.ANNOTATION, classes = Controller.class))
public class SpringConfig {
}

对于加载springMVC的配置文件和Spring的配置文件，可以使用如下两种方式：

方式1：继承AbstractDispatcherServletInitializer类并重写响应方法。


import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.support.AbstractDispatcherServletInitializer;

public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    @Override
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext ac = new AnnotationConfigWebApplicationContext() ;
        ac.register(SpringMvcConfig.class);
        return ac ;
    }

    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    @Override
    protected WebApplicationContext createRootApplicationContext() {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(SpringConfig.class);
        return ctx;
    }
}

方式2：继承AbstractAnnotationConfigDispatcherServletInitializer类并重写相应方法。

import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

}

1.4、Postman软件的安装与使用

Postman软件是用于模拟浏览器发送请求的，常用于进行接口测试。

1）直接下载exe文件，打开即安装，注册一个账号，登录后打开工作空间，在工作空间创建Collectin用于后面的使用。

2）在输入框输入地址，模拟浏览器发送请求即可，如下：

3）可以对请求进行命名并保存，如下：

二、请求与响应

2.1、设置请求映射路径

当类上和方法上都添加了 @RequestMapping 注解，前端发送请求的时候，要和两个注解的value
值相加匹配才能访问到。@RequestMapping注解value属性前面加不加 / 都可以

使用如下链接访问save方法：http://localhost/user/save

使用如下方法访问delete方法：http://localhost/user/delete

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

@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/save")
    @ResponseBody
    public String save(){
        System.out.println("controller save ...");
        return "{'info':'save}" ;
    }
    @RequestMapping("/delete")
    @ResponseBody
    public String delete(){
        System.out.println("controller delete ...");
        return "{'info':'delete}" ;
    }
}

2.2、请求参数的传递

请求路径设置好后，只要确保页面发送请求地址和后台Controller类中配置的路径一致，就可以接
收到前端的请求，接收到请求后，如何接收页面传递的参数?
关于请求参数的传递与接收是和请求方式有关系的，目前比较常见的两种请求方式为：GET和POST，针对于不同的请求前端如何发送，后端如何接收?

postman发送get请求：

接收参数：

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

@Controller
public class UserController {
    @RequestMapping("/commonParam")
    @ResponseBody
    public String save(String name,int age){
        System.out.println("姓名" + name);
        System.out.println("年龄" + age);
        return "{'info':'save}" ;
    }
}

处理get请求的中文参数乱码问题，需要配置tomcat的访问路径编码字符集。

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.1</version>
        <configuration>
          <uriEncoding>UTF-8</uriEncoding><!--访问路径编解码字符集-->
        </configuration>
      </plugin>
    </plugins>
  </build>

postman发送post请求：

处理post请求中文乱码问题，通过重写过滤器方法，设置编码方式，如下：

import org.springframework.web.filter.CharacterEncodingFilter;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

import javax.servlet.Filter;

public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    //处理post请求乱码问题
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter() ;
        characterEncodingFilter.setEncoding("utf-8");
        return new Filter[]{characterEncodingFilter} ;
    }
}

2.3、常见5种类型的参数传递

1）普通对象参数传递

对于普通对象的传递，直接对应形参值传递即可，当请求参数和形参不一样时，可以用@RequestParam注解绑定参数。

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

@Controller
public class UserController {
    @RequestMapping("/commonParam")
    @ResponseBody
    public String save(@RequestParam("username") String name, int age){
        System.out.println("姓名" + name);
        System.out.println("年龄" + age);
        return "{'info':'save}" ;
    }
}

2)pojo对象参数传递

首先创建一个java实体对象user类，如下：

public class User {
    private String name ;
    private Integer age ;
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

在userController中使用实体类直接接收对象，如下：

    @RequestMapping("/pojoParam")
    @ResponseBody
    public String pojoParam(User user){
        System.out.println("姓名" + user.getName());
        System.out.println("年龄" + user.getAge());
        return "{'info':'pojo}" ;
    }

3）数组对象参数传递

   @RequestMapping("/arrayParam")
    @ResponseBody
    public String arrayParam(String [] likes){
        System.out.println(Arrays.toString(likes));
        return "{'info':'pojo}" ;
    }

4）集合对象传递参数

   @RequestMapping("/listParam")
    @ResponseBody
    public String listParam(@RequestParam List<String> likes){
        System.out.println(likes);
        return "{'info':'pojo}" ;
    }

5）pojo嵌套类

首先创建一个被嵌套的实体类，如下：

public class Address {
    private String province ;
    private String city ;

    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    @Override
    public String toString() {
        return "Address{" +
                "province='" + province + '\'' +
                ", city='" + city + '\'' +
                '}';
    }
}

然后在实体类User中，引入Address对象，如下：


public class User {
    private String name ;
    private Integer age ;
    private Address address ;

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address=" + address +
                '}';
    }
}

最后，正常接收参数即可，如下：

    @RequestMapping("/pojoParam1")
    @ResponseBody
    public String pojoParam1(User user){
        System.out.println(user);
        return "{'info':'pojo}" ;
    }

使用postman发送请求的方式如下，对于嵌套的需要写到具体的变量名：

2.4、JSON数据传递参数

1）SpringMVC默认使用的是jackson来处理json的转换，所以需要在pom.xml添加jackson依赖。

  <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.0</version>
    </dependency>

2）在SpringMVC的配置类中开启SpringMVC的注解支持，这里面就包含了将JSON转换成对象的功能。

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;

@Configuration
//开启json数据类型自动转换
@EnableWebMvc
@ComponentScan("com.controller")
public class SpringMvcConfig {
}

3）参数前添加@RequestBody

   @RequestMapping("/listParam")
    @ResponseBody
    public String listParam(@RequestBody List<String> likes){
        System.out.println(likes);
        return "{'info':'pojo}" ;
    }

4）发送json数据请求，获取相应数据：

@RequestBody与@RequestParam区别：
@RequestParam用于接收url地址传参，表单传参【application/x-www-form-urlencoded】
@RequestBody用于接收json数据【application/json】

后期开发中，发送json格式数据为主，@RequestBody应用较广
如果发送非json格式数据，选用@RequestParam接收请求参数

2.5、日期类型参数传传递

1）postman模拟发送日期请求：

2）接收请求，分别是按默认格式接收和按指定格式接收，如下：

  @RequestMapping("/dataParam")
    @ResponseBody
    public String dataParam(Date date,
                            @DateTimeFormat(pattern="yyyy-MM-dd") Date date1,
                            @DateTimeFormat(pattern="yyyy/MM/dd HH:mm:ss") Date
                                    date2){
        System.out.println("参数传递 date ==> "+date);
        System.out.println("参数传递 date1(yyyy-MM-dd) ==> "+date1);
        System.out.println("参数传递 date2(yyyy/MM/dd HH:mm:ss) ==> "+date2);
        return "{'module':'data param'}";
    }

2.6、响应

1）页面响应,页面跳转，直接return页面的字符串形式即可。


    @RequestMapping("/JumpPage")
    public String JumpPage(){
        return "newPage.jsp" ;
    }

2）返回文本内容

   @RequestMapping("/ToText")
    @ResponseBody
    public String ToText(){
        return "hello world" ;
    }

3）响应json数据

    @RequestMapping("/ToJson")
    @ResponseBody
    public User ToJson(){
        User user = new User() ;
        user.setName("张三");
        user.setAge(19);
        return user ;
    }

4）响应POJO集合对象

    @RequestMapping("/toJsonList")
    @ResponseBody
    public List<User> toJsonList(){
        User user1 = new User() ;
        user1.setName("张三");
        user1.setAge(12);
        Address address = new Address() ;
        address.setProvince("安徽省");
        address.setCity("合肥市");
        user1.setAddress(address);
        User user2 = new User() ;
        user2.setName("李四");
        user2.setAge(32);
        Address address1 = new Address() ;
        address1.setProvince("江苏省");
        address1.setCity("南京市");
        user2.setAddress(address1);
        List<User> list = new ArrayList<>() ;
        list.add(user1) ;
        list.add(user2) ;
        return list ;

    }

nuist__NJUPT

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
JavaEE开发之SpringMVC框架整合1

SpringMVC是处于Web层的框架，所以其主要的作用就是用来接收前端发过来的请求和数据然后经过处理并将处理的结果响应给前端，SpringMVC就是途中的Controller部分。
复制链接

扫一扫