Dipendenza circolare nelle classi java

Question

Ho le seguenti classi.

public class B 
{ 
    public A a; 

    public B() 
    { 
     a= new A(); 
     System.out.println("Creating B"); 
    } 
} 

e

public class A 
{ 
    public B b; 

    public A() 
    { 
     b = new B(); 
     System.out.println("Creating A"); 
    } 

    public static void main(String[] args) 
    { 
     A a = new A(); 
    } 
} 

Come si vede chiaramente, v'è una dipendenza circolare tra le classi. se provo a eseguire la classe A, alla fine ottengo uno StackOverflowError.

Se viene creato un grafico di dipendenza, in cui i nodi sono classi, questa dipendenza può essere facilmente identificata (almeno per i grafici con pochi nodi). Allora perché la JVM non lo identifica, almeno in fase di runtime? Invece di lanciare StackOverflowError, JVM può almeno dare un avvertimento prima di iniziare l'esecuzione.

[Aggiornamento] Alcune lingue non possono avere dipendenze circolari, perché quindi il codice sorgente non verrà generato. Ad esempio, see this question e la risposta accettata. Se la dipendenza circolare è un odore di progettazione per C# allora perché non è per Java? Solo perché Java può (compilare codice con dipendenze circolari)?

[update2] Trovato di recente jCarder. Secondo il sito web, trova potenziali deadlock, strumentando dinamicamente i codici byte Java e cercando i cicli nel grafico degli oggetti. Qualcuno può spiegare in che modo lo strumento trova i cicli?

Answer 1

Il costruttore della classe A chiama il costruttore della classe B. Il costruttore della classe B chiama il costruttore della classe A. Hai una chiamata di ricorsione infinita, ecco perché hai un StackOverflowError.

Supporti Java con dipendenze circolari tra classi, il problema qui è solo relativo ai costruttori che si chiamano l'un l'altro.

Si può provare con qualcosa di simile:

A a = new A(); 
B b = new B(); 

a.setB(b); 
b.setA(a); 

Answer 2

Non è necessariamente facile come nel tuo esempio. Credo che risolvere questo problema equivarrebbe a risolvere il halting problem che - come tutti sappiamo - è impossibile.

Answer 3

Il suo perfettamente valido in Java per avere un rapporto circolare tra 2 classi (anche se le domande si potrebbe chiedere circa il disegno), ma nel tuo caso si ha l'insolito azione di ogni istanza che crea un'istanza dell'altro nel suo costruttore (questa è la causa effettiva dello StackOverflowError).

Questo modello particolare è noto un ricorsione mutua dove si hanno 2 metodi A e B (un costruttore è più solo un caso particolare di un metodo) e A chiama B e B chiama A. Rilevare un loop infinito nel rapporto tra questi due metodi sono possibili nel caso banale (quello che hai fornito), ma risolverlo per il generale è come risolvere il problema dell'arresto. Dato che risolvere il problema dell'arresto è impossibile, in genere i compilatori non si preoccupano nemmeno di provare i casi semplici.

Potrebbe essere possibile coprire alcuni dei casi semplici utilizzando uno schema FindBugs, ma non sarebbe corretto per tutti i casi.

Answer 4

Una soluzione simile ai getter/setter che utilizzano la composizione e l'iniezione del costruttore per le dipendenze. La cosa più importante da notare è che gli oggetti non creano l'istanza per le altre classi, ma vengono passati (ovvero l'iniezione).

public interface A {} 
public interface B {} 

public class AProxy implements A { 
    private A delegate; 

    public void setDelegate(A a) { 
     delegate = a; 
    } 

    // Any implementation methods delegate to 'delegate' 
    // public void doStuff() { delegate.doStuff() } 
} 

public class AImpl implements A { 
    private final B b; 

    AImpl(B b) { 
     this.b = b; 
    } 
} 

public class BImpl implements B { 
    private final A a; 

    BImpl(A a) { 
     this.a = a; 
    } 
} 

public static void main(String[] args) { 
    A proxy = new AProxy(); 
    B b = new BImpl(proxy); 
    A a = new AImpl(b); 
    proxy.setDelegate(a); 
} 

Answer 5

Se avete davvero un caso d'uso come questo, è possibile creare gli oggetti su richiesta (pigramente) e utilizzare un getter:

public class B 
{ 
    private A a; 

    public B() 
    { 
     System.out.println("Creating B"); 
    } 

    public A getA() 
    { 
     if (a == null) 
     a = new A(); 

     return a; 
    } 
} 

(e allo stesso modo per la classe A). Quindi vengono creati solo gli oggetti necessari se ad es. fanno:

a.getB().getA().getB().getA() 

Answer 6

Si prega di dare un'occhiata al mio articolo su http://java.dzone.com/articles/tackling-circular-dependency

Penso che sarà chiarire i vostri dubbi ...