SpringMVC_入门案例&基础配置&请求&响应

最新推荐文章于 2024-07-23 10:48:19 发布
最新推荐文章于 2024-07-23 10:48:19 发布
阅读量189 收藏
点赞数
文章标签： spring mvc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/peng_19_20_qing/article/details/107518421
版权

01-SpringMVC概述

三层架构

> 这里是引用

MVC:

在这里插入图片描述

SpringMVC简介
  • SpringMVC 是一种基于Java实现 MVC模型的轻量级 Web框架
SpringMVC有点
1. 使用简单
    2.性能突出
    3.灵活性强

02-SpringMVC_入门案例

入门案例-步骤1-导入坐标
在pop.xml文件中导入
 <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
    <!-- servlet3.1规范的坐标 -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
    <!--jsp坐标-->
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.1</version>
      <scope>provided</scope>
    </dependency>
    <!--spring的坐标-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.1.9.RELEASE</version>
    </dependency>
    <!--spring web的坐标-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>5.1.9.RELEASE</version>
    </dependency>
    <!--springmvc的坐标-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.1.9.RELEASE</version>
    </dependency>

  </dependencies>

  <!--构建-->
  <build>
    <!--设置插件-->
    <plugins>
      <!--具体的插件配置-->
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.1</version>
        <configuration>
          <port>80</port>
          <path>/</path>
          <!--在pom.xml中 配置编码 解决乱码-->
          <!--<uriEncoding>UTF-8</uriEncoding>-->
        </configuration>
      </plugin>
    </plugins>
  </build>
入门案例-步骤2-中央控制器的配置
  • web.xml中配置 SpringMVC核心控制器 用于将请求转发到对应的具体业务处理器 Controller
<servlet>
    <servlet-name>DispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--加载spring xml配置文件-->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath*:spring_mvc.xml</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>DispatcherServlet</servlet-name>
    <!--拦截范围 / 代表所有-->
    <url-pattern>/</url-pattern>
  </servlet-mapping>
入门案例-步骤3-创建spring容器
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <!--扫描加载所有的控制类类-->
    <context:component-scan base-package="com.itheima"/>
   
    
    <!--静态资源放行-->
    <mvc:default-servlet-handler/>

</beans>
入门案例-步骤4-编写Controller（servlet）
@Controller
public class UserController {
    //设定当前方法的访问映射地址
    @RequestMapping("/abc")
    //设置当前方法返回值类型为String，用于指定请求完成后跳转的页面
    public String save(){
        System.out.println("user mvc controller is running ...");
        //设定具体跳转的页面
        return "success.jsp";
    }


    @RequestMapping("/hello")
    public String hello(String param) {
        System.out.println(param);
        return "success.jsp";
    }
}
小结
服务器启动:
     tomcat启动加载web.xml
    1. 加载web.xml中的DispatcherServlet
    2.  读取spring xml中的配置,加载所有com.itheima包中所有标记为bean 的类
     3.读取bean中方法上标注@RequestMapping的内容
 处理请求:
    1.DispatcherServlet 配置拦截所有请求 / 
     2.使用请求路径与所有加载的@RequestMapping的内容进行对比
        3.执行对应的方法
        4.根据方法法的返回值在webapp目录查找对应的页面并展示
SpringMVC技术架构图

说明:
乱码解决一 在web.xml中配置过滤器
  <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>
乱码解决二 在tomcat插件uri编码配置
 <!--构建-->
    <build>
      <!--设置插件-->
      <plugins>
        <!--具体的插件配置-->
        <plugin>
          <groupId>org.apache.tomcat.maven</groupId>
          <artifactId>tomcat7-maven-plugin</artifactId>
          <version>2.1</version>
          <configuration>
            <port>80</port>
            <path>/</path>
              <!--配置乱码过滤器-->
            <uriEncoding>UTF-8</uriEncoding>
          </configuration>
        </plugin>
      </plugins>
    </build>

03-SpringMVC_基础配置

Controller加载控制
  • SpringMVC的处理器对应的bean必须按照规范格式开发,为避免加入无效的bean可通过bean加载器进行包含设定或排除设定,表现层bean标注通常设定为@Controller
  • 在SpringMvc的xml中配置加载控制
 <context:component-scan base-package="com.itheima">
        <!-- type选择注解类型 -->
        <context:include-filter    <!--这里选择包含模式,排除模式,需要排除的选项太多-->
           type="annotation"                                    					
      <!--与表现层的注解 @Controller是同一个路径-->										  			expression="org.springframework.stereotype.Controller"/>			
    </context:component-scan>
  • 在配置类中配置加载控制
