在aspectj之后（）

Question

I am new to aspectj and I had a function which gets the integer variable and adds 100 to it as follows

public static void add(int no)
    {
        no=no+100;


    }

My aspect is as follows

pointcut printMessage(int m) : execution(* add(..)) && args(m);
 after(int m) returning: printMessage(m) {
            System.out.println(m);
}

I am calling the function with the value 10. But when I run the code, it returns the result as 10. can any one tell me why it is not returning 110. correct me if I am wrong

Answer 1

Because in java an int is not modifiable. If you write

int i = 10;
add(i);
System.out.println(i);

You will still get 10. So your aspect does what you asked : you pass a variable of value 10 to a function, the fuction does what it wants with its local copy, and on return the variable is unchanged

Edit :

If you want to get a modified value, you could pass a modifiable variable like an array, or more simply use the return value (because your current add is a no op) :

Edit 2 here is full test code :

public class AspectTest {
    public static int add(int i) {
        return i+100;
    }

    @Test
    public void test() throws Exception {
        int j = add(10);
        assertEquals(110, j);
        add(20);
    }
}

and :

aspect A {
pointcut printMessage() : execution(* add(..));
 after() returning (int m): printMessage() {
            System.out.println(m);
}
}

Output :

Running ...AspectTest
110
120
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.214 sec

Answer 2

Here is a variant of Serge Ballesta's sample code which makes it even clearer what happens in Java. Primitive types like int are immutable, but even some simple built-in object types like String are, too. More complex types like Set are not, though.

Driver application with different add methods:

package de.scrum_master.app;

import java.util.HashSet;
import java.util.Set;

public class Application {
    public static int add(int i) {
        i += 100;
        return i;
    }

    public static String add(String text) {
        text = "#" + text + "#";
        return text;
    }

    public static Set<String> add(Set<String> set) {
        set.add("new element");
        return set;
    }

    public static void main(String[] args) {
        add(10);
        add("foo");
        Set<String> mySet = new HashSet<>();
        mySet.add("foo");
        mySet.add("bar");
        add(mySet);
    }
}

Aspect capturing all add methods, printing their parameters and results for comparison:

package de.scrum_master.app;

public aspect MyAspect {
    pointcut addMethods(Object parameter) :
        execution(* add(*)) && args(parameter);

    after(Object parameter) returning (Object returnValue): addMethods(parameter) {
        System.out.println(thisJoinPoint);
        System.out.println("  parameter    = " + parameter);
        System.out.println("  return value = " + returnValue);
    }
}

Console output:

execution(int de.scrum_master.app.Application.add(int))
  parameter    = 10
  return value = 110
execution(String de.scrum_master.app.Application.add(String))
  parameter    = foo
  return value = #foo#
execution(Set de.scrum_master.app.Application.add(Set))
  parameter    = [new element, foo, bar]
  return value = [new element, foo, bar]

As you can see, int and String parameters remain unchanged while the Set parameter is mutable and thus updated.