正文

深入了解tomcat中servlet的创建方式实现

︶ㄣ米米素材网 メ
米米素材网V管理员 / 阅读
0801

这篇文章主要介绍了深入了解tomcat中servlet的创建方式实现,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧

一、 什么是servlet

1.1、用官方的话解释：

servlet是oracle公司提供的一门用于开发动态web资源的技术，属于javaee体系中的一种核心规范。
通俗解释一下：就是我们开发人员所编写的一个类，必须直接或者间接实现这个javaee的核心规范，也就是实现servlet接口，因为这种类产生的对象可以被浏览器访问到，因此称之为servlet,并且javaee中规定了只有servlet的实现类产生的对象才可以被浏览器访问，就是servlet.(也就是说这个类要直接或者间接实现了servlet接口)

二、开始进入servlet的创建

2.1、通过前面介绍，我们知道了一个什么样的类创建的对象可以被浏览器访问，首先我们直接上代码：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package com.briup.web;
import java.io.ioexception;
import javax.servlet.servlet;
import javax.servlet.servletconfig;
import javax.servlet.servletexception;
import javax.servlet.servletrequest;
import javax.servlet.servletresponse;
 
public class firstway implements servlet {
    public firstway() {
        system.out.println("对象创建了");
    }
    @override
    public void init(servletconfig config) throws servletexception {
        // todo auto-generated method stub
        system.out.println("我是init:我被调用了");
    }
    @override
    public servletconfig getservletconfig() {
        // todo auto-generated method stub
        return null;
    }
    @override
    public void service(servletrequest req, servletresponse res) throws servletexception, ioexception {
        // todo auto-generated method stub
        system.out.println("我是service，我被调用了"); 
    }
    @override
    public string getservletinfo() {
        // todo auto-generated method stub
        return null;
    }
    @override
    public void destroy() {
        // todo auto-generated method stub
        system.out.println("我是destory:我被调用了");
    }
 
}

那么，一个满足servlet的类已经创建好了，接下来抛出疑问

servet对象由谁创建？

里面实现的接口方法，哪些会调用，什么时候调用，调用几次？
第一个疑问： 既然是servlet类，由我们开发人员自己手动创建对象，显然是不合理，所以这个对象的创建，是交给tomcat创建的，我们开发人员只需要告诉 tomcat,让他创建，让他什么时候创建就行了；
如何告诉？

1、方法一：通过配置webxml的方式。（极其不推荐使用）

对于整个动态web项目而言，web.xml是最先加载的配置文件，所以在web.xml的方式配置

?
1
2
3
4
5
6
7
8
9
10
11
12
13
<?xml version="1.0" encoding="utf-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemalocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" version="3.1">
 <display-name>firstway</display-name>
 <servlet>
        <servlet-name>firstway</servlet-name>
        <servlet-class>com.briup.web.firstway</servlet-class>
        <!-- <load-on-startup>1</load-on-startup> -->
 </servlet>
 <servlet-mapping>
    <servlet-name>firstway</servlet-name>
    <url-pattern>/firstway</url-pattern>
 </servlet-mapping>
</web-app>

解释：
1、servlet-name:见名知意：servlet的名字，注意要与下面你设置映射的名字对应
2、serlvet-class:serlvet的全限定名
3、load-on-startup:是否在tomcat启动的时候就创建servlet对象，传入一个大于0的整数‘'（默认是浏览器第一次请求的时候创建servlet对象）
4、servlet-mapping：见名知意，设置浏览器的访问映射
5、servlet-name:于上面的对应
6、url-pattern:浏览器的访问映射（假设默认是本机的话，且tomcat的端口号为8080,那么浏览器访问这个servlet的路径为:localhost:8080/项目名/firstway）
有了这些基础，让我们访问看看；

第一步：启动tomcat

深入了解tomcat中servlet的创建方式实现

tomcat正常启动

第二步：通过浏览器访问（我们这里手动访问3次）

深入了解tomcat中servlet的创建方式实现

浏览器访问正常

第三步：观察控制台

深入了解tomcat中servlet的创建方式实现

