Comment remplacer un espace réservé dans une chaîne avec un modèle SimpleDateFormat

Dans une Chaîne comme ceci

".../uploads/${customer}/${dateTime('yyyyMMdd')}/report.pdf"

J'ai besoin de remplacer un customer et un yyyyMMdd timestamp.

Pour remplacer le customer espace réservé, je pourrais utiliser le StrSubstitutor de Apache Commons. Mais comment remplacer le SimpleDateFormat? Nous sommes en cours d'exécution, au Printemps de enviourment, alors peut-être Spring EL est une option?

Le balisage pour les espaces réservés n'est pas fixe, c'est ok, si une autre bibliothèque de syntaxe change.

Ce petit tests montre le problème:

SimpleDateFormat            formatter   = new SimpleDateFormat("yyyyMMdd");

String                      template    = ".../uploads/${customer}/${dateTime('yyyyMMdd')}/report.pdf";

@Test
public void shouldResolvePlaceholder()
{
    final Map<String, String> model = new HashMap<String, String>();
    model.put("customer", "Mr. Foobar");

    final String filledTemplate = StrSubstitutor.replace(this.template, model);

    assertEquals(".../uploads/Mr. Foobar/" + this.formatter.format(new Date()) + "/report.pdf", filledTemplate);
}

source d'informationauteur d0x

  1. 26

    Pourquoi n'utilisez-vous pas MessageFormat à la place?

    String result = MessageFormat.format(".../uploads/{0}/{1,date,yyyyMMdd}/report.pdf", customer, date);

    Ou avec String.format

    String result = String.format(".../uploads/%1$s/%2$tY%2$tm%2$td/report.pdf", customer, date);
  2. 9

    Comme NilsH suggéré MessageFormat est vraiment agréable pour cette fin. D'avoir nommé les variables que vous pouvez masquer MessageFormat derrière votre classe:

    public class FormattedStrSubstitutor {
    public static String formatReplace(Object source, Map<String, String> valueMap) {
        for (Map.Entry<String, String> entry : valueMap.entrySet()) {   
            String val = entry.getValue();
            if (isPlaceholder(val)) {
                val = getPlaceholderValue(val);
                String newValue = reformat(val);

                entry.setValue(newValue);
            }
        }

        return new StrSubstitutor(valueMap).replace(source);
    }

    private static boolean isPlaceholder(String isPlaceholder) {
        return isPlaceholder.startsWith("${");
    }

    private static String getPlaceholderValue(String val) {
        return val.substring(2, val.length()-1);
    }

    private static String reformat(String format) {
        String result = MessageFormat.format("{0,date," + format + "}", new Date());

        return result;
    }
}

    Et vous devez ajuster votre cas de test:

    SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd");

String template = ".../uploads/${customer}/${dateTime}/report.pdf";

@Test
public void shouldResolvePlaceholder() {
    final Map<String, String> model = new HashMap<String, String>();
    model.put("customer", "Mr. Foobar");
    model.put("dateTime", "${yyyyMMdd}");

    final String filledTemplate = FormattedStrSubstitutor.formatReplace(this.template,
        model);

    assertEquals(".../uploads/Mr. Foobar/" + this.formatter.format(new Date())
        + "/report.pdf", filledTemplate);
}

    J'ai enlevé les génériques et les remplacer par celles de la Chaîne. Aussi isPlaceholder et getPlaceholderValue est codé en dur et attendre ${valeur} syntaxe.

    Mais c'est juste l'idée pour résoudre votre problème. Pour ce faire pouvez utiliser les méthodes de StrSubstitutor (utilisez est ou faire FormattedStrSubstitutor extends StrSubstitutor).

    Aussi, vous pouvez utiliser par exemple $d{valeur} pour le formatage de la date et de $foo{valeur} pour les foo mise en forme.

    Mise à JOUR

    Ne pouvait pas dormir sans solution complète. Vous pouvez ajouter cette méthode pour FormattedStrSubstitutor classe:

    public static String replace(Object source,
        Map<String, String> valueMap) {

    String staticResolved = new StrSubstitutor(valueMap).replace(source);

    Pattern p = Pattern.compile("(\$\\{date)(.*?)(\\})");
    Matcher m = p.matcher(staticResolved);

    String dynamicResolved = staticResolved;
    while (m.find()) {
        String result = MessageFormat.format("{0,date" + m.group(2) + "}",
                new Date());

        dynamicResolved = dynamicResolved.replace(m.group(), result);
    }

    return dynamicResolved;
}

    Votre cas de test, c'est comme dans votre question (de petits changements dans l'espace réservé):

    SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd");

String template = ".../uploads/${customer}/${date,yyyyMMdd}/report.pdf";

@Test
public void shouldResolvePlaceholder() {
    final Map<String, String> model = new HashMap<String, String>();
    model.put("customer", "Mr. Foobar");

    final String filledTemplate =  FormattedStrSubstitutor.replace(this.template,
            model);

    assertEquals(
            ".../uploads/Mr. Foobar/" + this.formatter.format(new Date())
                    + "/report.pdf", filledTemplate);
}

    Même limite comme avant; pas de génériques et de fixer le préfixe et le suffixe de l'espace réservé.

  3. 0

    Semble que c'est aussi simple que cela?

    static final Pattern DOLLARS = Pattern.compile("\$\\{([^}]+)}");

public static String resolve(String string, Map<String,String> config) {
    StringBuilder builder = new StringBuilder();
    Matcher matcher = DOLLARS.matcher(string);
    int start = 0;
    while (matcher.find(start)) {
        builder.append(string.substring(start, matcher.start()));
        String property = matcher.group(1);
        String value = config.get(property);
        builder.append(value);
        start = matcher.end();
    }
    builder.append(string.substring(start));
    return builder.toString();
}