SpringMVC

最新推荐文章于 2024-05-08 18:58:33 发布
原创 最新推荐文章于 2024-05-08 18:58:33 发布 · 204 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#Java

Springmvc学习

一. 框架的搭建

1. 加入依赖坐标
 <dependencies>
    <!-- junit的jar包坐标 -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>
    <!-- mysql-connector-java -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.38</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
    <dependency>
      <groupId>com.mchange</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.5.2</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.9</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>4.3.7.RELEASE</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>4.3.7.RELEASE</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-beans -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.3.7.RELEASE</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.3.7.RELEASE</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>4.3.7.RELEASE</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-expression -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>4.3.7.RELEASE</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-tx -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>4.3.7.RELEASE</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>4.3.7.RELEASE</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-web -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>4.3.7.RELEASE</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>4.3.7.RELEASE</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>4.3.7.RELEASE</version>
      <scope>test</scope>
    </dependency><!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.4.4</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
    <!--MyBatis整合spring-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.0</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.mybatis.generator/mybatis-generator-core -->
    <dependency>
      <groupId>org.mybatis.generator</groupId>
      <artifactId>mybatis-generator-core</artifactId>
      <version>1.3.5</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>
  
</dependencies>




  <build>
    <finalName>SpringMvc_01</finalName>
    <!--<pluginManagement>--><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <!-- 配置tomcat插件 -->
        <plugin>
          <groupId>org.apache.tomcat.maven</groupId>
          <artifactId>tomcat7-maven-plugin</artifactId>
          <configuration>
            <path>/</path>
            <port>8080</port>
            <uriEncoding>UTF-8</uriEncoding>
          </configuration>
        </plugin>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    <!--</pluginManagement>-->
  </build>
</project>
2.配置web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
         http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         id="WebApp_ID" version="3.0">

<!-- 加载spring配置文件 -->
<!-- 关联到spring主配置文件的路径地址  classpath根目录-->
<context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>classpath:spring/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:mvc/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>

</web-app>
3.Springmvc核心配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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">

    <!-- 开启注解驱动 -->
    <context:component-scan base-package="com.kgc.controller"></context:component-scan>

    <!-- 开启mvc注解驱动 -->
    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
               <constructor-arg value="UTF-8" /><!--解决@responsebody响应中文乱码-->
            </bean>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
        </mvc:message-converters>
    </mvc:annotation-driven>

    <mvc:default-servlet-handler/>
    <!-- 视图解析器  location表示路径地址 -->

   <!-- <mvc:resources mapping="/css/**" location="/css/"/>
    <mvc:resources mapping="/js/**" location="/js/"/>
    <mvc:resources mapping="/jsp/**" location="/jsp/"/>
    <mvc:resources mapping="/html/**" location="/html/"/>-->


    <!-- 处理jsp页面所在的前缀和后缀 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 前缀,确定当前访问的页面路径地址 -->
        <property name="prefix">
            <value>/WEB-INF/jsp/</value><!-- 放在WEB-INF文件夹之下的page文件夹 -->
        </property>
        <!-- 后缀,确定要访问的文件类型 -->
        <property name="suffix">
            <value>.jsp</value>
        </property>
    </bean>
</beans>
4. 添加spring核心配置文件
<?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:aop="http://www.springframework.org/schema/aop"
       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/tx
          http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 1.开启spring注解驱动 -->
    <context:component-scan base-package="com.kgc.service"></context:component-scan>
    <!-- 2.读取properties -->
    <context:property-placeholder location="classpath:properties/db.properties"/>

    <!--3. 配置数据库连接池 c3p0 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" >
        <property name="driverClass" value="${jdbc.driver}"/>
        <!-- 配置Jdbc的Url -->
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <!-- 配置用户名 -->
        <property name="user" value="${jdbc.username}"/>
        <!-- 密码 -->
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!-- 4.配置事务管理器 -->
    <bean id="transactionManager"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 事务管理数据库连接池 -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--5. 开启事务的注解驱动 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

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

    <!-- 7.spring管理mybatis映射接口和sql映射文件之间关联关系 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.kgc.mapper" />
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
    </bean>
