Aspect-oriented programming (AOP) is a programming paradigm that aims to modularize cross-cutting concerns in code. AOP was developed by Gregor Kiczales and colleagues at Xerox PARC. AspectJ is a popular implementation of AOP for Java that uses pointcuts, advice, and inter-type declarations to inject additional behavior into existing code by means of weaving. Pointcuts define where advice should be applied, advice is the additional code to execute, and weaving is the process of applying aspects to code.

1. Aspect-Oriented Programming Andrey Bratukhin, 2011

3. Main conceptions in AOP

4. AspectJ as one of implementation

5. Pointcuts in AspectJ

6. Advice in AspectJ

7. Inter-type declaration

8. Weaving

9. Bad practicies

10. Conclusion

12. Aspect-oriented programming is a way of modularizing crosscutting concerns much like object-oriented programming is a way of modularizing common concerns.

13. Motivation void transfer ( Account fromAcc, Account toAcc, int amount, User user, Logger logger ) throws Exception { logger.info ( &quot;transferring money...&quot; ); if (! checkUserPermission ( user )){ logger.info ( &quot;User has no permission.&quot; ); throw new UnauthorizedUserException (); } if ( fromAcc.getBalance () < amount ) { logger.info ( &quot;Insufficient Funds, sorry&quot; ); throw new InsufficientFundsException (); } fromAcc.withdraw ( amount ); toAcc.deposit ( amount ); //get database connection //save transactions logger.info ( &quot;Successful transaction.&quot; ); }

14. Tangled code

15. Dispersed code Module #1 Module #1 Module #1 Security API calls Security module

16. Extract common concerns Module #1 Module #1 Module #1 Automated integration of calls Security module Security aspect

18. Pointcut is a way to specify (or quantify) join points.

19. Advice is the code to run at a join point.

20. Inter-type decoration provide a way to express crosscutting concerns affecting the structure of modules.

21. Weaving is the process of applying aspects to code.

22. AspectJ example public aspect SomeAspect { pointcut allMethodCalls () : call (* *.*(..)); before () : allMethodCalls () { Logger.log ( &quot;Before &quot; + thisJoinPoint .toLongString ()); } after () : allMethodCalls () { Logger.log ( &quot;After &quot; + thisJoinPoint .toLongString ()); } }

24. Method or constructor call

25. Read/write field

26. Handling of exceptions

27. Initialization of class and objects

28. Pointcuts Signature Example *, .., + call(public *.new(int)), call(public Account.new(..)), execution(public Account+.new(..)) &&, ||, ! call(* int Account.*(..)) || call(* double Account.*(..)) && !within(Account) call(Signature), execution(Signature) call(public *.new(int)), execution(public Account+.new(..)) get(Signature), set(Signature) get(* System.out), set(private Account.amount) handler(TypePattern) Handler(* Account) within(TypePattern), withincode(Signature) within(* Account), withincode(private Account.transfer(..)) staticinitialization(TypePattern) staticinitialization(* Account)

30. after(Formals) returning – runs after each join point that returns normally.

31. after(Formals) throwing – runs after each join point that throws a Throwable.

32. after(Formals) – runs after each join point regardless of whether it returns normally or throws a Throwable.

33. Type arround(Formals) – runs in place of each join point.

34. Inter-type declaration declare parents : Account implements Serializable ; declare @type : Account : @MyAnnotation ; private String Account.name ; private void Account.getName ( String name ) { this .name = name ; } private String Account.getName () { return name ; } declare warning : get (* System.out ) && ! within ( Logger ) : &quot;Use Logger.log()&quot; ;

36. Post-compile weaving

37. Load-time weaving

38. Dynamic Proxy

40. Business logic strongly depends on aspects

41. Duplicating of functionality of runtime environment (EJB, OSGi and etc.)

42. Aspect hides valuable functionality of application

43. No unit or integration tests

45. Runtime environments

46. Codegeneration

48. Chain of responsibility

49. Decorator

50. Proxy

51. etc.