Spring AOP
6 likes•1,328 views
Spring AOP is presented to solve the problem of cross-cutting concerns. Core concepts include join points, pointcuts, advice, and aspects. Pointcuts define where advice executes, such as methods matching a signature. Advice includes before, after returning, after throwing and around advice. Aspects modularize concerns using pointcuts and advice. Spring AOP uses proxies to weave aspects at runtime.
![Tracking property changes with Context
@Aspect
public class PropertyChangeTracker {
private static final Log logger =
LogFactory.getLog(PropertyChangeTracker.class);
@Before("setterMethod()")
public void trackChange( JoinPoint point){
String name = point.getSignature().getName();
Object newValue= point.getArgs()[0];
logger.info(name +"property about to change to " +newValue
+" on object" +point.getTarget());
}
@Pointcut("execution(void set*(*))")
public void setterMethod(){
}
}
Context about the
intercepted point
INFO: setCacheSizeproperty about to change to 2500 on object…
© Shakil Akhtar](https://image.slidesharecdn.com/springaop-140821095341-phpapp01/85/Spring-AOP-34-320.jpg)
Spring AOP
- 1. Spring AOP Presented By SHAKIL AKHTAR
- 2. Agenda v What problem does AOP solve? v Core AOP concepts. v Quick Start. v Defining Pointcuts. v Implementing Advice. © Shakil Akhtar
- 3. What are Cross-cutting Concerns? v Generic functionality that’s needed in places in application. v Examples • Logging • Transaction Management • Security • Caching • Error Handling • Performance Monitoring • Custom Business Rules © Shakil Akhtar
- 4. An Example Requirement v Perform a role based security check before every application method. A cross cutting concern requirement © Shakil Akhtar
- 5. Implementing Cross-Cutting Concerns Without Modularization v Failing to Modularize cross-cutting concerns leads to two things • Code Tangling o A couple of concerns • Code scattering o The same concern spread across modules © Shakil Akhtar
- 6. Symptom #1: Tangling v Write tangling code © Shakil Akhtar
- 7. Symptom #2: Scattering v Write scattering code © Shakil Akhtar
- 8. System Evolution Without Modularization © Shakil Akhtar
- 9. How AOP Works v Implement your mainline application logic • Focusing on the core problem v Write aspects to implement your cross-cutting concerns • Spring provides many aspects v Weave the aspects into your application • Adding the cross cutting concern behavior’s to the right place © Shakil Akhtar
- 10. Aspect Oriented Programming (AOP ) v Aspect Oriented Programming(AOP) enables modularization of cross-cutting concerns • To avoid tangling • To avoid Scattering © Shakil Akhtar
- 11. Aspect Oriented Programming (AOP ) © Shakil Akhtar Object A Object C Object B method method method method method method method
- 12. … © Shakil Akhtar Object A Object Bmet hod met hod advice Object Oriented Programming Target obj=obj B Pointcut=method B Aspect Join point method = invocation AOP
- 13. Leading AOP Technologies v AspectJ • Original AOP technology (first version in 1995) • Offers a full blown Aspect Oriented Programming language • Uses byte code modification for aspect weaving v Spring AOP • Java based AOP framework with AspectJ integration • Uses dynamic proxies for aspect weaving • Focuses on using AOP to solve enterprise problems • The Focus of this session © Shakil Akhtar
- 14. Core AOP Concepts v Join Point • A point in the execution point such as a method call or field assignment or handling of an exception v Pointcut • An expression that selects one or more join points v Advice • Code to be executed at join point that has been selected by a pointcut v Aspect • A module that encapsulates pointcuts and advice © Shakil Akhtar
- 15. Aspect v A modularization of a concern that cuts across multiple classes v Example Transaction management v Two flavor • Code XML based • AspectJ Annotation style © Shakil Akhtar
- 16. JoinPoint v A point during the execution of a program, such as the execution of a method or the handling of an exception v This represents a point in your application where you can plug-in AOP aspect v A place in the application where an action will be taken using Spring AOP framework © Shakil Akhtar
- 17. Advice v Action taken by an aspect at a particular join point v Example Transaction management v This is actual piece of code that is invoked during program execution v Types of advice • Around • Before • After returning • After throwing • After (finally) © Shakil Akhtar
- 18. Pointcut v A predicate that matches join points.Advice is associated with a pointcut expression and runs at any join point matched by the pointcut (for example, the execution of a method with a certain name). v A set of one or more joinpoints where an advice should be executed v Spring uses the AspectJ pointcut expression language by default © Shakil Akhtar
- 19. Introduction or inner-type v Declaring additional methods or fields on behalf of a type v Allows you to add new methods or attributes to existing classes v Example, you could use an introduction to make a bean implement an IsModified interface, to simplify caching © Shakil Akhtar
- 20. Target Object v An object being advised by one or more aspects. v This object will always be a proxied object v Also referred as the advised object © Shakil Akhtar
- 21. AOP Proxy v An object created by the AOP framework in order to implement the aspect contracts (advise method executions and so on). v In Spring ,an AOP proxy will be a JDK dynamic proxy or a CGLIB proxy © Shakil Akhtar
- 22. Weaving v Linking aspects with other application types or objects to create an advised object. v This can be done at compile time (using the AspectJ compiler, for example), load time, or at runtime v Spring AOP, like other pure Java AOP frameworks, performs weaving at runtime © Shakil Akhtar
- 23. Considerations v Field interception is not implemented, although support for field interception could be added using AspectJ.The same for protected/private methods and constructors. © Shakil Akhtar
- 24. AOP Types v Static AOP • In static AOP weaving process finds another step in the build process for an application • AOP is achieved by modifying byte code • well –performing way of achieving the weaving process, because the end result is just java byte code. • Recompilation requires for very join point addition v Dynamic AOP • Dynamic AOP (spring AOP) • Weaving process is performed dynamically at runtime • Less performance than static AOP © Shakil Akhtar
- 25. AOP Quick Start v Consider the basic requirement • Log a message every time a property is going to change v How can you use AOP to meet this? © Shakil Akhtar
- 26. An Application Object whose properties could change public class SimpleCache implements Cache{ int cacheSize; public void setCacheSize(int cacheSize) { this.cacheSize = cacheSize; } ... } © Shakil Akhtar
- 27. Implement the Aspect @Aspect public class PropertyChangeTracker { private static final Log logger = LogFactory.getLog(PropertyChangeTracker.class); @Before("execution(void set*(*))") public void trackChange(){ logger.info("property about to change"); } } © Shakil Akhtar
- 28. Best Practice Use Named Pointcuts @Aspect public class PropertyChangeTracker { private static final Log logger = LogFactory.getLog( PropertyChangeTracker.class); @Before("setterMethod()") public void trackChange(){ logger.info("property about to change"); } @Pointcut("execution(void set*(*))") public void setterMethod(){ } } © Shakil Akhtar
- 29. Configure the Aspect as a bean <beans> <aop:aspectj-autoproxy> <aop:include name="propertyChangeTracker"/> </aop:aspectj-autoproxy> <bean id="propertyChangeTracker" class="com.tr.spring.aop.PropertyChangeTracker" /> </beans> Configures spring to apply the @Aspect to your bean aspect-config.xml © Shakil Akhtar
- 30. Include the Aspect Configuration <beans> <import resource="aspect-config.xml"/> <bean name="cache-A" class="com.tr.spring.aop.SimpleCache"/> <bean name="cache-B" class="com.tr.spring.aop.SimpleCache"/> <bean name="cache-C" class="com.tr.spring.aop.SimpleCache"/> </beans> application-config.xml © Shakil Akhtar
- 31. Test the application ApplicationContext appCtx = new ClassPathXmlApplicationContext(APP_CTX_FILE_NAME); Cache cache = (Cache) appCtx.getBean("cache-A"); cache.setCacheSize(2500); INFO: property about to change © Shakil Akhtar
- 32. How Aspects are applied © Shakil Akhtar
- 33. How Aspects are applied © Shakil Akhtar
- 34. Tracking property changes with Context @Aspect public class PropertyChangeTracker { private static final Log logger = LogFactory.getLog(PropertyChangeTracker.class); @Before("setterMethod()") public void trackChange( JoinPoint point){ String name = point.getSignature().getName(); Object newValue= point.getArgs()[0]; logger.info(name +"property about to change to " +newValue +" on object" +point.getTarget()); } @Pointcut("execution(void set*(*))") public void setterMethod(){ } } Context about the intercepted point INFO: setCacheSizeproperty about to change to 2500 on object… © Shakil Akhtar
- 35. Useful JoinPoint Context v this • The currently executing object that has been intercepted(a proxy in spring AOP) v target • The target of the execution(typically your object) v args • The method arguments passed to the join point v signature • The method signature of the join point © Shakil Akhtar
- 36. Defining Pointcuts v With spring AOP you write pointcuts using AspectJ’s pointcut expression language • For selecting where to apply advice v Complete expression language reference available at • http://www.eclipse.org/aspectj © Shakil Akhtar
- 37. Execution Expression Example v execution(void send*(String)) • Any method starting with send and takes a single string parameter and has a void return type v execution(* send(int,..)) • Any method named send whose first parameter is an int(the “..” signifies 0 or more parameters may follow v execution(void example.MessageService+.send(*)) • Any MessageService method named send that takes a single parameter and returns void © Shakil Akhtar
- 38. Execution Expression Example using Annotations v execution(@org.springframework.transaction.annotat ion.Transactional void*(..)) • Any method marked with the @Transactional annotation v execution((@privacy.Sensitive*)*(..)) • Any method that returns a value marked with the @Sensitive annotation © Shakil Akhtar
- 39. Pointcut Expression Example v @Pointcut("execution(public * *(..))") § It will be applied on all the public methods. v @Pointcut("execution(public Operation.*(..))") § It will be applied on all the public methods of Operation class v @Pointcut("execution(* Operation.*(..))") § It will be applied on all the methods of Operation class © Shakil Akhtar
- 40. Pointcut Expression Example v @Pointcut("execution(public * *(..))") § It will be applied on all the public methods. v @Pointcut("execution(public Operation.*(..))") § It will be applied on all the public methods of Operation class © Shakil Akhtar
- 41. Advice Type: Before © Shakil Akhtar
- 42. Advice Type: After Returning © Shakil Akhtar
- 43. Advice Type: After Throwing © Shakil Akhtar
- 44. Advice Type: After © Shakil Akhtar
- 45. Advice Type: Around © Shakil Akhtar
- 46. Advice Best Practices v Use the simplest possible advice • Do not use @Around unless you must © Shakil Akhtar
- 47. Alternative Spring AOP Syntax-XML v Annotation syntax is java 5+ only v XML syntax works on java 1.4 v Approach • Aspect logic defined java • Aspect configuration in XML • Easy to learn once annotation syntax is understood © Shakil Akhtar
- 48. More Information v Documentation http://www.springsource.org v Forum http://forum.springsource.org/ v Spring Source Consulting http://www.springsource.com/support/professional- services © Shakil Akhtar
- 49. © Shakil Akhtar