使用javaparser替换项目中的代码

package com.d1m.common.logs;

import cn.hutool.core.io.FileUtil;
import com.github.javaparser.ParseResult;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.ImportDeclaration;
import com.github.javaparser.ast.Node;
import com.github.javaparser.ast.NodeList;
import com.github.javaparser.ast.body.MethodDeclaration;
import com.github.javaparser.ast.body.TypeDeclaration;
import com.github.javaparser.ast.expr.Expression;
import com.github.javaparser.ast.expr.MethodCallExpr;
import com.github.javaparser.ast.expr.NameExpr;
import com.github.javaparser.ast.expr.StringLiteralExpr;
import com.github.javaparser.ast.stmt.IfStmt;
import com.github.javaparser.ast.visitor.ModifierVisitor;
import com.github.javaparser.ast.visitor.Visitable;
import com.github.javaparser.utils.CodeGenerationUtils;
import com.github.javaparser.utils.SourceRoot;

import java.io.File;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;


/**
 * @ClassName Demo
 * @Description TODO
 * @Author yanqing.liu
 * @Date 2021/6/20 10:41 下午
 * @Version 1.0
 */
public class LogParseV2 {

    /**
     * 项目路径
     */
    public static final String SOURCE_URL = "/Users/liuyanqing/work/estore-core的副本";

    /**
     * utils import
     */
    public static final String IMPORT_NAME = "com.d1m.common.logs";

    /**
     * 工具类名
     */
    public static final String LOG_UTILS_NAME = "LogUtils";

    /**
     * 方法名
     */
    public static final String LOG_UTILS_METHOD_NAME = "method";

    /**
     * 方法模板(内容)
     *  packageName 日志所在文件的包路径
     *  className   日志所在文件名
     *  methodName  日志所在方法名
     *  original 日志原始参数
     *  classReferenceName 日志所在文件全限定名
     *
     */
    public static final List<String> METHOD_FORMAT = Arrays.asList("classReferenceName","methodName","original");


    public static void main(String[] args) {
        String sourceUrl = SOURCE_URL;

        try {
            //URI uri = new URI(sourceUrl);
            Path path = Paths.get(sourceUrl);
            SourceRoot sourceRoot = new SourceRoot(path);


            List<ParseResult<CompilationUnit>> parseResults = sourceRoot.tryToParse("src/main/java");
            for (ParseResult<CompilationUnit> parseResult : parseResults) {
                Optional<CompilationUnit> result = parseResult.getResult();
                if (!result.isPresent()) {
                    continue;
                }
                CompilationUnit cu =  result.get();
                LogParseV2.parse(cu);
            }

            //备份老文件
            String  srcPath = sourceUrl + FileUtil.FILE_SEPARATOR+"src";
            String  destPath = sourceUrl + FileUtil.FILE_SEPARATOR+"src-bac";
            FileUtil.copy(srcPath,destPath,false);

            sourceRoot.saveAll(
                    CodeGenerationUtils.mavenModuleRoot(LogParseV2.class)
                            .resolve(sourceUrl));

        }catch (Exception e){
            e.printStackTrace();
        }

    }

    public static void parse(CompilationUnit cu){

        if (cu == null || cu.getTypes() == null || cu.getTypes().isEmpty()) {
            return;
        }
        boolean isLog = false;
        for (ImportDeclaration anImport : cu.getImports()) {
            String nameAsString = anImport.getNameAsString();
            if (nameAsString.contains("Slf4j") || nameAsString.contains("slf4j")) {
                isLog = true;
                break;
            }
        }

        if (!isLog){
            return;
        }

        String  packageName = cu.getPackageDeclaration().get().getNameAsString();

        String className = cu.getTypes().get(0).getNameAsString();
        //获取类信息
        cu.accept(new ModifierVisitor<Void>() {


            @Override
            public Visitable visit(MethodCallExpr n, Void arg) {
                String string = n.toString();
                String regex = "^[L|l][O|o][G|g]\\.[(info)|(debug)|(error)|(warn)].+";
                MethodCallExpr newMethodCall = new MethodCallExpr();
                if (string.matches(regex)){

                    // 添加import
                    ImportDeclaration importDeclaration = new ImportDeclaration(IMPORT_NAME,false,true);
                    cu.addImport(importDeclaration);


                    NameExpr nameExpr =   (NameExpr)n.getScope().get();
                    nameExpr.setName(LOG_UTILS_NAME);

                   /* if (string.contains("info")){
                        n.setName("info");
                    }else if (string.contains("debug")){
                        n.setName("debug");
                    }else if (string.contains("error")){
                        n.setName("error");
                    }else if (string.contains("warn")){
                        n.setName("warn");
                    }*/



                    NodeList<Expression> arguments = n.getArguments();

                    NodeList<Expression> argumentsNew = new NodeList();
                    StringLiteralExpr classNameExpr = new StringLiteralExpr();
                    classNameExpr.setValue(className);

                    StringLiteralExpr packageNameExpr = new StringLiteralExpr();
                    packageNameExpr.setValue(packageName);

                    StringLiteralExpr refesrenceExpr = new StringLiteralExpr();
                    refesrenceExpr.setValue(packageName+"."+className);

                    // 获取方法名
                    Node node = n.getParentNode().get();
                    String methodName = LogParseV2.findMethod(node);
                    StringLiteralExpr methodNameExpr = new StringLiteralExpr();
                    methodNameExpr.setValue(methodName);

                    for (String s : METHOD_FORMAT) {
                        switch (s){
                            case "packageName" :
                                argumentsNew.add(packageNameExpr);
                                break;
                            case "className" :
                                argumentsNew.add(classNameExpr);
                                break;
                            case "methodName" :
                                argumentsNew.add(methodNameExpr);
                                break;
                            case "classReferenceName" :
                                argumentsNew.add(refesrenceExpr);
                                break;
                            case "original" :
                                for (Expression argument : arguments) {
                                    argumentsNew.add(argument);
                                }
                                break;

                        }
                    }

                    n.setArguments(argumentsNew);
                    System.out.println(n.toString());
                }
                return super.visit(n, arg);
            }
        }, null);



    }

    public static String findMethod(Node node){
        if (node instanceof MethodDeclaration) {
            return ((MethodDeclaration) node).getNameAsString();
        }
        return findMethod(node.getParentNode().get());
    }


}