Wie kann ich über Reflection auf private Methoden und private Datenmitglieder zugreifen?

1. Verwenden Sie die in der Antwort angegebene Methode, die Sie mit: setAccessible (true) verknüpft haben. Dies ist eine Methode der Oberklasse von Field, Constructor und Method.
2. Nein.
3. Nein, es sei denn, der Code wird in einer von Ihnen kontrollierten JVM ausgeführt, in der Sie einen Sicherheitsmanager installieren. Wenn Sie jedoch jemandem eine Jar-Datei geben und er die Klassen aus dieser Jar-Datei verwendet, kann er auf alles zugreifen.

Für den Zugriffein privates Feld müssen Sie die Class.getDeclaredField(String name)- oder enter code here-Methode aufrufen. Überprüfen Sie diesen einfachen Code:

public class PrivateObject {

  private String privateString = null;

  public PrivateObject(String privateString) {
    this.privateString = privateString;
  }
}

PrivateObject privateObject = new PrivateObject("The Private Value");

Field privateStringField = PrivateObject.class.
            getDeclaredField("privateString");

privateStringField.setAccessible(true);

String fieldValue = (String) privateStringField.get(privateObject);
System.out.println("fieldValue = " + fieldValue

Für den Zugriff auf eine private Methode müssen Sie die Methode Class.getDeclaredMethod (Stringname, Class [] parameterTypes) oder die Methode Class.getDeclaredMethods () aufrufen.

Überprüfen Sie diesen einfachen Code:

public class PrivateObject {

  private String privateString = null;

  public PrivateObject(String privateString) {
    this.privateString = privateString;
  }

  private String getPrivateString(){
    return this.privateString;
  }
}
PrivateObject privateObject = new PrivateObject("The Private Value");

Method privateStringMethod = PrivateObject.class.
        getDeclaredMethod("getPrivateString", null);

privateStringMethod.setAccessible(true);

String returnValue = (String)
        privateStringMethod.invoke(privateObject, null);

System.out.println("returnValue = " + returnValue);

Weitere Informationen finden Sie unter http://tutorials.jenkov.com/Java-reflection/private-fields-and-methods.html

Beispiel wie folgt:

import Java.lang.reflect.Constructor;

import Java.lang.reflect.Field;

import Java.lang.reflect.InvocationTargetException;

import Java.lang.reflect.Method;

class Test
{
    private int a = 5;   // Private data member

    private void call(int n) // Private method
    {
        System.out.println("in call()  n: " + n);
    }
}

public class Sample
{
    public static void main(String args[]) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchFieldException
    {
        Class c = Class.forName("Test");

        Object obj = c.newInstance();

        //---- Accessing a private method
        Method m=c.getDeclaredMethod("call",new Class[]{int.class});
        m.setAccessible(true);
        m.invoke(obj,7);

       //---- Accessing a private data member
       Field d = c.getDeclaredField("a");
       d.setAccessible(true);
       System.out.println(d.getInt(obj));
    }
}

 Area s=(Area)c.newInstance();  
 s.setRadius(10);
 System.out.println("Area: "+s.calculateArea(4));

 Method m[]=c.getDeclaredMethods(); 
  Constructor c1[]=c.getConstructors();  

 for(int i=0;i<m.length;i++)
     System.out.println(""+m[i]);

 for(int i=0;i<c1.length;i++)
     System.out.println(""+c1[i]);

Um Ihre dritte Frage zu beantworten:

3. Gibt es eine Möglichkeit, zu verhindern, dass jemand auf private Konstruktoren, Methoden und Datenmitglieder zugreift?

Antworten:

Ja, Sie können den Zugriff einschränken (Sie können eine Ausnahme auslösen, wenn jemand versucht, auf Ihren privaten Konstruktor/Methode/Daten zuzugreifen).

Siehe das folgende Beispiel:

******JavaSingleton Class******

package server;

public class JavaSingleton {

  private static final JavaSingleton INSTANCE = new JavaSingleton();

  private JavaSingleton() {
    if (INSTANCE != null) {
      throw new IllegalStateException("Inside JavaSingleton(): JavaSingleton " +
                                                        "instance already created.");
    }
    System.out.println("Inside JavaSingleton(): Singleton instance is being created.");
  }

  public static final JavaSingleton getInstance() {
    return INSTANCE;
  }
}


***Listing 2: JavaSingleton client***

import server.JavaSingleton;
import Java.lang.reflect.*;

public class TestSingleton {

  public static void main(String[] args) throws ReflectiveOperationException {
    System.out.println("Inside main(): Getting the singleton instance using getInstance()...");
    JavaSingleton s = JavaSingleton.getInstance();

    System.out.println("Inside main(): Trying to use reflection to get another instance...");
    Class<JavaSingleton> clazz = JavaSingleton.class;
    Constructor<JavaSingleton> cons = clazz.getDeclaredConstructor();
    cons.setAccessible(true);
    JavaSingleton s2 = cons.newInstance();
  }
}

Output:

C:\singleton>Java TestSingleton
Inside main(): Getting the singleton instance using getInstance()...
Inside JavaSingleton(): Singleton instance is being created.
Inside main(): Trying to use reflection to get another instance...
Exception in thread "main" Java.lang.reflect.InvocationTargetException
  at Sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
  at Sun.reflect.NativeConstructorAccessorImpl.newInstance(Unknown Source)
  at Sun.reflect.DelegatingConstructorAccessorImpl.newInstance(Unknown Source)
  at Java.lang.reflect.Constructor.newInstance(Unknown Source)
  at TestSingleton.main(TestSingleton.Java:13)
Caused by: Java.lang.IllegalStateException: Inside JavaSingleton(): JavaSingleton instance already created.
  at server.JavaSingleton.<init>(JavaSingleton.Java:7)
  ... 5 more

Dieses Beispiel war für eine Singleton-Klasse (Einchecken im Konstruktor), Sie können diese Logik jedoch für die privaten Methoden implementieren, auf die Sie den Zugriff von anderen Klassen verhindern möchten.

In diesem Fall werden Sie auch eine statische Instanz deklarieren und deren Wert in der privaten Methode überprüfen und bei unerwünschten Werten einen Fehler ausgeben.