springMVC框架——框架搭建——简单介绍——特有注解——参数获取——响应正文和页面跳转

最新推荐文章于 2023-08-12 14:30:44 发布
最新推荐文章于 2023-08-12 14:30:44 发布
阅读量301 收藏 2
点赞数
分类专栏： SSM 文章标签： springMVC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Eiffel_Wu/article/details/101419594
版权

springMVC框架

一、SSM框架搭建
1、pom.xml
<?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>com.java.SpringMVC</groupId>
  <artifactId>SpringMVC</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>SpringMVC 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.12</version>
      <scope>test</scope>
    </dependency>

    <!--1.MyBatis-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.4.6</version>
    </dependency>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.0</version>
    </dependency>
    <!--2.Spring-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>4.2.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.2.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>4.2.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.2.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>4.2.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>4.2.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>4.2.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>4.2.5.RELEASE</version>
    </dependency>
    <!--3.SpringMvc-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>4.2.5.RELEASE</version>
    </dependency>
    <!--4.c3p0-->
    <dependency>
      <groupId>com.mchange</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.5.2</version>
    </dependency>
    <!--pojo转换成 json -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.7.3</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.7.3</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.7.3</version>
    </dependency>

    <!--servlet 2.5 -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
      <!--此处的servlet仅在编译和测试的时候使用，运行的时候不使用，使用的是tomcat中的servlet-->
      <scope>provided</scope>
    </dependency>
    <!--IO流 -->
    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.4</version>
    </dependency>

  </dependencies>

  <build>
    <finalName>SpringMVC</finalName>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
        <configuration>
          <path>/</path>
          <port>8080</port>
          <!--请求和响应编码-->
          <uriEncoding>UTF-8</uriEncoding>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>
