Java：什么场景需要使用反射？

Question

因此，通过阅读一些文章，我从中得到的信息是能够实时修改字段并向类设置值，而无需重新编译。

那么是否可以对第三方java库创建的没有可用源代码的类执行此操作/是否可以使用反射在运行时修改类实例？

反射还常用在哪些场景中？

我试图了解反射如何适用。

Answer 1

每当您在运行时处理字符串并希望将该字符串的一部分视为该语言中的标识符时。

1. 远程过程调用——将通过网络接收到的消息的一部分视为方法名称。
2. 序列化和反序列化——将字段名称转换为字符串，以便您可以将对象的字段写入流，然后将其转换回对象。
3. 对象关系映射——维护对象中的字段与数据库中的列之间的关系。
4. 与动态类型脚本语言的接口——将脚本语言生成的字符串值转换为对对象上的字段或方法的引用。

它还可用于允许在语言中模拟语言功能。
考虑命令行 java com.example.MyClass 将字符串转换为类名。这不需要反射，因为 java 可执行文件可以将 .class 文件转换为代码，但如果没有反射，它就无法编写 java com. example.Wrapper com.example.MyClass 其中 Wrapper 委托给其参数，如下所示：

class Wrapper {
  public static void main(String... argv) throws Exception {
    // Do some initialization or other work.
    Class<?> delegate = Class.forName(argv[0]);
    Method main = delegate.getMethod("main", String[].class);
    main.apply(null, Arrays.asList(argv).subList(1, argv.length).toArray(argv));
  }
}

Answer 2

另一种情况是开发 IDE，如 eclipse/netbeans 等，以确定抽象类中的哪些方法需要由子类实现，并自动为您编写缺少的方法调用（一个示例）。

Answer 3

Guice 或 Spring 等注入框架使用反射来帮助您在运行时构建对象的实例。

Answer 4

在需要配置将事物串在一起的情况下，反射也很有用。例如，在我编写的应用程序中，我有一个 @Report("debits") 注释，它只是添加到生成报告的方法中。然后，在 XML 配置中，用户可以简单地添加：

<requiredReports="debits,blah,another"/>

这可以最大限度地减少将 XML 代码映射到实际方法的样板代码，因为反射可以发现报告方法并使其直接可用。

Answer 5

我被要求为以下语句创建一个解决方案。

“1）差异服务：
• 可以计算两个对象之间的差异并返回结果
“差异”
• 可以对原始对象应用先前创建的“差异”，以便
返回的对象与用于计算的修改后的对象相匹配
差异。 “

如果不使用反射，这将非常困难。使用反射，我可以列出所有未知对象的类元素、属性和方法。我可以使用它们来获取对象中包含的值。我可以比较原始对象值和修改后的对象值，创建反映两个对象之间变化的“diff”对象，

然后我可以读取“diff”对象中的指令并将其应用到原始对象上，Java 反射为我提供了更改未知属性值所需的工具。我可以调用原始对象的 setter 方法和如果原始属性为 null，则在需要时实例化类型以在原始对象上设置修改后的值。

“diff”应用程序适用于同一类型的任何两个对象，但它们可以是任何类型，两个对象都必须是同一类型。反射

非常强大，允许我们创建真正的通用多态方法、函数、库和系统，其中传递的对象类型不需要在编译时知道。这适用于同时使用 Java 反射和泛型（这是一个非常强大的组合）。

最后，我还使用 Java Reflection 创建了一个通用排序函数，它可以使用该类的任何属性作为排序键对任何类类型的任何列表进行排序。只要调用方法传递列表和属性要使用的名称，该方法将返回一个排序列表。

Answer 6

以下是使用反射的一些情况 在

public class Main {

    public static void main(String[] args) {

        displayProperties(Stage.class);
    }

    public static void displayProperties(Class class) {
        boolean hasParam = false;
        boolean hasReturn = false;
        ArrayList<Method> propMethods = new ArrayList<>();
        Method[] methods = clazz.getMethods();
        for (Method m: methods) {

            Parameter[] paraType = m.getParameters();
            if(m.getParameterCount()<2) {
                if ((m.getReturnType() == void.class && paraType.length == 1) || (m.getReturnType() != void.class && paraType.length == 0)) {
                    //Get the properties alone
                    propMethods.add(m);
                }
            }

        }
        for (int i = 0; i < propMethods.size(); i++) {

            if (propMethods.get(i).getName().startsWith("get") || propMethods.get(i).getName().startsWith("set")) {

                System.out.println(readWrite(propMethods.get(i), propMethods) + " " + propMethods.get(i).getName().substring(3)+"( "+propMethods.get(i).getReturnType().getTypeName()+" )");
            } else
                System.out.println(readWrite(propMethods.get(i), propMethods) + " " + propMethods.get(i).getName() + "( "+propMethods.get(i).getReturnType().getTypeName()+" )");
        }

    }

