Affichage des éléments d’une liste déroulante issus d’une énumération dans un projet Java Struts2
Pour ce qui ne sont pas familié avec le concepte de Struts2, voici un petit tour d’horizon.
Struts2 repose sur le modèle de conception de type MVC (Modèle, Vue, Contrôleur). Il repose sur une déclaration de l’architecture sous forme de fichiers XML (ou annotations Java) localisées dans les fichiers des classes d’actions. Struts2 est un framework orienté actions. Les actions sont décomposées en trois rôles :
– Les actions encapsulent le traitement et le travail à réaliser par le service.
– Les actions permettent de manipuler automatiquement les données des requêtes lors des transferts.
– Le framework détermine quel résultat doit être retourné et la Vue à afficher en réponse à un traitement. La Vue est un fichier JSP au format XML.
Les actions Struts2 implémentent des objets JavaBeans (simple objet Java : classe publique, constructeur par défaut, publique, sans paramètre, attributs non publics, déclarer getter et setter) pour chaque groupe de données envoyées dans la requête. Chaque paramètre de la requête est déclaré dans la classe d’action avec un nom identique pour réaliser automatiquement le mapping des valeurs. La finalité d’une action étant de retourner une chaîne de caractères permettant de sélectionner le résultat à afficher.
Voici notre exemple : L’affichage des éléments d’une liste déroulante issus d’une énumération :
Dans la classe AccountType.java, le liste les éléments de la liste.
public enum AccountType {
tva,
client,
vente,
analytique;
}
L’Enum AccountType est appelé par la classe Account.
Classe Account.java
@Entity@Inheritance(strategy=InheritanceType.JOINED)
public class Account {
private Long id;
private Integer version;
private boolean enabled;
private String label;
private String numero;
private AccountType type;
//-------------
@Enumerated(EnumType.STRING)
public AccountType getType() {
return type;
}
public void setType(AccountType type) {
this.type = type;
}
Quelques explications sur les annotations Hibernate :
@Entity : Cette dernière est persistante et donc associée à une table dans la base de données.
@Inheritance(strategy=InheritanceType.JOINED) : La stratégie de mapping est de type “Joined”. Il y a une table et une jointure par table. Ainsi les informations sont répartis sur plusieurs tables. La seule colonne commune entre les tables est la colonne ID qui permet de faire les jointures table mère et table fille.
Puis, la classe AccountViews.java (javaBean) fait appelle à l’attribut account pour récupérer le type enregistré dans la bdd.
public class AccountView {
private Account account;
//---------
public String getTypeStr(){
if(account.getType()!=null){
return account.getType().toString();
}else{
return null;
}
}
public void setTypeStr(String type) {
if(type!=null && type.length()>0){
account.setType(AccountType.valueOf(type));
}
}C’est un moment important car si le type est modifié, c’est à ce moment que account change de type.
Exemple : l’utilisateur souhaite modifier la liste déroulante et passer d’un type tva à un type analytique.
L’enregistrement du changement de l’élément de la liste déroulante s’effectue grâce à la méthode doSave() de la classe AccountListAction.java
@End public String doSave(){
try {
accountService.Save(account.getAccount());
sessionMap.put("saveok","ok");
} catch (ServiceException e) {
sessionMap.put("savenok","nok");
e.printStackTrace();
}
return "save";
}@End est une annotation Hibernate pour la démarcation de contexte. Cela spécifie qu’une conversation longue s’achève.
La méthode save() permet la persistance d’une nouvelle occurrence.
La liste peut-être éditée correctement, grâce à la méthode doEdit() dans la classe AccountListAction.java
public class AccountListAction {private String id;
private Map<String,String> types;
@Begin
public String doEdit(){
//------
this.types = new HashMap<String,String>();
AccountType[] acc = AccountType.values();
for (int i = 0; i < acc.length; i++)
{
AccountType b = acc[i];
types.put(b.toString(),getText("account.type."+b.toString()));
}
if(id!=null){
account = new AccountView(accountService.find(Long.valueOf(id)));
}else{
account = new AccountView();
}
} catch (ServiceException e) {
e.printStackTrace();
}
return "edit";
}
@Begin est une annotation Hibernate pour la démarcation de contexte. Cela spécifie qu’une conversation longue démarre.
La première partie de la méthode permet de lister tous les éléments de la liste déroulante. Le getText(« account.type. »+b.toString() fait référence aux éléments du fichier de properties.
La seconde partie permet de remplir l’objet account grâce à l’id du compte :
id : 1
Libellé du compte : Compte 1
N° de compte : CompteHt
Type : vente
Enfin, la dernière étape est l’intégration de la liste déroulante dans la JSP.
edit.jsp
<s:select list="types"name="account.typeStr"
value="%{account.typeStr}"
listKey="key"
listValue="value"
key="account.type">
</s:select>
Les tags Struts sont précédés par <s:…>
Pour prendre en compte ce type de balise : (déclaration au début du fichier jsp).
<%@ taglib prefix= »s » uri= »/struts-tags »%>
Dans le select :
La list est le nom de la liste déroulante qui est appelée.
Le name permet de remplir la liste lors de l’enregistrement de la page.
La value permet de remplir la liste lors du chargement de la page.
La key représente le nom du label appelé dans un fichier de properties
global-messages.properties
account.type = Type
Résultat :
Cet exemple permet de mettre en lumière le fonctionnement et l’architecture du framework Struts2 par le biais d’une liste déroulante.
