|
JSP
Questions
1. When a JSP page is compiled, what
is it turned into?
Answer (B): Compiled JSP pages are turned into
Servlets. See JSP Architecture for more information
on this translation phase.
2. Which of the following is not a
standard method called as part of the JSP life
cycle?
Answer (B): The standard service method for JSP
has an _ in its name. See JSP Architecture.
3. If you want to override a JSP file's initialization
method, within what type of tags must you declare
the method?
Answer (D): Declarations are placed within a set
of <%! %> tags. See Declarations.
4. Which of the following can not be used as the
scope when using a JavaBean with JSP?
Answer (D): Response is not a valid object scope
for JavaBeans (or anything else). See Object Scopes.
5. The implicit JSP objects like request, response,
and out are only visible in the _jspService()
method.
Answer: (A) Unless passed in as arguments to other
methods, the implicit JSP arguments are only visible
in the jspService() method. See JSP Implicit Objects.
6. What is the key difference between using a
<jsp:forward> and HttpServletResponse.sendRedirect()?
Answer (B): When you forward a request, the forwarding
is done within the server, and limited in scope
to where you can forward. Redirections are done
on the client and thus don't have these limitations.
7. Which of the following statements makes your
compiled JSP page implement the SingleThreadModel
interface?
Answer (A): If you flag the JSP page as not being
thread safe, it will implement the interface.
See Synchronization Issues.
8. Of the following four valid comment styles
that can be used within JSP pages, which can the
end user see?
Answer (B): Only the JavaScript comment can be
seen from the generated page. The other comments
will be buried in the source for the generated
servlet. See Comments.
9. How can a servlet call a JSP error page?
Answer (C): D will get the browser to display
the appropriate page, it just doesn't preserve
the state information requiring an unnecessary
round trip to the browser. C is the direct approach.
See Exception
10. When using a JavaBean to get all the parameters
from a form, what must the property be set to
(??? in the following code) for automatic initialization?
Answer (A): The * character is used for this.
See Using JavaBean Components.
Which web servers support JSP technology?
There are a number of JSP technology
implementations for different web servers. The
latest information on officially-announced support
can be found at http://java.sun.com/products/jsp/industry.html.
Is Sun providing a reference implementation
for the JSP specification?
The J2EE SDK is a reference implementation
of the JavaTM 2 Platform, Enterprise Edition.
Sun adapts and integrates the Tomcat JSP and Java
Servlet implementation into the J2EE SDK. The
J2EE SDK can be used as a development enviroment
for applications prior to their deployment and
distribution.
Tomcat a free, open-source implementation
of Java Servlet and JavaServer Pages technologies
developed under the Jakarta project at the Apache
Software Foundation, can be downloaded from http://jakarta.apache.org.
Tomcat is available for commercial use under the
ASF license from the Apache web site in both binary
and source versions. An implementation of JSP
technology is part of the J2EE SDK.
How is JSP technology different from
other products?
JSP technology is the result of industry
collaboration and is designed to be an open, industry-standard
method supporting numerous servers, browsers and
tools. JSP technology speeds development with
reusable components and tags, instead of relying
heavily on scripting within the page itself. All
JSP implementations support a Java programming
language-based scripting language, which provides
inherent scalability and support for complex operations.
Where do I get more information on
JSP technology?
The first place to check for information
on JSP technology is http://java.sun.com/products/jsp/.
This site includes numerous resources, as well
as pointers to mailing lists and discussion groups
for JSP technology-related topics.
What is a JSP page?
A JSP page is a page created by the
web developer that includes JSP technology-specific
and custom tags, in combination with other static
(HTML or XML) tags. A JSP page has the extension
.jsp or .jspx; this signals to the web server
that the JSP engine will process elements on this
page. Using the web.xml deployment descriptor,
additional extensions can be associated with the
JSP engine. The exact format of a JSP page is
described in the JSP specification.
How do JSP pages work?
A JSP engine interprets tags, and
generates the content required - for example,
by calling a bean, accessing a database with the
JDBC API or including a file. It then sends the
results back in the form of an HTML (or XML) page
to the browser. The logic that generates the content
is encapsulated in tags and beans processed on
the server.
Does JSP technology require the use of other Java
platform APIs?
JSP pages are typically compiled into
Java platform servlet classes. As a result, JSP
pages require a Java virtual machine that supports
the Java platform servlet specification.
How is a JSP page invoked and compiled?
Pages built using JSP technology are
typically implemented using a translation phase
that is performed once, the first time the page
is called. The page is compiled into a Java Servlet
class and remains in server memory, so subsequent
calls to the page have very fast response times.
What is the syntax for JavaServer
Pages technology?
The syntax card and reference can
be viewed or downloaded from our website.
Can I create XML pages using JSP technology?
Yes, the JSP specification does support
creation of XML documents. For simple XML generation,
the XML tags may be included as static template
portions of the JSP page. Dynamic generation of
XML tags occurs through bean components or custom
tags that generate XML output. See the white paper
Developing XML Solutions with JavaServer Pages
Technology (PDF) for details.
Can I generate and manipulate JSP
pages using XML tools?
The JSP 2.0 specification describes
a mapping between JSP pages and XML documents.
The mapping enables the creation and manipulation
of JSP pages using XML tools.
How do I use JavaBeans components (beans) from
a JSP page?
The JSP specification includes standard
tags for bean use and manipulation. The useBean
tag creates an instance of a specific JavaBeans
class. If the instance already exists, it is retrieved.
Otherwise, it is created. The setProperty and
getProperty tags let you manipulate properties
of the given object. These tags are described
in more detail in the JSP specification and tutorial.
This short quiz is based on JSP Professional:
Chapter 12, JSP Architecture. Test your knowledge
on the differences between servlets and JavaServer
Pages (JSP), factor forward-factor back, page-
centric versus the dispatcher approach, and more.
Then read the source code and see how this quiz
was developed.
1. Choose the statement that best
describes the relationship between JSP and servlets:
A. Servlets are built on JSP semantics and all
servlets are compiled to JSP pages for runtime
usage.
B. JSP and servlets are unrelated technologies.
C. Servlets and JSP are competing technologies
for handling web requests. Servlets are being
superseded by JSP, which is preferred. The two
technologies are not useful in combination.
D. JSPs are built on servlet semantics and all
JSPs are compiled to servlets for runtime usage.
2. What is a benefit of using JavaBeans
to separate business logic from presentation markup
within the JSP environment?
A. It allows the JSP to access middleware.
B. It creates a cleaner role separation between
the web-production team and the software development
team, so that the web-production team can focus
on presentation markup, while the software team
can focus on building reusable software components
for helping to generate dynamic displays.
C. It provides a dynamic markup environment, such
that JavaBeans are integrated seamlessly with
the template presentation content, in order to
create the dynamic display for the client.
D. It provides the developer with full access
to the Java 2 Platform Enterprise Edition (J2EE),
which is unavailable from outside the JavaBean
environment.
3. Why use RequestDispatcher to forward
a request to another resource, instead of using
a sendRedirect?
A. Redirects are no longer supported
in the current servlet API.
B. Redirects are not a cross-platform portable
mechanism.
C. The RequestDispatcher does not use the reflection
API.
D. The RequestDispatcher does not require a round
trip to the client, and thus is more efficient
and allows the server to maintain request state.
4. What alternatives exist to embedding
Java code directly within the HTML markup of your
JSP page?
A. Moving the code into your session
manager.
B. Moving the code into scriptlets.
C. Moving the code into JavaBeans and servlets.
D. Moving the code into a transaction manager.
5. What type of scriptlet code is
better-suited to being factored forward into a
servlet?
A. Code that deals with logic that
is common across requests.
B. Code that deals with logic that is vendor specific.
C. Code that deals with logic that relates to
database access.
D. Code that deals with logic that relates to
client scope.
6. Choose the statement that best
describes how to connect JSP pages and Enterprise
JavaBeans (EJBs):
A. Lookup the EJBs from within a JSP,
but use the EJBs from within a basic JavaBean.
B. Lookup and use the EJBs from a separate business
delegate. The JavaBeans that work with JSP pages
are clients to these business delegates and know
nothing about EJB specifics.
C. Lookup and use the EJBs from within a JSP page,
but only as remote references.
D. Lookup the EJBs from within a servlet, delegating
usage to specific JSP pages.
7. Are custom tags available in JSP
1.0? If not, how else might you implement iteration
from within a JSP?
A. Yes, but the only tags available
relate to database access.
B. No. To iterate over a collection of values,
one must use scriptlet code.
C. No, but there is a standard <iterate>
tag that may be used.
D. Yes, but custom tags will not help developers
create tags for use in iterating over a collection.
8. What is the initial contact point
for handling a web request in a Page-Centric architecture?
A. A JSP page.
B. A JavaBean.
C. A servlet.
D. A session manager.
9. What is the difference between
doing an include or a forward with a RequestDispatcher?
A. The forward method transfers control
to the designated resource, while the include
method invokes the designated resource, substitutes
its output dynamically in the display, and returns
control to the calling page.
B. The two methods provide the same functionality,
but with different levels of persistence.
C. The forward method is deprecated as of JSP
1.1 and the include method should be used in order
to substitute portions of a dynamic display at
runtime.
D. The include method transfers control to a dynamic
resource, while the forward method allows for
dynamic substitution of another JPS pages output,
returning control to the calling resource.
10. What line of code below might
be combined in the same JSP page with a validation
guard (for example, <% bean.validationGuard();
%> ), in order to create an alternate flow
of control for scenarios in which exceptions arise.
The validationGaurd method might throw an exception,
which should cause the flow of control to continue
in another user-defined page (assume JSP 1.0).
A. <jsp:error page="errorPage.jsp"
guard="true" />
B. <%@ page language="java" buffer="8k"
%>
C. <jsp:useBean id="bean" class="examples.Bean"
scope="request" />
D. <%@ page language="java" errorPage="errorPage.jsp"
buffer="8k" %>
1. Every JavaServer Pages (JSP) source
page is compiled into a servlet before it is executed
at runtime.
2. When large amounts of Java scriptlet code are
mixed with HTML markup within a JSP page, not
only do readability and reuse suffer, but often
bugs are introduced as web-production team members,
who may not be familiar with Java programming,
need to modify the accompanying markup. Additionally,
dependencies now exist among various teams competing
for the same file, making the development process
less efficient.
3. Doing an HTTP redirect requires
a round-trip to the client. If this is not required,
and the only desire is to forward the request
to another resource, then this can be much more
efficiently accomplished with the RequestDispatcher.
Additionally, when using the dispatcher the state
of the request object is maintained between resources,
which will not be the case with the HTTP redirect.
4. Business logic is better contained
in a JavaBean or a servlet that is owned by a
software developer. When lots of Java code is
embedded directly within the JSP page as scriptlets,
the "cut-and-paste" mentality tends
to prevail when it comes to code reuse.
5. Since the servlet is the initial
contact point for each request, it is well-suited
to handle logic that is common across multiple
requests. A good example of this type of logic
is an authentication check.
6. Using a business delegate reduces
coupling between the presentation and business
tiers. The presentation tier has no knowledge
of the EJB implementation details, such as Java
Naming and Directory InterfaceTM lookup.
7. Using Java scriptlets is the accepted method
of doing iteration in JSP 1.0. In JSPTM 1.1, a
custom tag may be used, which will hide the implementation
details of the iteration code.
8. The term Page-Centric is used to describe an
architecture where the initial contact point for
the request is a JSP page. An example is shown
visually below:
9. When the forward method is used, the invoking
resource does not regain control. Multiple include
invocations can be made from the same resource,
while the invoking resource maintains execution
control.
10. Error pages are invoked when there
is an uncaught exception from within a particular
page. In this case, we mention that the validationGaurd()
method might throw an exception. If this exception
is not caught within the page, then we vector
control to errorPage, as stipulated in the attribute
of the given page directive.
12. JSP Architecture. The first page
of the quiz consists of regular HTML with a form
that calls answer.jsp. Answer.jsp requests parameters
from the bean, in this case, called QuizResponses.
The page-view with bean approach for this quiz
required extra work to write the bean, and it
could have been done using the page-view approach
without a bean, requesting invocation directly
from the answer.jsp page. Deciding which approach
is preferable depends on the application and how
much HTML and Java scriptlets need to be used.
For this quiz we opted for the page-view with
bean approach for illustration purposes.
1. When a JSP page is compiled, what
is it turned into?
A. Applet
B. Servlet
C. Application
D. Mailet
2. Which of the following is not a standard method
called as part of the JSP life cycle?
A. jspInit()
B. jspService()
C. _jspService()
D. jspDestroy()
3. If you want to override a JSP file's
initialization method, within what type of tags
must you declare the method?
A. <@ @>
B. <%@ %>
C. <% %>
D. <%! %>
4. Which of the following can not
be used as the scope when using a JavaBean with
JSP?
A. application
B. session
C. request
D. response
E. page
5. The implicit JSP objects like request,
response, and out are only visible in the _jspService()
method.
A. True
B. False
6.What is the key difference between
using a <jsp:forward> and HttpServletResponse.sendRedirect()?
A. forward executes on the client while sendRedirect()
executes on the server.
B. forward executes on the server while sendRedirect()
executes on the client.
C. The two methods perform identically.
7. Which of the following statements
makes your compiled JSP page implement the SingleThreadModel
interface?
A. <%@ page isThreadSafe="false"
%>
B. <%@ page isThreadSafe="true" %>
8. Of the following four valid comment
styles that can be used within JSP pages, which
can the end user see?
A. <%-- My comments
<% out.println("Hello World"); %>
--%>
B. <!-- (c)2000 jGuru.com -->
C. <% // For Loop
for (int i=1; i<=4; i++) {
%>
<H<%=i%>>Hello</H<%=i%>>
<% } %>
D. <% /** yet another comment */
JavaDoc Rules
%>
9. How can a servlet call a JSP error
page?
A. This capability is not supported.
B. When the servlet throws the exception, it will
automatically be caught by the calling JSP page.
C. The servlet needs to forward the request to
the specific error page URL. The exception is
passed along as an attribute named "javax.servlet.jsp.jspException".
D. The servlet needs to redirect the response
to the specific error page, saving the exception
off in a cookie.
10. When using a JavaBean to get all
the parameters from a form, what must the property
be set to (??? in the following code) for automatic
initialization?
<jsp:useBean id="fBean"
class="govi.FormBean" scope="request"/>
<jsp:setProperty name="fBean" property="???"
/>
<jsp:forward page="/servlet/JSP2Servlet"
/>
A. *
B. all
C. @
D. =
// Import io package
import java.io.*;
// Import servlet packages
import javax.servlet.*;
import javax.servlet.http.*;
public class CookieCounter extends
HttpServlet
{
// GET request handler
public void doGet (HttpServletRequest request,
HttpServletResponse response) throws IOException
{
// Define content type
response.setContentType("text/html");
PrintStream pout = new PrintStream(response.getOutputStream());
// Check to see if there are any cookies
Cookie[] cookieArray = request.getCookies();
// Default value
int count = 0;
// Check for cookies
if (cookieArray != null)
{
for (int i =0; i< cookieArray.length; i++)
{
Cookie c = cookieArray[i];
// Check for the count cookie
if (c.getName().equals("count"))
{
// Parse cookie value and assign to count
try
{
Integer num = new Integer (c.getValue());
count = num.intValue();
}
catch (NumberFormatException nfe) {}
}
}
}
// Increment counter
count++;
// Send updated cookie
response.addCookie(new Cookie ("count",
String.valueOf(count)));
// Output message
pout.println ("You have visited this page
" + count +
" times since your web browser started");
pout.flush();
}
// POST request handler calls GET
request handler
public void doPost (HttpServletRequest request,
HttpServletResponse response) throws IOException
{
doGet(request,response);
}
}
|
