Wie ist die Assoziation in Java implementiert?

Question

Ich versuche eine Java-Methode zu schreiben, die Assoziationen von einer bestimmten Klasse zu einer anderen Klasse entdeckt. Wie kann ich die Assoziation und die einer bestimmten Klasse zugeordneten Klassen finden?

Answer 1

Dies ist möglicherweise eine sehr komplexe Frage, Sie sollten Ihre Frage wirklich bearbeiten, um mehr Details darüber zu erhalten, was Sie versuchen zu tun. Ich werde versuchen zu erklären, warum das schwieriger ist als du denkst, während du gleichzeitig etwas bereitstellst, das gut genug ist, um das zu erreichen, was du willst.

Mein Verständnis ist, dass Sie eine Java-Methode schreiben möchten, die "Assoziationen" von einer bestimmten Klasse zu anderen Klassen entdeckt, und dass "Assoziationen" bedeutet "hat-a" Beziehungen.

Hinweis: für die Zwecke des Beispielcodes ich die Paketnamen „reflect.findHasARelation“

So lassen Sie sich das folgende Szenario verwenden:

Es gibt eine Car Klasse, die eine erklärt einige Felder:

package reflect.findHasARelation; 

public class Car { 
    private Motor motor; 
    private int weight; 
    private FuelTank fuelTank; 
} 

und wir haben auch die Klassen Motor und FuelTank im gleichen Paket. Zur Vereinfachung tun sie nichts.

Motorklasse:

package reflect.findHasARelation; 

public class Motor {} 

FuelTank Klasse:

package reflect.findHasARelation; 

public class FuelTank {} 

Lassen Sie uns jetzt einige Code schreiben, der die Car Klasse analysiert:

package reflect.findHasARelation; 

import java.lang.reflect.Field; 

public class FindHasARelationMain { 

    public static void main(String[] args) { 

     //It's not clear to me how you need to identify which classes to analyze 
     // so for now this is just hardcoded for the purposes of this example. 
     analyzeClass(Car.class); 

    } 

    public static void analyzeClass(Class classToAnalyze){ 
     //Process all fields of the class 
     for(Field field: classToAnalyze.getDeclaredFields()){ 
      if(Object.class.isAssignableFrom(field.getType())){ 
       //Assuming you're only interested in non-primitive fields 
       // this condition would tell you that the class you're 
       // analyzing is in a "has-a" relationship with whatever 
       // class the field is defined with. 
       System.out.println("Class "+classToAnalyze.getName()+" has a field " 
        + field.getName() + " of type "+ field.getType().getName()); 
      }else{ 
       System.out.println("Class "+classToAnalyze.getName()+" has a primitive field " 
         + field.getName() + " of type "+ field.getType().getName()); 
      } 
     } 
    } 

} 

Wenn Sie die oben Klasse ausgeführt werden Sie Siehe Ausgabe wie folgt:

Class reflect.findHasARelation.Car has a field motor of type reflect.findHasARelation.Motor 
Class reflect.findHasARelation.Car has a primitive field weight of type int 
Class reflect.findHasARelation.Car has a field fuelTank of type reflect.findHasARelation.FuelTank 

Sieht bis jetzt ziemlich gut aus, nicht wahr? Wir können sehen, dass es in der Lage ist zu identifizieren, dass die Car Klasse in einer "has-a" -Beziehung sowohl mit Motor als auch FuelTank ist.

Hier kommt die Komplexität ins Spiel: Was ist, wenn der Typ eines Feldes eine Schnittstelle statt einer Klasse ist?

Beginnen wir durch eine Schnittstelle zu erstellen:

package reflect.findHasARelation; 

public interface Engine { 
    public void start(); 
} 

Nun wollen wir eine neue Art von Auto erstellen:

package reflect.findHasARelation; 

public class StandardCar { 
    //Declares a field using an interface as the type 
    private Engine engine; 
    private int weight; 
    private FuelTank fuelTank; 

    public StandardCar(){ 
     engine = new StandardEngine(); 
    } 
} 

Wenn wir die main Methode aus früheren nehmen und ersetzen Car.class mit StandardCar.class dann wir sehe diesen Ausgang:

Class reflect.findHasARelation.StandardCar has a field engine of type reflect.findHasARelation.Engine 
Class reflect.findHasARelation.StandardCar has a primitive field weight of type int 
Class reflect.findHasARelation.StandardCar has a field fuelTank of type reflect.findHasARelation.FuelTank 

Warum passiert das? Dies liegt daran, dass es beim Analysieren der Klassendefinition durch reflection nicht möglich ist zu wissen, welche Implementierung von Engine zur Laufzeit verwendet wird.Stattdessen können Sie nur herausfinden, dass es ein Engine von einer Art ist - bis eine Instanz der Klasse tatsächlich erstellt wird, ist nicht bekannt, welche spezielle Art von Engine es ist. Es könnte sogar zwischen Instanzen variieren, da wir die Engine zu einem Parameter machen und ihn dann in den Konstruktor oder eine Setter-Methode übergeben könnten. In diesem Fall könnte ich zwei Instanzen der gleichen Klasse haben, die intern verschiedene Arten von Engine Implementierungen haben.

Hoffentlich verstehen Sie jetzt, warum Ihre Frage möglicherweise viel komplexer ist, als Sie dachten.