La meilleure façon de transmettre une référence Java en aval de la chaîne d'objets

Question

Considérons une chaîne d'objets comme ceci :

Earth->Continent->Country->City->name

Considérons également Earth.class tiene public static void main(String[] args)

Lorsque l'application est exécutée avec l'option de la ligne de commande, p. ex. Barcelona quelle serait la meilleure façon de le transmettre à City sans introduire de paramètres intermédiaires ?

Les objets sont créés à différentes étapes de l'exécution du programme.

Devrions-nous faire name variable statique ou utiliser IoC comme Spring ou Google Guice ? Y a-t-il d'autres options ?

Toutes les idées sont les bienvenues.

Answer 1

• Je préfère la COI pour cette tâche. Laissez le CIO transmettre la dépendance lorsqu'il construit la ville.
• Alternatif : Utiliser un registre de services statique, qui peut être interrogé pour obtenir une valeur. La ville pourrait obtenir son nom à partir du registre des services.
• Alternatif : Implémentez le modèle composite dans votre hiérarchie, y compris une fonction telle que find, qui pourrait renvoyer la ville. Il vous suffit alors d'interroger et de définir earth.find(BarcelonaID).setName(args[0]);

Un exemple de ce à quoi ressemblerait une solution IoC dans PicoContainer :

PicoContainer container = new DefaultPicoContainer();
container.addComponent(Earth.class);
container.addComponent(Continent.class);
container.addComponent(Country.class);
container.addComponent(City.class, new ConstantParameter(cityName));

City barcelona = container.getComponent(City.class);

Answer 2

Vous pouvez construire des structures de données de haut en bas - le continent construit la ville - ou de bas en haut - le continent construit la ville. main construit la ville et la transmet au pays, ou en utilisant une combinaison des deux. DI privilégie cette dernière solution.

public static void main(String... argv) {
  // Bottom up.
  City city = new City(/* args relevant to city */);
  Country country = new Country(city, /* args relevant to country */);
  Continent continent = new Continent(country, /* args relevant to continent */);
  Planet planet = new Planet(continent, /* args relevant to planet */);
}

class City {
  City(/* few parameters */) { /* little work */ }
}
class Country {
  Country(/* few parameters */) { /* little work */ }
}
...
class Planet {
  Planet(/* few parameters */) { /* little work */ }
}

qui peut être beaucoup plus propre que la méthode descendante :

public static void main(String... argv) {
  // Top down.
  Planet earth = new Planet(
    /* all the parameters needed by Earth and its dependencies. */);
}
class Planet {
  Planet(/* many parameters */) { /* lots of work */ }
}
...

Les adeptes du DI soutiennent que la construction ascendante permet d'obtenir un code beaucoup plus facile à maintenir et à tester, mais vous n'avez pas besoin d'un cadre DI pour l'utiliser.

Answer 3

À mon avis, c'est le meilleur cas d'utilisation que vous puissiez imaginer pour un Visiteur modèle. Fondamentalement, il devrait y avoir une classe Parameters qui devrait contenir tous les paramètres. Chaque objet qui a besoin d'un jeu de paramètres peut être visité avec cet objet. Parameters classe. L'objet peut alors passer les paramètres à ses enfants qui savent quels paramètres utiliser et comment. Dans votre cas, cela peut être fait de cette façon :

public interface IParameterized{
   public void processParameters(Parameters param);
}

public class Earth implements IParameterized{
   public Earth(){
      // Create all countries here and store them in a list or hashmap 
   }
   public void processParameters(Parameters param){
      // find the country you want and pass the parameters to it
      country.processParameters(param);
   }
} 

public class Country implements IParameterized{
   public Country(){
      // Create all cities that belong to this country
   }
   public void processParameters(Parameters param){
      // find the city you want and pass the parameters to it
      city.processParameters(param);
   }
} 

public class City implements IParameterized{
   public City(){
      // Create city...
   }
   public void processParameters(Parameters param){
      // Do something with the parameter
   }
}

EDIT Pour câbler les points, on peut l'utiliser de la manière suivante :

public static void main(String... argv) {
     Parameters params = new Parameters();
     // Populate params from the command line parameters
     Earth earth = new Earth();

     // Earth takes the responsibilty of processing the parameters
     // It will delegate the processing to the underlying objects in a chain
     earth.processParameters(params);
}

À titre d'information, vous pouvez également jeter un coup d'œil sur le site Web de la Commission européenne. Chaîne de responsabilité modèle de conception