如何根据当前用户区域设置对Wicket下拉列表中的选项进行排序?

时间:2012-05-22 09:26:42

标签: localization wicket

我有以下问题:

  • 带有元素列表的下拉列表
  • 这些元素中的每一个都有一个固定的密钥,IChoiceRenderer实现使用它来查找密钥的本地化版本(它是在不同包中实现的标准实用程序渲染器)。
  • 本地化密钥列表位于属性文件中,链接到实例化下拉列表的面板。

是否有优雅/可重复使用的解决方案让下拉列表按字母顺序显示其元素?

5 个答案:

答案 0 :(得分:2)

最后,我认为使用渲染可能是最好的方法。为了使其可重用和高效,我在行为中将其隔离。

以下是代码:

import org.apache.wicket.Component;
import org.apache.wicket.behavior.Behavior;
import org.apache.wicket.markup.html.form.AbstractChoice;
import org.apache.wicket.markup.html.form.IChoiceRenderer;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

import static java.util.Arrays.sort;

/**
 * This {@link Behavior} can only be used on {@link AbstractChoice} subclasses. It will sort the choices
 * according to their "natural display order" (i.e. the natural order of the display values of the choices).
 * This assumes that the display value implements {@link Comparable}. If this is not the case, you should
 * provide a comparator for the display value. An instance of this class <em>cannot be shared</em> between components.
 * Because the rendering can be costly, the sort-computation is done only once, by default,
 * unless you set to <code>false</code> the <code>sortOnlyOnce</code> argument in the constructor.
 *
 * @author donckels (created on 2012-06-07)
 */
@SuppressWarnings({"unchecked"})
public class OrderedChoiceBehavior extends Behavior {

    // ----- instance fields -----

    private Comparator displayValueComparator;
    private boolean sortOnlyOnce = true;
    private boolean sorted;

    // ----- constructors -----

    public OrderedChoiceBehavior() {
    }

    public OrderedChoiceBehavior(boolean sortOnlyOnce) {
        this.sortOnlyOnce = sortOnlyOnce;
    }

    public OrderedChoiceBehavior(boolean sortOnlyOnce, Comparator displayValueComparator) {
        this.sortOnlyOnce = sortOnlyOnce;
        this.displayValueComparator = displayValueComparator;
    }

    // ----- public methods -----

    @Override
    public void beforeRender(Component component) {
        if (this.sorted && this.sortOnlyOnce) { return;}
        AbstractChoice owner = (AbstractChoice) component;
        IChoiceRenderer choiceRenderer = owner.getChoiceRenderer();
        List choices = owner.getChoices();

        // Temporary data structure: store the actual rendered value with its initial index
        Object[][] displayValuesWithIndex = new Object[choices.size()][2];
        for (int i = 0, valuesSize = choices.size(); i < valuesSize; i++) {
            Object value = choices.get(i);
            displayValuesWithIndex[i][0] = choiceRenderer.getDisplayValue(value);
            displayValuesWithIndex[i][1] = i;
        }

        sort(displayValuesWithIndex, new DisplayValueWithIndexComparator());
        List valuesCopy = new ArrayList(choices);
        for (int i = 0, length = displayValuesWithIndex.length; i < length; i++) {
            Object[] displayValueWithIndex = displayValuesWithIndex[i];
            int originalIndex = (Integer) displayValueWithIndex[1];
            choices.set(i, valuesCopy.get(originalIndex));
        }
        this.sorted = true;
    }

    public Comparator getDisplayValueComparator() {
        return this.displayValueComparator;
    }

    // ----- inner classes -----

    private class DisplayValueWithIndexComparator implements Comparator<Object[]> {

        // ----- Comparator -----

        public int compare(Object[] left, Object[] right) {
            Object leftDisplayValue = left[0];
            Object rightDisplayValue = right[0];
            if (null == leftDisplayValue) { return -1;}
            if (null == rightDisplayValue) { return 1;}

            if (null == getDisplayValueComparator()) {
                return ((Comparable) leftDisplayValue).compareTo(rightDisplayValue);
            } else {
                return getDisplayValueComparator().compare(leftDisplayValue, rightDisplayValue);
            }
        }
    }
}

答案 1 :(得分:1)

如果您想要一个基于Wicket的解决方案,您可以尝试使用类似的方式对列表进行排序:

public class ChoiceRendererComparator<T> implements Comparator<T> {

    private final IChoiceRenderer<T> renderer;

    public ChoiceRendererComparator(IChoiceRenderer<T> renderer) {
        this.renderer = renderer;
    }

    @SuppressWarnings("unchecked")
    public int compare(T o1, T o2) {
        return ((Comparable<Object>) renderer.getDisplayValue(o1)).compareTo(renderer.getDisplayValue(o2));
    }
}

用法:

    List<Entity> list = ...
    IChoiceRenderer<Entity> renderer = ...
    Collections.sort(list, new ChoiceRendererComparator<Entity>(renderer));
    DropDownChoice<Entity> dropdown = new DropDownChoice<Entity>("dropdown", list, renderer);

