Writing Enterprise Applications with J2EE (First lesson)

1
WritingEnterprise Applications with J2EE(First
lesson)

• Alessio Bechini
• June 2002
• (based on material by Monica Pawlan)

2
A Simple Session Bean

• Example Thin-Client Multitiered Application
• Path and ClassPath Settings
• J2EE Application Components
• Create the HTML Page
• Create the Servlet
• Create the Session Bean
• Compile the Session Bean and Servlet

• Start the J2EE Application Server
• Start the Deploy Tool
• Deploy Tool
• Assemble the J2EE Application
• Verify and Deploy the J2EE Application
• Run the J2EE Application
• Updating Component Code

3
Thin-Client Multitiered Application
4
J2EE Download Contents

• The typical download has the J2EE application
  server, Cloudscape database, a Web server using
  secure socket layer (SSL) also known as HTTP over
  HTTPS, development and deployment tools, and the
  Java APIs for the Enterprise.

5
PATH and CLASSPATH

• Path Settings
• Unix
• ../J2EE/jdk1.2.2/bin
• ../J2EE/j2sdkee1.2.1/bin
• Windows replace / with \
• Class Path Settings
• Unix
• ../J2EE/j2sdkee1.2.1/lib/j2ee.jar
• Windows replace / with \

6
J2EE Appl. Components

• The J2EE specification defines the following
  application components
• Application client components
• Enterprise JavaBeans components
• Servlets and JavaServer Pages components (also
  called Web components)
• Applets

7
Interacting Components

• The session bean executes in the J2EE
  application server.

• Data flows between the browser and the session
  bean.

8
HTML Code

• ltHTMLgt
• ltBODY BGCOLOR "WHITE"gt
• ltBLOCKQUOTEgt
• ltH3gtBonus Calculationlt/H3gt
• ltFORM METHOD"GET"
• ACTION"BonusAlias"gt
• ltPgt
• Enter social security Number
• ltPgt
• ltINPUT TYPE"TEXT" NAME"SOCSEC"gtlt/INPUTgt
• ltPgt

• Enter Multiplier
• ltPgt
• ltINPUT TYPE"TEXT" NAME"MULTIPLIER"gtlt/INPUTgt
• ltPgt
• ltINPUT TYPE"SUBMIT" VALUE"Submit"gt
• ltINPUT TYPE"RESET"gt
• lt/FORMgt
• lt/BLOCKQUOTEgt
• lt/BODYgt
• lt/HTMLgt

9
Servlet Duties

• At run time, the servlet code does the following
• Retrieves the user data
• Looks up the session bean
• Passes the data to the session bean
• Upon receiving a value back from the session
  bean, creates an HTML page to display the
  returned value to the user.

10
Servlet Code (I)

• import javax.servlet.
• import javax.servlet.http.
• import java.io.
• import javax.naming.
• import javax.rmi.PortableRemoteObject
• import Beans.
• public class BonusServlet extends HttpServlet
• CalcHome homecalc
• public void init(ServletConfig config) throws
  ServletException
• //Look up home interface
• try
• InitialContext ctx new InitialContext()
• Object objrefctx.lookup("calcs")
• homecalc (CalcHome)PortableRemoteObject.na
  rrow(objref,CalcHome.class)
• catch (Exception NamingException)
• NamingException.printStackTrace()

11
Servlet Code (II)

• public void doGet (
• HttpServletRequest request, HttpServletResponse
  response)
