Eine Fortsetzung von Dependency injection, delayed injection praxis. Ich habe die Hauptklasse:Federdynamische Einspritzung, fabrikähnliches Muster
package test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Scanner;
@Component
public class Main {
@Autowired
private StringValidator stringValidator;
@Autowired
private StringService stringService;
@Autowired
private ValidationService validationService;
public void main() {
scanKeyboardCreateLists();
stringValidator.validate();
final List<String> validatedList = stringValidator.getValidatedList();
for (String currentValid : validatedList) {
System.out.println(currentValid);
}
}
private void scanKeyboardCreateLists() {
//Let's presume the user interacts with the GUI, dynamically changing the object graph...
//Needless to say, this is past container initialization...
Scanner scanner = new Scanner(System.in);
int choice = scanner.nextInt();
//Delayed creation, dynamic
if (choice == 0) {
stringService.createList();
validationService.createList();
} else {
stringService.createSecondList();
validationService.createSecondList();
}
}
public static void main(String[] args) {
ApplicationContext container = new ClassPathXmlApplicationContext("/META-INF/spring/applicationContext.xml");
container.getBean(Main.class).main();
}
}
Und das Objektdiagramm wird dynamisch erstellt, abhängig von der Benutzerinteraktion. Ich habe die Anwendungskopplung gelöst und kann das sehr einfach testen. Da die Listen auch vom Container verwaltet werden, ist die dynamische Art dieser Anwendung (und jeder anderen) irrelevant, da sie jederzeit angefordert werden können, wenn die Anwendung sie benötigt, und ihre Elemente beibehalten werden.
Der Rest des Codes ist hier:
package test;
import java.util.List;
public interface Stringable {
List<String> getStringList();
}
package test;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
@Component
public class StringList extends ArrayList<String> {
}
package test;
import org.springframework.stereotype.Component;
import javax.inject.Inject;
import java.util.ArrayList;
import java.util.List;
@Component
public class StringService implements Stringable {
private List<String> stringList;
@Inject
public StringService(final ArrayList<String> stringList) {
this.stringList = stringList;
}
//Simplified
public void createList() {
stringList.add("FILE1.txt");
stringList.add("FILE1.dat");
stringList.add("FILE1.pdf");
stringList.add("FILE1.rdf");
}
public void createSecondList() {
stringList.add("FILE2.txt");
stringList.add("FILE2.dat");
stringList.add("FILE3.pdf");
stringList.add("FILE3.rdf");
}
@Override
public List<String> getStringList() {
return stringList;
}
}
package test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
@Component
public class StringValidator {
private List<String> stringList;
private List<String> validationList;
private final List<String> validatedList = new ArrayList<String>();
@Autowired
public StringValidator(final ArrayList<String> stringList,
final ArrayList<String> validationList) {
this.stringList = stringList;
this.validationList = validationList;
}
public void validate() {
for (String currentString : stringList) {
for (String currentValidation : validationList) {
if (currentString.equalsIgnoreCase(currentValidation)) {
validatedList.add(currentString);
}
}
}
}
public List<String> getValidatedList() {
return validatedList;
}
}
package test;
import java.util.List;
public interface Validateable {
List<String> getValidationList();
}
package test;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
@Component
public class ValidationList extends ArrayList<String> {
}
package test;
import org.springframework.stereotype.Component;
import javax.inject.Inject;
import java.util.ArrayList;
import java.util.List;
@Component
public class ValidationService implements Validateable {
private List<String> validationList;
@Inject
public ValidationService(final ArrayList<String> validationList) {
this.validationList = validationList;
}
//Simplified...
public void createList() {
validationList.add("FILE1.txt");
validationList.add("FILE2.txt");
validationList.add("FILE3.txt");
validationList.add("FILE4.txt");
}
public void createSecondList() {
validationList.add("FILE5.txt");
validationList.add("FILE6.txt");
validationList.add("FILE7.txt");
validationList.add("FILE8.txt");
}
@Override
public List<String> getValidationList() {
return validationList;
}
}
Wer weiß, wie würde ich den Methodenaufruf Createlist() oder createSecondList() lösen - ohne den Konstruktor die so ziemlich Kräfte das Design. Ich dachte an eine Fabrik, aber eine Fabrik für jede Klasse in einem größeren Projekt scheint keine gute Idee zu sein.
Etwas wie:
<bean ... factory-method="..." depends-on="..." lazy-init="..."/>
Und in der Factory-Methode die Klasse instanziiert und die Methode Createlist) (nennen. Oder nennen Sie es so, von einer Methode - die wiederum schlecht aussieht, zwingt die Methode, die Verantwortung für die Instanziierung des Objektgraphen zu haben.
Das Bild der Laufzeit Abhängigkeiten, die ich in der Laufzeit lösen will, ist unten:
Gibt es irgendeine andere Weise, die ich den Container dynamische faul initialisiert abhängig von der Benutzer-Interaktion achive verwenden könnte ?
Vielen Dank.
Ich habe keine Ahnung, was Sie fragen. Was meinst du mit "_solve_ der Methodenaufruf createList() oder createSecondList()"? Wenn ich richtig einschätze, was Sie zu tun versuchen (und ich bezweifle es), würde ich eine Factory-Klasse mit einer (statischen?) Factory-Methode erstellen, die das interaktive Argument verwendet und die entsprechende Liste erstellt und dann einfügt ein Factory-Objekt dieser Klasse in Ihr Main-Objekt. –
Ich dachte, du würdest das aus dem Kontext verstehen. Kein guter Fragenschreiber. Ja, so etwas. Die Frage ist fett geschrieben. Neben factory (natürlich natürlich) und mit pull/initialization der Objekte (mit Initialisierung in der Main-Klasse, "main" -Methode), wie kann ich den dynamischen Objektgraphen konstruieren, so muss ich mich nicht um Architektur "Code kümmern "In meiner Bewerbung. Warum injizieren Sie das Fabrikobjekt in Ihr Hauptobjekt? Du hättest viel Arbeit, wenn alle deine Klassen dynamisch sind. Da solltest du eine Factory für jede dynamische Klasse haben. Ich glaube immer noch, dass es eine einfachere Lösung gibt :) – pfh