SlideShare a Scribd company logo
1 of 54
Behavioral and J2EE Design Patterns


Pre-assessment Questions
         1.   Which structural design pattern separates the interface with its
              implementation?
               a) Adapter
              b) Bridge
              c)   Composite
              d) Decorator

         3.   Which behavioral design pattern encapsulates a request as an object
              and enables the queuing and logging of requests?
              a)   Template Method
              b) Visitor
              c)   Strategy
              d) Command



 ©NIIT                  Architecting J2EE Solutions          Lesson 3A / Slide 1 of 54
Behavioral and J2EE Design Patterns


Pre-assessment Questions
         1.   Which statement defines a structural design pattern?
              a)  Represents the composition of classes and objects.
              b) Defines the state, behavior, and communication among the
                  objects.
              c)  Provides separation between the sender and receiver of a request
                  by introducing a number of objects between them.
              d) Provides a way to dynamically select the instantiation of an object
                  and to return a clone of a prototypical object.




 ©NIIT                  Architecting J2EE Solutions         Lesson 3A / Slide 2 of 54
Behavioral and J2EE Design Patterns


Pre-assessment Questions
         1.   Consider the statements:
              Statement A: Facade design pattern provides a unified interface to a
              collection of interfaces in a subsystem.
              Statement B: Facade pattern enables you to extend functionality of an
              object and dynamically provides additional responsibilities to an object.
              Identify the correct option.
              a)    Statement A is true and statement B is false
              b) Statement A is false and statement B is true
              c)    Both, statements A and B, are true
              d) Both, statements A and B, are false




 ©NIIT                  Architecting J2EE Solutions           Lesson 3A / Slide 3 of 54
Behavioral and J2EE Design Patterns


Pre-assessment Questions
         2.   Which design pattern composes objects into tree structures?
              a) Flyweight
              b) Composite
              c) Adaptor
              d) Proxy




 ©NIIT                  Architecting J2EE Solutions        Lesson 3A / Slide 4 of 54
Behavioral and J2EE Design Patterns


Solutions to Pre-assessment
  Questions
         1.   b.   Bridge
         2.   d.   Command
         3.   a.   Represents the composition of classes and objects.
         4.   a.   Statement A is true and statement B is false
         5.   b.   Composite




 ©NIIT                    Architecting J2EE Solutions         Lesson 3A / Slide 5 of 54
Behavioral and J2EE Design Patterns


Objectives
    In this lesson you will learn to:


         •   Use Behavioral design patterns
         •   Identify J2EE design Patterns




 ©NIIT                   Architecting J2EE Solutions   Lesson 3A / Slide 6 of 54
Behavioral and J2EE Design Patterns


Behavioral Design Patterns
    •    The behavioral design pattern defines the state, behavior, and communication
         among the objects.
    •    The various behavioral design patterns are Chain of Responsibility, Command,
         Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template
         Method, and Visitor.
    •    All these patterns are concerned with how an object behaves.




 ©NIIT                   Architecting J2EE Solutions         Lesson 3A / Slide 7 of 54
Behavioral and J2EE Design Patterns


Behavioral Design Patterns (Contd.)
    •    Interpreter Pattern
           • The Interpreter design pattern is used to interpret the grammar of a given
             language.
           • The advantages of using Interpreter design pattern are:
                • Makes it easy to change and extend the grammar.
                • Makes it simple to implement the grammar.
           • The participants of Interpreter design pattern are:
                • Context: Contains global information.
                • Client: Invokes methods on the Interpreter.
                • AbstractExpression abstract class : Declares abstract operations
                  implemented by TerminalExpression class.
                • TerminalExpresssion class : Implements an operation to interpret
                  a language for terminal symbols in the grammar. For example, ‘X’ in
                  roman is a terminal symbol that represents “10”.


 ©NIIT                    Architecting J2EE Solutions         Lesson 3A / Slide 8 of 54
Behavioral and J2EE Design Patterns


Behavioral Design Patterns (Contd.)
    •    Interpreter Pattern (Contd.)
           • Class diagram of Interpreter design pattern




 ©NIIT                    Architecting J2EE Solutions      Lesson 3A / Slide 9 of 54
Behavioral and J2EE Design Patterns


Behavioral Design Patterns (Contd.)
    •    Iterator Pattern
           • The Iterator design pattern allows you to access elements of a certain data
              structure in a sequential manner, without knowing the internal
              representation of the content.
           • The advantages of using Iterator design pattern are:
                 • Provides different ways to iterate through a data structure.
                 • Simplifies the retrieval of data from a collection.
           • The participants of Iterator design pattern are:
                 • Aggregate abstract class: Defines an interface to create an
                   Iterator object.
                 • ConcreteAggregate class: Creates and returns an instance of
                   ConcreteIterator object.
                 • Iterator abstract class: Defines an interface for accessing elements
                   of a data structure.
                 • ConcreteIterator class: Implements the Iterator operation.
 ©NIIT                    Architecting J2EE Solutions        Lesson 3A / Slide 10 of 54
Behavioral and J2EE Design Patterns


Behavioral Design Patterns (Contd.)
    •    Iterator Pattern (Contd.)
           • Class diagram of Iterator design pattern




 ©NIIT                    Architecting J2EE Solutions   Lesson 3A / Slide 11 of 54
Behavioral and J2EE Design Patterns


Behavioral Design Patterns (Contd.)
    •    Mediator Pattern
          • The Mediator design pattern defines an object, which is responsible for
             coordinating and controlling the change in state between objects of a
             group.
          • The advantages of using Mediator design pattern are:
               • Provides loose coupling among the objects of a group.
               • Centralizes the logic to manage interaction between the objects of a
                   group.
               • Enables the objects of a group to avoid the logic required to
                  communicate with each other.
          • The participants of Mediator design pattern are:
               • Mediator abstract class: Defines an interface for communication
                  with other objects.
               • Colleague abstract class: An object that communicates with other
                  objects using the Mediator.


 ©NIIT                   Architecting J2EE Solutions        Lesson 3A / Slide 12 of 54
Behavioral and J2EE Design Patterns


Behavioral Design Patterns (Contd.)
    •    Mediator Pattern (Contd.)
          • The participants of Mediator design pattern are (Contd.):
               • ConcreteMediator class : Implements Mediator behavior in order to
                  provide communication between colleague objects.




 ©NIIT                   Architecting J2EE Solutions     Lesson 3A / Slide 13 of 54
Behavioral and J2EE Design Patterns


Behavioral Design Patterns (Contd.)
    •    Mediator Pattern (Contd.)
          • Class diagram of Mediator design pattern




 ©NIIT                   Architecting J2EE Solutions   Lesson 3A / Slide 14 of 54
Behavioral and J2EE Design Patterns


Behavioral Design Patterns (Contd.)
    •    Memento Pattern
          • The Memento design pattern provides serialization of an object, so that
            the state of the object at various stages during the execution of a program
            can be saved.
          • The advantages of using the Memento design pattern are:
              • Restores the state of an object.
              • Conserves the encapsulation limitations of an object.
          • The participants of Memento design pattern are:
              • Originator class: Creates a Memento object by saving its current
                 internal state.
              • Memento class: Stores the internal state of an Originator object.
              • Caretaker class : Maintains an object’s saved internal state.



 ©NIIT                    Architecting J2EE Solutions       Lesson 3A / Slide 15 of 54
Behavioral and J2EE Design Patterns


Behavioral Design Patterns (Contd.)
    •    Memento Pattern (Contd.)
          • Class diagram of Memento design pattern




 ©NIIT                  Architecting J2EE Solutions   Lesson 3A / Slide 16 of 54
Behavioral and J2EE Design Patterns


Behavioral Design Patterns (Contd.)
    •    Observer Pattern
         • The Observer design pattern defines one to many relationships between
             subject and observer objects.
         • The advantages of using Observer design pattern are:
             •     Provides support for publisher to subscriber type communication.
             •     Provides decoupling between subject and observer in order to
                  reuse them independently.
         • The participants of Observer design pattern are:
             •     Subject abstract class: Provides an interface using which
                  observers can keep track of its implementation object.
             •     Observer abstract class: An object that updates itself according to
                  the changes in subject.
             •     ConcreteSubject class: Notifies its observers when its state
                  changes.
             •     ConcreteObserver class: Keeps its state consistent with the
                  subject’s state.



 ©NIIT                  Architecting J2EE Solutions        Lesson 3A / Slide 17 of 54
Behavioral and J2EE Design Patterns


Behavioral Design Patterns (Contd.)
    •    Observer Pattern (Contd.)
         • Class diagram of Observer design pattern




 ©NIIT                Architecting J2EE Solutions     Lesson 3A / Slide 18 of 54
Behavioral and J2EE Design Patterns


