[java 基础]反射入门

原文

概况

使用java的反射，可以让我们检查（或者修改）类，接口，字段，方法的特性。当你在编译期不知道他们的名字的时候非常有用。

除此之外，可以使用反射来创建实例，调用方法或者get/set 字段值。

设置项目

需要做的只有导个包。

import java.lang.reflect.*; //根据使用的情况导特定的，比如reflect.constructor等

简单例子

先加一下junit的依赖，然后添加一个Person类，两个字段。

public class Person {
    private String name;
    private int age;
}

写个测试方法来获取这个类的所有字段。

 /**
  * 包含所有字段
  */
 @Test
 public void containAllFields() {
     Object p = new Person();
     Field[] declaredFields = p.getClass().getDeclaredFields();
     List<String> actualFields = Arrays.stream(declaredFields).map(field -> field.getName()).collect(Collectors.toList());
     List<String> exceptFields = new ArrayList<>();
     exceptFields.add("age");
     exceptFields.add("name");
     Assert.assertTrue(exceptFields.containsAll(actualFields));
 }

使用场景

最常用的使用场景为数据库表和实体类做字段映射。

检查java类

下面来做一些测试，用来获取前面提到过的比如类名，修饰符，字段，方法，实现的接口之类的东西。

准备工作

先创建一个Eating接口

public interface Eating {
    String eats();
}

创建一个抽象Animal类来实现这个Eating接口

package com.lou.reflect.test;

public abstract class Animal implements Eating {
    public static String CATEGORY = "domestic";
    private String name;

    protected abstract String getSound();

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

创建一个Locomotion接口用来描述动物的行动方式。

package com.lou.reflect.test;

public interface Locomotion {
    String getLocomotion();
}

创建一个具体的Goat类，继承自Animal同时实现Locomotion接口。

package com.lou.reflect.test;

public class Goat extends Animal implements Locomotion {
    public Goat(String name) {
        super(name);
    }

    @Override
    protected String getSound() {
        return "山羊叫";
    }

    @Override
    public String eats() {
        return "吃草";
    }

    @Override
    public String getLocomotion() {
        return "行走";
    }
}

创建一个Bird类，继承自Animal

public class Bird extends Animal {
    private boolean walks;


    public Bird() {
        super("鸟");
    }

    public Bird(String name) {
        super(name);
    }

    public Bird(String name, boolean walks) {
        super(name);
        this.walks = walks;
    }

    @Override
    protected String getSound() {
        return null;
    }

    @Override
    public String eats() {
        return null;
    }

    public boolean isWalks() {
        return walks;
    }

