ADVANCED JAVA LECTURE I& II BY Dr rani reddy

1. Enterprise Java Beans
Dr M.Rani Reddy

2. Introduction
J2EE (Java2 Enterprise Edition) offers a
suite of software specification to design,
develop, assemble and deploy
enterprise applications.
It provides a distributed, component-
based, loosely coupled, reliable and
secure, platform independent and
responsive application environment.

3. J2EE Technologies
Enterprise Java Bean Technology 2.0
JDBC API 2.0
Java Servlet Technology 2.3
Java Server Pages Technology 1.2
Java Messaging Service 1.0
Java Naming and Directory Interface 1.2
Java Transaction API 1.0
Java Mail API 1.2
Javabeans activation framework 1.0
Java API for XML Processing 1.1
Java Connector Architecture 1.0
Java Authentication and Authorization Service 1.0
Tools: deploytool (scripts etc.)

4. Systems and Application
Integration
The J2EE APIs enable systems and
applications integration through the following:
 Unified application model across tiers with
enterprise beans
 Simplified response and request mechanism with
JSP pages and servlets
 Reliable security model with JAAS
 XML-based data interchange integration with JAXP
 Simplified interoperability with the J2EE Connector
Architecture
 Easy database connectivity with the JDBC API
 Enterprise application integration with message-
driven beans and JMS, JTA, and JNDI

5. J2EE Technology Architecture
Server
platform
JTS JMAPI JNDI JMS JDBC
JAXP JAAS …
Enterprise Java Beans Components
Java Server
pages
Servlets
Application clients Web clients
IIOP,
others
html

6. Enterprise Java Bean(EJB)
An enterprise bean is a server-side
component that contains the business logic of
an application. At runtime, the application
clients execute the business logic by invoking
the enterprise bean's methods.
Main goal of Enterprise Java Bean (EJB)
architecture is to free the application
developer from having to deal with the
system level aspects of an application. This
allows the bean developer to focus solely on
the logic of the application.

7. Roles in EJB Development
Bean developer: Develops bean component.
Application assembler: composes EJBs to form
applications
Deployer: deploys EJB applications within an
operation environment.
System administrator: Configures and administers the
EJB computing and networking infrastructure.
EJB Container Provider and EJB server provider:
Vendors specializing in low level services such as
transactions and application mgt.

8. Enterprise Java Bean (EJB)
Deployable unit of code.
At run-time, an enterprise bean resides in an
EJB container.
An EJB container provides the deployment
environment and runtime environment for
enterprise beans including services such as
security, transaction, deployment,
concurrency etc.
Process of installing an EJB in a container is
called EJB deployment.

9. Enterprise Application with
many EJBs
WebClient
ApplClient
EJB1
EJB2
EJB3
EJB4
EJB5
EJB6
Lets consider a shopping front application and figure out the
possible components (EJBs)

10. Deployment with Multiple EJB
Clients
Web
Container1
Deploys:
WebApp1
EJB
Container1
Deploys :
EJB1,EJB2,EJB3
Client
Container1
Deploys :
Client1
EJB
Container2
Deploys :
EJB4
Client
Container3
Deploys :
EJB5,EJB6

11. Business Entities, Processes
and Rules
EJB Applications organize business rules into
components.
Components typically represent a business
entity or business process.
Entity: is an object representing some
information maintained in the enterprise. Has
a “state” which may be persistent.
Example: Customer, Order, Employee,
Relationships are defined among the entities:
dependencies.

12. Process
Is an object that typically encapsulates an interaction
of a user with business entities.
A process typically updated and changes the state of
the entities.
A business process may have its own state which
may exist only for the duration of the process; at the
completion of the process the state ceases to exist.
Process state may be transient or persistent.
States ate transient for conversational processes and
persistent for collaborative processes.

13. Rules
Rules that apply to the state of an
entity should be implemented in the
component that represents the entity.
Rules that apply to the processes
should be implemented in the
component that represents the
processes.