2、web.xml
<?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">

  <!-- 加载spring配置文件 -->
  <!-- 关联到spring主配置文件的路径地址  classpath根目录-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>

  <!-- 配置监听器加载spring的配置文件 -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

  <!-- 配置过滤器，过滤编码格式 为utf-8,只支持post提交-->
  <filter>
    <filter-name>CharacterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <!--异步支持  -->
    <async-supported>true</async-supported>
    <!-- 初始化编码格式为UTF-8,只适用于post提交-->
    <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>

  <!-- 加载springmvc配置文件 -->
  <!-- 配置DispatcherServlet，来加载springmvc的配置 -->
  <servlet>
    <servlet-name>DispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springMVC.xml</param-value>
    </init-param>
    <!-- 启动优先加载 -->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>DispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

  <!-- / 和 /* 的区别：
  / ：匹配不带后缀名的servlet路径
  /* ：匹配的是所有的路径 -->

</web-app>
3、spring核心配置文件：applicationContext.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:tx="http://www.springframework.org/schema/tx"
       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/tx
        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">

    <!--1.开启spring注解驱动-->
    <context:component-scan base-package="com.java.service"/>

    <!-- 2.读取properties -->
    <context:property-placeholder location="classpath:db.properties"/>

    <!--3. 配置数据库连接池 c3p0 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${driver}"/>
        <property name="jdbcUrl" value="${url}"/>
        <property name="user" value="${username}"/>
        <property name="password" value="${password}"/>
    </bean>

    <!--配置事务管理器-->
    <bean id="tx" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 事务管理数据库连接池 -->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--5. 开启事务的注解驱动 -->
    <tx:annotation-driven transaction-manager="tx"/>

    <!-- 6.spring管理mybatis配置文件 -->
    <bean id="fb" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--dataSource属性指定要用到的连接池，ref映射的是id=dataSource的bean标签，读取连接数据库信息-->
        <property name="dataSource" ref="dataSource"/>
        <!--configLocation属性指定mybatis的核心配置文件，管理mybatis配置文件-->
        <property name="configLocation" value="classpath:sqlMapConfig.xml"/>
        <!-- 所有配置的mapper文件,mybatis的实体类配置文件所有的sql映射文件 -->
        <!--<property name="mapperLocations" value="classpath:mapper/*.xml"/>-->
    </bean>

    <!-- 7.spring管理mybatis映射接口和sql映射文件之间关联关系 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--指定mapper接口的路径-->
        <property name="basePackage" value="com.java.mapper"/>
        <property name="sqlSessionTemplateBeanName" value="fb"/>
    </bean>

</beans>
4、springMVC核心配置文件：springMVC.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:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       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">

    <!--开启controller层类的注解-->
    <context:component-scan base-package="com.java.controller"/>

    <!--开启springMVC自己的注解-->
    <mvc:annotation-driven>
        <!--设置响应编码：String、json-->
        <mvc:message-converters>
            <!--解决@responsebody响应中文乱码-->
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <constructor-arg value="UTF-8"/>
            </bean>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
        </mvc:message-converters>
    </mvc:annotation-driven>

    <!--和web.xml的mvc配置呼应-->
    <mvc:default-servlet-handler/>

    <!-- 处理jsp页面所在的前缀和后缀 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 前缀,确定当前访问的页面路径地址 -->
        <property name="prefix" value="/WEB-INF/page/jsp/"/>
        <!-- 后缀,确定要访问的文件类型 -->
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>
5、mybatis核心配置文件：sqlMapConfig.xml
<?xml version="1.0"   encoding="UTF-8"?>
<!DOCTYPE configuration   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <settings>
        <!-- 可以在控制台输出日志信息：sql语句和参数 -->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
    <!-- 表示类型别名 库-->
    <typeAliases>
        <!-- 每一个类型的别名  type属性表示别名对应的类型地址 alias表示起的别名-->
        <typeAlias type="java.util.List" alias="list"/>
        <!-- package表示包，利用包的形式进行扫描包之下的所有的类，别名就是当前类名 -->
        <package name="com.java.entity"/>
    </typeAliases>

</configuration>
6、db.properties
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/asset
username=root
password=Root
二、SpringMVC知识
1、Spring和SpringMVC关系

  1. Spring是IOC和AOP的容器框架，SpringMVC是基于Spring功能之上添加的Web框架，想用SpringMVC必须先依赖Spring。 简单讲的话可以将SpringMVC类比于servlet。

  2. Spring可以说是一个管理bean的容器，也可以说是包括很多开源项目的总称，SpringMVC是其中一个开源项目，所以简单走个流程的话，http请求一到，由容器（如：tomact）解析http搞成一个request，通过映射关系（路径，方法，参数）被SpringMVC一个分发器去找到可以处理这个请求的bean，那tomcat里面就有spring管理bean的一个池子（bean容器）里面找到，处理完了就把响应返回回去。

  3. SpringMVC是一个MVC模式的WEB开发框架。

  4. Spring是一个通用解决方案，最大的用处就是通过LOC/AOP解耦，降低软件复杂性， 所以Spring可以结合SpringMVC等很多其他解决方案一起使用，不仅仅只适用于WEB开发。

2、DispatcherServlet 处理流程

在整个 SpringMVC 框架中，DispatcherServlet 处于核心位置，它负责协调和组织不同组件完成请求处理并返回响应工作。我们看一下请求处理的大致流程：

  1. Tomcat 启动，对 DispatcherServlet 进行实例化，然后调用它的 init() 方法进行初始化，在这个初始化过程中完成了：
    • 对 web.xml 中初始化参数的加载；
    • 建立 WebApplicationContext (SpringMVC的IOC容器)；
    • 进行组件的初始化；
  2. 客户端发出请求，由 Tomcat 接收到这个请求，如果匹配 DispatcherServlet 在 web.xml 中配置的映射路径，Tomcat 就将请求转交给 DispatcherServlet 处理；
  3. DispatcherServlet 从容器中取出所有 HandlerMapping 实例（每个实例对应一个 HandlerMapping 接口的实现类）并遍历，每个 HandlerMapping 会根据请求信息，通过自己实现类中的方式去找到处理该请求的 Handler (执行程序，如Controller中的方法)，并且将这个 Handler 与一堆 HandlerInterceptor (拦截器) 封装成一个 HandlerExecutionChain 对象，一旦有一个 HandlerMapping 可以找到 Handler 则退出循环；
  4. DispatcherServlet 取出 HandlerAdapter 组件，根据已经找到的 Handler，再从所有 HandlerAdapter 中找到可以处理该 Handler 的 HandlerAdapter 对象；
  5. 执行 HandlerExecutionChain 中所有拦截器的 preHandler() 方法，然后再利用 HandlerAdapter 执行 Handler ，执行完成得到 ModelAndView，再依次调用拦截器的 postHandler() 方法；
  6. 利用 ViewResolver 将 ModelAndView 或是 Exception（可解析成 ModelAndView）解析成 View，然后 View 会调用 render() 方法再根据 ModelAndView 中的数据渲染出页面；
  7. 最后再依次调用拦截器的 afterCompletion() 方法，这一次请求就结束了。
3、SpringMVC工作机制
  1. 用户发送请求至前端控制器DispatcherServlet。
  2. DispatcherServlet收到请求调用HandlerMapping处理器映射器。
  3. 处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。
  4. DispatcherServlet调用HandlerAdapter处理器适配器。
  5. HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。
  6. Controller执行完成返回ModelAndView。
  7. HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。
  8. DispatcherServlet将ModelAndView传给ViewReslover视图解析器。
  9. ViewReslover解析后返回具体View。
  10. DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。
  11. DispatcherServlet响应用户。
4、SpringMVC工作原理图

在这里插入图片描述

三、SpringMVC特有注解
1、@RequestMapping

@RequestMapping注解：请求路径映射，可以修饰类或者方法。如果标注在某个controller的类级别上，则表明访问此类路径下的方法都要加上其配置的路径；最常用的是标注在方法上，表明哪个具体的方法来接受处理某次请求。如果类上没有该注解，只是在方法上有该注解，那么在浏览器请求的时候url=localhost:8080/方法请求映射名称。

2、@RequestParam

@RequestParam()是请求参数注解，应用在方法的参数中。

@RequestParam主要用于在SpringMVC后台控制层获取参数，类似一种是request.getParameter(“name”)，它有三个常用参数：defaultValue = “0”，required = false，value = “isApp”；

  • defaultValue ：表示设置默认值

  • required：通过boolean设置是否是必须要传入的参数，true表示必须传入，如果不传则为null，如果为null，则报异常。

  • value： 值表示接收的传入的参数名称

3、@PathVariable

restful风格的参数注解，只能修饰从路径中获取的参数，用于将请求URL中的模板变量映射到功能处理方法的参数上，即取出uri模板中的变量作为参数。

4、@DateTimeFormat(pattern=“yyyy-MM-dd”)

等效于@DateTimeFormat(iso = DateTimeFormat.ISO.DATE)注解，可将Date时间格式的国际格式转为中文格式，主要应用于实体类的Date类型属性上，或者方法中Date类型的参数上。

四、SpringMVC获取参数
1、实体类（在以下所有操作的实体类中使用）
package com.java.entity;

import org.springframework.format.annotation.DateTimeFormat;

import java.util.Date;

/**
 * @author Liushun
 * @date Created in 2018/9/21 20:29
 * @description 用户实体类
 */
