SCALA AND ASPECTJ. Approaching Modularizing of Crosscutting. Ramnivas Laddad. Concerns. ramnivas

Transcription

1 SCALA AND ASPECTJ Approaching Modularizing of Crosscutting Concerns Ramnivas Laddad ramnivas Copyright Ramnivas Laddad. All rights reserved.

2 @ramnivas Spring framework committer Cloud Foundry committer Main interests Aspect-oriented programming Cloud computing Scala and functional programming Author of books and articles AspectJ in Action (1 st and 2 nd edition) Speaker at many professional conferences JavaOne, JavaPolis, SpringOne, Software Development, No Fluff Just Stuff, EclipseCon, O Reilly OSCON etc. Active involvement in AspectJ since its early form

3 AspectJ and Scala connection Both statically typed

4 AspectJ and Scala connection Both compiled to JVM-compatible byte code

5 AspectJ and Scala connection AspectJ advice shares some characteristics of higher order functions

6 AspectJ and Scala connection AspectJ static crosscutting shares some characteristics of traits

7 AspectJ and Scala connection AspectJ weaving used in Scala IDE

8 A QUICK INTRO TO AOP Copyright Ramnivas Laddad. All rights reserved.

9 Crosscutting concern Functionality whose implementation spans multiple modules Many examples Logging and tracing Transaction management Concurrency control Security Error handling Business rules Auditing Performance monitoring!

10 Dealing with crosscutting concerns AOP A programming methodology AspectJ A prominent language to support AOP for Java

11 Core AOP concepts Join point An identifiable point in the execution of a program. Central, distinguishing concept in AOP Pointcut Program construct that selects join points and collects context at those points. Advice Code to be executed at a join point that has been selected by a pointcut Inter-type declaration Additional data or method to existing types, implementing new interfaces

12 AspectJ weaving Java and aspect source files (.java/.aj) Weaver Java and aspect byte-code files (.jar/.class) Compiler, linker, or load-time Woven system (.class files or.jar file)

13 ASPECTJ IN PRACTICE Lessons learned over years Copyright Ramnivas Laddad. All rights reserved.

14 Aspects come in all sizes Locally scoped concerns Cross-unit concerns Widely applied concerns Caching, read-write lock, retry failures Transaction, security Monitoring, auditing, policy enforcement, concurrency control*

15 AOP and annotations Annotation use very pervasive " Annotations as marker for advice here Obliviousness not considered critical " Explicit annotations not frowned upon

16 Pervasive annotations Object around() public class OrderService public void process()

17 Scala way of addressing crosscutting functionality Implement higher order function encapsulating the crosscutting logic Apply the function to all places that need the functionality