通过运行结果分析：

第一次启动服务器，对象并没有被创建

浏览器请求三遍，但是对象只创建一次，init()方法也只调用一次

每访问一次，对象便会调用一次service()方法

其他方法没被调用

解释为嘛没被调用：getservletconfig（）：得到servletconfig对象
： getservletinfo（）：得到servlet的信心，比如作者
：destroy（）：servlet销毁的时候才会调用这个方法，（比如：tomcati正常关闭 这里我就不去测试，想测试的小伙伴，可以右键service,点击stop）然后再观察控制台便可知了。

 2、方法二：注解的方式告诉tomcat（与前者相比，推荐使用）

?
1
2
3
@webservlet(value ="映射路径")
public fristservlet implement servelt {
}

通过这个注解也可以设置，是否在启动服务器的时候就创建对象，这里就不演示了，
注意：（一旦使用了注解的方式告诉tomcat如果创建某个对象，就不能在web.xml里面再对这个servlet进行访问设置了）

三、回归主题，servlet的第二种创建方式

有了前面的解释，直接上代码然后再分析

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.briup.web;
 
import java.io.ioexception;
 
import javax.servlet.genericservlet;
import javax.servlet.servletexception;
import javax.servlet.servletrequest;
import javax.servlet.servletresponse;
import javax.servlet.annotation.webservlet;
@webservlet(value = "/secondway")
public class secondwaycreate extends genericservlet {
 
    @override
    public void service(servletrequest req, servletresponse res) throws servletexception, ioexception {
        // todo auto-generated method stub
        system.out.println("调用了service方法");
    }
 
}

1、比第一种方法简洁，实现的是genericservlet这个类

2、我们看一下genericservlet源码，然后进行分析；

?
1
public abstract class genericservlet implements servlet, servletconfig,

可知，这是个抽线类，是servlet接口的实现类，那么genericservlet间接 实现了servlet接口，
与第一种方式相比：开发者不是必须将一些接口中不必要的方法实现，可以具有选择性，减少了代码量。然而并没有上面ruan用，就是装b而已

三、重点第三种方式（与前两者相比，我更推荐第三种方式）

直接上代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.briup.web;
 
import java.io.ioexception;
 
import javax.servlet.servletexception;
import javax.servlet.annotation.webservlet;
import javax.servlet.http.httpservlet;
import javax.servlet.http.httpservletrequest;
import javax.servlet.http.httpservletresponse;
@webservlet(value = "/threewaycreate")
public class threewaycreate extends httpservlet {
    @override
    protected void doget(httpservletrequest req, httpservletresponse resp) throws servletexception, ioexception {
        // todo auto-generated method stub
        super.doget(req, resp);
    }
    @override
    protected void dopost(httpservletrequest req, httpservletresponse resp) throws servletexception, ioexception {
        // todo auto-generated method stub
        super.dopost(req, resp);
    }
}

通过以上代码，可能就有小伙伴要问了
不是说servlet要直接或者间接实现servlet接口吗，不是说浏览器每请求一次就要调用一次service方法吗？方法在哪呢？这不是与前面理论冲突了吗？
我们继续看源码，源码才是道理
我在下面值列举源码里面比较核心的部分，需要理解更加深入了解的小伙伴，直接去看源码，tomcat是开源的

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.briup.web;
 
import java.io.ioexception;
 
import javax.servlet.servletexception;
import javax.servlet.annotation.webservlet;
import javax.servlet.http.httpservlet;
import javax.servlet.http.httpservletrequest;
import javax.servlet.http.httpservletresponse;
@webservlet(value = "/threewaycreate")
public class threewaycreate extends httpservlet {
    @override
    protected void doget(httpservletrequest req, httpservletresponse resp) throws servletexception, ioexception {
        // todo auto-generated method stub
        super.doget(req, resp);
    }
    @override
    protected void dopost(httpservletrequest req, httpservletresponse resp) throws servletexception, ioexception {
        // todo auto-generated method stub
        super.dopost(req, resp);
    }
}

分析：

第一步分析

深入了解tomcat中servlet的创建方式实现

