Comment faire pour remplir les options de h:selectOneMenu à partir de la base de données?

Basé sur votre question de l'histoire, vous êtes en utilisant JSF 2.x. Donc, voici de la JSF 2.x la réponse ciblée. Dans JSF 1.x vous seriez forcé d'envelopper les valeurs/les étiquettes dans laide SelectItem instances. Ce n'est heureusement pas besoin de plus de JSF 2.x.

---

Exemple de base

Pour répondre directement à votre question, il suffit d'utiliser <f:selectItems> dont value points pour un List<T> propriété qui vous préserver de la DB au cours de l'haricot (post)de la construction. Voici une base de lancement pour exemple en supposant que T représente en fait une String.

<h:selectOneMenu value="#{bean.name}">
    <f:selectItems value="#{bean.names}" />
</h:selectOneMenu>

avec

@ManagedBean
@RequestScoped
public class Bean {

    private String name;
    private List<String> names; 

    @EJB
    private NameService nameService;

    @PostConstruct
    public void init() {
        names = nameService.list();
    }

    //... (getters, setters, etc)
}

Simple que cela. En fait, la T's toString() sera utilisé pour représenter à la fois la liste déroulante de l'élément de l'étiquette et la valeur. Donc, quand vous êtes au lieu de List<String> à l'aide d'une liste d'objets complexes comme List<SomeEntity> et vous n'avez pas remplacé la classe' toString() méthode, puis com.example.SomeEntity@hashcode comme élément de valeurs. Voir la section suivante comment le résoudre correctement.

Également noter que le haricot pour <f:selectItems> valeur ne doit pas nécessairement être la même bean le bean pour <h:selectOneMenu> valeur. Ceci est utile chaque fois que les valeurs sont en fait applicationwide constantes qui vous avez juste à charger qu'une seule fois au démarrage de l'application. Vous pouvez ensuite il suffit de faire une propriété d'une application étendue de haricot.

<h:selectOneMenu value="#{bean.name}">
    <f:selectItems value="#{data.names}" />
</h:selectOneMenu>

---

Des objets complexes comme des éléments disponibles

