webentwicklung-frage-antwort-db.com.de

Wie muss ich eine E-Mail-Adresse bestätigen?

Was ist eine gute Technik zum Validieren einer E-Mail-Adresse (z. B. von einem Benutzereingabefeld) in Android? org.Apache.commons.validator.routines.EmailValidator scheint nicht verfügbar zu sein. Gibt es andere Bibliotheken, die bereits in Android enthalten sind, oder müsste ich RegExp verwenden?

296
znq

Verwenden Sie kein Reg-Ex. 

Anscheinend ist das folgende ein Reg-Ex, das die meisten E-Mail-Adressen, die RFC 2822 entsprechen, korrekt überprüft (und bei "[email protected]" immer noch fehlschlägt, wie auch 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])+)\])

Möglicherweise ist der einfachste Weg, eine E-Mail zu bestätigen, um nur eine Bestätigungs-E-Mail an die angegebene Adresse zu senden, und wenn sie abspringt, ist sie ungültig.

Wenn Sie einige grundlegende Überprüfungen durchführen möchten, überprüfen Sie einfach, ob es sich im Formular *@* befindet.

Wenn Sie über eine für die Geschäftslogik spezifische Validierung verfügen, können Sie dies unter Verwendung eines regulären Ausdrucks durchführen, z. muss ein gmail.com-Konto oder etwas sein.

46
Glen

Eine weitere Option ist das eingebaute Patterns , das mit API Level 8 beginnt:

public final static boolean isValidEmail(CharSequence target) {
  if (TextUtils.isEmpty(target)) {
    return false;
  } else {
    return Android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
  }
}

Patterns sichtbare Quelle

ODER

Einzeilige Lösung von @AdamvandenHoven:

public final static boolean isValidEmail(CharSequence target) {
  return !TextUtils.isEmpty(target) && Android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
}
986
mindriot

Das nächste Muster wird in der K-9-Mail verwendet:

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}" +
          ")+"
      );

Sie können die Funktion verwenden

private boolean checkEmail(String email) {
        return EMAIL_ADDRESS_PATTERN.matcher(email).matches();
}
96
Andrei Buneyeu

Seit API 8 (Android 2.2) gibt es ein Muster: Android.util.Patterns.EMAIL_ADDRESS http://developer.Android.com/reference/Android/util/Patterns.html

So können Sie es verwenden, um Ihren EmailString zu überprüfen:

private boolean isValidEmail(String email) {
    Pattern pattern = Patterns.EMAIL_ADDRESS;
    return pattern.matcher(email).matches();
}

gibt true zurück, wenn die E-Mail gültig ist

UPD: Dieser Muster-Quellcode lautet:

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}" +
        ")+"
    );

siehe: http://grepcode.com/file/repository.grepcode.com/Java/ext/com.google.Android/android/2.2_r1.1/Android/util/Patterns.Java

Sie können es also selbst erstellen, um die Kompatibilität mit API <8 zu gewährleisten.

68
Luten

Wir haben jetzt einen einfachen E-Mail-Mustervergleicher

 private static boolean isValidEmail(String email) {
        return !TextUtils.isEmpty(email) && Android.util.Patterns.EMAIL_ADDRESS.matcher(email).matches();
    }
44
Salman Nazir

Dies sind Android Studio-Vorschläge:

public static boolean isEmailValid(String email) {
    return !(email == null || TextUtils.isEmpty(email)) && Android.util.Patterns.EMAIL_ADDRESS.matcher(email).matches();
}
16
Matteo

verwenden Sie Android: inputType = "textEmailAddress" wie folgt:

       <EditText
        Android:layout_width="match_parent"
        Android:layout_height="wrap_content"
        Android:hint="email"
        Android:inputType="textEmailAddress"
        Android:id="@+id/email"
        />

und:

       boolean isEmailValid(CharSequence email) {
        return Android.util.Patterns.EMAIL_ADDRESS.matcher(email)
                .matches();
      }
11
Victor Odiah

Sie können dazu reguläre Ausdrücke verwenden. Etwas wie das Folgende.

