Software Quality Management

Transcription

1 Marco Scotto

2 Outline Behavioral Patterns Chain of Responsibility Command 2

3 Design Pattern Space Purpose Creational Structural Behavioral Scope Class Factory Method Adapter Interpreter Template Method Object Abstract Factory Adapter Chain of Responsibility Builder Bridge Command Prototype Composite Iterator Singleton Decorator Mediator Façade Memento Proxy Flyweight Observer State Strategy Visitor 3

4 Chain of Responsibility (1/2) Intent Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request Chain the receiving objects and pass the request along the chain until an object handles it 4

5 Chain of Responsibility (2/2) Motivation Consider a context-sensitive help system for a GUI The object that ultimately provides the help isn't known explicitly to the object (e.g., a button) that initiates the help request So use a chain of objects to decouple the senders from the receivers. The request gets passed along the chain until one of the objects handles it Each object on the chain shares a common interface for handling requests and for accessing its successor on the chain 5

6 Motivation 6

7 Applicability Use Chain of Responsibility: When more than one object may handle a request and the actual handler is not know in advance When requests follow a handle or forward model Some requests can be handled where they are generated while others must be forwarded to another object to be handled 7

8 Consequences Reduced coupling between the sender of a request and the receiver the sender and receiver have no explicit knowledge of each other Receipt is not guaranteed A request could fall off the end of the chain without being handled The chain of handlers can be modified dynamically 8

9 Structure (1/2) 9

10 Structure (2/2) A typical object structure might look like this: 10

11 Chain of Responsibility Example 1 (1/7) Scenario The designers of a set of GUI classes need to have a way to propagate GUI events, such as MOUSE_CLICKED, to the individual component where the event occurred and then to the object or objects that are going to handle the event 11

12 Chain of Responsibility Example 1 (2/7) Solution Use the Chain of Responsibility pattern. First post the event to the component where the event occurred. That component can handle the event or post the event to its container component (or both). The next component in the chain can again either handle the event or pass it up the component containment hierarchy until the event is handled This technique was actually used in the Java 1.0 AWT 12

13 Chain of Responsibility Example 1 (3/7) Here's a typical Java 1.0 AWT event handler: public boolean action(event event, Object obj) { if (event.target == test_button) dotestbuttonaction(); else if (event.target == exit_button) doexitbuttonaction(); else return super.action(event,obj); return true; // Return true to indicate the event has been // handled and should not be propagated further. 13

14 Chain of Responsibility Example 1 (4/7) In Java 1.1 the AWT event model was changed from the Chain of Responsibility pattern to the Observer pattern Why? 14

15 Chain of Responsibility Example 1 (5/7) Efficiency GUIs frequently generate many events, such as MOUSE_MOVE events. In many cases, the application did not care about these events. Yet, using the Chain of Responsibility pattern, the GUI framework would propagate the event up the containment hierarchy until some component handled it This caused the GUI to slow noticeably 15

16 Chain of Responsibility Example 1 (6/7) Flexibility The Chain of Responsibility pattern assumes a common Handler superclass or interface for all objects which can handle chained requests. In the case of the Java 1.0 AWT, every object that could handle an event had to be a subclass of the Component class Thus, non-gui events could not be handled, limiting the flexibility of the program 16

17 Chain of Responsibility Example 1 (7/7) The Java 1.1 AWT event model uses the Observer pattern Any object that wants to handle an event registers as an event listener with a component. When an event occurs, it is posted to the component. The component then dispatches the event to any of its listeners. If the component has no listeners, the event is discarded For this application, the Observer pattern is more efficient and more flexible 17

18 Chain of Responsibility Example 2 (1/2) Scenario We are designing the software for a security monitoring system. The system uses various sensors (smoke, fire, motion, etc.) which transmit their status to a central computer. We decide to instantiate a sensor object for each physical sensor. Each sensor object knows when the value it is sensing exceeds some threshold(s). When this happens, the sensor object should take some action. But the action that should be taken may depend on factors other than just the sensor's value. For example, the location of the sensor, the value of the data or equipment located at the sensor s position, the value of the data or equipment in other locations near the sensor s position, etc. We want a very scalable solution in which we can use our physical sensors and sensor objects in any environment What can be do? 18

19 Chain of Responsibility Example 2 (2/2) Solution Use the Chain of Responsibility pattern Aggregate sensor objects in a containment hierarchy that mirrors the required physical zones (areas) of security. Define wall, room, floor, area, building, campus and similar objects as part of this containment hierarchy. The alarm generated by a sensor is passed up this hierarchy until some containment object handles it 19

