反射工具类【ReflectionUtils】

原创 2017年05月05日 00:45:43

        <ul class="article_tags clearfix csdn-tracking-statistics" data-mod="popu_377">
            <li class="tit">标签：</li>

                                                        <li><a href="http://so.csdn.net/so/search/s.do?q=java&amp;t=blog" target="_blank">java</a> <span>/</span></li>
                                        <li><a href="http://so.csdn.net/so/search/s.do?q=反射&amp;t=blog" target="_blank">反射</a> <span>/</span></li>
                                        <li><a href="http://so.csdn.net/so/search/s.do?q=reflection&amp;t=blog" target="_blank">reflection</a> <span style="display: none;">/</span></li>
                                <!--          [endarticletags]-->
        </ul>
        <ul class="right_bar">
            <li><button class="btn-noborder"><i class="icon iconfont icon-read"></i><span class="txt">893</span></button></li>

            <li class="edit" style="display: none;">
                <a class="btn-noborder" href="http://write.blog.csdn.net/postedit/71190114">
                    <i class="icon iconfont icon-bianji"></i><span class="txt">编辑</span>
                </a>
            </li>
            <li class="del" style="display: none;">
                <a class="btn-noborder" onclick="javascript:deleteArticle(fileName);return false;">
                    <i class="icon iconfont icon-shanchu"></i><span class="txt">删除</span>
                </a>
            </li>
        </ul>
    </div>
    <div id="article_content" class="article_content csdn-tracking-statistics" data-mod="popu_519" data-dsm="post" style="overflow: hidden;">
        <pre><code>import java.lang.annotation.Annotation;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

