add return method

Author: hsjfans

src/main/java/com/hsjfans/github/model/ApiTree.java

@@ -1,53 +1,45 @@
 package com.hsjfans.github.model;
 
 import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import lombok.Data;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.PatchMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 
 import java.io.Serializable;
+import java.util.Collection;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.ConcurrentMap;
 
 /**
  * @author hsjfans[hsjfans.scholar@gmail.com]
  */
-@Controller
-@RequestMapping(value = "/123/",method = {RequestMethod.POST,RequestMethod.GET})
+
+@Data
 public class ApiTree implements Serializable {
 
-    private static  final ConcurrentMap<Class<?>,ControllerClass> controllerClassMap
-            = Maps.newConcurrentMap();
+    private final Set<ControllerClass> set
+            = Sets.newHashSet();
 
     /**
-     *  insert the controller cl
-     * @param cl
+     * insert the controller cl
+     *
+     * @param controllerClass
      */
-    @PatchMapping(value ={ "/123","/456"})
-    public void insert(Class<?> cl,ControllerClass controllerClass){
-        controllerClassMap.putIfAbsent(cl,controllerClass);
+    public void insert(ControllerClass controllerClass) {
+        set.add(controllerClass);
     }
 
 
-    /**
-     * @name 测试get
-     */
-    @RequestMapping(value = "/789")
-    public void get(){
-        return;
+    public void insertAll(Collection<? extends ControllerClass> controllerClasses) {
+        set.addAll(controllerClasses);
     }
 
 
-    /**
-     * @name 测试set
-     */
-    @RequestMapping("/123-12312")
-    public void set(){
-        return;
-    }
-
-    public static ConcurrentMap<Class<?>, ControllerClass> getControllerClassMap() {
-        return controllerClassMap;
+    public void union(ApiTree apiTree) {
+        set.addAll(apiTree.getSet());
     }
 }

src/main/java/com/hsjfans/github/model/RequestParam.java

@@ -68,5 +68,7 @@ public class RequestParam implements Serializable {
     private List<RequestParam> params;
 
 
+    private Object[] enumValues;
+
 
 }

src/main/java/com/hsjfans/github/model/ResponseReturn.java

@@ -2,6 +2,8 @@
 
 import lombok.Data;
 
+import java.util.List;
+
 /**
  * @author hsjfans[hsjfans.scholar@gmail.com]
  */
@@ -11,7 +13,7 @@ public class ResponseReturn {
     /**
      *  the return item
      */
-    private ReturnItem returnItem;
+    private List<RequestParam> returnItem;
 
     /**
      *  the description
@@ -24,6 +26,10 @@ public class ResponseReturn {
      */
     private String name;
 
+    /**
+     *  the type
+     */
+    private String type;
 
 
 

src/main/java/com/hsjfans/github/model/ReturnItem.java

@@ -23,9 +23,12 @@ public abstract class AbstractParser implements Parser  {
 
     protected final Config config;
 
+    private final ApiTree apiTree;
+
     public AbstractParser(Config config){
         this.config = config;
         this.classLoader = new ApiClassLoader(config);
+        this.apiTree = new ApiTree();
     }
 
 
@@ -43,14 +46,21 @@ public ApiTree parse(String projectPath, boolean recursive) throws ParserExcepti
         Set<CompilationUnit> compilationUnits =  getAllControllerClass(javaFiles);
         Set<ControllerClass> controllerClasses = Sets.newHashSet();
         compilationUnits.forEach(compilationUnit -> parseCompilationUnit(compilationUnit,controllerClasses));
-        return null;
+        this.apiTree.insertAll(controllerClasses);
+        return apiTree;
     }
 
 
     @Override
     public ApiTree parse(List<String> projectPaths, boolean recursive) throws ParserException {
-       // todo
-        return null;
+        projectPaths.forEach(path->{
+            try {
+                this.apiTree.union(this.parse(path,recursive));
+            } catch (ParserException e) {
+                e.printStackTrace();
+            }
+        });
+        return this.apiTree;
     }
 
 

src/main/java/com/hsjfans/github/parser/AbstractParser.java

@@ -2,8 +2,10 @@
 
 
 import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.NodeList;
 import com.github.javaparser.ast.PackageDeclaration;
 import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.body.Parameter;
 import com.github.javaparser.ast.body.TypeDeclaration;
 import com.github.javaparser.ast.expr.AnnotationExpr;
 import com.google.common.collect.Lists;
@@ -105,22 +107,31 @@ protected void   parseCompilationUnit(CompilationUnit compilationUnit,final Set<
 
                LogUtil.info(" className = %s 加载完毕 %s",className,controllerClass);
                final List<ControllerMethod> controllerMethods = Lists.newArrayListWithCapacity(cl.getMethods().length);
+
                // just public method
+               // PostMapping GetMapping ...
                Arrays.stream(cl.getMethods())
                        .filter(method ->
                        Arrays.stream(method.getAnnotations()).anyMatch(annotation ->
                                SpringUtil.map.containsKey(annotation.annotationType().getSimpleName())))
                .forEach(method -> {
+//                     LogUtil.info(" method signature  is %s",methodSignature(method));
+//                   LogUtil.info(" methodDeclarations  are %s",typeDeclaration.getMethods().get(0).getSignature().asString());
 //                   LogUtil.info(" methodName is %s annotations len = %s ",method.getName(),method.getAnnotations()[0].annotationType().getSimpleName());
-                   List<MethodDeclaration> methodDeclarations = typeDeclaration.getMethodsByName(method.getName());
-//                   LogUtil.info( " methodDeclarations is %s",methodDeclarations.toString());
+                    List<MethodDeclaration> methodDeclarations = typeDeclaration.getMethodsBySignature(method.getName(),methodSignature(method));
+//                    typeDeclaration.getMethods().forEach(methodDeclaration -> {
+//                        System.out.println(methodDeclaration.getSignature().asString());
+//                    });
+                   LogUtil.info( " methodDeclarations is %s and method is %s ",methodDeclarations.toString(),method.getName());
                    if(methodDeclarations.size()>0){
                        ControllerMethod controllerMethod = null;
                        try {
-                           controllerMethod = ClassUtils.parseMethodComment(methodDeclarations.get(0).getComment().orElse(null),method);
+                           controllerMethod = ClassUtils.parseMethodComment(methodDeclarations.get(0),method);
                            if(controllerMethod!=null){
                                controllerMethod.setAClass(cl);
+                               controllerMethod.setMethod(method);
                                controllerMethods.add(controllerMethod);
+                               LogUtil.info( " methodDeclarations %s 解析完毕",methodDeclarations.toString());
                            }
                        } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
                            LogUtil.error(" err = %s ",e.getMessage());
@@ -137,14 +148,12 @@ protected void   parseCompilationUnit(CompilationUnit compilationUnit,final Set<
 
     }
 
-    private static String methodSignature(Method method){
-        StringBuilder stringBuilder = new StringBuilder(method.getName());
-        Arrays.stream(method.getParameters()).forEach(
-                parameter -> {
-                    stringBuilder.append(parameter.getType().getSimpleName());
-                }
-        );
-        return stringBuilder.toString();
+    private static String[] methodSignature(Method method){
+        String[] strings = new String[method.getParameters().length];
+        for (int i = 0; i < method.getParameters().length; i++) {
+            strings[i] = method.getParameters()[i].getType().getSimpleName();
+        }
+        return strings;
     }