Behavioral Design Patterns (Contd.)
    •    State Pattern
         • The State design pattern enables an object to change its behavior when
              the state of the object changes.
         • The advantage of using State design pattern is that the transition of
              state is made explicit.
         • The participants of State design pattern are:
              •     Context class: Maintains an instance that defines the current
                   state of a ConcreteState class.
              •     State class: Encapsulates the behavior associated with a specific
                   state of context by defining an interface.
              •     ConcreteState1 class: Implements the behavior defined in the
                   State object.
              •     ConcreteState2 class: Implements the behavior defined in the
                   State object.




 ©NIIT                  Architecting J2EE Solutions        Lesson 3A / Slide 19 of 54
Behavioral and J2EE Design Patterns


Behavioral Design Patterns (Contd.)
    •    State Pattern (Contd.)
         • Class diagram of State design pattern




 ©NIIT                 Architecting J2EE Solutions   Lesson 3A / Slide 20 of 54
Behavioral and J2EE Design Patterns


Behavioral Design Patterns (Contd.)
    •    Strategy Pattern
         • The Strategy design pattern encapsulates the functionality of the
              subclasses of a common superclass.
         • The advantages of using Strategy design pattern are:
              • Providing an alternative to subclassing.
              • Enabling you to add new behavior without making changes in the
                   application.




 ©NIIT                 Architecting J2EE Solutions     Lesson 3A / Slide 21 of 54
Behavioral and J2EE Design Patterns


Behavioral Design Patterns (Contd.)
    •    Strategy Pattern (Contd.)
         • The participants of Strategy design pattern are:
              •     Context class: Keeps a reference to a Strategy object.
              •     Strategy abstract class: Declares a strategy interface that is
                   common to all algorithms, which support the interface.
              •     ConcreteStrategy1 class: Implements the algorithm that is
                   defined in the Strategy object.
              •     ConcreteStrategy2 class: Implements the algorithm that is
                   defined in the Strategy object.
              •     ConcreteStrategy3 class: Implements the algorithm that is
                   defined in the Strategy object.




 ©NIIT                  Architecting J2EE Solutions         Lesson 3A / Slide 22 of 54
Behavioral and J2EE Design Patterns


Behavioral Design Patterns (Contd.)
    •    Strategy Pattern (Contd.)
           • Class diagram of Strategy design pattern




 ©NIIT                   Architecting J2EE Solutions    Lesson 3A / Slide 23 of 54
Behavioral and J2EE Design Patterns

Behavioral Design Patterns (Contd.)
    •    Template Method Pattern
           • The Template Method design pattern defines the skeleton of a method
             deferring the implementation to the subclasses.
           • The advantages of using the Template Method design pattern are:
               • Allows code reusability.
               • Allows you to define the structure of an algorithm and force the
                  subclass to provide the implementation.
           • The participants of Template Method design pattern are:
               • Abstract Class: Declares abstract operations that are implemented
                  by Concrete classes.
               • Concrete Class: Implements the abstract operations to provide
                  subclass specific functionality.




 ©NIIT                   Architecting J2EE Solutions      Lesson 3A / Slide 24 of 54
Behavioral and J2EE Design Patterns


Behavioral Design Patterns (Contd.)
    •    Template Method Pattern (Contd.)
          • Class diagram of Template Method design pattern




 ©NIIT                Architecting J2EE Solutions    Lesson 3A / Slide 25 of 54
Behavioral and J2EE Design Patterns


Behavioral Design Patterns (Contd.)
    •    Visitor Pattern
         • The Visitor design pattern defines an operation, which is executed on
               the elements of other classes.
         • The advantages of using the Visitor design pattern are:
               • Separates the related operations from the unrelated operations.
               • Enables you to add new operations.




 ©NIIT                 Architecting J2EE Solutions       Lesson 3A / Slide 26 of 54
Behavioral and J2EE Design Patterns


Behavioral Design Patterns (Contd.)
    •    Visitor Pattern (Contd.)
         • The participants of Visitor design pattern are:
               •     Visitor abstract class: Declares the methods that are
                    implemented by ConcreteVisitor1 and ConcreteVisitor2
                    classes.
               •     ConcreteVisitor1 class: Implements all the operations declared
                    by the Visitor class.
               •     ConcreteVisitor2 class: Implements all the operations declared
                    by the Visitor class.
               •     ObjectStructure class: Provides a higher-level interface allowing
                    the visitor to visit its elements.
               •     Element abstract class: Defines an operation to accept the
                    Visitor object.




 ©NIIT                  Architecting J2EE Solutions         Lesson 3A / Slide 27 of 54
Behavioral and J2EE Design Patterns


Behavioral Design Patterns (Contd.)
    •    Visitor Pattern (Contd.)
         • Class diagram of Visitor design pattern




 ©NIIT                 Architecting J2EE Solutions   Lesson 3A / Slide 28 of 54
Behavioral and J2EE Design Patterns


Demonstration-Identifying Behavioral
  Design Patterns

    •    Problem Statement
         • In an online shopping portal, the sales manager frequently
             announces various schemes and discounts. The sales manager
             segregates the information of different kind of customers on the
             basis of age group, income group, location, and gender. The
             sales manager is also responsible for enabling and disabling the
             schemes and discounts. The shopping portal always provides
             special discount to its privileged customers. While shopping, the
             customer can stop shopping at any instance of time. Later on,
             the customer can restart shopping from the point he has left
             shopping. Identify the behavioral design pattern that can be
             applied on the given scenario.



 ©NIIT                Architecting J2EE Solutions     Lesson 3A / Slide 29 of 54
Behavioral and J2EE Design Patterns


Demonstration-Identifying Behavioral
  Design Patterns (Contd.)
    •    Solution
         • To solve the preceding problem, perform the following tasks:
              1.  Identify the Chain of Responsibility design pattern.
              2.  Identify the Command design pattern.
              3.  Identify the Interpreter design pattern.
              4.  Identify the State design pattern.
              5.  Identify the Mediator design pattern.
              6.  Identify the Memento design pattern.




 ©NIIT                Architecting J2EE Solutions   Lesson 3A / Slide 30 of 54
Behavioral and J2EE Design Patterns


J2EE Design Patterns
    •    A pattern is defined as a recurring problem and its solution in context to
         share the knowledge among different users.
    •    Context is defined as an environment in which a problem occurs.
    •    A problem is defined as a query that needs to be explored and answered in a
         given environment .
    •    Solution is defined as a response to the query that resolves the problem.
    •    A J2EE pattern is defined as a group of J2EE-based problems and its
         solutions.
    •    The J2EE design patterns are categorized into different tiers that build up an
         enterprise application:
         • Presentation tier
         • Business tier
         • Integration tier


 ©NIIT                  Architecting J2EE Solutions         Lesson 3A / Slide 31 of 54
Behavioral and J2EE Design Patterns


J2EE Design Patterns (Contd.)
    •    Presentation Tier
         • A presentation tier contains the logic that is required for presenting the
              information to an end user.
         • The major role of the presentation tier is to intercept the client
              requests, restrict the access to business services, and send the
              response back to clients.
         • The various patterns available in the presentation tier are:
              • Intercepting Filter
              • Front Controller
              • Context Object
              • Application Controller
              • View Helper
              • Composite View
              • Service to Worker
              • Dispatcher View
 ©NIIT                  Architecting J2EE Solutions       Lesson 3A / Slide 32 of 54
Behavioral and J2EE Design Patterns


J2EE Design Patterns (Contd.)
    •    Intercepting Filter Pattern
         • The Intercepting Filter design pattern is used to preprocess and post
              process a client request.
         • The advantages of using the Intercepting Filter design pattern are:
              • Centralizes control for managing processing across various client
                   requests.
              • Provides reusability by adding or removing the pluggable
                   interceptors from an existing code and using them for creating
                   different presentations.
         • This design pattern creates pluggable filters to process these
              preprocessing and post processing services.
         • The servlet filters for Hypertext Transfer Protocol (HTTP) requests or
              responses and message handlers for Simple Object Access Protocol
              (SOAP) requests or responses are the examples that implement the
              Intercepting Filter design pattern.


 ©NIIT                 Architecting J2EE Solutions      Lesson 3A / Slide 33 of 54
Behavioral and J2EE Design Patterns


J2EE Design Patterns (Contd.)
    •    Front Controller Pattern
         • The Front Controller design pattern manages the client requests using a
              centralized controller.
         • The advantages of using the Front Controller design pattern are:
              • Centralizes control for managing control logic across multiple
                   requests.
              • Provides reusability by transferring the code that needs to be
                   common among applications to a controller and allowing the
                   access to the code.




 ©NIIT                 Architecting J2EE Solutions      Lesson 3A / Slide 34 of 54
Behavioral and J2EE Design Patterns


J2EE Design Patterns (Contd.)
    •    Context Object Pattern
         • The Context Object design pattern encapsulates the data in a context
             object.
         • The advantages of using the Context Object design pattern are:
             • Improving the process of testing by eliminating the protocol-
                  specific code that binds a Web server or an application server with
                  a container.
             • Providing reusability of application components among various
                  clients by eliminating the protocol-specific data types.




 ©NIIT                  Architecting J2EE Solutions       Lesson 3A / Slide 35 of 54
Behavioral and J2EE Design Patterns


J2EE Design Patterns (Contd.)
    •    Application Controller Pattern
         • The Application Controller design pattern integrates and modularizes
              action management and view management along with a front controller.
         • The advantages of using the Application Controller design pattern are:
              • Providing reusability and modularity by categorizing the code into
                   action management and view management.
              • Reducing the coupling between the code that enables the rules to
                   be modified without modifying the code.




 ©NIIT                 Architecting J2EE Solutions      Lesson 3A / Slide 36 of 54
Behavioral and J2EE Design Patterns


J2EE Design Patterns (Contd.)
    •    View Helper Pattern
         • The View Helper design pattern enables a view to perform tasks that
              are not related with the presentation of the view.
         • Programming logic is responsible for formatting and presenting the
              output.
         • The advantages of using the View Helper design pattern are:
              • Developing modularity in an application by detaching HTML from
                   the processing logic, such as business logic and control logic.
              • Reducing the need of incorporating implementation details in code
                   by separating the HTML code from the processing logic.




 ©NIIT                 Architecting J2EE Solutions       Lesson 3A / Slide 37 of 54
Behavioral and J2EE Design Patterns


J2EE Design Patterns (Contd.)
    •    Composite View Pattern
         • A view represents the information to clients.
         • An atomic portion of a composite whole is known as a subview or a view
            segment.
         • A composite view is composed of multiple views.
         • The Composite View design pattern creates a flexible presentation that
            enables personalization and customization of views by grouping
            together sub views.
         • The advantages of using the Composite View design pattern are:
            • Providing modularity and reusability by dividing a template into
                  various subviews and reusing them.
            • Incorporating role-based and policy-based controls, such as user
                  role or security policy in an application.




 ©NIIT                 Architecting J2EE Solutions      Lesson 3A / Slide 38 of 54
Behavioral and J2EE Design Patterns


J2EE Design Patterns (Contd.)
    •    Service to Worker Pattern
         • The Service to Worker design pattern consists of a combination of front
              controller, view helper, and dispatcher components.
         • The advantages of using the Service to Worker design pattern are:
              • Providing reusability by incorporating the request-handling logic
                   within a view.
              • Improving maintainability by making the changes at a centralized
                   location.




 ©NIIT                 Architecting J2EE Solutions       Lesson 3A / Slide 39 of 54
Behavioral and J2EE Design Patterns


J2EE Design Patterns (Contd.)
    •    Dispatcher View Pattern
         • The Dispatcher View design pattern is similar to the Service to Worker
              design pattern and consists of a combination of front controller, view
              helper, and dispatcher components.
         • The advantages of using the Dispatcher View design pattern are:
              • Providing support for standard and custom libraries that enable
                   you to use data access tags, transformers, and view adapters.
              • Improving reusability by separating the processing logic from the
                   view that reduces the need of implementation in code.




 ©NIIT                 Architecting J2EE Solutions        Lesson 3A / Slide 40 of 54
Behavioral and J2EE Design Patterns


J2EE Design Patterns (Contd.)
    •    Business Tier
         • The business tier provides various business services, such as business
              data and business logic required by an application client in an enterprise
              application.
         • The various patterns available in the business tier are:
              • Business Delegate
              • Service Locator
              • Session Facade
              • Application Service
              • Business Object
              • Composite Entity
              • Transfer Object
              • Transfer Object Assembler
              • Value List Handler

 ©NIIT                  Architecting J2EE Solutions         Lesson 3A / Slide 41 of 54
Behavioral and J2EE Design Patterns


J2EE Design Patterns (Contd.)
    •    Business Delegate Pattern
         • The Business Delegate design pattern extracts and hides the details
              required in implementing business services at client-side.
         • A business service encapsulates the business logic and business state.
         • The advantages of using the Business Delegate design pattern are:
              • Reducing coupling by hiding the details of the business services,
                   such as naming and lookup mechanisms.
              • Improving the performance of request services by caching the data
                   for presentation tier.




 ©NIIT                 Architecting J2EE Solutions      Lesson 3A / Slide 42 of 54
Behavioral and J2EE Design Patterns


J2EE Design Patterns (Contd.)
    •    Service Locator Pattern
         • The Service Locator design pattern is used by the Business Delegate
              design pattern to trace the business services.
         • The Service Locator design pattern locates the business services by
              hiding the implementation details of the business services components.
         • The advantages of using Service Locator design pattern are:
              • Improving the network performance by eliminating the need of
                   creating and locating an object.
              • Providing a centralized control and improving the performance of
                   the system through caching.




 ©NIIT                  Architecting J2EE Solutions       Lesson 3A / Slide 43 of 54
Behavioral and J2EE Design Patterns


J2EE Design Patterns (Contd.)
    •    Session Facade Pattern
         • The Session Facade design pattern is used when a client wants to
              retrieve data from the server.
         • This design pattern provides a remote reference layer, which exposes
              the required interfaces to be used by the clients.
         • The advantages of using the Session Facade design pattern are:
              • Centralizing security management by managing security policies at
                    the client-end.
              • Improving flexibility by introducing a layer between clients and
                    business tier to provide remote services to multiple clients.




 ©NIIT                 Architecting J2EE Solutions      Lesson 3A / Slide 44 of 54
Behavioral and J2EE Design Patterns


J2EE Design Patterns (Contd.)
    •    Application Service Pattern
         • The Application Service design pattern provides a uniform service layer
              that implements business logic by hiding the complexity of business
              services.
         • The advantages of using the Application Service design pattern are:
              • Avoiding the duplication of code by introducing a reusable business
                   logic layer.
              • Improving the reusability of business logic by creating a set of
                   components that you can reuse across various use case
                   implementations. A use case implementation determines the
                   operations that a system performs.




 ©NIIT                 Architecting J2EE Solutions       Lesson 3A / Slide 45 of 54
Behavioral and J2EE Design Patterns


J2EE Design Patterns (Contd.)
    •    Business Object Pattern
         • The Business Object design pattern preserves the business data and
              implements actions that are common to an enterprise application.
         • The basic role of a business object is to represent the state and
              behavior of information associated with business.
         • The advantages of using the Business Object design pattern are:
              • Providing a centralized and modular approach to multi-tier
                   components by implementing the rules and behavior of business
                   logic as separate components.
              • Improving the maintainability of system by providing the
                   reusability and centralization of code.




 ©NIIT                 Architecting J2EE Solutions       Lesson 3A / Slide 46 of 54
Behavioral and J2EE Design Patterns


J2EE Design Patterns (Contd.)
    •    Transfer Object Pattern
         • The Transfer Object design pattern is used to carry multiple data
              elements required by a request or a response in a single structure
              across a tier.
         • A transfer object is passed by value to a client and all the operations
              are performed on duplicate copies of the transfer object.
         • The advantages of using the Transfer Object design pattern are:
              • Transmitting data of multiple clients over the network using a
                   single method call thereby reducing the network traffic.
              • Reducing the duplication of code between an entity and its transfer
                   object.




 ©NIIT                 Architecting J2EE Solutions       Lesson 3A / Slide 47 of 54
Behavioral and J2EE Design Patterns


J2EE Design Patterns (Contd.)
    •    Transfer Object Assembler Pattern
         • The Transfer Object Assembler design pattern is used to create complex
              transfer objects from session beans and entity beans.
         • This design pattern is used to retrieve transfer objects from the
              business components.
         • The advantages of using the Transfer Object Assembler design pattern
              are:
              • Reducing the coupling between the clients and the application
                   model.
              • Improving the client performance by creating the model without
                   using any client resources.




 ©NIIT                 Architecting J2EE Solutions      Lesson 3A / Slide 48 of 54
Behavioral and J2EE Design Patterns


J2EE Design Patterns (Contd.)
    •    Value List Handler Pattern
         • The Value List Handler design pattern accesses the persistent data
              store, such as RDBMS at request time to provide a set of dynamically
              created transfer objects.
         • The advantages of using the Value List Handler design pattern are:
              • Improving the network performance by sending only the required
                    result set instead of sending the whole result set that increases
                    unnecessary network traffic. A result set represents the results
                    obtained while executing a query.
              • Improving the transaction management by caching the results on
                    the server side.




 ©NIIT                  Architecting J2EE Solutions         Lesson 3A / Slide 49 of 54