/**

反射工具类 <br />
<br />
提供了一系列的获取某一个类的信息的方法<br />
包括获取全类名，实现的接口，接口的泛型等<br />
并且提供了根据Class类型获取对应的实例对象的方法，以及修改属性和调用对象的方法等
*/
public class ReflectionUtils {

/**

获取包名
@return 包名【String类型】
*/
public static String getPackage(Class<?> clazz) {
Package pck = clazz.getPackage();
if (null != pck) {
return pck.getName();
} else {
return "没有包！";
}
}

/**

获取继承的父类的全类名
@return 继承的父类的全类名【String类型】
*/
public static String getSuperClassName(Class<?> clazz) {
Class<?> superClass = clazz.getSuperclass();
if (null != superClass) {
return superClass.getName();
} else {
return "没有父类！";
}
}

/**

获取全类名
@return 全类名【String类型】
*/
public static String getClassName(Class<?> clazz) {
return clazz.getName();
}

/**

获取实现的接口名
@return 所有的接口名【每一个接口名的类型为String，最后保存到一个List集合中】
*/
public static List<String> getInterfaces(Class<?> clazz) {
Class<?>[] interfaces = clazz.getInterfaces();
int len = interfaces.length;

List<String> list = new ArrayList<String>();
for (int i = 0; i < len; i++) {
Class<?> itfc = interfaces[i];
```
 // 接口名
 String interfaceName = itfc.getSimpleName();

 list.add(interfaceName);
```
}

return list;
}

/**

获取所有属性
@return 所有的属性【每一个属性添加到StringBuilder中，最后保存到一个List集合中】
*/
public static List<StringBuilder> getFields(Class<?> clazz) {
Field[] fields = clazz.getDeclaredFields();
int len = fields.length;

List<StringBuilder> list = new ArrayList<StringBuilder>();
StringBuilder sb = null;
for (int i = 0; i < len; i++) {
Field field = fields[i];
sb = new StringBuilder();
```
 // 修饰符
 String modifier = Modifier.toString(field.getModifiers());
 sb.append(modifier + " ");

 // 数据类型
 Class&lt;?&gt; type = field.getType();
 String typeName = type.getSimpleName();
 sb.append(typeName + " ");

 // 属性名
 String fieldName = field.getName();
 sb.append(fieldName + ";");

 list.add(sb);
```
}

return list;
}

/**

获取所有公共的属性
@return 所有公共的属性【每一个属性添加到StringBuilder中，最后保存到一个List集合中】
*/
public static List<StringBuilder> getPublicFields(Class<?> clazz) {
Field[] fields = clazz.getFields();
int len = fields.length;

List<StringBuilder> list = new ArrayList<StringBuilder>();
StringBuilder sb = null;
for (int i = 0; i < len; i++) {
Field field = fields[i];
sb = new StringBuilder();
```
 // 修饰符
 String modifier = Modifier.toString(field.getModifiers());
 sb.append(modifier + " ");

 // 数据类型
 Class&lt;?&gt; type = field.getType();
 String typeName = type.getSimpleName();
 sb.append(typeName + " ");

 // 属性名
 String fieldName = field.getName();
 sb.append(fieldName + ";");

 list.add(sb);
```
}

return list;
}

/**

获取所有构造方法

@return 所有的构造方法【每一个构造方法添加到StringBuilder中，最后保存到一个List集合中】
*/
public static List<StringBuilder> getConstructors(Class<?> clazz) {
Constructor<?>[] constructors = clazz.getDeclaredConstructors();
int len = constructors.length;

List<StringBuilder> list = new ArrayList<StringBuilder>();
StringBuilder sb = null;
for (int i = 0; i < len; i++) {
Constructor<?> constructor = constructors[i];
sb = new StringBuilder();

 // 修饰符
 String modifier = Modifier.toString(constructor.getModifiers());
 sb.append(modifier + " ");

 // 方法名（类名）
 String constructorName = clazz.getSimpleName();
 sb.append(constructorName + " (");

 // 形参列表
 Class&lt;?&gt;[] parameterTypes = constructor.getParameterTypes();
 int length = parameterTypes.length;
 for (int j = 0; j &lt; length; j++) {
     Class&lt;?&gt; parameterType = parameterTypes[j];

     String parameterTypeName = parameterType.getSimpleName();

     if (j &lt; length - 1) {
         sb.append(parameterTypeName + ", ");
     } else {
         sb.append(parameterTypeName);
     }

 }

 sb.append(") {}");

 list.add(sb);

}

return list;
}

/**

获取所有自身的方法

@return 所有自身的方法【每一个方法添加到StringBuilder中，最后保存到一个List集合中】
*/
public static List<StringBuilder> getMethods(Class<?> clazz) {
Method[] methods = clazz.getDeclaredMethods();
int len = methods.length;

List<StringBuilder> list = new ArrayList<StringBuilder>();
StringBuilder sb = null;
for (int i = 0; i < len; i++) {
Method method = methods[i];
sb = new StringBuilder();

 // 修饰符
 String modifier = Modifier.toString(method.getModifiers());
 sb.append(modifier + " ");

 // 返回值类型
 Class&lt;?&gt; returnClass = method.getReturnType();
 String returnType = returnClass.getSimpleName();
 sb.append(returnType + " ");

 // 方法名
 String methodName = method.getName();
 sb.append(methodName + " (");

 // 形参列表
 Class&lt;?&gt;[] parameterTypes = method.getParameterTypes();
 int length = parameterTypes.length;

 for (int j = 0; j &lt; length; j++) {
     Class&lt;?&gt; parameterType = parameterTypes[j];

     // 形参类型
     String parameterTypeName = parameterType.getSimpleName();

     if (j &lt; length - 1) {
         sb.append(parameterTypeName + ", ");
     } else {
         sb.append(parameterTypeName);
     }

 }

 sb.append(") {}");

 list.add(sb);

}

return list;
}

/**

获取所有公共的方法

@return 所有公共的方法【每一个方法添加到StringBuilder中，最后保存到一个List集合中】
*/
public static List<StringBuilder> getPublicMethods(Class<?> clazz) {
Method[] methods = clazz.getMethods();
int len = methods.length;

List<StringBuilder> list = new ArrayList<StringBuilder>();
StringBuilder sb = null;
for (int i = 0; i < len; i++) {
Method method = methods[i];
sb = new StringBuilder();

 // 修饰符
 String modifier = Modifier.toString(method.getModifiers());
 sb.append(modifier + " ");

 // 返回值类型
 Class&lt;?&gt; returnClass = method.getReturnType();
 String returnType = returnClass.getSimpleName();
 sb.append(returnType + " ");

 // 方法名
 String methodName = method.getName();
 sb.append(methodName + " (");

 // 形参列表
 Class&lt;?&gt;[] parameterTypes = method.getParameterTypes();
 int length = parameterTypes.length;

 for (int j = 0; j &lt; length; j++) {
     Class&lt;?&gt; parameterType = parameterTypes[j];

     // 形参类型
     String parameterTypeName = parameterType.getSimpleName();

     if (j &lt; length - 1) {
         sb.append(parameterTypeName + ", ");
     } else {
         sb.append(parameterTypeName);
     }

 }

 sb.append(") {}");

 list.add(sb);

}

return list;
}

/**

获取所有的注解名
@return 所有的注解名【每一个注解名的类型为String，最后保存到一个List集合中】
*/
public static List<String> getAnnotations(Class<?> clazz) {
Annotation[] annotations = clazz.getAnnotations();
int len = annotations.length;

List<String> list = new ArrayList<String>();
for (int i = 0; i < len; i++) {
Annotation annotation = annotations[i];
```
 String annotationName = annotation.annotationType().getSimpleName();
 list.add(annotationName);
```
}

return list;
}

/**

获取父类的泛型
@return 父类的泛型【Class类型】
*/
public static Class<?> getSuperClassGenericParameterizedType(Class<?> clazz) {
Type genericSuperClass = clazz.getGenericSuperclass();

Class<?> superClassGenericParameterizedType = null;

// 判断父类是否有泛型
if (genericSuperClass instanceof ParameterizedType) {
// 向下转型，以便调用方法
ParameterizedType pt = (ParameterizedType) genericSuperClass;
// 只取第一个，因为一个类只能继承一个父类
Type superClazz = pt.getActualTypeArguments()[0];
// 转换为Class类型
superClassGenericParameterizedType = (Class<?>) superClazz;
}

return superClassGenericParameterizedType;
}

/**

获取接口的所有泛型

@return 所有的泛型接口【每一个泛型接口的类型为Class，最后保存到一个List集合中】
*/
public static List<Class<?>> getInterfaceGenericParameterizedTypes(Class<?> clazz) {
Type[] genericInterfaces = clazz.getGenericInterfaces();
int len = genericInterfaces.length;

List<Class<?>> list = new ArrayList<Class<?>>();
for (int i = 0; i < len; i++) {
Type genericInterface = genericInterfaces[i];

 // 判断接口是否有泛型
 if (genericInterface instanceof ParameterizedType) {
     ParameterizedType pt = (ParameterizedType) genericInterface;

     // 得到所有的泛型【Type类型的数组】
     Type[] interfaceTypes = pt.getActualTypeArguments();

     int length = interfaceTypes.length;

     for (int j = 0; j &lt; length; j++) {
         // 获取对应的泛型【Type类型】
         Type interfaceType = interfaceTypes[j];
         // 转换为Class类型
         Class&lt;?&gt; interfaceClass = (Class&lt;?&gt;) interfaceType;
         list.add(interfaceClass);
     }

 }

}

return list;
}

/**

打印包名
*/
public static void printPackage(Class<?> clazz) {
System.out.println(getPackage(clazz));
}

/**

打印继承的父类的全类名
*/
public static void printSuperClassName(Class<?> clazz) {
System.out.println(getSuperClassName(clazz));
}

/**

打印全类名
*/
public static void printClassName(Class<?> clazz) {
System.out.println(getClassName(clazz));
}

/**

打印实现的接口
*/
public static void printInterfaces(Class<?> clazz) {
List<String> list = getInterfaces(clazz);
int size = list.size();
if (0 < size) {
for (int i = 0; i < size; i++) {
System.out.println(list.get(i));
}
} else {
System.out.println("没有实现接口！");
}
}

/**

打印所有属性
*/
public static void printFields(Class<?> clazz) {
List<StringBuilder> list = getFields(clazz);
int size = list.size();
if (0 < size) {
for (int i = 0; i < size; i++) {
System.out.println(list.get(i));
}
} else {
System.out.println("没有属性！");
}
}

/**

打印所有公共的属性
*/
public static void printPublicFields(Class<?> clazz) {
List<StringBuilder> list = getPublicFields(clazz);
int size = list.size();
if (0 < size) {
for (int i = 0; i < size; i++) {
System.out.println(list.get(i));
}
} else {
System.out.println("没有属性！");
}
}

/**

打印所有构造方法
*/
public static void printConstructors(Class<?> clazz) {
List<StringBuilder> list = getConstructors(clazz);
int size = list.size();
if (0 < size) {
for (int i = 0; i < size; i++) {
System.out.println(list.get(i));
}
} else {
System.out.println("没有构造方法！");
}
}

/**

打印所有方法
*/
public static void printMethods(Class<?> clazz) {
List<StringBuilder> list = getMethods(clazz);
int size = list.size();
if (0 < size) {
for (int i = 0; i < size; i++) {
System.out.println(list.get(i));
}
} else {
System.out.println("没有方法！");
}
}

/**

打印所有公共的方法
*/
public static void printPublicMethods(Class<?> clazz) {
List<StringBuilder> list = getPublicMethods(clazz);
int size = list.size();
if (0 < size) {
for (int i = 0; i < size; i++) {
System.out.println(list.get(i));
}
} else {
System.out.println("没有方法！");
}
}

/**

打印所有的注解
*/
public static void printAnnotations(Class<?> clazz) {
List<String> list = getAnnotations(clazz);
int size = list.size();
if (0 < size) {
for (int i = 0; i < size; i++) {
System.out.println(list.get(i));
}
} else {
System.out.println("没有注解！");
}
}

/**

打印父类的泛型名
*/
public static void printSuperClassGenericParameterizedType(Class<?> clazz) {
Class<?> superClassGenericParameterizedType = getSuperClassGenericParameterizedType(clazz);
if (null != superClassGenericParameterizedType) {
System.out.println(superClassGenericParameterizedType.getSimpleName());
} else {
System.out.println("父类没有泛型！");
}
}

/**

打印接口的泛型
*/
public static void printInterfaceGenericParameterizedTypes(Class<?> clazz) {
List<Class<?>> list = getInterfaceGenericParameterizedTypes(clazz);
int size = list.size();
if (0 < size) {
for (int i = 0; i < size; i++) {
System.out.println(list.get(i).getSimpleName());
}
} else {
System.out.println("没有泛型接口！");
}
}

/**

打印一个类的相关信息
@param clazz
*/
public static void printAll(Class<?> clazz) {
System.out.print("【包名】 ");
printPackage(clazz);

System.out.print("【类名】 ");
System.out.println(clazz.getSimpleName());

System.out.println(" 【父类全类名】");
printSuperClassName(clazz);
System.out.println("【全类名】");
printClassName(clazz);
System.out.println(" 【所有已实现的接口】");
printInterfaces(clazz);

System.out.println(" 【属性】");
printFields(clazz);
System.out.println(" 【构造方法】");
printConstructors(clazz);
System.out.println(" 【方法】");
printMethods(clazz);

System.out.println(" 【公共的属性】");
printPublicFields(clazz);
System.out.println(" 【公共的方法】");
printPublicMethods(clazz);
}

/**

根据Class类型，获取对应的实例【要求必须有无参的构造器】
@return 对应的实例【Object类型】
*/
public static Object getNewInstance(Class<?> clazz) throws InstantiationException, IllegalAccessException {
return clazz.newInstance();
}

/**

根据传入的类的Class对象，以及构造方法的形参的Class对象，获取对应的构造方法对象
@param clazz
```
       类的Class对象
```
@param parameterTypes

       构造方法的形参的Class对象【可以不写】

@return 构造方法对象【Constructor类型】
*/
public static Constructor<?> getConstructor(Class<?> clazz, Class<?>... parameterTypes)
throws NoSuchMethodException, SecurityException {
return clazz.getDeclaredConstructor(parameterTypes);
}

/**

根据传入的构造方法对象，以及，获取对应的实例
@param constructor
```
       构造方法对象
```
@param initargs

       传入构造方法的实参【可以不写】

@return 对应的实例【Object类型】
*/
public static Object getNewInstance(Constructor<?> constructor, Object... initargs)
throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
constructor.setAccessible(true);
return constructor.newInstance(initargs);
}

