一.SpringMVC概述
1.1 简介
SpringMVC:
- 是基于spring的一个框架, 实际上就是spring的一个模块, 专门是做web开发的。
理解是servlet的一个升级
web开发底层是servlet , 框架是在servlet基础上面加入一些功能,让你做web开发方便。
SpringMVC就是一个Spring:
- Spring是容器,ioc能够管理对象,使用< bean>, @Component, @Repository, @Service, @Controller
SpringMVC能够创建对象, 放入到容器中(SpringMVC容器),springmvc容器中放的是控制器对象
我们要做的是 使用@Contorller创建控制器对象, 把对象放入到springmvc容器中, 把创建的对象作为控制器使用这个控制器对象能接收用户的请求, 显示处理结果,就当做是一个servlet使用。
- 使用@Controller注解创建的是一个普通类的对象,不是Servlet。springmvc赋予了控制器对象一些额外的功能。
web开发底层是servlet, springmvc中有一个对象是Servlet : DispatherServlet(中央调度器)
- DispatherServlet: 负责接收用户的所有请求, 用户把请求给了DispatherServlet, 之后DispatherServlet把请求转发给我们的Controller对象, 最后是Controller对象处理请求。
例:
- index.jsp-----DispatherServlet(Servlet)----转发,分配给—Controller对象(@Controller注解创建的对象)
main.jsp -------DispatherServlet —转发--------------------------MainController
addUser.jsp —DispatherServlet—转发---------------------------UserController
二.使用springMvc步骤
2.1 springmvc请求的处理流程
- 1)发起some.do
2)tomcat(web.xml–url-pattern知道 *.do的请求给DispatcherServlet)
3)DispatcherServlet(根据springmvc.xml配置知道 some.do—doSome())
4)DispatcherServlet把some.do转发个MyController.doSome()方法
5)框架执行doSome()把得到ModelAndView进行处理, 转发到show.jsp
上面的过程简化的方式
some.do—DispatcherServlet—MyController
2.2 实现步骤
实现步骤:
- 新建web maven工程
- 加入依赖
spring-webmvc依赖,间接把spring的依赖都加入到项目
jsp,servlet依赖
<!--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>
- 重点: 在web.xml中注册springmvc框架的核心对象DispatcherServlet
1)DispatcherServlet叫做中央调度器, 是一个servlet, 它的父类是继承HttpServlet
2)DispatcherServlet页叫做前端控制器(front controller)
3)DispatcherServlet负责接收用户提交的请求, 调用其它的控制器对象,
并把请求的处理结果显示给用户
<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>
- 创建一个发起请求的页面 index.js
<body>
<p>第一个springmvc项目</p>
<p><a href="some.do">发起some.do的请求</a> </p>
<p><a href="other.do">发起other.do的请求</a> </p>
</body>
- 创建控制器(处理器)类
1)在类的上面加入@Controller注解,创建对象,并放入到springmvc容器中
2)在类中的方法上面加入@RequestMapping注解。
/**
* @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;
}
}
- 创建一个作为结果的jsp,显示请求的处理结果。
<body>
<h3>/WEB-INF/view/show.jsp从request作用域获取数据</h3><br/>
<h3>msg数据:${msg}</h3><br/>
<h3>fun数据:${fun}</h3>
</body>
- 创建springmvc的配置文件(spring的配置文件一样)
1)声明组件扫描器, 指定@Contorller注解所在的包名
2)声明视图解析器。帮助处理视图的。
<!--声明组件扫描器-->
<context:component-scan base-package="com.tx.controller" />
<!--声明 springmvc框架中的视图解析器, 帮助开发人员设置视图文件的路径-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--前缀:视图文件的路径-->
<property name="prefix" value="/WEB-INF/view/" />
<!--后缀:视图文件的扩展名-->
<property name="suffix" value=".jsp" />
</bean>
2.3 springmvc执行过程源代码分析
- tomcat启动,创建容器的过程
通过load-on-start标签指定的1,创建DisaptcherServlet对象,
DisaptcherServlet它的父类是继承HttpServlet的, 它是一个serlvet, 在被创建时,会执行init()方法。
在init()方法中
//创建容器,读取配置文件
WebApplicationContext ctx = new ClassPathXmlApplicationContext("springmvc.xml");
//把容器对象放入到ServletContext中
getServletContext().setAttribute(key, ctx);
上面创建容器作用: 创建@controller注解所在的类的对象, 创建MyController对象,
这个对象放入到 springmvc的容器中, 容器是map , 类似 map.put(“myController”,MyController对象)
2.请求的处理过程
1)执行servlet的service()
protected void service(HttpServletRequest request, HttpServletResponse response)
protected void doService(HttpServletRequest request, HttpServletResponse response)
DispatcherServlet.doDispatch(request, response){
调用MyController的.doSome()方法
}
doDispatch:springmvc中DispatcherServlet的核心方法, 所有的请求都在这个方法中完成的。
三. SpringMVC注解式开发
3.1 @RequestMapping定义请求规则
3.1.1 指定模块名称以及提交方式的定义
/**
* @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) //index.jsp页面form表单提交方式需要更改
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;
}
序号 | 请求方式 | 提交方式 |
---|---|---|
1 | 表单请求 | 默认get,可以指定post |
2 | AJAX请求 | 默认get,可以指定post |
3 | 地址栏请求 | get请求 |
4 | 超链接请求 | get请求 |
5 | src资源路径请求 | get请求 |
3.2 处理器方法参数(接收请求参数)
httpServletRequest
httpServletResponse
HttpSession
3.2.1 逐个接受参数
<form action="receiveproperty.do" method="post">
姓名:<input type="text" name="name"> <br/>
年龄:<input type="text" name="age"> <br/>
<input type="submit" value="提交参数">
</form>
@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;
}
3.2.2 请求参数中文乱码问题
<!--注册声明过滤器,解决post请求乱码的问题-->
<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>
<!--强制请求对象(HttpServletRequest)使用encoding编码的值-->
<init-param>
<param-name>forceRequestEncoding</param-name>
<param-value>true</param-value>
</init-param>
<!--强制应答对象(HttpServletResponse)使用encoding编码的值-->
<init-param>
<param-name>forceResponseEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<!--
/*:表示强制所有的请求先通过过滤器处理。
-->
<url-pattern>/*</url-pattern>
</filter-mapping>
3.2.3 校正请求参数名@RequestParam
<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>
/**
* 请求中参数名和处理器方法的形参名不一样
* @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;
}
3.2.4 对象参数接收
创建实体类对象
/**
* 处理器方法形参是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;
}
3.3 处理方法返回值
几种返回值常用类型:
- ModelAndView: 有数据和视图,对视图执行forward。
- String:表示视图,可以逻辑名称,也可以是完整视图路径
- void: 不能表示数据,也不能表示视图。
在处理ajax的时候,可以使用void返回值。 通过HttpServletResponse输出数据。响应ajax请求。
ajax请求服务器端返回的就是数据, 和视图无关。 - Object: 例如String , Integer , Map,List, Student等等都是对象,
对象有属性, 属性就是数据。 所以返回Object表示数据, 和视图无关。
可以使用对象表示的数据,响应ajax请求。
3.3.1 返回ModelAndView
在使用时,若该处理器方法只是进行跳转而不传递数据,或只是传递数据而并不向任何
资源跳转(如对页面的 Ajax 异步响应),此时若返回 ModelAndView,则将总是有一部分多
余:要么 Model 多余,要么 View 多余。即此时返回 ModelAndView 将不合适。
3.3.2 返回String
<body>
<p>处理器方法返回String表示视图名称</p>
<form action="returnString-view.do" method="post">
姓名:<input type="text" name="name"> <br/>
年龄:<input type="text" name="age"> <br/>
<input type="submit" value="提交参数">
</form>
<br/>
<p>处理器方法返回String表示视图完整路径</p>
<form action="returnString-view2.do" method="post">
姓名:<input type="text" name="name"> <br/>
年龄:<input type="text" name="age"> <br/>
<input type="submit" value="提交参数">
</form>
/**
* 处理器方法返回String--表示逻辑视图名称,需要配置视图解析器
*/
@RequestMapping(value = "/returnString-view.do")
public String doReturnView(HttpServletRequest request,String name, Integer age){
System.out.println("doReturnView, name="+name+" age="+age);
//可以自己手工添加数据到request作用域
request.setAttribute("myname",name);
request.setAttribute("myage",age);
// show : 逻辑视图名称,项目中配置了视图解析器
// 框架对视图执行forward转发操作
return "show";
}
//处理器方法返回String,表示完整视图路径, 此时不能配置视图解析器
@RequestMapping(value = "/returnString-view2.do")
public String doReturnView2(HttpServletRequest request,String name, Integer age){
System.out.println("===doReturnView2====, name="+name+" age="+age);
//可以自己手工添加数据到request作用域
request.setAttribute("myname",name);
request.setAttribute("myage",age);
// 完整视图路径,项目中不能配置视图解析器
// 框架对视图执行forward转发操作
// /WEB-INF/view//WEB-INF/view/show.jsp.jsp
// /WEB-INF/view/WEB-INF/view/show.jsp.jsp
return "/WEB-INF/view/show.jsp";
}
3.3.3 返回void (使用ajax)
<!--Jackson依赖-->
<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>
$("button").click(function(){
//alert("button click");
$.ajax({
//url:"returnVoid-ajax.do",
//url:"returnStudentJsonArray.do",
url:"returnStringData.do",
data:{
name:"zhangsan",
age:20
},
type:"post",
dataType:"text",
//dataType:"json",
success:function(resp){
//处理器方法返回void, 响应ajax请求
//手工实现ajax,json数据: 代码有重复的 1. java对象转为json; 2. 通过HttpServletResponse输出json数据
@RequestMapping(value = "/returnVoid-ajax.do")
public void doReturnVoidAjax(HttpServletResponse response, String name, Integer age) throws IOException {
System.out.println("===doReturnVoidAjax====, name="+name+" age="+age);
//处理ajax, 使用json做数据的格式
//service调用完成了, 使用Student表示处理结果
Student student = new Student();
student.setName("张飞同学");
student.setAge(28);
String json = "";
//把结果的对象转为json格式的数据
if( student != null){
ObjectMapper om = new ObjectMapper();
json = om.writeValueAsString(student);
System.out.println("student转换的json===="+json);
}
//输出数据,响应ajax的请求
response.setContentType("application/json;charset=utf-8");
PrintWriter pw = response.getWriter();
pw.println(json);
pw.flush();
pw.close();
}
3.3.4 返回对象Object
现在做ajax, 主要使用json的数据格式。 实现步骤:
- 加入处理json的工具库的依赖, springmvc默认使用的jackson。
- 在sprigmvc配置文件之间加入 mvc:annotation-driven 注解驱动。
json = om.writeValueAsString(student); - 在处理器方法的上面加入@ResponseBody注解
response.setContentType(“application/json;charset=utf-8”);
PrintWriter pw = response.getWriter();
pw.println(json);
@RequestMapping的produces属性指定字符集
/**
* 处理器方法返回一个Student,通过框架转为json,响应ajax请求
* @ResponseBody:
* 作用:把处理器方法返回对象转为json后,通过HttpServletResponse输出给浏览器。
* 位置:方法的定义上面。 和其它注解没有顺序的关系。
* 返回对象框架的处理流程:
* 1. 框架会把返回Student类型,调用框架的中ArrayList<HttpMessageConverter>中每个类的canWrite()方法
* 检查那个HttpMessageConverter接口的实现类能处理Student类型的数据--MappingJackson2HttpMessageConverter
*
* 2.框架会调用实现类的write(), MappingJackson2HttpMessageConverter的write()方法
* 把李四同学的student对象转为json, 调用Jackson的ObjectMapper实现转为json
* contentType: application/json;charset=utf-8
*
* 3.框架会调用@ResponseBody把2的结果数据输出到浏览器, ajax请求处理完成
*/
@RequestMapping(value = "/returnStudentJson.do")
@ResponseBody
public Student doStudentJsonObject(String name, Integer age) {
//调用service,获取请求结果数据 , Student对象表示结果数据
Student student = new Student();
student.setName("李四同学");
student.setAge(20);
return student; // 会被框架转为json
}
/**
* 处理器方法返回的是String , String表示数据的,不是视图。
* 区分返回值String是数据,还是视图,看有没有@ResponseBody注解
* 如果有@ResponseBody注解,返回String就是数据,反之就是视图
*
* 默认使用“text/plain;charset=ISO-8859-1”作为contentType,导致中文有乱码,
* 解决方案:给RequestMapping增加一个属性 produces, 使用这个属性指定新的contentType.
* 返回对象框架的处理流程:
* 1. 框架会把返回String类型,调用框架的中ArrayList<HttpMessageConverter>中每个类的canWrite()方法
* 检查那个HttpMessageConverter接口的实现类能处理String类型的数据--StringHttpMessageConverter
*
* 2.框架会调用实现类的write(), StringHttpMessageConverter的write()方法
* 把字符按照指定的编码处理 text/plain;charset=ISO-8859-1
*
* 3.框架会调用@ResponseBody把2的结果数据输出到浏览器, ajax请求处理完成
*/
@RequestMapping(value = "/returnStringData.do",produces = "text/plain;charset=utf-8")
@ResponseBody
public String doStringData(String name,Integer age){
return "Hello SpringMVC 返回对象,表示数据";
}
3.4 解读
3.4.1 配置详解
发起的请求是由哪些服务器程序处理的。
http://localhost:8080/ch05_url_pattern/index.jsp :tomcat(jsp会转为servlet)
http://localhost:8080/ch05_url_pattern/js/jquery-3.4.1.js : tomcat
http://localhost:8080/ch05_url_pattern/images/p1.jpg : tomcat
http://localhost:8080/ch05_url_pattern/html/test.html: tomcat
http://localhost:8080/ch05_url_pattern/some.do : DispatcherServlet(springmvc框架处理的)
<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.使用斜杠 "/"
当你的项目中使用了 / ,它会替代 tomcat中的default。
导致所有的静态资源都给DispatcherServlet处理, 默认情况下DispatcherServlet没有处理静态资源的能力。
没有控制器对象能处理静态资源的访问。所以静态资源(html,js,图片,css)都是404.
动态资源some.do是可以访问,的因为我们程序中有MyController控制器对象,能处理some.do请求。
-->
<url-pattern>/</url-pattern>
</servlet-mapping>
问题:
- 使用"/",它会替代tomcat中的default,导致所有静态资源都给DispatcherServlet处理,默认情况DispatcherServlet没有处理静态资源的能力。
第一种解决办法:使用mvc:default-servlet-handler/
声明了mvc:default-servlet-handler/后,springmvc框架会在容器中创建DefaultServletHttpRequestHandler处理器对象。它会像一个检查员,对进行入DsipatcherServlet的URL进行筛选,如果发现是静态资源的请求,就将该请求转由Web应用服务器默认的Servlet处理。
有点:方便 ;缺点:需要依赖tomcat服务器的default
<!-- default-servlet-handler 和 @RequestMapping注解 有冲突, 需要加入annotation-driven 解决问题-->
<mvc:annotation-driven />
<!--第一种处理静态资源的方式:
需要在springmvc配置文件加入 <mvc:default-servlet-handler>
原理是: 加入这个标签后,框架会创健控制器对象DefaultServletHttpRequestHandler(类似我们自己创建的MyController).
DefaultServletHttpRequestHandler这个对象可以把接收的请求转发给 tomcat的default这个servlet。
-->
<mvc:default-servlet-handler />
第二种解决办法:
<!--第二种处理静态资源的方式
mvc:resources 加入后框架会创建 ResourceHttpRequestHandler这个处理器对象。
让这个对象处理静态资源的访问,不依赖tomcat服务器。
mapping:访问静态资源的uri地址, 使用通配符 **
location:静态资源在你的项目中的目录位置。
images/**:表示 images/p1.jpg , images/user/logo.gif , images/order/history/list.png
-->
<mvc:resources mapping="/images/**" location="/images/" />
<mvc:resources mapping="/html/**" location="/html/" />
<mvc:resources mapping="/js/**" location="/js/" />
<!--mvc:resources和@RequestMapping有一定的冲突-->
<mvc:annotation-driven />
3.4 解决路径问题(base标签)
前端页面路径
<--base标签-->
<%
String basePath = request.getScheme() + "://" +
request.getServerName() + ":" + request.getServerPort() +
request.getContextPath() + "/";
%>
<html>
<head>
<base href="<%=basePath%>"/>
</head>
</html>
<--el表达式-->
<a href="${pagecontext.request.contextPath}/user/some.do">发起user/some.do的get方法</a>