@Configuration //标明这是一个配置类
@ComponentScan(value = "com.itheima",  //里选择包含模式,排除模式,需要排除的选项太多
              includeFilters =@ComponentScan.Filter(type=FilterType.ANNOTATION,
                                                   classes = {Controller.class})
    )
public class SpringMVCConfiguration implements WebMvcConfigurer{ }
bean加载控制说明
业务层与数据层bean加载由Spring控制,
表现层bean加载由SpringMVC单独控制
    1.表现层处理器bean使用注解@Controller声明
    2.bean加载控制使用包含性过滤器
    3.过滤器类型为通过注解进行过滤
    4.过滤的注解名称为Controller
静态资源加载
  • 核心控制器拦截的是所有请求,需要对静态资源进行放行
通过配置放行静态资源
 <!--放行指定静态资源的配置方式-->
<mvc:resources mapping="/img/**" location="/img/"/>
<mvc:resources mapping="/js/**" location="/js/"/>

  <!--SpringMVC提供的通用资源放行方式-->
    <mvc:default-servlet-handler/>

注解驱动

  • 使用注解形式转化SpringMVC核心配置文件为配置类
配置类
@Configuration
@ComponentScan(value = "com.itheima",includeFilters =
    @ComponentScan.Filter(type=FilterType.ANNOTATION,classes = {Controller.class})
    )
public class SpringMVCConfiguration implements WebMvcConfigurer{
    /*覆盖原有的默认功能
    注解配置放行指定资源格式
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/img/**").addResourceLocations("/img/");
        registry.addResourceHandler("/js/**").addResourceLocations("/js/");
        registry.addResourceHandler("/css/**").addResourceLocations("/css/");
    } */

    //注解配置通用放行资源的格式
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
}
  • 自定义Servlet容器初始化配置类,加载核心配置类
自定义Servlet容器
public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    //创建Servlet容器时，使用注解的方式加载SPRINGMVC配置类中的信息，并加载成WEB专用的ApplicationContext对象
    //该对象放入了ServletContext范围，后期在整个WEB容器中可以随时获取调用
    @Override
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(SpringMVCConfiguration.class);
        return ctx;
       /* 代替web.xml中的下面注释配置 加载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*:spring-mvc.xml</param-value>
        </init-param>
    </servlet> */
    }

    //注解配置映射地址方式，服务于SpringMVC的核心控制器DispatcherServlet
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

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

    //乱码处理作为过滤器，在servlet容器启动时进行配置，相关内容参看Servlet零配置
    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        // 调用父类的 onStartu
        super.onStartup(servletContext);
        //1. 创建字符集过滤器对象
        CharacterEncodingFilter cef = new CharacterEncodingFilter();
        //2. 设置使用的字符集
        cef.setEncoding("UTF-8");
        //3. 添加到容器（它不是 ioc 容器，而是 ServletContainer ）
        FilterRegistration.Dynamic registration = servletContext.addFilter("characterEncodingFilter", cef);
        //4. 添加映射
        registration.addMappingForUrlPatterns(EnumSet.of(DispatcherType.REQUEST,DispatcherType.FORWARD,DispatcherType.INCLUDE),false,"/*");
    }
}
  • 配置完成后需要删除web.xml和Springmvc.xml配置

04-请求_request

请求参数
  • SpringMVC将传递的参数封装到处理器的形参中,达到快速访问参数的目的

###### 图片04-请求1

请求参数类型
    普通类型参数
    POJO类型参数
    数组类型参数
    集合类型参数

普通类型参数

//方法传递普通类型参数，数量任意，类型必须匹配  参数名与处理器方法形参名保持一致
    //http://localhost/requestParam1?name=itheima
    //http://localhost/requestParam1?name=itheima&age=14  
    @RequestMapping("/requestParam1")
    public String requestParam1(String name,int age){
        System.out.println(name+","+age);
        return "page.jsp";
    }

###### 图片04-请求2