    public void setWalks(boolean walks) {
        this.walks = walks;
    }
}

做好准备工作之后开始下面的测试。

类名

获取类名。

/**
 * simpleName为Goat，
 * name为com.lou.reflect.test.Goat
 * cannocalName为com.lou.reflect.test.Goat
 */
@Test
public void givenObjectThenGetNameTest() {
    Object goat = new Goat("山羊");
    Class<?> goatClazz = goat.getClass();

    Assert.assertEquals("Goat", goatClazz.getSimpleName());
    Assert.assertEquals("com.lou.reflect.test.Goat", goatClazz.getName());
    Assert.assertEquals("com.lou.reflect.test.Goat",goatClazz.getCanonicalName());
}

类修饰符

/**
 * 通过获取类的modifier来判断类的特性
 * @throws Exception
 */
@Test
public void givenObjectThenGetModifiersTest() throws Exception {
    Class<?> animalClazz = Class.forName("com.lou.reflect.test.Animal");
    Class<?> goatClazz = Class.forName("com.lou.reflect.test.Goat");
    //获取两个类的修饰符
    int animalModifiers = animalClazz.getModifiers();
    int goatModifiers = goatClazz.getModifiers();
    //判断是否是公有
    Assert.assertTrue(Modifier.isPublic(goatModifiers));
    //判断是否是抽象
    Assert.assertTrue(Modifier.isAbstract(animalModifiers));
    //判断是否为公有
    Assert.assertTrue(Modifier.isPublic(animalModifiers));
}

包信息

/**
 * 获取包信息
 */
@Test
public void givenClassThenGetPackageNameTest() {
    Goat goat = new Goat("山羊");
    Package goatPackage = goat.getClass().getPackage();
    Assert.assertEquals("com.lou.reflect.test", goatPackage.getName());
}

父类信息

/**
 * 获取父类信息
 */
@Test
public void givenClassThenGetSupperClassTest() {
    Goat goat = new Goat("山羊");
    String str = "hello";

    Class<?> goatSupperClazz = goat.getClass().getSuperclass();
    Class<?> strSupperClazz = str.getClass().getSuperclass();

    Assert.assertEquals("com.lou.reflect.test.Animal",goatSupperClazz.getName());
    Assert.assertEquals("java.lang.Object",strSupperClazz.getName());
}

实现的接口

/**
 * 获取实现的接口信息
 *
 * @throws Exception
 */
@Test
public void givenClassThenGetImpMethodsTest() throws Exception {

    Class<?> goatClazz = Class.forName("com.lou.reflect.test.Goat");
    Class<?> animalClazz = Class.forName("com.lou.reflect.test.Animal");
    Class<?>[] goatInterfaces = goatClazz.getInterfaces();
    Class<?>[] animalInterfaces = animalClazz.getInterfaces();

    //实现的接口，都是1个，虽然goat的父类实现了一个，goat自己也实现了一个。
    //只能获取用implements显式实现的接口。如果要全部就只能递归了。
    Assert.assertEquals(1, goatInterfaces.length);
    Assert.assertEquals(1, animalInterfaces.length);

    Assert.assertEquals("Locomotion", goatInterfaces[0].getSimpleName());
    Assert.assertEquals("Eating", animalInterfaces[0].getSimpleName());

}

构造函数，方法，字段

/**
 * 构造函数，方法，字段
 */
@Test
public void givenClassThenGetConstructorMethodField() throws Exception {
    Class<?> goatClazz = Class.forName("com.lou.reflect.test.Goat");
    Class<?> animalClazz = Class.forName("com.lou.reflect.test.Animal");
    Constructor<?>[] goatCtors = goatClazz.getConstructors();
    Assert.assertEquals(1, goatCtors.length);
    Field[] animalFields = animalClazz.getDeclaredFields();
    //一个静态的CATEGORY，一个name，所以是2个。
    Assert.assertEquals(2, animalFields.length);
    //3个。这里获取到的是显式申明的方法，不包括那些从object继承下来的
    Method[] animalMethods = animalClazz.getDeclaredMethods();
    Assert.assertEquals(3, animalMethods.length);
    //getName,setName,getSound,
    List<String> methodNames = Arrays.stream(animalMethods).map(method -> method.getName()).collect(Collectors.toList());
    Assert.assertTrue(methodNames.containsAll(Arrays.asList("getName", "setName", "getSound")));
}

获取构造函数然后动态调用

/**                                                                                   
 * 获取bird的3个构造函数，然后分别调用~。                                                             
 * @throws Exception                                                                  
 */                                                                                   
@Test                                                                                 
public void getConstructorThenCreateInstance() throws Exception {                     
    Class<?> birdClazz = Class.forName("com.lou.reflect.test.Bird");                  
    //获取无参的构造函数                                                                       
    Constructor<?> birdCtro1 = birdClazz.getConstructor();                            
    //获取有一个String类型的参数的构造函数                                                           
    Constructor<?> birdCtro2 = birdClazz.getConstructor(String.class);                
    //获取有一个String类型，一个boolean类型参数的构造函数                                                
    Constructor<?> birdCtro3 = birdClazz.getConstructor(String.class, boolean.class); 
    //调用无参的                                                                           
    Bird bird1 = (Bird) birdCtro1.newInstance();                                      
    Assert.assertEquals("鸟", bird1.getName());                                        
    //调用有一个参数的                                                                        
    Bird bird2 = (Bird) birdCtro2.newInstance("bird2");                               
    Assert.assertEquals("bird2", bird2.getName());                                    
    //调用两个参数的构造函数                                                                     
    Bird bird3 = (Bird) birdCtro3.newInstance("bird3", true);                         
    Assert.assertEquals("bird3", bird3.getName());                                    
    Assert.assertEquals(true, bird3.isWalks());                                       
}                                                                                     

运行期间修改field值，调用method

/**
 * 通过获取name字段，然后动态修改。 
 * 通过动态调用setName方法，修改name的值 
 * @throws Exception
 */
@Test  
public void givenClassThenModifyFields() throws Exception {
    Class<?> birdClazz = Class.forName("com.lou.reflect.test.Bird");     
    Bird bird =(Bird) birdClazz.newInstance();   
    //定义在父类
    Field nameField = birdClazz.getSuperclass().getDeclaredField("name");                       
    //先设置为可访问                                                                              
    nameField.setAccessible(true);                                                             
    nameField.set(bird,"一只bird");                                                             
    Assert.assertEquals("一只bird",bird.getName());
    Method setNameMethod = birdClazz.getSuperclass().getDeclaredMethod("setName", String.class);       
    setNameMethod.invoke(bird,"又一只"); 
    Assert.assertEquals("又一只",bird.getName());                                                         
}