添加依赖
<dependency>
<groupId>com.sun</groupId>
<artifactId>tools</artifactId>
<version>1.8</version>
</dependency>
实例代码
@SupportedAnnotationTypes("cn.fireface.call.process.proxy.CallChain")
@SupportedSourceVersion(SourceVersion.RELEASE_7)
public class Process extends AbstractProcessor {
private Messager messager;
private JavacTrees trees;
private TreeMaker treeMaker;
private Names names;
Elements elementUtils;
/** {@inheritDoc} */
@Override
public synchronized void init(ProcessingEnvironment processingEnv) {
System.out.println("init");
super.init(processingEnv);
this.messager = processingEnv.getMessager();
this.trees = JavacTrees.instance(processingEnv);
Context context = ((JavacProcessingEnvironment) processingEnv).getContext();
this.treeMaker = TreeMaker.instance(context);
this.names = Names.instance(context);
elementUtils = processingEnv.getElementUtils();
}
/** {@inheritDoc} */
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
// Set<? extends Element> set = roundEnv.getElementsAnnotatedWith(CallChain.class);
Set<? extends Element> set = roundEnv.getRootElements();
for (Element element : set) {
JCTree jcTree = trees.getTree(element);
if (null==jcTree) {
continue;
}
jcTree.accept(new TreeTranslator() {
@Override
public void visitClassDef(JCTree.JCClassDecl jcClassDecl) {
List<JCTree.JCVariableDecl> jcVariableDeclList = List.nil();
List<JCTree> myDefs = List.nil();
for (JCTree tree : jcClassDecl.defs) {
if(tree.getKind().equals(Tree.Kind.METHOD)){
JCTree.JCMethodDecl jcMethodDecl = (JCTree.JCMethodDecl) tree;
if ("<init>".equals(jcMethodDecl.getName().toString()) || "run".equals(jcMethodDecl.getName().toString())){
myDefs = myDefs.append(tree);
continue;
}
myDefs = myDefs.append(addCall(jcMethodDecl,jcClassDecl));
}else {
myDefs=myDefs.append(tree);
}
}
jcClassDecl.defs = myDefs;
super.visitClassDef(jcClassDecl);
}
});
}
return true;
}
JCTree.JCStatement execute(JCTree.JCStatement statement, final String key){
if (!check(statement.getKind())) {
return statement;
}
statement.accept(new JCTree.Visitor() {
@Override
public void visitTry(JCTree.JCTry jcTry) {
JCTree.JCBlock tryBody = jcTry.body;
jcTry.body = buildNewJcBlock(tryBody, key);
List<JCTree.JCCatch> catches = jcTry.getCatches();
for (JCTree.JCCatch aCatch : catches) {
JCTree.JCBlock catchBody = aCatch.body;
aCatch.body= buildNewJcBlock(catchBody, key);
}
}
@Override
public void visitIf(JCTree.JCIf jcIf) {
JCTree.JCStatement thenpart = jcIf.thenpart;
if (check(thenpart.getKind())) {
jcIf.thenpart = execute(thenpart,key);
}else {
JCTree.JCBlock thenBody = (JCTree.JCBlock) thenpart;
jcIf.thenpart= buildNewJcBlock(thenBody, key);
}
JCTree.JCStatement elseStatement = jcIf.getElseStatement();
if (elseStatement!=null) {
if (check(elseStatement.getKind())) {
jcIf.elsepart = execute(elseStatement,key);
}else {
JCTree.JCBlock elseBody = (JCTree.JCBlock) elseStatement;
jcIf.elsepart = buildNewJcBlock(elseBody, key);
}
}
}
@Override
public void visitForLoop(JCTree.JCForLoop jcForLoop) {
JCTree.JCStatement body = jcForLoop.body;
if (check(body.getKind())) {
jcForLoop.body = execute(body,key);
}else {
JCTree.JCBlock thenBody = (JCTree.JCBlock) body;
jcForLoop.body= buildNewJcBlock(thenBody, key);
}
}
@Override
public void visitForeachLoop(JCTree.JCEnhancedForLoop jcEnhancedForLoop) {
JCTree.JCStatement body = jcEnhancedForLoop.body;
if (check(body.getKind())) {
jcEnhancedForLoop.body = execute(body,key);
}else {
JCTree.JCBlock thenBody = (JCTree.JCBlock) body;
jcEnhancedForLoop.body= buildNewJcBlock(thenBody, key);
}
}
@Override
public void visitCatch(JCTree.JCCatch jcCatch) {
JCTree.JCBlock body = jcCatch.body;
jcCatch.body= buildNewJcBlock(body, key);
}
});
return statement;
}
private JCTree.JCBlock buildNewJcBlock(JCTree.JCBlock body, String key) {
List<JCTree.JCStatement> statements = body.getStatements();
ListBuffer<JCTree.JCStatement> jcStatements = new ListBuffer<>();
for (JCTree.JCStatement jcStatement : statements) {
if (check(jcStatement.getKind())) {
JCTree.JCStatement execute = execute(jcStatement, key);
jcStatements=jcStatements.append(execute);
continue;
}
if (jcStatement.getKind()== Tree.Kind.RETURN || jcStatement.getKind()== Tree.Kind.THROW ) {
JCTree.JCExpressionStatement jcExpressionStatement = buildEndCall(key);
jcStatements=jcStatements.append(jcExpressionStatement);
}
jcStatements=jcStatements.append(jcStatement);
}
return treeMaker.Block(0, jcStatements.toList());
}
private boolean check(JCTree.Kind kind){
return kind== Tree.Kind.TRY ||
kind == Tree.Kind.IF||
kind == Tree.Kind.FOR_LOOP||
kind == Tree.Kind.CATCH;
}
private JCTree.JCExpressionStatement buildEndCall(String key){
JCTree.JCFieldAccess selectEnd = treeMaker.Select(treeMaker.Select(treeMaker.Ident(names.fromString("cn.fireface.call.core.utils")), names.fromString("LogPool")), names.fromString("endLog"));
JCTree.JCMethodInvocation testEnd = treeMaker.Apply(List.<JCTree.JCExpression>nil(), selectEnd, List.<JCTree.JCExpression>of(treeMaker.Literal(key)));
JCTree.JCExpressionStatement exec = treeMaker.Exec(testEnd);
return exec;
}
private JCTree.JCMethodDecl addCall(JCTree.JCMethodDecl jcMethodDecl,JCTree.JCClassDecl jcClassDecl){
try {
String key = getKey(jcMethodDecl, jcClassDecl);
JCTree.JCBlock body = jcMethodDecl.getBody();
ListBuffer<JCTree.JCStatement> statementBuffer = new ListBuffer<>();
JCTree.JCExpressionStatement startCallStatement = buildStartCall(key);
JCTree.JCExpressionStatement endCallStatement = buildEndCall(key);
List<JCTree.JCStatement> oldstatements = body.getStatements();
JCTree returnType = jcMethodDecl.getReturnType();
if (returnType.type.getKind() == TypeKind.VOID) {
statementBuffer.append(startCallStatement);
for (JCTree.JCStatement jcStatement : oldstatements) {
if(jcStatement.getKind()== Tree.Kind.RETURN || jcStatement.getKind()== Tree.Kind.THROW){
statementBuffer.append(endCallStatement).append(jcStatement);
continue;
}
statementBuffer.append(execute(jcStatement,key));
}
if (oldstatements.get(oldstatements.length()-1).getKind() != Tree.
Kind.RETURN && oldstatements.get(oldstatements.length()-1).getKind() != Tree.
Kind.THROW){
statementBuffer.append(endCallStatement);
}
// if (oldstatements.get(oldstatements.length()-1).getKind() == Tree.
// Kind.THROW) {
// statementBuffer.append(startCallStatement).appendArray(oldstatements.subList(0,oldstatements.length()-1).toArray(new JCTree.JCStatement[0])).append(endCallStatement).append(oldstatements.get(oldstatements.length()-1));
// }else {
// statementBuffer.append(startCallStatement).appendArray(oldstatements.toArray(new JCTree.JCStatement[oldstatements.size()])).append(endCallStatement);
// }
}else {
statementBuffer.append(startCallStatement);
for (JCTree.JCStatement jcStatement : oldstatements) {
if(jcStatement.getKind()== Tree.Kind.RETURN || jcStatement.getKind()== Tree.Kind.THROW){
statementBuffer.append(endCallStatement).append(jcStatement);
continue;
}
statementBuffer.append(execute(jcStatement,key));
}
}
JCTree.JCBlock body1 = treeMaker.Block(0, statementBuffer.toList());
return treeMaker.MethodDef(jcMethodDecl.getModifiers(),jcMethodDecl.getName(),jcMethodDecl.restype, jcMethodDecl.getTypeParameters(),jcMethodDecl.getParameters(),jcMethodDecl.getThrows(),body1,jcMethodDecl.defaultValue);
} catch (Exception e) {
return jcMethodDecl;
}
}
private String getKey(JCTree.JCMethodDecl jcMethodDecl, JCTree.JCClassDecl jcClassDecl) {
String classFullName = jcClassDecl.sym.fullname.toString();
String methodName = jcMethodDecl.getName().toString();
return classFullName+"."+methodName;
}
private JCTree.JCExpressionStatement buildStartCall(String key) {
JCTree.JCFieldAccess select = treeMaker.Select(treeMaker.Select(treeMaker.Ident(names.fromString("cn.fireface.call.core.utils")), names.fromString("LogPool")), names.fromString("startLog"));
JCTree.JCMethodInvocation test = treeMaker.Apply(List.<JCTree.JCExpression>nil(), select, List.<JCTree.JCExpression>of(treeMaker.Literal(key)));
return treeMaker.Exec(test);
}
}