</beans>
5. 添加mybatis核心配置文件
<?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.kgc.pojo"/>
    </typeAliases>

    <!-- 分页插件 -->
    <!-- <plugins>            
         <plugin interceptor="com.github.pagehelper.PageInterceptor">                           	3.3.0版本可用 - 分页参数合理化，默认false禁用         
           pageNum表示当前页  pages表示尾页         
          true启用合理化时，如果pageNum<1会查询第一页，如果pageNum>pages会查询最后一页                     false禁用合理化时，如果pageNum<1或pageNum>pages会返回空数据            
         <property name="reasonable"   value="true"/>    
       </plugin>        
     </plugins> -->
    
</configuration>
6.分析配置文件关联关系

二. Springmvc知识

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

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

  2. SpringMVC是一个MVC模式的WEB开发框架;

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

2.DispatcherServlet 处理流程
  • 在整个 Spring MVC 框架中，DispatcherServlet 处于核心位置，它负责协调和组织不同组件完成请求处理并返回响应工作。在看 DispatcherServlet 类之前，我们先来看一下请求处理的大致流程：
  1. Tomcat 启动，对 DispatcherServlet 进行实例化，然后调用它的 init() 方法进行初始化，在这个初始化过程中完成了：
  • 对 web.xml 中初始化参数的加载；
  • 建立 WebApplicationContext (SpringMVC的IOC容器)；
  • 进行组件的初始化；

  1. 客户端发出请求，由 Tomcat 接收到这个请求，如果匹配 DispatcherServlet 在 web.xml 中配置的映射路径，Tomcat 就将请求转交给 DispatcherServlet 处理；

  2. DispatcherServlet 从容器中取出所有 HandlerMapping 实例（每个实例对应一个 HandlerMapping 接口的实现类）并遍历，每个 HandlerMapping 会根据请求信息，通过自己实现类中的方式去找到处理该请求的 Handler (执行程序，如Controller中的方法)，并且将这个 Handler 与一堆 HandlerInterceptor (拦截器) 封装成一个 HandlerExecutionChain 对象，一旦有一个 HandlerMapping 可以找到 Handler 则退出循环；（详情可以看[ Java]SpringMVC工作原理之二：HandlerMapping和HandlerAdpater 这篇文章）

  3. DispatcherServlet 取出 HandlerAdapter 组件，根据已经找到的 Handler，再从所有 HandlerAdapter 中找到可以处理该 Handler 的 HandlerAdapter 对象；

  4. 执行 HandlerExecutionChain 中所有拦截器的 preHandler() 方法，然后再利用 HandlerAdapter 执行 Handler ，执行完成得到 ModelAndView，再依次调用拦截器的 postHandler() 方法；

  5. 利用 ViewResolver 将 ModelAndView 或是 Exception（可解析成 ModelAndView）解析成 View，然后 View 会调用 render() 方法再根据 ModelAndView 中的数据渲染出页面；

  6. 最后再依次调用拦截器的 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. 类的注解

  1. @controller:用于标注控制层类的注解

  2. @service:用于标注业务层组件

  3. @repository:注解数据访问层

  4. @Component 应用于任何层

2. 属性的注解

  1. @Autowired 自动装配，修饰属性

  2. @resource 根据名称注解属性

3. springmvc特有注解

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

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

  • @requestParam主要用于在SpringMVC后台控制层获取参数，类似一种是request.getParameter(“name”)，它有三个常用参数：

    • defaultValue = “0”, required = false, value = “isApp”；

    • defaultValue 表示设置默认值，

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

      如果为null,则报异常。

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

  1. @DateTimeFormat(pattern=“yyyy-MM-dd”)注解date时间格式把国际格式改为中文格式，应用于pojo类的date类型属性之上
  2. 参数注解
  • @PathVariable只能修饰从路径中获取的参数,用于将请求URL中的模板变量映射到功能处理方法的参数上，即取出uri模板中的变量作为参数
