Transcript ppt

Introduction to Java
Server-Side Technologies:
Servlets and JSP
Representation and Management of
Data on the Internet, 2007
CS Department, HUJI
Sun tutorial to servlets
Sun JSP Tutorial
1
Introduction to Servlets
2
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
3
A Java Servlet
request
request
Servlet
response
response
Web
browser
Web server
4
An Example
• In the following example, the local server calls
the Servlet TimeServlet with 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!)
5
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-ModifiedSince
Clear the cache, open and then reload /dbi/Time.html
Open and reload /dbi/init
Compare the headers sent and received.
6
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
7
Supporting Servlets
• To run Servlets, the Web server must support them
- Apache Tomcat
• Also functions as a module for other Apache servers
- Sun Java System Web Server and Java System Application
Server
- IBM's WebSphere Application Server
- BEA’s Weblogic Application Server
- Macromedia’s Jrun – an engine that can be added to Microsoft’s
IIS, Apache’s Web servers and more...
- Oracle Application Server
In your final project
you will install this
- …
server to create a
powerful website
8
Creating a Simple Servlet
Read more about the Servlet Interface
9
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)
response
MyServlet
service(request,response)
(HTTP)
request
10
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
11
Servlet Hierarchy
Called by the servlet container to
allow the servlet to respond to any
request method
Servlet
Generic Servlet
service(ServletRequest,
ServletResponse)
A generic, protocol-independent
class, implementing Servlet
HttpServlet
doGet(HttpServletRequest ,
HttpServletResponse)
doPost(HttpServletRequest
YourOwnServlet
HttpServletResponse)
doPut
Called by the servlet container to
doTrace
allow the servlet to respond to a
…
specific request method
12
Class HttpServlet
• Class HttpServlet handles requests and responses
of HTTP protocol
• The service() method of HttpServlet checks the
request method and calls the appropriate
HttpServlet method:
doGet, doPost, doPut, doDelete, doTrace,
doOptions or doHead That is, a class that can be sub-
• This class is abstract
classed but not instantiated.
This class’ methods however
are not abstract…
Read more about the HttpServlet Class
13
Creating a Servlet
• Extend the class HTTPServlet
• Implement doGet or 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 doPost by calling doGet, or viceversa
Check the result of an empty implementation
http://localhost/dbi/empty
You could also run:
CheckRequestServlet <host> /dbi/empty <port> <OTHER-METHODS>
14
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
HelloWorld.java
public class TextHelloWorld extends HttpServlet {
public void doGet(HttpServletRequest req, HttpServletResponse
res) throws ServletException, IOException {
PrintWriter out = res.getWriter();
out.println("Hello World");
}
public void doPost(HttpServletRequest req, HttpServletResponse
res) throws ServletException, IOException {
doGet(req, res);
}
}
15
Returning HTML
• By default, no content type is given with a
As you can check using LiveHttpHeaders plug-in
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 before writing the
document content. Can you guess why?
Download LiveHttpHeaders Extension
16
public class HelloWorld extends HttpServlet {
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
HelloWorld.java
Content type wasn’t set,
but the browser will
understand…
)don’t rely on this in a real
product / the project)
PrintWriter out = response.getWriter();
out.println("<html><head><title>Hello World</title></head>\n");
out.println("<body>");
out.println("<h2>" + new java.util.Date() + "</h2>\n");
out.println("<h1>Hello World</h1>\n</body></html>"); }
}
17
Configuring the Server
• More on this in when we Tomcat in depth…
myApp/WEB<web-app>
INF/web.xml
<servlet>
<servlet-name>hello</servlet-name>
<servlet-class>HelloWorld</servlet-class>
</servlet> myApp/WEB-INF/classes/HelloWorld.class
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping></web-app>
</web-app>
http://inferno:5000/dbi/hello
18
Getting Information
From the Request
19
An HTTP Request Example
GET /default.asp HTTP/1.0
Accept: image/gif, image/x-xbitmap, image/jpeg, image/png, */*
Accept-Language: en
Connection: Keep-Alive
Host: magni.grainger.uiuc.edu
User-Agent: Mozilla/4.04 [en] (WinNT; I ;Nav)
Cookie:SITESERVER=ID=8dac8e0455f4890da220ada8b76f;
ASPSESSIONIDGGQGGGAF=JLKHAEICGAHEPPMJKMLDEM
Accept-Charset: iso-8859-1,*,utf-8
20
Getting HTTP Data
• Values of the HTTP request can be accessed through the
HttpServletRequest object
• Get the value of the header hdr using
getHeader("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
21
public class ShowRequestHeaders extends HttpServlet {
public void doGet(HttpServletRequest request,HttpServletResponse
response) throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String title = "Servlet Example: Showing Request Headers";
out.println(
"<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>");
22
Enumeration headerNames = request.getHeaderNames();
while (headerNames.hasMoreElements()) {
String headerName = (String) headerNames.nextElement();
out.println("<tr><td>" + headerName + "</td>"
+"<td>"+request.getHeader(headerName)+"</td></tr>");
}
out.println("</table>\n</body></html>");
}
public void doPost(HttpServletRequest request,HttpServletResponse
response) throws ServletException, IOException {
doGet(request, response);
}
Compare the results of the different browsers
}
}
23
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)
24
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, imagebuttons, text areas, hidden fields, etc.
• Each one associates a single (string) value with a
named parameter
25
GET Example
<form method="get"
action="http://www.google.com/search">
<p><input name="q" type="text" />
<input type="submit" />
<input type="reset" />
</p>
</form>
http://www.google.com/search?q=servlets
26
POST Example
<form method="post"
action="http://www.google.com/search">
<p><input name="q" type="text" />
<input type="submit" />
<input type="reset" />
Google doesn’t
</p>
support POST!
</form>
POST /search HTTP/1.1
(try to guess why)
Host: www.google.com
…
Content-type: application/x-www-form-urlencoded
Content-length: 10
<empty-line>
q=servlets
27
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()
28
<html><head><title>Sending Parameters</title>
<style type="text/css">
p{display:table-row} span{display:table-cell; padding:0.2em}
</style></head><body>
<h1>Please enter the parameters</h1>
<form action=“setcolors" method="get">
<p>Background color:
<span><input type="text" name="bgcolor"/></span></p>
<p>Font color:
<span><input type="text" name="fgcolor"/> </span> </p>
<p>Font size:
<span><input type="text" name="size"/></span></p>
<h2>
<input type="submit" value="Submit Parameters"/></h2>
</form>
</body></html>
parameters.html
29
An Example (cont)
public class SetColors extends HttpServlet {
public void doGet(HttpServletRequest
request,HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
String bg = request.getParameter("bgcolor");
String fg = request.getParameter("fgcolor");
String size = request.getParameter("size");
SetColors.java
30
An Example (cont)
out.println("<html><head><title>Set Colors Example"
+"</title></head>");
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>");
out.println("</body></html>");
}
SetColors.java
31
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);
}
32
Creating the
Response of the Servlet
33
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
<HTML><HEAD><TITLE>HELLO
WORLD</TITLE></HEAD>
<BODY><H1>Hello World
</H1></BODY></HTML>
Read more about the HttpResponse Interface
34
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
35
http://localhost/dbi/redirect
Setting the Response Status
• Class HTTPServletResponse has static integer
variables for popular status codes
- for example:
SC_OK(200), SC_NOT_MODIFIED(304),
SC_UNAUTHORIZED(401), SC_BAD_REQUEST(400)
• Status code 200 (OK) is the default
36
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.
37
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
38
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 sendError or
sendRedirect
Check the result of writing a response after sendError/sendRedirect
http://localhost/dbi/bad.html
39
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
40
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
41
Supporting HTTP Methods
42
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> HEAD
Run CheckRequestServlet <HOST> /dbi/Time.html <PORT> HEAD
(shorter output yet its length is calculated…)
In class HOST=localhost, PORT=80
43
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
44
OPTIONS and TRACE
• doOptions returns the supported methods:
- For example, if you override doGet then the following
header will be returned:
Allow: GET, HEAD, TRACE, OPTIONS
• doTrace returns 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…
45
Unsupported Methods
• By default, the methods doPost, doGet, doPut and
doDelete return an error status code 405 with the
message:
HTTP method XXX is 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 doGet and doPost if
you want to return an appropriate response for these
methods
- Many applications support only one of GET/POST
46
Servlet Life Cycle
47
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
Browser
Browser
Server
Servlet
Instance
Browser
• The server can remove the Servlet
• The Servlet can remain loaded to handle additional
requests
48
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
49
Servlet Life Cycle
Calling the
init method
Servlet
Instance
Deal with requests:
call the
service method
Destroy the Servlet:
call the
destroy method
ServletConfig
In our case by servlet we
Servlet Class
refer to any class
extending HttpServlet
Garbage
Collection
50
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 not
If we use init(), how can we obtain a
init(ServletConfig)
reference to the ServletConfig ?
- The former is automatically called by the latter
after performing default initializations
Read more about the ServletConfig Interface
51
A web.xml Example
• More on this in when we Tomcat in depth…
<web-app>
…
<servlet>
<servlet-name>InitExample</servlet-name>
<servlet-class>ServletInit</servlet-class>
<init-param>
<param-name>login</param-name>
<param-value>snoopy</param-value>
</init-param>
</servlet>
…
</web-app>
52
public class ServletInit extends HttpServlet {
Calls the method
String _login = null;
getInitParameter
defined within the
Calendar _initTime = null;
ServletConfig interface
public void init() throws ServletException {
implemented by
_login = getInitParameter("login");
HttpServlet class
_initTime = new GregorianCalendar();
}
public void 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)
ServletInit.java
+ "</h2></body></html>"); }}
53
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…
<servlet>
<servlet-name>InitExample</servlet-name>
You can use this element to
<servlet-class>ServletInit</servlet-class>
set the loading order of
<load-on-startup/>
those servlets which are
</servlet>
loaded on startup
54
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 period has 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
55
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)
56
Introduction to JSP
57
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...")
58
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.
59
Relationships
• 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!
Java
HTML
HTML
JAVA
60
Example
<html>
<head>
<title>Hello World</title>
</head>
<body>
<h2><%= new java.util.Date() %></h2>
<h1>Hello World</h1>
</body>
</html>
Open the generated Java code
61
Generated Servlet Hierarchy
(Tomcat 5.0 Implementation)
Sun
Specifications
Servlet
classes
GenericServlet
HttpServlet
Apache
Implementation
Abstract class extended
by every generated
Servlet
JspPage
interfaces
HttpJspPage
HttpJspBase
mypage_jsp
Generated
Servlet
Read more about Apache HttpJspBase Class
62
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
63
JSP Life Cycle
64
JSP Life Cycle
The following table describes the life cycle of JSP
generated Servlet in details:
65
Translation &
compilation only
after first call…
JSP Life Cycle
Request
#4
Request
#5
Request
#6
Yes
No
No
No
Yes
No
Yes
No
No
No
Yes
No
Yes
No
Yes
No
Yes
No
init (or
equivalent) called
Yes
No
Yes
No
Yes
No
doGet (or
equivalent) called
Yes
Yes
Yes
Yes
Yes
Yes
JSP page
translated into
servlet
JSP’s Servlet
compiled
Servlet
instantiated and
loaded into
server's memory
Page modified
Request
#3
Server restarted
Request
#2
Page first written
Request
#1
Written by Marty Hall. Core Servlets & JSP book: www.coreservlets.com
66
JSP Translation
• When the JSP file is modified,
JSP is translated into a Servlet
JSP file named file.jsp
will be translated into the
Java file file_jsp.java
- 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()
67
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
68
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 methods jspInit() 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)
69
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
70
Basic JSP Elements
A Quick Reference to JSP Elements
71
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...
72
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:
The heading
space and the
following space
are not created in
the result.
Use “ “ if you
want a real space
<%= new java.util.Date() %>
<%= "Hello"+" World" %>
<%= (int)(100*Math.random()) %>
73
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...
74
Expression Translation
<h1>A Random Number</h1>
<%= Math.random() %>
public void _jspService(HttpServletRequest request,
HttpServletResponse response)
throws java.io.IOException, ServletException {
...
Default contentresponse.setContentType("text/html");
type
...
out.write("<h1>A Random Number</h1>\r\n");
out.print( Math.random() );
The generated servlet
out.write("\r\n");
calls out.write() for
Strings, and out.print()
...
for objects
75
}
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
76
<html>
<head>
<title>JSP Expressions</title>
</head>
<body>
<h2>JSP Expressions</h2>
<ul>
<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>
</ul>
</body> Computer-code
style
</html>
77
JSP Scriplets
• JSP scriptlets let 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
78
Scriptlet Translation
<%= foo() %>
<% bar(); %>
public void _jspService(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
...
response.setContentType("text/html");
...
out.print(foo());
bar();
...
}
79
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!");
}
80
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...
81
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>
82
public class serviceCount_jsp extends... implements...Generated
Servlet
throws... {
Java permits
private int accessCount = 0;
member
initialization on
private synchronized int incAccess() { declaration,
even
if the location is
return ++accessCount;
outside any
}
method’s scope
public void _jspService(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
...
...
out.write("<h1>Accesses to page since Servlet init: ");
out.print(incAccess());
... } ... }
83
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:
<%@ directive attribute1="value1" ...
attributeN="valueN" %>
• Three important directives: page, include and taglib
• include and taglib will be discussed later
84
page-Directive Attributes
• import attribute: A comma separated list of
classes/packages to import
<%@ page import="java.util.*, java.io.*" %>
Imports from the
class/Jar locations as
mentioned in Tomcat
class
• contentType attribute: Sets the MIME-Type of the
resulting document (default is text/html as already
mentioned)
<%@ page contentType="text/plain" %>
85
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)
86
page-Directive Attributes (cont)
• session="true|false" - use a session?
The underlined value is the
default
• buffer="sizekb|none|8kb"
.
If the JSP is defined as
using a session, a
session cookie will be
sent to the client
- 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
87