Java反射

用途

运行时，通过反射获取类的变量、方法等各种信息。

简介

JDK中java.lang.reflect包里的一些类提供了反射的主要功能。
1、Class代表一个类。
2、Field代表类的变量。
3、Method代表类的方法。
4、Constructor类代表类的构造方法。
5、Array类提供了动态创建数组，访问数组元素的静态方法。

如何使用？

获取Class对象的3个方法

public void test1() throws ClassNotFoundException {
    Class<?> clazz1 = Class.forName("java.lang.String");
    Class<String> clazz2 = String.class;
    Class<? extends String> clazz3 = "1".getClass();
    System.out.println(clazz1 == clazz2);  //true
    System.out.println(clazz2 == clazz3);  // true
}

创建Class实例的2个方法

@Test
public void test2() throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
    Class<String> clazz = String.class;
    String s1 = clazz.newInstance();
    System.out.println(s1 instanceof String);  //true

    Constructor<String> c2 = clazz.getConstructor(String.class);
    String s2 = c2.newInstance("");
    System.out.println(s2 instanceof String);  //true
}

获取类的方法

getDeclaredMethods()无法获取继承的方法。

class Student extends Teacher{
    public void learn(){

    }

    protected void discuss(){

    }

    private void review(){

    }
}

class Teacher{
    public void teach(){

    }
}

/**
 * protected void com.sss.refection.RefectionTest1$Student.discuss()
 * public void com.sss.refection.RefectionTest1$Student.learn()
 * private void com.sss.refection.RefectionTest1$Student.review()
 */
@Test
public void test3() {
    Class<Student> clazz = Student.class;
    Method[] methods = clazz.getDeclaredMethods();
    for (Method m: methods) {
        System.out.println(m);
    }
}

getMethods()可以获取继承的方法，但只能获取public方法。

/**
 * public void com.sss.refection.RefectionTest1$Student.learn()
 * public void com.sss.refection.RefectionTest1$Teacher.teach()
 * 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 java.lang.String java.lang.Object.toString()
 * 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()
 */
@Test
public void test5() {
    Class<Student> clazz = Student.class;
    Method[] methods = clazz.getMethods();
    for (Method m: methods) {
        System.out.println(m);
    }
}

getMethod()获取单个方法

/**
 * public void com.sss.refection.RefectionTest1$Student.learn()
 */
@Test
public void test6() throws NoSuchMethodException {
    Class<Student> clazz = Student.class;
    Method method = clazz.getMethod("learn");
    System.out.println(method);
}

获取构造方法、方法、成员变量是反射最重要的三类API。

// 返回此Class对象对应参数的构造方法
public Constructor<T> getConstructor(Class<?>... parameterTypes);
// 返回此Class对象所有public构造方法
public Constructor<?>[] getConstructors();
// 返回此Class对象对应类的，带指定形参的构造方法，与构造方法的访问权限无关
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes);
// 返回此Class对象对应类的所有构造方法，与构造方法的访问权限无关
public Constructor<?>[] getDeclaredConstructors()

// 获取此Class对象对应类的，带指定参数的public方法
public Method getMethod(String name, Class<?>... parameterTypes)
// 获取此Class对象对应类的public方法
public Method[] getMethods()
// 获取此Class对象对应类的、带指定参数的方法，与方法权限无关
public Method getDeclaredMethod(String name, Class<?>... parameterTypes)
// 获取此Class对象对应类的方法，与方法权限无关
public Method[] getDeclaredMethods()

// 获取此Class对象对应类的指定名称的public成员变量
public Field getField(String name)
// 获取此Class对象对应类的public成员变量
public Field[] getFields()
// 获取此Class对象对应类指定名称的成员变量，与成员变量的访问权限无关
public Field getDeclaredField(String name)
// 获取此Class对象对应类的全部成员变量，与成员变量的访问权限无关
public Field[] getDeclaredFields()

注解相关的方法：

// 获取此Class对象对应类上存在指定类型的Annotation。
public <A extends Annotation> A getAnnotation(Class<A> annotationClass)
// 获取此Class对象对应类上存在指定类型的直接修饰的Annotation。
public <A extends Annotation> A getDeclaredAnnotation(Class<A> annotationClass)
// 获取此Class对应类上存在的所有Annotation
public Annotation[] getAnnotations()
// 返回直接修饰该Class对应类的所有Annotation
public Annotation[] getDeclaredAnnotations()

反射应用：手写精简版IOC容器

/**
 * 指定需要容器管理的类
 */
@Target({ ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {
}


/**
 * 指定需要注入的属性
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Autowired {
}



import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor(access = AccessLevel.PUBLIC)
@NoArgsConstructor
public class Student {
    private String name;
    private int id;
}


@Component
public class StudentService {
    public void queryAllStudent(){
        System.out.println("查询所有Student");
    }
}

@Component
public class StudentController {
    @Autowired
    private StudentService studentService;

    public void queryAllStudent(){
        studentService.queryAllStudent();
    }
}


public class IOC {
    public static final Map<Class<?>, Object> applicationContext = new ConcurrentHashMap<Class<?>, Object>();

    static{
        String packageName = "com.sss.refection.myioc";
        try {
            initBean(packageName);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    private static void initBean(String packageName) throws Exception {
        Enumeration<URL> urls = Thread.currentThread().getContextClassLoader().getResources(packageName.replaceAll("\\.", "/"));
        while (urls.hasMoreElements()) {
            addClassByAnnotation(urls.nextElement().getPath(), packageName);
        }
        autowired();
    }

    //获取指定包路径下实现 Component主键Bean的实例
    private static void addClassByAnnotation(String filePath, String packageName) {
        try {
            File[] files = getClassFile(filePath);
            if (files != null) {
                for (File f : files) {
                    String fileName = f.getName();
                    if (f.isFile()) {
                        Class<?> clazz = Class.forName(packageName + "." + fileName.substring(0, fileName.lastIndexOf(".")));
                        if(clazz.isAnnotationPresent(Component.class)) {
                            applicationContext.put(clazz, clazz.newInstance());
                        }
                    } else {
                        addClassByAnnotation(f.getPath(), packageName + "." + fileName);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //获取该路径下所遇的class文件和目录
    private static File[] getClassFile(String filePath) {
        return new File(filePath).listFiles(new FileFilter() {
            @Override
            public boolean accept(File file) {
                return file.isFile() && file.getName().endsWith(".class") || file.isDirectory();
            }
        });
    }

    private static void autowired() {
        try {
            for (Map.Entry<Class<?>, Object> entry : applicationContext.entrySet()) {
                Class<?> clazz = entry.getKey();
                Object obj = entry.getValue();
                Field[] fields = clazz.getDeclaredFields();
                for (Field field : fields) {
                    if (field.isAnnotationPresent(Autowired.class)) {
                        Class<?> fieldClazz = field.getType();
                        field.setAccessible(true);
                        Object fieldObj = applicationContext.get(fieldClazz);
                        field.set(obj, fieldObj);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class Test {
    public static void main(String[] args) throws Exception {
        StudentController userController = (StudentController)IOC.applicationContext.get(StudentController.class);
        userController.queryAllStudent();
    }
}