案例–获取参数

1.测试post和get方式提交参数

  • controller
//测试post
    @RequestMapping(value = "test4",method = RequestMethod.POST)
    public void test4(@RequestParam(name = "name")String name1,
                      @RequestParam(name = "age") int age1,
                      @DateTimeFormat(pattern = "yyyy-MM-dd") Date birth){
        System.out.println(name1);
        System.out.println(age1);
        System.out.println(birth);
    }
  • jsp
<form method="post" action="/test4">
    <input type="text" name="name"><br>
    <input type="text" name="age"><br>
    <input type="date" name="birth"><br>
    <input type="submit" value="提交">
</form>

2.一次性获取所有的请求参数

 //测试--一次性获取所有的请求参数
    @RequestMapping(value = "test6",method = RequestMethod.POST)
    public void test6(@RequestParam Map map){
        Set<Map.Entry> set = map.entrySet();
        for(Map.Entry entry:set){
            System.out.println(entry.getKey()+"--"+entry.getValue());
        }
    }

3.获取rest风格请求参数

@RequestMapping(value = "/test7/{name}")
    public void test3(@PathVariable String name){
        System.out.println(name);    
    }

  1. @ResponseBody(意思就是把传入的参数类型转化为json或者xml格式)，应用于方法之上，适用于ajax后台

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

  • 使用时机：返回的数据不是html标签的页面，而是其他某种格式的数据时（如json、xml等）使用；

  • 其实就是为了把传出或者传入的参数类型转变成json，xml类型

案例–响应正文
  1. 响应字符串
 //测试响应正文
    @RequestMapping(value = "test8",produces = "text/html;charset=utf-8")
    @ResponseBody
    public String test8(){
        return "你好";
    }
  1. 以json格式响应pojo对象
  • 导入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>
  • 在springmvc配置类型转化配置
<!-- 开启mvc注解驱动 -->
    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
               <constructor-arg value="UTF-8" /><!--解决response响应中文乱码-->
            </bean>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
        </mvc:message-converters>
    </mvc:annotation-driven>
  • 代码演示
@RequestMapping("/test2")
    @ResponseBody
    public User test2(){
        User user = new User();
        user.setName("李白");
        return user;
    }
  • 展示效果

[外链图片转存失败(img-wuKibtXk-1564973616040)(C:\Users\CX\AppData\Roaming\Typora\typora-user-images\1556548396761.png)]

案例–页面跳转
1. String类型

  • Model接口类型：模型，用来承载数据，

  • Servlet形式承载数据

//方法的请求映射，利用model传值
	@RequestMapping("/test1.do")
	public String test1(Model model){
		//把数据k-v保存在model类中，其实保存在request作用域中
		model.addAttribute("message", "错误信息");
		return "test";//渲染视图，跳页面
	}
	//利用servlet传值
	@RequestMapping("/test2.do")
	public String test2(HttpServletRequest request){
		request.setAttribute("message", "serlvet请求信息");
		request.getSession().setAttribute("aa", "session信息");
		request.getSession().getServletContext().setAttribute("bb", "application");
		return "test";
	}
2. ModelAndView类型
  • 表示模型与视图，既可以进行传值，又可以进行渲染视图
//方法的请求映射，ModelAndView
	@RequestMapping("/test3.do")
	public ModelAndView test3(ModelAndView mav){
		mav.addObject("message", "成功信息");
		mav.setViewName("test");//渲染视图，跳页面
		return mav;
	}
	//方法的请求映射，ModelAndView
	@RequestMapping("/test4.do")
	public ModelAndView test4(){
		ModelAndView mav=new ModelAndView("test");
		mav.addObject("message", "成功信息");
		mav.setViewName("test");//渲染视图，跳页面
			return mav;
	}
  • 所有的存储数据model，modelMap,modelAndView默认保存在request作用域中
  • model和modelMap，modelAndView的区别