18 Higher order functions def retry[t](maxretry: Int)(thunk: => T) = { def retry(thunk: => T, attempt: Int): T = { try { thunk catch { case ex if (attempt < maxretry) => retry(thunk, attempt + 1) def process() : Unit = { retry(5) {

19 LOCALLY APPLIED FUNCTIONALITY Copyright Ramnivas Laddad. All rights reserved.

20 Caching using keyscript="#stock.ticker + ':' + #days") public byte[] getquotegraph(stock stock, int days) { Expensive calculation External language

21 Caching aspect public aspect CacheAspect { public pointcut cached(cachable cachable) : execution(@cachable * *(..)) Object around(cachable cachable) : cached(cachable) { String key = evaluate(cachable.keyscript(), thisjoinpoint); if (cache.containskey(key)) { return cache.get(key) else { Object value = proceed(cacheble); cache.put(key, value); return value;

22 Caching using Scala def getquotegraph(stock: Stock,!! days: Int) : Array[Byte] = { cached("chart", stock.ticker + ":" + days) { Expensive calculation!

23 Caching higher-order function abstract class Caching(val cachemanager: CacheManager) { def cached[t](region: String, key: Any) val cache = (thunk: => T): T = { if (cache.containskey(key)) { cache.get(key).asinstanceof[t] else { val thunkval: T = thunk cache.put(key, thunkval) thunkval

24 Comparing caching solutions AspectJ Scala Every cached element needs an annotation Every cached element needs wrapping in the HOF Uses external language (dynamically typed) Use the native language

25 Thought! Is retry or caching even a crosscutting functionality?

26 CROSS-UNIT CROSSCUTTING FUNCTIONALITY Copyright Ramnivas Laddad. All rights reserved.

27 Annotating for transaction management public class OrderServiceImpl implements OrderService public Order findorder(long orderid) public void updateorder(order order) public void addproduct(order order, Product product, int quantity) public void removeproduct(order order, Product product, int quantity) public void cancelorder(order order) {

28 Transaction management with Scala class OrderServiceImpl extends OrderService { def findorder(orderid: Long) : Order = { transactional(readonly=true) { def updateorder(order: Order) { transactional() { def addproduct(order: Order, product: Product, quantity: Int) { transactional() { def removeproduct(order: Order, product: Product, quantity: Int) { transactional() { def cancelorder(order: Order) { transactional() {

29 Transaction management aspect public aspect TransactionManagementAspect { private TransactionManager txmanager; pointcut transactionalop() : Object around() : transactionalop() { TransactionAttribute ta = TransactionStatus ts = txmanager.gettransaction(ta); try { Object ret = proceed(); transactionmanager.commit(ts); return ret; catch (Throwable ex) { rollback throw ex;

30 Transaction management function def transactional[t](propgation: Propagation = Propagation.REQUIRED, isolation: Isolation = Isolation.DEFAULT, readonly: Boolean = false, timeout: Int =TransactionDefinition.TIMEOUT_DEFAULT, rollbackfor: List[Throwable] = List(), norollbackfor: List[Throwable] = List()) (thunk: => T) : T

31 Transaction management implementation abstract class TransactionManagement(val txmanager: PlatformTransactionManager) { def transactional[t]()(thunk: => T) : T = { val txattribute = new TransactionAttributeWithRollbackRules() val status = txmanager.gettransaction(txattribute) try { val ret = thunk txmanager.commit(status) ret catch { case ex => { if (txattribute.rollbackon(ex)) { txmanager.rollback(status) else { txmanager.commit(status) throw ex

32 But! Transaction management often applies to all methods of a class Often with generic selection: public methods only " Class-level annotation suffices Transaction management often applies to all classes of certain * Special attributes can be derived using convention over configuration * (@Transactional *).find*(..)

33 Class-level public class OrderServiceImpl implements OrderService public Order findorder(long orderid) { public void updateorder(order order) { public void addproduct(order order, Product product, int quantity) { public void removeproduct(order order, Product product, int quantity) { public void cancelorder(order order) {

34 However! Scala can apply transaction management to smaller unit than the whole method Little practical value, since refactoring to extract method that need transaction is a good idea anyway

35 Comparing transaction management solutions! AspectJ Scala Not every element needs a marker (annotation) Every transactional logic wrapped in HOF Method-level granularity Any desired granularity possible

36 WIDELY APPLIED CROSSCUTTING Copyright Ramnivas Laddad. All rights reserved.

37 Classic crosscutting concerns Monitoring Tracing Profiling First failure data capture Policy enforcement Concurrency control Swing, SWT, Android Auditing

38 FFDC: Base aspect public abstract aspect FFDC { public abstract pointcut ffdcop(); after() throwing(exception ex) : ffdcop() { Signature sig = thisjoinpointstaticpart.getsignature(); logffdc(sig.getdeclaringtype().getname(), sig.getname(), ex, thisjoinpoint.getthis(), thisjoinpoint.getargs()); public void logffdc(string classname, String methodname, Exception ex, Object thiz, Object[] args) {

39 FFDC: Derived aspect public aspect DaoFFDC extends FFDC { public pointcut ffdcop() : execution(* com.acme..dao.*.*(..)); No annotation or other marker in advised code

40 FFDC through Scala Possible through higher-order function But! Tedious to wrap every function There are just too many of those Error prone Missed functions diminishing value in data captured Hard to reason at system level All classic crosscutting symptoms

41 Solution for Scala programs: Use AspectJ Compile Scala program as usual Weave aspects using binary weaving (build-time or load-time)

42 Conclusion With every element carrying a marker annotation, higherorder function offer a simpler and powerful solution Often not really crosscutting concerns to begin with Annotation used as a crutch to have aspects apply HOF Cross-unit crosscutting functionality Aspects have an edge Not all lost by staying with Scala-only Wide crosscutting concerns AspectJ is only game in town You can apply aspects to Scala-compiled code

43 Q&A Ramnivas Laddad ramnivas