J2EE Study Note

J2EE Architecture
----------------------
Tier 1: Client
Tier 2: J2EE Server
a. EJB Container:Enterprise Bean
b. Web Container:JSP File,Servlet
Tier 3: Database Server[@more@]

----------------------

J2EE Server
----------------------
The J2EE Server provies the following services:
. 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
----------------------
Enterprise bean instances run within an EJB container.The container is a runtime
environment that controls the enterprise beans and provides them with important
system-level services.Since you don't have to develop these services yourself,you
are free to concentrate on the business methods in the enterprise beans.The
container provides the following services to enterprise beans:
. Transaction Management
. Security
. Remote Client Connectivity
. Life Cycle Management
. Database Connection Pooling

Transaction Management

When a client invokes a method in an enterprise bean,the container intervenes in
order to manage the transaction.Because the container manages the transaction,you
do not have to code transaction boundaries in the enterprise bean.The code required
to control distributed transactions can be quite complex.Instead of writing and
debugging complex code,you simply declare the enterprise bean's transactional
properties in the deployment descriptor file.The container reads the file and handles
the enterprise bean's transactions for you.

Security

The container permits only authorized clients to invoke an enterprise bean's
methods.Each client belongs to a particular role,and each role is permitted to
invoke certain methods.You declare the roles and the methods they may invoke in
the enterprise bean's deployment descriptor.Because of this declarative approach,
you don't need to code routines that enforce security.

Remote Client Connectivity

The container manages the low-level communications between clients and enterprise
beans.After an enterprise bean has been created,a client invokes methods on it as if
it were in the same virtual machine.

Life Cycle Management

An enterprise bean passes through several states during its lifetime.The container
creates the enterprise bean,moves it between a pool of available instances and the
active state,and finally,removes it.Although the client calls methods to create and
remove an enterprise bean,the container performs these tasks behind the scenes.

Database Connection Pooling

A database connection is a costly resource.Obtaining a database connection is time-
consuming and the number of connections may be limited.To alleviate these
problems,the container manages a pool of database connections.An enterprise bean
can quickly obtain a connection from the pool.After the bean release the
connection,it may be re-used by another bean.

Web Container

The Web container is a runtime environment for JSP files and servlets.Although
these Web components are an important part of a J2EE application,this manual
focuses on enterprise beans.For more information on developing Web components,
see the home pages for the JavaServer Pages and Java Servlet technologies.

Enterpise Bean Creation

Person: software developer
Tasks:
. Codes and compiles the Java source code needed by the enterprise bean
. Specifies the deployment descriptor for the enterprise bean
. Bundles the .class files and deployment descriptor into an EJB .jar file
Deliverable: the EJB .jar file containing the enterprise bean

Web Component Creation

Persons: Web designer(JavaServer Pages components),software developer(servlets)
Tasks:
. Codes and compiles Java source code for the servlet
. Writes .jsp and .html files
. Specifies the deployment descriptor for the Web component
. Bundles the .class,.jsp,.html,and deployment descriptor files int the .war file
Deliverable: the .war file containing the Web component

J2EE Application Client Creation

Person: software developer
Tasks:
. Codes and compiles the Java source code needed by the client
. Specifies the deployment descriptor for the client
. Bundles the .class files and deployment descriptor into the .jar file for the client.
Deliverable: the .jar file containing the J2EE application client

J2EE Application Assembly

Person: software developer
Tasks:
. Assembles enterprise beans(EJB .jar) and Web components(.war) created in the previous phases into a J2EE application(.ear)
. Specifies the deployment descriptor the J2EE application
Deliverable: the .ear file containing the J2EE application

J2EE Application Deployment

Person: system administrator
Tasks:
. Adds the J2EE application(.ear) created in the preceding phase to the J2EE server
. Configures the J2EE application for the operational environment by modifying the deployment descriptor of the J2EE application
. Deploys (installs) the J2EE application (.ear) into the J2EE server
Deliverable: an installed and configured J2EE application

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/802415/viewspace-826961/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/802415/viewspace-826961/