I'm getting near to the solution, but I've got still a few problems. First of
all the pointcut:
pointcut lazyLoaderRequired( LazyLoading loadingProperties, FilteredLoader
mySelf ) :
( get( @LazyLoading Collection<SerializableObject+>+
SerializableObject+.* )
||
get( @LazyLoading Map<SerializableObject+, DatabaseObject+>+
SerializableObject+.* )
)
&&
@annotation( loadingProperties )
&&
this( mySelf )
&&
(! execution( public void FilteredLoader.loadFilteredData(Class) ) ) ;
so I catch any access to a variable that is a plain collection or a map that
has been annotated with @LazyLoading. This works, so I've got the following
advice:
before( LazyLoading loadingProperties, FilteredLoader mySelf) :
lazyLoaderRequired( loadingProperties, mySelf){
// get the annotation properties
Class requiredType = loadingProperties.type();
try{
// load the data only if it has not already been loaded or I must
override the loaded
// data
if( (! this.loadingMap.containsKey(mySelf) ) ||
( loadingProperties.alwaysReload() &&
this.loadingMap.containsKey(mySelf) )
){
mySelf.loadFilteredData(requiredType);
this.loadingMap.put(mySelf, requiredType);
System.out.println("Lazy loading for the type " + requiredType
+ " " +
mySelf);
}
else{
System.out.println("not loading " + requiredType + " " +
mySelf);
}
}catch(Exception e){
Logger.exception("Exception caught while performing the lazy
loading
within the aspect", e);
}
}
So I got the Class type of the collection I need to load, and invoke the
loadFilteredData on the target. The problem is that there's an infinite
recursion. The loadFilteredData method is the following:
public void loadFilteredData(Class type) throws DatabaseException{
// check what kind of data should I load
if( type == null )
return;
try{
if( type.equals(Skill.class) ){
// load the skills
this.refreshSkills();
}
else
if( type.equals(Role.class) ){
// load the roles
this.refreshRoles();
}
else
if( type.equals(KnowledgeLevel.class) ){
// load the knowledge level
this.refreshHires();
}
else
if( type.equals(Hire.class) ){
// load the hires
this.refreshHires();
}
}catch(SQLException e){
Logger.exception("Exception caught while loading filtered data", e);
throw new DatabaseException("Exception caught while loading
filtered data
of type " + type);
}
}
I guess the problem is in the loadFIlteredData method, that invokes another
method (e.g., refreshSkills()) that access a variable that is annotated with
@LazyLoading, and so there's the recursion. How should I avoid the recursion,
so excluding everything that happens since loadFilteredData ahead?
Thanks,
Luca
_______________________________________________
aspectj-users mailing list
aspectj-users@eclipse.org
https://dev.eclipse.org/mailman/listinfo/aspectj-users