public class User {

    // 用户姓名
    private String name;

    // 用户年龄
    private Integer age;

    // 用户出生日期
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date birth;

    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;
    }

    public Date getBirth() {
        return birth;
    }

    public void setBirth(Date birth) {
        this.birth = birth;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", birth=" + birth +
                '}';
    }
}
2、Controller层
package com.java.controller;

import com.java.entity.User;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

import java.util.Date;
import java.util.Map;
import java.util.Set;

/**
 * @author Liushun
 * @date Created in 2018/9/21 21:36
 * @description springMVC获取参数的几种方式
 */

@Controller
@RequestMapping("/con1")
public class TestParamController {

    /*@RequestParam：
    1、如果请求参数名和后台接收参数名不一致，使用此注解可正常传参，不然会传参失败
    2、相当于request.getParameter()
    3、如果不使用@RequestParam，方法的形参和url中的参数名要保持一致
    */

    @RequestMapping("/paramTest")
    public void paramTest(@RequestParam(value = "name") String name1, Integer age, @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) Date birth){
        System.out.println("name：" + name1);
        System.out.println("age：" + age);
        System.out.println("birth：" + birth);
    }

    // 一次性获取所有的请求参数
    @RequestMapping("/paramsTest")
    public void paramsTest(@RequestParam Map map){
        Set<Map.Entry> set = map.entrySet();
        for(Map.Entry entry : set){
            System.out.println(entry.getKey() + "——" + entry.getValue());
        }
    }

    // 专门处理post请求
    @RequestMapping(value = "/entityTest",method = RequestMethod.POST)
    public void entityTest(User user){
        System.out.println("POST请求接参：" + user);
    }

    // 专门处理get请求
    @RequestMapping(value = "/entityTest",method = RequestMethod.GET)
    public void entityTest2(User user){
        System.out.println("GET请求接参：" + user);
    }
    
    /**@GetMapping用于将HTTP get请求映射到特定处理程序的方法注解
    具体来说，@GetMapping是一个组合注解，是@RequestMapping(method = RequestMethod.GET)的缩写。

    @PostMapping用于将HTTP post请求映射到特定处理程序的方法注解
    具体来说，@PostMapping是一个组合注解，是@RequestMapping(method = RequestMethod.POST)的缩写。*/    

    // rest风格的参数获取——url中只有参数值，参数名在注解中，路径变量的注解：@PathVariable
    @RequestMapping("/restfulTest/{name}/{age}/{birth}")
    public void restfulTest(@PathVariable String name,
                             @PathVariable Integer age,
                             @PathVariable @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) Date birth){

        System.out.println("name：" + name);
        System.out.println("age：" + age);
        System.out.println("birth：" + birth);
    }
}
3、JSP页面
<%@ page language="java" contentType="text/html; charset=UTF-8" %>
<html>
<body>
<h2>springMVC获取参数的几种方式</h2>
<form action="/con1/paramsTest/" method="GET">
    姓名：<input type="text" name="name"><br>
    年龄：<input type="text" name="age"><br>
    生日：<input type="text" name="birth"><br>
    <input type="submit" value="提交">
