Introduction to java server side technologies servlets and jsp
Sponsored Links
This presentation is the property of its rightful owner.
1 / 87

Introduction to Java Server-Side Technologies: Servlets and JSP PowerPoint PPT Presentation

  • Uploaded on
  • Presentation posted in: General

Introduction to Java Server-Side Technologies: Servlets and JSP. Sun tutorial to servlets. Sun JSP Tutorial. Introduction to Servlets. What is a Servlet?. Servlets are Java programs that can be run dynamically from a Web Server Servlets are a server-side technology

Download Presentation

Introduction to Java Server-Side Technologies: Servlets and JSP

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript

Introduction to JavaServer-Side Technologies:Servlets and JSP

Sun tutorial to servlets

Sun JSP Tutorial

Introduction to Servlets

What is a Servlet?

  • Servlets are Java programs that can be run dynamically from a Web Server

  • Servlets are a server-side technology

  • A Servlet is an intermediating layer between an HTTP request of a client and the data stored on the Web server





A Java Servlet


Web browser

Web server

An Example

  • In the following example, the local server calls the ServletTimeServletwith an argument supplied by the user

  • This example, as well as all the examples in this lecture can be found at http://inferno:5000/(accessible only from CS!)

Reload / Refresh Servlet Result

  • Trying to refresh the content created by a servlet will lead to fetching a new content from the server

  • This is not the case with static resources

  • Response headers of a static (as opposed to a servlet generated) resource contain

    • Etag, Last-Modified

  • While trying to refresh a resource

    • Cache-Contol: max-age=0 is sent and that means the server/proxies will try to revalidate the resource

    • Only in the static case the resource could be revalidated against some values the client holds

    • So in the static case the client sends the Etag value attached to the If-None-Match header, and the Last-Modified value is sent in If-Modified-Since

Clear the cache, open and then reload /dbi/Time.htmlOpen and reload /dbi/initCompare the headers sent and received.

What can Servlets do?

  • Read data sent by the user (e.g., form data)

  • Look up other information about the request in the HTTP request (e.g. authentication data, cookies, etc.)

  • Generate the result (may do this by talking to a database, file system, etc.)

  • Format the result as a document (e.g., convert it into HTML format)

  • Set the appropriate HTTP response parameters(e.g. cookies, content-type, etc.)

  • Send the resulting document to the user

In your final project you will install this server to create a powerful website

Supporting Servlets

  • To run Servlets, the Web server must support them

    • ApacheTomcat

      • Also functions as a module for other Apache servers

    • SunJava System Web Server and Java System Application Server

    • IBM's WebSphere Application Server

    • BEA’sWeblogic Application Server

    • Macromedia’sJrun– an engine that can be added to Microsoft’s IIS, Apache’s Web servers and more...

    • Oracle Application Server

Creating a Simple Servlet

Read more about the Servlet Interface







The Servlet Interface

  • Java provides the interface Servlet

  • Specific Servlets implement this interface

  • Whenever the Web server is asked to invoke a specific Servlet, it activates the method service()of an instance of this Servlet

HTTP Request Methods

  • POST -application data sent in the request body

  • GET - application data sent in the URL

  • HEAD- client sees only header of response

  • PUT - place documents directly on server

  • DELETE - opposite of PUT

  • TRACE- debugging aid

  • OPTIONS - list communication options

Servlet Hierarchy

Called by the servlet container to allow the servlet to respond to any request method

service(ServletRequest, ServletResponse)


Generic Servlet

A generic, protocol-independent class, implementing Servlet


doGet(HttpServletRequest , HttpServletResponse)

doPost(HttpServletRequest HttpServletResponse)




Called by the servlet container to allow the servlet to respond to a specific request method

Class HttpServlet

  • Class HttpServlethandles requests and responses of HTTP protocol

  • The service() method of HttpServlet checks the request method and calls the appropriate HttpServletmethod:

    doGet,doPost, doPut, doDelete, doTrace, doOptions ordoHead

  • This class is abstract

That is, a class that can be sub-classed but not instantiated. This class’ methods however are not abstract…

Read more about the HttpServlet Class

Creating a Servlet

  • Extend the classHTTPServlet

  • Implement doGetor doPost(or both; also maybe others…)

  • Both methods get:

    • HttpServletRequest: methods for getting form (query) data, HTTP request headers, etc.

    • HttpServletResponse: methods for setting HTTP status codes, HTTP response headers, and get an output stream used for sending data to the client

  • Many times, we implement doPostby calling doGet, or vice-versa

