Programowanie zorientowane aspektowo

1. Programowaniezorientowane aspektowo Aspect-Oriented Programming » Magdalena Tchorzewska

2. Ewolucja • Assembler • Tłumaczenie formuł (Fortran) • Programowanie proceduralne • Abstrakcyjne typy danych (ADT) • Programowanie obiektowe (OOP) • Programowanie po-obiektowe (POP): • Programowanie aspektowe (AOP) • Programowanie generyczne • ...

3. Implementacje • Łatwa do zrozumienia i nieefektywna, • Efektywna, lecz trudna do zrozumienia, • Oparta na AOP, która jest zarówno łatwa do zrozumienia, jak i efektywna. Eufemizm? • Implementacja dużych systemów OOP nadal nastręcza wiele trudności podczas prób modyfikacji kodu.

4. Czym jest AOP? • Jest to rozwiązanie problemu wynikającego z użycia wielu podobnych obiektów do interakcji z wieloma klasami w tradycyjnych systemach OOP. • Nazywa się je także związkiem przecięcia (ang. cross-cutting concern), trawersacją (ang. traversal strategy) lub po prostu aspektem.

5. osoba student profesor uczelnia policz() policz() System OOP generalizacja specjalizacja

6. osoba student profesor uczelnia policz() policz() System AOP [1] generalizacja specjalizacja aspekt

7. komponenty i opisy aspektów kod źródłowy (poplątany kod) System AOP [2] Wysoki poziom,wynik implementacjimoże być różny (c) grimsay „tkacz” (ang. weaver),w czasie kompilacji

8. System AOP [3] program AOP zwykły program funkcjonalność komponenty struktura aspekt 1 synchronizacja aspekt 2

9. Przykładowe zastosowania • Rejestrowanie aktywności użytkowników (logowanie) • Rejestrowanie wystąpień błędów (ang. error handling) • Synchronizacja • Optymalizacja • Zarządzanie konfiguracją

10. Przykład 1 aspect PointObserving { private Vector Point.observers = new Vector(); public static void addObserver(Point p, Screen s) { p.observers.add(s); }public static void removeObserver(Point p, Screen s) { p.observers.remove(s); } pointcut changes(Point p): target(p) && call(void Point.set*(int)); after(Point p): changes(p) { Iterator iter = p.observers.iterator(); while ( iter.hasNext() ) { updateObserver(p, (Screen)iter.next()); } } static void updateObserver(Point p, Screen s) { s.display(p); } }

11. Przykład 2 • Śledzenie: aspect SimpleTracing { pointcut tracedCall(): call(void FigureElement.draw(GraphicsContext)); before(): tracedCall() { System.out.println("Entering: " + thisJoinPoint); } } • Logowanie: aspect SetsInRotateCounting { int rotateCount = 0; int setCount = 0; before(): call(void Line.rotate(double)) { rotateCount++; } before(): call(void Point.set*(int)) && cflow(call(void Line.rotate(double))) { setCount++; } }

12. Przykład 3 abstract aspect SubjectObserverProtocol { abstract pointcut stateChanges(Subject s); after(Subject s): stateChanges(s) { for (int i = 0; i < s.getObservers().size(); i++) { ((Observer)s.getObservers().elementAt(i)).update(); } } private Vector Subject.observers = new Vector(); public void Subject.addObserver(Observer obs) { observers.addElement(obs); obs.setSubject(this); } public void Subject.removeObserver(Observer obs) { observers.removeElement(obs); obs.setSubject(null); } public Vector Subject.getObservers() { return observers; } private Subject Observer.subject = null; public void Observer.setSubject(Subject s) { subject = s; } public Subject Observer.getSubject() { return subject; } }

13. Co wiemy? • Zmiany w każdym z aspektów są propagowane do całego systemu podczas ponownego „tkania” kodu. • Wielkość kodu wejściowego jest nieporównywalnie mniejsza od wielkości kodu wynikowego (strukturalnego). • AOP jest rozszerzeniem dotychczas istniejących technik programowania (obiektowego).

14. Co dalej? • Nadal jest zbyt mało wiedzy teoretycznej na temat interakcji między aspektami a komponentami. • Czy można utworzyć kolekcję komponentów, tak by połączyć języki aspektowe w jedną całość widoczną na różne sposoby przez różne aplikacje? • Czy musimy pisać oddzielnie aspekty dla każdego języka programowania lub różnych rodzajów komponentów?

15. Aspectual components (AC) • Odpowiedź na brak niezależności od języka programowania. • Odpowiedź na potrzebę kontroli nad poplątanym kodem.

16. modyfikacja wynik wymagane spodziewane połączenia aplikacja Łączenie funkcji i obiektów

17. Cechy komponentów • Typowe dla klas: • Posiadają zmienne lokalne i zmienne metod • Jeden komponent może dziedziczyć od innego • Różniące się od klas: • Oddzielenie komponentu/połączenia od całości -- kod komponentu nie jest częścią aplikacji.

18. Rozlokowanie połączeń connector ShowReadAccessConn1 { Point is ShowReadAccess.DataToAccess with {readOp = get*; } } connector ShowReadAccessConn3 { {Point, Line, Rectangle} is ShowReadAccess.DataToAccess with {readOp = get*; } }

19. Dziedziczenie komponentów component ShowReadWriteAccess extends ShowReadAccess { participant DataToAccess { expect void writeOp(Object[] args); replace void writeOp(Object[] args){ System.out.println("Write access on " +this.toString()); expected(args); } } }

20. Dziedziczenie połączeń connector ShowReadWriteAccessConn2 extends ShowReadAccessConn3 { {Point,Line,Rectangle} is DataToAccess with {writeOp = set*; } }

21. Podsumowanie AC • Komplementarność w modelowaniu współpracy pomiędzy klasami lub zachowań dla nich wspólnych • Uniwersalne zachowanie, które może być wielokrotnie wykorzystywane • Niezależne tworzenie komponentów • Niezależne połączenia AC z aplikacjami • Niezależne interfejsy, które mogą być precyzyjnie zaadaptowane

22. Systemy wspierające AOP • Demeter (C++/Java) • AspectJ • HyperJ • Object Teams • ... • LOOM.NET i WEAVER.NET (Microsoft) • Inne: http://www.aosd.net/technology/research.php

23. Źródła • G. Kiczales, J. Lamping, A. Mendhekar, C. Maeda, C.V. Lopes, J.M. Loingtier, J. Irwin „Aspect-Oriented Programming” • M. Mezini, D. Lorenz, K. Lieberherr „Components and Aspect-Oriented Design/Programming” • K. Lieberherr „Demeter and Aspect-Oriented Programming: Why are programs hard to evolve?” • D. Bruce, N. Exon „Alternatives to Aspect-Oriented Programming?” • http://www.parc2.com/csl/groups/sda/ • http://www.ccs.neu.edu/research/demeter/ • http://www.aspectprogramming.com/