lombok自定义扩展实践

作者: 徐志毅 | 来源:发表于2018-06-03 22:25 被阅读0次

    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期间改变代码的方式,可以在模版代码比较多的时候考虑使用。我后面还写了使用打桩的方式,在代码里放入特定的空方法,再编译期间动态替换的代码,也是一种减少模版代码的方式。

    相关文章

      网友评论

        本文标题:lombok自定义扩展实践

        本文链接:https://www.haomeiwen.com/subject/tmjssftx.html