Servlet中的构造方法和finalize（）方法

Question

As we know init() does the job of constructor and destroy() the same of finalize method in case of servlet and there is no harm having a constructor and finalize() method in a Servlet .

Now the query is: if a constructor and a finalize() method are defined in a Servlet, will they be called? Is it like whatever we will initialize in constructor will be overriden with that in init() , or the constructor wont be called at all?

Answer 1

Small Corrections First

Let's review some assumptions first. More details in the rest of the post.

As we know init() does the job of constructor

No, it doesn't. It's significantly different as it:

• declares a throws ServletException ,
• declares a ServletConfig parameter, * it invokes its parent constructor (as Java invokes the parent's no-arg constructor by default).

For that last point, it won't matter in your general case as Servlet and HttpServlet don't do anything, but if using extensions of these abstract clases then you shouldn't assume that they didn't also mess up with the constructors and do things in them. While you can choose from your init() to NOT invoke the paren't init() , the parent's no-arg constructor will always be invoked.

[...] and destroy() the same of finalize method

No, it doesn't.

there is no harm having a constructor and finalize method in a servlet

There may be harm if exceptions occur in your constructor and finalizer, and in any case I surely wouldn't recommend using those, but suggest sticking to init() and destroy() to comply to the spec. The exception handling rules for exceptions thrown from your custom constructor and destructors aren't defined in the specification, so these would be undefined behavior / container-specific.

will they be called?

Did you try? What happens?

(Yes: the no-arg constructor will called for each new thread instance, and the finalizer will be called... whenever the GC will feel like it. )

is it like whatever we will initialize in constructor will be overriden with that in init() or constructor wont be called at all?

init() isn't a constructor.

You may be able to override something in init() that was initialized in the constructor (eg a member variable), or undo/revert actions that you performed in the constructor. Don't see a reason why that would be useful, but you possibly could. But they won't cancel each other out, if that's what you mean.

Why even want to do that?

The questions I ask myself here are more:

• Why do you feel you need a custom constructor here?
• Why do you feel you need a finalizer here? (or in general, actually?)

---

Servlet Lifecycle

Taken from the Java EE 6 Tutorial's section on the Servlet Lifecycle :

1. If an instance of the servlet does not exist, the web container
   • Loads the servlet class.
   • Creates an instance of the servlet class.
   • Initializes the servlet instance by calling the init method. Initialization is covered in Creating and Initializing a Servlet.
   • Invokes the service method, passing request and response objects. Service methods are discussed in Writing Service Methods.
2. If it needs to remove the servlet, the container finalizes the servlet by calling the servlet's destroy method. For more information, see Finalizing a Servlet.

[...]

Any number of exceptions can occur when a servlet executes. When an exception occurs, the web container generates a default page containing the following message:

A Servlet Exception Has Occurred

How to properly init()

Let's the review the Javadoc on init() (emphasis mine)

Called by the servlet container to indicate to a servlet that the servlet is being placed into service.

The servlet container calls the init method exactly once after instantiating the servlet . The init method must complete successfully before the servlet can receive any requests.

The servlet container cannot place the servlet into service if the init method

• Throws a ServletException
• Does not return within a time period defined by the Web server

So, be careful not do anything too consuming in your init() , and things that need to be done only once. If it's something that needs to be done for all requests, then do it in the request processing method (eg doGet() , doPost() , ...).

See also Creating and Initializing a Servlet in the Java EE 6 Tutorial ( and for Java EE 5 ).

How to properly destroy()

Called by the servlet container to indicate to a servlet that the servlet is being taken out of service. This method is only called once all threads within the servlet's service method have exited or after a timeout period has passed. After the servlet container calls this method, it will not call the service method again on this servlet.

This method gives the servlet an opportunity to clean up any resources that are being held (for example, memory, file handles, threads) and make sure that any persistent state is synchronized with the servlet's current state in memory.

See also Finalizing a Servlet in the Java EE 6 Tutorial ( and for Java EE 5 ) (granted, poor choice of words from them here...).

More Information on the Historical Servlet Design and Why Trying to Bypass it is a BAD THING (TM)!

See http://oreilly.com/catalog/jservlet/chapter/ch03.html#15894 :

Why not use a constructor instead? Well, in JDK 1.0 (for which servlets were originally written), constructors for dynamically loaded Java classes (such as servlets) couldn't accept arguments. So, in order to provide a new servlet any information about itself and its environment, a server had to call a servlet's init() method and pass along an object that implements the ServletConfig interface. Also, Java doesn't allow interfaces to declare constructors. This means that the javax.servlet.Servlet interface cannot declare a constructor that accepts a ServletConfig parameter . It has to declare another method, like init(). It's still possible, of course, for you to define constructors for your servlets, but in the constructor you don't have access to the ServletConfig object or the ability to throw a ServletException.

Pay especially attention to the last sentence:

[...] but in the constructor you don't have access to the ServletConfig object or the ability to throw a ServletException.

So doing anything in the servlet's constructor would be:

• impractical,
• but mostly quite dangerous!!

Answer 2

I'm pretty certain that servlets will follow the normal object lifecycle and the constructor will be called.

The existence of an init method means that you can include initialisation code that relies on other parts of the framework having also been initialized. It is called in a known point in the construction of the framework.

Finalize may be called - it'll have all the same problems associated with finalize on all java onjects

Answer 3

Constructor creates an object of the servlet . init() is used to initialize the servlet object. The container passes a reference of ServletConfig to the servlet object in the init(ServletConfig) method so that the Servlet has access to the ServletConfig and ServletContext . You can override a no-arg init() method to execute any initialization code specific to your Servlet. Without the init() method , your Servlet will not have access to its init params.

Since destroy() is the method that the container uses to cleanup resources held by Servlet, you should use it. The finalize() method should be regarded as the absolute last chance to clean up as an object is removed from memory, and not the normal routine cleanup method.Since destroy() is called while the Servlet container still has a reference to the Servlet object, it will be called before the GC process ever gets around to calling finalize() .