In-depth understanding of the creation and implementation of servlets in tomcat

1. What is a servlet

1.1. Explain in official words:

Servlet is a technology provided by Oracle for developing dynamic web resources and is a core specification in the JavaEE system.
To put it simply : a class written by our developers must directly or indirectly implement the core specification of JavaEE, that is, implement the Servlet interface. Because the objects generated by this class can be accessed by the browser, it is called Servlet, and JavaEE stipulates that only objects generated by the Servlet implementation class can be accessed by the browser, that is, Servlet. (That is to say, this class must directly or indirectly implement the Servlet interface)

2. Start creating servlet

2.1. Through the previous introduction, we know what kind of class creates objects that can be accessed by the browser. First, let's go directly to the code:

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("Object created");
	}
	@Override
	public void init(ServletConfig config) throws ServletException {
		// TODO Auto-generated method stub
		System.out.println("I am init: I was called");
	}
	@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("I am a service, I was called");	
	}
	@Override
	public String getServletInfo() {
		// TODO Auto-generated method stub
		return null;
	}
	@Override
	public void destroy() {
		// TODO Auto-generated method stub
		System.out.println("I am destory: I was called");
	}

}

So, a class that satisfies the servlet has been created, and the next question is

Who creates the servet object?

Which interface methods implemented in it will be called, when will they be called, and how many times will they be called?
The first question is: since it is a servlet class, it is obviously unreasonable for our developers to manually create the object, so the creation of this object is handed over to Tomcat. Our developers only need to tell Tomcat to create it and let it create it at any time.
How to tell?

1. Method 1: By configuring webxml. (Highly not recommended)

For the entire dynamic web project, web.xml is the first configuration file loaded, so configure it in web.xml

<?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>

explain:
1. servlet-name: The name of the servlet. Please note that it should correspond to the name you set in the mapping below.
2. serlvet-class: the fully qualified name of serlvet
3. load-on-startup: whether to create a servlet object when tomcat starts, pass in an integer greater than 0'' ( the default is to create a servlet object when the browser requests it for the first time )
4. Servlet-mapping: As the name suggests, set the browser access mapping
5. servlet-name: corresponds to the above
6. url-pattern: browser access mapping (assuming the default is the local machine, and the port number of tomcat is 8080, then the path for the browser to access this servlet is: localhost:8080/project name/FirstWay )
With these foundations in place, let’s take a look;

Step 1: Start Tomcat

tomcat starts normally

Step 2: Access through the browser (we manually access 3 times here)

Browser access is normal

Step 3: Observe the console

By running the results analysis:

When you start the server for the first time, the object is not created

The browser requests three times, but the object is created only once and the init() method is called only once.

Each time the object is accessed, the service() method is called

Other methods are not called

Explain why it is not called: getServletConfig(): get the ServletConfig object: getServletInfo(): get the confidence of the Servlet, such as the author: destroy(): This method is called when the servlet is destroyed (for example: tomcati is closed normally , I will not test it here. If you want to test it, you can right-click the service and click stop) and then observe the console to know.

2. Method 2: Tell tomcat by annotation (compared with the former, recommended)

@WebServlet(value = "mapping path")
public Fristservlet implement Servelt {
}

This annotation can also be used to set whether to create an object when starting the server. This will not be demonstrated here.
Note: ( Once you use annotations to tell Tomcat to create an object, you can no longer access and set the servlet in web.xml )

3. Return to the topic, the second way to create a servlet

With the previous explanation, let's go directly to the code and then analyze it

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("The service method was called");
	}

}

1. Simpler than the first method, it implements the GenericServlet class

2. Let's look at the GenericServlet source code and then analyze it;

public abstract class GenericServlet implements Servlet, ServletConfig,

It can be seen that this is a drawer class, which is the implementation class of the servlet interface, so GenericServlet indirectly implements the servlet interface.
Compared with the first method: developers do not have to implement unnecessary methods in some interfaces, can be selective, and reduce the amount of code. However, it is not as useful as above, it is just pretending to be B

3. Focus on the third method (compared with the first two, I recommend the third method more)

Directly on the code

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);
	}
}

Through the above code, some friends may ask, doesn’t the servlet have to directly or indirectly implement the servlet interface? Doesn’t the browser have to call the service method once for each request? Where is the method? Doesn’t this conflict with the previous theory?
Let's continue to look at the source code, the source code is the truth <br /> I will list the core parts of the source code below. Friends who need to understand more deeply can go directly to the source code. Tomcat is open source

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);
	}
}

analyze:

First step analysis

It can be seen that this abstract class inherits the abstract class GennericeServlet , which means it is pushed down layer by layer and implements the Servle interface. Then this extraction class must also inherit the serice method.

Second step analysis

This is the service method that inherits the servlet interface. This method is called every time the browser requests. As shown in the figure, this method has been implemented by HttpServlet. From the implementation class, it can be concluded that the request object req and the response object res are forcibly converted into HttpServletRequest and HttpServletResponse (downward transformation), and then the forcibly converted objects are passed into the overloaded Service method of HttpServlet and called. The third step is to analyze the overloaded Service (HttpRequest req, HttpResponse res);

Step 3 Analysis

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);
    }
  }

The request method is determined by the passed HttpRequest object, and the method to be called is determined by the request method ( if the request method is post, the doPost(HttpRequest req,HttpRestpone Res) method is called )

Analysis of the fourth step: Based on the above analysis, we can conclude that: tomcat creates an object, and when the browser requests, it calls the Servlet's Service(ServeltRequest req, ServletRespone res) method, and then this method calls the overloaded Servlet(HttpServletReqeust req, HttpServletRespone res) method in HttpServlet, and then this method will selectively call the doPost() or doGet() method according to the request method ( of course there are many other ways that are not listed here ). Therefore, the essence of the third method is that when the browser initiates a request, the Service(ServeltRequest req, ServletRespone res) method in the Servlet interface is called, and then the doPost() and other methods are indirectly called through the logic in the implementation class.

advantage:

1. The corresponding request can be processed through the request method, making the logic clearer

2. Reduce the amount of code to make the program more concise

3. Make the request or response more operable

4…

IV. Summary:

Note: The browser must initiate a request to call the service method of the servlet;

This is the end of this article about in-depth understanding of the implementation of servlet creation in tomcat. For more relevant content on tomcat servlet creation, please search for previous articles on 123WORDPRESS.COM or continue to browse the following related articles. I hope you will support 123WORDPRESS.COM in the future!