Enterprise Informatization LECTURE

Transcription

1 Enterprise Informatization LECTURE Piotr Zabawa, PhD. Eng. IBM/Rational Certified Consultant www:

2 Lecture 7 Aspect-Oriented Programming

3 Current tendences The approach to enterprise application and, more generally speaking, to software development significantly changes lately. There are several reasons originated by the following concepts: The concept of execution of BPMN2 models on engines The concept of MDA the one scenario of each is the same as the above concept The Domain-Driven Design paradigm Changes in the approach to software development involved by the observation that teams better cooperate if the work decomposition is based on domains rather than on functional decomposition (eg. use-case model driven decomposition) of the software system

4 Current tendences The first three items are discussed on Object-Oriented Techniques subject and on separate presentations of this subject. The last item is a result of the observations of software projects. And it is independent of the rest items mentioned earlier it does not depend on the approach (OO or BPMN2). It was observed that the software teams as well as software companies have vertical competences they are strongly connected with business domains of the software developed by these companies.

5 Current tendences A good example is banking. In case of almost any bank system there are specific problems like: Bank business processes Safety (logging, transaction confirmation, electronic keys, ) Document flow Operation audits It is a good practice to separate each problem (a concern) associating each of them with different business domain and to dedicate software implementation to the experts of each domain. The architectural problems are not a barrier due to very powerfull technologies for integration like SOA as well as Integration Design Patterns (both are discussed separately).

6 Current tendences We can think, in the context of the above example, about bank business processes as about main domain of the software (core concern) we develop and about other service domains as orthogonal aspects. Orthogonal means that do not depend one on another. And these ortogonal service domains are called concerns in Aspect-Oriented Programming. The more general notion is Aspect-Oriented software Development (AOD). More about AOD: Due to weak dependencies between aspects the modularization is promoted as well as transformation of concerns into services.

