反射的基本使用

反射作为java的灵魂技术。大概介绍一下反射的基本方法

首先编写两个实体类信息，为继承关系：

public class Reflection extends ReflectionFather{
    //私有
    @DateTimeFormat
    private String str1;
    //受保护的
    protected String str2;
    //公共的
    public String str3;
    //默认
    String str4;
    //动态方法
    private void getStr1(){}
    protected void getStr2(){}
    public void getStr3(){}
    void getStr4(){}
    //静态方法
    private static void getStr11(){}
    protected static void getStr22(){}
    public static void getStr33(){}
    static void getStr44(){}
    //无参构造方法
    public Reflection(){
        System.out.println("无参构造方法");
    }
    //有参构造方法
    public Reflection(String str1, String str2, String str3, String str4) {
        this.str1 = str1;
        this.str2 = str2;
        this.str3 = str3;
        this.str4 = str4;
    }

    public String getStr1(String str1) {
        return str1;
    }

    public String getStr2(String str2) {
        return str2;
    }

    public String getStr3(String str3) {
        return str3;
    }

    public String getStr4(String str4) {
        return str4;
    }

    @Override
    public String toString() {
        return "Reflection{" +
                "str1='" + str1 + '\'' +
                ", str2='" + str2 + '\'' +
                ", str3='" + str3 + '\'' +
                ", str4='" + str4 + '\'' +
                ", str22='" + str22 + '\'' +
                ", str33='" + str33 + '\'' +
                ", str44='" + str44 + '\'' +
                '}';
    }
}

public class ReflectionFather {
    //私有
    @DateTimeFormat
    private String str11;
    //受保护的
    protected String str22;
    //公共的
    public String str33;
    //默认
    String str44;
    //动态方法
    private void getstr11(){}
    protected void getstr22(){}
    public void getstr33(){}
    void getstr44(){}
    //静态方法
    private static void getstr111(){}
    protected static void getstr222(){}
    public static void getstr333(){}
    static void getstr444(){}
    //无参构造方法
    public ReflectionFather(){
        System.out.println("父类无参构造方法");
    }
    //有参构造方法
    public ReflectionFather(String str11, String str22, String str33, String str44) {
        this.str11 = str11;
        this.str22 = str22;
        this.str33 = str33;
        this.str44 = str44;
    }

    public String gettr11(String str11) {
        return str11;
    }

    public String getstr22(String str22) {
        return str22;
    }

    public String getstr33(String str33) {
        return str33;
    }

    public String getstr44(String str44) {
        return str44;
    }

    @Override
    public String toString() {
        return "ReflectionFather{" +
                "str11='" + str11 + '\'' +
                ", str22='" + str22 + '\'' +
                ", str33='" + str33 + '\'' +
                ", str44='" + str44 + '\'' +
                '}';
    }
}

方法：获取类的class对象

/**
 * 获取类的class对象
 * @param className 对象所在完整路径
 * @return
 * @throws ClassNotFoundException
 */
 public static Class<?> getClassObj(String className) throws ClassNotFoundException {
    return Class.forName(className);
}

ReflectionUtil.getClassObj("com.qingnian.spring.reflection.Reflection")
result：class com.qingnian.spring.reflection.Reflection

方法：通过反射获取实例对象（有参，无参）

/**
 * 通过反射获取实例对象
 *
 * @param clazz 类的class对象
 * @param pareTyples 构造函数的参数类型
 * @param pareVaules 构造函数的入参
 * @return
 */
 public static Object createObject(Class clazz, Class[] pareTyples, Object[] pareVaules) {
     try {
         Constructor ctor = clazz.getDeclaredConstructor(pareTyples);
         ctor.setAccessible(true);
         return ctor.newInstance(pareVaules);
     } catch (Exception e) {
         e.printStackTrace();
     }

     return null;
 }

Class[] pareTyples=new Class[]{String.class,String.class,String.class,String.class};
Object[] pareVaules=new Object[]{"1","2","3","4"};
Object object2 = ReflectionUtil.createObject(aClass, pareTyples,pareVaules);
result：Reflection{str1='1', str2='2', str3='3', str4='4', str22='null', str33='null', str44='null'}

方法：通过反射调用方法获取返回值

/**
 * 通过反射调用方法获取返回值
 * @param clazz 类的class对象
 * @param method_name 要调取的方法名
 * @param pareTyples 方法参数类型
 * @param pareVaules 方法入参
 * @return
 */
 public static Object invokeMethod(Class clazz, String method_name, Class[] pareTyples, Object[] pareVaules) {
     try {
         Object o = clazz.getDeclaredConstructor().newInstance();
         Method method = clazz.getDeclaredMethod(method_name, pareTyples);
         method.setAccessible(true);
         return method.invoke(o, pareVaules);
      } catch (Exception e) {
         e.printStackTrace();
      }
         return null;
 }

Class[] pareTyples2=new Class[]{String.class};                     
Object[] pareVaules2=new Object[]{"4-13"};
Object getStr1 = ReflectionUtil.invokeMethod(aClass, "getStr1", pareTyples2, pareVaules2);

方法：获取有指定注解的字段

/**
 *   查询包含指定注解 pareTyple的字段集合
 * @param clazz  类的class对象
 * @param pareTyple
 * @return
 */
 public static Field[] getAnnotationsFields(Class clazz,Class pareTyple){
     //获取所有字段
     Field[] fields = clazz.getDeclaredFields();
     Field[] result=new Field[fields.length];
     for (int i = 0; i < fields.length; i++) {
         //包含指定注解，则在结果集添加此字段
         if (fields[i].isAnnotationPresent(pareTyple)){
             result[i]=fields[i];
         }
     }
     return result;
 }

Class pareTyples3=JacksonInject.class;
Field[] fields1 = ReflectionUtil.getAnnotationsFields(aClass, pareTyples3);
for (Field field : fields1) {
    System.out.println(field);
}
result：
null
protected java.lang.String com.qingnian.spring.reflection.Reflection.str2
null
null