come faccio a ripetere un elenco java in stringtemplate?

Question

Voglio ripetere i risultati di una query di ibernazione all'interno di stringtemplate. Ho cercato degli esempi ma non riesco a trovare nulla.

puoi aiutarmi per favore? grazie

Answer 1

%staffForOrg: {staff| 
    <tr> 
     <td><a href="#%staff.id%a" class="directory " id="%staff.id%1" onclick="javascript: window.location='StaffInfo.html?id=%staff.id%';">%staff.telephoneNumber%</a></td> 

    </tr> 
}% 

---

questo codice funziona perfettamente.

staffForOrg è un elenco del mio modello. Ho usato l'ibernazione per recuperare i record.

Answer 2

La sintassi si presenta come

<items :{ item | <item> }> 

Mettere insieme in Java:

List<String> teams = Arrays.asList("Cats", "Birds", "Turtles"); 
ST s = new ST("<teams :{team | <team> }>"); 
s.add("teams", teams); 
System.out.println(s.render()); 

In questo esempio ho iterare l'elenco e stampare ogni. Il risultato che verrebbe stampato è:

Cats Birds Turtles 

Possiamo esplorare la sintassi che lo rende possibile. Prima di farlo, ricorda che i delimitatori predefiniti in StringTemplate sono inferiori a < e superiori a >. Dal momento che non abbiamo specificato delimitatori diversi, saranno quelli che utilizzeremo nel nostro esempio. See more about delimiters

:{ } 

Questo insieme di simboli, colon : e la parentesi aperta e chiusa {} può essere letta come "per ogni". Nel modello di esempio, il codice legge, per ogni team in teams stampa team. Il lato sinistro del tubo verticale | indica la variabile che verrà creata per ciascuna iterazione. Terrà la squadra attuale dall'elenco delle squadre. La stampa è composta da <team> sul lato destro del tubo verticale | e sul lato sinistro della graffa di chiusura }. Tutto ciò che si trova sul lato destro del tubo verticale | e prima della base di chiusura } verrà valutato per la stampa.

:{ current value | everything in here will be printed } 

Per utilizzare il concetto, utilizzare una struttura di dati più complessa.

public class Player { 
    private String name; 
    private int age; 

    public Person(String name, int age) { 
     this.name = name; 
     this.age = age; 
    } 
    public int getAge() { return age; } 
    public String getName() { return name; } 
} 

Ora siamo in grado di creare un paio di giocatori per la nostra squadra:

Player[] players = new Player[] { 
    new Player("Bill", 29), 
    new Player("Steve", 30), 
    new Player("Toby", 15) 
}; 

String playerTemplate = "<players:{ player |<player.name> is <player.age> <\\n>}>" 
ST s = new ST(playerTemplate ); 
s.add("players", Arrays.asList(players)); 
System.out.println(s.render()); 

dando un risultato di

Bill is 29 
Steve is 30 
Toby is 15 

paio di cose da notare. Non abbiamo accesso all'età e al nome delle proprietà direttamente. La ST ha chiamato i metodi getAge e getName. ST non guarda alle proprietà. Invece cerca i metodi di accesso.

E se volessimo solo iterare su un elenco che conteneva un altro elenco. Possiamo farlo anche noi. Per prima cosa, costruiamo la nostra struttura dati e riempiamola con un paio di elenchi.

List<List<String>> listOfLists = asList(
    asList("One", "Two", "Three"), 
    asList("Four", "Five"), 
    asList("Six", "Seven", "Eight", "Nine") 
); 

Il modello sarà simile al seguente.

<list :{ items |<items :{ item |<item> }><\n>}> 

Il nostro modello in questo caso sarà solo una combinazione. Il guscio esterno sarà iterare l'elenco passeremo dentro.

<list :{ items | what we will print }> 

Poi per ogni articolo che si stampare le voci nella sua lista.

<items :{ item |<item> }> 

Una volta abbiamo messo tutto insieme

String template = "<list :{ items |<items :{ item |<item> }><\\n>}>"; 
ST st = new ST(template); 
st.add("list", listOfLists); 
System.out.println(st.render()); 

otteniamo un risultato che sia simile alla seguente.

One Two Three 
Four Five 
Six Seven Eight Nine 

Basandoci su questo concetto un po 'di più possiamo creare una seconda struttura dati che contiene un elenco di giocatori. Questo dimostrerà come iterare all'interno dell'iterazione.

La prima cosa di cui abbiamo bisogno è una struttura dati che contenga un elenco. Per questo possiamo creare una squadra per far partecipare i nostri giocatori.

public class Team { 
    private List<Player> players; 
    private String name; 

    public Team (String name, List<Player> players) { 
     this.players = players; 
     this.name = name; 
    } 

    public List<Player> getPlayers() { 
     return players; 
    } 

    public String getName() { 
     return name; 
    } 
} 

Si noti che la nostra squadra contiene giocatori. Questa composizione ci permetterà di costruire due iterazioni.

Ora che abbiamo la nostra struttura dati, possiamo impostare tutto insieme per formare un paio di squadre con alcuni giocatori.

List<Team> teams = asList(
     new Team("Billings", asList(
       new Player("Bill", 29), 
       new Player("Steve", 30), 
       new Player("Toby", 15) 
     )), 
     new Team("Laurel", asList(
       new Player("Chad", 32), 
       new Player("Chuck", 29), 
       new Player("Will", 24), 
       new Player("Ben", 26) 
     )) 
); 

Ora ti permette di creare un modello e compilare alcuni dettagli:

String simpleTeamTemplate = "<teams:{ team |<team.name> has <length(team.players)> players<\\n>}>"; 

ST template = new ST(simpleTeamTemplate); 
template.add("teams", teams); 

System.out.println(template.render()); 

che stamperà fuori

Billings has 3 players 
Laurel has 4 players 

il nostro semplice modello è quasi lo stesso come il nostro primo modello da sopra. L'unica vera differenza è che stiamo usando un metodo build in length(). See more on functions here

Aumentiamo un po 'la complessità dei modelli da aggiungere nella nostra seconda iterazione.

Per prima cosa creeremo il nostro playersTemplate. Questo è quasi identico al nostro modello playerTemplate dall'alto. L'unica differenza è che i nostri giocatori provengono da uno team: team.players.

String playersTemplate = "<team.players :{ player |<player.name> is <player.age><\\n>}>"; 

Ora costruiremo un secondo modello che contiene il primo. In questo modello possiamo eseguire iterazioni sui team e per ogni team stamperemo lo name, il numero di giocatori length(team.players) e tutto il numero playersTemplate.

String teamTemplate = "<teams:{ team |<team.name> has <length(team.players)> players<\\n>"+playersTemplate+"}>"; 

Ora mettiamo tutto insieme.

ST teamsTemplate = new ST(simpleTeamTemplate); 
teamsTemplate.add("teams", teams); 

System.out.println(teamsTemplate.render()); 

Questo stamperà per noi quanto segue.

Billings has 3 players 
Bill is 29 
Steve is 30 
Toby is 15 
Laurel has 4 players 
Chad is 32 
Chuck is 29 
Will is 24 
Ben is 26 

Ora, non siete realmente intenzione di voler coniugare i modelli in questo modo. Aggiungere le stringhe insieme per comporre i modelli è piuttosto sciocco. StringTemplate offre strumenti per rendere questa combinazione di modelli parziali molto semplice. Se sei curioso di abbinare i modelli puoi scoprire di più here