可知这个抽象类继承了gennericeservlet这个抽象类 也就是逐层往下推，实现了servle接口，那么这个抽线类必然也继承了serice方法。

第二步分析

深入了解tomcat中servlet的创建方式实现

这个是继承servlet接口的service方法，当浏览器每请求一次时，都会调用这个方法，由图可知，这个方法已经被httpservlet实现了，由实现类可以得出，请求对象req,和响应对象res，被强转成了httpservletrequest，和httpservletresponse（向下转型），然后将强转的对象，传入httpservlet重载的service方法中，调用，第三步，分析重载后的service(httprequest req,httprespone res);

第三步分析

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
protected void service(httpservletrequest req, httpservletresponse resp)
    throws servletexception, ioexception {
 
    string method = req.getmethod();
 
    if (method.equals(method_get)) {
      long lastmodified = getlastmodified(req);
      if (lastmodified == -1) {
        // servlet doesn't support if-modified-since, no reason
        // to go through further expensive logic
        doget(req, resp);
      } else {
        long ifmodifiedsince;
        try {
          ifmodifiedsince = req.getdateheader(header_ifmodsince);
        } catch (illegalargumentexception iae) {
          // invalid date header - proceed as if none was set
          ifmodifiedsince = -1;
        }
        if (ifmodifiedsince < (lastmodified / 1000 * 1000)) {
          // if the servlet mod time is later, call doget()
          // round down to the nearest second for a proper compare
          // a ifmodifiedsince of -1 will always be less
          maybesetlastmodified(resp, lastmodified);
          doget(req, resp);
        } else {
          resp.setstatus(httpservletresponse.sc_not_modified);
        }
      }
 
    } else if (method.equals(method_head)) {
      long lastmodified = getlastmodified(req);
      maybesetlastmodified(resp, lastmodified);
      dohead(req, resp);
 
    } else if (method.equals(method_post)) {
      dopost(req, resp);
 
    } else if (method.equals(method_put)) {
      doput(req, resp);
 
    } else if (method.equals(method_delete)) {
      dodelete(req, resp);
 
    } else if (method.equals(method_options)) {
      dooptions(req,resp);
 
    } else if (method.equals(method_trace)) {
      dotrace(req,resp);
 
    } else {
      //
      // note that this means no servlet supports whatever
      // method was requested, anywhere on this server.
      //
 
      string errmsg = lstrings.getstring("http.method_not_implemented");
      object[] errargs = new object[1];
      errargs[0] = method;
      errmsg = messageformat.format(errmsg, errargs);
 
      resp.senderror(httpservletresponse.sc_not_implemented, errmsg);
    }
  }

通过传过来的httprequest对象，判断请求方式，通过请求方式，决定调用哪个方法（如果请求方式是post方式，那么就会调用dopost(httprequest req,httprestpone res)方法）

第四步分析
综上分析，总结：tomcat创建对象，当浏览器请求的时候，调用servlet的service(serveltrequest req,servletrespone res )方法，然后这个方法再调用，httpservlet里面重载的servlet(httpservletreqeust req ,httpservletrespone res)方法，然后这个方法会通过请求方式是什么，选择性的调用dopost(），还是doget()方法（当然还有很多其他的方式这里就不列举了）， 因此第三种方式，的本质还是当浏览器发起一次请求的时候调用了servlet接口里面的service(serveltrequest req,servletrespone res )方法，然后通过实现类的里面的逻辑，间接的调用了dopost()等方法。

优点：

1、通过请求方式可以处理相应的请求，使得逻辑更加清晰

2，减少代码量，是程序更加简洁

3，使得请求或者响应的操作性更加丰富

4…

四、 总结：

注意点：浏览器发起请求调用的一定是servlet种的service方法；

到此这篇关于深入了解tomcat中servlet的创建方式实现的文章就介绍到这了,更多相关tomcat servlet创建方式内容请搜索’米米素材网’以前的文章或继续浏览下面的相关文章希望大家以后多多支持’米米素材网’！

原文链接：https://blog.csdn.net/weixin_43277309/article/details/108982029