servlet是啥
Java Servlet 是运行在 Web 服务器或应用服务器上的程序,它是作为来自 Web 浏览器或其他 HTTP 客户端的请求和 HTTP 服务器上的数据库或应用程序之间的中间层。
使用 Servlet,您可以收集来自网页表单的用户输入,呈现来自数据库或者其他源的记录,还可以动态创建网页。
Java Servlet 通常情况下与使用 CGI(Common Gateway Interface,公共网关接口)实现的程序可以达到异曲同工的效果。但是相比于 CGI,Servlet 有以下几点优势:
性能明显更好。
Servlet 在 Web 服务器的地址空间内执行。这样它就没有必要再创建一个单独的进程来处理每个客户端请求。
Servlet 是独立于平台的,因为它们是用 Java 编写的。
服务器上的 Java 安全管理器执行了一系列限制,以保护服务器计算机上的资源。因此,Servlet 是可信的。
Java 类库的全部功能对 Servlet 来说都是可用的。它可以通过 sockets 和 RMI 机制与 applets、数据库或其他软件进行交互。
在写spring mvc之前先来了解下servlet的基础知识,在早之前的java开发中,可能大家都使用过jsp+servlet的开发模式,相信servlet大家都很熟悉了,可以说java的后端就是最重要的就是servlet,servlet在java 后端开发过程中扮演这比较重要的角色,现在的开发人员如果说来就直接spring boot零配置开发,那么可能对servlet这个概念只停留这面试复习的时候吧,我自己最早做java 的时候,那个时候spring mvc还是一大堆配置文件,使用的也是视图解析器的模式来的,前后端没有进行分离,然而当时,struts还比较火,所以说那个时候spring mvc用的人不是很多,而当初我们自己的项目就是spring mvc+spring jdbc的模式进行的开发;我是在2010年开始做java开发的,当时没有使用任何框架,用的最多的还是jsp + servlet,视图页面使用了el的表达式,开发了好久的servlet,所以我们这些做的久一点的程序员对servlet还比较熟悉,我记得当初还自己简单封装了servlet的,类似于struts一样,但是当初只是为了项目而做,符合项目的需求和开发,而只要做后端的,servlet是比较重要的一个后端技术,servlet是一种规范,业界规定的规范,不管哪种框架要做后端,那么必定遵循servlet的定义规范来做,所以像大家现在使用比较多的spring webmvc、struts都是遵循了servlet的定义规范,所以说不要说你使用了高级框架,别个问你servlet是个啥,你至少得知道这是一个啥吧;简单来说servlet是一个基于http协议的容器,所有的开发框架都是基于这个规范进行开发的。
Servlet 执行以下主要任务:
读取客户端(浏览器)发送的显式的数据。这包括网页上的 HTML 表单,或者也可以是来自 applet 或自定义的 HTTP 客户端程序的表单。
读取客户端(浏览器)发送的隐式的 HTTP 请求数据。这包括 cookies、媒体类型和浏览器能理解的压缩格式等等。
处理数据并生成结果。这个过程可能需要访问数据库,执行 RMI 或 CORBA 调用,调用 Web 服务,或者直接计算得出对应的响应。
发送显式的数据(即文档)到客户端(浏览器)。该文档的格式可以是多种多样的,包括文本文件(HTML 或 XML)、二进制文件(GIF 图像)、Excel 等。
发送隐式的 HTTP 响应到客户端(浏览器)。这包括告诉浏览器或其他客户端被返回的文档类型(例如 HTML),设置 cookies 和缓存参数,以及其他类似的任务。
Servlet运行流程
我们来想象一个流程,当你通过web浏览器通过http的方式来访问网络中一个资源,比如图片资源,肯定是通过一个url的方式来访问的,那么它的初六流程肯定是:
1.接收请求,然后将请求解析成一个统一规范对象(ServletRequest);
2.处理请求,处理请求是交给开发者去实现的,servlet会调用它的service方法,然后根据请求类型(GET POST DELETE PUT)去调用相应的方法,开发者要不实现service方法要不实现相对应的方法。
3.相应请求信息,封装成统一的规范对象ServletResponse。
web服务器:将某个主机上的资源映射为一个URL供外界访问,完成接收和响应请求
servlet容器:存放着servlet对象(由程序员编程提供),处理请求
示例
tomcat中已经根据servlet的规范实现了对应的servlet容器,我们这里写个例子,就以tomcat为例,在项目中使用tomcat内嵌的一个插件运行
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<version>2.2</version>
<configuration>
<path>/</path>
<port>8080</port>
</configuration>
</plugin>
maven中添加spring mvc的相关依赖
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.7.RELEASE</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
编写一个Controller
@RestController
public class IndexController {
@RequestMapping("/test.do")
public String test(){
return "test";
}
@RequestMapping("/test1")
public String test1(){
return "test1";
}
}
定义一个spring-servlet.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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
<context:component-scan base-package="com.dev1.web"/>
<mvc:annotation-driven />
</beans>
web.xml内容如下:
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Archetype Created Web Application</display-name>
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-servlet.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
我们定义的这个sevlet就是DispatcherServlet,DispatcherServlet是spring webmvc中的一个sevlet
,然后这个servlet我们要去它的过滤路径是“/”,意思是拦截所有的请求项,项目的整体结构如下:
然后我们启动,在启动命令加入:
启动完成过后打开浏览器输入:
这样是能够到我们的IndexController中的,所以是生效的,比如我们的web中有两个资源文件,index.jsp和index.html文件,但是我们访问只有index.jsp能够访问,而index.html就不能访问,这是为什么呢?
我们来看这几个servlet:
DefaultServlet
DispatcherServlet
JspServlet(类似的名字)
我们在web.xml中配置的sevlet的过滤是“/”,代表的是这个路径下的所有被拦截到,而真正我们输入http://localhost:8080/test的时候是被拦截了,但是如果说输入http://localhost:8080/index.jsp这个就不是DispatcherServlet来处理的了,而是JspServlet来处理的,而html的时候就没有对应的sevlet去处理它,从而就走到了DefaultServlet,所以就报错了。
如果说我们把web.xml中的DispatcherServlet的过滤路径写成"/",那么这个时候只有DispatcherServlet的访问路径能够访问,其他都不能访问
这是为什么呢?我们再看来 “/”和“/”的区别,这个两个方式都是找所有的路径,
但是如果说“/”它的优先级就最高了,也就是说加了"/"那么只能是找DispatcherServlet对应的请求
所以说在日常工作中要区分开来,否则有时候出现一些莫名其妙的错误,但是如果说你要区分看来,你可以写*.do这些类似的,每个servlet的mapping分开来写;
还有一个就是类似于我们在xml中配置配置文件的路径也有这样写:
classpath:springmvc.xml
classpath*:xxxxx.xml
那么这两种有什么区别呢?classpath:是找class路径下的配置文件,而classpath*:是除了class路径下的配置文件找之外还找jar中的路径。
Servlet
public interface Servlet {
//tomcat反射创建servlet之后,调用init方法传入ServletConfig
void init(ServletConfig var1) throws ServletException;
ServletConfig getServletConfig();
//tomcat解析http请求,封装成对象传入
void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;
String getServletInfo();
void destroy();
}
ServletConfig:封装了servlet的参数信息,从web.xml中获取,init-param
ServletRequest:http请求到了tomcat后,tomcat通过字符串解析,把各个请求头(header),请求地址(URL),请求参数(queryString)都封装进Request。
ServletResponse:Response在tomcat传给servlet时还是空的对象,servlet逻辑处理后,最终通过response.write()方法,将结果写入response内部的缓冲区,tomcat会在servlet处理结束后拿到response,获取里面的信息,组装成http响应给客户端。
GenericServlet
改良版的servlet,抽象类
public abstract class GenericServlet implements Servlet, ServletConfig, Serializable {
private static final long serialVersionUID = 1L;
private transient ServletConfig config;
public GenericServlet() {
}
//并不是销毁servlet的方法,而是销毁servlet前一定会调用的方法。默认空实现,可以借此关闭一些资源
public void destroy() {
}
public String getInitParameter(String name) {
return this.getServletConfig().getInitParameter(name);
}
public Enumeration<String> getInitParameterNames() {
return this.getServletConfig().getInitParameterNames();
}
public ServletConfig getServletConfig() {
return this.config;//初始化时已被赋值
}
public ServletContext getServletContext() {
//通过ServletConfig获取ServletContext
return this.getServletConfig().getServletContext();
}
public String getServletInfo() {
return "";
}
public void init(ServletConfig config) throws ServletException {
this.config = config;//提升ServletConfig作用域,由局部变量变成全局变量
this.init();//提供给子类覆盖
}
public void init() throws ServletException {
}
public void log(String message) {
this.getServletContext().log(this.getServletName() + ": " + message);
}
public void log(String message, Throwable t) {
this.getServletContext().log(this.getServletName() + ": " + message, t);
}
//空实现
public abstract void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;
public String getServletName() {
return this.config.getServletName();
}
}
HttpServlet
GenericServlet的升级版,针对http请求所定制,在GenericServlet的基础上增加了service方法的实现,完成请求方法的判断
抽象类,用来被子类继承,得到匹配http请求的处理,子类必须重写以下方法中的一个
doGet,doPost,doPut,doDelete 未重写会报错(400,405)
service方法不可以重写
模板模式实现
public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
HttpServletRequest request;
HttpServletResponse response;
try {
request = (HttpServletRequest)req;//强转成http类型,功能更强大
response = (HttpServletResponse)res;
} catch (ClassCastException var6) {
throw new ServletException(lStrings.getString("http.non_http"));
}
this.service(request, response);//每次都调
}
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
String method = req.getMethod();//获取请求方式
long lastModified;
if (method.equals("GET")) {//判断逻辑,调用不同的处理方法
lastModified = this.getLastModified(req);
if (lastModified == -1L) {
//本来业务逻辑应该直接写在这里,但是父类无法知道子类具体的业务逻辑,所以抽成方法让子类重写,父类的默认实现输出405,没有意义
this.doGet(req, resp);
} else {
long ifModifiedSince;
try {
ifModifiedSince = req.getDateHeader("If-Modified-Since");
} catch (IllegalArgumentException var9) {
ifModifiedSince = -1L;
}
if (ifModifiedSince < lastModified / 1000L * 1000L) {
this.maybeSetLastModified(resp, lastModified);
this.doGet(req, resp);
} else {
resp.setStatus(304);
}
}
} else if (method.equals("HEAD")) {
lastModified = this.getLastModified(req);
this.maybeSetLastModified(resp, lastModified);
this.doHead(req, resp);
} else if (method.equals("POST")) {
this.doPost(req, resp);
} else if (method.equals("PUT")) {
this.doPut(req, resp);
} else if (method.equals("DELETE")) {
this.doDelete(req, resp);
} else if (method.equals("OPTIONS")) {
this.doOptions(req, resp);
} else if (method.equals("TRACE")) {
this.doTrace(req, resp);
} else {
String errMsg = lStrings.getString("http.method_not_implemented");
Object[] errArgs = new Object[]{method};
errMsg = MessageFormat.format(errMsg, errArgs);
resp.sendError(501, errMsg);
}
}
一个类被声明为抽象的,一般有两个原因:
有抽象方法需要被实现
没有抽象方法,但是不希望被实例化
ServletContext
servlet上下文,代表web.xml文件,其实就是一个map,服务器会为每个应用创建一个servletContext对象:
创建是在服务器启动时完成
销毁是在服务器关闭时完成
javaWeb中的四个域对象:都可以看做是map,都有getAttribute()/setAttribute()方法。
ServletContext域(Servlet间共享数据)
Session域(一次会话间共享数据,也可以理解为多次请求间共享数据)
Request域(同一次请求共享数据)
Page域(JSP页面内共享数据)
servletConfig对象持有ServletContext的引用,Session域和Request域也可以得到ServletContext
五种方法获取:
- ServletConfig#getServletContext();
- GenericServlet#getServletContext();
- HttpSession#getServletContext();
- HttpServletRequest#getServletContext();
- ServletContextEvent#getServletContext();//创建ioc容器时的监听
Filter
不仅仅是拦截Request
拦截方式有四种:
Redirect和REQUEST/FORWARD/INCLUDE/ERROR最大区别在于:
重定向会导致浏览器发送2次请求,FORWARD们是服务器内部的1次请求
因为FORWARD/INCLUDE等请求的分发是服务器内部的流程,不涉及浏览器,REQUEST/FORWARD/INCLUDE/ERROR和Request有关,Redirect通过Response发起
通过配置,Filter可以过滤服务器内部转发的请求。
servlet映射器
每一个url要交给哪个servlet处理,由映射器决定
映射器在tomcat中就是Mapper类:
internalMapWrapper方法定义了七种映射规则
private final void internalMapWrapper(ContextVersion contextVersion,
CharChunk path,
MappingData mappingData) throws IOException {
int pathOffset = path.getOffset();
int pathEnd = path.getEnd();
boolean noServletPath = false;
int length = contextVersion.path.length();
if (length == (pathEnd - pathOffset)) {
noServletPath = true;
}
int servletPath = pathOffset + length;
path.setOffset(servletPath);
// Rule 1 -- 精确匹配
MappedWrapper[] exactWrappers = contextVersion.exactWrappers;
internalMapExactWrapper(exactWrappers, path, mappingData);
// Rule 2 -- 前缀匹配
boolean checkJspWelcomeFiles = false;
MappedWrapper[] wildcardWrappers = contextVersion.wildcardWrappers;
if (mappingData.wrapper == null) {
internalMapWildcardWrapper(wildcardWrappers, contextVersion.nesting,
path, mappingData);
if (mappingData.wrapper != null && mappingData.jspWildCard) {
char[] buf = path.getBuffer();
if (buf[pathEnd - 1] == '/') {
mappingData.wrapper = null;
checkJspWelcomeFiles = true;
} else {
// See Bugzilla 27704
mappingData.wrapperPath.setChars(buf, path.getStart(),
path.getLength());
mappingData.pathInfo.recycle();
}
}
}
if(mappingData.wrapper == null && noServletPath &&
contextVersion.object.getMapperContextRootRedirectEnabled()) {
// The path is empty, redirect to "/"
path.append('/');
pathEnd = path.getEnd();
mappingData.redirectPath.setChars
(path.getBuffer(), pathOffset, pathEnd - pathOffset);
path.setEnd(pathEnd - 1);
return;
}
// Rule 3 -- 扩展名匹配
MappedWrapper[] extensionWrappers = contextVersion.extensionWrappers;
if (mappingData.wrapper == null && !checkJspWelcomeFiles) {
internalMapExtensionWrapper(extensionWrappers, path, mappingData,
true);
}
...
上面都不匹配,则交给DefaultServlet,就是简单地用IO流读取静态资源并响应给浏览器。如果资源找不到,报404错误
对于静态资源,Tomcat最后会交由一个叫做DefaultServlet的类来处理对于Servlet ,Tomcat最后会交由一个叫做 InvokerServlet的类来处理对于JSP,Tomcat最后会交由一个叫做JspServlet的类来处理
也就是说,servlet,/这种配置,相当于把DefaultServlet、JspServlet以及我们自己写的其他Servlet都“短路”了,它们都失效了。
这会导致两个问题:
JSP无法被编译成Servlet输出HTML片段(JspServlet短路)
HTML/CSS/JS/PNG等资源无法获取(DefaultServlet短路)
DispatcherServlet配置/,会和DefaultServlet产生路径冲突,从而覆盖DefaultServlet。此时,所有对静态资源的请求,映射器都会分发给我们自己写的DispatcherServlet处理。遗憾的是,它只写了业务代码,并不能IO读取并返回静态资源。JspServlet的映射路径没有被覆盖,所以动态资源照常响应。
DispatcherServlet配置/,虽然JspServlet和DefaultServlet拦截路径还是.jsp和/,没有被覆盖,但无奈的是在到达它们之前,请求已经被DispatcherServlet抢去,所以最终不仅无法处理JSP,也无法处理静态资源。
tomcat中conf/web.xml
相当于每个应用默认都配置了JSPServlet和DefaultServlet处理JSP和静态资源。
<servlet>
<servlet-name>default</servlet-name>
<servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
<init-param>
<param-name>debug</param-name>
<param-value>0</param-value>
</init-param>
<init-param>
<param-name>listings</param-name>
<param-value>false</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>jsp</servlet-name>
<servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
<init-param>
<param-name>fork</param-name>
<param-value>false</param-value>
</init-param>
<init-param>
<param-name>xpoweredBy</param-name>
<param-value>false</param-value>
</init-param>
<load-on-startup>3</load-on-startup>
</servlet>
<!-- The mappings for the JSP servlet -->
<servlet-mapping>
<servlet-name>jsp</servlet-name>
<url-pattern>*.jsp</url-pattern>
<url-pattern>*.jspx</url-pattern>
</servlet-mapping>