参数设定
名称:@RequestParam
类型:形参注解
位置:处理器类中的方法形参前方
作用:绑定请求参数与对应处理方法形参间的关系    

 //方法传递普通类型参数，使用@RequestParam参数匹配URL传参中的参数名称与方法形参名称
    //http://localhost/requestParam2?userName=Jock       //访问路径
    @RequestMapping("/requestParam2")
    public String requestParam2(@RequestParam(value = "userName",
                        //  required=true表示必须带有参数 否则无法访问报错                    
                      required = true) String name){
        System.out.println(name);
        return "page.jsp";
    }

POJO类型参数

POJO类型参数
  • 当POJO中使用简单类型属性时,参数名称与POJO类属性名保持一致
//方法传递POJO类型参数，URL地址中的参数作为POJO的属性直接传入对象
    //http://localhost/requestParam3?name=Jock&age=39
    @RequestMapping("/requestParam3")
    public String requestParam3(User user){
        System.out.println(user);
        return "page.jsp";
    }

###### 图片04-请求3

参数冲突
  • 当POJO类型属性与其他形参出现同名问题时,将被同时赋值
  • 建议使用@RequestParam注解进行区分
 //当方法参数中具有POJO类型参数与普通类型参数嘶，URL地址传入的参数不仅给POJO对象属性赋值，也给方法的普通类型参数赋值
    //http://localhost/requestParam4?name=Jock&age=39
    @RequestMapping("/requestParam4")
    public String requestParam4(User user,int age){
        System.out.println("user="+user+",age="+age);
        return "page.jsp";
    }

在这里插入图片描述

复杂POJO类型参数-01
  • 当POJO中出现对象属性时,参数名称与对象名称层次结构名称保持一致
//使用对象属性名.属性名的对象层次结构可以为POJO中的POJO类型参数属性赋值
    //http://localhost/requestParam5?address.city=beijing
    @RequestMapping("/requestParam5")
    public String requestParam5(User user){
        System.out.println(user.getAddress().getCity());
        return "page.jsp";
    }

在这里插入图片描述

复杂POJO类型参数-02
  • 当POJO中出现集合,保存简单数据,使用多个相同名称的参数为其进行赋值

###### 图片04-请求6

//通过URL地址中同名参数，可以为POJO中的集合属性进行赋值，集合属性要求保存简单数据
    //http://localhost/requestParam6?nick=Jock1&nick=Jockme&nick=zahc
    @RequestMapping("/requestParam6")
    public String requestParam6(User user){
        System.out.println(user);
        return "page.jsp";
    }
复杂POJO类型参数-03
  • 当POJO中出现List,保存对象数据,参数名称与对象层次结果名称保持一致,使用数组格式描述集合中对象的位置

在这里插入图片描述

//POJO中List对象保存POJO的对象属性赋值，使用[数字]的格式指定为集合中第几个对象的属性赋值
    //http://localhost/requestParam7?addresses[0].city=beijing&addresses[1].province=hebei
    @RequestMapping("/requestParam7")
    public String requestParam7(User user){
        System.out.println(user.getAddresses());
        return "page.jsp";
    }
复杂POJO类型参数-04
  • 当POJO中出现Map,保存对象数据,参数名称与对象层次结果名称保持一致,使用映射格式描述集合中对象的位置

###### 图片04-请求6

//POJO中Map对象保存POJO的对象属性赋值，使用[key]的格式指定为Map中的对象属性赋值
    //http://localhost/requestParam8?addressMap['job'].city=beijing&addressMap['home'].province=henan
    @RequestMapping("/requestParam8")
    public String requestParam8(User user){
        System.out.println(user.getAddressMap());
        return "page.jsp";
    }

数组类型参数

  • 请求参数名与处理器方法形参名保持一致,且请求参数数量>1

###### 图片04-请求6

//方法传递普通类型的数组参数，URL地址中使用同名变量为数组赋值
    //http://localhost/requestParam9?nick=Jockme&nick=zahc
    @RequestMapping("/requestParam9")
    public String requestParam9(String[] nick){
        System.out.println(nick[0]+","+nick[1]);
        return "page.jsp";
    }

集合类型参数

  • 保存简单数据类型,请求参数名与处理器方法形参名保持一致,且请求参数数量>1

###### 图片04-请求6

//方法传递保存普通类型的List集合时，无法直接为其赋值，需要使用@RequestParam参数对参数名称进行转换
    //http://localhost/requestParam10?nick=Jockme&nick=zahc
    @RequestMapping("/requestParam10")
    public String requestParam10(@RequestParam("nick") List<String> nick){
        System.out.println(nick);
        return "page.jsp";
    }

