java 反射增加字段方法

谁还没有辜负几段昂贵的时光-毛不易

文章目录

• Class的获取方式
• 字段访问
• 方法调用
• 构造方法调用
• 继承关系
• 动态代理

在工作中会时不时的用到反射，今天我们系统的梳理一下反射的知识点，以下分几个模块来梳理反射的内容。

Class的获取方式

1. 通过类名.class获取

Class clazz = Animal.class;

1. 通过对象.getClass方法获取

Cat cat = new Cat();
Class aClass = cat.getClass();

1. 通过类名获取

try {
            Class<?> aClass1 = Class.forName("com.example.testreflect.Animal");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

注意：尽管获取的方式有多种，但是类对象在内存中是唯一的，所以静态方法加锁的对象是类对象。

类对象的一些方法，以String为例：

方法	作用
getName（）	获取类的全名称，带包名（java.lang.String）
getSimpleName（）	获取类的名称，不带包名 （String）
getPackage().getName()	获取包名 （java.lang）
isInterface()	是否是接口（不是接口）
isEnum()	是否是枚举（不是枚举）
isArray()	是否是数组（不是数组）
isPrimitive()	是否是基本类型（不是基本类型）
newInstance()	创建类实例，只能调用public的无参数构造方法。

一些使用技巧，用来判断类是否存在

boolean isClassPresent(String name) {
    try {
        Class.forName(name);
        return true;
    } catch (Exception e) {
        return false;
    }
}

字段访问

• 获取字段的方法：

方法	作用
Field getField(name)	根据字段名获取某个public的field（包括父类）
Field getDeclaredField(name)	根据字段名获取当前类的某个field，私有的也可以（不包括父类）
Field[] getFields()	获取所有public的field（包括父类）
Field[] getDeclaredFields()	获取当前类的所有field，私有的也可以（不包括父类）

测试以及运行结果

public void filedId() throws NoSuchFieldException {
        Class<Cat> catClass = Cat.class;

        Field age = catClass.getField("age");

        Field name = catClass.getField("name");

        Field climb = catClass.getDeclaredField("climb");
        Field[] fields = catClass.getDeclaredFields();
        Field[] fields1 = catClass.getFields();

        System.out.println(age + "\n" + name + "\n" + climb + "\n" + Arrays.toString(fields) + "\n" + Arrays.toString(fields1));
    }

运行结果

I System.out: public int com.example.testreflect.Animal.age
I System.out: public java.lang.String com.example.testreflect.Animal.name
I System.out: private int com.example.testreflect.Cat.climb
I System.out: [private int com.example.testreflect.Cat.climb]
I System.out: [public int com.example.testreflect.Animal.age, public java.lang.String com.example.testreflect.Animal.name]

• Field的一些方法

方法	作用
getName()	返回字段名称
getType()	返回字段类型，也是一个Class实例
getModifiers()	返回字段的修饰符，它是一个int，不同的bit表示不同的含义。

Field测试：

Field f = String.class.getDeclaredField("value");
f.getName(); // "value"
f.getType(); // class [B 表示byte[]类型
int m = f.getModifiers();
Modifier.isFinal(m); // true
Modifier.isPublic(m); // false
Modifier.isProtected(m); // false
Modifier.isPrivate(m); // true
Modifier.isStatic(m); // false

• 获取对象字段值

class Test{
     public void getValue() throws NoSuchFieldException, IllegalAccessException {
        Animal animal = new Animal(1, "小强");
        Class<? extends Animal> aClass = animal.getClass();
        Field name = aClass.getDeclaredField("name");
        //setAccessible作用是启动和禁用访问安全检查的开关
        name.setAccessible(true);
        Object o = name.get(animal);
        System.out.println(o);//小强
    }
}

class Animal{
    private int age;
    private String name;

    public Animal(int age, String name) {
        this.age = age;
        this.name = name;
    }
}

注意以上访问的是Animal的私有属性，必须禁用访问安全检查才可以访问setAccessible。

• 设置对象字段值

class Test{
     @Test
    public void setValue() throws NoSuchFieldException, IllegalAccessException {
        Animal animal = new Animal(1, "小强");
        Class<? extends Animal> aClass = animal.getClass();
        Field name = aClass.getDeclaredField("name");
        //setAccessible作用是启动和禁用访问安全检查的开关
        name.setAccessible(true);
        name.set(animal,"小明");
        Object o = name.get(animal);

        System.out.println(o);//小明
    }
}


class Animal{
    private int age;
    private String name;

    public Animal(int age, String name) {
        this.age = age;
        this.name = name;
    }
}

方法调用

• 方法调用

方法	作用
Method getMethod(name, Class…)	获取某个public的Method（包括父类）
Method getDeclaredMethod(name, Class…)	获取当前类的某个Method（不包括父类）
Method[] getMethods()	获取所有public的Method（包括父类）
Method[] getDeclaredMethods()	获取当前类的所有Method（不包括父类）

测试代码

class Test{
     public void call() throws NoSuchMethodException {
        Class<Cat> catClass = Cat.class;
        //获取public的getAge，参数为String类型
        Method getAge = catClass.getMethod("getAge", String.class);
        //获取public的getNameByTag，参数为int类型
        Method getNameByTag = catClass.getMethod("getNameByTag", int.class);
        // 获取private方法getClimb，
        Method getClimb = catClass.getDeclaredMethod("getClimb");
    }
}

class Animal{
    private int age;
    private String name;

    public String getNameByTag(int tag) {
        return name + tag;
    }

    public int getAge(String type) {
        return age;
    }


}

class Cat extends Animal{
    private int climb;

    private int getClimb() {
        return climb;
    }
}

• Method方法

方法	作用
getName()	返回方法名称
getReturnType()	返回方法返回值类型，也是一个Class实例
getParameterTypes()	返回方法的参数类型，是一个Class数组
getModifiers()	返回方法的修饰符，它是一个int，不同的bit表示不同的含义

• 反射调用方法
  invoke的第一个参数是对象实例，即在哪个实例上调用该方法，后面的可变参数要与方法参数一致，否则将报错。

public void invoke() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Cat cat = new Cat();
        cat.setName("小强");
        Class<? extends Cat> aClass = cat.getClass();
        Method getNameByTag = aClass.getMethod("getNameByTag", int.class);
        Object invoke = getNameByTag.invoke(cat, 1);
        System.out.println(invoke);//小强1
    }

