解析Spring mvc 项目的所有http请求

深藏阁楼爱情的钟 2022-09-25 08:19 32阅读 0赞

结合自己的注解完成spring mvc项目里对所有action请求的解析，主要是反射和注解的使用  
代码如果看不懂，可以关注我的git，以后会写一个能够产生htpp接口甚至接口的文档

[我的git][git]

[项目源码][Link 1]

package com.galaxy.fym.common;
    
    import com.galaxy.fym.model.*;
    import org.apache.commons.collections.CollectionUtils;
    import org.apache.commons.lang.StringUtils;
    import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    import java.io.IOException;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    import java.lang.reflect.Modifier;
    import java.lang.reflect.Parameter;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    /** * Created by fengyiming on 2016/8/15. */
    public class SpringMVCAnnotationUtils { 
    
        public final static String BANK = "";
    
        public static List<ClassDocument> getAllController(String packageName) throws IOException {
            List<ClassDocument> list = new ArrayList<ClassDocument>();
            List<Class<?>> controllerList = ClassUtils.getAnnotationClassList(packageName, Controller.class);
            for (Class<?> clazz : controllerList) {
                if (clazz.isAnnotationPresent(RequestMapping.class)) {
                    ClassDocument classDocument = getClassDocument(clazz);
                    list.add(classDocument);
                }
            }
            return list;
        }
    
        public static ClassDocument getClassDocument(Class<?> clazz) {
            ClassDocument classDocument = new ClassDocument();
            String packageName = clazz.getPackage().getName();
            String[] module = {};
            int sort = 0;
            String desc = BANK;
            String[] path = {};
            RequestMapping requestMapping = clazz.getDeclaredAnnotation(RequestMapping.class);
            path = requestMapping.value().length > 0 ? requestMapping.value() : requestMapping.path();
            desc = requestMapping.name();
            if (clazz.isAnnotationPresent(SpringDocument.class)) {
                SpringDocument springDocument = clazz.getAnnotation(SpringDocument.class);
                module = springDocument.module();
                sort = springDocument.sort();
                desc = StringUtils.isNotEmpty(springDocument.desc())?springDocument.desc():desc;
            }
            classDocument.setIndex(sort);
            classDocument.setModule(Arrays.asList(module));
            classDocument.setPath(Arrays.asList(path));
            classDocument.setPackagePath(packageName);
            classDocument.setBaseClass(clazz);
            classDocument.setDesc(desc);
            List<FieldDocument> fieldDocuments = getFieldDocuments(clazz);
            classDocument.setFieldDocumentList(fieldDocuments);
            List<MethodDocument> methodDocuments = getMethodDocuments(clazz);
            classDocument.setMethodDocumentList(methodDocuments);
            return classDocument;
        }
    
        public static List<FieldDocument> getFieldDocuments(Class<?> clazz){
            List<FieldDocument> list = new ArrayList<FieldDocument>();
            Field[] fields = clazz.getDeclaredFields();
            if(fields != null && fields.length > 0) {
                for (Field field : fields) {
                    FieldDocument fieldDocument = getFieldDocument(field);
                    list.add(fieldDocument);
                }
            }
            return list;
        }
    
        public static FieldDocument getFieldDocument(Field field){
            FieldDocument fieldDocument = new FieldDocument();
            String name = field.getName();
            Class<?> fieldClass = field.getType();
            int modifierValue = field.getModifiers();
            String desc = BANK;
            int sort = 0;
            if(field.isAnnotationPresent(FieldAnnotation.class)){
                FieldAnnotation fieldAnnotation = field.getAnnotation(FieldAnnotation.class);
                sort = fieldAnnotation.sort();
                desc = StringUtils.isNotEmpty(fieldAnnotation.desc())?fieldAnnotation.desc():desc;
            }
            fieldDocument.setIndex(sort);
            fieldDocument.setName(name);
            fieldDocument.setDesc(desc);
            fieldDocument.setBaseClass(fieldClass);
            fieldDocument.setModifierValue(modifierValue);
            return fieldDocument;
        }
    
        public static List<MethodDocument> getMethodDocuments(Class<?> clazz){
            List<MethodDocument> list = new ArrayList<MethodDocument>();
            Method[] methods = clazz.getDeclaredMethods();
            if(methods != null && methods.length > 0){
                for(Method method : methods){
                    MethodDocument methodDocument = getMethodDocument(method);
                    list.add(methodDocument);
                }
            }
            return list;
        }
    
        public static MethodDocument getMethodDocument(Method method){
            MethodDocument methodDocument = new MethodDocument();
            String name = method.getName();
            int sort = 0;
            String desc = BANK;
            String[] path = {};
            Class<?> methodClass = method.getReturnType();
            if(method.isAnnotationPresent(RequestMapping.class)){
                RequestMapping requestMapping = method.getAnnotation(RequestMapping.class);
                desc = requestMapping.name();
                path = requestMapping.value().length > 0 ? requestMapping.value() : requestMapping.path();
            }
            if(method.isAnnotationPresent(MethodAnnotation.class)){
                MethodAnnotation methodAnnotation = method.getAnnotation(MethodAnnotation.class);
                desc = StringUtils.isNotEmpty(methodAnnotation.desc()) ? methodAnnotation.desc():desc;
                sort = methodAnnotation.sort();
                methodClass = methodAnnotation.baseClass();
            }
            methodDocument.setIndex(sort);
            methodDocument.setName(name);
            methodDocument.setDesc(desc);
            methodDocument.setPath(Arrays.asList(path));
            methodDocument.setModifierValue(method.getModifiers());
            methodDocument.setReturnClass(methodClass);
            if(method.isAnnotationPresent(ResponseBody.class)){
                methodDocument.setIsJson(true);
            }else{
                methodDocument.setIsJson(false);
            }
            Parameter[] parameters = method.getParameters();
            if(parameters != null && parameters.length > 0) {
                LocalVariableTableParameterNameDiscoverer loadParameter = new LocalVariableTableParameterNameDiscoverer();
                String[] parameterNames = loadParameter.getParameterNames(method);
                List<ParameterDocument> list = getParameterDocuments(parameters, parameterNames);
                methodDocument.setParameterDocumentList(list);
            }
            return methodDocument;
        }
    
        private static List<ParameterDocument> getParameterDocuments(Parameter[] parameters,String[] parameterNames){
            List<ParameterDocument> list = new ArrayList<ParameterDocument>(parameters.length);
            for(int index = 0;index< parameters.length;index++){
                ParameterDocument parameterDocument = new ParameterDocument();
                Parameter parameter = parameters[index];
                String value = parameterNames[index];
                String desc = BANK;
                boolean required = true;
                String defaultValue = BANK;
                if(parameter.isAnnotationPresent(RequestParam.class)){
                    RequestParam requestParam = parameter.getAnnotation(RequestParam.class);
                    value = StringUtils.isNotBlank(requestParam.value()) ? requestParam.value() : value;
                    desc = requestParam.name();
                    String defaultString = requestParam.defaultValue();
                    if(StringUtils.isNotEmpty(defaultString)){
                        if(!isDefaultValue(defaultString)){
                            defaultValue = defaultString;
                        }else{
                            defaultValue = null;
                        }
                    }else {
                        defaultValue = null;
                    }
                    required = requestParam.required();
                }
                parameterDocument.setIndex(index + 1);
                parameterDocument.setValue(value);
                parameterDocument.setDefaultValue(defaultValue);
                parameterDocument.setDesc(desc);
                parameterDocument.setRequired(required);
                parameterDocument.setParameterClass(parameter.getType());
                list.add(parameterDocument);
            }
            return list;
        }
    
        public static boolean isDefaultValue(String defaultValue){
            char[] chars = defaultValue.toCharArray();
            char[] isNull = new char[]{
       '\n','\t','\t','\n','\t','\t','\n','\uE000','\ue001','\ue002','\n','\t','\t','\t','\t','\n'};
            if(chars.length == isNull.length){
                for(int index = 0;index < isNull.length;index++){
                    if(isNull[index] != chars[index]){
                        return false;
                    }
                }
                return true;
            }else{
                return false;
            }
        }
    }

[git]: https://github.com/fengym201507411
[Link 1]: https://github.com/fengym201507411/springDocs