Read without ads and support Scribd by becoming a Scribd Premium Reader.

Language:

Download

Go BackAdd Note

Link

Embed

Save for later

Common Architectures

Scalability:

Scalability is the ability to economically support the required quality of service asthe load increases. Two types: Vertical and Horizontal

Vertical:

Achieved by adding capacity (memory, CPUs, etc.) to existing servers.Requires few to no changes to the architecture of a system.Increases: Capacity, ManageabilityDecreases: Reliability, Availability (single failure is more likely to lead to system failure)Vertical scalability is usually cheaper than horizontal scalability.J2EE supports vertical scaling because of automatic lifecycle management. Adding morecapacity to a server allows it to manage more components (EJBs, etc.).

Horizontal:

Achieved by adding servers to the system.Increases the complexity of the system architecture.Increases: Reliability, Availability, Capacity, Performance (depends on load balancing),FlexibilityDecreases: Manageability (more elements in the physical architecture)J2EE supports horiz. scaling because the container and server handle clustering and load-balancing.Availability and reliability are obtained through scalability.Scalability affects capacity. The more scalable the system is the more capacity it can support.This must be traded-off against the complexity & manageability costs.

Maintainability:

How related is this to Flexibility?Flexibility is the ability to change the architecture to meet new requirements in a cost-efficientmanner.A flexible system should be more maintainable in the face of changes to the environment and/or tothe application itself.Flexibility improves: Availability, Reliability, ScalabilityFlexibility slightly decreases: Performance, ManageabilityFlexibility is achieved via code that can be distributed across servers with load balancing that preventsone system from being overburdened. The use of a multi-tier architecture also helps achieveflexibility.

Reliability:

The ability to ensure the integrity and consistency of the application and all of its transactions.You increase reliability through the use of horizontal scalability, i.e., by adding more servers. This onlyworks up to a certain point, though.When you increase reliability you increase availability.

Availability:

Availability is about assuring that services are available to the required number of users for therequired proportion of time.

Extensibility:

The ability to modify or add functionality without impacting the existing functionality.The key to an extensible design is to make an effective OO design. Extensibility pays the most towardsthe font end of a system.

Some rough guidelines:

More than 25 top-level classes will lead to problemsEvery use case should be able to be implemented using domain model methodsJ2EE supports extensibility because it is component-based and allows you to separate the roles of anapp. JSPs can handle presentation. Servlets can handle routing, and EJBs can handle business logic.

Performance:

Architectural performance is concerned with creating an architecture that forces end-to-endperformance.The purpose of an architecture that ensures performance is to control expensive calls and to identifybottlenecks.If you know the boundaries of the various parts of the system, the technologies, and the capabilitiesof the technologies you can do a good job of controlling performance.You want to minimize the number of network calls your distributed app makes

�

make a few

�

large

�

calls that get a lot of data vs. lots of calls that get small amounts of data.Try to minimize process-to-process calls because they are expensive.Use resource pooling to reduce the number of expensive resources that need to be created likenetwork connections, database connections, etc.

Manageability:

Manageability refers to the ability to manage a system to ensure the health of the system.A single tier or monolithic app would be more manageable from a management perspective than amulti-tier system but this must be weighed against the possibility of a change rippling through amonolithic app.A simple architecture may not be as flexible or available as a more complex system but the amount of effort required to keep the system up & functioning will be less.A component-based architecture like J2EE offsets some of the manageability problems caused by amulti-tier system.

Security:

Security ensures that info is neither modified nor disclosed except in accordance with the securitypolicy.Tradeoffs: personal privacy, ease of use, and expense.A highly secure system is:More costlyHarder to define and developRequires more watchdog activities

Principles of Security:

Identity

�

The user is correctly ID

�

d thru an authentication mechanismAuthority

�

The user can perform only allowed activitiesIntegrity

�

Data can only be modified in allowed waysPrivacy

�

Data is disclosed to authorized entities in authorized waysAuditability

�

The system maintains logs of actions taken for later analysis

Design Patterns

1) State the benefits of using design patterns.Improves communication between designers by use of pattern names vs. the details of the patterns.Captures experience of solving a type of problem.Provide a way of reusing design.Provide a mechanism for making designs more reusable.Provides a mechanism for systematizing the reuse of things that have been seen before.Can be used to teach good design.2) From a list, select the most appropriate design pattern for a given scenario.3) State the name of a GOF design pattern given the UML diagram and/or a brief description of thepattern’s functionality.4) Select from a list benefits of a specified GOF pattern. Identify the GOF pattern associated with aspecified J2EE feature.

J2EE Essential Patterns

Abstract Factory

CreationalProvide an interface for creating families of related or dependent objects (products) withoutspecifying their concrete classes.J2EE technology uses this pattern for the EJB Home interface, which creates new EJB objects.It isolates concrete classes.It makes exchanging product families easy.It promotes consistency among products.Supporting new kinds of products is difficult.

Decorator:

StructuralAttach additional responsibilities to an object dynamically. Decorators provide a flexiblealternative to subclassing for extending functionality.In J2EE technology, The EJB object is a decorator for the bean because the bean

�

sfunctionality is expanded to include remote behavior.

Factory Method (Virtual Constructor):

CreationalDefine an interface for creating an object, but let subclasses decide which class to instantiate.Factory Method lets a class defer instantiation to subclasses.J2EE technology uses this pattern for the EJB Home interface, which creates new EJB objects.Eliminates the need to bind application-specific classes into your code.Gives subclasses a hook for providing an extended version of an object being constructed.

Proxy: