lombok自定义扩展实践

lombok是一款能够在java代码编译阶段改变代码的插件。比如生成setter和getter方法，生成log类变量等，能够简化一些特定的模版式代码。本文将以实现一个基于特定注解生成日志代码的方式，简单介绍在lombok基础上自定义扩展的方式。

1、实现功能

基于自定义注解，将下面的代码块1变成代码块2，自动生成日志代码：

    //代码块1
    static void m1(Map<String, String> req) {
        System.out.println("m1 running");
    }

    //代码块2
    static void m1(Map<String, String> req) {
        log.info("Application.m1 req:{}", JSON.toJSONString(req));
        System.out.println("m1 running");
    }

2、环境准备

首先搭建lombok工程，git地址：https://github.com/rzwitserloot/lombok，并安装ant环境，lombok需要使用ant编译，并下载openjdk（可选），使用openjdk有助于理解javac的源码，因为默认jkd是没有javac的源码的。
关于这些环境，自己想办法百度去搞定吧！

3、核心实现

自定义注解：

package lombok.extern.youzan;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 *
 * Date: 2018/5/26
 * @author xuzhiyi
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.SOURCE)
public @interface LogBefore {
    String level() default "info";
}

这个注解是用来作用在方法上，来表示需要在方法第一行增加代码，log方法传入的参数；

自定义注解解析：

package lombok.javac.handlers;

import com.sun.tools.javac.tree.JCTree;
import com.sun.tools.javac.util.List;
import com.sun.tools.javac.util.ListBuffer;
import com.sun.tools.javac.util.Name;

import org.mangosdk.spi.ProviderFor;

import java.util.logging.Logger;

import lombok.core.AST;
import lombok.core.AnnotationValues;
import lombok.core.HandlerPriority;
import lombok.extern.youzan.LogBefore;
import lombok.javac.JavacAnnotationHandler;
import lombok.javac.JavacNode;
import lombok.javac.JavacTreeMaker;

/**
 * Date: 2018/5/26
 *
 * @author xuzhiyi
 */
@ProviderFor(JavacAnnotationHandler.class)
@HandlerPriority(20)
public class HandleLogBefore extends JavacAnnotationHandler<LogBefore> {

    private static Logger logger = Logger.getLogger(HandleLogBefore.class.getName());

    @Override
    public void handle(AnnotationValues<LogBefore> annotation, JCTree.JCAnnotation ast, JavacNode annotationNode) {
        JavacNode methodNode = annotationNode.up();
        switch (methodNode.getKind()) {
            case METHOD:
                JCTree.JCMethodDecl methodDecl = (JCTree.JCMethodDecl) methodNode.get();
                String methodName = methodDecl.getName().toString();
                String logLevel = annotation.getInstance().level();

                if (logLevel == null) {
                    logLevel = "info";
                }

                String logFieldName = "log";
                String logMethodName = logFieldName + "." + logLevel;

                String className = null;
                String logTypeName = null;
                Name logVarName = null;

                JavacNode typeNode = methodNode.up();
                if (AST.Kind.TYPE == typeNode.getKind()) {
                    JCTree.JCClassDecl classDecl = (JCTree.JCClassDecl) typeNode.get();
                    className = classDecl.getSimpleName().toString();
                    // 遍历类，寻找是否有log类变量
                    for (JCTree def : classDecl.defs) {
                        if (def instanceof JCTree.JCVariableDecl) {
                            JCTree.JCVariableDecl variableDecl = (JCTree.JCVariableDecl) def;
                            if (variableDecl.name.toString().equals(logFieldName)) {
                                logVarName = variableDecl.name;
                                logTypeName = variableDecl.getType().toString();
                                break;
                            }
                        }
                    }
                    // 没有log类变量，则直接返回
                    if (logVarName == null) {
                        return;
                    }
                }

                JCTree.JCBlock block = methodDecl.getBody();
                List<JCTree.JCStatement> statements = block.stats;

                JavacTreeMaker maker = annotationNode.getTreeMaker();

                JCTree.JCExpression logMethod = JavacHandlerUtil.chainDotsString(typeNode, logMethodName);
                JCTree.JCExpression logType = JavacHandlerUtil.chainDotsString(typeNode, logTypeName);

                List<JCTree.JCVariableDecl> parameters = methodDecl.getParameters();

                JCTree.JCExpression apply = maker.Apply(List.<JCTree.JCExpression>of(logType), logMethod,
                                                        generateLogArgs(parameters, className, methodName, maker, typeNode));

                ListBuffer<JCTree.JCStatement> listBuffer = new ListBuffer<JCTree.JCStatement>();
                listBuffer.append(maker.Exec(apply));

                for (JCTree.JCStatement stat : statements) {
                    listBuffer.append(stat);
                }
                methodDecl.body.stats = listBuffer.toList();
                annotationNode.getAst().setChanged();

                break;
            default:
                annotationNode.addError("@LogBefore is legal only on types.");
                break;
        }
    }

    /**
     * 生成log的参数表达式
     */
    public static List<JCTree.JCExpression> generateLogArgs(List<JCTree.JCVariableDecl> parameters, String className, String methodName, JavacTreeMaker maker, JavacNode typeNode) {
        JCTree.JCExpression[] argsArray = new JCTree.JCExpression[parameters.size() + 1];

        StringBuilder stringBuilder = new StringBuilder(className).append(".").append(methodName);
        if (parameters.size() > 0) {
            stringBuilder.append(" ");
            for (JCTree.JCVariableDecl variableDecl : parameters) {
                stringBuilder.append(variableDecl.getName()).append(":{},");
            }
            stringBuilder.deleteCharAt(stringBuilder.length() - 1);
        } else {
            stringBuilder.append(" begin");
        }

        argsArray[0] = maker.Literal(stringBuilder.toString());

        JCTree.JCExpression jsonStringMethod = JavacHandlerUtil.chainDotsString(typeNode, "com.alibaba.fastjson.JSON.toJSONString");

        for (int i = 0; i < parameters.size(); i++) {
            argsArray[i + 1] = maker.Apply(List.<JCTree.JCExpression>nil(), jsonStringMethod, List.<JCTree.JCExpression>of(maker.Ident(parameters.get(i))));
        }

        return List.<JCTree.JCExpression>from(argsArray);
    }
}

这是自定义的处理LogBefore的handler，lombok插件在编译时遇到LogBefore时会掉调用这个handler来处理。这里使用javac的一些相关方法，比较难理解，会将我们的java代码抽象成一颗语法树，我们在这颗树上进行相关的处理动作，关于javac的文档比较少，好在其方法名都比较直接，基本可以通过方法名来理解其作用，使用openjdk在使用的时候会更舒服一些。

4、编译使用

lombok jar 包生成：
在lombok代码当前目录使用ant打包，当前目录cmd下输入ant回车就可以了，jar包会出现在dist目录下。然后用产生的jar包替换掉当前maven仓库中的jar包。

自定义注解使用
书写代码如下：

@Slf4j
public class Application {

    @LogBefore
    static void m1(Map<String, String> req) {
        System.out.println("m1 running");
    }
}

使用mvn clean package打包编译后代码如下：

public class Application {
    private static final Logger log = LoggerFactory.getLogger(Application.class);

    public Application() {
    }

    static void m1(Map<String, String> req) {
        log.info("Application.m1 req:{}", JSON.toJSONString(req));
        System.out.println("m1 running");
    }
}

总结：
1、难点在于handler的逻辑处理，里面的javac的api不太容易掌握，容易出错，本文也只是简单实现，可能还有很多潜在的情况没有考虑到。
2、基于这种在javac期间改变代码的方式，可以在模版代码比较多的时候考虑使用。我后面还写了使用打桩的方式，在代码里放入特定的空方法，再编译期间动态替换的代码，也是一种减少模版代码的方式。