Java反射机制初步理解

一、反射的概念

Java的反射（reflection）机制是指在程序的运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类，可以了解任意一个类的成员变量和方法，可以调用任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制。反射被视为动态语言的关键。（百度）

说白了：就是把java类中的各种成分映射成一个个的Java对象

例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把个个组成部分映射成一个个对象。

     （其实：一个类中这些成员方法、构造方法、在加入类中都有一个类来描述）

二、前提

获取字节码文件   **.Class

三种方式：

2.1、任意类继承的Object类，自带的getClass 方法

2.2、Class类的静态forName（String  ClassName）方法

2.3、Java中任意对象都自带静态的.class属性

三、反射的几点应用：

我首先写一个普通的userInfo实体类，自定义一个注解myAnnotation，进行以下演示

代码地址：https://gitee.com/huelwyk/codes/rju0h5k4e13glp6vwyis941

useInfo类

package Reflection;

/**
 * className UserInfo
 *  测试的userInfo类
 *  提供私有属性和公开属性，构造方法全部私有，
 *  切记：利用反射原理，一定要将无参构造完善，后面会解释（自动填充对象）
 * @author Java DaKun
 * @date 2020/8/28
 * @version:1.0
 * @since:jdk:1.8
 */
@MyAnnotation(id = 1,name = "tom",age = 20)//可以手动给与参数，如果不加上，会自动加上为默认值
public class UserInfo {

    private String name = "admin";

    public String str = "你好";

    private Integer id;

    @Override
    public String toString() {
        return "UserInfo{" +
                "name='" + name + '\'' +
                ", str='" + str + '\'' +
                ", id=" + id +
                '}';
    }

    //公开属性，可以加上get、set方法，私有属性就不加了


    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    //两个带参方法
    private String test(String str, Integer num) {
        System.out.println("test.......num:" + num);
        return str;
    }
    @MyAnnotation(id=1)//其它不赋值，采用默认值 name() default "Jim"; age() default 18;
    public String test(Integer num) {
        System.out.println("num:" + num);
        return str;
    }

    public UserInfo() { //此处应该私有，为做比较，换为public
    }

    //构造私有
    private UserInfo(Integer id) {
        this.id = id;
    }

}

 

myannotation类

package Reflection;

import java.lang.annotation.*;

/**
 * className MyAnnotation
 * 自定义注解
 * @author Java DaKun
 * @date 2020/8/28
 * @version:1.0
 * @since:jdk:1.8
 */
@Target({ElementType.TYPE,ElementType.FIELD,ElementType.METHOD})// 自定义注解 放置位置，不太理解的同学，可以看我上一篇博客
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    int id();

    //利用反射获取注解，主要作用就是获取注解的参数，所以这边给出默认赋值
    String name() default "Jim";

    byte age() default 18;
}

test类

public class reflectionTest {
    public static void main(String[] args) {
        //testFiled();
       //testMethod();
       //testConstructor();
      //testAnnotation();

    }

 

3.1、获取构造方法

 private static void testConstructor() {
        // 通过Class对象可以获取某个类中的：构造方法、成员变量、成员方法；并访问成员；
        // *
        // * 1.获取构造方法：
        // *        1).批量的方法：
        // *           public Constructor[] getConstructors()：所有”公有的”构造方法
        //            public Constructor[] getDeclaredConstructors()：获取所有的构造方法(包括私有、受保护、默认、公有)
        //
        // *         2).获取单个的方法，并调用：
        // *             public Constructor getConstructor(Class… parameterTypes):获取单个的”公有的”构造方法：
        // *          public Constructor getDeclaredConstructor(Class… parameterTypes):获取”某个构造方法”可以是私有的，或受保护、默认、公有；
        // *
        // *            调用构造方法：
        // *             Constructor–>newInstance(Object… args)
        Class<UserInfo> userInfoClass = UserInfo.class;

        System.out.println();

        System.out.println("--获取无参构造-返回值数组-");
        Constructor<?>[] constructors = userInfoClass.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor);
        }

        System.out.println("--获取任意有参构造方法- 返回值单一方法 -");
        try {
            
            Constructor<?> constructor = userInfoClass.getDeclaredConstructor(Integer.class);//此处指定带一个Integer参数的构造
            constructor.setAccessible(true);//此有参构造私有，授权
            UserInfo userInfo = (UserInfo) constructor.newInstance(100);
            System.out.println(userInfo.str);//new出对象后，得到实例变量str="你好"

        } catch (NoSuchMethodException | IllegalAccessException | InstantiationException | InvocationTargetException e) {
            e.printStackTrace();
        }

    }

输出结果

--获取无参构造-返回值数组-
public Reflection.UserInfo()
--获取任意有参构造方法- 返回值单一方法 -
你好

 