</form>

<a href="/con1/restfulTest/鬼见愁/26/1993-01-01">测试restful风格的请求参数获取</a>
</body>
</html>
五、SpringMVC响应正文和页面跳转
1、@ResponseBody

将传入的参数类型转化为json或者xml格式，应用于方法之上，适用于ajax后台

该注解用于将Controller的方法返回的对象，通过适当的HttpMessageConverter转换为指定格式后，写入到Response对象的body数据区

使用时机：返回的数据不是html标签的页面，而是其他某种格式的数据时（如json、xml等）使用，其实就是为了把传出或者传入的参数类型转变成json，xml类型

2、Controller层
package com.java.controller;

import com.java.entity.User;
import org.apache.commons.io.IOUtils;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.FileInputStream;
import java.io.IOException;

/**
 * @author Liushun
 * @date Created in 2018/9/21 21:03
 * @description 响应正文和页面跳转
 */
@Controller
@RequestMapping("/con2")
public class TestResponseController {

    //1、响应字符串，相当于response.getWriter().write("我爱你，中国")
    // @RequestMapping注解中produces = "text/html;charset=UTF-8"，解决响应中文乱码
    @RequestMapping(value = "/responseString",produces = "text/html;charset=UTF-8")
    @ResponseBody
    public String responseString(){
        return "我爱你，中国";
    }

    // 2、响应实体类字符串   
    @RequestMapping(value = "/responseEntityStr",produces = "text/html;charset=UTF-8")
    @ResponseBody
    public String responseEntityStr(){
        User user = new User();
        user.setName("鬼见愁");
        return user.toString();
    }

    // 3、以json格式响应实体类
    @RequestMapping("/responseEntity")
    @ResponseBody
    public Object responseEntity(){
        User user = new User();
        user.setName("鬼见愁");
        return user;
    }