Pattern pattern = Pattern.compile("[email protected]+\\.[a-z]+");

String email = "[email protected]";

Matcher matcher = pattern.matcher(email);

boolean matchFound = matcher.matches();

Hinweis: Überprüfen Sie den oben angegebenen regulären Ausdruck und verwenden Sie ihn nicht so wie er ist.

10
Mudassir

Im Paket Android.util gibt es eine Patterns-Klasse, was hier von Vorteil ist. Im Folgenden finden Sie die Methode, die ich immer zum Überprüfen von E-Mails und vielen anderen Dingen verwende

private boolean isEmailValid(String email) {
    return !TextUtils.isEmpty(email) && Patterns.EMAIL_ADDRESS.matcher(email).matches();
}
8
Jimit Patel

Verwenden Sie einen einfachen einzeiligen Code für die E-Mail-Bestätigung

public static boolean isValidEmail(CharSequence target) {
    return !TextUtils.isEmpty(target) && Android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
}

verwenden Sie wie ...

if (!isValidEmail(yourEdittext.getText().toString()) {
    Toast.makeText(context, "your email is not valid", 2000).show();
}
8
Pankaj Talaviya

Für eine E-Mail-Gültigkeitsprüfung bietet Android ein InBuilt-Muster an. Es unterstützt jedoch nur API Level 8 und höher.

Hier ist der Code, mit dem Sie dieses Muster zur Überprüfung der E-Mail-Gültigkeit verwenden können.

  private boolean Email_Validate(String email) 
  {
    return Android.util.Patterns.EMAIL_ADDRESS.matcher(email).matches();
  }

Stellen Sie sicher, dass Sie nach dem Ausführen dieser Methode überprüfen müssen, ob diese E-Mail gespeichert werden soll, wenn diese Methode true zurückgibt. Wenn diese Methode false zurückgibt, wird die Nachricht "Ungültig" angezeigt.

Ich hoffe, Sie erhalten Ihre Antwort... Vielen Dank.

5
AMI CHARADAVA

Sie könnten eine Kotlin-Erweiterung wie folgt schreiben:

fun String.isValidEmail() =
        this.isNotEmpty() && Android.util.Patterns.EMAIL_ADDRESS.matcher(this).matches()

Und dann nennen wir es so:

email.isValidEmail()
5
Danilo Lemes

Rufen Sie diese Methode auf, bei der Sie die E-Mail-ID überprüfen möchten. 

public static boolean isValid(String email)
{
   String expression = "^[\\w\\.-][email protected]([\\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;
   }
}
5
Sumit Sharma

Bestätigen Sie Ihr E-Mail-Adressformat. [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();
}
4
Virag Brahme
    public boolean isValidEmail(String email)
{
    boolean isValidEmail = false;

    String emailExpression = "^[\\w\\.-][email protected]([\\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;
}
3
Atif Mahmood

Kann ich DRINGEND empfehlen, dass Sie nicht versuchen, E-Mail-Adressen zu "validieren"? Sie werden sich einfach ohne großen Grund mit einer Menge Arbeit beschäftigen.

Stellen Sie nur sicher, dass das Eingegebene Ihren eigenen Code nicht verletzt - z. Keine Leerzeichen oder unzulässigen Zeichen, die eine Ausnahme verursachen könnten.

Alles andere wird nur eine Menge Arbeit für minimale Erträge verursachen ...

3
user834595

Hier ist 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 wird dem entsprechen, wenn

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, -)

Beispiel eine spezielle Match-E-Mail

[email protected]
[email protected]
[email protected]

Sie können dieses Muster für Ihren Fall ändern und dann mit bestätigen

fun isValidEmail(email: String): Boolean {
    return Patterns.EMAIL_ADDRESS.matcher(email).matches()
}
2
Linh

Versuchen Sie diese einfache Methode, die die mit Ziffern beginnende E-Mail-Adresse nicht akzeptieren kann:

boolean checkEmailCorrect(String Email) {
    if(signupEmail.length() == 0) {
        return false;
    }

    String pttn = "^\\[email protected]+\\.[a-z]+";
    Pattern p = Pattern.compile(pttn);
    Matcher m = p.matcher(Email);

    if(m.matches()) {
        return true;
    }

    return false;
}
1
Arman

