JavaScript, often abbreviated as JS, is a programming language and core technology of the World Wide Web, alongside HTML and CSS. As of 2024, 98.9% of websites use JavaScript on the client side for webpage behavior, often incorporating third-party libraries.

1. Java Server Page (JSP)

2. Overview of History
CGI
(in C)
Template
(ASP, PHP)
Servlet
CGI
(java, C++)
JSP
Speed, Security
complexity

3. INE2720 – Web Application
Software Development
All copyrights reserved by C.C. Cheung 2003. 3
Web Application Topics
• Web Application Architecture
– 1-, 2-, 3-Tier Architectures
• J2EE framework
– Java Servlets
– JavaServer Pages
– Enterprise JavaBeans
– JDBC
– JavaMail
– Java Transaction Service (JTS), …

4. INE2720 – Web Application
Software Development
All copyrights reserved by C.C. Cheung 2003. 4
Web Application model
Client Tier Middle Tier
Enterprise Information
System (EIS) Tier
application
browser
Web Container
Servlet
Servlet
JSP
…
Database
JDBC

5. INE2720 – Web Application
Software Development
All copyrights reserved by C.C. Cheung 2003. 5
A Servlet’s Job
• Read explicit data sent by client (form data)
• Read implicit data sent by client (request headers)
• Generate the results
• Send the explicit data back to client (HTML)
• Send the implicit data to client
(status codes and response headers)

6. INE2720 – Web Application
Software Development
All copyrights reserved by C.C. Cheung 2003. 6
Why Build Pages Dynamically?
• The Web page is based on data submitted by the
user
– E.g., results page from search engines and order-
confirmation pages at on-line stores
• The Web page is derived from data that changes
frequently (E.g., a weather report)
• The Web page uses information from databases or
other server-side sources
– E.g., an e-commerce site could use a servlet to build a Web
page that lists the current price and availability of each
item that is for sale

7. INE2720 – Web Application
Software Development
All copyrights reserved by C.C. Cheung 2003. 7
Servlet Engine (container)
IE
Netscape
Opera
Many other Servlets

8. Java Server Pages
• JavaServer Pages (JSP) is a technology for developing web pages
that support dynamic content which helps developers insert java
code in HTML pages by making use of special JSP tags, most of
which start with <% and end with %>.
• A JavaServer Pages component is a type of Java servlet that is
designed to fulfill the role of a user interface for a Java web
application.
• Web developers write JSPs as text files that combine HTML or
XHTML code, XML elements, and embedded JSP actions and
commands.
• Using JSP, you can collect input from users through web page forms,
present records from a database or another source, and create web
pages dynamically.
• JSP tags can be used for a variety of purposes, such as retrieving
information from a database or registering user preferences,
accessing JavaBeans components, passing control between pages
and sharing information between requests, pages etc.

9. Why Use JSP
• Performance is significantly better because JSP allows
embedding Dynamic Elements in HTML Pages itself instead
of having a separate CGI files.
• JSP are always compiled before it's processed by the server
• JavaServer Pages are built on top of the Java Servlets API,
so like Servlets, JSP also has access to all the powerful
Enterprise Java APIs, including JDBC, JNDI, EJB, JAXP etc.
• JSP pages can be used in combination with servlets that
handle the business logic, the model supported by Java
servlet template engines.
• Finally, JSP is an integral part of Java EE, a complete
platform for enterprise class applications. (simple to
complex applications)

11. Client and Server with JSP

12. JSP Processing

13. JSP Processing
• As with a normal page, your browser sends an HTTP request to the web
server.
• The web server recognizes that the HTTP request is for a JSP page and
forwards it to a JSP engine. This is done by using the URL or JSP page
which ends with .jsp instead of .html.
• The JSP engine loads the JSP page from disk and converts it into a servlet
content. This conversion is very simple in which all template text is
converted to println( ) statements and all JSP elements are converted to
Java code that implements the corresponding dynamic behavior of the
page.
• The JSP engine compiles the servlet into an executable class and forwards
the original request to a servlet engine.
• A part of the web server called the servlet engine loads the Servlet class
and executes it. During execution, the servlet produces an output in HTML
format, which the servlet engine passes to the web server inside an HTTP
response.
• The web server forwards the HTTP response to your browser in terms of
static HTML content.
• Finally web browser handles the dynamically generated HTML page inside
the HTTP response exactly as if it were a static page.

14. Four major phases of JSP life cycle are

