反射使您能够编写更通用的代码。它允许您在运行时创建对象并在运行时调用其方法。因此，程序可以高度参数化。它还允许对对象和类进行内省，以检测其暴露于外部世界的变量和方法。

我使用反射基于类名（String中的类名）创建一个对象，并调用该类的方法

Object obj = Class.forName(config.getClassPath())
                    .getDeclaredConstructor()
                    .newInstance();
Method method = obj.getClass().getMethod("getCustomer", SearchObject.class, ObjectConfig.class,
                HttpServletRequest.class);
method.invoke(obj, searchObject, config, request);

但一个主要问题是，如果您在该类上自动连线了某个对象，则该对象将被重新初始化为null

从java文档页面

java.lang.reflect包提供了用于获取关于类和对象的反射信息的类和接口。反射允许编程访问有关已加载类的字段、方法和构造函数的信息，以及在安全限制内使用反射字段、方法或构造函数对其底层对应对象进行操作。

如果必要的ReflectPermission可用，AccessibleObject允许禁止访问检查。

此包中的类与java.lang.Class一起容纳调试器、解释器、对象检查器、类浏览器等应用程序，以及需要访问目标对象的公共成员（基于其运行时类）或给定类声明的成员的服务（如object Serialization和JavaBeans）

它包括以下功能。

获取类对象，检查类（字段、方法、构造函数）的财产，设置和获取字段值，调用方法，创建对象的新实例。

查看Class类公开的方法的文档链接。

本文（由Sosnoski Software Solutions，Inc总裁Dennis Sosnosiki撰写）和本文（security-explorations pdf）：

与使用反射相比，我可以看到相当多的缺点

反射用户：

它提供了动态链接程序组件的多种方式它对于创建以非常通用的方式处理对象的库非常有用

反射的缺点：

当用于字段和方法访问时，反射比直接代码慢得多。它可以隐藏代码中的实际情况它绕过源代码会产生维护问题反射代码也比相应的直接代码更复杂它允许违反关键Java安全约束，例如作为数据访问保护和类型安全

一般滥用：

加载限制类，获取对受限类的构造函数、方法或字段的引用，创建新的对象实例、方法调用、获取或设置受限类的字段值。

看看这个关于滥用反射功能的SE问题：

如何在Java中读取私有字段？

摘要：

在系统代码中不安全地使用其功能也很容易导致Java安全模型的破坏。因此，谨慎使用此功能

我最喜欢的反射用法之一是下面的Java转储方法。它将任何对象作为参数，并使用Java反射API打印出每个字段名和值。

import java.lang.reflect.Array;
import java.lang.reflect.Field;

public static String dump(Object o, int callCount) {
    callCount++;
    StringBuffer tabs = new StringBuffer();
    for (int k = 0; k < callCount; k++) {
        tabs.append("\t");
    }
    StringBuffer buffer = new StringBuffer();
    Class oClass = o.getClass();
    if (oClass.isArray()) {
        buffer.append("\n");
        buffer.append(tabs.toString());
        buffer.append("[");
        for (int i = 0; i < Array.getLength(o); i++) {
            if (i < 0)
                buffer.append(",");
            Object value = Array.get(o, i);
            if (value.getClass().isPrimitive() ||
                    value.getClass() == java.lang.Long.class ||
                    value.getClass() == java.lang.String.class ||
                    value.getClass() == java.lang.Integer.class ||
                    value.getClass() == java.lang.Boolean.class
                    ) {
                buffer.append(value);
            } else {
                buffer.append(dump(value, callCount));
            }
        }
        buffer.append(tabs.toString());
        buffer.append("]\n");
    } else {
        buffer.append("\n");
        buffer.append(tabs.toString());
        buffer.append("{\n");
        while (oClass != null) {
            Field[] fields = oClass.getDeclaredFields();
            for (int i = 0; i < fields.length; i++) {
                buffer.append(tabs.toString());
                fields[i].setAccessible(true);
                buffer.append(fields[i].getName());
                buffer.append("=");
                try {
                    Object value = fields[i].get(o);
                    if (value != null) {
                        if (value.getClass().isPrimitive() ||
                                value.getClass() == java.lang.Long.class ||
                                value.getClass() == java.lang.String.class ||
                                value.getClass() == java.lang.Integer.class ||
                                value.getClass() == java.lang.Boolean.class
                                ) {
                            buffer.append(value);
                        } else {
                            buffer.append(dump(value, callCount));
                        }
                    }
                } catch (IllegalAccessException e) {
                    buffer.append(e.getMessage());
                }
                buffer.append("\n");
            }
            oClass = oClass.getSuperclass();
        }
        buffer.append(tabs.toString());
        buffer.append("}\n");
    }
    return buffer.toString();
}

例子：

以一个远程应用程序为例，它为您的应用程序提供了一个对象，您可以使用其API方法获取该对象。现在，基于对象，您可能需要执行某种计算。

提供者保证对象可以是3种类型，我们需要根据对象的类型进行计算。

因此，我们可以在3个类中实现，每个类包含不同的逻辑。显然，对象信息在运行时可用，因此您无法静态编码以执行计算，因此反射用于实例化类的对象，您需要根据从提供程序接收的对象执行计算。

名称反射用于描述能够检查同一系统（或其本身）中其他代码的代码。

例如，假设您在Java中有一个未知类型的对象，如果存在，您希望对其调用“doSomething”方法。Java的静态类型系统并不是为了支持这一点而设计的，除非对象符合已知的接口，但是使用反射，您的代码可以查看对象并找出它是否有一个名为“doSomething”的方法，如果需要，可以调用它。

因此，给您一个Java代码示例（假设所讨论的对象是foo）：

Method method = foo.getClass().getMethod("doSomething", null);
method.invoke(foo, null);

Java中一个非常常见的用例是注释的用法。例如，JUnit4将使用反射在类中查找标记有@Test注释的方法，然后在运行单元测试时调用它们。

有一些很好的反思示例可以帮助您开始http://docs.oracle.com/javase/tutorial/reflect/index.html

最后，是的，这些概念在其他支持反射的静态类型语言（如C#）中非常相似。在动态类型语言中，上面描述的用例不太必要（因为编译器将允许在任何对象上调用任何方法，如果不存在，则在运行时失败），但是第二种情况仍然很常见，即查找被标记或以某种方式工作的方法。

从评论更新：

检查系统中的代码并查看对象类型的能力是不是反思，而是类型反思。反射就是能够在运行时通过使用反省在某些语言中，这种区别是必要的支持内省，但不支持反思。一个这样的例子是C++