Behavioral and J2EE Design Patterns


J2EE Design Patterns (Contd.)
    •    Integration Tier
         • The integration tier communicates with the external resources, such as
              data stores and applications.
         • When a business object needs data or services that exist in the resource
              tier, the business tier integrates with the integration tier to perform
              these services.
         • A resource tier contains the business data and the required services.
         • The integration tier uses JDBC and J2EE connector technologies to work
              with the resource tier.
         • The various patterns available in the integration tier are:
              • Data Access Object
              • Service Activator



 ©NIIT                  Architecting J2EE Solutions       Lesson 3A / Slide 50 of 54
Behavioral and J2EE Design Patterns


J2EE Design Patterns (Contd.)
    •    Data Access Object Pattern
         • The Data Access Object design pattern provides transparent access to
              the persistent store in order to retrieve and store data.
         • This design pattern contains a data access object, which does not cache
              the result of executing a query that a client can need at a later stage.
         • The advantages of using the Data Access Object design pattern are:
              • Reducing complexity of data access client code by encapsulating
                   the code required interacting with the persistent storage.
              • Enabling an application to easily migrate to a different database
                   implementation.




 ©NIIT                  Architecting J2EE Solutions        Lesson 3A / Slide 51 of 54
Behavioral and J2EE Design Patterns


J2EE Design Patterns (Contd.)
    •    Service Activator Pattern
         • The Service Activator design pattern enables you to receive messages
              and perform asynchronous processing with EJB components, such as
              session beans.
         • The advantages of using the Service Activator design pattern are:
              • Integrating JMS into enterprise applications to provide
                   asynchronous processing capabilities for any business-tier
                   component.
              • Providing a standalone JMS listener that can run without using a
                   container.




 ©NIIT                 Architecting J2EE Solutions       Lesson 3A / Slide 52 of 54
Behavioral and J2EE Design Patterns


Summary
    In this lesson, you learned:
         • The behavioral design pattern, defines the state, behavior, and
               communication among the objects.
         • The various behavioral design patterns are Chain of Responsibility,
               Command, Interpreter, Iterator, Mediator, Memento, Observer, State,
               Strategy, Template Method, and Visitor.
         • The behavioral design patterns are concerned with how an object
               behaves.
         • A J2EE pattern is defined as a group of J2EE-based problems and its
               solutions. The J2EE patterns are categorized into different tiers that
               build up an application:
               • Presentation tier
               • Business tier
               • Integration tier

 ©NIIT                  Architecting J2EE Solutions       Lesson 3A / Slide 53 of 54
Behavioral and J2EE Design Patterns


Summary (Contd.)
    •    The various presentation tier design patterns are Intercepting Filter, Front
         Controller, Context Object, Application Controller, View Helper, Composite
         View, Service to Worker, and Dispatcher View.
    •    The business tier provides various business services, such as business data
         and business logic required by an application client in an enterprise
         application.
    •    The various business tier design patterns are Business Delegate, Service
         Locator, Session Facade, Application Service, Business Object, Transfer
         Object, Transfer Object Assembler, and Value List Handler.
    •    The various integration tier design patterns are Data Access Object and
         Service Activator.




 ©NIIT                  Architecting J2EE Solutions         Lesson 3A / Slide 54 of 54

More Related Content

What's hot

Vb net xp_10
Vb net xp_10Vb net xp_10
Vb net xp_10
Niit Care
 
4 - Architetture Software - Architecture Portfolio
4 - Architetture Software - Architecture Portfolio4 - Architetture Software - Architecture Portfolio
4 - Architetture Software - Architecture Portfolio
Majong DevJfu
 
2 - Architetture Software - Software architecture
2 - Architetture Software - Software architecture2 - Architetture Software - Software architecture
2 - Architetture Software - Software architecture
Majong DevJfu
 
8 - Architetture Software - Architecture centric processes
8 - Architetture Software - Architecture centric processes8 - Architetture Software - Architecture centric processes
8 - Architetture Software - Architecture centric processes
Majong DevJfu
 
3 f6 8_databases
3 f6 8_databases3 f6 8_databases
3 f6 8_databases
op205
 
3 f6 9_distributed_systems
3 f6 9_distributed_systems3 f6 9_distributed_systems
3 f6 9_distributed_systems
op205
 
Object and method exploration for embedded systems
Object and method exploration for embedded systemsObject and method exploration for embedded systems
Object and method exploration for embedded systems
Mr. Chanuwan
 
Java session01
Java session01Java session01
Java session01
Niit Care
 
How to Design Frameworks
How to Design FrameworksHow to Design Frameworks
How to Design Frameworks
elliando dias
 

What's hot (20)

Dacj 1-2 b
Dacj 1-2 bDacj 1-2 b
Dacj 1-2 b
 
Dacj 4 1-a
Dacj 4 1-aDacj 4 1-a
Dacj 4 1-a
 
Vb net xp_10
Vb net xp_10Vb net xp_10
Vb net xp_10
 
05 architectural design
05 architectural design05 architectural design
05 architectural design
 
08 component level_design
08 component level_design08 component level_design
08 component level_design
 
4 - Architetture Software - Architecture Portfolio
4 - Architetture Software - Architecture Portfolio4 - Architetture Software - Architecture Portfolio
4 - Architetture Software - Architecture Portfolio
 
2 - Architetture Software - Software architecture
2 - Architetture Software - Software architecture2 - Architetture Software - Software architecture
2 - Architetture Software - Software architecture
 
Context-Oriented Programming
Context-Oriented ProgrammingContext-Oriented Programming
Context-Oriented Programming
 
8 - Architetture Software - Architecture centric processes
8 - Architetture Software - Architecture centric processes8 - Architetture Software - Architecture centric processes
8 - Architetture Software - Architecture centric processes
 
Software Architecture: Design Decisions
Software Architecture: Design DecisionsSoftware Architecture: Design Decisions
Software Architecture: Design Decisions
 
Mcq m4
Mcq m4Mcq m4
Mcq m4
 
Software Patterns
Software PatternsSoftware Patterns
Software Patterns
 
3 f6 8_databases
3 f6 8_databases3 f6 8_databases
3 f6 8_databases
 
3 f6 9_distributed_systems
3 f6 9_distributed_systems3 f6 9_distributed_systems
3 f6 9_distributed_systems
 
Introducing MDSD
Introducing MDSDIntroducing MDSD
Introducing MDSD
 
Pitfalls of software product development
Pitfalls of software product developmentPitfalls of software product development
Pitfalls of software product development
 
Object and method exploration for embedded systems
Object and method exploration for embedded systemsObject and method exploration for embedded systems
Object and method exploration for embedded systems
 
Java session01
Java session01Java session01
Java session01
 
Software design
Software designSoftware design
Software design
 
How to Design Frameworks
How to Design FrameworksHow to Design Frameworks
How to Design Frameworks
 

Viewers also liked (10)

Ajs 4 c
Ajs 4 cAjs 4 c
Ajs 4 c
 
Vb net xp_04
Vb net xp_04Vb net xp_04
Vb net xp_04
 
Database programming in vb net
Database programming in vb netDatabase programming in vb net
Database programming in vb net
 
01 asp.net session01
01 asp.net session0101 asp.net session01
01 asp.net session01
 
VISUAL BASIC .net data accesss vii
VISUAL BASIC .net data accesss viiVISUAL BASIC .net data accesss vii
VISUAL BASIC .net data accesss vii
 
Basic Database Testing
Basic Database TestingBasic Database Testing
Basic Database Testing
 
Asp.net
 Asp.net Asp.net
Asp.net
 
ASP.NET Presentation
ASP.NET PresentationASP.NET Presentation
ASP.NET Presentation
 
ASP.NET Tutorial - Presentation 1
ASP.NET Tutorial - Presentation 1ASP.NET Tutorial - Presentation 1
ASP.NET Tutorial - Presentation 1
 
State of the Word 2011
State of the Word 2011State of the Word 2011
State of the Word 2011
 

Similar to Ajs 3 a

Cse 6007 fall2012
Cse 6007 fall2012Cse 6007 fall2012
Cse 6007 fall2012
rhrashel
 
C# Design Patterns | Design Pattern Tutorial For Beginners | C# Programming T...
C# Design Patterns | Design Pattern Tutorial For Beginners | C# Programming T...C# Design Patterns | Design Pattern Tutorial For Beginners | C# Programming T...
C# Design Patterns | Design Pattern Tutorial For Beginners | C# Programming T...
Simplilearn
 
Design pattern in android
Design pattern in androidDesign pattern in android
Design pattern in android
Jay Kumarr
 