15. JSP Compilation
• When a browser asks for a JSP, the JSP engine
first checks to see whether it needs to compile
the page. If the page has never been
compiled, or if the JSP has been modified
since it was last compiled, the JSP engine
compiles the page.
• The compilation process involves three steps:
1.Parsing the JSP.
2.Turning the JSP into a servlet.
3.Compiling the servlet.

16. JSP Initialization
• When a container loads a JSP it invokes the jspInit()
method before servicing any requests. If you need to
perform JSP-specific initialization, override the jspInit()
method:
public void jspInit()
{
// Initialization code...
}
• Typically initialization is performed only once and as
with the servlet init method, you generally initialize
database connections, open files, and create lookup
tables in the jspInit method.

17. JSP Execution
• This phase of the JSP life cycle represents all interactions with
requests until the JSP is destroyed.
• Whenever a browser requests a JSP and the page has been loaded
and initialized, the JSP engine invokes the _jspService() method in
the JSP.
• The _jspService() method takes an HttpServletRequest and
an HttpServletResponse as its parameters as follows:
void _jspService(HttpServletRequest request,
HttpServletResponse response)
{
// Service handling code...
}
• The _jspService() method of a JSP is invoked once per a request and
is responsible for generating the response for that request and this
method is also responsible for generating responses to all seven of
the HTTP methods ie. GET, POST, DELETE etc.

18. JSP Cleanup
• The destruction phase of the JSP life cycle represents
when a JSP is being removed from use by a container.
• The jspDestroy() method is the JSP equivalent of the
destroy method for servlets. Override jspDestroy when
you need to perform any cleanup, such as releasing
database connections or closing open files.
• The jspDestroy() method has the following form:
public void jspDestroy()
{
// Your cleanup code goes here.
}

19. JSP Components
• There are three main types of JSP constructs that you
embed in a page.
– Scripting elements
• You can specify Java code
• Expressions, Scriptlets, Declarations
– Directives
• Let you control the overall structure of the servlet
• Page, include, Tag library
– Actions
• Enable the use of server side Javabeans
• Transfer control between pages

20. Types of Scripting Elements
• You can insert code into the servlet that will be
generated from the JSP page.
• Expressions: <%= expression %>
– Evaluated and inserted into the servlet’s output. i.e.,
results in something like out.println(expression)
• Scriptlets: <% code %>
– Inserted verbatim into the servlet’s _jspService method
(called by service)
• Declarations: <%! code %>
– Inserted verbatim into the body of the servlet class,
outside of any existing methods

21. Scriptlets
• A scriptlet can contain any number of JAVA
language statements, variable or method
declarations, or expressions that are valid in
the page scripting language.
Syntax
<% statement; %>

22. Expression
• We can use the output stream of the response
in the expression tag.
• We do not need the out variable in the
expression tag.
• It is mainly used to print the values of a
varaibale or method
Syntax
<%= %>

23. Declaration tag
• We can use the declaration tag to declare the
fields and methods
• The code declare inside the decleration
display the outside service method of
generated by servlet
Syntax
<%! Statement %>

24. JSP Implicit Objects
• JSP Implicit Objects are the Java objects that the JSP
Container makes available to developers in each page and
developer can call them directly without being explicitly
declared.
• JSP Implicit Objects are also called pre-defined variables.
• JSP supports nine Implicit Objects which are listed below:

25. Object Description
Request This is the HttpServletRequest object associated with the request.
response
This is the HttpServletResponse object associated with the response to the
client.
out This is the PrintWriter object used to send output to the client.
session This is the HttpSession object associated with the request.
application This is the ServletContext object associated with application context.
config This is the ServletConfig object associated with the page.
pageContext
This encapsulates use of server-specific features like higher performance
JspWriters.
page
This is simply a synonym for this, and is used to call the methods defined
by the translated servlet class.
Exception
The Exception object allows the exception data to be accessed by
designated JSP.

26. The request Object:
• The request object is an instance of a
javax.servlet.http.HttpServletRequest object.
Each time a client requests a page the JSP
engine creates a new object to represent that
request.
• The request object provides methods to get
HTTP header information including form data,
cookies, HTTP methods etc.

27. Example of JSP request implicit object
index.html
<form action="welcome.jsp">
<input type="text" name="uname">
<input type="submit" value="go"><br/>
</form>
welcome.jsp
<%
String name=request.getParameter("una
me");
out.print("welcome "+name);
%>

29. The response Object:
• The response object is an instance of a
javax.servlet.http.HttpServletResponse object.
Just as the server creates the request object, it
also creates an object to represent the response
to the client.
• The response object also defines the interfaces
that deal with creating new HTTP headers.
Through this object the JSP programmer can add
new cookies or date stamps, HTTP status codes
etc.

30. index.html
<form action="welcome.jsp">
<input type="text" name="uname">
<input type="submit" value="go"><br/>
</form>
welcome.jsp
<%
response.sendRedirect("http://www.google.com");
%>

32. The out Object:
• The out implicit object is an instance of a
javax.servlet.jsp.JspWriter object and is used to send content
in a response.
• The initial JspWriter object is instantiated differently
depending on whether the page is buffered or not. Buffering
can be easily turned off by using the buffered='false' attribute
of the page directive.
• The JspWriter object contains most of the same methods as
the java.io.PrintWriter class. However, JspWriter has some
additional methods designed to deal with buffering. Unlike
the PrintWriter object, JspWriter throws IOExceptions.

33. The session & application Object:
• The session object is an instance of
javax.servlet.http.HttpSession and behaves exactly the same way
that session objects behave under Java Servlets.
• The session object is used to track client session between client
requests.
• The application object is direct wrapper around the
ServletContext object for the generated Servlet and in reality an
instance of a javax.servlet.ServletContext object.
• This object is a representation of the JSP page through its entire
lifecycle. This object is created when the JSP page is initialized
and will be removed when the JSP page is removed by the
jspDestroy() method.
• By adding an attribute to application, you can ensure that all JSP
files that make up your web application have access to it.

34. Example of session implicit object
index.html
<html>
<body>
<form action="welcome.jsp">
<input type="text" name="uname">
<input type="submit" value="go"><br/>
</form>
</body>
</html>
welcome.jsp
<html>
<body>
<%
String name=request.getParameter("uname");
out.print("Welcome "+name);
session.setAttribute("user",name);
<a href="second.jsp">second jsp page</a>
%>
</body>
</html>

35. second.jsp
<html>
<body>
<%
String name=(String)session.getAttribute("user");
out.print("Hello "+name);
%>
</body>
</html>

37. Example of application implicit object:
index.html
<form action="welcome">
<input type="text" name="uname">
<input type="submit" value="go"><br/>
</form>
welcome.jsp
<%
out.print("Welcome "+request.getParameter("uname"));
String driver=application.getInitParameter("dname");
out.print("driver name is="+driver);
%>

38. web.xml file
<web-app>
<servlet>
<servlet-name>sonoojaiswal</servlet-name>
<jsp-file>/welcome.jsp</jsp-file>
</servlet>
<servlet-mapping>
<servlet-name>sonoojaiswal</servlet-name>
<url-pattern>/welcome</url-pattern>
</servlet-mapping>
<context-param>
<param-name>dname</param-name>
<param-value>sun.jdbc.odbc.JdbcOdbcDriver</param-value>
</context-param>
</web-app>

40. The config Object:
• The config object is an instantiation of
javax.servlet.ServletConfig and is a direct wrapper around the
ServletConfig object for the generated servlet.
• This object allows the JSP programmer access to the Servlet or
JSP engine initialization parameters such as the paths or file
locations etc.
• The following config method is the only one you might ever
use, and its usage is trivial:
config.getServletName();
• This returns the servlet name, which is the string contained in
the <servlet-name> element defined in the WEB-INFweb.xml
file

41. The pageContext Object:
• The pageContext object is an instance of a javax.servlet.jsp.PageContext object.
The pageContext object is used to represent the entire JSP page.
• This object is intended as a means to access information about the page while
avoiding most of the implementation details.
• This object stores references to the request and response objects for each request.
The application, config, session, and out objects are derived by accessing
attributes of this object.
• The pageContext object also contains information about the directives issued to
the JSP page, including the buffering information, the errorPageURL, and page
scope.
• The PageContext class defines several fields, including PAGE_SCOPE,
REQUEST_SCOPE, SESSION_SCOPE, and APPLICATION_SCOPE, which identify the
four scopes. It also supports more than 40 methods, about half of which are
inherited from the javax.servlet.jsp. JspContext class.
• One of the important methods is removeAttribute, which accepts either one or
two arguments. For example, pageContext.removeAttribute ("attrName") removes
the attribute from all scopes, while the following code only removes it from the
page scope:
pageContext.removeAttribute("attrName", PAGE_SCOPE);

42. index.html
<html>
<body>
<form action="welcome.jsp">
<input type="text" name="uname">
<input type="submit" value="go"><br/>
</form>
</body>
</html>
welcome.jsp
<html>
<body>
<%
String name=request.getParameter("uname");
out.print("Welcome "+name);
pageContext.setAttribute("user",name,PageContext.SESSION_SCOPE);
<a href="second.jsp">second jsp page</a>
%>
</body>
</html>

43. second.jsp
<html>
<body>
<%
String name=(String)pageContext.getAttribute("user",PageContext
.SESSION_SCOPE);
out.print("Hello "+name);
%>
</body>
</html>

45. The page & exception Object:
• The page object is an actual reference to the
instance of the page. It can be thought of as
an object that represents the entire JSP page.
• The page object is really a direct synonym for
the this object.
• The exception object is a wrapper containing
the exception thrown from the previous page.
It is typically used to generate an appropriate
response to the error condition.

46. Directive elements
• The program tells the web conatiner how to
translate the page in a response side.
Syntax
<%@ directive attribute=“value”%>
Types
– Page directive
– Include directive
– Tag library directive

47. Page directive
• In this directive we can translate a jsp page by
implements the various types of attribute in a
page directive
Syntax
<%@ page attribute =“value”%>

48. Attributes in page directive
• Import
• Info
• ContentType
• ErrorPage
• isErrorPage
• Buffer

49. Include directive
• This attribute can use to include the conten it
may be either html,css,jsp or servlet
Syntax
<%@ include file="resourceName" %>

50. Tag library directive
• The JSP taglib directive is used to define a tag
library that defines many tags. We use the TLD
(Tag Library Descriptor) file to define the tags. In
the custom tag section we will use this tag so it
will be better to learn it in custom tag.
Syntax
<%@ taglib uri="uriofthetaglibrary" prefix="prefix
oftaglibrary" %>

51. Action tag
• There are many JSP action tags or elements.
Each JSP action tag is used to perform some
specific tasks.
• The action tags are used to control the flow
between pages and to use Java Bean. The Jsp
action tags are given below.

52. JSP Action Tags Description
jsp:forward forwards the request and response to another
resource.
jsp:include includes another resource.
jsp:useBean creates or locates bean object.
jsp:setProperty sets the value of property in bean object.
jsp:getProperty prints the value of property of the bean.
jsp:plugin embeds another components such as applet.
jsp:param sets the parameter value. It is used in
forward and include mostly.
jsp:fallback can be used to print the message if plugin is
working. It is used in jsp:plugin.

53. Java bean
• It should have a no-arg constructor.It
should be Serialivzable.It should provide
methods to set and get the values of the
properties, known as getter and setter
method
Syntax
<jsp: useBean id=“obj”
class=“packagename.classname”>

54. J2EE
• J2EE means java 2 enterprise edition .
• It is used for multitype web application
• Like servlet,jsp,ejb.

55. Some of the key features and services of J2EE:
At the client tier, J2EE supports pure HTML, as well as
Javaapplets or applications. It relies on Java Server
Pages and servletcode to create HTML or other formatted data for
the client.
Enterprise JavaBeans (EJBs) provide another layer where the
platform's logic is stored. An EJB server provides functions such as
threading, concurrency, security and memory management. These
services are transparent to the author.
Java Database Connectivity (JDBC), which is the Java equivalent
to ODBC, is the standard interface for Java databases.
The Java servlet API enhances consistency for developers without
requiring a graphical user interface.

56. J2EE CONTAINER
• EJB
• WEB CONTAINER
• APPLET CONTAINER
• APPLICATION CLIENT CONTAINER

57. COOKIES
• Cookies are text files stored on the client computer and they
are kept for various information tracking purpose. JSP
transparently supports HTTP cookies using underlying servlet
technology.
There are three steps involved in identifying returning users:
• Server script sends a set of cookies to the browser. For
example name, age, or identification number etc.
• Browser stores this information on local machine for future
use.
• When next time browser sends any request to web server
then it sends those cookies information to the server and
server uses that information to identify the user or may be for
some other purpose as well.

58. Difference between session and cookie
• Sessions are server-side files that contain user information,
while Cookies are client-side files that contain user
information. Sessions have a unique identifier that maps them
to specific users. This identifier can be passed in the URL or
saved into a session cookie.
• Most modern sites use the second approach, saving the
identifier in a Cookie instead of passing it in a URL (which
poses a security risk). You are probably using this approach
without knowing it, and by deleting the cookies you
effectively erase their matching sessions as you remove the
unique session identifier contained in the cookies.