3.2、获取成员变量

 /*拿到类属性*/
    /* 1.批量的
     *       1).Field[] getFields():获取所有的”公有字段”
     *       2).Field[] getDeclaredFields():获取所有字段，包括：私有、受保护、默认、公有；
     * 2.获取单个的：
     *      1).public Field getField(String fieldName):获取某个”公有的”字段；
     *         2).public Field getDeclaredField(String fieldName):获取某个字段(可以是私有的)
     *
     *   设置字段的值：
     *        Field –> public void set(Object obj,Object value):
     *                  参数说明：
     *                   1.UserInfoClass:要设置的字段所在的对象；
     *                  2.name:要为字段设置的值；*/
    private static void testFiled() {

        // 等于Class UserInfoClass1 = UserInfo.class; ？其实就是UserInfo自己或者子类，主要用于安全地访问数据
        Class<? extends UserInfo> UserInfoClass = UserInfo.class;

        System.out.println("--获取所有公有属性-返回值数组-");
        Field[] Fields = UserInfoClass.getFields();
        for (Field Field : Fields) {

            System.out.println(Field);
        }

        System.out.println("--获取所有属性，包括私有的-返回值数组-");
        Field[] declaredFields = UserInfoClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }

        System.out.println("--获取任一公有属性-返回值单一属性-");
        try {
            Field field = UserInfoClass.getDeclaredField("id");
            System.out.println(field.getName());
            System.out.println(field.getType());
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }

        System.out.println("--获取任意属性，包括私有的-返回值单一属性-");
        try {
            Field field = UserInfoClass.getDeclaredField("name");
            System.out.println(field.getName());
            System.out.println(field.getType());
            field.setAccessible(true);//由于name属性是私有的，需要授权
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }

        
    }

输出结果

--获取所有公有属性-返回值数组-
public java.lang.String Reflection.UserInfo.str
--获取所有属性，包括私有的-返回值数组-
private java.lang.String Reflection.UserInfo.name
public java.lang.String Reflection.UserInfo.str
private java.lang.Integer Reflection.UserInfo.id
--获取任一公有属性-返回值单一属性-
id
class java.lang.Integer
--获取任意属性，包括私有的-返回值单一属性-
name
class java.lang.String

3.3、获取成员方法

    private static void testMethod() {
        // * 获取成员方法并调用：
        // *
        // * 1.批量的：
        // *         public Method[] getMethods():获取所有”公有方法”；（包含了父类的方法也包含Object类）
        // *        public Method[] getDeclaredMethods():获取所有的成员方法，包括私有的(不包括继承的)
        // * 2.获取单个的：
        // *       public Method getMethod(String name,Class<?>… parameterTypes):
        // *                  参数：
        // *                         name : 方法名；
        // *                         Class … : 形参的Class类型对象
        // *        public Method getDeclaredMethod(String name,Class<?>… parameterTypes)
        // *
        // *   调用方法：
        // *      Method –> public Object invoke(Object obj,Object… args):
        // *                  参数说明：
        // *                   obj : 要调用方法的对象；
        // *                     args:调用方式时所传递的实参；
        Class<UserInfo> userInfoClass = UserInfo.class;


        System.out.println("--获取所有公有方法包括父类、Object等-返回值数组-");
        Method[] methods = userInfoClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }

        System.out.println("--获取类所有方法,包括私有的-返回值数组-");
        Field[] declaredFields = userInfoClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }

        System.out.println("--获取任意公有方法-返回值  单一方法-");
        try {
            Method test = userInfoClass.getMethod("test", Integer.class); //指定一个参数的方法（此方法为public修饰），此方法返回值为实例变量str
            UserInfo userInfo = userInfoClass.newInstance(); //获取一个实例
            Object test1 = test.invoke(userInfo, 100); // 实例 + 参数
            System.out.println(test1);

        } catch (NoSuchMethodException | InstantiationException | InvocationTargetException | IllegalAccessException e) {
            e.printStackTrace();
        }

        System.out.println("---获取任意方法，包括私有的-返回值  单一方法----");
        try {
            Method test = userInfoClass.getDeclaredMethod("test", String.class, Integer.class);//可以指定私有test方法
            UserInfo userInfo = userInfoClass.newInstance(); //获取一个实例
            test.setAccessible(true); //授权
            Object hello = test.invoke(userInfo, "hello", 100);
            System.out.println(hello);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException | InstantiationException e) {
            e.printStackTrace();
        }


    }

输出值为

 1 Reflection.reflectionTest
--获取所有公有方法-返回值数组-
public java.lang.String Reflection.UserInfo.toString()
public java.lang.Integer Reflection.UserInfo.getId()
public java.lang.String Reflection.UserInfo.test(java.lang.Integer)
public void Reflection.UserInfo.setId(java.lang.Integer)
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
--获取所有方法,包括私有的-返回值数组-
private java.lang.String Reflection.UserInfo.name
public java.lang.String Reflection.UserInfo.str
private java.lang.Integer Reflection.UserInfo.id
--获取任意公有方法-返回值  单一方法-
num:100
你好
---获取任意公有方法，包括私有的-返回值  单一方法----
test.......num:100
hello

 

3.4、获取注解

   private static void testAnnotation() {
        Class<UserInfo> infoClass = UserInfo.class;

        //获得类上的注解
        MyAnnotation annotation = infoClass.getAnnotation(MyAnnotation.class);
        System.out.println(annotation.name());//赋值了tom


        System.out.println("-------------------------------");
        try {
            //获得方法上的注解
            MyAnnotation myAnnotation = infoClass.getMethod("test", Integer.class).getAnnotation(MyAnnotation.class);
            System.out.println(myAnnotation.name());//不赋值为Jim
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }

输出结果

tom
-------------------------------
Jim