Cs 1023 lec 8 design pattern (week 2)
Cs 1023 lec 8 design pattern (week 2)Cs 1023 lec 8 design pattern (week 2)
Cs 1023 lec 8 design pattern (week 2)
stanbridge
 
SADP PPTs of all modules - Shanthi D.L.pdf
SADP PPTs of all modules - Shanthi D.L.pdfSADP PPTs of all modules - Shanthi D.L.pdf
SADP PPTs of all modules - Shanthi D.L.pdf
B.T.L.I.T
 

Similar to Ajs 3 a (20)

Ajs 1 a
Ajs 1 aAjs 1 a
Ajs 1 a
 
UNIT IV DESIGN PATTERNS.pptx
UNIT IV DESIGN PATTERNS.pptxUNIT IV DESIGN PATTERNS.pptx
UNIT IV DESIGN PATTERNS.pptx
 
Cse 6007 fall2012
Cse 6007 fall2012Cse 6007 fall2012
Cse 6007 fall2012
 
Design patterns tutorials
Design patterns tutorialsDesign patterns tutorials
Design patterns tutorials
 
Dacj 1-1 c
Dacj 1-1 cDacj 1-1 c
Dacj 1-1 c
 
Unit 5
Unit 5Unit 5
Unit 5
 
C# Design Patterns | Design Pattern Tutorial For Beginners | C# Programming T...
C# Design Patterns | Design Pattern Tutorial For Beginners | C# Programming T...C# Design Patterns | Design Pattern Tutorial For Beginners | C# Programming T...
C# Design Patterns | Design Pattern Tutorial For Beginners | C# Programming T...
 
Designpattern
DesignpatternDesignpattern
Designpattern
 
Design pattern in android
Design pattern in androidDesign pattern in android
Design pattern in android
 
Cs 1023 lec 8 design pattern (week 2)
Cs 1023 lec 8 design pattern (week 2)Cs 1023 lec 8 design pattern (week 2)
Cs 1023 lec 8 design pattern (week 2)
 
Design Concepts in Software Engineering-1.pptx
Design Concepts in Software Engineering-1.pptxDesign Concepts in Software Engineering-1.pptx
Design Concepts in Software Engineering-1.pptx
 
Architectural design
Architectural designArchitectural design
Architectural design
 
Design Patterns - General Introduction
Design Patterns - General IntroductionDesign Patterns - General Introduction
Design Patterns - General Introduction
 
Design patterns: Understand the patterns and design your own
Design patterns: Understand the patterns and design your ownDesign patterns: Understand the patterns and design your own
Design patterns: Understand the patterns and design your own
 
Software Design Patterns. Part I :: Structural Patterns
Software Design Patterns. Part I :: Structural PatternsSoftware Design Patterns. Part I :: Structural Patterns
Software Design Patterns. Part I :: Structural Patterns
 
Chapter 4_Introduction to Patterns.ppt
Chapter 4_Introduction to Patterns.pptChapter 4_Introduction to Patterns.ppt
Chapter 4_Introduction to Patterns.ppt
 
Chapter 4_Introduction to Patterns.ppt
Chapter 4_Introduction to Patterns.pptChapter 4_Introduction to Patterns.ppt
Chapter 4_Introduction to Patterns.ppt
 
Gof design pattern
Gof design patternGof design pattern
Gof design pattern
 
SADP PPTs of all modules - Shanthi D.L.pdf
SADP PPTs of all modules - Shanthi D.L.pdfSADP PPTs of all modules - Shanthi D.L.pdf
SADP PPTs of all modules - Shanthi D.L.pdf
 
Design Pattern in Software Engineering
Design Pattern in Software Engineering Design Pattern in Software Engineering
Design Pattern in Software Engineering
 

More from Niit Care

More from Niit Care (17)

Ajs 1 c
Ajs 1 cAjs 1 c
Ajs 1 c
 
Dacj 4 2-c
Dacj 4 2-cDacj 4 2-c
Dacj 4 2-c
 
Dacj 4 2-b
Dacj 4 2-bDacj 4 2-b
Dacj 4 2-b
 
Dacj 4 2-a
Dacj 4 2-aDacj 4 2-a
Dacj 4 2-a
 
Dacj 4 1-c
Dacj 4 1-cDacj 4 1-c
Dacj 4 1-c
 
Dacj 4 1-b
Dacj 4 1-bDacj 4 1-b
Dacj 4 1-b
 
Dacj 1-3 c
Dacj 1-3 cDacj 1-3 c
Dacj 1-3 c
 
Dacj 1-3 b
Dacj 1-3 bDacj 1-3 b
Dacj 1-3 b
 
Dacj 1-3 a
Dacj 1-3 aDacj 1-3 a
Dacj 1-3 a
 
Dacj 1-2 c
Dacj 1-2 cDacj 1-2 c
Dacj 1-2 c
 
Dacj 1-2 a
Dacj 1-2 aDacj 1-2 a
Dacj 1-2 a
 
Dacj 1-1 b
Dacj 1-1 bDacj 1-1 b
Dacj 1-1 b
 
Dacj 1-1 a
Dacj 1-1 aDacj 1-1 a
Dacj 1-1 a
 
Dacj 2-2 b
Dacj 2-2 bDacj 2-2 b
Dacj 2-2 b
 
Dacj 2-2 a
Dacj 2-2 aDacj 2-2 a
Dacj 2-2 a
 
Dacj 2-1 c
Dacj 2-1 cDacj 2-1 c
Dacj 2-1 c
 
Dacj 2-1 b
Dacj 2-1 bDacj 2-1 b
Dacj 2-1 b
 

Recently uploaded

Revolutionizing SAP® Processes with Automation and Artificial Intelligence
Revolutionizing SAP® Processes with Automation and Artificial IntelligenceRevolutionizing SAP® Processes with Automation and Artificial Intelligence
Revolutionizing SAP® Processes with Automation and Artificial Intelligence
Precisely
 
“Iamnobody89757” Understanding the Mysterious of Digital Identity.pdf
“Iamnobody89757” Understanding the Mysterious of Digital Identity.pdf“Iamnobody89757” Understanding the Mysterious of Digital Identity.pdf
“Iamnobody89757” Understanding the Mysterious of Digital Identity.pdf
Muhammad Subhan
 
Easier, Faster, and More Powerful – Alles Neu macht der Mai -Wir durchleuchte...
Easier, Faster, and More Powerful – Alles Neu macht der Mai -Wir durchleuchte...Easier, Faster, and More Powerful – Alles Neu macht der Mai -Wir durchleuchte...
Easier, Faster, and More Powerful – Alles Neu macht der Mai -Wir durchleuchte...
panagenda
 
Tales from a Passkey Provider Progress from Awareness to Implementation.pptx
Tales from a Passkey Provider  Progress from Awareness to Implementation.pptxTales from a Passkey Provider  Progress from Awareness to Implementation.pptx
Tales from a Passkey Provider Progress from Awareness to Implementation.pptx
FIDO Alliance
 
Harnessing Passkeys in the Battle Against AI-Powered Cyber Threats.pptx
Harnessing Passkeys in the Battle Against AI-Powered Cyber Threats.pptxHarnessing Passkeys in the Battle Against AI-Powered Cyber Threats.pptx
Harnessing Passkeys in the Battle Against AI-Powered Cyber Threats.pptx
FIDO Alliance
 

Recently uploaded (20)

Intro to Passkeys and the State of Passwordless.pptx
Intro to Passkeys and the State of Passwordless.pptxIntro to Passkeys and the State of Passwordless.pptx
Intro to Passkeys and the State of Passwordless.pptx
 
UiPath manufacturing technology benefits and AI overview
UiPath manufacturing technology benefits and AI overviewUiPath manufacturing technology benefits and AI overview
UiPath manufacturing technology benefits and AI overview
 
WebRTC and SIP not just audio and video @ OpenSIPS 2024
WebRTC and SIP not just audio and video @ OpenSIPS 2024WebRTC and SIP not just audio and video @ OpenSIPS 2024
WebRTC and SIP not just audio and video @ OpenSIPS 2024
 
Revolutionizing SAP® Processes with Automation and Artificial Intelligence
Revolutionizing SAP® Processes with Automation and Artificial IntelligenceRevolutionizing SAP® Processes with Automation and Artificial Intelligence
Revolutionizing SAP® Processes with Automation and Artificial Intelligence
 
“Iamnobody89757” Understanding the Mysterious of Digital Identity.pdf
“Iamnobody89757” Understanding the Mysterious of Digital Identity.pdf“Iamnobody89757” Understanding the Mysterious of Digital Identity.pdf
“Iamnobody89757” Understanding the Mysterious of Digital Identity.pdf
 
