Una continuazione da Dependency injection, delayed injection praxis. Ho la classe principale:Iniezione dinamica a molla, modello tipo fabbrica
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();
}
}
E il grafico dell'oggetto viene creato dinamicamente, a seconda dell'interazione dell'utente. Ho risolto l'accoppiamento dell'applicazione, permettendomi di testarlo molto semplicemente. Inoltre, poiché gli elenchi sono gestiti dal contenitore, la natura dinamica di questa applicazione (e di ogni altra) è irrilevante, poiché possono essere richiesti ogni volta che l'applicazione ne ha bisogno, mantenendo i loro elementi.
Il resto del codice è qui:
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;
}
}
Qualcuno sa come vorrei risolvere il createList chiamata al metodo() o createSecondList() - senza utilizzare il costruttore che più o meno le forze della progettazione. Stavo pensando ad una fabbrica, ma una fabbrica per ogni classe in un progetto di una grandezza maggiore non sembra una buona idea.
Qualcosa di simile:
<bean ... factory-method="..." depends-on="..." lazy-init="..."/>
E nel metodo factory istanziare la classe e chiamare il metodo createList(). Oppure chiamalo in questo modo, da un altro metodo - che di nuovo sembra scadente, costringendo il metodo ad avere la responsabilità di istanziare il grafico dell'oggetto.
Il quadro delle dipendenze runtime che voglio risolvere in fase di esecuzione è sotto:
C'è qualche altro modo ho potuto utilizzare il contenitore per achive dinamica inizializzazione del pigro a seconda della interazione con l'utente ?
Grazie.
Non ho idea di cosa stai chiedendo. Cosa intendi con "_solve_ il metodo call createList() o createSecondList()"? Se ho ragione su ciò che stai cercando di fare (e ne dubito), creerei una classe factory che ha un metodo factory (statico?) Che prende l'argomento interattivo e crea l'elenco appropriato, quindi inietta un oggetto factory di quella classe nel tuo oggetto Main. –
Ho pensato che avresti capito dal contesto. Non una grande scrittrice di domande. Sì, qualcosa di simile. La domanda è audace. Oltre alla fabbrica (statica, ovviamente) e usando il pull/inizializzazione degli oggetti (con inizializzazione nella classe Main, metodo "main"), come posso costruire il grafico dinamico degli oggetti in modo da non dovermi preoccupare dell'architettura "codice "nella mia domanda. Perché dovresti iniettare l'oggetto fabbrica nel tuo oggetto principale? Avresti molto lavoro se tutte le tue classi fossero dinamiche. Dal momento che dovresti avere una fabbrica su ogni classe dinamica. Continuo a credere che esista una soluzione più semplice :) – pfh