Upload
crishantha-nanayakkara
View
331
Download
4
Tags:
Embed Size (px)
DESCRIPTION
Enterprise Application Design Patterns
Citation preview
ICTA Technology Meetup 06ICTA Technology Meetup 06
Enterprise ApplicationDesign Patterns
(Part 01)
By Crishantha Nanayakkara
2
AgendaEnterprise Design Patterns – An Introduction
Enterprise Design Pattern Catalogs
Gang Of Four (GOF) Patterns
What Next? Enterprise Application Architecture Design Patterns
3
Design PatternsDesign PatternsAn IntroductionAn Introduction
4
5
● “The gap between the best software engineering practice and the average practice is very wide – perhaps wider than the other engineering ”
– Fred Brooks (A famous author, ACM award winner)
6
What is a Pattern?
This means, a This means, a Design PatternDesign Pattern gives you a solution to a gives you a solution to a common common recurringrecurring design problem design problem
However,However,
The Design Patterns are not meant to be laws or rules; The Design Patterns are not meant to be laws or rules; they are just guidelines that you can even alter to fit to they are just guidelines that you can even alter to fit to your needsyour needs
7
How to create your own design pattern?
● Firstly, get the complete design pattern catalog and get familiar with them
● If you find a new pattern, then apply,
The Rule of ThreePattern can be called a pattern if it has been applied in real
world solution by at least three times
8
OO vs Design Patterns
● Knowing the OO basics (abstraction, encapsulation, inheritance, polymorphism) will not make you a good designer!!!
Oh!!!What should
I do then?
9
OO vs Design Patterns
● Patterns show you how to build systems with good OO design qualities
● Patterns do not give you code. They give general solutions to design problems
● Patterns are not invented they are discovered
10
Are patterns always great?● NO
– Patterns are a tool, which only be used when it is needed
– Heavy use of patterns will lead to complexity
– Design patterns can be used as a shared vocabulary for communicating the design to others irrespective of the programming language
11
What are anti-patterns?● If a design pattern gives you a general
solution to a recurring problem in a particular context then what does an anti-pattern give u?– An anti-pattern tells you how to go from a
problem to a BAD solution
● Why worry about finding anti-patterns?– To prevent other developers from making the
same mistake
12
(Reference: as3dp.com)
13
Enterprise Design Enterprise Design Pattern CatalogsPattern Catalogs
14
GOF Design Patterns
Enterprise Application ArchitectureDesign Patterns
Enterprise Integration Design Patterns
SOA Patterns
Cloud Patterns
Security Patterns
15
What are Pattern Catalogs?The much formal way of specifying pattern descriptionsThe much formal way of specifying pattern descriptions
The first and the The first and the most definite most definite Fundamental Design Pattern Design Pattern Catalog is Catalog is GOFGOF
(There are 23 (There are 23 fundamental fundamental patterns in it!!)patterns in it!!)
Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley, 1995)
16
Gang of Four (GOF) Design Patterns Catalog
17
Enterprise Application Architecture Patterns Catalog
(http://martinfowler.com/eaaCatalog)
19
GOF Design PatternsGOF Design PatternsAn IntroductionAn Introduction
20
21
Behavioural PatternsBehavioural Patterns
22
GOF Design Pattern Organization
23
GOF Design Pattern Relationships
24
Strategy Pattern
● Design Principle 1
Identify the aspects of your application that vary and separate them from what stays the same
● Design Principle 2
Program to an interface not to an implementation
● Design Principle 3
Favor composition over inheritance
25
Strategy Pattern
26
Strategy Pattern
27
Strategy Pattern
Reference: Head First Design Patterns
28Reference: Head First Design Patterns
29Reference: Head First Design Patterns
30
The Observer Pattern
Subject
Observer 1
Observer 2
Observer 3
Unsubscribed
Subscribers
Publisher
●When the in Subject changes, subscribers are notified●The observers are subscribed to the Subject to receive updates when the Subject data changes
31
ConcreteCommand
Objects
Invoker Receiver
Command Pattern
32
Creational PatternsCreational Patterns
33
Singleton Pattern
However, the synchronization is bit expensive
This overcomes the multiple threading issue.
This way is good if the performance is not an issue
34
The Simple Factory
35
The Simple Factory
36
Simple Factory
37
The Factory MethodThe factory method pattern encapsulates the object
creation by letting subclasses to decide what objects to create
38
The Factory Method
Factory objects are createdthrough INHERITANCE
This is the “Factory Method”
39
Dependency Inversion Principle
● Before Factory Method ● After Factory Method
This is all about reducing dependencies to concrete classes in our code
Abstract Class
Concrete Classes
Though this principle is quite similar to “Program to an interface” principle, this makes a bigger statement
40
Structural PatternsStructural Patterns
41
Decorator Pattern
42
Decorator Pattern
43
Cannot Connect
Can Connect
Decorator Pattern
44
Decorator Pattern
45
“Adapter is used when you have an abstract interface, and you want to map that interface to another object, which has similar functional role, but a different interface”
Basically it is used to Convert the interface of an object into something else
Adapter vs Decorator Pattern
● Adapter Pattern
46
“Decorator is used to extend the functionality of an object while maintaining its own interface”
● Decorator Pattern
Since both “Decorator” and “Adapter” patterns are used to “wrap” objects, they are basically known as “Wrapper Patterns”
47
Facade Pattern
48
Facade Pattern● Facades don’t encapsulate the sub system
classes
● They provide a simplified interface to their functionality
● The sub system classes still remain for direct access to outside clients
● One sub system can have any number of facades linked to it
● Decouples the client from a sub system – If you change any of the sub systems, your client code does not need to change.
49
Facade Pattern
● Design Principle
The principle of least knowledge
Talk only to your immediate friends
This prevents us from creating a large number of classes coupled together. Having too many dependencies creates a fragile design
50
● There are different kinds of proxy types
● The above is called the “Remote Proxy”
● The “Remote Proxy” acts as a local representative for an remote object. A method call on an “Remote Proxy” results the call being transferred on the wire and the result is returned back to the proxy and to the client
Proxy Pattern Remote Proxy
51
● The “client object” acts like its making remote calls. ● The “proxy object” pretends to be like the “remote object”● Actually what happens is, the “client object” calls methods in the “proxy object” (in its local heap), which handles all low level details of communication
Proxyobject
Clientobject
RemoteobjectRemote call
Local heap Remote heap
52
Composites
Leaf Nodes
Composite Pattern
53
MenuComponent
MenuItem
Menu
MenuItems
Composite Pattern
54
All components must implement the MenuComponent interface;
Why? In order for the composite to work transparently to the client, you must implement the same interface for all objects in the composite
Sometimes, the best possible way is to throw Run-time Exceptions to all unrelated methods
Composite Pattern
55
The MenuComponent
Both Menu andMenuItem components should implement this interface
Having default implementation will be difficult for each method
Hence, exceptions are thrown if any invalid method is called through a component
MenuItem
Menu
Com
mon
56
57