课堂案例：
1.获取请求参数
@Controller
public class TestController {

    @RequestMapping("/test1")//如果不使用@RequestParam，方法的形参和url中的参数 名一致
    public void test1(String name){
        System.out.println(name);
        System.out.println("ssm整合1");
    }

    @RequestMapping("/test2")//@RequestParam(name = "name") a=request.getParameter("name")
    public void test2(@RequestParam(name = "name")String a){
        System.out.println(a);
        System.out.println("ssm整合2");
    }

    @RequestMapping(value = "/testPost",method = RequestMethod.POST)//测试post提交
    public void testPost(String name, int age, @DateTimeFormat(pattern = "yyyy-MM-dd") Date birth){
        System.out.println(name);
        System.out.println(age);
        System.out.println(birth);
    }

    @RequestMapping(value ="/testGET",method = RequestMethod.GET)//测试get提交
    public void testMap(@RequestParam Map map){
        Set<Map.Entry> set = map.entrySet();
        for(Map.Entry entry:set){
            System.out.println(entry.getKey()+"--"+entry.getValue());
        }
    }
    @RequestMapping(value ="/testUser")//测试get提交 自动检测
    public void testUser(User user){
        System.out.println(user);
    }
    //rest风格 请求参数 
   @RequestMapping("/testRest/{name1}/{age}/{birth}")//参数名不在url中，在注解的路径里
    public void testRest(@PathVariable String name1,
                         @PathVariable int age,
                         @PathVariable String birth){
        System.out.println(name1);
        System.out.println(age);
        System.out.println(birth);
    }
}
2.响应正文和页面跳转
@Controller
@RequestMapping("/con1")
public class TestController1 {

    @RequestMapping("/test1")
    @ResponseBody //response.getWriter.write("hello ssm")
    public String test1(){
        return "hello ssm";
    }
    @RequestMapping("/test2")
    @ResponseBody //response.getWriter.write(u)
    public User test2(){
        User u = new User();
        u.setName("黑冰");
        u.setAge(19);
        return u;
    }
//上面是响应正文 下面是页面的跳转

    @RequestMapping("/test3")//测试页面跳转 ：model  modelMap  dodelAndView
    public String test3(Model model, ModelMap map){
        model.addAttribute("name","红冰");
        map.addAttribute("name1","黄冰");
        //request  域中
        return "test";//自动拼接前后缀 转发 到 对应的jsp
    }

    @RequestMapping("/test4")//测试页面跳转 ：model  modelMap  dodelAndView
    public ModelAndView test4(ModelAndView mav){//ModelAndView:1.Model 向request域中添加参数 2.View：jsp名字
        //1.Model 向request域中添加参数
        mav.addObject("name2","冰冰");
        //2.封装jsp逻辑视图名
        mav.setViewName("test");
        return mav;  //自动拼接前后缀 转发 到 对应的jsp
    }
    //重定向
    @RequestMapping("/test5")
    public String test5(Model m){
        //1.向request域中添加参数
        m.addAttribute("name3","3冰冰");
        //return "redirect:/";  //重定向 时 request域失效 ，model中的参数作为url的请求参数
        return "redirect:test4";//重定向的路径：1.非web-inf下的jsp 2.其它的RequestMapping路径
    }


}
  • jsp请求页面
<form action="/testPost" method="post">
    <input type="text" name="name"><br>
    <input type="text" name="age"><br>
    <input type="date" name="birth"><br>
    <input type="submit" value="提交">
</form>

<h1><a href="/testGET?name=白冰&age=6&birth=2001-10-12">测试get请求</a></h1>

<h1><a href="/testUser?name=白冰&age=6&birth=2001-10-12">测试get请求--用pojo对象接收参数</a></h1>
<%--1. ?变成/ 2.不写参数名 --%>
<h1><a href="/testRest/白冰/16/2014-15-16">测试rest风格提交参数</a></h1>