    public static String readWrite(Method method, ArrayList<Method> propMeths) {

        ArrayList<Method> temp;
        temp = propMeths;

        boolean readIn = false;
        boolean writeIn = false;
        String onlyName = method.getName().substring(3);

        for (int i = 0; i < temp.size(); i++) {
            //use the substring--

            if (temp.get(i).getName().startsWith("get") && temp.get(i).getName().endsWith(onlyName)) {
                readIn = true;
            }
            if (temp.get(i).getName().startsWith("set") && temp.get(i).getName().endsWith(onlyName)) {

                writeIn = true;
            }
        }

        if (readIn == true && writeIn == true)
            return "rw ";
        else if (readIn == true && writeIn == false)
            return "r ";
        else
            return "w ";
    }
}

String 类的另一种情况

public static void main(String[] args) 
    {
        displayProperties(String.class);
    }

    public static void displayProperties(Class class){
        clazz.getDeclaredFields();

        Method[] methods = clazz.getDeclaredMethods();

        for(int ii = 0; ii<methods.length; ii++){
            System.out.println("Method Name: "+methods[ii].getName());
            System.out.println("Method Type: "+methods[ii].getReturnType());
            System.out.println("Method Pa: "+methods[ii].getParameterCount());
            System.out.println("Method Type: "+methods[ii].getReturnType());

        }
    }

下 使用反射从 XML 加载

public static Object loadFromXml(String filePath) throws Exception {

        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();
        File newFile = new File(filePath);
        Document doc = builder.parse(newFile);
        Node root = doc.getFirstChild();

        return loadObjectElement(root);


    }
    /**
     * This method loads from an xml file and returns all the contents of the file as an object
     * @param root The node passed in to the method from which the "tree" gets a new level
     * @return all the contents of the xml file as an object
     * @throws Exception
     */
    public static Object loadObjectElement(Node root) throws Exception {
        //loads the root
        String studentClass = root.getAttributes().getNamedItem("class").getTextContent();
        Object newStudentObject = Class.forName(studentClass).newInstance();
        //gets the children nodes (may have text elements like \n)
        NodeList studentFieldList = root.getChildNodes();

        //iterates through the children nodes
        for (int i = 0; i < studentFieldList.getLength(); i++) {
            //checks to make sure the child node is not a text node
            if (studentFieldList.item(i).getNodeType() != Node.TEXT_NODE) {
                //checks if the current node does not have children
                if (studentFieldList.item(i).getChildNodes().getLength() == 0) {
                    //receives data of the current node
                    String nameField = studentFieldList.item(i).getAttributes().getNamedItem("name").getTextContent();
                    String valueField = studentFieldList.item(i).getAttributes().getNamedItem("value").getTextContent();
                    Field declaredFieldInClass = newStudentObject.getClass().getDeclaredField(nameField);

                    //makes the field accessible
                    declaredFieldInClass.setAccessible(true);
                    //checks the field type
                    switch (declaredFieldInClass.getType().getSimpleName().toLowerCase()) {
                        case "integer":
                        case "int":
                            declaredFieldInClass.set(newStudentObject, Integer.valueOf(valueField));
                            break;
                        case "float":
                            declaredFieldInClass.set(newStudentObject, Float.valueOf(valueField));
                            break;
                        case "boolean":
                            declaredFieldInClass.set(newStudentObject, Boolean.valueOf(valueField));
                            break;
                        default:
                            declaredFieldInClass.set(newStudentObject, valueField);
                    }
                    declaredFieldInClass.setAccessible(false);
                } else {
                    //there are children in the current node
                    NodeList modulesObjectList = studentFieldList.item(i).getChildNodes();
                    String nameField = studentFieldList.item(i).getAttributes().getNamedItem("name").getTextContent();
                    Field declaredFieldInClass = newStudentObject.getClass().getDeclaredField(nameField);
                    List<Object> modules = new ArrayList<>();
                    //adds the modules into the array
                    for (int j = 0; j < modulesObjectList.getLength(); j++) {
                        if (modulesObjectList.item(j).getNodeType() != Node.TEXT_NODE) {
                            //recursively calls the the loadObjectElement method for any sub lists
                            modules.add(loadObjectElement(modulesObjectList.item(j)));
                        }
                    }
                    //sets the modules of the specific student that the method is working with
                    declaredFieldInClass.set(newStudentObject, modules);
                }
            }
        }
        return newStudentObject;
    }