1   /***************************************************************************************
2    * Copyright (c) Jonas Bon?r, Alexandre Vasseur. All rights reserved.                 *
3    * http://aspectwerkz.codehaus.org                                                    *
4    * ---------------------------------------------------------------------------------- *
5    * The software in this package is published under the terms of the LGPL license      *
6    * a copy of which has been included with this distribution in the license.txt file.  *
7    **************************************************************************************/
8   package test.args;
9   
10  import org.codehaus.aspectwerkz.definition.Pointcut;
11  import org.codehaus.aspectwerkz.joinpoint.JoinPoint;
12  import test.Loggable;
13  
14  /***
15   * @author <a href="mailto:alex@gnilux.com">Alexandre Vasseur</a>
16   */
17  public class ArgsAspect {
18  
19      //-- Method execution pointcuts with args
20  
21      /***
22       * @Expression within(test.args.ArgsAdviceTest)
23       */
24      Pointcut in_scope;
25  
26      /***
27       * @Expression in_scope && execution(* matchAll(..)) && args(String, String, long)
28       */
29      Pointcut pc_matchAll;
30  
31      /***
32       * @Expression in_scope && execution(* matchAllWithWildcard(..)) && args(..)
33       */
34      Pointcut pc_matchAllWithWildcard;
35  
36      /***
37       * @Expression in_scope && execution(* getFirst(..)) && args(s, ..)
38       */
39      void pc_getFirst(String s) {
40          ;
41      }// here we use "return void" style
42  
43      /***
44       * @Expression in_scope && execution(* changeArg(..)) && args(String, s, long)
45       */
46      Pointcut pc_changeArg(StringBuffer s) {
47          return null;
48      }// here we use "return null" style
49  
50      /***
51       * @Expression in_scope && execution(* orderChangedInPointcutSignature(..)) && args(s0, s1, long)
52       */
53      Pointcut pc_orderChangedInPointcutSignature(String s1, String s0) {
54          return null;
55      }
56  
57      /***
58       * @Expression in_scope && execution(* orderChangedInAdviceSignature(..)) && args(s0, s1, long)
59       */
60      Pointcut pc_orderChangedInAdviceSignature(String s0, String s1) {
61          return null;
62      }
63  
64      /***
65       * @Expression in_scope && execution(* orderChangedInPointcutAndAdviceSignature(..)) && args(s0, s1, long)
66       */
67      Pointcut pc_orderChangedInPointcutAndAdviceSignature(String s1, String s0) {
68          return null;
69      }
70  
71      /***
72       * @Before in_scope && execution(* singleAndDotDot(..)) && args(i)
73       */
74      public void singleAndDotDot(JoinPoint joinPoint, int i) {
75          ((Loggable) joinPoint.getTarget()).log("before " + i + " ");
76      }
77  
78      /***
79       * @Before in_scope && execution(* withArray(..)) && args(l, s, matrix)
80       */
81      public void withArray(JoinPoint joinPoint, long l, String s, int[][] matrix) {
82          String iis = "";
83          for (int i = 0; i < matrix.length; i++) {
84              for (int j = 0; j < matrix[i].length; j++) {
85                  iis += ""+matrix[i][j]+"-";
86              }
87          }
88          ((Loggable) joinPoint.getTarget()).log("before " + l + " " + s + " " + iis + " ");
89      }
90  
91      /***
92       * @Before pc_matchAll || pc_matchAllWithWildcard
93       */
94      public void matchAllBefore(JoinPoint joinPoint) {
95          ((Loggable) joinPoint.getTarget()).log("before ");
96      }
97  
98      /***
99       * @After pc_matchAll || pc_matchAllWithWildcard
100      */
101     public void matchAllAfter(JoinPoint joinPoint) {
102         ((Loggable) joinPoint.getTarget()).log("after ");
103     }
104 
105     /***
106      * @Around pc_matchAll || pc_matchAllWithWildcard
107      */
108     public Object matchAllAround(JoinPoint joinPoint) throws Throwable {
109         ((Loggable) joinPoint.getTarget()).log("before1 ");
110         Object res = joinPoint.proceed();
111         ((Loggable) joinPoint.getTarget()).log("after1 ");
112         return res;
113     }
114 
115 
116     /***
117      * @Before pc_getFirst(as)
118      */
119     public void getFirstBefore(JoinPoint joinPoint, String as) {
120         ((Loggable) joinPoint.getTarget()).log("before " + as + " ");
121     }
122 
123     /***
124      * @After pc_getFirst(as)
125      */
126     public void getFirstAfter(String as, JoinPoint joinPoint) {//here we use some fancy order in the signature
127         ((Loggable) joinPoint.getTarget()).log("after " + as + " ");
128     }
129 
130     /***
131      * @Around pc_getFirst(as)
132      */
133     public Object getFirstAround(JoinPoint joinPoint, String as) throws Throwable {
134         ((Loggable) joinPoint.getTarget()).log("before1 " + as + " ");
135         Object res = joinPoint.proceed();
136         ((Loggable) joinPoint.getTarget()).log("after1 " + as + " ");
137         return res;
138     }
139 
140     /***
141      * @Before in_scope && execution(* getFirstAnonymous(..)) && args(as,String,..)
142      */
143     public void getFirstAnonymousBefore(JoinPoint joinPoint, String as) {
144         ((Loggable) joinPoint.getTarget()).log("before " + as + " ");
145     }
146 
147     /***
148      * @After in_scope && execution(* getFirstAnonymous(..)) && args(as, String, long)
149      */
150     public void getFirstAnonymousAfter(String as, JoinPoint joinPoint) {
151         ((Loggable) joinPoint.getTarget()).log("after " + as + " ");
152     }
153 
154     /***
155      * @Around in_scope && execution(* getFirstAnonymous(..)) && args(as,..)
156      */
157     public Object getFirstAnonymousAround(JoinPoint joinPoint, String as) throws Throwable {
158         ((Loggable) joinPoint.getTarget()).log("before1 " + as + " ");
159         Object res = joinPoint.proceed();
160         ((Loggable) joinPoint.getTarget()).log("after1 " + as + " ");
161         return res;
162     }
163 
164     /***
165      * @Before pc_changeArg(as)
166      */
167     public void changeArgBefore(JoinPoint joinPoint, StringBuffer as) {
168         as.append("x");
169         ((Loggable) joinPoint.getTarget()).log("before " + as.toString() + " ");
170     }
171 
172     /***
173      * @After pc_changeArg(as)
174      */
175     public void changeArgAfter(JoinPoint joinPoint, StringBuffer as) {
176         as.append("x");
177         ((Loggable) joinPoint.getTarget()).log("after " + as.toString() + " ");
178     }
179 
180     /***
181      * @Around pc_changeArg(as)
182      */
183     public Object changeArgAround(StringBuffer as, JoinPoint joinPoint) throws Throwable {//here we use some fancy order in the signature
184         as.append("x");
185         ((Loggable) joinPoint.getTarget()).log("before1 " + as.toString() + " ");
186         Object res = joinPoint.proceed();
187         as.append("x");
188         ((Loggable) joinPoint.getTarget()).log("after1 " + as.toString() + " ");
189         return res;
190     }
191 
192 
193     /***
194      * @Before pc_orderChangedInPointcutSignature(as0, as1)
195      */
196     public void orderChangedInPointcutSignatureBefore(JoinPoint joinPoint, String as0, String as1) {
197         ((Loggable) joinPoint.getTarget()).log("before " + as0 + " " + as1 + " ");
198     }
199 
200     /***
201      * @After pc_orderChangedInPointcutSignature(as0, as1)
202      */
203     public void orderChangedInPointcutSignatureAfter(JoinPoint joinPoint, String as0, String as1) {
204         ((Loggable) joinPoint.getTarget()).log("after " + as0 + " " + as1 + " ");
205     }
206 
207     /***
208      * @Around pc_orderChangedInPointcutSignature(as0, as1)
209      */
210     public Object orderChangedInPointcutSignatureAround(JoinPoint joinPoint, String as0, String as1) throws Throwable {
211         ((Loggable) joinPoint.getTarget()).log("before1 " + as0 + " " + as1 + " ");
212         Object res = joinPoint.proceed();
213         ((Loggable) joinPoint.getTarget()).log("after1 " + as0 + " " + as1 + " ");
214         return res;
215     }
216 
217 
218     /***
219      * @Before pc_orderChangedInAdviceSignature(as1, as0)
220      */
221     public void orderChangedInAdviceSignatureBefore(JoinPoint joinPoint, String as0, String as1) {
222         ((Loggable) joinPoint.getTarget()).log("before " + as0 + " " + as1 + " ");
223     }
224 
225     /***
226      * @After pc_orderChangedInAdviceSignature(as1, as0)
227      */
228     public void orderChangedInAdviceSignatureAfter(JoinPoint joinPoint, String as0, String as1) {
229         ((Loggable) joinPoint.getTarget()).log("after " + as0 + " " + as1 + " ");
230     }
231 
232     /***
233      * @Around pc_orderChangedInAdviceSignature(as1, as0)
234      */
235     public Object orderChangedInAdviceSignatureAround(JoinPoint joinPoint, String as0, String as1) throws Throwable {
236         ((Loggable) joinPoint.getTarget()).log("before1 " + as0 + " " + as1 + " ");
237         Object res = joinPoint.proceed();
238         ((Loggable) joinPoint.getTarget()).log("after1 " + as0 + " " + as1 + " ");
239         return res;
240     }
241 
242 
243     /***
244      * @Before pc_orderChangedInPointcutAndAdviceSignature(as1, as0)
245      */
246     public void orderChangedInPointcutAndAdviceSignatureBefore(JoinPoint joinPoint, String as0, String as1) {
247         ((Loggable) joinPoint.getTarget()).log("before " + as0 + " " + as1 + " ");
248     }
249 
250     /***
251      * @After pc_orderChangedInPointcutAndAdviceSignature(as1, as0)
252      */
253     public void orderChangedInPointcutAndAdviceSignatureAfter(JoinPoint joinPoint, String as0, String as1) {
254         ((Loggable) joinPoint.getTarget()).log("after " + as0 + " " + as1 + " ");
255     }
256 
257     /***
258      * @Around pc_orderChangedInPointcutAndAdviceSignature(as1, as0)
259      */
260     public Object orderChangedInPointcutAndAdviceSignatureAround(JoinPoint joinPoint, String as0, String as1)
261             throws Throwable {
262         ((Loggable) joinPoint.getTarget()).log("before1 " + as0 + " " + as1 + " ");
263         Object res = joinPoint.proceed();
264         ((Loggable) joinPoint.getTarget()).log("after1 " + as0 + " " + as1 + " ");
265         return res;
266     }
267 
268     //-- Method call pointcuts with args
269 
270     /***
271      * @Expression in_scope && call(* callGetFirstAndSecond(..)) && args(l, s)
272      */
273     void pc_callGetFirstAndSecond(long l, String[] s) {
274     };
275 
276     /***
277      * @Before pc_callGetFirstAndSecond(l, s)
278      */
279     public void callGetFirstAndSecondBefore(JoinPoint joinPoint, long l, String[] s) {
280         ((Loggable) joinPoint.getTarget()).log("before " + l + " " + s[0] + "," + s[1] + " ");
281     }
282 
283     /***
284      * @After pc_callGetFirstAndSecond(l, s)
285      */
286     public void callGetFirstAndSecondAfter(JoinPoint joinPoint, long l, String[] s) {
287         ((Loggable) joinPoint.getTarget()).log("after " + l + " " + s[0] + "," + s[1] + " ");
288     }
289 
290     /***
291      * @Around pc_callGetFirstAndSecond(l, s)
292      */
293     public Object callGetFirstAndSecondAround(JoinPoint joinPoint, long l, String[] s) throws Throwable {
294         ((Loggable) joinPoint.getTarget()).log("before1 " + l + " " + s[0] + "," + s[1] + " ");
295         Object res = joinPoint.proceed();
296         ((Loggable) joinPoint.getTarget()).log("after1 " + l + " " + s[0] + "," + s[1] + " ");
297         return res;
298     }
299 
300     //-- Ctor execution pointcuts with args
301     // we are using inner class, so args() is a bit tricky
302 
303     /***
304      * @Expression execution(test.args.ArgsAdviceTest$CtorExecution.new(..)) && args(test.args.ArgsAdviceTest, s)
305      */
306     void pc_ctorExecutionGetFirst(String s) {
307     };
308 
309     /***
310      * @Before pc_ctorExecutionGetFirst(s)
311      */
312     public void ctorExecutionGetFirstBefore(JoinPoint joinPoint, String s) {
313         ((Loggable) joinPoint.getTarget()).log("before " + s + " ");
314     }
315 
316     /***
317      * @After pc_ctorExecutionGetFirst(s)
318      */
319     public void ctorExecutionGetFirstAfter(JoinPoint joinPoint, String s) {
320         ((Loggable) joinPoint.getTarget()).log("after " + s + " ");
321     }
322 
323     /***
324      * @Around pc_ctorExecutionGetFirst(s)
325      */
326     public Object ctorExecutionGetFirstAround(JoinPoint joinPoint, String s) throws Throwable {
327         ((Loggable) joinPoint.getTarget()).log("before1 " + s + " ");
328         Object res = joinPoint.proceed();
329         ((Loggable) joinPoint.getTarget()).log("after1 " + s + " ");
330         return res;
331     }
332 
333     //-- Ctor call pointcuts with args
334     // we are using inner class, so args() is a bit tricky
335 
336     /***
337      * @Expression in_scope && call(test.args.ArgsAdviceTest$CtorCall.new(..)) && args(test.args.ArgsAdviceTest, s)
338      */
339     void pc_ctorCallGetFirst(String s) {
340     };
341 
342     /***
343      * @Before pc_ctorCallGetFirst(s)
344      */
345     public void ctorCallGetFirstBefore(JoinPoint joinPoint, String s) {
346         ArgsAdviceTest.logStatic("before " + s + " ");
347     }
348 
349     /***
350      * @After pc_ctorCallGetFirst(s)
351      */
352     public void ctorCallGetFirstAfter(JoinPoint joinPoint, String s) {
353         ArgsAdviceTest.logStatic("after " + s + " ");
354     }
355 
356     /***
357      * @Around pc_ctorCallGetFirst(s)
358      */
359     public Object ctorCallGetFirstAround(JoinPoint joinPoint, String s) throws Throwable {
360         ArgsAdviceTest.logStatic("before1 " + s + " ");
361         Object res = joinPoint.proceed();
362         ArgsAdviceTest.logStatic("after1 " + s + " ");
363         return res;
364     }
365 
366     //-- field set with args()
367     /***
368      * @Expression in_scope && set(* m_field) && args(s)
369      */
370     void pc_mfield(String s) {
371     };
372 
373     /***
374      * @Before pc_mfield(s)
375      */
376     public void mfieldBefore(JoinPoint joinPoint, String s) {
377         String fieldValue = ((ArgsAdviceTest) joinPoint.getTarget()).getField();
378         ((Loggable) joinPoint.getTarget()).log("before " + fieldValue + "," + s + " ");
379     }
380 
381     /***
382      * @After pc_mfield(s)
383      */
384     public void mfieldAfter(JoinPoint joinPoint, String s) {
385         String fieldValue = ((ArgsAdviceTest) joinPoint.getTarget()).getField();
386         ((Loggable) joinPoint.getTarget()).log("after " + fieldValue + "," + s + " ");
387     }
388 
389     /***
390      * @Around pc_mfield(s)
391      */
392     public Object mfieldAround(JoinPoint joinPoint, String s) throws Throwable {
393         String fieldValue = ((ArgsAdviceTest) joinPoint.getTarget()).getField();
394         ((Loggable) joinPoint.getTarget()).log("before1 " + fieldValue + "," + s + " ");
395         s = "changed"; // will be ignored due to delegation ! [AJ]
396         Object res = joinPoint.proceed();
397         fieldValue = ((ArgsAdviceTest) joinPoint.getTarget()).getField();
398         ((Loggable) joinPoint.getTarget()).log("after1 " + fieldValue + "," + s + " ");
399         return "ignored";
400     }
401 
402     //-- static field set with args()
403     /***
404      * @Expression in_scope && set(* s_field) && args(s)
405      */
406     void pc_sfield(String s) {
407     };
408 
409     /***
410      * @Before pc_sfield(s)
411      */
412     public void sfieldBefore(JoinPoint joinPoint, String s) {
413         String fieldValue = ArgsAdviceTest.getStaticField();
414         ArgsAdviceTest.logStatic("before " + fieldValue + "," + s + " ");
415     }
416 
417     /***
418      * @After pc_sfield(s)
419      */
420     public void sfieldAfter(JoinPoint joinPoint, String s) {
421         String fieldValue = ArgsAdviceTest.getStaticField();
422         ArgsAdviceTest.logStatic("after " + fieldValue + "," + s + " ");
423     }
424 
425     /***
426      * @Around pc_sfield(s)
427      */
428     public Object sfieldAround(JoinPoint joinPoint, String s) throws Throwable {
429         String fieldValue = ArgsAdviceTest.getStaticField();
430         ArgsAdviceTest.logStatic("before1 " + fieldValue + "," + s + " ");
431         s = "changed"; // will be ignored due to delegation ! [AJ]
432         Object res = joinPoint.proceed();
433         fieldValue = ArgsAdviceTest.getStaticField();
434         ArgsAdviceTest.logStatic("after1 " + fieldValue + "," + s + " ");
435         return "ignored";
436     }
437 
438 }