类型转换器

  • SpringMVC对接受的数据进行自动类型转换,该工作通过Converter接口实现
  • 标量转换器
  • 集合 `数组相关转换器
  • 默认转换器
日期类型格式转换
  • 声明自定义的转换格式并覆盖系统转换格式
在xml配置文件中配置
<!--    自定义格式转换器案例，配合不带@DateTimeFormat的requestParam11使用-->

    <!--开启注解驱动，加载自定义格式化转换器对应的类型转换服务-->
    <mvc:annotation-driven conversion-service="conversionService"/>
    <!--自定义格式化转换器-->
    <bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
        <!--覆盖格式化转换器定义规则，该规则是一个set集合，对格式化转换器来说是追加和替换的思想，而不是覆盖整体格式化转换器-->
        <property name="formatters">
            <set>
                <!--具体的日期格式化转换器-->
                <bean class="org.springframework.format.datetime.DateFormatter">
                    <!--具体的规则，不具有通用性，仅适用于当前的日期格式化转换器-->
                    <property name="pattern" value="yyyy-MM-dd"/>
                </bean>
            </set>
        </property>
    </bean>
使用注解简化配置
@DateTimeFormat
类型:形参注解,成员变量注解
位置:形参前面 或 成员变量 上方
 示例1   
public String requestParam12(@DateTimeFormat(pattern = "yyyy-MM-dd") Date date){
     System.out.println("date="+date);
     return "page.jsp";
}
示例2
  @DateTimeFormat(pattern = "yyyy-MM-dd")
       private Date birthday;

注意:依赖注解驱动支持

 <!--    自定义格式转换器案例，配合带@DateTimeFormat的requestParam11使用-->

    <mvc:annotation-driven/>

 //数据类型转换，使用自定义格式化器或@DateTimeFormat注解设定日期格式
    //两种方式都依赖springmvc的注解启动才能运行
    //http://localhost/requestParam11?date=1999-09-09
    @RequestMapping("/requestParam11")
    public String requestParam11(@DateTimeFormat(pattern = "yyyy-MM-dd") Date date){
        System.out.println(date);
        return "page.jsp";
    }
自定义类型转换器
  • 自定义类型转换器,实现Converter接口,并制定转换前后的类型
//自定义类型转换器，实现Converter接口，接口中指定的泛型即为最终作用的条件
//本例中的泛型填写的是String，Date，最终出现字符串转日期时，该类型转换器生效
public class MyDateConverter implements Converter<String, Date> {
    //重写接口的抽象方法，参数由泛型决定
    public Date convert(String source) {
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        Date date = null;
        //类型转换器无法预计使用过程中出现的异常，因此必须在类型转换器内部捕获，不允许抛出，框架无法预计此类异常如何处理
        try {
            date = df.parse(source);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }
}
spring.xml配置中注册自定义转换器
 <!--    自定义格数据类型转换器案例，配合requestParam12使用-->

    <mvc:annotation-driven conversion-service="conversionService"/>
    <!--自定义类型转换器-->
    <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
        <!--覆盖类型转换器定义规则，该规则是一个set集合，对类型转换器来说是追加和替换的思想，而不是覆盖整体格式化转换器-->
        <property name="converters">
            <set>
                <!--添加自定义的类型转换器，会根据定义的格式覆盖系统中默认的格式-->
                <!--当前案例中是将String转换成Date的类型转换器进行了自定义，所以添加后，系统中原始自带的String——>Date的类型转换器失效-->
                <bean class="com.itheima.converter.MyDateConverter"/>
            </set>
        </property>
    </bean>
请求映射
方法注解 @RequestMapping
  位置: 处理器类中的方法定义上方
  作用: 绑定请求地址与对应处理方法间的关系
@RequestMapping("/requestURL1")
     public String requestURL1() {
     return "page.jsp";
}   

 类注解 @RequestMapping
 位置: 处理器类定义上方
 作用: 绑定请求地址与对应处理方法间的关系
 @Controller
@RequestMapping("/user")
public class UserController {
     @RequestMapping("/requestURL2")
     public String requestURL2() {
         return "page.jsp";
     }
}    
访问路径/user/requestURL1
  • 请求返回的页面地址默认为当前路径
  • 当设置了公共的访问前缀后,当前路径发生了变化,需要根据变化修改地址或访问页面的路径
//带有类映射地址访问格式，需要将类映射地址作为前缀添加在实际映射地址的前面
    //最终返回的页面如果未设定绝对访问路径，将从类映射地址所在目录中查找
    //http://localhost/user/requestURL2     （注意：要配合类上定义的路径使用）
    @RequestMapping("/requestURL2")
    public String requestURL2(){
        return "/page.jsp";
    }
@RequestMappings属性
// target代表你能写在那些地方
// type代表类型， 能写在类上
// METHOD 方法上
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Mapping
public @interface RequestMapping {
    String name() default "";

    //路径
    //Alias别名
    @AliasFor("path")
    String[] value() default {};
	//路径
    @AliasFor("value")
    String[] path() default {};

    // method, 指定请求方式（GET,POST）
    RequestMethod[] method() default {};
	//参数
    String[] params() default {};
	//请求头信息指定
    String[] headers() default {};
	//接收的媒体类型
    String[] consumes() default {};
	//响应的媒体类型
    String[] produces() default {};
}

05-响应_response

响应方式

在这里插入图片描述

页面跳转设定
  • 当处理器的返回值类型为String类型,即可通过具体的返回值设置访问的页面
public class UserController {
@RequestMapping("/showPage")
  public String showPage() {
      System.out.println("user mvc controller is running ...");
      return "page.jsp";
}
}

页面跳转方式

  • 直接返回值是页面路径
没有配置视图解析器
  • 直接返回值是页面路径
@RequestMapping("/showPage")
public String showPage() {
    System.out.println("user mvc controller is running ...");
    //返回值直接为webapp下的路径
    return "/system/userlist.jsp";
}

@RequestMapping("/showPage")
public String showPage() {
    System.out.println("user mvc controller is running ...");
    //返回值直接为webapp下的路径
    return "/WEB-INF/page/page.jsp";
}


@RequestMapping("/showPage2")
public String showPage2() {
    System.out.println("user mvc controller is running ...");
    // forward   转发
    // redirect 重定向
    return "redirect:/WEB-INF/page/page.jsp";
}
配置有视图解析器
    <context:component-scan base-package="com.itheima"/>

    <!--设定页面加载的前缀后缀，仅适用于默认形式，不适用于手工标注转发或重定向的方式-->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/page/"/>
            <property name="suffix" value=".jsp"/>
        </bean>

    <!--开启springmvc注解驱动，对@ResponseBody的注解进行格式增强，追加其类型转换的功能，具体实现由MappingJackson2HttpMessageConverter进行-->
    <mvc:annotation-driven/>
    <mvc:default-servlet-handler/>
  • 在返回值中直接写上/WEB-INF/page/的静态页面名称即可
@RequestMapping("/showPage3")
    public String showPage3() {
        System.out.println("user mvc controller is running ...");
        return "page";
    }
  • 转发(默认方式)
 //forward:page.jsp转发访问，支持访问WEB-INF下的页面
    @RequestMapping("/showPage1")
    public String showPage1() {
        System.out.println("user mvc controller is running ...");
        return "forward:/WEB-INF/page/page.jsp";
    }
  • 重定向
//redirect:page.jsp重定向访问，不支持访问WEB-INF下的页面
    @RequestMapping("/showPage2")
    public String showPage2() {
        System.out.println("user mvc controller is running ...");
        return "redirect:/WEB-INF/page/page.jsp";
    }
页面访问快捷设定
<!--设定页面加载的前缀后缀，仅适用于默认形式，不适用于手工标注转发或重定向的方式-->
        <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/page/"/>
            <property name="suffix" value=".jsp"/>
        </bean>

//页面简化配置格式，使用前缀+页面名称+后缀的形式进行，类似于字符串拼接
    @RequestMapping("/showPage3")
    public String showPage3() {
        System.out.println("user mvc controller is running ...");
        return "page";
    }
页面访问快捷设定缺省页面
 //最简页面配置方式，使用访问路径作为页面名称，省略返回值
    @RequestMapping("/showPage5")
    public void showPage5() {
        System.out.println("user mvc controller is running ...");
    }
相当于
@RequestMapping("/showPage5")
public String showPage5() {
    return "showPage5";
}

携带数据页面跳转设定

方式一:使用HttpServletRequest类型
  • 仅封装跳转页面的基本信息 底层由ModelAndView实现
 //使用原生request对象传递参数
    @RequestMapping("/showPageAndData1")
    public String showPageAndData1(HttpServletRequest request) {
        request.setAttribute("name","itheima");
        return "page";
    }
方式二:使用Model类型形参进行数据传递
  • 仅封装数据
/使用Model形参传递参数
    @RequestMapping("/showPageAndData2")
    public String showPageAndData2(Model model) {
        //添加数据的方式，key对value
        model.addAttribute("name","Jock");
        Book book  = new Book();
        book.setName("SpringMVC入门案例");
        book.setPrice(66.66d);
        //添加数据的方式，key对value
        model.addAttribute("book",book);
        return "page";
    }
方式三:使用modelAndView形参传递数据,
  • 该对象作为返回值传递给调用者
  • 封装数据并封装视图,包含Model和View两个对象
 //使用ModelAndView形参传递参数，该对象还封装了页面信息
    @RequestMapping("/showPageAndData3")
    public ModelAndView showPageAndData3(ModelAndView modelAndView) {
        //ModelAndView mav = new ModelAndView();    替换形参中的参数
        Book book  = new Book();
        book.setName("SpringMVC入门案例");
        book.setPrice(66.66d);

        //添加数据的方式，key对value
        modelAndView.addObject("book",book);
        //添加数据的方式，key对value
        modelAndView.addObject("name","Jockme");
        //设置页面的方式，该方法最后一次执行的结果生效
        modelAndView.setViewName("page");
        //返回值设定成ModelAndView对象
        return modelAndView;
    }

返回数据

返回数据
方式一:使用response对象完成数据返回
@RequestMapping("/showData1")
public void showData1(HttpServletResponse response) throws IOException {
response.getWriter().print("message");
}
方式二:简化格式
@RequestMapping("/showData2")
@ResponseBody
public String showData2(){
return "message";
}
返回JSON数据
基于response返回数据的简化格式,返回json数据
 //使用jackson进行json数据格式转化
    @RequestMapping("/showData3")
    @ResponseBody
    public String showData3() throws JsonProcessingException {
        Book book  = new Book();
        book.setName("SpringMVC入门案例");
        book.setPrice(66.66d);

        ObjectMapper om = new ObjectMapper();
        return om.writeValueAsString(book);
    }
返回JSON数据(对象)
  • 使用SpringMVC提供的消息类型转换器将对象与几何数据自动转换为json数据
 //使用SpringMVC注解驱动，对标注@ResponseBody注解的控制器方法进行结果转换，由于返回值为引用类型，自动调用jackson提供的类型转换器进行格式转换
    @RequestMapping("/showData4")
    @ResponseBody
    public Book showData4() {
        Book book  = new Book();
        book.setName("SpringMVC入门案例");
        book.setPrice(66.66d);
        return book;
    }

响应JSON数据(常用)

1.0 导包
 <!--json相关坐标3个-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.9.0</version>
    </dependency>

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

    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.9.0</version>
    </dependency>
2.0 spring-mvc配置文件添加注解支持
<mvc:annotation-driven/>
3.0 使用
 @RequestMapping("/mapdata")
    @ResponseBody
    public Map<String, Object> mapdata() {
        Map map = new HashMap();
        map.put("name", "zhangsan");
        map.put("age", 12);
        return map;
    }

06-Servlet相关接口

  • SpringMVC提供访问原始Servlet接口API的功能,通过形参声明即可
//获取request,response,session对象的原生接口
    @RequestMapping("/servletApi")
    public String servletApi(HttpServletRequest request, HttpServletResponse response, HttpSession session){
        System.out.println(request);
        System.out.println(response);
        System.out.println(session);
        return "page";
    }
Head数据获取
@RequestHeader
形参注解
处理器类中的方法形参前方  
作用:绑定请求头数据与对应方法形参间的关系    

  //获取head数据的快捷操作方式
    @RequestMapping("/headApi")
    public String headApi(@RequestHeader("Accept-Encoding") String headMsg){
        System.out.println(headMsg);
        return "page";
    }
Cookie数据获取
@CookieValue
形参注解
处理器类中的方法形参前方
 作用:绑定请求cookie数据与对应处理方法形参间的关系    

 //获取cookie数据的快捷操作方式
    @RequestMapping("/cookieApi")
    public String cookieApi(@CookieValue("JSESSIONID") String jsessionid){
        System.out.println(jsessionid);
        return "page";
    }
Session数据获取
@SessionAttribute
形参注解
处理器类中的方法形参前方
 作用:绑定请求Session数据与对应处理方法形参间的关系  

 //测试用方法，为下面的试验服务，用于在session中放入数据
    @RequestMapping("/setSessionData")
    public String setSessionData(HttpSession session){
        session.setAttribute("name","itheima");
        return "page";
    }

    //获取session数据的快捷操作方式
    @RequestMapping("/sessionApi")
    public String sessionApi(@SessionAttribute("name") String name,
                             @SessionAttribute("age") int age,
                             @SessionAttribute("gender") String gender){
        System.out.println(name);
        System.out.println(age);
        System.out.println(gender);
        return "page";
    }
Session数据设置
@SessionAttributes
形参注解
处理器类中的方法形参前方
作用:声明放入Session范围的变量名称,适用于Model类型数据传参 

@Controller
//设定当前类中名称为age和gender的变量放入session范围，不常用，了解即可
@SessionAttributes(names = {"age","gender"})
public class UserController {
    //配合@SessionAttributes(names = {"age","gender"})使用
    //将数据放入session存储范围，通过Model对象实现数据set，通过@SessionAttributes注解实现范围设定
    @RequestMapping("/setSessionData2")
    public String setSessionDate2(Model model) {
        model.addAttribute("age",39);
        model.addAttribute("gender","男");
        return "page";
    }

}
-=---=
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springmvc 响应封装_SpringMVC概述和基础知识详解
weixin_33132251的博客
01-04 446
一. SpringMVC概述及原理1. SpringMVC是什么Spring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块。使用 Spring 可插入的 MVC 架构，从而在使用Spring进行WEB开发时，可以选择使用Spring的Spring MVC框架或集成其他MVC开发...
c++ 遍历list_Redis列表list 底层原理
weixin_39551366的博客
11-22 411
list在版本3.2之前，Redis 列表list使用两种数据结构作为底层实现：压缩列表ziplist双向链表linkedlist 因为双向链表占用的内存比压缩列表要多， 所以当创建新的列表键时， 列表会优先考虑使用压缩列表， 并且在有需要的时候， 才从压缩列表实现转换到双向链表实现。压缩列表转化成双向链表条件创建新列表时 redis 默认使用 redis_encoding_ziplist 编码，...
java题1
weixin_42175570的博客
10-05 1万+
  1、面向对象的特征有哪些方面      ①抽象：     抽象是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。     ②继承：     继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类...
【前端笔试题】汇总
lorogy的博客
06-17 1万+
前端笔试
史上最全的java spring注解，没有之一
热门推荐
陈袁的博客
05-27 5万+
注解是个好东西，但好东西我们也是看见过，整理过，理解过，用过才知道好。不求我们每个都记住，但求保有印象，在需要的时候能提取出来再查找相关资料，平时工作就不会显得那么被动了。1.@Configuration注解该类等价 与XML中配置beans，相当于Ioc容器，它的某个方法头上如果注册了@Bean，就会作为这个Spring容器中的Bean，与xml中配置的bean意思一样。@Configurati...
Java Web 过滤器
A2113438464的博客
12-06 534
Java Web 过滤器 什么是过滤器(Filter)应用场景思维导图创建Filter1. 创建一个类2. 实现接口Filter3. 鼠标悬浮在类名上，点击Add unimplemented methods5. 在web.xml中配置FilterFilter接口中doFilter方法案例----统一设置编码格式 什么是过滤器(Filter) 过滤器：任何实现了Filter接口的类称为过滤器类。 实际上就是对web资源进行拦截，做一些处理后再交给下一个过滤器或servlet处理 通常都是用来拦截request
初识SpringMVC以及springmvc基本应用入门案例彩色PPT版本.pptx
05-29
【入门案例】 开发一个基于 SpringMVC 的 Web 程序通常包括以下步骤： 1. 创建 Maven 结构的 Web 工程。 2. 配置 Tomcat 服务器，并使用 Tomcat 插件加载 Web 工程。 3. 在 pom.xml 文件中导入 SpringMVC 和 ...
springmvc测试入门示例
06-21
SpringMVC是Spring框架的一个模块，专为...通过这个入门示例，你将能够了解SpringMVC的基础架构，以及如何进行单元测试和集成测试。实践是最好的老师，尝试修改代码并编写新的测试案例，将有助于巩固你的理解和技能。
springmvc-demo01-start.zip
09-12
在本入门案例 "springmvc-demo01-start.zip" 中，我们将探索如何设置和运行一个基本的 Spring MVC 项目。 首先，创建 Spring MVC 项目时，我们需要以下组件： 1. **Spring Framework**：这是基础，提供了丰富的库...
springmvc教学案例
02-24
Spring MVC 是一款强大的Java Web开发框架，用于构建可维护、高性能的Web应用程序。Spring MVC是Spring框架的一个...通过这个入门级教学案例，你可以快速掌握Spring MVC的基础，为进一步深入学习和实践打下坚实的基础。
SpringMVC 学习总结
12-05
SpringMVC 的入门案例通常包括以下步骤： 1. 创建一个新的 Web 动态工程或 Maven 项目。 2. 添加 SpringMVC 和 Servlet API 的 Maven 依赖。 3. 配置 web.xml，设置 DispatcherServlet 作为前端控制器，并定义 ...
SpringMVC中Controller里面的那些注解
小小默：进无止境
02-20 3808
# 【1】Controller的声明 SpringMVC提供了一个基于注解的编程模型，带有`@Controller`和`@RestController`注解的组件使用注解来表示请求映射、请求输入、异常处理等。带注解的控制器具有灵活的方法签名，不必扩展基类，也不必实现特定的接口。 **以下示例显示了由注解定义的控制器：** ```java @Controller public class HelloController { @GetMapping("/hello") public Str
SpringMVC二、SpringMVC使用基本使用
吃透Java
04-12 315
一、SpringMVC的请求处理 1、SpringMVC对请求参数的处理 在之前的servlet中我们可以通过request.getParameter()来获取请求中的参数，但是在我们编写的SpringMVC的应用程序中，在具体请求的方法中并不包含request参数，那么我们应该如何获取请求中的参数呢？ 需要使用以下几个注解： @RequestParam：获取请求的参数 @RequestHead...
XXL-JOB配置笔记
u010679782的博客
02-26 1万+
本人在配置XXL-JOB的配置笔记 1、下载xxl-job，然后导入到IDEA中 地址1：https://github.com/xuxueli/xxl-job 地址2：http://gitee.com/xuxueli0323/xxl-job 2、在xxl-job-admin中的application.properties配置中把 数据库地址和用户名密码修改成自己的 3、启动xx...
Alibaba Sentinel RESTful 接口流控处理优化
我的程序人生(亦山札记)
06-12 8980
0.前言 笔者最近打算使用Sentinel替换掉之前的Hystrix作为微服务架构的熔断/断路组件。整体上，Sentinel的设计比Hystrix要易用很多。在实际使用的过程中，也存在了一些问题。本文将介绍Sentinel 在处理RESTful 风格的web项目过程中存在的问题。 问题描述： 在Spring Cloud架构下，如果Http请求格式是按照RESTful风格设计的，当大规模的Http...
Java试题大全
weixin_34306446的博客
09-20 9326
J2EE是什么？它包括哪些技术？ 解答：从整体上讲，J2EE是使用Java技术开发企业级应用的工业标准 主要包括以下这些技术： 1) Servlet Servlet是Java平台上的CGI技术。Servlet在服务器端运行，动态地生成Web页面。 对于Servlet，重复的请求不会导致同一程序的多次转载，它是依靠线程的方式来支持并发访问的。 2)JSP JSP(Java Server...
Spring MVC—XML配置与注解配置+使用注解完成请求参数绑定
qwe123147369的博客
06-12 378
SpringMVC应用开发流程剖析：XML配置与注解配置 提供了一个入门案例来深入理解SpringMVC的请求处理流程，同时熟悉SpringMVC的应用开发流程。开发一个SpringMVC应用，首先需要为我们的Web项目添加Spring支持，然后我们就可以采用基于XMl配置的方式或者基于注解配置方式进行应用的构建。本节将分别演示基于XML配置和Annotation配置的SpringMVC 应用。...
SpringBoot整合Elastic-Job 2.1.53版本任务调度，手动任务，动态添加任务演示
最新发布
小哇
07-23 397
zookeeper安装并成功运行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值