Reflect工具类（自己写的小玩意，作个纪念）

 

package cn.edu.sdu.tavor;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
/**
 * 解析类结构
 * @author tavor
 * @version 1.0
 */
public class MyReflectTools
{
 private static int dimention = 0;
 private HashMap classNames = new HashMap();
 private static ArrayList importKeyWord = new ArrayList();
 private static final String [] keys = {"int","float","void","short","double","char","boolean", "byte", "long"};
 private ArrayList outList = new ArrayList();
 private static final String langPackage = "java.lang.";
 private static final String objectClass = "java.lang.Object";
 private MyReflectTools()
 {
 }
 public String toString()
 {
  Iterator iterator = outList.iterator();
  StringBuffer buff = new StringBuffer();
  while(iterator.hasNext())
  {
   buff.append(iterator.next());
   buff.append("/n");
  }
  return buff.toString();
 }
 public static String reflect(String className)
 {
  try
  {
   Class c = Class.forName(className);
   return reflect(c);
  }
  catch (Throwable e)
  {
   System.err.println(e);
   return null;
  }
 }
 public static String reflect(Class c)
 {
  checkImportKeyWord();
  if(c != null)
  {
   MyReflectTools tool = new MyReflectTools();
   tool.beginReflect(c);
   return tool.toString();
  }
  return null;
 }
 public static void printClass(String className)
 {
  System.out.print(reflect(className));
 }
 public static void printClass(Class c)
 {
  System.out.print(reflect(c));
 }
 private static void checkImportKeyWord()
 {
  if(importKeyWord.size() == 0)
  {
   for(int i=0; i<keys.length; i++)
   {
    importKeyWord.add(keys[i]);
   }
  }
 }
 private String getParentInter(Class c)
 {
  StringBuffer interStr = new StringBuffer();
  Class[] inters = c.getInterfaces();
  if(inters.length > 0)
  {
   interStr.append(" implements ");
  }
  for(int i=0; i<inters.length; i++)
  {
   putClassName(inters[i]);
   interStr.append(getShortName(inters[i]));
   if(i != inters.length-1)
   {
    interStr.append(",");
   }
  }
  return interStr.toString();
 }
 private void beginReflect(Class c)
 {
  Package p = c.getPackage();
  if(p != null)
  {
   outList.add("package "+p.getName()+";");
  }
  StringBuffer temp = new StringBuffer();
  temp.append(getModiferStr(c.getModifiers()));
  temp.append("class ");
  temp.append(getShortName(c));
  temp.append(getSuperClassName(c));
  temp.append(getParentInter(c));
  outList.add(temp.toString());
  outList.add("{");
  reflectClass(c);
  outList.add("}");
  Iterator iter = classNames.keySet().iterator();
  while(iter.hasNext())
  {
   Object t =  iter.next();
   if(!importKeyWord.contains(t))
   {
    if(!checkLangPackage(t.toString()))
    {
     outList.add("import "+t.toString()+";");
    }
   }
  }
 }
 private String getSuperClassName(Class c)
 {
  if(c != null)
  {
   Class temp = c.getSuperclass();
   putClassName(temp);
   if(!temp.getName().equalsIgnoreCase(objectClass))
   {
    return " extends "+getShortName(temp);
   }
  }
  return "";
 }
 private void reflectClass(Class c)
 {
     dimention++;
     String spaceStr = getCountSpaceStr(dimention);
  Class []classes = c.getDeclaredClasses();
  StringBuffer temp = new StringBuffer();
        for(int v=0; v<classes.length; v++)
        {
         temp.append(spaceStr);
         temp.append(getModiferStr(classes[v].getModifiers()));
         if(!classes[v].isInterface())
         {
          temp.append("class/t");
         }
         temp.append(classes[v].getName().substring(c.getName().length()+1));
         temp.append(getSuperClassName(classes[v]));
      temp.append(getParentInter(classes[v]));
         outList.add(temp.toString());
         temp = new StringBuffer();
         temp.append(spaceStr);
         temp.append("{");
         outList.add(temp.toString());
         reflectClass(classes[v]);
         temp = new StringBuffer();
         temp.append(spaceStr);
         temp.append("}");
         outList.add(temp.toString());
         temp = new StringBuffer();
        }
       
        Constructor[] cons = c.getDeclaredConstructors();
        if(cons.length >0) outList.add(spaceStr+"//ConStructors");
        for(int i=0; i<cons.length; i++)
        {
         temp.append(spaceStr);
         temp.append(getModiferStr(cons[i].getModifiers()));
         temp.append(cons[i].getName().substring(cons[i].getName().lastIndexOf('.')+1));
         temp.append("(");
         temp.append(reflectMethodParas(cons[i].getParameterTypes()));
         outList.add(temp.toString());
         temp = new StringBuffer();
        }
        Field [] fields = c.getDeclaredFields();
        if(fields.length >0) outList.add(spaceStr+"//Fields");
        for(int i=0;i<fields.length;i++)
        {
         temp.append(spaceStr);
         temp.append(getModiferStr(fields[i].getModifiers()));
         temp.append(reflectType(fields[i].getType()));
         temp.append("/t");
         temp.append(fields[i].getName());
         temp.append(";");
         outList.add(temp.toString());
         temp = new StringBuffer();
        }
        Method m[] = c.getDeclaredMethods();
        if(m.length >0) outList.add(spaceStr+"//Methods");
        for (int i = 0; i < m.length; i++)
        {
         temp.append(spaceStr);
         temp.append(getModiferStr(m[i].getModifiers()));
         temp.append(reflectType(m[i].getReturnType()));
         temp.append("/t");
         temp.append(m[i].getName());
         temp.append("(");
         temp.append(reflectMethodParas(m[i].getParameterTypes()));
         outList.add(temp.toString());
         temp = new StringBuffer();
        }
     dimention--;
 }
 private String reflectMethodParas(Class[] paras)
 {
  StringBuffer retStr = new StringBuffer();
         if(paras!=null && paras.length>0)
         {
          for(int t=0; t<paras.length;t++)
          {
           retStr.append(reflectType(paras[t]));
           if(t<paras.length -1)
           {
            retStr.append(", ");
           }
          }
         }
         retStr.append(");");
         return retStr.toString();
 }
 private String reflectType(Class cl)
 {
  StringBuffer retStr = new StringBuffer();
  if(cl.isArray())
  {
   int dimensions = 0;
   while (cl.isArray())
   {
    dimensions++;
    cl = cl.getComponentType();
   }
   retStr.append(getShortName(cl));
   putClassName(cl);
   for (int j = 0; j < dimensions; j++)
   {
    retStr.append("[]");
   }
  }
  else
  {
   retStr.append(getShortName(cl));
   putClassName(cl);
  }
  return retStr.toString();
 }
 private void putClassName(Class c)
 {
  if(c != null)
  {
   String name = c.getName();
   classNames.put(name, getShortName(c));
  }
 }
 private String getShortName(Class c)
 {
  String retStr = null;
  if(c != null)
  {
   String name = c.getName();
   if(!classNames.containsKey(c.getName()))
   {
    String shortName = name.substring(name.lastIndexOf('.')+1);
    if(classNames.containsValue(shortName))
    {
     retStr = name;
    }
    else
    {
     retStr = shortName;
    }
   }
   else
   {
    retStr = classNames.get(name).toString();
   }
  }
  return retStr;
 }
 private static String getCountSpaceStr(int count)
 {
  StringBuffer bufferStr = new StringBuffer(count);
  for(int i=0; i<count; i++)
  {
   bufferStr.append("/t");
  }
  return bufferStr.toString();
 }
 private static String getModiferStr(int modifiers)
 {
  String strRe = Modifier.toString(modifiers);
  if(strRe != "")
  {
   strRe+="/t";
  }
  return strRe;
 }
 private static boolean checkLangPackage(String path)
 {
  if(path != null && path.startsWith(langPackage))
  {
   if(path.indexOf('.',langPackage.length()) < 0)
   {
    return true;
   }
  }
  return false;
 }
}