Table of Contents
Notes of Enterprise Application Design And Development
J2EE Platform Overview(Application Architecture)
Java EE Platform Benefits
- Simplified architecture and development
- Freedom of choice in servers, tools, and components
- Integration with existing information systems
- Scalability to meet demand variations
- Flexible security model
Simplified Architecture and Development
- The JEE platform supports a simplified, component-based development model.
- This model offers “Write-Once-Run-Anywhere” portability, supported by any server product that conforms to the JEE standard.
- The component-based JEE development model can enhance application development productivity in a number of ways:
- Maps easily to application functionality—
- Simplifies application maintenance, since components can be updated and replaced independently—new functionality can be shimmed/added into existing applications simply by updating selected components.
- Enables assembly- and deploy-time behaviors
- The code of a JEE application can be generated automatically by tools.
- Many application behaviors can be configured at application assembly or deployment time, without recoding.
- Supports the division of labor—
- Web page authors can create JSP templates,
- Java coders can implement application behavior,
- Domain experts can develop business logic
- Application developers and integrators can assemble and deploy applications.
- This division of labor also expedites application maintenance.
Integrating Existing Enterprise IS
APIs are used for accessing existing enterprise information systems.
- The JEE Connector architecture is the infrastructure for interacting with a variety of Enterprise IS types, including ERP, and other legacy systems.
- The JDBC API is used for accessing relational data from the Java programming language.
- The Java Transaction API (JTA) is the API for managing and coordinating transactions across enterprise information systems.
- The Java Naming and Directory Interface(JNDI) is the API for accessing information in enterprise name and directory services.
- The Java Message Service (JMS) is the API for sending and receiving messages via enterprise messaging systems such as IBM MQ Series and TIBCO Rendezvous.
- The JavaMail API is used for sending and receiving e-mail.
- Java IDL provides the mechanism for calling CORBA services.
- Java APIs for XML provides support for integration with legacy systems and applications, and for implementing Web services in the J2EE platform.
Choice of Servers, Tools, and Components
- The standardization and branding of the J2EE platform provide many benefits, including:
- A range of server choices— Application development organizations can expect J2EE branded platforms from a variety of vendors, providing a range of choices in hardware platforms, operating systems, and server configurations.
- This ensures that businesses get a choice of servers appropriate to their needs.
Designed for tool support
- Both enterprise beans and JSP page components are designed to be manipulated by graphical development tools and to allow automating many of the application development.
- Application developers have a choice of tools to manipulate and assemble components, and individual team members may choose tools that best suit their specific requirements.
A marketplace for components
- Component-based design ensures that many types of behavior can be standardized, packaged, and reused by any J2EE application.
- Component vendors will provide a variety of off-the-shelf component solutions, including accounting beans, user interface templates.
- J2EE containers provide a mechanism that supports simplified scaling of distributed applications, with no application development effort.
- Because J2EE containers provide components with transaction support, database connections.
- Containers may pool database connections, providing clients with quick, efficient access to data because containers may run on multiple systems, Web containers can automatically balance the load in response to fluctuating demand.
Simplified, Unified Security Model
- The J2EE security model is designed to support single sign-on access to application services.
- Component developers can specify the security requirements of a component at the method level
- While both Enterprise JavaBeans technology and Java Servlet APIs provide programmatic security control, the basic role-based security mechanism (where groups of users share specific permissions) is specified entirely at application deployment time.
- This provides both greater flexibility and better security control.
Multitier Application Scenario
- Web container hosts Web components that are almost exclusively dedicated to handling a given application’s presentation logic.
- The EJB container hosts application components that use EIS resources to service requests from Web-tier components.
- Application back-office functionality is relatively isolated from the end-user look and feel.
- Regardless of application domain or industry vertical, technology platform, and client-side technology, everyone agrees that three fundamental concepts should be decoupled and kept separate—namely, the data, the business logic that operates on that data, and the presentation of that data to the end-user
- In the JEE platform, a design pattern that enforces this separation of concerns is called the MVC model.
- Model–view–controller (MVC) is a software architecture pattern which separates the representation of information from the user’s interaction with it.
- The model consists of application data, business rules, logic, and functions.
- A view can be any output representation of data, such as a chart or a diagram. Multiple views of the same data are possible, such as a bar chart for management and a tabular view for accountants.
- The controller mediates input, converting it to commands for the model or view. The central ideas behind MVC are code reusability and separation of concerns.
Relationships Between MVC Participants
Components of the MVC pattern.
- The controller receives the user input, constructs the appropriate model, and then passes it to the view.
- Both the controller and the view have a dependency on the model, but the model itself is kept ignorant of the controller and view.
Three pieces of the MVC pattern:
The model— The domain that your software is built around.
- If you were building a blog, your models might be post and comment. In some contexts, the term model might refer to a view-specific model— a representation of the domain for the specific purpose of being displayed in the user interface.
Three pieces of the MVC pattern:
The view— The visual representation of a model, given some context.
- It’s usually the resulting markup that the framework renders to the browser, such as the HTML representing the blog post.
Three pieces of the MVC pattern:
The controller— The coordinator that provides the link between the view and the model.
- The controller is responsible for processing input, acting upon the model, and deciding on what action should be performed, such as rendering a view or redirecting to another page.
- Continuing the blog example, the controller might look up the most recent comments for a post (the model) and pass them to the view for rendering.
- Notes of Enterprise Application Design And Development – EADD
- IOM 2068 Past Question With Answers
- UNIT-1 BBA III Year Notes – Logistics Management (Osmania University)
- Attitude BBA Notes