J'essaie d'analyser les dates en utilisant La raison derrière le Le Je pourrais quitter le code tel qu'il est, mais vide Je pourrais mettre les suivants dans le bloc code> code> bloc: p> mais à nouveau, le code à l'intérieur Servie aucun but comme no est là un moyen d'éviter le "code> inutile" / code> bloc? Pourrait Questions similaires (mais pas tout à fait): p> Éviter une clause de capture vide P> Est-ce qu'il est toujours correct d'avoir une déclaration de capture vide? p> p> SimpleDateDeformat code>. Comme mon service prend plusieurs formats de date, j'ai adopté Ceci < / a> Approche:
try-attrape code> est que si le format de date actuel ne pouvait pas analyser la
datring code> , une exception code> code> serait lancée et le code continuerait de boucler jusqu'à ce qu'un format de date approprié soit trouvé ou de retourner
null code>. p>
CODE> Le bloc est simplement là-bas afin que le bloc
ESSAYER code> aurait quelque chose après cela (une erreur de compilation pourrait se produire si rien ne suit
Essayez code>). P>
attrape code> Les blocs sont mauvaises. Il serait également déroutant pour les autres personnes de maintenir à l'avenir. Et c'est tout simplement inélégant. P>
d'une exception code> autre qu'un
parseexception code> pourrait être lancé par le bloc code> Essayez code> bloquer (i Rechercher pour
nullpointeException code> plus tôt dans le code). Utilisation d'un bloc code> final code> au lieu d'un bloc code> bloc code> serait inutile aussi. P>
try-attraper code> être complètement évité complètement? P>
7 Réponses :
vous peut em> faire cela. Mais à mon avis (qui est partagé par un grand nombre d'autres développeurs de logiciels professionnels), des blocs de capture vides sont un anti-motif. Vous avez rencontré un cas exceptionnel em> dans votre code; Pourquoi l'ignorer? Cela signifie que vous avez une entrée incorrecte / inutilisable. Qui mérite une attention em>, n'est-ce pas d'accord? P>
Alors, Enfin, si vous voulez omettre purement le bloc-catch ... Eh bien, vous ne pouvez pas aller de côté ignorer em> l'exception. Vous pouvez inclure une exception une déclaration code> sur votre prototype de méthode. Mais même alors, quiconque utilise votre API devra l'attraper. C'est juste une partie de la façon dont les exceptions vérifiées fonctionnent en Java. P>
Ma question est de demander comment éviter cela, ne pas demander si c'est bon ou non.
@Photometricstereo Vérifiez le dernier paragraphe de ma réponse. Vous pouvez éviter d'écrire un Catch CODE> -BLOCK dans votre code, au coût de l'attente de quelqu'un d'autre pour l'attraper. C'est le seul moyen. Il fait partie des spécifications de Dateformat pour lancer une exception vérifiée (ParseException, spécifique) si la chaîne est imparable. Les spécifications de langue empêchent de les ignorer tout à fait.
Vous ne pouvez pas omettre un bloc de capture. Un essai doit être suivi d'au moins un attrape code> ou un
final code>.
@Photométométricstereo qui est vrai. J'aurais dû être un peu plus verbeux, peut-être. Quand je dis que vous pouvez omettre la prise, je veux dire que vous omettez entièrement toute la structure d'essais.
Votre code va bien. Il est intentionnel et raisonnable dans ce cas de ne prendre aucune mesure lorsque le SimpleDateDeformat code> jette un
parseexception code>. La seule chose que je ferais différemment est d'insérer un commentaire documentaire à cet effet:
for (String format : formats)
{
try
{
return new SimpleDateFormat(format).parse(dateString);
}
catch (ParseException e) {
// The string does not conform to the trial format.
// Just try the next format, if any.
}
}
Si vous voulez éviter le bloc Essayer / Catch, il est possible, mais cela augmente certainement la taille du code. Le plus gros problème que j'ai avec des blocs de capture vides non moqués est qu'ils laissent la question de "je voulais dire //do: vérifier les exceptions ou non?" L'odeur de code que s'applique vraiment, imo, s'il n'a aucun sens de le faire de cette façon, c'est-à-dire si vous analysez de voir si quelque chose est un nombre, plutôt que d'utiliser une méthode ISnumber.
Vous pouvez créer une méthode explicite conçue. Pour vérifier si cela peut être analysé, puis renvoyer la valeur si elle est analyable. p> puis appliquer p> for (String format : formats)
{
SimpleDateFormat format = new SimpleDateFormat(format);
if(isParseable(dateString, format))
return format.parse(dateString);
}
return null;
Vous pouvez avoir isparsible code> (ou équivalent) renvoyer un
en option
Vous dites que vous n'aimez pas l'interface fournie par SimpleDateFormat code>. Votre seul choix consiste à envelopper cette interface dans une autre qui fournit l'interface que vous recherchez. E.g.,
Lorsque vous êtes en train de formater une date en essayant un format après un autre, c'est raisonnable que vous aurez un tas d'exceptions, propagez-leur serait inutile, même les voir même, n'est pas utile la plupart du temps. Le seul changement que je ferais consisterait à enregistrer l'exception au niveau de débogage ou de trace (défini ci-dessous où vous auriez votre journalisation normale lors de l'exécution du code dans le développement), donc au cas où vous souhaitiez revenir et examiner ce qui allait revenir sur vous devrez seulement changer la configuration de la journalisation.
Toutes les réponses données jusqu'à présent, disons que vous devez vivre avec une exception capturée, mais SimpleDateDeformat Code> -api et un avec l'utilisation de ma bibliothèque TIME4J .
SimpleDateFormat H2>
private static final MultiFormatParser<Moment> MULTI_FORMAT_PARSER;
static {
String[] formats =
{
"yyyy-MM-dd'T'HH:mm:ss.SSSX",
"yyyy-MM-dd'T'HH:mm:ss.SSS-HH:mm",
"EEE MMM dd HH:mm:ss Z yyyy"
};
List<ChronoFormatter<Moment>> formatters =
Arrays.stream(formats)
.map(pattern ->
ChronoFormatter.ofMomentPattern(
pattern,
PatternType.CLDR,
Locale.ENGLISH,
Timezone.ofSystem().getID()))
.collect(Collectors.toList());
MULTI_FORMAT_PARSER = MultiFormatParser.of(formatters);
}
public static java.util.Date parse(String input) {
ParseLog plog = new ParseLog();
Moment m = MULTI_FORMAT_PARSER.parse(input, plog);
if (plog.isError()) {
// log an error message based on plog.getErrorMessage()
return null; // or throw an exception
} else {
return TemporalType.JAVA_UTIL_DATE.from(m); // converted to old API
}
}
Merci pour la réponse, je vais explorer les méthodes que vous avez mentionnées. En outre, je vais changer mes formats de date. Je dois avoir le 'z' code> dans un parce que je reçois parfois ce type de date:
2016-07-15t08: 32: 53.689Z code>.
@Photométricstereo the iso-text "2016-07-15t08: 32: 53.689Z" signifie vraiment "2016-07-15t08: 32: 53.689 + 00: 00" (zéro décalage de UTC). Par conséquent, vous devez définir Timezone.gettimeZone ("GMT") CODE> sur votre
SimpleDateDeformat CODE> Pour ce cas et ne s'appuie pas sur votre fuseau horaire système (qui correspond à la valeur par défaut).
@Photométométricstereo Si vous souhaitez utiliser SimpleDateDormat CODE> et êtes sur Java-7, vous pouvez également utiliser le symbole de motif "x" qui peut interpréter correctement le "Z" littéral.
J'utiliserais quelque chose comme org.apache.commons.lang3.time.datetutils.ParseDate (ou parseDateStrictement si vous devez correspondre à l'ensemble du modèle). Il faut une liste de modèles possibles. Jetez un coup d'œil à cet exemple:
Date d = DateUtils.parseDate("23/10/2014T12:34:22", new String[] {"yyyy/MM/dd'T'HH:mm:ss", "dd/MM/yyyy'T'HH:mm:ss"}); System.out.println(d);
"Aucun but comme aucune exception, une impression d'une parseexception pourrait être lancée par le bloc d'essai" Il pourrait y avoir un
nullpointexception code>, en fonction de l'endroit où
daturling "/ code> vient.
Désolé, je n'ai pas inclus cela dans mon code, mais il y a un chèque de pointeur nul avant cela.
Votre commentaire selon lequel "le bloc de capture est simplement là-bas, alors le bloc d'essai aurait quelque chose après" semble en arrière. Si vous ne vouliez pas non plus un
attraper code> ou un
enfin code>, vous ne devez pas nécessiter ou vouloir un
essayer code>, non plus. Pour autant que je puisse déterminer, le bloc code> code> est là pour la raison habituelle: vous voulez attraper (certaines) exceptions.
"Je pourrais placer ce qui suit dans le bloc de capture:" Ne pas sur-attraper des exceptions: tout ce que vous devez gérer est
parseexception code>. Ensuite, si un
RunTimeException code> est lancé, qui sera propagé; et le compilateur garantit qu'aucune exception vérifiée sauf
parseexception code> est lancée. Donc, c'est juste un moyen compliqué d'obtenir fondamentalement le même comportement.
Je vois. J'avais à l'origine un enregistreur dans le bloc de capture et je pensais peut-être que je pourrais peut-être vous débarrasser de tout ce qui ne faisait aucune exception qui a été jetée nulle part. Je vais juste garder un enregistreur là-bas.