Servlets, JSP and JavaBeans

subduedjourneyΛογισμικό & κατασκευή λογ/κού

28 Οκτ 2013 (πριν από 4 χρόνια και 10 μέρες)

82 εμφανίσεις

Servlets, JSP and JavaBeans

Joshua Scotton


Getting Started


Servlets


JSP


JavaBeans


MVC


Conclusion


Install JDK 5.0


http://www.oracle.com/techn
etwork
/java/
javase
/downloads/index
-
jdk5
-
jsp
-
142662.html


Install Tomcat 6.0


http://tomcat.apache.org/download
-
60.cgi



Install Eclipse EE IDE


http://www.eclipse.org/downloads/packages/eclip
se
-
ide
-
java
-
ee
-
developers/heliossr1


Handling Client Requests


Servlets are modules of Java code that run in
a server application


Servlets handle client requests


Although not exclusively, most
servlets

are
used to answer HTTP requests and hence
extend the javax.servlet.http.HttpServlet class

1.
Server Application loads the
Servlet

and creates
an instance by calling the null constructor.

2.
Servlet’s

init(
ServletConfig

config
) method is
called.
HttpServlet’s

should call
super.init
(
config
) if overriding.

3.
Once initialized, service(
ServletRequest

req
,
ServletResponse

res) is called concurrently for
every request.

4.
When the
servlet

is unloaded, the destroy()
method is called. This may be run concurrently
with service so must be thread
-
safe.

import java.io.*;

import
javax.servlet
.*;

import
javax.servlet.http
.*;

public class
HelloWorldServlet

extends
HttpServlet

{



protected void
doGet
(
HttpServletRequest

req
,


HttpServletResponse

res) throws
ServletException
,
IOException

{



res.setContentType
("text/html");


PrintWriter

out =
res.getWriter
();


out.println
("<HTML><HEAD><TITLE>Hello World!" +


"</TITLE></HEAD><BODY>Hello World!" +


"</BODY></HTML>");


out.close
();



}

}


Request data is sent to the
servlet

in an
HttpServletRequest

object


To access a parameter use the
getParameter

method. For example:

String email =
req.getParameter
(“email”);


If you are not going to be sure of which request type
you are going to be handling, or if you want to handle
both in the same manner. You can forward one to the
other as shown below:

protected void
doGet
(
HttpServletRequest

req
,


HttpServletResponse

res) throws


ServletException
,
IOException

{


doPost
(
req,res
);

}

protected void
doPost
(
HttpServletRequest

req
,


HttpServletResponse

res) throws


ServletException
,
IOException

{


//response code goes here...

}

J a v a S e r v e r

P a g e s


JSP =
JavaServer

Pages


Puts Java inside a

HTML page


JSP files are recognised by the extension .
jsp


JSP’s are compiled on the first time that they
are loaded


Needs a JSP

supporting web server like
Tomcat
,

Glassfish

and
Blazix

etc

<HTML>

<BODY>

Hello World!

<
br

/>

The time is: <%= new
java.util.Date
() %>

</BODY>

</HTML>

<HTML>

<BODY>

<%

//
System.out

prints to the server log