• throws ServletException, IOException
• String socsec null
• int multiplier 0 double calc 0.0
• PrintWriter out
• response.setContentType("text/html")
• String title "EJB Example"
• out response.getWriter()
• out.println("ltHTMLgtltHEADgtltTITLEgt")
• out.println(title)
• out.println("lt/TITLEgtlt/HEADgtltBODYgt")
• try
• Calc theCalculation
• //Get Multiplier and Soc.Sec. Info
• String strMultrequest.getParameter("MULTIPLIE
  R")
• Integer integerMult new Integer(strMult)
• multiplier integerMult.intValue()
• socsec request.getParameter("SOCSEC")

12
Servlet Code (III)

• //cont. for public void doGet (
• //Display Data
• out.println("ltH1gtBonus Calculationlt/H1gt")
• out.println("ltPgtSoc Sec " socsec "ltPgt")
• out.println("ltPgtMultiplier " multiplier
  "ltPgt")
• out.println("ltPgtBonus Amount " calc
  "ltPgt")
• out.println("lt/BODYgtlt/HTMLgt")
• out.close()
• public void destroy()
• System.out.println("Destroy")

13
Interfaces of a EJBean

• This picture shows how the servlet and session
  bean application components work as a complete
  J2EE application once they are assembled and
  deployed.
• The container is the interface between the
  session bean and the low-level platform-specific
  functionality that supports the session bean.
  The container is created during deployment.

14
Creating a session bean

• A session bean represents a transient
  conversation with a client. If the server or
  client crashes, the session bean and its data
  are gone.
• In contrast, entity beans are persistent and
  represent data in a database. If the server or
  client crashes, the underlying services ensure
  the entity bean data is saved.
• Because the enterprise bean performs a simple
  calculation at the request of BonusServlet, and
  the calculation can be reinitiated in the event
  of a crash, it makes sense to use a session bean
  in the current example.

15
CalcHome

• BonusServlet does not work directly with the
  session bean, but creates an instance of its
  home interface.
• The home interface extends EJBHome and has a
  create method for creating the session bean in
  its container.
• CreateException is thrown if the session bean
  cannot be created, and RemoteException is thrown
  if a communications-related exception occurs
  during the execution of a remote method.

• package Beans
• import java.rmi.RemoteException
• import javax.ejb.CreateException
• import javax.ejb.EJBHome
• public interface CalcHome extends EJBHome
• Calc create() throws CreateException,
  RemoteException

16
Calc

• When the home interface is created, the J2EE
  application server creates the remote interface
  and session bean.
• The remote interface extends EJBObject and
  declares the calcBonus method for calculating
  the bonus value.
• This method is required to throw
  javax.rmi.RemoteException, and is implemented by
  the CalcBean class.

• package Beans
• import javax.ejb.EJBObject
• import java.rmi.RemoteException
• public interface Calc extends EJBObject
• public double calcBonus(int multiplier, double
  bonus)
• throws RemoteException

17
CalcBean

• The session bean class implements the SessionBean
  interface and provides behavior for the calcBonus
  method.
• The setSessionContext and ejbCreate methods are
  called in that order by the container after
  BonusServlet calls the create method in CalcHome.

• package Beans
• import java.rmi.RemoteException
• import javax.ejb.SessionBean
• import javax.ejb.SessionContext
• public class CalcBean implements SessionBean
• public double calcBonus(int multiplier, double
  bonus)
• double calc (multiplierbonus)
• return calc
• //These methods are not described here
• public void ejbCreate()
• public void setSessionContext(SessionContext
  ctx)
• public void ejbRemove()
• public void ejbActivate()
• public void ejbPassivate()
• public void ejbLoad()
• public void ejbStore()

18
Compiling Instructions

• Session Bean
• Unix
• !/bin/sh
• cd ../J2EE
• J2EE_HOME../J2EE/j2sdkee1.3.1
• CPATH.J2EE_HOME/lib/j2ee.jar
• javac -d . -classpath "CPATH" Beans/CalcBean.java
  Beans/CalcHome.java Beans/Calc.java
• Windows
• cd \home\monicap\J2EE
• Set J2EE_HOME..\J2EE\j2sdkee1.3.1
• set CPATH.J2EE_HOME\lib\j2ee.jar
• javac -d . -classpath CPATH Beans/CalcBean.java
  Beans/CalcHome.java Beans/Calc.java

• Servlet
• Unix
• .. javac -d . -classpath "CPATH"
  BonusServlet.java
• Windows
• .. javac -d . -classpath "CPATH"
  BonusServlet.java

19
J2EE Application Server Deploy Tool

• You need to start the J2EE application server to
  deploy and run the example.
• type j2ee -verbose
• Note Sometimes the J2EE server will not start if
  Outlook is running.
• To assemble and deploy the J2EE application, you
  have to start the deploy tool.
• type deploytool
• Note If a memory access error is encountered
  when starting deploytool, add an environment
  variable called JAVA_FONTS and set the path to c
  \ltfont directorygt, e.g. c\winnt\fonts.

20
The Deploy Tool GUI
21
Assemble the J2EE Application

• Assembling a J2EE application involves creating
  a new application, and adding the application
  components to it, according to the following
  steps
• Create a new J2EE application
  (BonusApp.ear).
• Create a new enterprise bean
  (CalcBean.jar).
• Create a new web component
  (Bonus.war).
• Specify JNDI name for the enterprise bean
  (calcs).
• Specify the Root Context for the J2EE application
  
  (BonusRoot).

22
Create J2EE Application

• J2EE components are assembled into J2EE
  application Enterprise Archive (EAR) files.
• From File menu Select New Application.

• New Application dialog box
• Fill the data about the application file name
  (BonusApp.ear) and the application display name
  (BonusApp), specifying the ditectory where you
  want to place the application EAR file.
• The GUI looks as shown.

23
Create Session Bean (I)

• Enterprise beans (entity and session beans) are
  bundled into a Java Archive (JAR) file.

• File menu Select New Enterprise Bean. The New
  Enterprise Bean Wizard starts and displays an
  Introduction dialog box.Click Next.
• EJB JAR dialog box Specify the jar display name
  (CalcJar, within BonusApp), and possibly other
  ancillary info.
• Add Files to Contents dialog box
• Calc.class, CalcHome.class,
• CalcBean.class.
• The GUI looks as shown.
• Go to the next step

24
Create Session Bean (II)

• In this step, make sure the following information
  is selected
• classname CalcBean
• Home interface Beans.CalcHome
• Remote interface Calc
• Bean type Session and Stateless
• Specify the display name (the name that appears
  when when the JAR file is added toBonusApp in the
  Local Applications window)
• Description e.g., This JAR file contains the
  CalcBean session bean.
• No further info is needed for the bean..

25
Creation of the Session Bean

• Once the session bean has been created, the GUI
  looks as shown.

26
Create Web Component (I)

• Web components (servlets, or JSP technology) are
  bundled into a WAR file.

• File menu Select New Web Component. The New
  Web Component Wizard starts.
• Provide the name to be displayed for the WAR, and
  then add contents
• First, bonus.html
• And then the servlet class,BonusServlet.class
• The GUI looks as shown.
• Go to the next step.

27
Create Web Component (II)

• At the next step of the wizard, select the
  BonusServlet as a servlet component.
• Now, the GUI looks as shown.

28
Component Aliases

• At the component aliases step of the wizard,
  type BonusAlias. This is the same alias name
  you put in the ACTION field of the HTML form
  embedded in the bonus.html file.
• Now, the GUI looks as shown.

29
Componentss Deployment Summary
30
Specify JNDI Name

• Before you can deploy the BonusApp application
  and its components, you have to specify the JNDI
  name BonusServlet uses to look up the CalcBean
  session bean.

31
Specify Root Context
32
Verify Specification Compliance
33
Deploy the J2EE Appl.
34
Run the J2EE Appl.

• The web server runs on port 8000 by default. To
  open the bonus.html page point your browser to
• http//localhost8000/BonusRoot/bonus.html
• which is where the Deploy tool put the HTML file.