Chaque fois que T concerne un objet complexe (javabean), comme User qui a un String propriété de name, alors vous pouvez utiliser les var attribut de s'emparer de la variable d'itération qui vous peut utiliser dans itemValue et/ou itemLabel attribtues (si vous omettez le itemLabel, l'étiquette devient la même que la valeur).

Exemple #1:

<h:selectOneMenu value="#{bean.userName}">
    <f:selectItems value="#{bean.users}" var="user" itemValue="#{user.name}" />
</h:selectOneMenu>

avec

private String userName;
private List<User> users;

@EJB
private UserService userService;

@PostConstruct
public void init() {
    users = userService.list();
}

//... (getters, setters, etc)

Ou quand il a un Long propriété id qui vous préférez définir comme la valeur de l'article:

Exemple #2:

<h:selectOneMenu value="#{bean.userId}">
    <f:selectItems value="#{bean.users}" var="user" itemValue="#{user.id}" itemLabel="#{user.name}" />
</h:selectOneMenu>

avec

private Long userId;
private List<User> users;

//... (the same as in previous bean example)

---

Objet complexe comme élément sélectionné

Chaque fois que vous souhaitez définir une T propriété du bean ainsi et T représente un User, alors vous devez faire cuire une coutume Convertisseur qui convertit entre User et une unique représentation de chaîne (qui peut être l' id de la propriété). Notez que le itemValue doit représenter l'objet complexe en lui-même, exactement le type qui doit être définie comme la sélection du composant value.

<h:selectOneMenu value="#{bean.user}" converter="#{userConverter}">
    <f:selectItems value="#{bean.users}" var="user" itemValue="#{user}" itemLabel="#{user.name}" />
</h:selectOneMenu>

avec

private User user;
private List<User> users;

//... (the same as in previous bean example)

et

@ManagedBean
@RequestScoped
public class UserConverter implements Converter {

    @EJB
    private UserService userService;

    @Override
    public Object getAsObject(FacesContext context, UIComponent component, String submittedValue) {
        if (submittedValue == null || submittedValue.isEmpty()) {
            return null;
        }

        try {
            return userService.find(Long.valueOf(submittedValue));
        } catch (NumberFormatException e) {
            throw new ConverterException(new FacesMessage(String.format("%s is not a valid User ID", submittedValue)), e);
        }
    }

    @Override
    public String getAsString(FacesContext context, UIComponent component, Object modelValue) {
        if (modelValue == null) {
            return "";
        }

        if (modelValue instanceof User) {
            return String.valueOf(((User) modelValue).getId());
        } else {
            throw new ConverterException(new FacesMessage(String.format("%s is not a valid User", modelValue)), e);
        }
    }

}

(veuillez noter que le Converter est un peu hacky afin d'être en mesure d'injecter un @EJB dans un JSF convertisseur; normalement, on aurait annoté comme @FacesConverter(forClass=User.class), mais qui, malheureusement, ne permet pas de @EJB injections)

N'oubliez pas de assurez-vous que l'objet complexe de classe a equals() et hashCode() correctement mis en œuvre, sinon JSF sera pendant le rendu ne parviennent pas à montrer élément présélectionné(s), et vous aurez à soumettre visage Erreur de Validation: la Valeur n'est pas valide.

public class User {

    private Long id;

    @Override
    public boolean equals(Object other) {
        return (other != null && getClass() == other.getClass() && id != null)
            ? id.equals(((User) other).id)
            : (other == this);
    }

    @Override
    public int hashCode() {
        return (id != null) 
            ? (getClass().hashCode() + id.hashCode())
            : super.hashCode();
    }

}

---

Des objets complexes avec un convertisseur générique

Tête de cette réponse: Mettre en œuvre des convertisseurs pour les entités avec Java Génériques.

---

Objets complexes sans un convertisseur personnalisé

La JSF bibliothèque utilitaire OmniFaces propose un convertisseur spécial sorti de la boîte qui vous permet d'utiliser des objets complexes dans <h:selectOneMenu> sans la nécessité de créer un convertisseur personnalisé. Le SelectItemsConverter va simplement faire la conversion, basé sur les articles facilement accessibles dans <f:selectItem(s)>.

<h:selectOneMenu value="#{bean.user}" converter="omnifaces.SelectItemsConverter">
    <f:selectItems value="#{bean.users}" var="user" itemValue="#{user}" itemLabel="#{user.name}" />
</h:selectOneMenu>

---

Voir aussi:

• Notre <h:selectOneMenu> de la page wiki

Rouler convertisseur générique pour des objets complexes comme élément sélectionné

La Balusc donne un très bon aperçu de réponse sur ce sujet. Mais il y a une alternative qu'il n'est pas présent: Le Roll-votre-propre convertisseur générique qui gère des objets complexes comme l'élément sélectionné. C'est très complexe à faire si vous voulez traiter l'ensemble des cas, mais assez simple pour les cas simples.

Le code ci-dessous contient un exemple de ce type de convertisseur. Il travaille dans le même esprit que la OmniFaces SelectItemsConverter qu'il regarde à travers les enfants, d'un composant pour UISelectItem(s) contenant des objets. La différence, c'est qu'il ne s'occupe que des liaisons simples collections d'objets de l'entité, ou les cordes. Il ne gère pas les groupes de produits, des collections de SelectItems, des ensembles et probablement beaucoup d'autres choses.

Les entités que le composant se lie à doit mettre en œuvre les IdObject interface. (Cela pourrait être résolu d'une autre manière, comme l'utilisation de toString.)

Noter que les entités déclarantes sont tenues de mettre en œuvre equals de telle manière que les deux entités, avec le même ID compare l'égalité.

La seule chose que vous devez faire pour l'utiliser, il est à spécifier que c'est le convertisseur sur l'sélectionner un composant, se lier à une entité de propriété et la liste des entités:

<h:selectOneMenu value="#{bean.user}" converter="selectListConverter">
  <f:selectItem itemValue="unselected" itemLabel="Select user..."/>
  <f:selectItem itemValue="empty" itemLabel="No user"/>
  <f:selectItems value="#{bean.users}" var="user" itemValue="#{user}" itemLabel="#{user.name}" />
</h:selectOneMenu>

Converter:

/**
* A converter for select components (those that have select items as children).
* 
* It convertes the selected value string into one of its element entities, thus allowing
* binding to complex objects.
* 
* It only handles simple uses of select components, in which the value is a simple list of
* entities. No ItemGroups, arrays or other kinds of values.
* 
* Items it binds to can be strings or implementations of the {@link IdObject} interface.
*/
@FacesConverter("selectListConverter")
public class SelectListConverter implements Converter {
public static interface IdObject {
public String getDisplayId();
}
@Override
public Object getAsObject(FacesContext context, UIComponent component, String value) {
if (value == null || value.isEmpty()) {
return null;
}
return component.getChildren().stream()
.flatMap(child -> getEntriesOfItem(child))
.filter(o -> value.equals(o instanceof IdObject ? ((IdObject) o).getDisplayId() : o))
.findAny().orElse(null);
}
/**
* Gets the values stored in a {@link UISelectItem} or a {@link UISelectItems}.
* For other components returns an empty stream.
*/
private Stream<?> getEntriesOfItem(UIComponent child) {
if (child instanceof UISelectItem) {
UISelectItem item = (UISelectItem) child;
if (!item.isNoSelectionOption()) {
return Stream.of(item.getValue());
}
} else if (child instanceof UISelectItems) {
Object value = ((UISelectItems) child).getValue();
if (value instanceof Collection) {
return ((Collection<?>) value).stream();
} else {
throw new IllegalStateException("Unsupported value of UISelectItems: " + value);
}
}
return Stream.empty();
}
@Override
public String getAsString(FacesContext context, UIComponent component, Object value) {
if (value == null) return null;
if (value instanceof String) return (String) value;
if (value instanceof IdObject) return ((IdObject) value).getDisplayId();
throw new IllegalArgumentException("Unexpected value type");
}
}

Appelez-moi paresseux, mais le codage d'un Convertisseur ressemble à beaucoup de travail inutile. Je suis l'aide de Primefaces et, n'ayant pas utilisé une plaine de vanille JSF2 zone de liste ou un menu déroulant avant, j'ai simplement supposé (paresseuse) que le widget pourrait manipuler des objets complexes, c'est à dire passer de l'objet sélectionné comme correspondant à son getter/setter, comme beaucoup d'autres widgets faire. J'ai été déçu de trouver (après des heures de casse-tête) que cette fonctionnalité n'existe pas pour ce type de widget sans Convertisseur. En fait, si vous fournissez un setter pour l'objet complexe plutôt que pour une Chaîne de caractères, il échoue silencieusement (il suffit de ne pas appeler le setter, pas d'Exception, pas d'erreur JS), et j'ai passé une tonne de temps va par le biais de BalusC excellent outil de dépannage pour trouver la cause, en vain, puisque aucune de ces suggestions appliquées. Ma conclusion: la zone de liste/menu widget besoins d'adaptation que d'autres JSF2 widgets ne le font pas. Cela semble induire en erreur et sujettes à la pointe du mal informés développeur comme moi, en bas d'un trou de lapin.

À la fin, j'ai résisté, le codage d'un Convertisseur et trouvé par essais et erreurs que si vous définissez la valeur d'un widget à un objet complexe, par exemple:

<p:selectOneListbox id="adminEvents" value="#{testBean.selectedEvent}">

... lorsque l'utilisateur sélectionne un élément, le widget peut appeler une Chaîne de définition pour cet objet, par exemple setSelectedThing(String thingString) {...}, et la Chaîne de caractères passée est une Chaîne JSON représentant la Chose objet. Je peux l'analyser pour déterminer quel objet a été sélectionné. Cela se sent un peu comme un hack, mais moins d'un hack qu'un Convertisseur.