14. EJB Types
There are three types of EJBs:
Entity, session and message-driven
We will discuss message-driven bean in a
separate discussion.
The syntax of the session bean and entity
bean client-view API is almost identical.
But they have different life cycle, different
persistence management, etc.
EJBs can be stateless and stateful beans.

15. Life Cycle Differences
Session Bean
 Object state:
Maintained by container
 Object Sharing:
No sharing: per client
 State Externalization:
State is inaccessible to other
programs
 Transactions:
Not recoverable
 Failure Recovery:
Not guaranteed to survive failures
Entity Bean
Maintained by DB
Shared by multiple client
Accessible to other programs
State changed transactionally and
is recoverable.
Survives failures and restored when
the container restarts.

16. Choosing Entity or Session
Bean
Entity (business entity) is typically implemented as
entity bean or a dependent object of an entity bean.
Conversational (business) process as a session bean.
Collaborative bean as an entity bean.
Any process that requires persistence is implemented
as an entity bean.
When exposure to other applications are not needed
for an entity or process (local/private process) then
they are implemented as bean dependent objects.

17. Parts of EJB
EJB class that implements the business methods
and life cycle methods; uses other helper
classes and libraries to implement.
Client-view API: consists of EJB home interface
and remote interface.
 Home interface: controls life cycle : create, remove,
find methods
 Remote interface: to invoke the EJB object methods

18. Parts of EJB (contd.)
Deployment Descriptor: XML document for
bean assembler and deployer;
 A declaration about EJB environment needed for
customizing the bean to the operating
environment.
Container Runtime services include:
transactions, security,distribution,load
balancing, multithreading, persistence, failure
recovery, resource pooling, state
management, clustering..

19. Enterprise Bean Parts
<<Home Interface>>
AccountHome
create()
find()
remove()
<<Remote Interface>>
Account
debit()
credit()
getBalance()
<<Enterrpise Bean class>
AccountBean
ejbCreate()
ejbFind()
ejbRemove()
debit()
credit()
getBalance()
Deployment Descriptor
name = AccountEJB
class = AccountBean
home = AccountHome
remote = Account
type = Entity
transaction = required
…..