答案 2 :(得分:1)

使用Java的Collator使用DropDownChoice的这个扩展名(基本上是区域敏感的排序 - 考虑到国家字符和国家排序规则)

使用Wicket 6和Java 5 +进行代码测试:

import java.text.Collator;
import java.util.Comparator;
import java.util.List;
import java.util.Locale;

import org.apache.wicket.Session;
import org.apache.wicket.markup.html.form.DropDownChoice;
import org.apache.wicket.markup.html.form.IChoiceRenderer;
import org.apache.wicket.model.IModel;

import com.google.common.collect.Ordering;

/**
 * DropDownChoice which sort its choices (or in HTML's terminology select's options) according it's localized value
 * and using current locale based Collator so it's sorted how it should be in particular language (ie. including national characters, 
 * using right order).
 * 
 * @author Michal Bernhard michal@bernhard.cz 2013
 *
 * @param <T>
 */
public class OrderedDropDownChoice<T> extends DropDownChoice<T> {

    public OrderedDropDownChoice(String id, IModel<? extends List<? extends T>> choices, IChoiceRenderer<? super T> renderer) {
        super(id, choices, renderer);
    }

    public OrderedDropDownChoice(String id, IModel<? extends List<? extends T>> choices) {
        super(id, choices);
    }

    public OrderedDropDownChoice(String id) {
        super(id);
    }

    public OrderedDropDownChoice(
            String id,
            IModel<T> model,
            IModel<? extends List<? extends T>> choices,
                    IChoiceRenderer<? super T> renderer) {

        super(id, model, choices, renderer);
    }

    @Override
    public List<? extends T> getChoices() {
        List<? extends T> unsortedChoices = super.getChoices();
        List<? extends T> sortedChoices = Ordering.from(displayValueAlphabeticComparator()).sortedCopy(unsortedChoices);

        return sortedChoices;
    }

    private Collator localeBasedTertiaryCollator() {
        Locale currentLocale = Session.get().getLocale();
        Collator collator = Collator.getInstance(currentLocale);
        collator.setStrength(Collator.TERTIARY);

        return collator;
    }

    private Comparator<T> displayValueAlphabeticComparator() {

        final IChoiceRenderer<? super T> renderer = getChoiceRenderer();

        return new Comparator<T>() {

            @Override
            public int compare(T o1, T o2) {
                Object o1DisplayValue = renderer.getDisplayValue(o1);
                Object o2DisplayValue = renderer.getDisplayValue(o2);

                return localeBasedTertiaryCollator().compare(o1DisplayValue, o2DisplayValue);
            }
        };

    }


}

https://gist.github.com/michalbcz/7236242

复制

答案 3 :(得分:0)

我们在公司使用的解决方案是基于Javascript的,我们在要下排的下拉列表上设置了一个特殊的css类,并且有一些jQuery技巧可以进行排序。

答案 4 :(得分:0)

面对同样的问题,我将部分本地化数据从我的XML移动到数据库,实现了匹配的解析器,并能够使用本地化的字符串进行排序。 表设计和hibernate配置有点棘手,在此处描述:Hibernate @ElementCollection - Better solution needed

ResourceLoader是这样的:

public class DataBaseStringResourceLoader extends ComponentStringResourceLoader {

    private static final transient Logger logger = Logger
            .getLogger(DataBaseStringResourceLoader.class);

    @Inject
    private ISomeDAO someDao;
    @Inject
    private IOtherDao otherDao;
    @Inject
    private IThisDAO thisDao;
    @Inject
    private IThatDAO thatDao;

    @Override
    public String loadStringResource(Class<?> clazz, String key, Locale locale,
            String style, String variation) {
        String resource = loadFromDB(key, new Locale(locale.getLanguage()));
        if (resource == null) {
            resource = super.loadStringResource(clazz, key, locale, style, variation);
        }
        return resource;
    }

    private String loadFromDB(String key, Locale locale) {
        String resource = null;
        if (locale.getLanguage() != Locale.GERMAN.getLanguage()
                && locale.getLanguage() != Locale.ENGLISH.getLanguage()) {
            locale = Locale.ENGLISH;
        }
        if (key.startsWith("some") || key.startsWith("other")
                || key.startsWith("this") || key.startsWith("that")) {
            Integer id = Integer.valueOf(key.substring(key.indexOf(".") + 1));
            ILocalizedObject master;
            if (key.startsWith("some")) {
                master = someDao.findById(id);
            } else if (key.startsWith("other")) {
                master = otherDao.findById(id);
            } else if (key.startsWith("this") ){
                master = thisDao.findById(id);
            } else {
                master = thatDao.findById(id);
            }
            if (master != null && master.getNames().get(locale) != null) {
                resource = master.getNames().get(locale).getName();
            } else if (master == null) {
                logger.debug("For key " + key + " there is no master.");
            }
        }
        return resource;
    }
[...]
    }