Introduction to Aspect-Oriented Programming

Transcription

1 Introduction to Aspect-Oriented Programming Martin Giese Chalmers University of Technology Göteborg, Sweden AOP Course 2003 p.1/33

2 AspectJ Idioms and Patterns AOP Course 2003 p.2/33

3 Sources These idioms and pattern candidates were taken from the AspectJ in Action book by Laddad A paper by Hanenberg, Unland and Schmidmeier, named AspectJ Idioms for Aspect-Oriented Software Construction. AOP Course 2003 p.3/33

4 Avoid Infinite Recursion Problem: Pointcut matches some code in the advice Stack overflow public aspect Tracing { before() : call(* *.*(..)) { System.out.println("Caling: " + thisjoinpointstaticpart); pointcut too general. Use call(* *.*(..)) &&!within(tracing) AOP Course 2003 p.4/33

5 Nullifying Advice Problem: How to temporarily switch off advice during development, for experimentation and debugging? Advice declaration: before() : operation() {... Nullify advice: before() : operation() && if(false) {... Why not put if(false){... around the advice body? AOP Course 2003 p.5/33

6 Nullifying Advice (cont.) Compare: around() : operation() { if(false) {... proceed();... and around() : operation() && if(false) {... proceed();... AOP Course 2003 p.6/33

7 Empty Pointcuts Problem: Extending an abstract advice requires you to define a pointcut, but there are no mathing join points in your system. Example: public abstract aspect RemoteCallHandler { protected abstract pointcut synchronouscalls(); protected abstract pointcut asynchronouscalls();... In your system, no calls can be asynchronous. AOP Course 2003 p.7/33

8 Empty Pointcuts (cont.) Solution: not an idiom, but a language feature. Leave away colon and pointcut: public aspect MyRemoteCallHandler { protected pointcut synchronouscalls() : call(...); protected pointcut asynchronouscalls(); The alternative if(false) does not work with parameters: pointcut anop(int x) : if(false); formal unbound in pointcut AOP Course 2003 p.8/33

9 Marker Interface Problem: You want to apply advice based on some property that cannot be derived from the signature and name alone. Selecting particular methods: very difficult. Sometimes, it is sufficient to select certain classes for a pointcut. use Marker Interface Empty interface that is implemented by classes where advice should apply. Maybe other aspect (Marker Sticker) to attach marker to classes. Liberty in specifying which classes should be included. AOP Course 2003 p.9/33

10 Marker Interface (cont.) public interface TraceConstructors { public aspect ConstructorTracing { pointcut constrexec(): execution(*.new(..)) && target(traceconstructors);... public aspect MarkerSticker { declare parents: TargetClass implements TraceConstructor; AOP Course 2003 p.10/33

11 The Participant Pattern Problem: Pointcuts contain long lists of entities from all over the system, which should receive advice. The pointcuts actually specify all classes/methods/fields with a certain property. Solution: Reverse the roles make classes aware of the aspect, and have them declare the relevant properties. Use aspect with abstract pointcut. Classes can participate by inheriting from the aspect. Usually use inner aspect. AOP Course 2003 p.11/33

12 Participant Example public abstract aspect AbstractTracing { // invite participants public abstract pointcut logpoints();... public class MyQuadraticSATSolver { public boolean issatisfiable(clauseset c) { // participate in tracing public static aspect TraceMe extends AbstractTracing { public pointcut logpoints() : call(* MyQuadraticSATSolver.*(..)); AOP Course 2003 p.12/33

13 Template Advice Problem: You have different advice bodies, doing mainly the same thing, with just a few details changing. Solution: inspired by the Gang-of-Four Template Method pattern. use an abstract aspect put variation points into abstract methods implement a template advice, which uses these abstract methods. Note: advice itself cannot be overwritten in a sub-aspect template itself cannot be refined. AOP Course 2003 p.13/33

14 Template Advice Example public abstract aspect MultilingualTracing { // primitive operations public abstract String enteringstring(); public abstract String exitingstring(); public abstract pointcut logpoints(); // temlate advice before() : logpoints() { System.err.println(enteringString() + " " + thisjoinpoint); public abstract aspect FrenchTracing { public String enteringstring() { return "entrant"; public String exitingstring() { return "sortant de"; AOP Course 2003 p.14/33

15 Worker Object Creation Problem: around advice only allows you to choose whether you execute the original code at a join point or not. Your application needs to execute the code later or elsewhere or concurrently, etc. Standard non-aspectj solution: Wrap the action in a worker object implementing the Runnable interface. The run() method performs the action in question. Use the worker object to register the delayed action, start a thread, etc. AOP Course 2003 p.15/33

16 Worker Object Example Example: In a GUI program, a worker thread periodically wants to update a table to monitor progress.... tablemodel.addrow(newdata);... But Swing s thread safety rule prohibits modifying the model from anywhere but the AWT event handling thread. use one of the methods: java.awt.eventqueue.invokelater(runnable r) java.awt.eventqueue.invokeandwait(runnable r) AOP Course 2003 p.16/33

17 Worker Object Example (cont.) class TableRowAdder impelements Runnable { DefaultTableModel _model; Vector _data; AddTableRow( DefaultTableModel m, Vector d ) { _model = m; _data = d; public void run() { _model.addrow(_data); Call: EventQueue.invokeLater(new TableRowAdder(tableModel,newData)); AOP Course 2003 p.17/33

18 Worker Object Example (cont.) With anonymous class: EventQueue.invokeLater(new Runnable() { public void run() { tablemode.addrow(newdata); ); Idea: use around advice to create a worker object. AOP Course 2003 p.18/33

19 Worker Object Aspect around() : guicalls() { Runnable worker = new Runnable() { public void run() { proceed(); ; EventQueue.invokeLater(worker); Use proceed to capture normal operation; use it in a worker object. AOP Course 2003 p.19/33

20 Worker Object Aspect (cont.) Second example: asynchronous execution: around() : makeasynccalls() { Runnable worker = new Runnable() { public void run() { proceed(); ; new Thread(worker).start(); AOP Course 2003 p.20/33

21 Getting the Return Value What if we care about the return value? First create variant of Runnable which can store a return value: public abstract class RunnableWithReturn implements Runnable { protected Object _returnvalue; public Object getreturnvalue() { return _returnvalue; Use around advice to create a worker object that extends this class. AOP Course 2003 p.21/33

22 Worker Object Aspect with Return Value Object around() : guicallswithvalue() { Runnable worker = new RunnableWithReturn() { public void run() { proceed(); ; EventQueue.invokeAndWait(worker); return worker.getreturnvalue(); Note that return type Object for around advice includes primitive types! AOP Course 2003 p.22/33

23 Wormhole Problem: Somewhere deep in the call graph, you find out that you need some context information that was present much further up. Traditional solution: Add a context parameter to all the intermediate mehtods, that is not needed but only passed along. Idea: use a pointcut to capture the information when it is available, and advice to re-introduce it when it is needed. AOP Course 2003 p.23/33

24 Wormhole Nomenclature Nomenclature: caller space : where the context information is available. callee space : where the context information is needed. Example: Add logging statements for binomial coefficients, which include arguments of top-level call. caller space: top level call to binomcoeff callee space: logging statement that needs top level arguments. AOP Course 2003 p.24/33

25 How to Drill a Wormhole public aspect WormholeAspect { pointcut callerspace(<caller context>) : <caller pointcut>; pointcut calleespace(<callee context>) : <callee pointcut>; pointcut wormhole(<caller context>,<callee context>) : cflow(callerspace(<caller context>)) && calleespace(<callee context>) ; around(<caller context>,<callee context>) : wormhole(<caller context>,<callee context>) {... AOP Course 2003 p.25/33

26 Binomial Coeff. Tracing with Context public aspect WormholeAspect { pointcut topcall(int n0,int m0) : bccall(n0,m0) &&!cflowbelow(bccall(int,int)); pointcut bccall(int n,int m) : call(* BC.bc(..)) && args(n,m); pointcut wormhole(int n0,int m0,int n,int m) : cflow(topcall(n0,m0)) && bccall(n,m) ; around(int n0,int m0,int n,int m) : wormhole(int n0,int m0,int n,int m) { System.out.println("Calling bc( "+ n + "," + m + ")" "for bc( "+ n0 + "," + m0 + ")" ); AOP Course 2003 p.26/33

27 Exception Introduction Problem: Advice throws concern specific exceptions that should not be handled in the advised code. Solution from yesterday s lecture: use declare soft always the same SoftException wrapper, prevents concern specific exception handling. Idea: mimic exception softening but with concern specific RuntimeException AOP Course 2003 p.27/33

28 Advice with Exception Introduction public abstract aspect ConcernAspect { abstract pointcut operations(); before() : operations() { try { concernlogic(); catch (ConcernCheckedException ex) { throw new ConcernRuntimeException(ex); void concernlogic() throws ConcernCheckedException {... AOP Course 2003 p.28/33

29 Advice with Exception Introduction (cont.) public class ConcernRuntimeException extends RuntimeException { public ConcernRuntimeException(Throwable cause) { super(cause); Note: Since Java 1.4, exceptions have a constructor taking another Throwable describing the cause of this exception. Dedicated RuntimeException for each concern. AOP Course 2003 p.29/33

30 Handling Business Exceptions Call exceptions concerning the original code and not the advice business exceptions. Sometimes advice needs to catch all exception to do its work, aspect-specific and business-specific. Problem: a generic, reusable aspect might catch too much. How do we regenerate the appropriate business exceptions, which the original code can and expects to handle? AOP Course 2003 p.30/33

31 Catching All Exceptions public abstract aspect ConcernAspect { abstract pointcut operations(); Object around() : operations() { try { return proceed(); catch (Throwable ex) {... do concern s stuff... throw new ConcernRuntimeException(ex); What about exceptions that are thrown in proceed(), are not taken care of by this aspect, and should be handled by the code around the join point? AOP Course 2003 p.31/33

32 Preserving Business Exceptions public aspect PreserveBusinessException { declare precedence: PreserveBusinessException, ConcreteConcernAspect; after() throwing(concernruntimeexception ex) throws BusinessException : call(* *.*(..) throws BusinessException) { Throwable cause = ex.getcause(); if (cause instanceof BusinessException) { throw (BusinessException)cause; throw ex; // still a RuntimeException -> unchecked Detect where business exception may occur, unwrap them there AOP Course 2003 p.32/33

33 Conclusion You should now know about: some pointcut idioms marker interfaces the participant idiom template advice worker object creation the wormhole pattern exception introduction Tomorrow, you will hear about pros and cons and alternatives. AOP Course 2003 p.33/33