Easier, Faster, and More Powerful – Alles Neu macht der Mai -Wir durchleuchte...
Easier, Faster, and More Powerful – Alles Neu macht der Mai -Wir durchleuchte...Easier, Faster, and More Powerful – Alles Neu macht der Mai -Wir durchleuchte...
Easier, Faster, and More Powerful – Alles Neu macht der Mai -Wir durchleuchte...
 
AI mind or machine power point presentation
AI mind or machine power point presentationAI mind or machine power point presentation
AI mind or machine power point presentation
 
Tales from a Passkey Provider Progress from Awareness to Implementation.pptx
Tales from a Passkey Provider  Progress from Awareness to Implementation.pptxTales from a Passkey Provider  Progress from Awareness to Implementation.pptx
Tales from a Passkey Provider Progress from Awareness to Implementation.pptx
 
Observability Concepts EVERY Developer Should Know (DevOpsDays Seattle)
Observability Concepts EVERY Developer Should Know (DevOpsDays Seattle)Observability Concepts EVERY Developer Should Know (DevOpsDays Seattle)
Observability Concepts EVERY Developer Should Know (DevOpsDays Seattle)
 
TopCryptoSupers 12thReport OrionX May2024
TopCryptoSupers 12thReport OrionX May2024TopCryptoSupers 12thReport OrionX May2024
TopCryptoSupers 12thReport OrionX May2024
 
Design and Development of a Provenance Capture Platform for Data Science
Design and Development of a Provenance Capture Platform for Data ScienceDesign and Development of a Provenance Capture Platform for Data Science
Design and Development of a Provenance Capture Platform for Data Science
 
2024 May Patch Tuesday
2024 May Patch Tuesday2024 May Patch Tuesday
2024 May Patch Tuesday
 
Overview of Hyperledger Foundation
Overview of Hyperledger FoundationOverview of Hyperledger Foundation
Overview of Hyperledger Foundation
 
ERP Contender Series: Acumatica vs. Sage Intacct
ERP Contender Series: Acumatica vs. Sage IntacctERP Contender Series: Acumatica vs. Sage Intacct
ERP Contender Series: Acumatica vs. Sage Intacct
 
ADP Passwordless Journey Case Study.pptx
ADP Passwordless Journey Case Study.pptxADP Passwordless Journey Case Study.pptx
ADP Passwordless Journey Case Study.pptx
 
The Zero-ETL Approach: Enhancing Data Agility and Insight
The Zero-ETL Approach: Enhancing Data Agility and InsightThe Zero-ETL Approach: Enhancing Data Agility and Insight
The Zero-ETL Approach: Enhancing Data Agility and Insight
 
How we scaled to 80K users by doing nothing!.pdf
How we scaled to 80K users by doing nothing!.pdfHow we scaled to 80K users by doing nothing!.pdf
How we scaled to 80K users by doing nothing!.pdf
 
Event-Driven Architecture Masterclass: Challenges in Stream Processing
Event-Driven Architecture Masterclass: Challenges in Stream ProcessingEvent-Driven Architecture Masterclass: Challenges in Stream Processing
Event-Driven Architecture Masterclass: Challenges in Stream Processing
 
Harnessing Passkeys in the Battle Against AI-Powered Cyber Threats.pptx
Harnessing Passkeys in the Battle Against AI-Powered Cyber Threats.pptxHarnessing Passkeys in the Battle Against AI-Powered Cyber Threats.pptx
Harnessing Passkeys in the Battle Against AI-Powered Cyber Threats.pptx
 
Long journey of Ruby Standard library at RubyKaigi 2024
Long journey of Ruby Standard library at RubyKaigi 2024Long journey of Ruby Standard library at RubyKaigi 2024
Long journey of Ruby Standard library at RubyKaigi 2024
 