Wenn Sie API 8 oder höher verwenden, können Sie die sofort verfügbare Klasse Patterns verwenden, um E-Mails zu überprüfen. Beispielcode:

public final static boolean isValidEmail(CharSequence target) {
    if (target == null) 
        return false;

    return Android.util.Patterns.EMAIL_ADDRESS.matcher(target).matches();
}

Wenn Sie sogar API-Level unter 8 unterstützen, können Sie die Patterns.Java-Datei einfach in Ihr Projekt kopieren und darauf verweisen. Den Quellcode für Patterns.Java erhalten Sie von diesem Link

1
Mahendra Liya

Der Schlüssel hier ist, dass Sie die E-Mail-Adresse vollständig überprüfen möchten. Sie möchten es nicht nur auf syntaktische Korrektheit überprüfen, sondern auch, ob die E-Mail-Adresse echt ist.

Zwei offensichtliche Gründe: Echte Benutzer geben häufig ihre E-Mail-Adressen falsch ein, und. Daher möchten Sie eine syntaktische Prüfung und eine Existenzprüfung durchführen. 

Die beste Methode, die ich auf Android gefunden habe, ist die Verwendung der kostenlosen Cloudmersive Validation API für diesen Vorgang.

Der Code sieht so aus: 

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();
}

Ich verwende dies in allen meinen Apps und es ist großartig, da ich die E-Mail-Adressen in UX zum Zeitpunkt der Eingabe überprüfen kann.

1
user5377037

Versuchen Sie diesen Code .. Es funktioniert wirklich ..

            if (!email
                    .matches("^[\\w-_\\.+]*[\\w-_\\.]\\@([\\w]+\\.)+[\\w]+[\\w]$"))
            {
                Toast.makeText(getApplicationContext(), "Email is invalid",
                        Toast.LENGTH_LONG).show();
                return;
            }
1
Jenifer

Die Linkify-Klasse verfügt über einige nützliche Hilfemethoden, die möglicherweise relevant sind, einschließlich regulärer Ausdrücke zum Abrufen von Telefonnummern und E-Mail-Adressen.

http://developer.Android.com/reference/Android/text/util/Linkify.html

0
Andrew Wyld

Beachten Sie, dass die meisten regulären Ausdrücke für internationale Domänennamen (IDN) und neue Top-Level-Domänen wie .mobi oder .info nicht gültig sind (wenn Sie nach Landescodes oder .org, .com, .gov usw. suchen).

Eine gültige Prüfung sollte den lokalen Teil (vor dem Vorzeichen) und den Domänenteil trennen. Sie sollten auch die maximale Länge des lokalen Teils und der Domäne berücksichtigen (in Summe 255 Zeichen einschließlich des at-Zeichens).

Die beste Methode ist, die Adresse in ein IDN-kompatibles Format umzuwandeln (falls erforderlich), den lokalen Teil (RFC) zu validieren, die Länge der Adresse und die Verfügbarkeit der Domäne zu überprüfen (DNS MX-Suche) oder einfach eine E-Mail zu senden .

0
Thorsten

e-Mail ist Ihre E-Mail-Adresse.

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();

    }
0
kyogs

Ich weiß, dass es sehr spät ist, aber ich werde meine Antwort geben.

Ich habe diese Codezeile verwendet, um das eingegebene Email-Format zu überprüfen:

!TextUtils.isEmpty(getEmail) && Android.util.Patterns.EMAIL_ADDRESS.matcher(getEmail).matches();

Das Problem ist, es wird nur nach der FORMAT und nicht nach der SPELLING gesucht.

Wenn ich @gmal.com fehlt, i und @yaho.com eine andere o ., Wird true zurückgegeben. Da er die Bedingung für Email Format erfüllt.

Was ich getan habe ist, ich habe den Code oben verwendet. Da gibt/true zurückgeben, wenn Wenn der Benutzer @gmail.comNUR eingibt, am Anfang kein Text.

