Spring AOP #Aspect J : how do I give Aspects access to other classes - class

Question

I am quite new to Java and Spring. I would like to find out if it is possible and if so how I can get my aspects to apply to more than one class without having to call the method from the class where the aspects "work".
This is my main class. Aspects work on any methods I call diresctly from this class, but will not work on any of the other methods called by other classes (even if they are not internal)
public class AopMain {
public static void main(String[] args) {
String selection = "on";
ApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml");
do {
try{
System.out.println("Enter 'length' for a length conversion and 'temperature' for a temperature conversion and 'quit' to quit");
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
selection = br.readLine();
if(selection.contentEquals("length")) {
LengthService lengthService = ctx.getBean("lengthService", LengthService.class);
lengthService.runLengthService();
lengthService.display();
}
else if(selection.contentEquals("temperature")) {
TemperatureService temperatureService = new TemperatureService();
temperatureService.runTempertureService();
temperatureService.display();
}
}
catch (Exception e) {
System.out.println("Input error");
}
} while (!selection.contentEquals("quit"));
}
}
This is one of the conversion service classes:
public class TemperatureService {
String fromUnit = null;
String toUnit = null;
double val = 0;
double converted = 0;
public void runTempertureService() {
Scanner in = new Scanner(System.in);
System.out.println("Convert from (enter C, K, F): ");
fromUnit = in.nextLine();
System.out.println("Convert to (enter C, K, F): ");
toUnit = in.nextLine();
TemperatureConverter from = new TemperatureConverter(fromUnit);
TemperatureConverter to = new TemperatureConverter(toUnit);
System.out.println("Value:");
val = in.nextDouble();
double celcius = from.toCelcius(val);
converted = to.fromCelcius(celcius);
from.display(val, fromUnit, converted, toUnit);
System.out.println(val + " " + fromUnit + " = " + converted + " " + toUnit);
}
public String[] display(){
String[] displayString = {Double.toString(val), fromUnit, Double.toString(converted), toUnit};
return displayString;
}
}
And this is one of the conversion classes:
public class TemperatureConverter {
final double C_TO_F = 33.8;
final double C_TO_C = 1;
final double C_TO_KELVIN = 274.15;
private double factor;
public TemperatureConverter(String unit) {
if (unit.contentEquals("F"))
factor = C_TO_F;
else if(unit.contentEquals("C"))
factor = C_TO_C;
else if(unit.contentEquals("K"))
factor = C_TO_KELVIN;
}
public double toCelcius(double measurement) {
return measurement * factor;
}
public double fromCelcius(double measurement) {
return measurement/factor;
}
public TemperatureConverter() {}
public void display(double val, String fromUnit, double converted, String toUnit) {}
}
This is my configuration file:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<aop:aspectj-autoproxy/>
<bean name= "lengthConverter" class= "converter.method.LengthConverter"/>
<bean name= "temperatureConverter" class= "converter.method.TemperatureConverter"/>
<bean name= "lengthService" class= "converter.service.LengthService" autowire = "byName"/>
<bean name= "temperatureService" class= "converter.service.TemperatureService"/>
<bean name="ValidationAspect" class= "converter.aspect.ValidationAspect" />
<bean name="DisplayAspect" class= "converter.aspect.DisplayAspect" />
</beans>
I want to be able to apply an aspect to functions of the converter class called by the service class but like I have mentioned, it doesnt work unnless the method is called from the main class directly. (the display function was originally part of the converter class but I moved it so that the aspect would work). Also why will an aspect not pick up the newline() method call?
Edit:
This is one of my aspects:
#Aspect
public class DisplayAspect {
#AfterReturning(pointcut = "execution(* display(..))", returning = "retVal")
public void fileSetUp(Object retVal) {
System.out.println("So we found the display things");
Writer writer = null;
String[] returnArray = (String[]) retVal;
try {
System.out.println("inside try");
String text = "The opertion performed was: " + returnArray[0] + " in " + returnArray[1] + " is " + returnArray[2] + " " + returnArray[3] + "\n";
File file = new File("Log.txt");
writer = new BufferedWriter(new FileWriter(file, true));
writer.write(text);
} catch (FileNotFoundException e1) {
e1.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (writer != null) {
writer.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

Answer 1

I want to be able to apply an aspect to functions of the converter class
Well, then change your pointcut so as intercept the methods (not functions, they are called methods) you want to handle in your advice. At the moment the pointcut is
execution(* display(..))
I.e. it will intercept all methods named display with any number of parameters and any return type. If you want to intercept all converter methods instead, change it to
execution(* converter.method.TemperatureConverter.*(..))
instead.
like I have mentioned, it doesnt work unnless the method is called from the main class directly.
I need to guess because this description is unclear, but probably What you are trying to describe is that the advice is only applied if the TemperatureService.display() is called from outside the class, not from a method within TemperatureService. This is a known and well described limitation of Spring AOP, see Spring Manual, chapter 9.6, "Proxying mechanisms": Due to the proxy-based "AOP lite" approach of Spring AOP, this cannot work because internal calls to methods of this, are not routed through the dynamic proxy created by the Spring container. Thus, Spring AOP only works for inter-bean calls, not intra-bean ones. If you need to intercept internal calls, you need to switch to full-blown AspectJ, which can be easily integrated into Spring applications via LTW (load-time weaving) as described in chapter 9.8, "Using AspectJ with Spring applications".