This 2-day AOP course provides an introduction to aspect-oriented programming and its role in enterprise application development. Using the very latest AOP support in Spring 2.0 and AspectJ 5, at this AOP course you will gain practical experience in developing and using aspects to produce more flexible, maintainable, and higher quality applications.

You will learn what AOP is and what kind of problems it can solve. You will gain practical experience using both Spring AOP and AspectJ, and understand how to build more flexible, maintainable, and higher quality applications by using them appropriately.

Upon completion of this AOP course, you will have an in-depth understanding of AOP that can be applied to immediate benefit on your own projects.

This AOP course has been developed by Adrian Colyer, SpringSource's CTO, leader of the AspectJ project and founder of the Eclipse AspectJ Development Tools (AJDT) project, and David Syer, Principal Consultant at SpringSource.

• Understand what AOP is and the kind of problems it can solve
• Know the fundamentals of Spring AOP and AspectJ, the two leading AOP solutions
• Be able to choose the most appropriate AOP approach for a given situation
• Have the practical knowledge needed to start introducing AOP in their own projects
• Know how to use aspect libraries
• Understand the use of aspects for protecting design modularity, transactions, security, management, profiling, tracing, failure handling, optimistic concurrency, caching, domain models, and more!
• Have at your disposal a proven roadmap for exploiting AOP in your own organisation

What is AOP?

• Motivations, join points, pointcuts, advice, aspects
• Aspects: HelloWorld in AspectJ

Approaches to AOP

• Proxy based vs language based
• Different weaving time
• Introduction to Spring AOP and AspectJ
• Where AOP fits in an enterprise application, choosing the right tool for the job

Writing pointcut expressions, part 1

• execution, call, get, set, handler, within, withincode
• aspects: making the service layer transactional

Design-level assertions

• declare warning and error
• demo of use in refactoring flow
• aspects: DontWriteToConsole, SpringHibernateUsageGuidelines, SpringJDBCUsageGuidelines, EJBCorporatePolicy "SystemArchitecture"
• architectural layering
• making it practical(link source folders; ant build integration; producing an HTML report)

Advice

• the 5 advice types, and how to declare them in AspectJ,@AspectJ, and Spring AOP
• aspects: HibernateExceptionTranslator, OptimisticOperationExecutor, SQLExceptionTranslator (w. declare soft)
• thisJoinPoint etc.

Writing pointcut expressions, part 2

• this, target, args
• aspects: simple caching, clustered caching with Tangosol coherence

Using an aspect library

• configuration :- AJDT, ant, LTW
• aop.xml
  • getting information on the weaving process
  • controlling weaving extent
  • integrating log messages
  • concrete aspects
• aspects: Dependency injection for domain objects

Writing infrastructure aspects

• transactions
• security
• remoting
• tracing
• profiling
• failure handling
• management (+ aspect design guidelines developed along the way)

Aspects and annotations

• @annotation etc
• using annotations wisely
• aspects: AnnotationUsageGuidelines, @Configurable, @Transactional, auditing, asynchronous execution (with task priority by customer status)

Adoption roadmap

• roadmap, extended to include Spring AOP
• aspects: LostUpdateDetector (in read-only transactions), PotentialOptimisationDetector (read-only tx marked as read-write), default interface implementation, inner aspects for interface implementation, lazy initialization support, SafeExecution, WarnOnSwallowedException (AspectJ compiler), ITD support and compilation loop adaptation (from AJ compiler)