20. AccountHome Interface
import java.rmi.RemoteException;
import javax.ejb.CreateException;
import javax.ejb.FinderException;
import java.util.Collection;
public interface AccountHome extends javax.ejb.EJBHome {
//create methods
Account create (String lastName, String firstName) throws RemoteException,
CreateException, BadNameException;
Account create (String lastName) throws RemoteException, CreateException;
// find methods
Account findByPrimaryKey (AccountKey primaryKey) throws RemoteException,
FinderException;
Collection findInActive(Date sinceWhen)
throws RemoteException, FinderException, BadDateException;

21. Account Interface
import java.rmi.RemoteException;
public interface Account extends javax.ejb.EJBObject {
BigDecimal getBalance() throws RemoteException;
void credit(BiGDecimal amount) throws RemoteException;
Void debit(BigDecimal amount) throws RemoteException,
InSufficientFundsException;
}

22. AccountBean class
public class AccountBean implements javax.ejb.EntityBean {
// life cycle methods from home interface
public AccountKey ejbCreate (String latName, String firstName) throws … {…
public AccountKey ejbCreate(String lastName) throws …{…}
public AccountKey ejbFindByPrimaryKey(AccountKey primarykey)… {…}
Public Collection ejbFindInactive( Data sinecWhen).. {…}
// business methods from remote interface
public BigDecimal getBalance() {….}
public void credit(BigDecimal amt) {…}
Public void debit(BigDecimal amt) throws InsufficientFundException {….}
// container callbacks from EntityBean container
public ejbRemove( ) throws RemoveException{ …}
public void setEntityContext(EntityContext ec) {…}
public unsetEntityContext(EntityContext ec) {…}
public void ejbActivate() {…}
public void ejbLoad() {….}
public void ejbStore() {….}
}

23. Deployment Descriptor
…
<entity-bean>
<ejb-name>AccountEJB</ejb-name>
<home>com.wombat.AccopuntHome</home>
<remote>com.wombat.Account</remote>
<ejb-class>com.wombat.AccountBean</ejb-class>
<persistence-type>Bean<persistence-type>
<primary-key-class>com.wombat.AccountKey</primary-key-class>
</entity-bean>
…
<container-transaction>
<method>
<ejb-name>AcoountEJB</ejb-name>
<method-name>*</method-name>
</method>
<trans-attribute>required</trans-attribute>
</container-transaction>

24. Introduction to
Java EE (J2EE)
By
Dr Rani Reddy

25. Session Objectives
 Understanding the value propositions of
J2EE
 Getting a big picture of J2EE architecture and
platform
 Getting high-level exposure of APIs and
Technologies that constitute J2EE
 You don't have to understand all the details
 Understanding why J2EE can be used for as
a platform for development and deployment
of web services

26. What is J2EE?

27. Challenges
Portability
Diverse
Environments
Time-to-market
Core Competence
Assembly
Integration
Key
Technologies
J2SE™
J2EE™
JMS
Servlet
JSP
Connector
XML
Data
Binding
XSLT
Products
App Servers
Web Servers
Components
Databases
Object to DB
tools
Legacy
Systems
Databases
TP Monitors
EIS Systems
Enterprise Computing

28. What Is the J2EE?
 Open and standard based platform for
 developing, deploying and managing
 n-tier, Web-enabled, server-centric, and
component-based enterprise applications

29. The Java™ Platform
High-End
Server
Java Technology
Enabled Desktop
Workgroup
Server
Java Technology
Enabled Devices

30. The JavaTM Platform
Optional
Packages
Java 2
Enterprise
Edition
(J2EE)
Java 2
Standard
Edition
(J2SE)
JVM
Java
Card
APIs
CardVM
Optional
Packages
Personal
Basis Profile
Personal
Profile
Foundation Profile
CDC
MIDP
CLDC
KVM
Java 2 Platform Micro Edition
(J2METM
)
* Under development in JCP

31. Open and Standard Solution
 Use "component and container" model in
which container provides system services in
a well-defined and as industry standard
 J2EE is that standard that also provides
portability of code because it is based on
Java technology and standard-based Java
programming APIs

32. Why J2EE?

33. Platform Value to Developers
 Can use any J2EE implementation for
development and deployment
 Use production-quality standard implementation which is
free for development/deployment
 Use high-end commercial J2EE products for scalability and
fault-tolerance
 Vast amount of J2EE community resources
 Many J2EE related books, articles, tutorials, quality code
you can use, best practice guidelines, design patterns etc.
 Can use off-the-shelf 3rd-party business
components

34. Platform Value to Vendors
 Vendors work together on specifications and
then compete in implementations
 In the areas of Scalability, Performance,
Reliability, Availability, Management and
development tools, and so on
 Freedom to innovate while maintaining the
portability of applications
 Do not have create/maintain their own
proprietary APIs

35. Platform Value to Business Customers
 Application portability
 Many implementation choices are possible
based on various requirements
 Price (free to high-end), scalability (single CPU to
clustered model), reliability, performance, tools,
and more
 Best of breed of applications and platforms
 Large developer pool

36. J2EE APIs &
Technologies

37. J2EE 1.4 APIs and Technologies
 J2SE 1.4 (improved)
 JAX-RPC (new)
 Web Service for J2EE
 J2EE Management
 J2EE Deployment
 JMX 1.1
 JMS 1.1
 JTA 1.0
 Servlet 2.4
 JSP 2.0
 EJB 2.1
 JAXR
 Connector 1.5
 JACC
 JAXP 1.2
 JavaMail 1.3
 JAF 1.0

38. Java EE 5
 JAX-WS 2.0 & JSR 181
 Java Persistence
 EJB 3.0
 JAXB 2.0
 JavaSever Faces 1.2 – new to Platform
 JSP 2.1 – Unification w/ JSF 1.2
 StAX – Pull Parser – new to Platform

39. Servlet &
JSP (JavaServer
Pages)

40. What is a Servlet?
 Java™ objects which extend the functionality
of a HTTP server
 Dynamic contents generation
 Better alternative to CGI, NSAPI, ISAPI, etc.
 Efficient
 Platform and server independent
 Session management
 Java-based

41. Servlet vs. CGI
CGI
Based
Webserver
CGI
Based
Webserver
Request CGI1
Child for CGI1
CGI
Based
Webserver
Servlet Based Webserver
JVM
Request CGI1
Child for CGI1
Request Servlet1
CGI
Based
Webserver
Servlet Based Webserver
JVM
Servlet1
Request CGI1
Child for CGI1
Request CGI2
Request Servlet1
CGI
Based
Webserver
Child for CGI2
Servlet Based Webserver
JVM
Servlet1
Request CGI1
Child for CGI1
Request CGI2
Request Servlet1
Request Servlet2
CGI
Based
Webserver
Child for CGI2
Servlet Based Webserver
JVM
Servlet1
Servlet2
Request CGI1
Child for CGI1
Request CGI2
Request CGI1
Request Servlet1
Request Servlet2
CGI
Based
Webserver
Child for CGI2
Child for CGI1
Servlet Based Webserver
JVM
Servlet1
Servlet2
Request CGI1
Child for CGI1
Request CGI2
Request CGI1
Request Servlet1
Request Servlet2
Request Servlet1
CGI
Based
Webserver
Child for CGI2
Child for CGI1
Servlet Based Webserver
JVM
Servlet1
Servlet2
Request CGI1
Child for CGI1

42. What is JSP Technology?
 Enables separation of business logic
from presentation
 Presentation is in the form of HTML or
XML/XSLT
 Business logic is implemented as Java Beans
or custom tags
 Better maintainability, reusability
 Extensible via custom tags
 Builds on Servlet technology

43. EJB
(Enterprise Java
Beans)

44. What is EJB Technology?
 A server-side component technology
 Easy development and deployment of Java
technology-based application that are:
 Transactional, distributed, multi-tier, portable,
scalable, secure, …

45. Why EJB Technology?
● Leverages the benefits of component-model
on the server side
● Separates business logic from system code
 Container provides system services
● Provides framework for portable components
 Over different J2EE-compliant servers
 Over different operational environments
● Enables deployment-time configuration
 Deployment descriptor

46. EJB Architecture

47. Enterprise JavaBeans
Enterprise JavaBeans
Entity Bean Message-Driven Bean
Synchronous communication Asynchronous communication
Stateless Stateful
Bean managed
Persistence
(BMP)
Container managed
Persistence
(CMP)
Session Bean

48. JMS
(Java Message
Service)

49. Java Message Service (JMS)
 Messaging systems (MOM) provide
 De-coupled communication
 Asynchronous communication
 Plays a role of centralized post office
 Benefits of Messaging systems
 Flexible, Reliable, Scalable communication
systems
 Point-to-Point, Publish and Subscribe
 JMS defines standard Java APIs to
messaging systems

50. Connector
Architecture

51. Connector Architecture
 Defines standard API for integrating J2EE
technology with EIS systems
 CICS, SAP, PeopleSoft, etc.
 Before Connector architecture, each App server has
to provide an proprietary adaptor for each EIS
system
 m (# of App servers) x n (# of EIS's) Adaptors
 With Connector architecture, same adaptor works
with all J2EE compliant containers
 1 (common to all App servers) x n (# of EIS's) Adaptors

52. m x n Problem Before Connector
Architecture
App
Server1
App
Server
App
Server3
App
Server2
SAP
EIS4
EIS3
m n
EIS
2

53. JAAS (Part of J2SE
1.4)
(Java Authentication &
Authorization Service)

54. JAAS: Authentication
 Pluggable authentication framework
 Userid/password
 Smartcard
 Kerberos
 Biometric
 Application portability regardless of authentication
schemes underneath
 JAAS provides authentication scheme independent API
 Authentication schemes are specified Login configuration
file, which will be read by JAAS

55. JAAS Pluggable Authentication

56. Other J2EE APIs &
Technologies

57. JNDI
 Java Naming and Directory Interface
 Utilized by J2EE applications to locate
resources and objects in portable fashion
 Applications use symbolic names to find object
references to resources via JNDI
 The symbolic names and object references have
to be configured by system administrator when
the application is deployed.

58. JDBC
 Provides standard Java programming
API to relational database
 Uses SQL
 Vendors provide JDBC compliant driver
which can be invoked via standard Java
programming API

59. J2EE Management (JSR-77)
 Management applications should be able to
discover and interpret the managed data of
any J2EE platform
 Single management platform can manage
multiple J2EE servers from different vendors
 Management protocol specifications ensure a
uniform view by SNMP and WBEM
management stations
 Leverages JMX

60. J2EE Deployment (JSR-88) - J2EE 1.4
Tools J2EE Platforms
Standard
Deployment API
(Universal Remote)
IDEs
Vendor Deploy
Tools
Management
Tools

61. J2EE App Server
App
JMX
JMX
JMX defacto
Dynamic Deployment
JMX API into
the J2EE 1.4 platform
A single technology for the J2EE platform
JMX

62. J2EE is an End-to-End
Architecture

63. N-tier J2EE Architecture
Web Tier EJB Tier

64. J2EE
Component & Container
Architecture

65. JNDI
J2SE
JMS
RMI/IIOP
JDBC
Database
App
Client
App Client Container
HTTP/
HTTPS
J2SE
RMI
J2SE
JNDI
JMS
RMI/IIOP
JDBC
JTA
JavaMail
JAF
JNDI
JMS
RMI/IIOP
JDBC
JTA
JavaMail
JAF
HTTP/
HTTPS
Applet Container
Applet JSP Servlet EJB
Web Container EJB Container
RMI
J2SE
J2EE Containers & Components

66. Components
Handle
 Concurrency
 Security
 Availability
 Scalability
 Persistence
 Transaction
 Life-cycle
management
 Management
 Presentation
 Business Logic
Containers
Handle

67. Containers & Components
 Containers do their work invisibly
q No complicated APIs
q They control by interposition
 Containers implement J2EE
– Look the same to components
– Vendors making the containers have great
freedom to innovate

68. J2EE Application
Anatomies

69. DB & EIS
Resources
Browser
Stand-alone
Web Server EJB Server
Web Server EJB Server
Possible J2EE Application
Anatomies

70. J2EE Application Anatomies
● 4-tier J2EE applications
– HTML client, JSP/Servlets, EJB, JDBC/Connector
● 3-tier J2EE applications
– HTML client, JSP/Servlets, JDBC
● 3-tier J2EE applications
– EJB standalone applications, EJB, JDBC/Connector
● B2B Enterprise applications
– J2EE platform to J2EE platform through the
exchange of JMS or XML-based messages

71. Which One to Use?
● Depends on several factors
 Requirements of applications
 Availability of EJB tier
 Availability of developer resource

72. Web Tier and JavaServer Pages
The Web Tier is also the location where JavaServer Pages (JSP) programs reside.
A JSP program is identified with a URL that is associated with a hyperlink built into a web page
displayed on the client.
Presentation and processing
A JSP program can contain two components: the presentation component and the processing logic.
Presentation Component: The presentation component defines the content that is
displayed by the client.
Processing logic: . Processing logic defines the business rules that are applied whenever the
client calls the JSP program.
• Although placing both the presentation and processing logic components in the same
component seems to compartmentalize enterprise application, this technique can lead to
nonmaintainable code
The Inclusion Strategy:
The designer of an enterprise application typically uses the same elements for all web pages of the
user interface to provide continuity throughout the application.
This means that the same code can appear in more than one web page, which is inefficient and a
maintenance nightmare.
The critical difference between the include action and the include directive is that the include action
places the results generated by the called JSP program into the calling JSP program.

73. Style sheets:
Consistency helps the user become familiar with how to use the application. This means that the
developer must write JSP programs that generate web pages having the same general appearance
(i.e., same font style, font size, and color combination).
Enterprise java beans tier:
The Enterprise JavaBeans Tier contains Enterprise JavaBeans that provide processing logic to other
tiers. Processing logic includes all code and data that is necessary to implement one or more
business rules.
There is a tendency for developers to create a one-to-one relationship between entities defined in
an application's entity relationship diagram and with Enterprise JavaBeans. Each time an Enterprise
JavaBean is created, there is increased overhead for the network and for the Enterprise JavaBeans
container.
MVC:
The Myth of Using Inheritance :
inheritance enables functionality and data to be reused without having to rewrite the functionality
and data several times in an application. Inheritance is also used to embellish both a functionality and
data. That is, the class that inherits a functionality can modify the functionality without affecting the
original functionality. Inheritance also provides a common interface based on functionality that is
used by similar classes.
Interfaces and Inheritance:
An interface contains functionality that is used across unlike real-world objects. This is different from
a base class in that a base class provides functionality that is fundamental to like real-world objects. A
common mistake is to use an interface as a base class because intuitively this seems sensible, but an
interface is too narrow in scope which means an interface consists of one of many functionalities that
are used by real-world objects.
Potential problems: Ripple effect

74. Maintainable Classes:
There are two factors that determine if classes are maintainable. These are coupling and cohesion.
Coupling occurs when there is a class dependent on another class.
Coupling also occurs when a class delegates responsibility to another class.
Before a change can be made to either the derived class or the base class, the developer must assess
the impact on the coupled class.
Cohesion describes how well a class functionality is focused. That is, a class that has broad
functionality isn't as cohesive as a class that has a single functionality.
Performance Enhancements :
There are two ways to reduce or practically eliminate the amount of bytecode that is interpreted at
runtime: by using HotSpot, new in the Just In Time compiler from Sun Microsystems, Inc., or by using
a native compiler. HotSpot tunes the performance of an application at runtime so the application
runs at optimal performance.
HotSpot analyzes both client- and server-side programs and applies an optimization algorithm that
has the greatest performance impact for the application.
concern about using HotSpot is the complexity of debugging runtime errors. Runtime errors occur in
the optimized code and not necessarily in the bytecode. Therefore, it can be difficult to re-create the
error.
Power of interfaces:
Designing an enterprise application using interfaces provides built-in flexibility, known as pluggability,
because an interface enables the developer to easily replace components.
A method signature consists of the name and the number and type of parameters for a method. A
developer implements the interface by defining a method of a class that has the same method
signature as the interface.
An interface defines a standard way to interact with classes that implement the interface. This
enables a developer to replace a class with another class that implements the same interface, and
only the statement that creates the instance of the class needs to be changed in the program that
calls the method.
Power of threads:
Proper use of threads can increase the efficiency of running an enterprise application because
multiple operations can appear to perform simultaneously. More than one thread can be executed
within an enterprise application. This means that multiple statements can run parallel. The thread
class is used to create a thread. Once the thread is created, the developer can specify the behaviour
of the thread (i.e., start, stop) and the point within the program where the thread begins execution.
Actually, the number of application threads being processed at one time is equal to or less than the
number of CPUs on the machine. Multiple threads that execute the same method share values, which
can cause unexpected results. However, synchronizing a method enables one thread at a time to run
within the method. This practically locks the method and assures that values aren't shared.

75. Be on the alert for possible deadlocks when using too many synchronized methods in an application.
A deadlock can occur when a synchronized method calls other methods that are also synchronized.
Power of Notification:
Each event might affect multiple objects within the application and therefore it is critical that a
notification process be implemented within the application, so that changes experienced by an object
can be transmitted to other objects that are affected by the change.
There are three ways in which objects are notified of changes: passive notification, timed notification,
and active notification.
Passive notification is the process whereby objects poll relative objects to determine the current
state of the object.
An alternative to the passive notification method is timed notification. Timed notification suspends
the thread that polls objects for a specific time period. The drawback of both passive notification and
timed notification is that each of these notification methods polls relative objects.
The original active notification method was called the observable-observer method, which is also
known as the publisher-scriber model.