Comment valider une adresse mail?
Quelle est la bonne technique pour valider une adresse e-mail (par exemple, à partir d'un champ de saisie utilisateur) sous Android? org.Apache.commons.validator.routines.EmailValidator ne semble pas être disponible. Existe-t-il déjà d'autres bibliothèques faisant cela dans Android ou devrais-je utiliser RegExp?
Ne pas utiliser un reg-ex.
Apparemment, ce qui suit est un reg-ex qui valide correctement la plupart des adresses e-mail conformes à RFC 2822 , (et échouera toujours dans des domaines tels que "[email protected]", ainsi que dans org.Apache. commons.validator.routines.EmailValidator)
(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])
Peut-être le moyen le plus simple de valider un courrier électronique consiste-t-il simplement à envoyer un courrier électronique de confirmation à l'adresse fournie et qu'il rebondit, il n'est pas valide.
Si vous souhaitez effectuer des vérifications de base, vous pouvez simplement vérifier que cela se présente sous la forme *@*
Si vous avez une validation spécifique à la logique métier, vous pouvez l’effectuer à l’aide d’une expression régulière, par exemple. doit être un compte gmail.com ou quelque chose.
Une autre option est les modèles intégrés Patterns commençant par l’API Niveau 8:
public final static boolean isValidEmail(CharSequence target) {
if (TextUtils.isEmpty(target)) {
return false;
} else {
return Android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
}
}
OU
Solution à une ligne de @AdamvandenHoven:
public final static boolean isValidEmail(CharSequence target) {
return !TextUtils.isEmpty(target) && Android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
}
Le motif suivant est utilisé dans le courrier K-9:
public static final Pattern EMAIL_ADDRESS_PATTERN = Pattern.compile(
"[a-zA-Z0-9\\+\\.\\_\\%\\-\\+]{1,256}" +
"\\@" +
"[a-zA-Z0-9][a-zA-Z0-9\\-]{0,64}" +
"(" +
"\\." +
"[a-zA-Z0-9][a-zA-Z0-9\\-]{0,25}" +
")+"
);
Vous pouvez utiliser la fonction
private boolean checkEmail(String email) {
return EMAIL_ADDRESS_PATTERN.matcher(email).matches();
}
Depuis API 8 (Android 2.2), il existe un modèle: Android.util.Patterns.EMAIL_ADDRESS http://developer.Android.com/reference/Android/util/Patterns.html
Vous pouvez donc l'utiliser pour valider votre EmailString:
private boolean isValidEmail(String email) {
Pattern pattern = Patterns.EMAIL_ADDRESS;
return pattern.matcher(email).matches();
}
renvoie vrai si l'email est valide
UPD: Ce code source de motif est:
public static final Pattern EMAIL_ADDRESS
= Pattern.compile(
"[a-zA-Z0-9\\+\\.\\_\\%\\-\\+]{1,256}" +
"\\@" +
"[a-zA-Z0-9][a-zA-Z0-9\\-]{0,64}" +
"(" +
"\\." +
"[a-zA-Z0-9][a-zA-Z0-9\\-]{0,25}" +
")+"
);
Vous pouvez donc le construire vous-même pour assurer la compatibilité avec l'API <8.
Nous avons maintenant un modèle de correspondance simple
private static boolean isValidEmail(String email) {
return !TextUtils.isEmpty(email) && Android.util.Patterns.EMAIL_ADDRESS.matcher(email).matches();
}
Ce sont des suggestions Android Studio:
public static boolean isEmailValid(String email) {
return !(email == null || TextUtils.isEmpty(email)) && Android.util.Patterns.EMAIL_ADDRESS.matcher(email).matches();
}
utilisez Android: inputType = "textEmailAddress" comme ci-dessous:
<EditText
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:hint="email"
Android:inputType="textEmailAddress"
Android:id="@+id/email"
/>
et:
boolean isEmailValid(CharSequence email) {
return Android.util.Patterns.EMAIL_ADDRESS.matcher(email)
.matches();
}
Vous pouvez utiliser une expression régulière pour le faire. Quelque chose comme ce qui suit.
Pattern pattern = Pattern.compile(".+@.+\\.[a-z]+");
String email = "[email protected]";
Matcher matcher = pattern.matcher(email);
boolean matchFound = matcher.matches();
Remarque: vérifiez l'expression régulière indiquée ci-dessus, ne l'utilisez pas telle quelle.
Il existe une classe Patterns dans le package Android.util, ce qui est avantageux ici. Voici la méthode que j’utilise toujours pour valider les courriels et de nombreux autres éléments.
private boolean isEmailValid(String email) {
return !TextUtils.isEmpty(email) && Patterns.EMAIL_ADDRESS.matcher(email).matches();
}
Utiliser un simple code d'une ligne pour la validation par courrier électronique
public static boolean isValidEmail(CharSequence target) {
return !TextUtils.isEmpty(target) && Android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
}
utiliser comme ...
if (!isValidEmail(yourEdittext.getText().toString()) {
Toast.makeText(context, "your email is not valid", 2000).show();
}
Pour une validation de courrier électronique, Android, indiquez quelques InBuilt Pattern , mais il ne prend en charge que API de niveau 8 ou supérieur.
Voici le code pour utiliser ce modèle pour vérifier la validation du courrier électronique.
private boolean Email_Validate(String email)
{
return Android.util.Patterns.EMAIL_ADDRESS.matcher(email).matches();
}
Assurez-vous qu'après exécution de cette méthode, vous devez vérifier que si cette méthode renvoie true, vous autorisez l'enregistrement des e-mails. Si cette méthode renvoie false, le message affiché indique que cet e-mail est "invalide".
J'espère que vous aurez votre réponse, merci.
Vous pouvez écrire une extension Kotlin comme ceci:
fun String.isValidEmail() =
this.isNotEmpty() && Android.util.Patterns.EMAIL_ADDRESS.matcher(this).matches()
Et puis appelez ça comme ça:
email.isValidEmail()
Appelez cette méthode où vous souhaitez valider l'ID de messagerie.
public static boolean isValid(String email)
{
String expression = "^[\\w\\.-]+@([\\w\\-]+\\.)+[A-Z]{2,4}$";
CharSequence inputStr = email;
Pattern pattern = Pattern.compile(expression, Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(inputStr);
if (matcher.matches())
{
return true;
}
else{
return false;
}
}
Validez votre format d'adresse email. [email protected]
public boolean emailValidator(String email)
{
Pattern pattern;
Matcher matcher;
final String EMAIL_PATTERN = "^[_A-Za-z0-9-]+(\\.[_A-Za-z0-9-]+)*@[A-Za-z0-9]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$";
pattern = Pattern.compile(EMAIL_PATTERN);
matcher = pattern.matcher(email);
return matcher.matches();
}
public boolean isValidEmail(String email)
{
boolean isValidEmail = false;
String emailExpression = "^[\\w\\.-]+@([\\w\\-]+\\.)+[A-Z]{2,4}$";
CharSequence inputStr = email;
Pattern pattern = Pattern.compile(emailExpression, Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(inputStr);
if (matcher.matches())
{
isValidEmail = true;
}
return isValidEmail;
}
Puis-je fortement recommander que vous n'essayiez pas de "valider" les adresses e-mail, mais que vous vous engagiez dans beaucoup de travail sans raison valable.
Assurez-vous simplement que ce qui est entré ne cassera pas votre propre code - par exemple. pas d'espaces ou de caractères illégaux qui pourraient causer une exception.
Tout le reste vous demandera beaucoup de travail pour un rendement minimal ...
Voici Android.util.Patterns.EMAIL_ADDRESS
[a-zA-Z0-9 + ._ \% - +] {1,256}\@ [a-zA-Z0-9] [a-zA-Z0-9 -] {0,64} (. [a- zA-Z0-9] [a-zA-Z0-9 -] {0,25}) +
String y correspondra si
Start by 1->256 character in (a-z, A-Z, 0-9, +, ., _, %, - , +)
then 1 '@' character
then 1 character in (a-z, A-Z, 0-9)
then 0->64 character in (a-z, A-Z, 0-9, -)
then **ONE OR MORE**
1 '.' character
then 1 character in (a-z, A-Z, 0-9)
then 0->25 character in (a-z, A-Z, 0-9, -)
Exemple d'e-mail de correspondance spéciale
[email protected]
[email protected]
[email protected]
Vous pouvez modifier ce modèle pour votre cas puis valider par
fun isValidEmail(email: String): Boolean {
return Patterns.EMAIL_ADDRESS.matcher(email).matches()
}
Essayez cette méthode simple qui ne peut pas accepter l’adresse email commençant par les chiffres:
boolean checkEmailCorrect(String Email) {
if(signupEmail.length() == 0) {
return false;
}
String pttn = "^\\D.+@.+\\.[a-z]+";
Pattern p = Pattern.compile(pttn);
Matcher m = p.matcher(Email);
if(m.matches()) {
return true;
}
return false;
}
Si vous utilisez l'API 8 ou une version ultérieure, vous pouvez utiliser la classe Patterns facilement disponible pour valider un courrier électronique. Exemple de code:
public final static boolean isValidEmail(CharSequence target) {
if (target == null)
return false;
return Android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
}
Par chance, si vous prenez même en charge un niveau d'API inférieur à 8, vous pouvez simplement copier le fichier Patterns.Java dans votre projet et le référencer. Vous pouvez obtenir le code source pour Patterns.Java à partir de ce lien
La clé ici est que vous voulez valider complètement l'adresse email. Vous ne voulez pas simplement vérifier si la syntaxe est correcte, vous voulez vérifier si l'adresse e-mail est réelle.
Deux raisons évidentes: de vrais utilisateurs tapent souvent mal leurs adresses e-mail, et, certains utilisateurs peuvent créer de fausses adresses e-mail. Par conséquent, vous souhaitez effectuer un contrôle syntaxique et un contrôle d'existence.
Le meilleur moyen de faire cela que j'ai trouvé sur Android est d'utiliser gratuitement Cloudmersive Validation API pour cela.
Le code ressemble à ceci:
ApiClient defaultClient = Configuration.getDefaultApiClient();
// Configure API key authorization: Apikey
ApiKeyAuth Apikey = (ApiKeyAuth) defaultClient.getAuthentication("Apikey");
Apikey.setApiKey("YOUR API KEY");
EmailApi apiInstance = new EmailApi();
String email = "email_example"; // String | Email address to validate, e.g. \"[email protected]\". The input is a string so be sure to enclose it in double-quotes.
try {
FullEmailValidationResponse result = apiInstance.emailFullValidation(email);
System.out.println(result);
} catch (ApiException e) {
System.err.println("Exception when calling EmailApi#emailFullValidation");
e.printStackTrace();
}
Je l’utilise dans toutes mes applications et c’est génial, car je peux valider les adresses e-mail du UX au point de saisie.
Essayez ce code .. Ca marche vraiment ..
if (!email
.matches("^[\\w-_\\.+]*[\\w-_\\.]\\@([\\w]+\\.)+[\\w]+[\\w]$"))
{
Toast.makeText(getApplicationContext(), "Email is invalid",
Toast.LENGTH_LONG).show();
return;
}
La classe Linkify a quelques méthodes utiles utiles qui peuvent être pertinentes, notamment les expressions régulières conçues pour saisir les numéros de téléphone et les adresses électroniques, par exemple:
http://developer.Android.com/reference/Android/text/util/Linkify.html
Notez que la plupart des expressions régulières ne sont pas valides pour les noms de domaine internationaux (IDN) et les nouveaux domaines de premier niveau tels que .mobi ou .info (si vous recherchez des codes de pays ou .org, .com, .gov, etc.).
Une vérification valide doit séparer la partie locale (avant le signe at) et la partie de domaine. Vous devez également prendre en compte la longueur maximale de la partie locale et du domaine (en tout 255 caractères, y compris l'arobase).
La meilleure approche consiste à transformer l'adresse en un format compatible IDN (si nécessaire), à valider la partie locale (RFC), à vérifier la longueur de l'adresse et à vérifier la disponibilité du domaine (recherche DNS MX) ou simplement d'envoyer un courrier électronique. .
l'email est votre email-est.
public boolean validateEmail(String email) {
Pattern pattern;
Matcher matcher;
String EMAIL_PATTERN = "^[_A-Za-z0-9-]+(\\.[_A-Za-z0-9-]+)*@[A-Za-z0-9]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$";
pattern = Pattern.compile(EMAIL_PATTERN);
matcher = pattern.matcher(email);
return matcher.matches();
}
Je sais qu'il est trop tard, je vais quand même donner ma réponse.
J'ai utilisé cette ligne de code pour vérifier le format Email entré:
!TextUtils.isEmpty(getEmail) && Android.util.Patterns.EMAIL_ADDRESS.matcher(getEmail).matches();
Le problème est que seul le FORMAT sera vérifié, pas le SPELLING.
Lorsque j'ai entré @gmal.com manquant i et @yaho.com manquant un autre o . Il retourne true. Puisqu'il remplit la condition pour Email Format.
Ce que j'ai fait est que j'ai utilisé le code ci-dessus. Puisqu'il donnera/retournera true si Le si l'utilisateur a entré @gmail.comSEULEMENT, pas de texte au début.
CHECKER DE FORMAT
Si j'entre cet email, cela me donnera: true mais l'orthographe est fausse. Inmy textInputLayout error
ADRESSE COURRIEL @yahoo.com, @gmail.com, @Outlook.com CHEQUE
//CHECK EMAIL
public boolean checkEmailValidity(AppCompatEditText emailFormat){
String getEmail = emailFormat.getText().toString();
boolean getEnd;
//CHECK STARTING STRING IF THE USER
//entered @gmail.com / @yahoo.com / @Outlook.com only
boolean getResult = !TextUtils.isEmpty(getEmail) && Android.util.Patterns.EMAIL_ADDRESS.matcher(getEmail).matches();
//CHECK THE EMAIL EXTENSION IF IT ENDS CORRECTLY
if (getEmail.endsWith("@gmail.com") || getEmail.endsWith("@yahoo.com") || getEmail.endsWith("@Outlook.com")){
getEnd = true;
}else {
getEnd = false;
}
//TEST THE START AND END
return (getResult && getEnd);
}
RETOUR: false
RETOUR: true
XML:
<Android.support.v7.widget.AppCompatEditText
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:id="@+id/editTextEmailAddress"
Android:inputType="textEmailAddress|textWebEmailAddress"
Android:cursorVisible="true"
Android:focusable="true"
Android:focusableInTouchMode="true"
Android:singleLine="true"
Android:maxLength="50"
Android:theme="@style/EditTextCustom"/>
Note: J'ai essayé d'obtenir la value à partir de EditText et utilisé split dessus et même StringTokenizer. Les deux me rendent false.
Vous pouvez faire tout type de validation dans Android très facilement avec le fichier oval.jar. OVal est un cadre de validation pragmatique et extensible à usage général pour tout type d'objets Java.
suivez ce lien: http://oval.sourceforge.net/userguide.html
Vous pouvez le télécharger ici: http://oval.sourceforge.net/userguide.html#download
Vous pouvez utiliser la validation en définissant des balises dans des variables
public class Something{
@NotEmpty //not empty validation
@Email //email validation
@SerializedName("emailAddress")
private String emailAddress;
}
private void checkValidation() {
Something forgotpass.setEmailAddress(LoginActivity.this.dialog_email.getText().toString());
Validator validator = new Validator();
//collect the constraint violations
List<ConstraintViolation> violations = validator.validate(forgotpass);
if(violations.size()>0){
for (ConstraintViolation cv : violations){
if(cv.getMessage().contains("emailAddress")){
dialog_email.setError(ValidationMessage.formattedError(cv.getMessage(), forgotpass));
}
}
}
}
J'ai utilisé le code suivant.Ceci fonctionne grate.J'espère que cela vous aidera.
if (validMail(yourEmailString)){
//do your stuf
}else{
//email is not valid.
}
et utilise la méthode suivante. Cela retourne true si l'email est valide.
private boolean validMail(String yourEmailString) {
Pattern emailPattern = Pattern.compile(".+@.+\\.[a-z]+");
Matcher emailMatcher = emailPattern.matcher(emailstring);
return emailMatcher.matches();
}
Pour les amateurs de regex, le meilleur modèle d'e-mail que j'ai trouvé depuis (par exemple, conforme à la RFC 822) est le suivant (avant les filtres fournis par PHP). Je suppose qu'il est facile de traduire cela en Java - pour ceux qui jouent avec une API <8:
private static function email_regex_pattern() {
// Source: http://www.iamcal.com/publish/articles/php/parsing_email
$qtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]';
$dtext = '[^\\x0d\\x5b-\\x5d\\x80-\\xff]';
$atom = '[^\\x00-\\x20\\x22\\x28\\x29\\x2c\\x2e\\x3a-\\x3c'.
'\\x3e\\x40\\x5b-\\x5d\\x7f-\\xff]+';
$quoted_pair = '\\x5c[\\x00-\\x7f]';
$domain_literal = "\\x5b($dtext|$quoted_pair)*\\x5d";
$quoted_string = "\\x22($qtext|$quoted_pair)*\\x22";
$domain_ref = $atom;
$sub_domain = "($domain_ref|$domain_literal)";
$Word = "($atom|$quoted_string)";
$domain = "$sub_domain(\\x2e$sub_domain)*";
$local_part = "$Word(\\x2e$Word)*";
$pattern = "!^$local_part\\x40$domain$!";
return $pattern ;
}
La suite a été utilisée par moi. Cependant, il contient des caractères supplémentaires par rapport aux emails normaux, mais c’était une exigence pour moi.
public boolean isValidEmail(String inputString) {
String s ="^((?!.*?\.\.)[A-Za-z0-9\.\!\#\$\%\&\'*\+\-\/\=\?\^_`\{\|\}\~]+@[A-Za-z0-9]+[A-Za-z0-9\-\.]+\.[A-Za-z0-9\-\.]+[A-Za-z0-9]+)$";
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(inputString);
return matcher.matches();
}
Réponse à cette question: - Obligation de valider une adresse e-mail avec des points donnés
Explication-
- (?!. *? ..) "Point de vue négatif" pour annuler 2 points consécutifs.
- [A-Za-z0-9.! #\$ \%\&\'* + -/\ = \?\^ _ {{|}\~] + Au moins un des caractères Définis. ("\" est utilisé pour s'échapper).
- @ Il pourrait y avoir un "@".
- [A-Za-z0-9] + alors au moins un caractère défini.
- [A-Za-z0-9 -.] * Zéro ou toute répétition de caractère défini.
- [A-Za-z0-9] + Au moins un caractère après point.