    // 4、响应字节流图片
    @RequestMapping("/responseByte")
    public void responseByte(HttpServletResponse response){
        try {
            FileInputStream fis = new FileInputStream("E:\\Img_Demo\\liushishi.jpg");
            ServletOutputStream os = response.getOutputStream();
            IOUtils.copy(fis, os);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    //上面是响应正文 下面是页面的跳转
    
    // 5、页面的跳转——转发
    @RequestMapping("/toShow")
    public String toShow(){
        // 自动拼接前后缀并转发到对应的jsp
        return "show";
    }

    // 6、页面的跳转——重定向
    @RequestMapping("/toShow2")
    public String toShow2(){
        // 重定向的路径：1.非web-inf下的jsp 2.其它的RequestMapping路径
        return "redirect:toShow";
    }
    
    // 7、方法的请求映射，利用model传值
    @RequestMapping("/saveData1")
    public String saveData1(Model model){
        // 把数据k-v保存在model类中，其实保存在request作用域中
        model.addAttribute("name","鬼见愁");
        // 渲染视图，跳页面
        return "show";
    }

    // 8、方法的请求映射，利用ModelMap传值
    @RequestMapping("/saveData2")
    public String saveData2(ModelMap modelMap){
        modelMap.addAttribute("name","鬼见愁");
        return "show";
    }

    // 9、ModelAndView表示模型与视图，既可以进行传值，又可以进行渲染视图
    @RequestMapping("/saveData3")
    public ModelAndView saveData3(ModelAndView modelAndView){
        modelAndView.addObject("name","鬼见愁");
        modelAndView.setViewName("show");
        return modelAndView;
    }

    
}
3、以json格式响应实体类
3.1导入jackson包
<!--pojo转换成 json -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.7.3</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.7.3</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>2.7.3</version>
</dependency>

<!--IO流-->
<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.4</version>
</dependency>
3.2在springmvc配置json类型转化
 <!--开启springMVC自己的注解-->
    <mvc:annotation-driven>
        <!--设置响应编码：String、json-->
        <mvc:message-converters>
            <!--解决@responsebody响应中文乱码-->
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <constructor-arg value="UTF-8"/>
            </bean>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
        </mvc:message-converters>
    </mvc:annotation-driven>
4、show.jsp页面

所有的存储数据model，modelMap，modelAndView，均默认保存在request作用域中

<%@ page language="java" contentType="text/html; charset=UTF-8" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>展示页面</h1>
    applicationScope：${applicationScope.name}<br>
    sessionScope：${sessionScope.name}<br>
    requestScope：${requestScope.name}<br>
    pageScope：${pageScope.name}<br>
</body>
</html>
Eiffel_Wu
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Servlet】请求和响应常用方法、会话、初始化参数、注解
莱克博尔德的博客
06-09 788
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、请求（的常用方法）1.1五种常用方法：1.2用法示例1.2.1客户端如何发送数据给服务器1.2.2处理请求乱码问题1.2.3Servlet跳转页面1.2.4后台给前台传数据二、响应(常用的4个方法)2.1重定向和转发的对比三、会话四、获取初始化参数五、注解 一、请求（的常用方法） HttpServletRequest表示Http环境中的Servlet请求。它扩展于javax.servlet.ServletRequest（接口）
.net webservice怎么接收post过来的json_结合参数接收响应转换原理讲解SpringBoot常用注解
weixin_39837105的博客
11-22 855
一、常用注解回顾1.1 @RequestBody与@ResponseBody//注意并不要求@RequestBody与@ResponseBody成对使用。 public @ResponseBody AjaxResponse saveArticle(@RequestBody ArticleVO article) 如上代码所示：@RequestBody修饰请求参数，注解用于接收HTTP的body，默...
Spring MVC-注解方式进行配置页面跳转
litengbin的博客
02-06 627
前面的例子，都是使用配置的方式进行跳转的配置，本例讲解如何使用注解的方式进行跳转的配置 修改IndexController 在类前面加上@Controller 表示该类是一个控制器 在方法handleRequest 前面加上 @RequestMapping("/index") 表示路径/index会映射到该方法上 注意：不再让IndexController实现Controller接
在自定义HandlerInterceptor中 方法执行之后获取响应体参数
最新发布
互联网小白兔专业CRUD 选手
08-12 1806
requestBody 和 responseBody 分别对应的是 InputStream 和 OutputStream，由于流的特性，读取完之后就无法再被使用了。以上的逻辑就是起到 流的重复使用。通过自定义的拦截器对部分接口的返回添加缓存,请求接口和参数作为redisKey。以上代码关键在于如何在 afterCompletion 方法中获取到相应参数。
java 拦截器响应中取所有参数,spring boot拦截器中获取request post请求中的参数
weixin_42309083的博客
03-20 1978
最近有一个需要从拦截器中获取post请求的参数的需求，这里记录一下处理过程中出现的问题。首先想到的就是request.getParameter(String )方法，但是这个方法只能在get请求中取到参数，post是不行的，后来想到了使用流的方式，调用request.getInputStream()获取流，然后从流中读取参数，如下代码所示：String body = "";StringBuilde...
手把手教你搭建SpringMVC框架——最小化配置
08-31
主要介绍了手把手教你搭建SpringMVC框架——最小化配置，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。
SSM框架——(SpringMVC+Spring+MyBatis+Maven多模块)整合
03-03
SpringMVC+Spring+MyBatisMaven多模块项目地址：SpringMVC:1.客户端发送请求到DispacherServlet（分发器)2.由DispacherServlet控制器查询HanderMapping，找到处理请求的Controller3.Controller调用业务逻辑处理后，...
SSM框架——详细整合教程（Spring+SpringMVC+MyBatis）
03-03
Spring是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架，由RodJohnson在其著作ExpertOne-On-OneJ2EEDevelopmentandDesign中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建...
spring boot 拦截器HandlerInterceptorAdapter的postHandle和afterCompletion无法获取response返回值问题
BLF2
10-24 1万+
缘起 有一个需求，在进入controller之前验证调用次数是否超过限制，在响应之后判断是否正常返回，对调用次数进行+1，发现带@RestController的类和带@ResponseBody的方法在被调用后response会直接写入输出流，在postHandle和afterCompletion这两个方法执行之前就已经把数据返回，导致这两个方法里面的response根本获取不到响应数据。 解决方案...
统一处理访问请求和返回值/响应体@ControllerAdvice,ResponseBodyAdvice,HandlerInterceptor
fz13768884254的博客
08-20 6162
一：统一处理访问请求（配置拦截器进行处理HandlerInterceptor）： 一般情况下，controller中入参很少需要HttpServletRequest和HttpServletResponse参数，但是有时我们需要对访问参数进行日志打印，查看请求ip或入参等信息时，就需要在入参加上request和response，这样每个controller都会增加这两个参数...
Java项目使用AOP打印请求参数和响应信息
精进编程の博客
06-26 2467
方便在后台日志直接看到请求参数等信息,可以快速定位bug原因 @Aspect @Configuration @Slf4j public class LogAspect { @Autowired private RedisOperate redisOperate; @Pointcut("execution(* com.dkdy.goodsserver.controller.*...
SpringBoot通过拦截器获取请求参数和返回结果进行操作
TimeQuantum的博客
07-03 2万+
SpringBoot项目的创建和初始化在这里就不在重复 一.实现请求拦截器处理数据 自定义拦截器 在SpringMVC中的 Interceptor拦截器才用实现 HandlerInterceptor的方式，实现其中的三个方法。 preHandle(): 该方法在请求处理之前执行，SpringMVC 中的Interceptor 是链式的调用的，在一个应用中或者说是在一个请求中可以同时存在多个Interceptor 。每个Interceptor 的调用会依据它的声明顺序依次执行，而且最先执行的都是Interce
java拦截了返回的数据,如何获取@ResponseBody后的 response响应值 通过 spring 拦截器 获取 controller 返回的response 的值...
weixin_29323273的博客
03-22 2008
public static String readPostJsonData(HttpServletResponse response) throws IOException {if (response instanceof ContentCachingResponseWrapper) {ContentCachingResponseWrapper responseWrapper = (Content...
springboot操作日志记录（使用拦截器）（待详细完善注意点）
u014104653的博客
08-09 3094
之所以重新定义改造，是因为HttpServletRequest 和 HttpServletResponse 这两个类的输出流只能被读取一次，再次读写将会读取不到任何内容，所以采用包装类进行改造，方便取请求的数据和响应的数据。用来标识哪些方法、操作需要被拦截（一般情况下，主要记录一些挂件业务的操作日志）以及简单介绍将要拦截的方法的内容是什么等等。5.配置controller中的方法，标识将要拦截的方法，下面是demo的信息。将来所有的日志记录代码就是写在这个里面，包含请求和响应数据的获取。......
拦截请求返回值的方法
热门推荐
彤哥读源码
11-08 2万+
拦截请求返回值的方法
SpringMVC通过注解加载properties配置文件
weixin_40571358的博客
10-15 1122
spring项目有多种方式加载properties配置文件，这里选取其中一种自认为比较简便的方式进行记录。 1.在spring的全局xml中配置properties文件的路径与对应的配置类包扫描路径 spring applicationContext.xml： <!-- 其他类扫描路径 --> <context:component-scan base-package="com.x.y.z"/> <!-- …… --> <!-- 配置类扫描路径 -->
spring boot 接口 XML 接受和请求（被调方）
ywj776199845的专栏
11-27 9670
spring boot 接口处理： import java.util.List; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestBody; import com.xianjinxia.sms.pojo.outp...
介绍下SpringMVC框架和它的特点
05-05
SpringMVC 是一个基于 Spring 框架的 Web 框架，它采用 Model-View-Controller（MVC）的设计模式，将请求和响应分离，使得应用程序能够更好地管理复杂的业务逻辑和用户交互。它的特点包括： 1. 轻量级：SpringMVC ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值