ch01-hello-springmvc
业务
ch01-hello-springmvc: 第一个springmvc项目。
需求： 用户在页面发起一个请求， 请求交给springmvc的控制器对象，
并显示请求的处理结果（在结果页面显示一个欢迎语句）。
实现步骤：
1. 新建web maven工程
2. 加入依赖
spring-webmvc依赖，间接把spring的依赖都加入到项目
jsp，servlet依赖
3.重点： 在web.xml中注册springmvc框架的核心对象DispatcherServlet
1)DispatcherServlet叫做中央调度器， 是一个servlet， 它的父类是继承HttpServlet
2)DispatcherServlet页叫做前端控制器（front controller）
3)DispatcherServlet负责接收用户提交的请求， 调用其它的控制器对象，
并把请求的处理结果显示给用户
4.创建一个发起请求的页面 index.jsp
5.创建控制器(处理器)类
1）在类的上面加入@Controller注解，创建对象，并放入到springmvc容器中
2）在类中的方法上面加入@RequestMapping注解。
6.创建一个作为结果的jsp，显示请求的处理结果。
7.创建springmvc的配置文件（spring的配置文件一样）
1）声明组件扫描器， 指定@Contorller注解所在的包名
2）声明视图解析器。帮助处理视图的。
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.bjpowernode</groupId>
<artifactId>ch01-hello-springmvc</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<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>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<!--servlet依赖-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
<!--springmvc依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
</dependencies>
<build>
<plugins>
<!-- 编码和编译和JDK版本 -->
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
MyController
package com.bjpowernode.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.view.RedirectView;
import javax.xml.ws.RequestWrapper;
/**
* @Controller:创建处理器对象，对象放在springmvc容器中。
* 位置：在类的上面
* 和Spring中讲的@Service ,@Component
*
* 能处理请求的都是控制器（处理器）： MyController能处理请求，
* 叫做后端控制器（back controller）
*
* 没有注解之前，需要实现各种不同的接口才能做控制器使用
*/
@Controller
public class MyController {
/*
处理用户提交的请求，springmvc中是使用方法来处理的。
方法是自定义的， 可以有多种返回值， 多种参数，方法名称自定义
*/
/**
* 准备使用doSome方法处理some.do请求。
* @RequestMapping: 请求映射，作用是把一个请求地址和一个方法绑定在一起。
* 一个请求指定一个方法处理。
* 属性： 1. value 是一个String，表示请求的uri地址的（some.do）。
* value的值必须是唯一的， 不能重复。 在使用时，推荐地址以“/”
* 位置：1.在方法的上面，常用的。
* 2.在类的上面
* 说明： 使用RequestMapping修饰的方法叫做处理器方法或者控制器方法。
* 使用@RequestMapping修饰的方法可以处理请求的，类似Servlet中的doGet, doPost
*
* 返回值：ModelAndView 表示本次请求的处理结果
* Model: 数据，请求处理完成后，要显示给用户的数据
* View: 视图， 比如jsp等等。
*/
@RequestMapping(value = {"/some.do","/first.do"})
public ModelAndView doSome(){ // doGet()--service请求处理
//处理some.do请求了。 相当于service调用处理完成了。
ModelAndView mv = new ModelAndView();
//添加数据， 框架在请求的最后把数据放入到request作用域。
//request.setAttribute("msg","欢迎使用springmvc做web开发");
mv.addObject("msg","欢迎使用springmvc做web开发");
mv.addObject("fun","执行的是doSome方法");
//指定视图, 指定视图的完整路径
//框架对视图执行的forward操作， request.getRequestDispather("/show.jsp).forward(...)
//mv.setViewName("/show.jsp");
//mv.setViewName("/WEB-INF/view/show.jsp");
//mv.setViewName("/WEB-INF/view/other.jsp");
//当配置了视图解析器后，可以使用逻辑名称（文件名），指定视图
//框架会使用视图解析器的前缀 + 逻辑名称 + 后缀 组成完成路径， 这里就是字符连接操作
///WEB-INF/view/ + show + .jsp
mv.setViewName("show");
//mv.setView( new RedirectView("/a.jsp"));
//返回mv
return mv;
}
@RequestMapping(value = {"/other.do","/second.do"})
public ModelAndView doOther(){
ModelAndView mv = new ModelAndView();
mv.addObject("msg","====欢迎使用springmvc做web开发====");
mv.addObject("fun","执行的是doOther方法");
mv.setViewName("other");
return mv;
}
}
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: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/context https://www.springframework.org/schema/context/spring-context.xsd">
<!--声明组件扫描器-->
<context:component-scan base-package="com.bjpowernode.controller" />
<!--声明 springmvc框架中的视图解析器， 帮助开发人员设置视图文件的路径-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--前缀：视图文件的路径-->
<property name="prefix" value="/WEB-INF/view/" />
<!--后缀：视图文件的扩展名-->
<property name="suffix" value=".jsp" />
</bean>
</beans>
index.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<p>第一个springmvc项目</p>
<p><a href="some.do">发起some.do的请求</a> </p>
<p><a href="other.do">发起other.do的请求</a> </p>
</body>
</html>
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">
<!--声明，注册springmvc的核心对象DispatcherServlet
需要在tomcat服务器启动后，创建DispatcherServlet对象的实例。
为什么要创建DispatcherServlet对象的实例呢？
因为DispatcherServlet在他的创建过程中， 会同时创建springmvc容器对象，
读取springmvc的配置文件，把这个配置文件中的对象都创建好， 当用户发起
请求时就可以直接使用对象了。
servlet的初始化会执行init（）方法。 DispatcherServlet在init（）中{
//创建容器，读取配置文件
WebApplicationContext ctx = new ClassPathXmlApplicationContext("springmvc.xml");
//把容器对象放入到ServletContext中
getServletContext().setAttribute(key, ctx);
}
启动tomcat报错，读取这个文件 /WEB-INF/springmvc-servlet.xml（/WEB-INF/myweb-servlet.xml）
springmvc创建容器对象时，读取的配置文件默认是/WEB-INF/<servlet-name>-servlet.xml .
-->
<servlet>
<servlet-name>myweb</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--自定义springmvc读取的配置文件的位置-->
<init-param>
<!--springmvc的配置文件的位置的属性-->
<param-name>contextConfigLocation</param-name>
<!--指定自定义文件的位置-->
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<!--在tomcat启动后，创建Servlet对象
load-on-startup:表示tomcat启动后创建对象的顺序。它的值是整数，数值越小，
tomcat创建对象的时间越早。 大于等于0的整数。
-->
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>myweb</servlet-name>
<!--
使用框架的时候， url-pattern可以使用两种值
1. 使用扩展名方式， 语法 *.xxxx , xxxx是自定义的扩展名。 常用的方式 *.do, *.action, *.mvc等等
不能使用 *.jsp
http://localhost:8080/myweb/some.do
http://localhost:8080/myweb/other.do
2.使用斜杠 "/"
-->
<url-pattern>*.do</url-pattern>
</servlet-mapping>
</web-app>
show.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h3>/WEB-INF/view/show.jsp从request作用域获取数据</h3><br/>
<h3>msg数据：${msg}</h3><br/>
<h3>fun数据：${fun}</h3>
</body>
</html>
other.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h3>/WEB-INF/view/other.jsp从request作用域获取数据</h3><br/>
<h3>msg数据：${msg}</h3><br/>
<h3>fun数据：${fun}</h3>
</body>
</html>
ch02-requestmapping
业务
ch02-requestmapping: @RequestMapping的使用实现步骤：1. 新建web maven工程2. 加入依赖 spring-webmvc依赖，间接把spring的依赖都加入到项目 jsp，servlet依赖3.重点： 在web.xml中注册springmvc框架的核心对象DispatcherServlet 1)DispatcherServlet叫做中央调度器， 是一个servlet， 它的父类是继承HttpServlet 2)DispatcherServlet页叫做前端控制器（front controller） 3)DispatcherServlet负责接收用户提交的请求， 调用其它的控制器对象， 并把请求的处理结果显示给用户4.创建一个发起请求的页面 index.jsp5.创建控制器(处理器)类 1）在类的上面加入@Controller注解，创建对象，并放入到springmvc容器中 2）在类中的方法上面加入@RequestMapping注解。6.创建一个作为结果的jsp，显示请求的处理结果。7.创建springmvc的配置文件（spring的配置文件一样） 1）声明组件扫描器， 指定@Contorller注解所在的包名 2）声明视图解析器。帮助处理视图的。
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.bjpowernode</groupId> <artifactId>ch02-requestmapping</artifactId> <version>1.0-SNAPSHOT</version> <packaging>war</packaging> <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> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.11</version> <scope>test</scope> </dependency> <!--servlet依赖--> <dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>3.1.0</version> <scope>provided</scope> </dependency> <!--springmvc依赖--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.2.5.RELEASE</version> </dependency> </dependencies> <build> <plugins> <!-- 编码和编译和JDK版本 --> <plugin> <artifactId>maven-compiler-plugin</artifactId> <version>3.1</version> <configuration> <source>1.8</source> <target>1.8</target> </configuration> </plugin> </plugins> </build></project>
Controller
package com.bjpowernode.controller;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestMethod;import org.springframework.web.servlet.ModelAndView;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import javax.servlet.http.HttpSession;import javax.xml.ws.RequestWrapper;/** * @RequestMapping: * value ： 所有请求地址的公共部分，叫做模块名称 * 位置： 放在类的上面 */@Controller@RequestMapping("/user")public class MyController { /** * @RequestMapping : 请求映射 * 属性： method， 表示请求的方式。 它的值RequestMethod类枚举值。 * 例如表示get请求方式， RequestMethod.GET * post方式， RequestMethod.POST * * 你不用get方式，错误是： * HTTP Status 405 - Request method 'GET' not supported */ //指定some.do使用get请求方式 @RequestMapping(value = "/some.do",method = RequestMethod.GET) public ModelAndView doSome(){ // doGet()--service请求处理 //处理some.do请求了。 相当于service调用处理完成了。 ModelAndView mv = new ModelAndView(); mv.addObject("msg","欢迎使用springmvc做web开发"); mv.addObject("fun","执行的是doSome方法"); mv.setViewName("show"); return mv; } //指定other.do是post请求方式 @RequestMapping(value = "/other.do",method = RequestMethod.POST) public ModelAndView doOther(){ ModelAndView mv = new ModelAndView(); mv.addObject("msg","====欢迎使用springmvc做web开发===="); mv.addObject("fun","执行的是doOther方法"); mv.setViewName("other"); return mv; } //不指定请求方式，没有限制 @RequestMapping(value = "/first.do") public ModelAndView doFirst(HttpServletRequest request, HttpServletResponse response, HttpSession session){ ModelAndView mv = new ModelAndView(); mv.addObject("msg","====欢迎使用springmvc做web开发====" + request.getParameter("name")); mv.addObject("fun","执行的是doFirst方法"); mv.setViewName("other"); return mv; }}
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: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/context https://www.springframework.org/schema/context/spring-context.xsd"> <!--声明组件扫描器--> <context:component-scan base-package="com.bjpowernode.controller" /> <!--声明 springmvc框架中的视图解析器， 帮助开发人员设置视图文件的路径--> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <!--前缀：视图文件的路径--> <property name="prefix" value="/WEB-INF/view/" /> <!--后缀：视图文件的扩展名--> <property name="suffix" value=".jsp" /> </bean></beans>
index.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %><html><head> <title>Title</title></head><body> <p>第一个springmvc项目</p> <p><a href="user/first.do">发起some.do的get请求</a> </p> <br/> <form action="user/first.do" method="post"> <input type="submit" value="post请求other.do"> </form></body></html>
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"> <!--声明，注册springmvc的核心对象DispatcherServlet 需要在tomcat服务器启动后，创建DispatcherServlet对象的实例。 为什么要创建DispatcherServlet对象的实例呢？ 因为DispatcherServlet在他的创建过程中， 会同时创建springmvc容器对象， 读取springmvc的配置文件，把这个配置文件中的对象都创建好， 当用户发起 请求时就可以直接使用对象了。 servlet的初始化会执行init（）方法。 DispatcherServlet在init（）中{ //创建容器，读取配置文件 WebApplicationContext ctx = new ClassPathXmlApplicationContext("springmvc.xml"); //把容器对象放入到ServletContext中 getServletContext().setAttribute(key, ctx); } 启动tomcat报错，读取这个文件 /WEB-INF/springmvc-servlet.xml（/WEB-INF/myweb-servlet.xml） springmvc创建容器对象时，读取的配置文件默认是/WEB-INF/<servlet-name>-servlet.xml . --> <servlet> <servlet-name>myweb</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <!--自定义springmvc读取的配置文件的位置--> <init-param> <!--springmvc的配置文件的位置的属性--> <param-name>contextConfigLocation</param-name> <!--指定自定义文件的位置--> <param-value>classpath:springmvc.xml</param-value> </init-param> <!--在tomcat启动后，创建Servlet对象 load-on-startup:表示tomcat启动后创建对象的顺序。它的值是整数，数值越小， tomcat创建对象的时间越早。 大于等于0的整数。 --> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>myweb</servlet-name> <!-- 使用框架的时候， url-pattern可以使用两种值 1. 使用扩展名方式， 语法 *.xxxx , xxxx是自定义的扩展名。 常用的方式 *.do, *.action, *.mvc等等 不能使用 *.jsp http://localhost:8080/myweb/some.do http://localhost:8080/myweb/other.do 2.使用斜杠 "/" --> <url-pattern>*.do</url-pattern> </servlet-mapping></web-app>
show.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %><html><head> <title>Title</title></head><body> <h3>/WEB-INF/view/show.jsp从request作用域获取数据</h3><br/> <h3>msg数据：${msg}</h3><br/> <h3>fun数据：${fun}</h3></body></html>
other.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %><html><head> <title>Title</title></head><body> <h3>/WEB-INF/view/other.jsp从request作用域获取数据</h3><br/> <h3>msg数据：${msg}</h3><br/> <h3>fun数据：${fun}</h3></body></html>
ch03-recevieparam
业务
ch03-recevieparam : 接收请求的参数接收请求参数，使用的处理器方法的形参1）HttpServletRequest2)HttpServletResponse3)HttpSession4)用户提交的数据接收用户提交的参数：1.逐个接收2.对象接收注意： 在提交请求参数时，get请求方式中文没有乱码。 使用post方式提交请求，中文有乱码，需要使用过滤器处理乱码的问题。过滤器可以自定义，也可使用框架中提供的过滤器 CharacterEncodingFilter实现步骤：1. 新建web maven工程2. 加入依赖 spring-webmvc依赖，间接把spring的依赖都加入到项目 jsp，servlet依赖3.重点： 在web.xml中注册springmvc框架的核心对象DispatcherServlet 1)DispatcherServlet叫做中央调度器， 是一个servlet， 它的父类是继承HttpServlet 2)DispatcherServlet页叫做前端控制器（front controller） 3)DispatcherServlet负责接收用户提交的请求， 调用其它的控制器对象， 并把请求的处理结果显示给用户4.创建一个发起请求的页面 index.jsp5.创建控制器(处理器)类 1）在类的上面加入@Controller注解，创建对象，并放入到springmvc容器中 2）在类中的方法上面加入@RequestMapping注解。6.创建一个作为结果的jsp，显示请求的处理结果。7.创建springmvc的配置文件（spring的配置文件一样） 1）声明组件扫描器， 指定@Contorller注解所在的包名 2）声明视图解析器。帮助处理视图的。
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.bjpowernode</groupId> <artifactId>ch03-recevieparam</artifactId> <version>1.0-SNAPSHOT</version> <packaging>war</packaging> <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> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.11</version> <scope>test</scope> </dependency> <!--servlet依赖--> <dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>3.1.0</version> <scope>provided</scope> </dependency> <!--springmvc依赖--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.2.5.RELEASE</version> </dependency> </dependencies> <build> <plugins> <!-- 编码和编译和JDK版本 --> <plugin> <artifactId>maven-compiler-plugin</artifactId> <version>3.1</version> <configuration> <source>1.8</source> <target>1.8</target> </configuration> </plugin> </plugins> </build></project>
controller
package com.bjpowernode.controller;import com.bjpowernode.vo.Student;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestMethod;import org.springframework.web.bind.annotation.RequestParam;import org.springframework.web.servlet.ModelAndView;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import javax.servlet.http.HttpSession;import javax.xml.ws.RequestWrapper;/** * @RequestMapping: * value ： 所有请求地址的公共部分，叫做模块名称 * 位置： 放在类的上面 */@Controllerpublic class MyController { /** * 逐个接收请求参数： * 要求： 处理器（控制器）方法的形参名和请求中参数名必须一致。 * 同名的请求参数赋值给同名的形参 * 框架接收请求参数 * 1. 使用request对象接收请求参数 * String strName = request.getParameter("name"); * String strAge = request.getParameter("age"); * 2. springmvc框架通过 DispatcherServlet 调用 MyController的doSome()方法 * 调用方法时，按名称对应，把接收的参数赋值给形参 * doSome（strName，Integer.valueOf(strAge)） * 框架会提供类型转换的功能，能把String转为 int ，long ， float， double等类型。 * * 400状态码是客户端错误， 表示提交请求参数过程中，发生了问题。 */ @RequestMapping(value = "/receiveproperty.do") public ModelAndView doSome(String name, Integer age){ System.out.println("doSome, name="+name+" age="+age); //可以在方法中直接使用 name ， age //处理some.do请求了。 相当于service调用处理完成了。 ModelAndView mv = new ModelAndView(); mv.addObject("myname",name); mv.addObject("myage",Integer.valueOf(age)); //show是视图文件的逻辑名称（文件名称） mv.setViewName("show"); return mv; } /** * 请求中参数名和处理器方法的形参名不一样 * @RequestParam: 逐个接收请求参数中， 解决请求中参数名形参名不一样的问题 * 属性： 1. value 请求中的参数名称 * 2. required 是一个boolean，默认是true * true：表示请求中必须包含此参数。 * 位置： 在处理器方法的形参定义的前面 */ @RequestMapping(value = "/receiveparam.do") public ModelAndView receiveParam(@RequestParam(value = "rname",required = false) String name, @RequestParam(value = "rage",required = false) Integer age){ System.out.println("doSome, name="+name+" age="+age); //可以在方法中直接使用 name ， age //处理some.do请求了。 相当于service调用处理完成了。 ModelAndView mv = new ModelAndView(); mv.addObject("myname",name); mv.addObject("myage",age); //show是视图文件的逻辑名称（文件名称） mv.setViewName("show"); return mv; } /** * 处理器方法形参是java对象， 这个对象的属性名和请求中参数名一样的 * 框架会创建形参的java对象， 给属性赋值。 请求中的参数是name，框架会调用setName() * @return */ @RequestMapping(value = "/receiveobject.do") public ModelAndView receiveParam( Student myStudent){ System.out.println("receiveParam, name="+myStudent.getName()+" age="+myStudent.getAge()); //可以在方法中直接使用 name ， age //处理some.do请求了。 相当于service调用处理完成了。 ModelAndView mv = new ModelAndView(); mv.addObject("myname",myStudent.getName()); mv.addObject("myage",myStudent.getAge()); mv.addObject("mystudent",myStudent); //show是视图文件的逻辑名称（文件名称） mv.setViewName("show"); return mv; }}
package com.bjpowernode.vo;//保存请求参数值的一个普通类public class Student { // 属性名和请求中参数名一样 private String name; private Integer age; public Student() { System.out.println("===Student的无参数构造方法==="); } public String getName() { return name; } public void setName(String name) { System.out.println("setName"+name); this.name = name; } public Integer getAge() { return age; } public void setAge(Integer age) { System.out.println("setAge"+age); this.age = age; } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age + '}'; }}
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: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/context https://www.springframework.org/schema/context/spring-context.xsd"> <!--声明组件扫描器--> <context:component-scan base-package="com.bjpowernode.controller" /> <!--声明 springmvc框架中的视图解析器， 帮助开发人员设置视图文件的路径--> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <!--前缀：视图文件的路径--> <property name="prefix" value="/WEB-INF/view/" /> <!--后缀：视图文件的扩展名--> <property name="suffix" value=".jsp" /> </bean></beans>
index.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %><html><head> <title>Title</title></head><body> <p>提交参数给Controller</p> <form action="receiveproperty.do" method="post"> 姓名：<input type="text" name="name"> <br/> 年龄：<input type="text" name="age"> <br/> <input type="submit" value="提交参数"> </form> <br/> <p>请求参数名和处理器方法的形参名不一样</p> <form action="receiveparam.do" method="post"> 姓名：<input type="text" name="rname"> <br/> 年龄：<input type="text" name="rage"> <br/> <input type="submit" value="提交参数"> </form> <br/> <p>使用java对象接收请求参数</p> <form action="receiveobject.do" method="post"> 姓名：<input type="text" name="name"> <br/> 年龄：<input type="text" name="age"> <br/> <input type="submit" value="提交参数"> </form></body></html>
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"> <!--声明，注册springmvc的核心对象DispatcherServlet 需要在tomcat服务器启动后，创建DispatcherServlet对象的实例。 为什么要创建DispatcherServlet对象的实例呢？ 因为DispatcherServlet在他的创建过程中， 会同时创建springmvc容器对象， 读取springmvc的配置文件，把这个配置文件中的对象都创建好， 当用户发起 请求时就可以直接使用对象了。 servlet的初始化会执行init（）方法。 DispatcherServlet在init（）中{ //创建容器，读取配置文件 WebApplicationContext ctx = new ClassPathXmlApplicationContext("springmvc.xml"); //把容器对象放入到ServletContext中 getServletContext().setAttribute(key, ctx); } 启动tomcat报错，读取这个文件 /WEB-INF/springmvc-servlet.xml（/WEB-INF/myweb-servlet.xml） springmvc创建容器对象时，读取的配置文件默认是/WEB-INF/<servlet-name>-servlet.xml . --> <servlet> <servlet-name>myweb</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <!--自定义springmvc读取的配置文件的位置--> <init-param> <!--springmvc的配置文件的位置的属性--> <param-name>contextConfigLocation</param-name> <!--指定自定义文件的位置--> <param-value>classpath:springmvc.xml</param-value> </init-param> <!--在tomcat启动后，创建Servlet对象 load-on-startup:表示tomcat启动后创建对象的顺序。它的值是整数，数值越小， tomcat创建对象的时间越早。 大于等于0的整数。 --> <load-on-startup>1</load-on-startup>
最低0.47元/天 解锁文章
3630
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