Ajs 3 a

  • 1. Behavioral and J2EE Design Patterns Pre-assessment Questions 1. Which structural design pattern separates the interface with its implementation? a) Adapter b) Bridge c) Composite d) Decorator 3. Which behavioral design pattern encapsulates a request as an object and enables the queuing and logging of requests? a) Template Method b) Visitor c) Strategy d) Command ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 1 of 54
  • 2. Behavioral and J2EE Design Patterns Pre-assessment Questions 1. Which statement defines a structural design pattern? a) Represents the composition of classes and objects. b) Defines the state, behavior, and communication among the objects. c) Provides separation between the sender and receiver of a request by introducing a number of objects between them. d) Provides a way to dynamically select the instantiation of an object and to return a clone of a prototypical object. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 2 of 54
  • 3. Behavioral and J2EE Design Patterns Pre-assessment Questions 1. Consider the statements: Statement A: Facade design pattern provides a unified interface to a collection of interfaces in a subsystem. Statement B: Facade pattern enables you to extend functionality of an object and dynamically provides additional responsibilities to an object. Identify the correct option. a) Statement A is true and statement B is false b) Statement A is false and statement B is true c) Both, statements A and B, are true d) Both, statements A and B, are false ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 3 of 54
  • 4. Behavioral and J2EE Design Patterns Pre-assessment Questions 2. Which design pattern composes objects into tree structures? a) Flyweight b) Composite c) Adaptor d) Proxy ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 4 of 54
  • 5. Behavioral and J2EE Design Patterns Solutions to Pre-assessment Questions 1. b. Bridge 2. d. Command 3. a. Represents the composition of classes and objects. 4. a. Statement A is true and statement B is false 5. b. Composite ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 5 of 54
  • 6. Behavioral and J2EE Design Patterns Objectives In this lesson you will learn to: • Use Behavioral design patterns • Identify J2EE design Patterns ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 6 of 54
  • 7. Behavioral and J2EE Design Patterns Behavioral Design Patterns • The behavioral design pattern defines the state, behavior, and communication among the objects. • The various behavioral design patterns are Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, and Visitor. • All these patterns are concerned with how an object behaves. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 7 of 54
  • 8. Behavioral and J2EE Design Patterns Behavioral Design Patterns (Contd.) • Interpreter Pattern • The Interpreter design pattern is used to interpret the grammar of a given language. • The advantages of using Interpreter design pattern are: • Makes it easy to change and extend the grammar. • Makes it simple to implement the grammar. • The participants of Interpreter design pattern are: • Context: Contains global information. • Client: Invokes methods on the Interpreter. • AbstractExpression abstract class : Declares abstract operations implemented by TerminalExpression class. • TerminalExpresssion class : Implements an operation to interpret a language for terminal symbols in the grammar. For example, ‘X’ in roman is a terminal symbol that represents “10”. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 8 of 54
  • 9. Behavioral and J2EE Design Patterns Behavioral Design Patterns (Contd.) • Interpreter Pattern (Contd.) • Class diagram of Interpreter design pattern ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 9 of 54
  • 10. Behavioral and J2EE Design Patterns Behavioral Design Patterns (Contd.) • Iterator Pattern • The Iterator design pattern allows you to access elements of a certain data structure in a sequential manner, without knowing the internal representation of the content. • The advantages of using Iterator design pattern are: • Provides different ways to iterate through a data structure. • Simplifies the retrieval of data from a collection. • The participants of Iterator design pattern are: • Aggregate abstract class: Defines an interface to create an Iterator object. • ConcreteAggregate class: Creates and returns an instance of ConcreteIterator object. • Iterator abstract class: Defines an interface for accessing elements of a data structure. • ConcreteIterator class: Implements the Iterator operation. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 10 of 54
  • 11. Behavioral and J2EE Design Patterns Behavioral Design Patterns (Contd.) • Iterator Pattern (Contd.) • Class diagram of Iterator design pattern ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 11 of 54
  • 12. Behavioral and J2EE Design Patterns Behavioral Design Patterns (Contd.) • Mediator Pattern • The Mediator design pattern defines an object, which is responsible for coordinating and controlling the change in state between objects of a group. • The advantages of using Mediator design pattern are: • Provides loose coupling among the objects of a group. • Centralizes the logic to manage interaction between the objects of a group. • Enables the objects of a group to avoid the logic required to communicate with each other. • The participants of Mediator design pattern are: • Mediator abstract class: Defines an interface for communication with other objects. • Colleague abstract class: An object that communicates with other objects using the Mediator. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 12 of 54
  • 13. Behavioral and J2EE Design Patterns Behavioral Design Patterns (Contd.) • Mediator Pattern (Contd.) • The participants of Mediator design pattern are (Contd.): • ConcreteMediator class : Implements Mediator behavior in order to provide communication between colleague objects. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 13 of 54
  • 14. Behavioral and J2EE Design Patterns Behavioral Design Patterns (Contd.) • Mediator Pattern (Contd.) • Class diagram of Mediator design pattern ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 14 of 54
  • 15. Behavioral and J2EE Design Patterns Behavioral Design Patterns (Contd.) • Memento Pattern • The Memento design pattern provides serialization of an object, so that the state of the object at various stages during the execution of a program can be saved. • The advantages of using the Memento design pattern are: • Restores the state of an object. • Conserves the encapsulation limitations of an object. • The participants of Memento design pattern are: • Originator class: Creates a Memento object by saving its current internal state. • Memento class: Stores the internal state of an Originator object. • Caretaker class : Maintains an object’s saved internal state. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 15 of 54
  • 16. Behavioral and J2EE Design Patterns Behavioral Design Patterns (Contd.) • Memento Pattern (Contd.) • Class diagram of Memento design pattern ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 16 of 54
  • 17. Behavioral and J2EE Design Patterns Behavioral Design Patterns (Contd.) • Observer Pattern • The Observer design pattern defines one to many relationships between subject and observer objects. • The advantages of using Observer design pattern are: • Provides support for publisher to subscriber type communication. • Provides decoupling between subject and observer in order to reuse them independently. • The participants of Observer design pattern are: • Subject abstract class: Provides an interface using which observers can keep track of its implementation object. • Observer abstract class: An object that updates itself according to the changes in subject. • ConcreteSubject class: Notifies its observers when its state changes. • ConcreteObserver class: Keeps its state consistent with the subject’s state. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 17 of 54
  • 18. Behavioral and J2EE Design Patterns Behavioral Design Patterns (Contd.) • Observer Pattern (Contd.) • Class diagram of Observer design pattern ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 18 of 54
  • 19. Behavioral and J2EE Design Patterns Behavioral Design Patterns (Contd.) • State Pattern • The State design pattern enables an object to change its behavior when the state of the object changes. • The advantage of using State design pattern is that the transition of state is made explicit. • The participants of State design pattern are: • Context class: Maintains an instance that defines the current state of a ConcreteState class. • State class: Encapsulates the behavior associated with a specific state of context by defining an interface. • ConcreteState1 class: Implements the behavior defined in the State object. • ConcreteState2 class: Implements the behavior defined in the State object. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 19 of 54
  • 20. Behavioral and J2EE Design Patterns Behavioral Design Patterns (Contd.) • State Pattern (Contd.) • Class diagram of State design pattern ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 20 of 54
  • 21. Behavioral and J2EE Design Patterns Behavioral Design Patterns (Contd.) • Strategy Pattern • The Strategy design pattern encapsulates the functionality of the subclasses of a common superclass. • The advantages of using Strategy design pattern are: • Providing an alternative to subclassing. • Enabling you to add new behavior without making changes in the application. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 21 of 54
  • 22. Behavioral and J2EE Design Patterns Behavioral Design Patterns (Contd.) • Strategy Pattern (Contd.) • The participants of Strategy design pattern are: • Context class: Keeps a reference to a Strategy object. • Strategy abstract class: Declares a strategy interface that is common to all algorithms, which support the interface. • ConcreteStrategy1 class: Implements the algorithm that is defined in the Strategy object. • ConcreteStrategy2 class: Implements the algorithm that is defined in the Strategy object. • ConcreteStrategy3 class: Implements the algorithm that is defined in the Strategy object. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 22 of 54
  • 23. Behavioral and J2EE Design Patterns Behavioral Design Patterns (Contd.) • Strategy Pattern (Contd.) • Class diagram of Strategy design pattern ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 23 of 54
  • 24. Behavioral and J2EE Design Patterns Behavioral Design Patterns (Contd.) • Template Method Pattern • The Template Method design pattern defines the skeleton of a method deferring the implementation to the subclasses. • The advantages of using the Template Method design pattern are: • Allows code reusability. • Allows you to define the structure of an algorithm and force the subclass to provide the implementation. • The participants of Template Method design pattern are: • Abstract Class: Declares abstract operations that are implemented by Concrete classes. • Concrete Class: Implements the abstract operations to provide subclass specific functionality. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 24 of 54
  • 25. Behavioral and J2EE Design Patterns Behavioral Design Patterns (Contd.) • Template Method Pattern (Contd.) • Class diagram of Template Method design pattern ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 25 of 54
  • 26. Behavioral and J2EE Design Patterns Behavioral Design Patterns (Contd.) • Visitor Pattern • The Visitor design pattern defines an operation, which is executed on the elements of other classes. • The advantages of using the Visitor design pattern are: • Separates the related operations from the unrelated operations. • Enables you to add new operations. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 26 of 54
  • 27. Behavioral and J2EE Design Patterns Behavioral Design Patterns (Contd.) • Visitor Pattern (Contd.) • The participants of Visitor design pattern are: • Visitor abstract class: Declares the methods that are implemented by ConcreteVisitor1 and ConcreteVisitor2 classes. • ConcreteVisitor1 class: Implements all the operations declared by the Visitor class. • ConcreteVisitor2 class: Implements all the operations declared by the Visitor class. • ObjectStructure class: Provides a higher-level interface allowing the visitor to visit its elements. • Element abstract class: Defines an operation to accept the Visitor object. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 27 of 54
  • 28. Behavioral and J2EE Design Patterns Behavioral Design Patterns (Contd.) • Visitor Pattern (Contd.) • Class diagram of Visitor design pattern ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 28 of 54
  • 29. Behavioral and J2EE Design Patterns Demonstration-Identifying Behavioral Design Patterns • Problem Statement • In an online shopping portal, the sales manager frequently announces various schemes and discounts. The sales manager segregates the information of different kind of customers on the basis of age group, income group, location, and gender. The sales manager is also responsible for enabling and disabling the schemes and discounts. The shopping portal always provides special discount to its privileged customers. While shopping, the customer can stop shopping at any instance of time. Later on, the customer can restart shopping from the point he has left shopping. Identify the behavioral design pattern that can be applied on the given scenario. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 29 of 54
  • 30. Behavioral and J2EE Design Patterns Demonstration-Identifying Behavioral Design Patterns (Contd.) • Solution • To solve the preceding problem, perform the following tasks: 1. Identify the Chain of Responsibility design pattern. 2. Identify the Command design pattern. 3. Identify the Interpreter design pattern. 4. Identify the State design pattern. 5. Identify the Mediator design pattern. 6. Identify the Memento design pattern. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 30 of 54
  • 31. Behavioral and J2EE Design Patterns J2EE Design Patterns • A pattern is defined as a recurring problem and its solution in context to share the knowledge among different users. • Context is defined as an environment in which a problem occurs. • A problem is defined as a query that needs to be explored and answered in a given environment . • Solution is defined as a response to the query that resolves the problem. • A J2EE pattern is defined as a group of J2EE-based problems and its solutions. • The J2EE design patterns are categorized into different tiers that build up an enterprise application: • Presentation tier • Business tier • Integration tier ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 31 of 54
  • 32. Behavioral and J2EE Design Patterns J2EE Design Patterns (Contd.) • Presentation Tier • A presentation tier contains the logic that is required for presenting the information to an end user. • The major role of the presentation tier is to intercept the client requests, restrict the access to business services, and send the response back to clients. • The various patterns available in the presentation tier are: • Intercepting Filter • Front Controller • Context Object • Application Controller • View Helper • Composite View • Service to Worker • Dispatcher View ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 32 of 54
  • 33. Behavioral and J2EE Design Patterns J2EE Design Patterns (Contd.) • Intercepting Filter Pattern • The Intercepting Filter design pattern is used to preprocess and post process a client request. • The advantages of using the Intercepting Filter design pattern are: • Centralizes control for managing processing across various client requests. • Provides reusability by adding or removing the pluggable interceptors from an existing code and using them for creating different presentations. • This design pattern creates pluggable filters to process these preprocessing and post processing services. • The servlet filters for Hypertext Transfer Protocol (HTTP) requests or responses and message handlers for Simple Object Access Protocol (SOAP) requests or responses are the examples that implement the Intercepting Filter design pattern. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 33 of 54
  • 34. Behavioral and J2EE Design Patterns J2EE Design Patterns (Contd.) • Front Controller Pattern • The Front Controller design pattern manages the client requests using a centralized controller. • The advantages of using the Front Controller design pattern are: • Centralizes control for managing control logic across multiple requests. • Provides reusability by transferring the code that needs to be common among applications to a controller and allowing the access to the code. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 34 of 54
  • 35. Behavioral and J2EE Design Patterns J2EE Design Patterns (Contd.) • Context Object Pattern • The Context Object design pattern encapsulates the data in a context object. • The advantages of using the Context Object design pattern are: • Improving the process of testing by eliminating the protocol- specific code that binds a Web server or an application server with a container. • Providing reusability of application components among various clients by eliminating the protocol-specific data types. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 35 of 54
  • 36. Behavioral and J2EE Design Patterns J2EE Design Patterns (Contd.) • Application Controller Pattern • The Application Controller design pattern integrates and modularizes action management and view management along with a front controller. • The advantages of using the Application Controller design pattern are: • Providing reusability and modularity by categorizing the code into action management and view management. • Reducing the coupling between the code that enables the rules to be modified without modifying the code. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 36 of 54
  • 37. Behavioral and J2EE Design Patterns J2EE Design Patterns (Contd.) • View Helper Pattern • The View Helper design pattern enables a view to perform tasks that are not related with the presentation of the view. • Programming logic is responsible for formatting and presenting the output. • The advantages of using the View Helper design pattern are: • Developing modularity in an application by detaching HTML from the processing logic, such as business logic and control logic. • Reducing the need of incorporating implementation details in code by separating the HTML code from the processing logic. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 37 of 54
  • 38. Behavioral and J2EE Design Patterns J2EE Design Patterns (Contd.) • Composite View Pattern • A view represents the information to clients. • An atomic portion of a composite whole is known as a subview or a view segment. • A composite view is composed of multiple views. • The Composite View design pattern creates a flexible presentation that enables personalization and customization of views by grouping together sub views. • The advantages of using the Composite View design pattern are: • Providing modularity and reusability by dividing a template into various subviews and reusing them. • Incorporating role-based and policy-based controls, such as user role or security policy in an application. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 38 of 54
  • 39. Behavioral and J2EE Design Patterns J2EE Design Patterns (Contd.) • Service to Worker Pattern • The Service to Worker design pattern consists of a combination of front controller, view helper, and dispatcher components. • The advantages of using the Service to Worker design pattern are: • Providing reusability by incorporating the request-handling logic within a view. • Improving maintainability by making the changes at a centralized location. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 39 of 54
  • 40. Behavioral and J2EE Design Patterns J2EE Design Patterns (Contd.) • Dispatcher View Pattern • The Dispatcher View design pattern is similar to the Service to Worker design pattern and consists of a combination of front controller, view helper, and dispatcher components. • The advantages of using the Dispatcher View design pattern are: • Providing support for standard and custom libraries that enable you to use data access tags, transformers, and view adapters. • Improving reusability by separating the processing logic from the view that reduces the need of implementation in code. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 40 of 54
  • 41. Behavioral and J2EE Design Patterns J2EE Design Patterns (Contd.) • Business Tier • The business tier provides various business services, such as business data and business logic required by an application client in an enterprise application. • The various patterns available in the business tier are: • Business Delegate • Service Locator • Session Facade • Application Service • Business Object • Composite Entity • Transfer Object • Transfer Object Assembler • Value List Handler ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 41 of 54
  • 42. Behavioral and J2EE Design Patterns J2EE Design Patterns (Contd.) • Business Delegate Pattern • The Business Delegate design pattern extracts and hides the details required in implementing business services at client-side. • A business service encapsulates the business logic and business state. • The advantages of using the Business Delegate design pattern are: • Reducing coupling by hiding the details of the business services, such as naming and lookup mechanisms. • Improving the performance of request services by caching the data for presentation tier. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 42 of 54
  • 43. Behavioral and J2EE Design Patterns J2EE Design Patterns (Contd.) • Service Locator Pattern • The Service Locator design pattern is used by the Business Delegate design pattern to trace the business services. • The Service Locator design pattern locates the business services by hiding the implementation details of the business services components. • The advantages of using Service Locator design pattern are: • Improving the network performance by eliminating the need of creating and locating an object. • Providing a centralized control and improving the performance of the system through caching. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 43 of 54
  • 44. Behavioral and J2EE Design Patterns J2EE Design Patterns (Contd.) • Session Facade Pattern • The Session Facade design pattern is used when a client wants to retrieve data from the server. • This design pattern provides a remote reference layer, which exposes the required interfaces to be used by the clients. • The advantages of using the Session Facade design pattern are: • Centralizing security management by managing security policies at the client-end. • Improving flexibility by introducing a layer between clients and business tier to provide remote services to multiple clients. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 44 of 54
  • 45. Behavioral and J2EE Design Patterns J2EE Design Patterns (Contd.) • Application Service Pattern • The Application Service design pattern provides a uniform service layer that implements business logic by hiding the complexity of business services. • The advantages of using the Application Service design pattern are: • Avoiding the duplication of code by introducing a reusable business logic layer. • Improving the reusability of business logic by creating a set of components that you can reuse across various use case implementations. A use case implementation determines the operations that a system performs. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 45 of 54
  • 46. Behavioral and J2EE Design Patterns J2EE Design Patterns (Contd.) • Business Object Pattern • The Business Object design pattern preserves the business data and implements actions that are common to an enterprise application. • The basic role of a business object is to represent the state and behavior of information associated with business. • The advantages of using the Business Object design pattern are: • Providing a centralized and modular approach to multi-tier components by implementing the rules and behavior of business logic as separate components. • Improving the maintainability of system by providing the reusability and centralization of code. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 46 of 54
  • 47. Behavioral and J2EE Design Patterns J2EE Design Patterns (Contd.) • Transfer Object Pattern • The Transfer Object design pattern is used to carry multiple data elements required by a request or a response in a single structure across a tier. • A transfer object is passed by value to a client and all the operations are performed on duplicate copies of the transfer object. • The advantages of using the Transfer Object design pattern are: • Transmitting data of multiple clients over the network using a single method call thereby reducing the network traffic. • Reducing the duplication of code between an entity and its transfer object. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 47 of 54
  • 48. Behavioral and J2EE Design Patterns J2EE Design Patterns (Contd.) • Transfer Object Assembler Pattern • The Transfer Object Assembler design pattern is used to create complex transfer objects from session beans and entity beans. • This design pattern is used to retrieve transfer objects from the business components. • The advantages of using the Transfer Object Assembler design pattern are: • Reducing the coupling between the clients and the application model. • Improving the client performance by creating the model without using any client resources. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 48 of 54
  • 49. Behavioral and J2EE Design Patterns J2EE Design Patterns (Contd.) • Value List Handler Pattern • The Value List Handler design pattern accesses the persistent data store, such as RDBMS at request time to provide a set of dynamically created transfer objects. • The advantages of using the Value List Handler design pattern are: • Improving the network performance by sending only the required result set instead of sending the whole result set that increases unnecessary network traffic. A result set represents the results obtained while executing a query. • Improving the transaction management by caching the results on the server side. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 49 of 54
  • 50. Behavioral and J2EE Design Patterns J2EE Design Patterns (Contd.) • Integration Tier • The integration tier communicates with the external resources, such as data stores and applications. • When a business object needs data or services that exist in the resource tier, the business tier integrates with the integration tier to perform these services. • A resource tier contains the business data and the required services. • The integration tier uses JDBC and J2EE connector technologies to work with the resource tier. • The various patterns available in the integration tier are: • Data Access Object • Service Activator ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 50 of 54
  • 51. Behavioral and J2EE Design Patterns J2EE Design Patterns (Contd.) • Data Access Object Pattern • The Data Access Object design pattern provides transparent access to the persistent store in order to retrieve and store data. • This design pattern contains a data access object, which does not cache the result of executing a query that a client can need at a later stage. • The advantages of using the Data Access Object design pattern are: • Reducing complexity of data access client code by encapsulating the code required interacting with the persistent storage. • Enabling an application to easily migrate to a different database implementation. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 51 of 54
  • 52. Behavioral and J2EE Design Patterns J2EE Design Patterns (Contd.) • Service Activator Pattern • The Service Activator design pattern enables you to receive messages and perform asynchronous processing with EJB components, such as session beans. • The advantages of using the Service Activator design pattern are: • Integrating JMS into enterprise applications to provide asynchronous processing capabilities for any business-tier component. • Providing a standalone JMS listener that can run without using a container. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 52 of 54
  • 53. Behavioral and J2EE Design Patterns Summary In this lesson, you learned: • The behavioral design pattern, defines the state, behavior, and communication among the objects. • The various behavioral design patterns are Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, and Visitor. • The behavioral design patterns are concerned with how an object behaves. • A J2EE pattern is defined as a group of J2EE-based problems and its solutions. The J2EE patterns are categorized into different tiers that build up an application: • Presentation tier • Business tier • Integration tier ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 53 of 54
  • 54. Behavioral and J2EE Design Patterns Summary (Contd.) • The various presentation tier design patterns are Intercepting Filter, Front Controller, Context Object, Application Controller, View Helper, Composite View, Service to Worker, and Dispatcher View. • The business tier provides various business services, such as business data and business logic required by an application client in an enterprise application. • The various business tier design patterns are Business Delegate, Service Locator, Session Facade, Application Service, Business Object, Transfer Object, Transfer Object Assembler, and Value List Handler. • The various integration tier design patterns are Data Access Object and Service Activator. ©NIIT Architecting J2EE Solutions Lesson 3A / Slide 54 of 54