FORMAT CHECKER

 check

Wenn ich diese E-Mail eingebe, bekomme ich: true, aber die Schreibweise ist falsch. Inmy textInputLayout error 

 wrongSpelling

E-MAIL-ADRESSE @yahoo.com, @gmail.com, @Outlook.com CHECKER

 //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);
}

RÜCKKEHR: false

 false

 noSpecial

RETURN: true

 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"/>

Hinweis: Ich habe versucht, die value von EditText abzurufen und habe split und sogar StringTokenizer verwendet. Beide geben false an mich zurück. 

0
RoCk Vangeance

Sie können jede Art von Validierung in Android sehr einfach über die Datei oval.jar durchführen. OVal ist ein pragmatisches und erweiterbares Validierungs-Framework für allgemeine Zwecke für jegliche Art von Java-Objekten.

folge diesem Link: http://oval.sourceforge.net/userguide.html

Sie können dies von hier herunterladen: http://oval.sourceforge.net/userguide.html#download

Sie können die Validierung verwenden, indem Sie Tags in Variablen setzen

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));
                }
            }
        }
}
0

Sie könnten auch verwenden

InternetAddress emailAddr = new InternetAddress(email);
emailAddr.validate();

Wenn die E-Mail nicht gültig ist, wird eine AddressException ausgelöst.

Leider unterstützt Android nichtjndi-dns , aber um Ihnen eine Vorstellung von einer leistungsfähigeren E-Mail-Validierung zu vermitteln, können Sie damit die E-Mail-Domäne überprüfen. Vielleicht könnte ein Android-Guru helfen und zeigen, ob es ähnliche Alternativen gibt ... Eine Beispielimplementierung mit "regulärem" Java finden Sie hier .

BEARBEITEN

Ich habe gerade erkannt, dass javax.mail auch keine Unterstützung bietet ... Aber dieser Beitrag zeigt eine Workaround .

0
Bob Rivers

Ich habe folgenden Code verwendet. Dies funktioniert dankend. Ich hoffe, das wird Ihnen helfen.

if (validMail(yourEmailString)){
   //do your stuf
 }else{
 //email is not valid.
}

und verwende folgende Methode. Gibt true zurück, wenn die E-Mail gültig ist.

    private boolean validMail(String yourEmailString) {
    Pattern emailPattern = Pattern.compile("[email protected]+\\.[a-z]+");
    Matcher emailMatcher = emailPattern.matcher(emailstring);
    return emailMatcher.matches();
}
0
Umesh

Für Regex-Liebhaber ist das beste E-Mail-Muster (z. B. mit RFC 822 beständig), das ich je gefunden habe, das folgende (vor PHP gelieferte Filter). Ich denke, es ist leicht, dies in Java zu übersetzen - für diejenigen, die mit API <8 spielen:

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 ;
}
0
hornetbzz

Folgendes wurde von mir benutzt. Es enthält jedoch zusätzliche Zeichen als normale E-Mails, aber dies war für mich eine Voraussetzung.

public boolean isValidEmail(String inputString) {
    String  s ="^((?!.*?\.\.)[A-Za-z0-9\.\!\#\$\%\&\'*\+\-\/\=\?\^_`\{\|\}\~][email protected][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();
}

Antwort auf diese Frage: - Anforderung zur Überprüfung einer E-Mail-Adresse mit angegebenen Punkten

Erläuterung-

  1. (?!. *? ..) "Negativer Lookhead", um 2 aufeinander folgende Punkte zu negieren.
  2. [A-Za-z0-9.! #\$ \%\&\'* + -/\ = \?\^ _ {{| |}\~] + Mindestens ein Zeichen definiert. ("\" wird für das Escaping verwendet).
  3. @ Möglicherweise gibt es ein "@".
  4. [A-Za-z0-9] + dann mindestens ein definiertes Zeichen.
  5. [A-Za-z0-9 -.] * Null oder beliebige Wiederholung des Zeichens.
  6. [A-Za-z0-9] + Mindestens ein Zeichen nach dem anderen.
0
Vipin Sharma