Dependencia circular en clases Java

Question

Tengo las siguientes clases.

public class B 
{ 
    public A a; 

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

y

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(); 
    } 
} 

Como puede verse claramente, hay una dependencia circular entre las clases. si trato de ejecutar la clase A, eventualmente obtengo un StackOverflowError.

Si se crea un gráfico de dependencia, donde los nodos son clases, entonces esta dependencia se puede identificar fácilmente (al menos para gráficos con pocos nodos). Entonces, ¿por qué la JVM no identifica esto, al menos en tiempo de ejecución? En lugar de arrojar StackOverflowError, JVM puede al menos dar una advertencia antes de comenzar la ejecución.

[Actualización] Algunos idiomas no pueden tener dependencias circulares, porque entonces el código fuente no se compilará. Por ejemplo, see this question y la respuesta aceptada. Si la dependencia circular es un olor de diseño para C#, entonces ¿por qué no es para Java? Solo porque Java puede (compilar código con dependencias circulares)?

[actualización2] Recientemente encontrado jCarder. Según el sitio web, encuentra bloqueos potenciales instrumentando dinámicamente los códigos de bytes de Java y buscando ciclos en el gráfico de objetos. ¿Alguien puede explicar cómo encuentra la herramienta los ciclos?

Answer 1

El constructor de su clase A llama al constructor de clase B. El constructor de clase B llama al constructor de clase A. Tiene una llamada de recursión infinita, por eso termina teniendo un StackOverflowError.

Java admite tener dependencias circulares entre clases, el problema aquí solo está relacionado con los constructores que se llaman entre sí.

Usted puede tratar con algo como:

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

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

Answer 2

No es necesariamente tan fácil como en su ejemplo. Creo que resolver este problema equivaldría a resolver el halting problem que, como todos sabemos, es imposible.

Answer 3

Su perfectamente válido en Java para tener una relación circular entre 2 clases (aunque las preguntas podrían ser preguntado por el diseño), sin embargo, en su caso, usted tiene la inusual acción de cada instancia creando una instancia de la otra en su constructor (siendo esta la causa real de StackOverflowError).

Este patrón particular se conoce como recursión mutua en la que tiene 2 métodos A y B (un constructor es solo un caso especial de un método) y A llama a las llamadas B y B. Detecta un ciclo infinito en la relación entre estos 2 métodos son posibles en el caso trivial (el que usted ha suministrado), pero resolverlo para el general es similar a la solución del problema de detención. Dado que la solución del problema de detención es imposible, los cumplidores en general no se molestan en intentar incluso para los casos simples.

Es posible cubrir algunos casos simples usando un patrón FindBugs, pero no sería correcto para todos los casos.

Answer 4

Una solución similar a los getters/setters que usan la composición y la inyección de constructor para las dependencias. Lo más importante a tener en cuenta es que los objetos no crean la instancia para las otras clases, sino que se pasan (también conocido como inyección).

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

Si realmente tiene un caso de uso de este tipo, se podría crear los objetos a demanda (pereza) y utilizar un captador:

public class B 
{ 
    private A a; 

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

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

     return a; 
    } 
} 

(y lo mismo para la clase A). Por lo tanto, solo se crean los objetos necesarios si, por ejemplo, Qué:

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

Answer 6

Por favor, echar un vistazo a mi artículo en http://java.dzone.com/articles/tackling-circular-dependency

Creo que va a despejar sus dudas ...