通过反射遍历属性，找出基本数据类型，和自定义引用类，以便生成接口文档时使用

 

 

    /**
     * 是否为一个用户标准bean，不考虑泛型情况
     */
    private static boolean isBean(Class<?> clazz) {
        if (clazz.equals(String.class) || ClassUtil.isBasicType(clazz)) {
            return false;
        }
        if (clazz.isArray() && ClassUtil.isSimpleValueType(clazz.getComponentType())) {
            return false;
        }
        //Map.class.isAssignableFrom(clazz) 继承时为true, Collection.class.isAssignableFrom(clazz) 继承时为true
        return !Collection.class.isAssignableFrom(clazz) && !Map.class.isAssignableFrom(clazz);
    }

 

    /**
     * 提取自定义引用bean
     */
    private static void getAllParameter(Type type, List<Class<?>> list) {
        Class<?> c1 = TypeUtil.getClass(type);
        if (type instanceof ParameterizedType) {
            if (isBean(c1) && !list.contains(c1)) {
                list.add(c1);
            }
            Type[] ts = ((ParameterizedType) type).getActualTypeArguments();
            for (Type tp : ts) {
                getAllParameter(tp, list);
            }
        } else {
            if (isBean(c1) && !list.contains(c1)) {
                list.add(c1);
            }
        }

    }

    @Test
    public void test() {
        for (Field field : Primitive.class.getDeclaredFields()) {
            System.out.print(field.getName() + ": ");
            Class<?> fieldClazz = field.getType();
            Type fieldType = field.getGenericType();

            //枚举
            if (fieldClazz.isEnum()) {
                System.out.println("枚举类型");
                continue;
            }

            //string
            if (fieldClazz.equals(String.class)) {
                System.out.println("String 类型");
                continue;
            }

            //基本数据类型
            if (ClassUtil.isBasicType(fieldClazz)) {
                System.out.println("基本数据类型");
                continue;
            }

            //数组
            if (fieldClazz.isArray()) {

                //基本数组
                if (ClassUtil.isSimpleValueType(fieldClazz.getComponentType())) {
                    System.out.println("基本数组");
                    continue;
                }

                System.out.println("引用数组");
                continue;
            }

            //是否为单列集合
            ArrayList<Class<?>> list = new ArrayList<>();
            getAllParameter(fieldType, list);
            if (Collection.class.isAssignableFrom(fieldClazz)) {
                if (CollUtil.isEmpty(list)) {
                    System.out.println("简单单列");
                    continue;
                }

                //引用单列
                System.out.println("引用单列");
                list.forEach(System.out::println);
                continue;
            }

            //是否为双列集合
            if (Map.class.isAssignableFrom(fieldClazz)) {
                if (CollUtil.isEmpty(list)) {
                    System.out.println("简单双列");
                    continue;
                }
                System.out.println("引用双列");
                list.forEach(System.out::println);
            }

            System.out.println("自定义bean");
            list.forEach(System.out::println);
        }
    }

 

package com.alipay.mychain.taas.apidoc;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ClassUtil;
import cn.hutool.core.util.TypeUtil;
import cn.hutool.db.PageResult;
import lombok.Data;
import org.junit.Test;
import org.springframework.http.RequestEntity;

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;

class User {
    private String name;
    private Integer age;
    private List<Primitive> list;
}

@Data
public class Primitive {

    private int inta;

    private Integer integera;

    private Double aDouble;

    private String Stringa;

    private User user;

    private List<User> List_User;

    private String[] strings;

    private User[] users;

    Map<String, List<User>> maps;

    private List<User> aa;

    private String[] listString;

    RequestEntity<Map<User, List<PageResult<User>>>> req;


    @Test
    public void test() {
        for (Field field : Primitive.class.getDeclaredFields()) {
            System.out.print(field.getName() + ": ");
            Class<?> fieldClazz = field.getType();
            Type fieldType = field.getGenericType();

            //枚举
            if (fieldClazz.isEnum()) {
                System.out.println("枚举类型");
                continue;
            }

            //string
            if (fieldClazz.equals(String.class)) {
                System.out.println("String 类型");
                continue;
            }

            //基本数据类型
            if (ClassUtil.isBasicType(fieldClazz)) {
                System.out.println("基本数据类型");
                continue;
            }

            //数组
            if (fieldClazz.isArray()) {

                //基本数组
                if (ClassUtil.isSimpleValueType(fieldClazz.getComponentType())) {
                    System.out.println("基本数组");
                    continue;
                }

                System.out.println("引用数组");
                continue;
            }

            //是否为单列集合
            ArrayList<Class<?>> list = new ArrayList<>();
            getAllParameter(fieldType, list);
            if (Collection.class.isAssignableFrom(fieldClazz)) {
                if (CollUtil.isEmpty(list)) {
                    System.out.println("简单单列");
                    continue;
                }

                //引用单列
                System.out.println("引用单列");
                list.forEach(System.out::println);
                continue;
            }

            //是否为双列集合
            if (Map.class.isAssignableFrom(fieldClazz)) {
                if (CollUtil.isEmpty(list)) {
                    System.out.println("简单双列");
                    continue;
                }
                System.out.println("引用双列");
                list.forEach(System.out::println);
            }

            System.out.println("自定义bean");
            list.forEach(System.out::println);
        }
    }

    /**
     * 提取自定义引用bean
     */
    private static void getAllParameter(Type type, List<Class<?>> list) {
        Class<?> c1 = TypeUtil.getClass(type);
        if (type instanceof ParameterizedType) {
            if (isBean(c1) && !list.contains(c1)) {
                list.add(c1);
            }
            Type[] ts = ((ParameterizedType) type).getActualTypeArguments();
            for (Type tp : ts) {
                getAllParameter(tp, list);
            }
        } else {
            if (isBean(c1) && !list.contains(c1)) {
                list.add(c1);
            }
        }

    }

    /**
     * 是否为一个用户标准bean，不考虑泛型情况
     */
    private static boolean isBean(Class<?> clazz) {
        if (clazz.equals(String.class) || ClassUtil.isBasicType(clazz)) {
            return false;
        }
        if (clazz.isArray() && ClassUtil.isSimpleValueType(clazz.getComponentType())) {
            return false;
        }
        //Map.class.isAssignableFrom(clazz) 继承时为true, Collection.class.isAssignableFrom(clazz) 继承时为true
        return !Collection.class.isAssignableFrom(clazz) && !Map.class.isAssignableFrom(clazz);
    }
}