System.out.println
( “Getting the Date" );



java.util.Date

date = new
java.util.Date
();

%>

The time is: <%

//The out object prints to the response

out.println
(
date.toString
());

%>

</BODY>

</HTML>


The
HttpServletRequest

can be accessed by
JSP as shown in the following example:


out.println
( “Your machine's address is: " );



out.println
(
request.getRemoteHost
());


session.setAttribute
( “user", username );


<%=
session.getAttribute
( “user" ) %>


Page Directive: importing packages

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

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



Include Directive: including other JSP’s inline

<%@ include file="hello.jsp" %>


A JSP is turned into a class definition.


To add variables and method declarations to the
class you use a JSP declaration using <%! and %>
tags as shown in the following example:

<%!


Date
theDate

= new Date();


Date
getDate
()


{


System.out.println
(“Returning the Date...”);


return
theDate
;


}

%>

The time is now <%=
getDate
() %>


${1 > (4/2)}

returns false


${3 div 4} or ${3 / 4}
return 0.75


${
pageContext.request.contextPath
}
returns the context path


${
sessionScope.cart.numberOfItems
}
gets
the property “
numberOfItems
” from the session
scoped bean “cart”


${
param
['
mycom.productId
']}
returns the
mycom.productId

parameter from the request


${header["host"]}
returns the host value from
the page header


pageScope
: Maps page
-
scoped variable names to their values


requestScope
: Maps request
-
scoped variable names to their
values


sessionScope
: Maps session
-
scoped variable names to their
values


applicationScope
: Maps application
-
scoped variable names to
their values


pageScope
: Maps page
-
scoped variable names to their values


requestScope
: Maps request
-
scoped variable names to their
values


sessionScope
: Maps session
-
scoped variable names to their
values


applicationScope
: Maps application
-
scoped variable names to
their values


Busi ness Logi c Bl ocks


Java Class


Implements
java.io.Serialiazable

interface


Has a
nullary

constructor


Provides getter and setter methods for
accessing it’s properties

package
webdev.examples
;


public class
UserInfo

implements java.io.Serializable {

private String name;

private Integer age;

public String
getName
() { return name;
}

public void
setName
(String name) { this.name = name;
}

public Integer
getAge
() { return age;
}

public void
setAge
(Integer age) {
this.age

= age;
}

}



<
jsp:useBean
>


<
jsp:setProperty
>


<
jsp:getProperty
>

<
jsp:useBean


id="object
-
name"

scope="page | request | session | application"

type="type
-
of
-
object"

class="fully
-
qualified
-
classname
"

beanName
="fully
-
qualified
-
beanName
"

/>


Example:

<
jsp:useBean

id=
"user"
class="
webdev.examples.UserInfo
" scope="session"/>



page



Default scope, the
JavaBean

is created
and destroyed every time a page is loaded.


request



The created object is bound to the
request object.


session



The bean is bound to the session
object, which means that this will be unique to
the user.


application



An object bound to the
application will stay as long as the application is
loaded. Can be used for counting page views.

<
jsp:setProperty


name="id
-
of
-
the
-
JavaBean
"

property="name
-
of
-
property"

param
="request
-
parameter"

value="new
-
value
-
of
-
this
-
property"

/>


Example:

<
jsp:setProperty

name=
"user"
property="password" />

<
jsp:setProperty

name=
"user"
property="password"
param
="pass" />

<
jsp:setProperty

name=
"user"
property="password" value="
secretPassword
" />




<
jsp:getProperty


name="name
-
of
-
the
-
object"

property="name
-
of
-
property"

/>


Example:

<
jsp:getProperty

name="user"
property="password" />


<form method=
"post"
action="saveDetails.jsp">

Enter your name: <input type=
"text"
name="name" size=50 /><
br

/>

Enter your age: <input type=
"text"
name="age" size=3 /><
br

/>

<input type=
"submit" />

<
jsp:useBean

id=
"user"
class="
webdev.examples.UserInfo
"
scope="session"/>

<
jsp:setProperty

name=
"user"
property="*"/>

<
jsp:useBean

id=
"user"
class="
webdev.examples.UserInfo
"
scope="session"/>

Hello <%=
user.getName
() %>, you are
<%=
user.getAge
() %> years old.

Model, Vi ew, Cont r ol l er


Model


View


Controller


The Model represents the business logic of
the application


Encapsulating business rules into
components:


Facilitates testing


Improves quality


Promotes reuse


The model can be partitioned into State and
Action components


Define the current set of values in the Model
and includes methods to update these values.


Should be protocol independent.


JavaBeans are a logical choice for
implementing State Components.



Define allowable changes to the State in
response to events


In simpler systems this function may be
absorbed into the Controller, however this is
not generally recommended.


Represents the presentation logic of the
application.


Retrieves the State from the Model and
provides the user interface for the specific
protocol.


Separating the View from the Model enables
the independent construction of user
interfaces with different look and feels.


JSPs are a good choice for implementing the
View.


Provides the glue to MVC


In a MVC system the Controller must handle
the following tasks:


Security


Event Identification


Prepare the Model


Process the Event


Handle Errors


Trigger the Response


Servlets are an ideal choice for the Controller



You can use just JSP to create a web
application


This makes it hard to separate out the web
design and the business code


Using JSP just for the View and Servlets for
the Controller can simplify the development
process


Search Example:

ArrayList

searchResultsList

= // get from the query

RequestDispatcher

disp
;

disp

=
getServletContext
().
getRequestDispatcher
("searchresults.jsp");

request.setAttribute
("
my.search.results
",
searchResultsList
);

disp.forward
(request, response);


searchResultsList

is populated from a query handled by the
servlet


searchresults.jsp is selected as the handler for the response


We add the search result array to the request so that it is
accessible to the JSP


The JSP can retrieve the result set using this
code:

ArrayList

myList

= (
ArrayList
)
request.getAttribute
("
my.search.results
");


You can then use a for loop to print the
contents of the search request.

http://www.java
-
samples.com/showtutorial.php?tutorialid=552

package
webdev.examples.address
;


public class Person
implements
java.io.Serializable

{

private String name;

private
int

age;

private Address
address
;


public Person() {


setName
("A N Other");


setAge
(21);


this.address

= new Address();

}


public void
setName
(String name) { this.name = name; }

public String
getName
() { return name; }

public void
setAge
(
int

age) {
this.age

= age; }

public
int

getAge
() { return age; }

public void
setAddress
(Address
address
) {
this.address

=
address; }

public Address
getAddress
() { return address; }

}

package
webdev.examples.address
;

import
java.util.Collection
;

public class Address
implements
java.io.Serializable

{

private String line1;

private String town;

private String county;

private String postcode;

private Collection
phoneNumbers
;


public Address() {


this.line1 = "line1";


this.town

= "a town2";


this.county

= "a county";


this.postcode

= "postcode";

}

public void setLine1(String line1) { this.line1 = line1; }

public String getLine1() { return line1; }



public Collection
getPhoneNumbers
() { return
phoneNumbers
; }

public void
setPhoneNumbers
(Collection
phoneNumbers
) {


this.phoneNumbers

=
phoneNumbers
;


}

}

package
webdev.examples.address
;


public class
PhoneNumber

implements
java.io.Serializable

{


private String std;


private String number;



public String
getNumber
() { return number; }


public String
getStd
() { return std; }


public void
setNumber
(String number) {


this.number

= number; }

public void
setStd
(String std) {


this.std = std; }

}

package
webdev.examples.address
;

import
java.io.IOException
; import
java.util.ArrayList
; import
javax.servlet.RequestDispatcher
;

import
javax.servlet.ServletException
; import
javax.servlet.http.HttpServlet
;

import
javax.servlet.http.HttpServletRequest
; import
javax.servlet.http.HttpServletResponse
;


public class
handlerServlet

extends
HttpServlet

{

protected void
doGet
(
HttpServletRequest

req
,
HttpServletResponse

res) throws
ServletException,IOException



{

Person p = new Person();

p.setName
("Sam Dalton");

p.setAge
(26);

Address a = new Address();

a.setLine1("221b Baker Street");

a.setTown
("London");

a.setCounty
("Greater London");

a.setPostcode
("NW1 1AA");

ArrayList

al = new
ArrayList
();

PhoneNumber

ph = new
PhoneNumber
();

ph.setStd
("01895");

ph.setStd
("678901");

al.add
(ph);

ph = new
PhoneNumber
();

ph.setStd
("0208");

ph.setStd
("8654789");

al.add
(ph);

a.setPhoneNumbers
(al);

p.setAddress
(a);

req.setAttribute
("person", p);

RequestDispatcher

rd =
req.getRequestDispatcher
(“show.jsp");

rd.forward
(
req
, res);


}

}

req.setAttribute
("person", p);

RequestDispatcher

rd =
req.getRequestDispatcher
(“show.jsp");

rd.forward
(
req
, res);

<html>

<head>

<title>MVC Example</title>

</head>

<body>

<h2>MVC Example</h2>

<table border="1">

<
tr
>

<td>${person.name}</td>

<td>${
person.age
}</td>

<td>${person["address"].line1}</td>

<td>${person["address"].town}</td>

<td>${
person.address.phoneNumbers
[0].std}

${
person.address.phoneNumbers
[0].number}</td>

<td>${
person.address.phoneNumbers
[1].std}

${
person.address.phoneNumbers
[1].number}</td>

</
tr
>

</table>

</body>

</html>