Hi,
Thanks for reply Alexander. I try to answer your questions:
- How are you using the aspect in your code? Do you compile the whole code with the AspectJ compiler (Ajc) or is the aspect in a separate JAR and used via LTW?
[Mike] currently we use ajc and weave it into our product at compile time. But I want to have a separate jar so I can use it with other products.
- How do you intend to use it for other products? LTW? Binary post-compile weaving? Compilation with Ajc? I guess it depends on what you mean by "other products" and whether they are in-house or 3rd party.
[Mike] It is inhouse products. And I want to add aspect ( and all its helper classes) into a seprate jar and use that when I compile the products.
- What do you need the stacktraces for? Please elaborate and explain as detailed as possible.
[Mike] When the target class is called I also get the stacktrace elements
Thread.currentThread().getStackTrace()
>From it I can find the class that calls our deprecated method. Startingpoint is target class. There are irrelevant information in stacktrace that is not applicable ( classes that are part of the java API or test frameworks).
We also look up information in gerrit and push data to a db. So there are more classes.
- Is your intention to find usages of your own deprecated methods or that of 3rd party code, maybe even JRE/JDK?
[Mike] Yes it is our own deprecated methods. No 3rd party code or JRE/JDK that we why I analyze the stacktrace.
- Have you considered using the AspectJ features "declare error" or "declare warning" and just get rid of deprecated class/method usage right during compilation instead of during runtime, using expensive stacktrace analysis?
[Mike] I guess this means that users have to get rid of their deprecated method usage at compile time. It is an interesting option.
Do you have an example on how it works. WIll compilation fail?
- As for your original question, the answer could be anything from implementing an interface as you suggest to using an abstract base aspect. But really, this looks like a "declare warning" use case to me.
[Mike] We have had issues when forcing people to change. Some users is afraid of change. So it is merly a "soft" issue. Will the new method be as stable as old.
- Would you mind giving us a full picture with the stacktrace helper class and some simple sample code? An [SSCCE](http://sscce.org/) maybe?
[Mike] Sure I will include it here ( see below).
Sample code:
package com.company.aspect;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
/**
* Helper class for stacktraces
*/
class StackTraceHelper {
private ListIterator<StackTraceElement> iterator = null;
private StringBuilder builder = null;
private final List<String> excludedPackages = new ArrayList<>();
public StackTraceHelper(List<StackTraceElement> stackTraceElements) {
this.iterator = stackTraceElements.listIterator();
stackTraceToString(stackTraceElements);
}
/**
* Find matching stack trace element and set iterator.
*
* @param className
* @return {@link StackTraceElement} matching className
*/
public StackTraceElement matchClassName(String className) {
while (iterator.hasNext()) {
StackTraceElement ste = iterator.next();
if (className.equals(ste.getClassName())) {
return ste;
}
}
//TODO: warn that no StackTraceElement was found for Name.
return null;
}
public StackTraceElement next() {
return iterator.next();
}
public boolean hasNext() {
return iterator.hasNext();
}
public boolean hasPrevious() {
return iterator.hasPrevious();
}
public StackTraceElement previous() {
iterator.previous();
return iterator.previous();
}
@Override
public String toString() {
return builder.toString();
}
DeprecatedMethodData extractData(String targetClass) {
DeprecatedMethodData dmd = new DeprecatedMethodData();
dmd.setTargetClassName(targetClass);
//This is the called class so we need to make sure that next class is a test class
//otherwise we are not interested.
StackTraceElement steTarget = this.matchClassName(targetClass);
if (steTarget != null) {
//we have a match of target in stack trace
while (this.hasNext()) {
StackTraceElement ste = this.next();
String clazzName = ste.getClassName();
String methodName = ste.getMethodName();
if (this.isTestClass(clazzName) && !this.isExternalFramework(clazzName)) {
//if (this.isTestClass(clazzName)) {//TODO: Fix
dmd.setCallingClassName(clazzName);
dmd.setCallingMethodName(methodName);
dmd.setDeprecatedClassName(steTarget.getClassName());
dmd.setDeprecatedMethodName(steTarget.getMethodName());
dmd.setAccess(Access.EXTERNAL);
break;
}
dmd.setAccess(Access.INTERNAL);
}
}
//Add complete stacktrace to find problems with current algorithm.
dmd.setStackTrace(this.builder.toString());
return dmd;
}
/**
* Must be called first thing since next operations
* will affect this.
*/
private void stackTraceToString(List<StackTraceElement> stackTraceElements) {
final ListIterator<StackTraceElement> iter = stackTraceElements.listIterator();
builder = new StringBuilder();
while (iter.hasNext()) {
builder.append(iter.next().toString());
}
}
public boolean isInternal(String clazz) {
if (clazz
.matches(
"^(com.company.manager|com.company.helpers|"
+ "com.company.actions|com.company.configuration|"
+ "com.company.demo).*")) {
//LogerHelper.log("internal class:" + clazz);
return true;
}
return false;
}
public boolean isJava(String clazz) {
if (clazz.startsWith("sun") ||
clazz.startsWith("java")) {
//LogerHelper.log("java class:" + clazz);
return true;
}
return false;
}
public boolean isTestClass(String clazz) {
if (isInternal(clazz) || isJava(clazz)) {
return false;
}
return true;
}
public boolean isExternalFramework(String clazz) {
if (clazz.startsWith("org.testng") || clazz.startsWith("org.apache.maven.surefire")) {
return true;
}
return false;
}
//TODO: Not ready yet.
// public void excludePackages(List<String> packageNames) {
// excludedPackages.addAll(packageNames);
// }
//
// boolean exclude(String clazz) {
// for (String exclude : excludedPackages) {
// if (clazz
// .matches(
// "^(" + exclude + ").*")) {
// return true;
// }
// }
// return false;
// }
//
// boolean isTestClass2(String clazz) {
// return exclude(clazz);
// }
}