Come faccio a confrontare i parametri e i tipi di ritorno in fase di esecuzione?

Question

Come faccio a confrontare i parametri e i tipi di ritorno in fase di esecuzione?

#1 da (1 voti)
#2 da (1 voti)
#3 da (0 voti)

1

Ho un'applicazione Java che ha bisogno di elaborare alcuni dati. I dati iniziano nel formato A.

L'applicazione è composta da un numero di moduli che sono ciascuno in grado di elaborare i dati. Ma non tutti i moduli supportano lo stesso tipo di dati dell'input e dell'output. Il modulo 1 accetta i dati nel formato A e li emette nel formato B. Il modulo 2 accetta i dati nel formato B e li emette nel formato C. Il modulo 3 prende i dati nel formato A o nel formato C e emette il formato B. Un altro prende B o C e restituisce lo stesso formato in cui ha ricevuto i dati. E così via, hai avuto l'idea.

E come se questa situazione non fosse già abbastanza brutta, ci sono molti moduli, ciascuno con i propri formati di input e output. Alcuni corrispondono, altri no. I moduli possono essere eseguiti in qualsiasi ordine e l'ordine viene fornito in fase di runtime dall'utente.

Ho bisogno di assicurarmi che i moduli siano in un ordine in cui ogni entrata e uscita corrispondono. Come posso farlo? C'è forse qualche schema di progettazione che non conosco che risolva questo?

Fondamentalmente, ho bisogno di un modo per recuperare il formato di input e output di un modulo, confrontarlo con un altro e, talvolta, lanciare un oggetto sul tipo che ho scoperto.

Ho avuto un paio di idee come recuperare il parametro e restituire i tipi tramite reflection, ma alcuni formati di dati coinvolgono generiche annidate che vengono cancellate in fase di compilazione. E altre cose che mi sono venute in mente non avrebbero aggirato il fatto che probabilmente avrei dovuto capire a che tipo dovevo eseguire il cast in runtime se le avessi applicate.

Tutti i pensieri e le indicazioni sarebbero apprezzati.

java design-patterns runtime modularization

posta Namnodorel 10.06.2018 - 17:33

fonte

3 risposte

Leggi altre domande sui tag java design-patterns runtime modularization

Come correttamente includere le dipendenze in artefatti nei casi d'uso di UML Unendo automaticamente un fork al master

score 1 · Answer 1

A, B e C dovrebbero essere di tipi diversi, quindi sai quale formato hai per il tipo che hai passato. Non c'è bisogno di riflessioni o generici o qualsiasi tipo di controllo di runtime, hai solo funzioni separate con diverse firme per prendere ogni tipo diverso, quindi il tuo codice non verrà nemmeno compilato se proverai a passare un particolare tipo a un modulo che non lo supporta.

Se c'è qualche motivo specifico che questo non funziona per te, probabilmente avremmo bisogno di più informazioni sulle tue specifiche per determinare le alternative.

score 1 · Answer 2

Innanzitutto voglio dire che se il sistema di tipo statico Javas non funziona davvero per te, puoi disattivarlo semplicemente trattando tutto come un oggetto.

Se posso parlarti di quell'opzione nucleare vorrei sottolineare che sapere staticamente che aToB() prende un A e restituisce un B non è la stessa cosa che sapere che il primo modulo sarà un A. Sai solo che se chiamano aToB() è meglio che lavorino su qualcosa di simile A. Il che ha senso dal momento che tutto aToB() sa come lavorare.

The modules could be executed in any order, and the order is provided at runtime by the user.

Non senza causare un errore non possono. La cosa importante che vorrei capire qui è come l'utente sta inserendo questo ordine. Se l'ordine viene creato senza conoscenza dei dati, si interromperà o non lo farà. Se l'ordine viene creato in fase di esecuzione quando i dati sono noti, puoi indirizzare l'input dell'utente eseguendo operazioni non valide prima di fare clic su di essi.

Un design molto pulito che ne consegue è quello di consentire a ogni tipo di dati di fornire un elenco di operazioni valide. Il nome che abbiamo dato a questo modello di design è "oggetti".

score 0 · Answer 3

Il primo problema da affrontare è la conversione dei formati: per ogni coppia di formati X e Y, dovrebbe esserci un metodo che trasforma il formato X in formato Y.

Il secondo problema è trovare per ogni modulo N quali sono i suoi formati di input e output.

Quindi, è un compito semplice prendere una sequenza di moduli: (1, 2, 3, 4) , e inserire le funzioni di mappatura tra ogni modulo: (1(A=>B), M(B=>B), 2(B=>C), M(C=>D), 3(D=>A), M(A=>E), 4(E=>B)) . La notazione M(A=>B) indica la funzione di mappatura che prende il formato A e restituisce il formato B .

Se il modulo 3 può prendere il formato C o il formato D , potrebbe non essere necessario interporre una funzione di mappatura.