AI编程：可视化Java项目拆解第一弹，解析本地Java项目

public void execute(List<CtType<?>> elements) {
        classStructs = Lists.newArrayList();
        for (CtType<?> type : elements) {
            try {
                // 匿名内部类和泛型会跳过解析
                if (type.isAnonymous()) {
                    continue;
                }
                if (Objects.isNull(type.getPackage())) {
                    continue;
                }
                // 获取类的简单类名
                String simpleClassName = type.getSimpleName();
                // GPT 接口获取解释
                String chatDesc = "";
                // 获取类所属包
                String packageName = type.getPackage().getQualifiedName();
                // 获取类注释信息
                String classComment = type.getDocComment();
                // 判断接口还是类
                ClassType classType = getClassType(type);
                // 获取类注解信息
                List<AnnotationInfo> annotationInfos = Lists.newArrayList();
                List<CtAnnotation<?>> annotations = type.getAnnotations();
                for (CtAnnotation<?> annotation : annotations) {
                    AnnotationInfo annotationInfo = new AnnotationInfo();
                    String annotationName = annotation.getAnnotationType().getSimpleName();
                    annotationInfo.setAnnotationName(annotationName);
                    Map<String, CtExpression> annotationValues = annotation.getValues();
                    for (Map.Entry<String, CtExpression> entry : annotationValues.entrySet()) {
                        String attributeName = entry.getKey();
                        Object attributeValue = entry.getValue();
                        annotationInfo.addAttributeName(attributeName, attributeValue.toString());
                    }
                    annotationInfos.add(annotationInfo);
                }
                // 构造类元信息
                ClassStruct classStruct = buildClassStruct(simpleClassName, packageName, classType,
                        classComment, annotationInfos, chatDesc);
                classStructs.add(classStruct);
            } catch (Exception e) {
                log.error("class parse error, className ==>{}, errMsg ==>", type.getSimpleName(), e);
            }
        }
        // 类元信息入库
    }

public void execute(List<CtType<?>> elements) {
        methodStructs = Lists.newArrayList();
        for (CtType<?> element : elements) {
            if (element.isAnonymous()) {
                continue;
            }
            if (Objects.isNull(element.getPackage())) {
                continue;
            }
            // 获取包名
            String packageName = element.getPackage().getQualifiedName();
            // 获取类名
            String className = element.getSimpleName();
            // 获取方法列表
            Set<CtMethod<?>> methods = element.getMethods();
            for (CtMethod<?> method : methods) {
                try {
                    // 获取简单方法名
                    String methodName = method.getSimpleName();
                    // 获取全限定参数
                    String signatureParameters = method.getSignature();
                    int firstIndex = method.getSignature().indexOf("(");
                    int lastIndex = method.getSignature().indexOf(")");
                    String parameters = signatureParameters.substring(firstIndex + 1, lastIndex);
                    List<String> methodParameters = Splitter.on(",").omitEmptyStrings().splitToList(parameters);
                    // 获取响应体类型
                    String responseType = method.getType().getQualifiedName();
                    // 获取方法开始的行
                    int startLine = method.getPosition().getLine();
                    // 获取方法结束的行
                    int endLine = method.getPosition().getEndLine();
                    // 获取方法注释
                    String methodComment = method.getDocComment();
                    // 获取方法包含的注解信息
                    List<AnnotationInfo> annotationInfos = Lists.newArrayList();
                    List<CtAnnotation<?>> annotations = method.getAnnotations();
                    for (CtAnnotation<?> annotation : annotations) {
                        AnnotationInfo annotationInfo = new AnnotationInfo();
                        String annotationName = annotation.getAnnotationType().getSimpleName();
                        annotationInfo.setAnnotationName(annotationName);
                        Map<String, CtExpression> annotationValues = annotation.getValues();
                        for (Map.Entry<String, CtExpression> entry : annotationValues.entrySet()) {
                            String attributeName = entry.getKey();
                            Object attributeValue = entry.getValue();
                            annotationInfo.addAttributeName(attributeName, attributeValue.toString());
                        }
                        annotationInfos.add(annotationInfo);
                    }
                    // 获取方法的访问修饰符
                    String accessModifier = "";
                    if (Objects.isNull(method.getVisibility())) {
                        accessModifier = "default";
                    } else {
                        accessModifier = method.getVisibility().toString();
                    }
                    String methodId = generateIdentityUtil.generateMethodId(MethodSignature.builder()
                            .packagePath(packageName)
                            .className(className)
                            .methodName(methodName)
                            .parameterTypeString(methodParameters)
                            .build(), endLine - startLine + 1);


                    MethodStruct old = null;
                    // 基于规则判断一波是否需要询问chat
                    int lineCount = endLine - startLine;

                    MethodStruct methodStruct = MethodStruct.builder()
                            .appCode(GlobalVariableUtil.getAppCodeName())
                            .methodId(methodId)
                            .methodName(methodName)
                            .classId(generateIdentityUtil.generateClassId(className, packageName, GlobalVariableUtil.getAppCodeName()))
                            .paramTypes(methodParameters)
                            .responseType(responseType)
                            .beginLine(startLine)
                            .endLine(endLine)
                            .branch(GlobalVariableUtil.getBranch())
                            .methodDesc(methodComment)
                            .annotationInfos(annotationInfos)
                            .accessModifier(accessModifier)
                            .invokeCount(old == null ? 0 : old.getInvokeCount())
                            .mermaidFlowGraph(old == null ? "" : old.getMermaidFlowGraph())
                            .build();
                    if (old == null) {
                        methodStructs.add(methodStruct);
                    }
                } catch (Exception e) {
                    log.error("method parse error, className ==>{}, methodName ==>{}, errMsg ==>",
                           className, method.getSimpleName(), e);
                }
            }
        }
//       方法元信息入库
    }