Kontynuacja z Dependency injection, delayed injection praxis. Mam główną klasę:Dynamiczny wtrysk wiosenny, fabrycznie podobny wzór
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();
}
}
Wykres obiektu jest dynamicznie tworzony, w zależności od interakcji użytkownika. Rozwiązałem sprzężenie aplikacji, co pozwoliło mi to przetestować bardzo prosto. Ponadto, ponieważ listy są obsługiwane przez kontener, dynamiczny charakter tej aplikacji (i wszystkich innych) jest nieistotny, ponieważ mogą one być wymagane w dowolnym momencie, gdy aplikacja ich potrzebuje, zachowując ich elementy.
Reszta kodu jest tutaj:
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;
}
}
Czy ktoś wie w jaki sposób mogę rozwiązać ten createList metoda call() lub createSecondList() - bez użycia konstruktora które dość dużo siły projektu. Myślałem o fabryce, ale fabryka dla każdej klasy w projekcie o większej skali nie wydaje się dobrym pomysłem.
Coś jak:
<bean ... factory-method="..." depends-on="..." lazy-init="..."/>
A w sposobie fabrycznego instancję klasy i wywołać metodę createList(). Albo tak to nazwij, z jakiejś metody - która znowu wygląda źle, zmuszając metodę do ponoszenia odpowiedzialności za utworzenie wykresu obiektu.
obrazem zależności runtime, że chcę rozwiązać w czasie wykonywania jest poniżej:
Czy istnieje jakiś inny sposób mógłbym wykorzystać pojemnik do achive dynamiczny leniwy initalization zależności od interakcji z użytkownikiem ?
Dziękuję.
Nie mam pojęcia, o co pytasz. Co masz na myśli przez "_solve_ wywołanie metody createList() lub createSecondList()"? Jeśli mam rację w moim przypuszczeniu, co próbujesz zrobić (i wątpię w to), utworzę klasę fabryczną, która ma (statyczną?) Metodę fabryczną, która pobiera argument interaktywny i tworzy odpowiednią listę, a następnie wstrzykuje obiekt fabryczny tej klasy do twojego głównego obiektu. –
Myślałem, że zrozumiesz z kontekstu. Nie jest świetnym pisarzem pytań. Tak, coś takiego. Pytanie jest pogrubione. Poza fabryką (statyczną, oczywiście) i za pomocą ciągnięcia/inicjalizacji obiektów (z inicjalizacją w klasie Main, metodą "główną"), jak mogę skonstruować wykres obiektów dynamicznych, żeby nie musieć się martwić o kod architektury " "w mojej aplikacji. Dlaczego miałbyś wstrzyknąć obiekt fabryczny w swój główny obiekt? Będziesz miał dużo pracy, jeśli wszystkie zajęcia będą dynamiczne. Ponieważ powinieneś mieć fabrykę na każdej dynamicznej klasie. Nadal uważam, że istnieje prostsze rozwiązanie :) – pfh