<h1>name:${name}</h1>
<h1>name1:${name1}</h1>
5.编码格式–乱码处理

  • get请求乱码 --pom.xml

    <!-- 配置tomcat插件 -->
        <plugin>
          <groupId>org.apache.tomcat.maven</groupId>
          <artifactId>tomcat7-maven-plugin</artifactId>
          <configuration>
            <path>/</path>
            <port>8080</port>
            <uriEncoding>UTF-8</uriEncoding>
          </configuration>
        </plugin>

  • post请求乱码–web.xml

    <!-- 配置过滤器，过滤编码格式 为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>

  • @responsebody响应乱码–springmvc.xml

<!-- 开启mvc注解驱动 -->
    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
               <constructor-arg value="UTF-8" /><!--解决response响应中文乱码-->
            </bean>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
        </mvc:message-converters>
    </mvc:annotation-driven>
Ken_ki
关注
springmvc处理模型数据ModelAndView过程详解
08-25
主要介绍了springmvc处理模型数据ModelAndView过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
quarkus 搭建与基础开发环境配置总结
liuyij3430448的博客
03-06 5644
Quarkus是一个集成了Kubernetes的开源云原生框架， 基于ApacheLicense 2.0发布， 用于创建适配GraalVM和OpenJDK HotSpot的 Kubernetes原生应用， 基于Hibernate、 Eclipse MicroProfile、Kubernetes、 Apache Camel和Eclipse Vert.x等流行库和技术构建。
SpringMVC汇总
Caristop3_走在前端这条大道上
06-13 476
SpringMVC
springboot中ModelAndView跳转设置
weixin_44083915的博客
12-09 4681
thymeleaf默认的是找.html文件，在templates文件夹下面的 如果你想更改搜索的位置 你可以在application.yml或者application.properties 中设置。我要跳转的目标是：templates/admin/login.html。最后使用thymeleaf时前端加上下面的这个数据才能生效。mvnrepository上面找到你想要的版本进行设置。如果不想用自带的版本 可以去。
springmvc常用注解标签详解
Stay hungry, Stay foolish
10-02 836
转：http://www.cnblogs.com/leskang/p/5445698.html 1、@Controller 在SpringMVC 中，控制器Controller 负责处理由DispatcherServlet 分发的请求，它把用户请求的数据经过业务处理层处理之后封装成一个Model ，然后再把该Model 返回给对应的View 进行展示。在SpringMV
Spring框架中ModelAndView用法分享
tongxinxiao的专栏
09-23 3万+
【写在前面】：很久没写博客了，
【SpringMVC】| SpringMVC 入门
m0_61933976的博客
04-25 3911
【SpringMVC】| SpringMVC 入门
SpringMVC——SpringMVC框架基本概述
莫得感情得码农
08-11 5万+
1.SpringMVC框架概述 1.1 SpringMVC框架的基本说明 SpringMVC是基于Spring的，是Spring中的一个模块，专门用来做web开发使用的。 SpringMVC 也叫 Spring web mvc。是 Spring 框架的一部分，是在Spring3.0 后发布的。基于 MVC 架构，功能分工明确、解耦合。 SpringMVC也是一个容器，使用IoC核心技术，管理界面层中的控制器对象。SpringMVC的底层就是servlet，以servlet为核心，接收请求、处理请.
SpringMVC | 快速上手SpringMVC
BoBooY的Java学习笔记
10-28 3312
本节讲解了SpringMVC的基本使用
【SpringMVC 】什么是SpringMVC（三）？基于springmvc的文件上传、基于springmvc的拦截器、基于springmvc的邮件发送
m0_74187147的博客
05-08 1541
@@@@@@@@@@@邮件发送 通过java进行邮件发送，会涉及到两种协议： 1、smtp 简单邮件传输协议 作用：用于指定如何发送邮件 2、pop3 邮局协议版本3 作用：用于指定如何接收邮件 @@@@@@@@我们在进行邮件发送时，首先需要开通邮箱的这两个协议 @@@@@@@@邮件发送的过程 此处，我们以QQ邮箱为例，进行配置,准备工作 登录QQ邮箱，开通smtp,pop3协议
SpringMVC_1
一个小白
11-25 552
1.什么是SpringMVC? Spring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。 Spring 框架提供的web模块，包含了开发Web 应用程序的全功能 MVC 模块。从而在使用Spring进行WEB开发时，可以选择使用Spring的SpringMVC框架。集成其他WEB MVC开发框架，如Struts(现在一般不用)，Struts2(一般老项目使用)等。 SpringMVC是web层的mvc开发框架，属于Spring框架的WEB模块中的一个部
ModelAndView
qq_38103699的博客
03-21 2242
ModelAndView 前提 首先梳理一下Spring Web MVC处理http请求的大致过程： 当http请求到来时，DispatcherServlet负责将请求进行分发。DispatcherServlet可以认为是Spring提供的前端控制器，所有的请求都要经过它来统一分发。 在DispatchServlet中有重写的doService()方法，此方法中又调用doDispatch()，doDispatch()方法调用getHandler()，在getHandler方法中使用了变量this.han
关于对ModelAndView自己的理解
静风落叶的博客
11-27 8572
之前学习的时候遇见过这个ModelAndView，但是一直不知道是什么意思，今天在项目里面遇到了，就理解下，加深自己的印象，以下内容均是本人对此理解，欢迎一起留言讨论。     首先ModelAndView 分为两部分：model和view。model负责的是从后面接收回来的参数，view就是视图就是指定的jsp页面。例如：ModelAndView mv = new ModelAndView("
Springboot 下 ModelAndView 的简单使用
LoveInTheSky的博客
11-09 1万+
本文简单介绍在Springboot下ModelAndVIew 的简单使用。
produces在@requestMapping中的使用方式和作用
热门推荐
jaryle的专栏
06-09 14万+
produces可能不算一个注解，因为什么呢，它是注解@requestMapping注解里面的属性项， 它的作用是指定返回值类型，不但可以设置返回值类型还可以设定返回值的字符编码； 还有一个属性与其对应，就是consumes： 指定处理请求的提交内容类型（Content-Type），例如application/json, text/html; 他们的使用方法如下： 一、produces的
java produces_@produces在spring mvc中是什么意思
weixin_42515058的博客
02-16 1226
@RequestMapping(value = "/produces", produces = "application/json")：表示将功能处理方法将生产json格式的数据，此时根据请求头中的Accept进行匹配，如请求头“Accept:application/json”时即可匹配;@RequestMapping(value = "/produces", produces = "applic...
@Produces注解
ArvinWoo
11-07 3万+
《Java RESTful Web Service实战（第2版）》第2章REST API设计，本章是REST理论和Jersey实践的核心章节，详细讲述了HTTP方法与REST API的统一接口设计、URI的REST风格设计，并逐个讲述了JAX-RS2定义的注解如何支持资源定位，还对Jersey对各种表述类型的支持和实现、Jersey对REST连通性的两种实现、REST资源方法对响应的处理以及Jers
ModelAndView详解
diandu2747的专栏
01-11 3436
ModelAndView的构造方法有7个。但是它们都是相通的。这里使用无参构造函数来举例说明如何构造ModelAndView实例。ModelAndView类别就如其名称所示，是代表了MVC Web程序中Model与View的对象，不过它只是方便您一次返回这两个对象的holder，Model与View两者仍是分离的概念。　最简单的ModelAndView是持有View的名称返回，...
springmvc 之 ModelAndView的简单使用
菜鸟程序员成长路
05-23 6582
转自：https://www.cnblogs.com/Sunnor/p/6130380.html 参考：http://blog.csdn.net/zzjjiandan/article/details/34089313先上图： MAVTest.java 1 package com.wyl; 2 3 import java.util.ArrayList; 4 import java.util....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值