/**

根据传入的属性名字符串，修改对应的属性值
@param clazz
```
       类的Class对象
```
@param name
```
       属性名
```
@param obj
```
       要修改的实例对象
```
@param value
```
       修改后的新值
```

*/
public static void setField(Class<?> clazz, String name, Object obj, Object value)
throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
Field field = clazz.getDeclaredField(name);
field.setAccessible(true);
field.set(obj, value);
}

/**

根据传入的方法名字符串，获取对应的方法
@param clazz
```
       类的Class对象
```
@param name
```
       方法名
```
@param parameterTypes

       方法的形参对应的Class类型【可以不写】

@return 方法对象【Method类型】
*/
public static Method getMethod(Class<?> clazz, String name, Class<?>... parameterTypes)
throws NoSuchMethodException, SecurityException {
return clazz.getDeclaredMethod(name, parameterTypes);
}

/**

根据传入的方法对象，调用对应的方法
@param method
```
       方法对象
```
@param obj

       要调用的实例对象【如果是调用静态方法，则可以传入null】

@param args

       传入方法的实参【可以不写】

@return 方法的返回值【没有返回值，则返回null】
*/
public static Object invokeMethod(Method method, Object obj, Object... args)
throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
method.setAccessible(true);
return method.invoke(obj, args);
}

}

http://blog.csdn.net/adsl624153/article/details/71190114