Generating a request and response kafka internal interface document

Generating a request and response kafka internal interface document

/**
 */
package com.code260.ss.kafka10demo;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

import org.apache.kafka.common.protocol.types.BoundField;
import org.apache.kafka.common.protocol.types.Schema;
import org.apache.kafka.common.requests.AbstractRequest;
import org.apache.kafka.common.requests.AbstractResponse;

/**
 * @since 2019-08-07
 *
 */
public class GenKafkaRequestDoc {

    /**
     * @param args
     * @throws IOException
     * @throws ClassNotFoundException
     */
    public static void main(String[] args) throws IOException, ClassNotFoundException {

        collect(AbstractRequest.class);
        System.out.println("=======");
        collect(AbstractResponse.class);
    }

    /**
     * @param sedClazz
     * @throws IOException
     * @throws ClassNotFoundException
     */
    public static void collect(Class<?> sedClazz) throws IOException, ClassNotFoundException {
        List<Class<?>> children = getAllChildrenClass("org.apache.kafka", sedClazz);
        List<Class<?>> childrenOfAbstractRequest = filter(children, sedClazz);
        for (Class<?> rquestClazz : childrenOfAbstractRequest) {
            System.out.println("\n## " + rquestClazz.getSimpleName());
            try {
                Schema[] schemas = (Schema[]) rquestClazz.getDeclaredMethod("schemaVersions").invoke(null);
                for (int i = 0; i < schemas.length; i++) {
                    Schema schema = schemas[i];
                    System.out.println("\n### version:" + i);
                    StringBuffer sb = new StringBuffer();
                    sb.append(
                            "<table><tr><td style=\"width:160px\">name</td><td>type</td><td  style=\"width:80px\">defaultValue</td><td>docString</td></tr>");
                    for (int j = 0; j < schema.fields().length; j++) {
                        BoundField field = schema.fields()[j];

                        sb.append("<tr><td>").append(field.def.name).append("</td>");
                        sb.append("<td>").append(field.def.type).append("</td>");
                        sb.append("<td>").append(field.def.defaultValue).append("</td>");
                        sb.append("<td>").append(field.def.docString).append("</td></tr>").append("\n");

                    }
                    sb.append("</table>  \n  \n  ");
                    System.out.println(sb.toString());
                }
//              System.out.println(schemas);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (SecurityException e) {
                e.printStackTrace();
            }
        }
    }

    private static List<Class<?>> filter(List<Class<?>> children, Class<?> parentClazz) {
        List<Class<?>> result = new ArrayList<Class<?>>();
        if (children == null || children.isEmpty()) {
            return result;
        }
        for (Class<?> child : children) {
            if (isAssignedFrom(child, parentClazz)) {
                result.add(child);
            }
        }
        return result;
    }

    private static boolean isAssignedFrom(Class<?> currentClazz, Class<?> targetParentClazz) {
        if (targetParentClazz == null || currentClazz == null) {
            return false;
        }

//      Class<?>[] parentInterfaces = currentClazz.getInterfaces();
        Class<?> parentClazz = currentClazz.getSuperclass();
        while (parentClazz != null) {
            if (parentClazz.equals(targetParentClazz)) {
                return true;
            } else {
                parentClazz = parentClazz.getSuperclass();
            }
        }

        Class<?>[] parentInterfaces = currentClazz.getInterfaces();
        return isAssignedFrom(parentInterfaces, targetParentClazz);
    }

    private static boolean isAssignedFrom(Class<?>[] parentInterfaces, Class<?> targetParentClazz) {
        if (parentInterfaces == null) {
            return false;
        }
        for (Class<?> ppInterface : parentInterfaces) {
            if (ppInterface != null && ppInterface.equals(targetParentClazz)) {
                return true;
            } else {
                boolean result = isAssignedFrom(ppInterface.getInterfaces(), targetParentClazz);
                if (result) {
                    return true;
                }
            }
        }
        return false;
    }

    private static List<Class<?>> getAllChildrenClass(String scanPackageStr, Class<?> parentClazz)
            throws IOException, ClassNotFoundException {
        List<Class<?>> children = new ArrayList<Class<?>>();
        Enumeration<URL> packageLocations = parentClazz.getClassLoader().getResources(scanPackageStr.replace(".", "/"));
        while (packageLocations.hasMoreElements()) {
            URL packageLocation = packageLocations.nextElement();
            String protocol = packageLocation.getProtocol();
            if ("file".equals(protocol)) {
                String filePath = URLDecoder.decode(packageLocation.getFile(), "UTF-8");
                findAndAddClassesInPackageByFile(filePath, scanPackageStr, children);
            } else if ("jar".equals(protocol)) {
                findAndAddClassesInPackageByJar(packageLocation.getPath(), scanPackageStr, children);

            }
        }
        return children;
    }

    private static void findAndAddClassesInPackageByJar(String packageLocation, String packageName,
            List<Class<?>> clazzList) throws IOException, ClassNotFoundException {
        String[] segs = packageLocation.split("!");
        String jarFilePath = segs[0].substring(segs[0].indexOf("/"));
        jarFilePath = URLDecoder.decode(jarFilePath, "UTF-8");
        String packagePath = segs[1].substring(1);
        JarFile jarFile = null;
        try {
            jarFile = new JarFile(jarFilePath);
            Enumeration<JarEntry> entrys = jarFile.entries();
            while (entrys.hasMoreElements()) {
                JarEntry jarEntry = entrys.nextElement();
                String entryName = jarEntry.getName();
                if (entryName.endsWith(".class")) {
                    if (entryName.startsWith(packagePath)) {
                        entryName = entryName.replace("/", ".").substring(0, entryName.lastIndexOf("."));
                        Class<?> clazz = Thread.currentThread().getContextClassLoader().loadClass(entryName);
                        clazzList.add(clazz);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }   
        finally {
            if (jarFile != null) {
                jarFile.close();
            }
        }

    }

    private static void findAndAddClassesInPackageByFile(String filePath, String packageName,
            List<Class<?>> clazzList) {
        File file = new File(filePath);
        File[] children = file.listFiles();
        for (File child : children) {
            if (child.isDirectory()) {
                findAndAddClassesInPackageByFile(child.getAbsolutePath(), packageName + "." + child.getName(),
                        clazzList);
            }
            if (child.isFile()) {
                if (!child.getName().endsWith(".class")) {
                    continue;
                }
            }
            String childName = child.getName();
            if (!childName.endsWith(".class")) {
                continue;
            }
            String className = packageName + "." + childName.substring(0, childName.length() - ".class".length());
            try {
                Class<?> clazz = Thread.currentThread().getContextClassLoader().loadClass(className);
                clazzList.add(clazz);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

}