7 Paradigms background Sub-Paradigms of Object-oriented paradigm: By separation of concerns ( Aspect-oriented Role-oriented Subject-oriented Class-based Prototype-based The overview of programming paradigms:

8 Low-level motivation Each problem we solve through software implementation has some accompanied small problems: - Logging - Authorization - Security - Transactions cohesion - Multithreading synchronization From the functional point of view they are weakly coupled. However if they are interleaved with main functionality the code becomes unclear and difficult to change (the plait). AOP makes possible to separate concerns. More:

9 History of AOP 2001, Xerox PARC Gregor Kiczales and coleagues developed the first formal AOP product AspectJ extension for Java. This is the product we will use and it is the most widely known AOP language. The date is of the first public release. 2001, IBM Hyper/J and the Concern Manipulation Environment. Not popular. Microsof Transactions Server Enterprise Java Bean (EJB)

10 Cross-cutting concerns Some concerns that could be separated are to small to apply AOP. However some are large enough to effectively use the separation of concerns. Where is the border? We should find so called cross-cutting concerns. These are such concerns that cut all core concern. A good example is authorization for web application. After logging process we are recognized by the software system as a particular user. When we open a web page the system should check if we have access to this page. This checking process distributed into access to all web pages, so through the whole application. More information at:

11 List of cross-cutting concerns Synchronization Real-time constraints Error detection and correction Product features Memory management Data validation Persistence Transaction processing Globalization which includes Language_localisation Information security Caching Logging Monitoring Business rules Code mobility Internationalization and localization Domain-specific optimizations

12 What is the aspect? Aspect Aspect is a module that encapsulates a concern. In AOP it should encapsulate cross-cutting concern.

13 Eclipse AJDT for AspectJ This IDE for developing our applications including an AspectJHelloWorld sample is integrated to the JBossTools development platform available from:

14 AspectJ_HelloWorld // core concern writing Hello Worls // into console package net.andrewewhite.examples; public class HelloWorld { public static void main(string[] argv) { System.out.println("Hello World");

15 AspectJ_HelloWorld package net.andrewewhite.aspects; import org.aspectj.lang.annotation.after; import org.aspectj.lang.annotation.aspect; import org.aspectj.lang.annotation.before; // Do this *before* any *call* to the function // *java.io.printstream.println* that takes a *String* and returns *void* // and the function is not called within any class // under the package public class BasicAspect call(void java.io.printstream.println(string)) " + "&&!within(net.andrewewhite.aspects..*)") public void beforeprintlncall() { System.out.println("About to make call to print Hello call(void java.io.printstream.println(string)) " + "&&!within(net.andrewewhite.aspects..*)") public void afterprintlncall() { System.out.println("Just made call to print Hello World");

16 AspectJ_HelloWorld The results in the console: About to make call to print Hello World Hello World Just made call to print Hello World

17 AspectJ Bank Transaction This example illustrates the improvement of banking transaction code quality. Step 1 void transfer(account fromacc, Account toacc, int amount) throws Exception { if (fromacc.getbalance() < amount) { throw new InsufficientFundsException(); fromacc.withdraw(amount); toacc.deposit(amount);

18 AspectJ Bank Transaction We do not know what happens, so logging is added. Step 2 void transfer(account fromacc, Account toacc, int amount, User user, Logger logger) throws Exception { logger.info("transferring money..."); if (! checkuserpermission(user)){ logger.info("user has no permission."); throw new UnauthorizedUserException(); if (fromacc.getbalance() < amount) { logger.info("insufficient Funds, sorry"); throw new InsufficientFundsException(); fromacc.withdraw(amount); toacc.deposit(amount); //get database connection //save transactions logger.info("successful transaction.");

19 AspectJ Bank Transaction We move logging functionality to the aspect. Step 3 aspect Logger { void Bank.transfer(Account fromacc, Account toacc, int amount, User user, Logger logger) { logger.info("transferring money..."); void Bank.getMoneyBack(User user, int transactionid, Logger logger) { logger.info("user requested money back"); // other crosscutting code...

20 AspectJ language AspectJ adds to Java just one new concept, a join point -- and that's really just a name for an existing Java concept. It adds to Java only a few new constructs: pointcuts advice inter-type declarations aspects Pointcuts and advice dynamically affect program flow, inter-type declarations statically affects a program's class hierarchy, and aspects encapsulate these new constructs.

21 Pointcuts: AspectJ language name-based crosscutting call(void Point.setX(int)) Whenever program flow reaches call for the method with the following signature: void Point.setX(int) then this call is picked up. The following operators can be used: &&, or! to combine calls. User-defined pointcuts can be introduced.

22 Pointcuts: AspectJ language property-based crosscutting call(void Figure.make*(..)) Just wildcard above to match any void method in in Figure class the name of which starts from make. call(public * Figure.* (..)) Matches any public method from Figure class. Other mechanisms are also available for pointcuts. An could be used.

23 Advice: AspectJ language This associates a piece of source code that must be run when the program flow reaches an appropriate pointcut. Before advice before(): move() { System.out.println("about to move"); After advice after() returning: move() { System.out.println("just successfully moved"); Around advice

24 AspectJ language Advice: Annotations can be also used @Around

25 AspectJ language Inner-type declarations: They are declarations that cut across classes and their @DeclareError

26 AspectJ language Suppose we want to have Screen objects observe changes to Point objects, where Point is an existing class. We can implement this by writing an aspect declaring that the class Point Point has an instance field, observers, that keeps track of the Screen objects that are observing Points. 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);

27 Aspects: AspectJ language They wrap up pointcuts, advice, and inter-type declarations in a a modular unit of crosscutting implementation. aspect Logging { OutputStream logstream = System.err; before(): move() { logstream.println("about to move");

28 Pitfalls: Infinite loop: aspect A { AspectJ language before(): call(* *(..)) { System.out.println("before"); after(): call(* *(..)) { System.out.println("after"); Solution: aspect A { before(): call(* *(..)) &&!within(a) { System.out.println("before"); after() returning: call(* *(..)) &&!within(a){ System.out.println("after");

29 Realizations of AOP compilers Aspects are separated from the rest of application on the level of source code. However in binary code they must be inserted into the code of classes from the main concern. This process is called weaving, and could be realized as follows: Compile-time weaving (for source code) Post-compile weaving (for jars) Load-time weaving (based on weaving class-loader)

30 AOP vs design patterns As was already told, application of aspects can be used to decouple code. Very similar goal is achieved by application of design patterns, which in many cases decouple class hierarchies. However in most design patterns these herarchies are connected by association relationship which means that at least one hierarchy depends on the other. This dependency can be eliminated through application of aspect-oriented programming. The good example is aspect-oriented realization of Observer design pattern. In such a case the Observable does not know that is observed by an Observer. Please, implement this design pattern yourself. Try to experiment with some other design patterns.

31 AOP vs business rules Business rules can be seen as a cross-cutting concern the one which is associated to decision making in a core concern (the business process). In Drools business process does not depend on business rules, but in current implementation rules depend on the name of a task. The name-based association will be eliminated in next Drools distributions, according to JBoss declarations. A possible realization is that process is observed by a set of business rules. The business rules are executed when the business process reaches a particular task and starts execution of it.

32 Literature 1. AspectJ in Action, Second Edition, Enterprise AOP with Spring Applications, Ramnivas Laddad, Foreword by Rod Johnson, Creator of the Spring Framework, September, 2009, 568 pages, ISBN: , 2. Maven+SpringAOP+AspectJ: 3. Tutorial by Gregor Kiczales, 92 pages, 4. DDD with Spring+AspectJ: 5. Tutorial, 58 pages

33 6. Eclipse AJDT tutorial Literature 7. Spring AOP AspectJ Logging Example 8. Jboss AOP 9. Making AspectJ development easier with AJDT Introducing AJDT: The AspectJ Development Tools Some interesting whitepapers about AOP (GoF DP)

34 Literature 12. AOP myths and realities Dependency injection with AspectJ and Spring The AspectJ TM Programming Guide Programowanie aspektowe na przykładzie AspectJ Eclipse AJDT

35 Literature 17. Simplifying Enterprise Applications with Spring 2.0 and AspectJ Aspect Oriented Programming with Spring AspectJ and Maven Spring AOP + AspectJ annotation example AspectJ Programming Guide

36 The end