• 静态方法调用
  获取到的Method表示一个静态方法，调用静态方法时，由于无需指定实例对象，所以invoke方法传入的第一个参数永远为null。

public void callStaticMethod() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Method test = Animal.class.getMethod("test");
        //调用者直接传null。
        Object invoke = test.invoke(null);
    }

• 私有方法调用
  为了调用非public方法，我们通过Method.setAccessible(true)允许其调用。

public void invokePrivateMethod() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Animal animal = new Animal();
        animal.setName("小强");
        Class<Animal> animalClass = Animal.class;
        Method getName = animalClass.getDeclaredMethod("getName");
        getName.setAccessible(true);//getName是私有方法
        Object invoke = getName.invoke(animal);
        System.out.println(invoke);//小强
    }

注意：setAccessible(true)可能会失败。如果JVM运行期存在SecurityManager，那么它会根据规则进行检查，有可能阻止setAccessible(true)。例如，某个SecurityManager可能不允许对java和javax开头的package的类调用setAccessible(true)，这样可以保证JVM核心库的安全。

• 多态思考
  父类获取方法，子类执行，其使用反射调用方法时，仍然遵循多态原则。
  以下测试程序打印cat。

class Test{
    public void duotai() throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
        Cat cat = new Cat();
        Method eat = cat.getClass().getDeclaredMethod("eat");
        eat.invoke(cat);

    }
}

class Animal{


   public void eat(){
       System.out.println("animal");
   }
}

class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("cat");
    }
}

构造方法调用

• 调用public无参的构造方法

Animal animal = Animal.class.newInstance();

• 为了调用任意的构造方法，Java的反射API提供了Constructor对象，它包含一个构造方法的所有信息，可以创建一个实例。

class{
   public void invokeC() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class<Animal> aClass = Animal.class;
        Constructor<Animal> constructor = aClass.getConstructor(String.class, int.class);
        Animal animal = constructor.newInstance("小强", 2);
        System.out.println(animal.getAge() + "--" + animal.getName());//2--小强
    }  
}


class Animal{
    private String name;
    private int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat(){
       System.out.println("animal");
   }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

• 构造方法方法汇总

方法	作用
getConstructor(Class…)	获取某个public的Constructor
getDeclaredConstructor(Class…)	获取某个Constructor
getConstructors()	获取所有public的Constructor
getDeclaredConstructors()	获取所有Constructor

注意：调用非public的Constructor时，必须首先通过setAccessible(true)设置允许访问。setAccessible(true)可能会失败。

继承关系

class实例通过调用getSuperclass()可以获取其父类的class，调用getInterfaces可以获取其实现的接口类型。

注意：etInterfaces()只返回当前类直接实现的接口类型，并不包括其父类实现的接口类型

动态代理

我们都知道，class（非abstract）是可以创建对象的，而interface是不能够进行实例化的。java开发规范中有一条是面向接口编程，其实通过某个实例向上转型并赋值给接口类型变量的。

而动态代理则是不需要编写实现类，则直接在运行期间创建某个interface的实例。

动态代理是直接通过JDK提供的一个Proxy.newProxyInstance()创建了一个接口对象，这个对象是在运行期间创建的，也是在内存中产生的对象。

其使用方式如下：

在运行期动态创建一个interface实例的方法如下：

1. 定义一个InvocationHandler实例，它负责实现接口的方法调用；
2. 通过Proxy.newProxyInstance()创建interface实例，它需要3个参数：

1. 使用的ClassLoader，通常就是接口类的ClassLoader；
2. 需要实现的接口数组，至少需要传入一个接口进去；
3. 用来处理接口方法调用的InvocationHandler实例。

3. 将返回的Object强制转型为接口。

class Test{
     public void testProxy(){
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println(method + "--" + Arrays.toString(args));// public abstract void com.example.testreflect.Action.eat(java.lang.String)--[fruit]

                return null;
            }
        };

        Action action = (Action) Proxy.newProxyInstance(Action.class.getClassLoader(), new Class[]{Action.class}, invocationHandler);
        action.eat("fruit");


    }
}

interface Action {
    void eat(String food);
}