CSC 224 Lecture Notes

• Enterprise JavaBeans (EJB) technology is part of a larger distributed framework-- the Java 2 Platform, Enterprise Edition (J2EE).
• Enterprise applications require system-level services, which the J2EE provides
  • transaction management
  • security
  • client connectivity
  • database access.
• Allows you to focus on the business logic in your applications, not the system-level plumbing.
• You code the business logic in enterprise beans, reusable components that can be accessed by client programs.
• Enterprise beans run on a J2EE server, which functions as a middle-tier server in a three-tier client/server system.

• Provide business services to clients.
  • a middle-tier server in an online shopping application might provide a variety of services: catalog lookup, order entry, and credit verification.
• Also provide system-level services:
  • Remote access to clients and back-office systems
  • Session and transaction management
  • Security enforcement
  • Resource pooling
• Because the middle-tier provides these services, the clients can be thin, simple, and rapidly developed.
• You can integrate new clients with existing applications and databases, protecting your investment in legacy systems.

• The J2EE Server
  • Naming and Directory - allows programs to locate services and components through the Java Naming and Directory Interface (JNDI) API
  • Authentication - enforces security by requiring users to log in
  • HTTP - enables Web browsers to access servlets and JavaServer Pages (JSP) files
  • EJB - allows clients to invoke methods on enterprise beans
• EJB Container
  • Transaction Management- The code required to control distributed transactions (method calls) can be quite complex.
  • Security- The container permits only authorized clients to invoke an enterprise bean's methods.
  • Remote Client Connectivity- The container manages the low-level communications between clients and enterprise beans.
  • Life Cycle Management-The container moves in and out of active states
  • Database Connection Pooling-The container manages a pool of database connections.
• Web Container
  • JSP and Servlets, we'll discuss soon...

Enterprise beans are server components written in the Java programming language.

• Enterprise beans DO contain the business logic for your application.
  • A checkbook client might invoke the debit and credit methods of an account enterprise bean.
• EJB'S do NOT!!
  • Managing or synchronizing threads
  • Accessing files or directories with the java.io package
  • Using AWT functionality to display information or to accept information from a keyboard
  • Listening on a socket, accepting connections on a socket, or using a socket for multicast
  • Setting a socket factory used by ServerSocket, Socket, or the stream handler factory used by the URL class
  • Loading a native library

There are two types of enterprise beans: session beans and entity beans.

• Every enterprise bean requires the following code:
  • Remote interface
  • Home interface
  • Enterprise bean class

import javax.ejb.EJBObject;
import java.rmi.RemoteException;

public interface Converter extends EJBObject {
 
   public double dollarToYen(double dollars) throws RemoteException;
   public double yenToEuro(double yen) throws RemoteException;
}

import java.io.Serializable;
import java.rmi.RemoteException;
import javax.ejb.CreateException;
import javax.ejb.EJBHome;

public interface ConverterHome extends EJBHome {

    Converter create() throws RemoteException, CreateException;
}

import java.rmi.RemoteException; 
import javax.ejb.SessionBean;
import javax.ejb.SessionContext;

public class ConverterEJB implements SessionBean {
 
   public double dollarToYen(double dollars) {

      return dollars * 121.6000;
   }

   public double yenToEuro(double yen) {

      return yen * 0.0077;
   }

   public ConverterEJB() {}
   public void ejbCreate() {}
   public void ejbRemove() {}
   public void ejbActivate() {}
   public void ejbPassivate() {}
   public void setSessionContext(SessionContext sc) {}
} 

• Servlets are programs that run on a Web server and build Web pages dynamically.
  • The Web page is based on data submitted by the user.
    • Results pages from search engines
    • E-Commerce, check DB for price, availability
  • The data changes frequently.
    • Weather-reports
    • News headlines
• Why is this better than CGI
  • Efficient; With traditional CGI, a new process is started for each HTTP request, java uses light weight threads
  • Much more powerful (talk directly to the server, maintain memory from client to client, talk to Java backend, DB pooling, etc.)
  • More portable, you needn't change the code from server to server

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD><TITLE>Welcome to Our Store</TITLE></HEAD>
<BODY>
<H1>Welcome to Our Store</H1>
<SMALL>Welcome,
<!-- User name is "New User" for first-time visitors --> 
<% out.println(Utils.getUserNameFromCookie(request)); %>
To access your account settings, click
<A HREF="Account-Settings.html">here.</A></SMALL>
<P>
Regular HTML for all the rest of the on-line store's Web page.
</BODY></HTML>

• vs. Active Server Pages (ASP). ASP is a similar technology from Microsoft. The advantages of JSP are twofold. First, the dynamic part is written in Java, not Visual Basic or other MS-specific language, so it is more powerful and easier to use. Second, it is portable to other operating systems and non-Microsoft Web servers.
• vs. Pure Servlets. JSP doesn't give you anything that you couldn't in principle do with a servlet. But it is more convenient to write (and to modify!) regular HTML than to have a zillion println statements that generate the HTML. Plus, by separating the look from the content you can put different people on different tasks: your Web page design experts can build the HTML, leaving places for your servlet programmers to insert the dynamic content.
• vs. Server-Side Includes (SSI). SSI is a widely-supported technology for including externally-defined pieces into a static Web page. JSP is better because it lets you use servlets instead of a separate program to generate that dynamic part. Besides, SSI is really only intended for simple inclusions, not for "real" programs that use form data, make database connections, and the like.
• vs. JavaScript. JavaScript can generate HTML dynamically on the client. This is a useful capability, but only handles situations where the dynamic information is based on the client's environment. With the exception of cookies, HTTP and form submission data is not available to JavaScript. And, since it runs on the client, JavaScript can't access server-side resources like databases, catalogs, pricing information, and the like.
• vs. Static HTML. Regular HTML, of course, cannot contain dynamic information. JSP is so easy and convenient that it is quite feasible to augment HTML pages that only benefit marginally by the insertion of small amounts of dynamic data. Previously, the cost of using dynamic data would preclude its use in all but the most valuable instances.

Here's a link to Sun's J2EE tutorial... SE452 and SE552 covers these subjects in detail

You can get a free application server here

I had a lot of fun and learned a lot, I hope you guys did too. If you see me around town stop me and say hello. Best... ~jgj