20 Chain of Responsibility Example 3 (1/2) Scenario We are designing the software for a system that approves purchasing requests. The approval authority depends on the dollar amount of the purchase. The approval authority for a given dollar amount could change at any time and the system should be flexible enough to handle this situation 20

21 Chain of Responsibility Example 3 (2/2) Solution Use the Chain of Responsibility pattern. PurchaseRequest objects forward the approval request to a PurchaseApproval object. Depending on the dollar amount, the PurchaseApproval object may approve the request or forward it on to the next approving authority in the chain. The approval authority at any level in the chain can be easily modified without affecting the original PurchaseRequest object 21

22 Handling Requests (1/10) Notice in the basic structure for the Chain of Responsibility pattern that the Handler class just has one method, handlerequest() Here it is as a Java interface: public interface Handler { public void handlerequest(); What if we want to handle different kinds of requests, for example, help, print and format requests? 22

23 Handling Requests (2/10) Solution 1 We could change our Handler interface to support multiple request types as follows: public interface Handler { public void handlehelp(); public void handleprint(); public void handleformat(); Now any concrete handler would have to implement all of the methods of this Handler interface 23

24 Handling Requests (3/10) Here's an example of a concrete handler for this new Handler interface: public class ConcreteHandler implements Handler { private Handler successor; public ConcreteHandler(Handler successor) { this.successor = successor; public void handlehelp() { // We handle help ourselves, so help code is here. public void handleprint() { successor.handleprint(); 24

25 Handling Requests (4/10) public void handleformat() { successor.handleformat(); The only problem with this technique is that if we add a new kind of request we need to change the interface which means that all concrete handlers need to be modified 25

26 Handling Requests (5/10) Solution 2 A better solution is to have separate handler interfaces for each type of request. For example, we could have: public interface HelpHandler { public void handlehelp(); public interface PrintHandler { public void handleprint(); public interface FormatHandler { public void handleformat(); 26

27 Handling Requests (6/10) Now a concrete handler can implement one (or more) of these interfaces. The concrete handler must have successor references to each type of request that it deals with, in case it needs to pass the request on to its successor 27

28 Handling Requests (7/10) Here's a concrete handler which deals with all three request types: public class ConcreteHandler implements HelpHandler, PrintHandler, FormatHandler { private HelpHandler helpsuccessor; private PrintHandler printsuccessor; private FormatHandler formatsuccessor; public ConcreteHandler(HelpHandler helpsuccessor PrintHandler printsuccessor, FormatHandler formatsuccessor) { this.helpsuccessor = helpsuccessor; this.printsuccessor = printsuccessor; this.formatsuccessor = formatsuccessor; 28

29 Handling Requests (8/10) public void handlehelp() { // We handle help ourselves, so help code is here. public void handleprint() { printsuccessor.handleprint(); public void handleformat() { formatsuccessor.handleformat(); 29

30 Handling Requests (9/10) Solution 3: Another approach to handling different kinds of requests is to have a single method in the Handler interface which takes an argument describing the type of request. For example, we could describe the request as a String: public interface Handler { public void handlerequest(string request); 30

31 Handling Requests (10/10) And now our concrete handler looks like: public class ConcreteHandler implements Handler { private Handler successor; public ConcreteHandler(Handler successor) { this.successor = successor; public void handlerequest(string request) { if (request.equals("help")) { // We handle help ourselves, so help code is here. else // Pass it on! successor.handle(request); 31

32 Command Intent Encapsulate a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations Also Known As Action, Transaction 32

33 Motivation (1/3) 33

34 Motivation (2/3) 34

35 Motivation (3/3) 35

36 Structure 36

37 Applicability Use the Command pattern when You want to implement a callback function capability You want to specify, queue, and execute requests at different times You need to support undo and change log operations 37

38 Collaborations 38

39 Consequences (1/2) Command decouples the object that invokes the operation from the one that knows how to perform it Commands are first-class objects. They can be manipulated and extended like any other object Commands can be made into a composite command 39

40 Consequences (2/2) 40

41 Implementation Issues (1/2) How intelligent should a command object be? Dumb: Delegates the required action to a receiver object Smart: Implements everything itself without delegating to a receiver object at all 41

42 Implementation Issues (2/2) A functor object usually implements the desired behavior itself without delegation to another object. A command object frequently delegates the desired behavior to another receiver object If the command object simply implements the desired behavior itself, it is acting as a simple functor 42

43 Command Pattern Example 1 (1/4) Situation A GUI system has several buttons that perform various actions. We want to have menu items that perform the same action as its corresponding button 43

44 Command Pattern Example 1 (2/4) Solution 1 Have one action listener for all buttons and menu items This is not a good solution as the resulting actionperformed() method violates the Open- Closed Principle 44

45 Command Pattern Example 1 (3/4) Solution 2 Have an action listener for each paired button and menu item. Keep the required actions in the actionperformed() method of this one action listener. This solution is essentially the Command pattern with simple ConcreteCommand classes that perform the actions themselves, acting like functors In Java 2, Swing Action objects are used for this purpose 45

46 Command Pattern Example 1 (4/4) 46

47 Swing Actions (1/4) A Swing Action object is really just an ActionListener object that not only provides the ActionEvent handling, but also centralized handling of the text, icon, and enabled state of toolbar buttons or menu items The same Action object can easily be associated with a toolbar button and a menu item 47

48 Swing Actions (2/4) The Action object also maintains the enabled state of the function associated with the toolbar button or menu item and allows listeners to be notified when this functionality is enabled or disabled 48

49 Swing Actions (3/4) In addition to the actionperformed method defined by the ActionListener interface, objects that implement the Action interface provide methods that allow the specification of: One or more text strings that describe the function of the button or menu item One or more icons that depict the function The enabled/disabled state of the functionality 49

50 Swing Actions (4/4) By adding an Action to a JToolBar or JMenu, you get: A new JButton (for JToolBar) or JMenuItem (for JMenu ) that is automatically added to the tool bar or menu. The button or menu item automatically uses the icon and text specified by the Action A registered action listener (the Action object) for the button or menu item Centralized handling of the button's or menu item's enabled state 50

51 Swing Actions Example (1/4) /** * Class SwingActions demonstrates the Command Pattern * using Swing Actions. */ public class SwingActions extends JFrame { private JToolBar tb; private JTextArea ta; private JMenu filemenu; private Action openaction; private Action closeaction; public SwingActions() { super("swingactions"); setupgui(); 51

52 Swing Actions Example (2/4) private void setupgui() { //Create the toolbar and menu. tb = new JToolBar(); filemenu = new JMenu("File"); //Create the text area used for output. ta = new JTextArea(5, 30); JScrollPane scrollpane = new JScrollPane(ta); //Layout the content pane. JPanel contentpane = new JPanel(); contentpane.setlayout(new BorderLayout()); contentpane.setpreferredsize(new Dimension(400, 150)); contentpane.add(tb, BorderLayout.NORTH); contentpane.add(scrollpane, BorderLayout.CENTER); setcontentpane(contentpane); 52

53 Swing Actions Example (3/4) //Set up the menu bar. JMenuBar mb = new JMenuBar(); mb.add(filemenu); setjmenubar(mb); // Create an action for "Open". ImageIcon openicon = new ImageIcon("open.gif"); openaction = new AbstractAction("Open", openicon) { public void actionperformed(actionevent e) { ta.append("open action from " + e.getactioncommand() +"\n"); ; // Use the action to add a button to the toolbar. JButton openbutton = tb.add(openaction); openbutton.settext(""); openbutton.setactioncommand("open Button"); openbutton.settooltiptext("this is the open button"); 53

54 Swing Actions Example (4/4) // Use the action to add a menu item to the file menu. JMenuItem openmenuitem = filemenu.add(openaction); openmenuitem.seticon(null); openmenuitem.setactioncommand("open Menu Item"); // Create an action for "Close" and use the action to add // a button to the toolbar and a menu item to the menu. // Code NOT shown - similar to "open" code above. public static void main(string[] args) { SwingActions frame = new SwingActions(); frame.pack(); frame.setvisible(true); 54

55 Command Pattern Example 2 (1/12) Scenario We want to write a class that can periodically execute one or more methods of various objects. For example, we want to run a backup operation every hour and a disk status operation every ten minutes. But we do not want the class to know the details of these operations or the objects that provide them. We want to decouple the class that schedules the execution of these methods with the classes that actually provide the behavior we want to execute 55

56 Command Pattern Example 2 (2/12) Solution: Command Pattern Here s the Task interface: public interface Task { public void performtask(); 56

57 Command Pattern Example 2 (3/12) Instead of a BackupTask or DiskStatusClass, here is a simple Fortune Teller Task which cycles through a list of fortune sayings: public class FortuneTask implements Task { int nextfortune = 0; String[] fortunes = {"She who studies hard, gets A", Seeth the pattern and knoweth the truth", "He who leaves state the day after final, graduates not" ; public FortuneTask() { public void performtask() { System.out.println("Your fortune is: " + fortunes[nextfortune]); nextfortune = (nextfortune + 1) % fortunes.length; public String tostring() { return ("Fortune Telling Task"); 57

58 Command Pattern Example 2 (4/12) And here is a Fibonacci Sequence Task which generates a sequence of Fibonacci numbers: public class FibonacciTask implements Task { int n1 = 1; int n2 = 0; int num; public FibonacciTask() { public void performtask() { num = n1 + n2; System.out.println("Next Fibonacci number is: " + num); n1 = n2; n2 = num; public String tostring() { return ("Fibonacci Sequence Task"); 58

59 Command Pattern Example 2 (5/12) Here is the TaskEntry class: public class TaskEntry { private Task task // The task to be done // It's a Command object! private long repeatinterval; // How often task should be // executed private long timelastdone; // Time task was last done public TaskEntry(Task task, long repeatinterval) { this.task = task; this.repeatinterval = repeatinterval; this.timelastdone = System.currentTimeMillis(); public Task gettask() { return task; 59

60 Command Pattern Example 2 (6/12) public void settask(task task) { this.task = task; public long getrepeatinterval() { return repeatinterval; public void setrepeatinterval(long ri) { this.repeatinterval = ri; public long gettimelastdone() { return timelastdone; public void settimelastdone(long t) { this.timelastdone = t; public String tostring() { return (task + " to be done every " + repeatinterval + " ms; last done " + timelastdone); 60

61 Command Pattern Example 2 (7/12) Here is the TaskMinder class: public class TaskMinder extends Thread { private long sleepinterval; // How often the TaskMinder // should check for tasks to be run private Vector tasklist; // The list of tasks public TaskMinder(long sleepinterval, int maxtasks) { this.sleepinterval = sleepinterval; tasklist = new Vector(maxTasks); start(); public void addtask(task task, long repeatinterval) { long ri = (repeatinterval > 0)? repeatinterval : 0; TaskEntry te = new TaskEntry(task, ri); tasklist.addelement(te); 61

62 Command Pattern Example 2 (8/12) public Enumeration gettasks() { return tasklist.elements(); public long getsleepinterval() { return sleepinterval; public void setsleepinterval(long si) { this.sleepinterval = si; public void run() { while (true) { try { sleep(sleepinterval); long now = System.currentTimeMillis(); Enumeration e = tasklist.elements(); 62

63 Command Pattern Example 2 (9/12) while (e.hasmoreelements()) { TaskEntry te = (TaskEntry) e.nextelement(); if (te.getrepeatinterval() + te.gettimelastdone() < now) { te.gettask().performtask(); te.settimelastdone(now); catch (Exception e) { System.out.println("Interrupted sleep: " + e); 63

64 Command Pattern Example 2 (10/12) Test program: public class TestTaskMinder { public static void main(string args[]) { // Create and start a TaskMinder. // This TaskMinder checks for things to do every 500 ms // and allows a maximum of 100 tasks. TaskMinder tm = new TaskMinder(500, 100); // Create a Fortune Teller Task. FortuneTask fortunetask = new FortuneTask(); // Have the Fortune Teller execute every 3 seconds. tm.addtask(fortunetask, 3000); 64

65 Command Pattern Example 2 (11/12) // Create a Fibonacci Sequence Task. FibonacciTask fibonaccitask = newfibonaccitask(); // Have the Fibonacci Sequence execute every 700 // milliseconds. tm.addtask(fibonaccitask, 700); 65

66 Command Pattern Example 2 (12/12) Test program output: Next Fibonacci number is: 1 Next Fibonacci number is: 1 Your fortune is: She who studies hard, gets A Next Fibonacci number is: 2 Next Fibonacci number is: 3 Next Fibonacci number is: 5 Next Fibonacci number is: 8 Your fortune is: Seeth the pattern and knoweth the truth Next Fibonacci number is: 13 Next Fibonacci number is: 21 Next Fibonacci number is: 34 Your fortune is: He who leaves state the day after final, graduates not Next Fibonacci number is: 55 Next Fibonacci number is: 89 Next Fibonacci number is: 144 etc. 66