• JavaEE开发之SpringMVC框架整合1

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

     

    目录

    一、SpringMVC概述及入门案例

    1.1、SpringMVC概述

    1.2、 SpringMVC入门案例

    1.3、SpringMvc加载bean

    1.4、Postman软件的安装与使用

     二、请求与响应

    2.1、设置请求映射路径 

    2.2、请求参数的传递

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

    2.4、JSON数据传递参数

    2.5、日期类型参数传传递

    2.6、响应


    对于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相关依赖。

    1. "1.0" encoding="UTF-8"?>
    2.  
    3. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.   <modelVersion>4.0.0modelVersion>
    6.  
    7.   <groupId>org.examplegroupId>
    8.   <artifactId>WebMVC1artifactId>
    9.   <version>1.0-SNAPSHOTversion>
    10.   <packaging>warpackaging>
    11.  
    12.   <name>WebMVC1 Maven Webappname>
    13.   
    14.   <url>http://www.example.comurl>
    15.  
    16.   <properties>
    17.     <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    18.     <maven.compiler.source>1.7maven.compiler.source>
    19.     <maven.compiler.target>1.7maven.compiler.target>
    20.   properties>
    21.  
    22.   <dependencies>
    23.     <dependency>
    24.       <groupId>junitgroupId>
    25.       <artifactId>junitartifactId>
    26.       <version>4.11version>
    27.       <scope>testscope>
    28.     dependency>
    29.     <dependency>
    30.       <groupId>org.springframeworkgroupId>
    31.       <artifactId>spring-webmvcartifactId>
    32.       <version>5.2.10.RELEASEversion>
    33.     dependency>
    34.     <dependency>
    35.       <groupId>javax.servletgroupId>
    36.       <artifactId>javax.servlet-apiartifactId>
    37.       <version>3.1.0version>
    38.       <scope>providedscope>
    39.     dependency>
    40.   dependencies>
    41.  
    42.   <build>
    43.     <plugins>
    44.       <plugin>
    45.         <groupId>org.apache.tomcat.mavengroupId>
    46.         <artifactId>tomcat7-maven-pluginartifactId>
    47.         <version>2.1version>
    48.       plugin>
    49.     plugins>
    50.   build>
    51. project>

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

    1. import org.springframework.context.annotation.ComponentScan;
    2. import org.springframework.context.annotation.Configuration;
    3.  
    4. @Configuration
    5. @ComponentScan("com")
    6. public class SpringMvcConfig {
    7.  
    8. }

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

    1. import org.springframework.stereotype.Controller;
    2. import org.springframework.web.bind.annotation.RequestMapping;
    3. import org.springframework.web.bind.annotation.ResponseBody;
    4.  
    5. @Controller
    6. public class UserController {
    7.     @RequestMapping("/save")
    8.     @ResponseBody
    9.     public String save(){
    10.         System.out.println("controller save ...");
    11.         return "{'info':'springMvc}" ;
    12. }
    13. }

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

    1. import org.springframework.web.context.WebApplicationContext;
    2. import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
    3. import org.springframework.web.servlet.support.AbstractDispatcherServletInitializer;
    4.  
    5. public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    6.     @Override
    7.     protected WebApplicationContext createServletApplicationContext() {
    8.         AnnotationConfigWebApplicationContext ac = new AnnotationConfigWebApplicationContext() ;
    9.         ac.register(SpringMvcConfig.class);
    10.         return ac ;
    11.     }
    12.  
    13.     @Override
    14.     protected String[] getServletMappings() {
    15.         return new String[]{"/"};
    16.     }
    17.  
    18.     @Override
    19.     protected WebApplicationContext createRootApplicationContext() {
    20.         return null;
    21.     }
    22. }

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

    1.3、SpringMvc加载bean

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

    方式1：如下

    1. import org.springframework.context.annotation.ComponentScan;
    2. import org.springframework.context.annotation.Configuration;
    3.  
    4. @Configuration
    5. @ComponentScan({"com.dao","com.service"})
    6. public class SpringConfig {
    7. }

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

    1. import org.springframework.context.annotation.ComponentScan;
    2. import org.springframework.context.annotation.Configuration;
    3. import org.springframework.context.annotation.FilterType;
    4. import org.springframework.stereotype.Controller;
    5.  
    6. @Configuration
    7. @ComponentScan(value = "com",excludeFilters = @ComponentScan.Filter
    8.         (type = FilterType.ANNOTATION, classes = Controller.class))
    9. public class SpringConfig {
    10. }

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

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

    1.  
    2. import org.springframework.web.context.WebApplicationContext;
    3. import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
    4. import org.springframework.web.servlet.support.AbstractDispatcherServletInitializer;
    5.  
    6. public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    7.     @Override
    8.     protected WebApplicationContext createServletApplicationContext() {
    9.         AnnotationConfigWebApplicationContext ac = new AnnotationConfigWebApplicationContext() ;
    10.         ac.register(SpringMvcConfig.class);
    11.         return ac ;
    12.     }
    13.  
    14.     @Override
    15.     protected String[] getServletMappings() {
    16.         return new String[]{"/"};
    17.     }
    18.  
    19.     @Override
    20.     protected WebApplicationContext createRootApplicationContext() {
    21.         AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
    22.         ctx.register(SpringConfig.class);
    23.         return ctx;
    24.     }
    25. }

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

    1. import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
    2.  
    3. public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    4.  
    5.     @Override
    6.     protected Class[] getRootConfigClasses() {
    7.         return new Class[]{SpringConfig.class};
    8.     }
    9.  
    10.     @Override
    11.     protected Class[] getServletConfigClasses() {
    12.         return new Class[]{SpringMvcConfig.class};
    13.     }
    14.  
    15.     @Override
    16.     protected String[] getServletMappings() {
    17.         return new String[]{"/"};
    18.     }
    19.  
    20. }

    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

    1. import org.springframework.stereotype.Controller;
    2. import org.springframework.web.bind.annotation.RequestMapping;
    3. import org.springframework.web.bind.annotation.ResponseBody;
    4.  
    5. @Controller
    6. @RequestMapping("/user")
    7. public class UserController {
    8.     @RequestMapping("/save")
    9.     @ResponseBody
    10.     public String save(){
    11.         System.out.println("controller save ...");
    12.         return "{'info':'save}" ;
    13.     }
    14.     @RequestMapping("/delete")
    15.     @ResponseBody
    16.     public String delete(){
    17.         System.out.println("controller delete ...");
    18.         return "{'info':'delete}" ;
    19.     }
    20. }

    2.2、请求参数的传递

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

    postman发送get请求：

     

    接收参数：

    1. import org.springframework.stereotype.Controller;
    2. import org.springframework.web.bind.annotation.RequestMapping;
    3. import org.springframework.web.bind.annotation.ResponseBody;
    4.  
    5. @Controller
    6. public class UserController {
    7.     @RequestMapping("/commonParam")
    8.     @ResponseBody
    9.     public String save(String name,int age){
    10.         System.out.println("姓名" + name);
    11.         System.out.println("年龄" + age);
    12.         return "{'info':'save}" ;
    13.     }
    14. }

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

    1.   
    2.     
    3.       
    4.         org.apache.tomcat.maven
    5.         tomcat7-maven-plugin
    6.         2.1
    7.         
    8.           UTF-8
    9.         
    10.       
    11.     
    12.

    postman发送post请求：

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

    1. import org.springframework.web.filter.CharacterEncodingFilter;
    2. import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
    3.  
    4. import javax.servlet.Filter;
    5.  
    6. public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    7.  
    8.     @Override
    9.     protected Class[] getRootConfigClasses() {
    10.         return new Class[]{SpringConfig.class};
    11.     }
    12.  
    13.     @Override
    14.     protected Class[] getServletConfigClasses() {
    15.         return new Class[]{SpringMvcConfig.class};
    16.     }
    17.  
    18.     @Override
    19.     protected String[] getServletMappings() {
    20.         return new String[]{"/"};
    21.     }
    22.  
    23.     //处理post请求乱码问题
    24.     @Override
    25.     protected Filter[] getServletFilters() {
    26.         CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter() ;
    27.         characterEncodingFilter.setEncoding("utf-8");
    28.         return new Filter[]{characterEncodingFilter} ;
    29.     }
    30. }

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

    1）普通对象参数传递

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

    1. import org.springframework.stereotype.Controller;
    2. import org.springframework.web.bind.annotation.RequestMapping;
    3. import org.springframework.web.bind.annotation.RequestParam;
    4. import org.springframework.web.bind.annotation.ResponseBody;
    5.  
    6. @Controller
    7. public class UserController {
    8.     @RequestMapping("/commonParam")
    9.     @ResponseBody
    10.     public String save(@RequestParam("username") String name, int age){
    11.         System.out.println("姓名" + name);
    12.         System.out.println("年龄" + age);
    13.         return "{'info':'save}" ;
    14.     }
    15. }

    2)pojo对象参数传递

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

    1. public class User {
    2.     private String name ;
    3.     private Integer age ;
    4.     
    5.     public String getName() {
    6.         return name;
    7.     }
    8.  
    9.     public void setName(String name) {
    10.         this.name = name;
    11.     }
    12.  
    13.     public Integer getAge() {
    14.         return age;
    15.     }
    16.  
    17.     public void setAge(Integer age) {
    18.         this.age = age;
    19.     }
    20.  
    21.     @Override
    22.     public String toString() {
    23.         return "User{" +
    24.                 "name='" + name + '\'' +
    25.                 ", age=" + age +
    26.                 '}';
    27.     }
    28. }

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

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

    3）数组对象参数传递

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

    4）集合对象传递参数

    1.    @RequestMapping("/listParam")
    2.     @ResponseBody
    3.     public String listParam(@RequestParam List likes){
    4.         System.out.println(likes);
    5.         return "{'info':'pojo}" ;
    6.     }

    5）pojo嵌套类

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

    1. public class Address {
    2.     private String province ;
    3.     private String city ;
    4.  
    5.     public String getProvince() {
    6.         return province;
    7.     }
    8.  
    9.     public void setProvince(String province) {
    10.         this.province = province;
    11.     }
    12.  
    13.     public String getCity() {
    14.         return city;
    15.     }
    16.  
    17.     public void setCity(String city) {
    18.         this.city = city;
    19.     }
    20.  
    21.     @Override
    22.     public String toString() {
    23.         return "Address{" +
    24.                 "province='" + province + '\'' +
    25.                 ", city='" + city + '\'' +
    26.                 '}';
    27.     }
    28. }

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

    1.  
    2. public class User {
    3.     private String name ;
    4.     private Integer age ;
    5.     private Address address ;
    6.  
    7.     public Address getAddress() {
    8.         return address;
    9.     }
    10.  
    11.     public void setAddress(Address address) {
    12.         this.address = address;
    13.     }
    14.  
    15.     public String getName() {
    16.         return name;
    17.     }
    18.  
    19.     public void setName(String name) {
    20.         this.name = name;
    21.     }
    22.  
    23.     public Integer getAge() {
    24.         return age;
    25.     }
    26.  
    27.     public void setAge(Integer age) {
    28.         this.age = age;
    29.     }
    30.  
    31.     @Override
    32.     public String toString() {
    33.         return "User{" +
    34.                 "name='" + name + '\'' +
    35.                 ", age=" + age +
    36.                 ", address=" + address +
    37.                 '}';
    38.     }
    39. }

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

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

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

    2.4、JSON数据传递参数

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

    1.   <dependency>
    2.       <groupId>com.fasterxml.jackson.coregroupId>
    3.       <artifactId>jackson-databindartifactId>
    4.       <version>2.9.0version>
    5.     dependency>

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

    1. import org.springframework.context.annotation.ComponentScan;
    2. import org.springframework.context.annotation.Configuration;
    3. import org.springframework.web.servlet.config.annotation.EnableWebMvc;
    4.  
    5. @Configuration
    6. //开启json数据类型自动转换
    7. @EnableWebMvc
    8. @ComponentScan("com.controller")
    9. public class SpringMvcConfig {
    10. }

    3）参数前添加@RequestBody

    1.    @RequestMapping("/listParam")
    2.     @ResponseBody
    3.     public String listParam(@RequestBody List likes){
    4.         System.out.println(likes);
    5.         return "{'info':'pojo}" ;
    6.     }

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

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

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

    2.5、日期类型参数传传递

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

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

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

    2.6、响应

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

    1.  
    2.     @RequestMapping("/JumpPage")
    3.     public String JumpPage(){
    4.         return "newPage.jsp" ;
    5.     }

    2）返回文本内容

    1.    @RequestMapping("/ToText")
    2.     @ResponseBody
    3.     public String ToText(){
    4.         return "hello world" ;
    5.     }

    3）响应json数据

    1.     @RequestMapping("/ToJson")
    2.     @ResponseBody
    3.     public User ToJson(){
    4.         User user = new User() ;
    5.         user.setName("张三");
    6.         user.setAge(19);
    7.         return user ;
    8.     }

    4）响应POJO集合对象

    1.     @RequestMapping("/toJsonList")
    2.     @ResponseBody
    3.     public List toJsonList(){
    4.         User user1 = new User() ;
    5.         user1.setName("张三");
    6.         user1.setAge(12);
    7.         Address address = new Address() ;
    8.         address.setProvince("安徽省");
    9.         address.setCity("合肥市");
    10.         user1.setAddress(address);
    11.         User user2 = new User() ;
    12.         user2.setName("李四");
    13.         user2.setAge(32);
    14.         Address address1 = new Address() ;
    15.         address1.setProvince("江苏省");
    16.         address1.setCity("南京市");
    17.         user2.setAddress(address1);
    18.         List list = new ArrayList<>() ;
    19.         list.add(user1) ;
    20.         list.add(user2) ;
    21.         return list ;
    22.  
    23.     }
  • 相关阅读:
    电脑想加个WIFI功能，怎么选！
    apt-get install 本地私有仓库创建
    5分钟看明白rust mod use
    浅谈新生代为什么要分三块区域并且比例为什么是8:1:1
    WebSocket 详细教程
    自动创建表分区存储
    二叉树结构以及堆结构基础
    关于 在国产麒麟系统上使用QProcess配合管道命令执行shell命令获取预期结果输出失败 的解决方法
    Chrome 浏览器关闭后再打开，需要重新登录账号，解决办法
    手写call(),apply(),bind()方法
  • 原文地址：https://blog.csdn.net/nuist_NJUPT/article/details/126631429