Check the result of an empty implementationhttp://localhost/dbi/empty

You could also run:

CheckRequestServlet <host> /dbi/empty <port> <OTHER-METHODS>


import javax.servlet.*;

import javax.servlet.http.*;

publicclass TextHelloWorld extends HttpServlet {

publicvoid doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException,IOException{

PrintWriter out = res.getWriter();

out.println("Hello World");


publicvoid doPost(HttpServletRequest req, HttpServletResponse res) throws ServletException,IOException{

doGet(req, res);



Returning HTML

  • By default, no content type is given with a response

  • In order to generate HTML:

    • Tell the browser you are sending HTML, by setting the Content-Type header (response.setContentType())

    • Modify the printed text to create a legal HTML page

  • You should set all headers beforewriting the document content.Can you guess why?

As you can check using LiveHttpHeaders plug-in

Download LiveHttpHeaders Extension

publicclass HelloWorld extends HttpServlet {

publicvoid doGet(HttpServletRequest request,

HttpServletResponse response)

throws ServletException,IOException{

PrintWriter out = response.getWriter();

out.println("<html><head><title>Hello World</title></head>\n");


out.println("<h2>"+new java.util.Date()+"</h2>\n");

out.println("<h1>Hello World</h1>\n</body></html>"); }


Content type wasn’t set, but the browser will understand…

)don’t rely on this in a real product / the project)


Configuring the Server

  • More on this in when we Tomcat in depth…













Getting Information From the Request

An HTTP Request Example

GET/default.asp HTTP/1.0

Accept:image/gif, image/x-xbitmap, image/jpeg, image/png, */*



User-Agent:Mozilla/4.04 [en] (WinNT; I ;Nav)


Accept-Charset: iso-8859-1,*,utf-8

Getting HTTP Data

  • Values of the HTTP request can be accessed through the HttpServletRequestobject

  • Get the value of the headerhdr usinggetHeader("hdr")of the request argument

  • Get all header names: getHeaderNames()

  • Methods for specific request information: getCookies,getContentLength, getContentType,getMethod,getProtocol, etc.

Read more about the HttpRequest Interface

publicclass ShowRequestHeaders extends HttpServlet {

publicvoid doGet(HttpServletRequest request,HttpServletResponse

response) throws ServletException, IOException {


PrintWriter out = response.getWriter();

String title = "Servlet Example: Showing Request Headers";


"<html><head><title>" + title + "</title></head><body>\n"

+ "<h1>" + title+ "</h1>\n"

+ "<h2>Request Method: "+request.getMethod()+"</h2>"

+ "<h2>Request URI: "+request.getRequestURI()+"</h2>"

+ "<h2>ServletPath: "+request.getServletPath()+"</h2>"

+ "<h2>Request Protocol: "+request.getProtocol()+"</h2>"

+ "<table border=\"1\">\n"

+ "<tr><th>Header Name</th><th>Header Value</th></tr>");

Enumeration headerNames = request.getHeaderNames();

while (headerNames.hasMoreElements()) {

String headerName = (String) headerNames.nextElement();

out.println("<tr><td>" + headerName + "</td>"





publicvoid doPost(HttpServletRequest request,HttpServletResponse

response) throws ServletException, IOException {

doGet(request, response);




Compare the results of the different browsers

User Input in HTML

  • Using HTML forms, we can pass parameters to Web applications

  • <form action=… method=…> …</form>comprises a single form

    • action:the address of the application to which the form data is sent

    • method: the HTTP method to use when passing parameters to the application (e.g.get or post)

The <input> Tag

  • Inside a form, INPUT tags define fields for data entry

  • Standard input types include: buttons, checkboxes, password fields,radio buttons, text fields, image-buttons, text areas, hidden fields, etc.

  • Each one associates a single (string) value with a named parameter

GET Example








POST Example








Google doesn’t support POST!(try to guess why)

POST /search HTTP/1.1


Content-type: application/x-www-form-urlencoded

Content-length: 10



Getting the Parameter Values

  • To get the (first) value of a parameter named x:

    • req.getParameter("x")

      where req is the service request argument

  • If there can be multiple values for the parameter:

    • req.getParameterValues("x")

  • To get parameter names:

    • req.getParameterNames()

<html><head><title>Sending Parameters</title>


p{display:table-row} span{display:table-cell; padding:0.2em}


<h1>Please enter the parameters</h1>


<p>Background color:


<p>Font color:

<span><inputtype="text" name="fgcolor"/> </span> </p>

<p>Font size:



<inputtype="submit"value="Submit Parameters"/></h2>




An Example (cont)

publicclass SetColors extends HttpServlet {

publicvoid doGet(HttpServletRequest

request,HttpServletResponse response)

throws ServletException, IOException {


PrintWriter out = response.getWriter();

String bg = request.getParameter("bgcolor");

String fg = request.getParameter("fgcolor");

String size = request.getParameter("size");

An Example (cont)

out.println("<html><head><title>Set Colors Example"


out.println("<body style=\"color:" + fg +

";background-color:" + bg + ";font-size:"+ size + "px\">");

out.println("<h1>Set Colors Example</h1>");

out.println("<p>You requested a background color " + bg + "</p>");

out.println("<p>You requested a font color " + fg + "</p>");

out.println("<p>You requested a font size " + size + "</p>");



Handling Post

  • You don't have to do anything different to read POST data instead of GET data. (Cool!)

<form action="localhost/dbi/SetColors"

method="post"> …

public void doPost(HttpServletRequest request,

HttpServletResponse response)

throws ServletException, IOException {

doGet(request, response);


Creating the Response of the Servlet

HTTP Response

  • The response includes:

    • Status line: version, status code, status message

    • Response headers

    • Empty line

    • Content

HTTP/1.1 200 OK

Content-Type: text/html

Content-Length: 89

Server: Apache-Coyote/1.1


<BODY><H1>Hello World </H1></BODY></HTML>

Read more about the HttpResponse Interface

Setting the Response Status

  • Use the following HttpServletResponse methods to set the response status:

    • setStatus(int sc)

      • Use when there is no error, like 201 (created)

      • No need to send 200 OK explicitly…

    • sendError(sc), sendError(sc, message)

      • Use in erroneous situations, like 400 (bad request)

      • The server may return a formatted message

    • sendRedirect(String location)

      • As opposed to forwarding which is done within the server side completely, on redirect the client gets the “Location” header and a special code (302) and sends another request to the new location


Setting the Response Status

  • Class HTTPServletResponse has static integer variables for popular status codes

    • for example:

      SC_OK(200), SC_NOT_MODIFIED(304),


  • Status code 200 (OK) is the default

Setting Response Headers

  • Use the following HTTPServletResponse methods to set the response headers:

    • setHeader(String hdr, String value), setIntHeader(String hdr, int value)

      • If a header with the same name exists, it is overridden.

    • addHeader(String hdr, String value), addIntHeader(String hdr, int value)

      • The header is added even if another header with the same name exists.

Specific Response Headers

  • Class HTTPServletResponse provides setters for some specific headers:

    • setContentType

    • setContentLength

      • automatically set if the entire response fits inside the response buffer

    • setDateHeader

    • setCharacterEncoding

More Header Methods

  • containsHeader(String header)

    • Check existence of a header in the response

  • addCookie(Cookie)

  • sendRedirect(String url)

    • automatically sets the Location header

  • Do not write into the response after sendErroror sendRedirect

Check the result of writing a responseafter sendError/sendRedirect http://localhost/dbi/bad.html

The Response Content Buffer

  • The response body is buffered

  • Data is sent to the client when the buffer is full or the buffer is explicitly flushed

  • Once the first data chunk is sent to the client, the response is committed

    • You cannot set the response line nor change the headers. Such operations are either ignored or cause an exception to be thrown

Check the result of sendError/setContentType getting “commited” http://localhost/dbi/bad.html

Buffer Related Methods

  • setBufferSize, getBufferSize

    • What are the advantages of using big buffers? what are the disadvantages?

  • flushBuffer

  • resetBuffer

    • Clears the unsent body content

  • reset

    • Clears any data that exists in the buffer as well as the status code and headers (if not yet sent)

  • isCommitted

Supporting HTTP Methods

The HEAD Method

  • The simple implementation of doHead is executing doGet and excluding the response body

  • In addition, the size of the body is calculated and added to the headers

  • You do not have to override this method

  • Why would one want to override this method?

    • The content size is not calculated in servlets as opposed to static html resources…

Check the default implementation of doHead:

Run CheckRequestServlet <HOST> /dbi/init <PORT> GET Run CheckRequestServlet <HOST> /dbi/init <PORT> HEADRun CheckRequestServlet <HOST> /dbi/Time.html <PORT> HEAD(shorter output yet its length is calculated…)In class HOST=localhost, PORT=80

The HEAD Method (cont)

  • The right way to implement doHead is :

    • Don’t implement doHead explicitly

    • Instead, check within the doGet call, what is the requested method (httpServletRequest.getMethod())

    • If it’s HEAD do the same without returning the content

    • This way the results of HEAD / GET requests are similar as they should be


  • doOptions returns the supported methods:

    • For example, if you override doGet then the following header will be returned:


  • doTracereturns the request itself in the body of the message, for debugging purposes

  • You usually do not override these methods

    • Override doOptions if you offer some new methods…

Unsupported Methods

  • By default, the methods doPost, doGet, doPutand doDeletereturn an error status code 405 with the message:

    HTTP method XXXis not supported by this URL

  • doHead calls doGet and therefore leads to the same result but with unsupported method GET

  • In particular, you have to override doGetand doPostif you want to return an appropriate response for these methods

    • Many applications support only one of GET/POST

Servlet Life Cycle

Servlet Life Cycle

  • When the servlet mapped URL is requested, the server loads the Servlet class and initializes one instance of it

  • Each client request is handled by the Serlvet instance in a separate thread

  • The server can remove the Servlet

  • The Servlet can remain loaded to handle additional requests

Servlet Life Cycle

  • When the Servlet in instantiated, its method init()is invoked (in our case, by Tomcat)

    • External parameters are supplied

  • Upon a request, its method service()is invoked

  • Before the Servlet removal, its method destroy()is invoked

Servlet Life Cycle

Deal with requests:

call the


Calling the


Destroy the Servlet:

call the





In our case by servlet we refer to any class extending HttpServlet




Initializing Servlets

  • The method init has a parameter of type ServletConfig

  • ServletConfig has methods to get external initialization parameters (getInitParameter())

    • In Tomcat, these parameters are set in web.xml

  • To make initializations, override init() and notinit(ServletConfig)

    • The former is automatically called by the latter after performing default initializations

If we use init(), how can we obtain a reference to the ServletConfig ?

Read more about the ServletConfig Interface

A web.xml Example

  • More on this in when we Tomcat in depth…











  • publicclass ServletInit extends HttpServlet {

  • String _login = null;

  • Calendar _initTime = null;

  • publicvoid init() throws ServletException {

  • _login = getInitParameter("login");

  • _initTime = newGregorianCalendar();

  • }

  • publicvoid doGet(HttpServletRequest req,

  • HttpServletResponse res) throws ServletException, IOException {

  • res.setContentType("text/html");

  • PrintWriter out = res.getWriter();

    • out.println("<html><head><title>Initialization</title><body><h2>"

  • + "I am the Servlet of <i>" + _login+ "</i><br/>"

  • + "I was initialized at " + _initTime.get(Calendar.HOUR_OF_DAY)

  • + ":"+ _initTime.get(Calendar.MINUTE)

  • + ":"+ _initTime.get(Calendar.SECOND)

  • + "</h2></body></html>"); }}

Calls the method getInitParameterdefined within the ServletConfig interface implemented by HttpServletclass

Loading a Servlet on Startup

  • A Servlet is usually loaded when it is first being called

  • You can set Tomcat to load a specific Servlet on startup in the Servlet declaration inside web.xml

  • More on this in when we Tomcat in depth…






You can use this element to set the loading order of those servlets which are loaded on startup

Destroying Servlets

  • The server may remove a loaded Servlet, Why?:

    • asked to do so by an administrator (e.g. Server shutdown)

    • Servlet was idle for a long time

    • server needs to free resources

  • The server removes a Servlet only if all threads have finished or a grace periodhas passed

  • Before removing, calls the destroy()method

    • can perform cleanup, e.g., close database connections

  • Is it possible for the Servlet to end without its destroy being called?

    • You can do it if you kill the process explicitly

Thread Synchronization

  • Multiple threads are accessing the same Servlet object at the same time

  • Therefore, you have to deal with concurrency

  • init() and destroy()are guaranteed to be executed only once (before/after all service executions)

Introduction to JSP

Many HTML Pages are Mostly Static

  • Servlets allow us to write dynamic Web pages

    • Easy access to request, session and context data

    • Easy manipulation of the response (cookies, etc.)

    • And lots more...

  • It is very inconvenient to write and maintain long and mostly static HTML pages using Servlets (even though such pages are very common)

    out.println("<h1>Bla Bla</h1>" + "bla bla bla bla" + "lots more here...")

Introducing JSP

  • The Idea:

    • Use HTML for most of the page.

    • Write Servlet code directly in the HTML page, marked with special tags.

  • The server automatically translates a JSP page to a Servlet class and the latter is actually invoked

    • In Tomcat 5.5, you can find the generated Servlet code under $CATALINA_BASE/work/

  • A JSP is no more than a very (very) convenient way to write servlets which output textual data.




  • Servlets: HTML code is printed using Java code

  • JSP: Java code is embedded in HTML code

  • Not only for HTML! JSP can be used for any textual format. Servlets can be used for any data!






<title>Hello World</title>



<h2><%= new java.util.Date() %></h2>

<h1>Hello World</h1>



Open the generated Java code







Generated Servlet Hierarchy(Tomcat 5.0 Implementation)



Abstract class extended by every generated Servlet

Read more about Apache HttpJspBase Class

JSP Limitations and Advantages

  • JSP can only do what a Servlet can do

  • Easier to write and maintain HTML

  • Easier to separate HTML from code

  • Can be created using a "reverse engineering technique":

    • Create static HTML and then replace static data with Java code

JSP Life Cycle

JSP Life Cycle

The following table describes the life cycle of JSP generated Servlet in details:

Translation & compilation only after first call…

JSP Life Cycle

Server restarted

Page modified

Page first written

Written by Marty Hall. Core Servlets & JSP book:

JSP Translation

JSP file named file.jsp will be translated into the Java file

  • When the JSP file is modified, JSP is translated into a Servlet

    • But only after the JSP’s url is requested by the client

    • Application needs not be reloaded when JSP file is modified

  • Server does not generate the Servlet class after startup, if the latter already exists and isn’t too old

    • Generated Servlet acts just like any other Servlet

  • The generated servlet can handle GET, POST, HEAD requests though it does not implement doGet(), doPost(), doHead() explicitly

    • Its Servlet.service() method calls the newly implemented main method named HttpJspBase._jspService()

init() and destroy()

  • init() of the generated Servlet is called every time the Servlet class is loaded into memory and instantiated

  • destroy() of the generated Servlet is called every time the generated Servlet is removed

  • The latter two happen even if the reason is modification of the JSP file

jspInit and jspDestroy

  • In JSP pages, like regular Servlets, we sometimes want to implement init and destroy

  • It is illegal to use JSP declarations to override init or destroy, since they are (usually) already implemented by the generated Servlet

  • Instead, override the methodsjspInit() and jspDestroy()

    • The generated servlet is guaranteed to call these methods from init and destroy,respectively

    • The standard versions of jspInit and jspDestroy are empty (placeholders for you to override)

Thread Synchronization

  • After the Servlet is generated, one instance of it serves requests in different threads, just like any other Servlet

  • In particular, the service method (_jspService) may be executed by several concurrent threads

  • Thus, like Servlets, JSP programming requires concurrency management

Basic JSP Elements

A Quick Reference to JSP Elements

Basic Elements in a JSP file

  • HTML code: <html-tag>content</html-tag>

  • JSP Comments: <%-- comment --%>

  • Expressions: <%= expression %>

  • Scriptlets: <% code %>

  • Declarations: <%! code %>

  • Directives: <%@ directive attribute="value" %>

  • Actions: <jsp:forward.../>, <jsp:include.../>

  • EL Expressions: ${expression}

Covered Later...

JSP Expressions

  • A JSP expression is used to insert Java values directly into the output

  • It has the form: <%= expression %>, where expression can be a Java object, a numerical expression, a method call that returns a value, etc...

  • For example:

    <%= new java.util.Date() %>

    <%= "Hello"+" World" %>

    <%= (int)(100*Math.random()) %>

The heading space and the following space are not created in the result.

Use “ “ if you want a real space

JSP Expressions

  • Within the generated Java code

    • A JSP Expression is evaluated

    • The result is converted to a string

    • The string is inserted into the page

  • This evaluation is performed at runtime (when the page is requested), and thus has full access to information about the request, the session, etc...

public void _jspService(HttpServletRequest request,

HttpServletResponse response)

throws, ServletException {




out.write("<h1>A Random Number</h1>\r\n");

out.print( Math.random() );




Expression Translation

<h1>A Random Number</h1>

<%= Math.random() %>

Default content-type

The generated servlet calls out.write() for Strings, and out.print() for objects

Predefined Variables (Implicit Objects)

  • The following predefined variables can be used:

    • request: the HttpServletRequest

    • response: the HttpServletResponse

    • session: the HttpSession associated with the request

    • out: the PrintWriter (a buffered version of type JspWriter) used to fill the response content

    • application: The ServletContext

    • config: The ServletConfig

  • These variables and more will be discussed in details



<title>JSP Expressions</title>



<h2>JSP Expressions</h2>


<li>Current time: <%= new java.util.Date() %></li>

<li>Your hostname:<%= request.getRemoteHost() %></li>

<li>Your session ID: <%= session.getId() %></li>

<li>The <code>testParam</code> form parameter:

<%= request.getParameter("testParam") %></li>




Computer-code style

JSP Scriplets

  • JSP scriptletslet you insert arbitrary code into the Servlet service method ( _jspService)

  • Scriptlets have the form: <% Java Code%>

  • The code is inserted verbatim into the service method, according to the location of the scriptlet

  • Scriptlets have access to the same automatically defined variables as expressions

Scriptlet Translation

<%= foo() %>

<% bar(); %>

public void _jspService(HttpServletRequest request,

HttpServletResponse response)

throws ServletException, IOException {








An Interesting Example

Scriptlets don't have to be complete code blocks:

<%if (Math.random() < 0.5) { %>

You <b>won</b> the game!

<%} else { %>

You <b>lost</b> the game!

<% } %>

if (Math.random() < 0.5) {

out.write("You <b>won</b> the game!");

} else {

out.write("You <b>lost</b> the game!");


JSP Declarations

  • A JSP declaration lets you define methods or members that get inserted into the Servlet class (outside of all methods)

  • It has the following form:

    <%! Java Code %>

  • For example:

    <%! private int someField = 5; %>

    <%! private void someMethod(...) {...} %>

  • JSPs are intended to contain a minimal amount of code so it is usually of better design to define methods in a separate Java class...

Declaration Example

  • Print the number of times the current page has been requested since the Servlet initialization:

<%! private int accessCount = 0; %>

<%! private synchronized int incAccess() {

return ++accessCount;

} %>

<h1>Accesses to page since Servlet init:

<%= incAccess() %> </h1>

Generated Servlet

public class serviceCount_jsp extends... implements...

throws... {

private int accessCount = 0;

private synchronized int incAccess() {

return ++accessCount;


public void _jspService(HttpServletRequest request,

HttpServletResponse response)

throws ServletException, IOException {



out.write("<h1>Accesses to page since Servlet init: ");


... } ... }

Java permits member initialization on declaration, even if the location is outside any method’s scope

JSP Directives

  • A JSP directive affects the structure of the Servlet class that is generated from the JSP page

  • It usually has the following form:

    <[email protected] attribute1="value1"... attributeN="valueN"%>

  • Three important directives: page, include and taglib

  • include and taglib will be discussed later

page-Directive Attributes

  • importattribute: A comma separated list of classes/packages to import

    <%@ page import="java.util.*,*" %>

  • contentTypeattribute:Sets the MIME-Type of the resulting document (default is text/html as already mentioned)

    <%@ page contentType="text/plain" %>

Imports from the class/Jar locations as mentioned in Tomcat class

page-Directive Attributes (cont)

  • What is the difference between setting the page contentType attribute, and writing<%response.setContentType("...");%> ?

    • In the latter case, the new servlet will call response.setContentType()twice

    • The first, impicit (from the JSP point of view), call will be with the default content type.

    • The second, explicit, call might even come after the buffer was flushed or after the writer was obtained…

Check: double-contenttype.jsp code using the explicit call, generated java code (servlet)

page-Directive Attributes (cont)

.If the JSP is defined as using a session, a session cookie will be sent to the client

The underlinedvalue is the default

  • session="true|false" - use a session?

  • buffer="sizekb|none|8kb"

    • Specifies the content-buffer (out) size in kilo-bytes

  • autoFlush="true|false"

    • Specifies whether the buffer should be flushed when it fills, or throw an exception otherwise

  • isELIgnored ="true|false"

    • Specifies whether JSP expression language is used

    • EL is discussed later

  • Login