Bir e-posta adresini nasıl doğrulamalıyım?

Android'de bir e-posta adresini (örneğin bir kullanıcı giriş alanından) doğrulamak için iyi bir teknik nedir? org.apache.commons.validator.routines.EmailValidator uygun görünmüyor. Bunu zaten Android'de bulunan başka bir kütüphane var mı veya RegExp kullanmak zorunda mıyım?

Reg-ex kullanmayın.

Görünüşe göre aşağıdakiler, RFC 2822'ye uyan çoğu e-posta adresini doğru bir şekilde doğrulayan ve yine de org.apache.commons.validator gibi "user@gmail.com.nospam" gibi şeylerde başarısız olacak bir reg- ex'dir. 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])+)\])

Muhtemelen verilen adrese bir onay e-postası göndermek için bir e-postayı doğrulamanın en kolay yolu ve o sıçrar, o zaman geçerli değildir.

Bazı temel kontroller yapmak istiyorsanız, bunun formda olup olmadığını kontrol edebilirsiniz. *@*

Bazı iş mantığına özgü doğrulama varsa o zaman bir regex kullanarak, örneğin bir gmail.com hesabı ya da bir şey olması gerekir.

Başka bir seçenek, API Düzey 8 ile başlayan yerleşik Desenlerdir :

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

Desenler görüntülenebilir kaynağı

VEYA

@AdamvandenHoven'dan bir satır çözüm:

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

K-9 postasında sonraki desen kullanılır:

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

Fonksiyonu kullanabilirsiniz

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

API 8'den (android 2.2) beri bir desen var: android.util.Patterns.EMAIL_ADDRESS http://developer.android.com/reference/android/util/Patterns.html

Böylece, e-postanızı doğrulamak için kullanabilirsiniz:

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

e-posta geçerliyse true değerini döndürür

UPD: Bu kalıp kaynak kodu:

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

bakınız: http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/2.2_r1.1/android/util/Patterns.java

Böylece API <8 ile uyumluluk için kendiniz oluşturabilirsiniz.

Şimdi basit E-posta kalıbı eşleştiricimiz var

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

E-posta Doğrulaması için basit bir satır kodu kullanın

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

gibi kullanın ...

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

Bu Android Studio önerileri:

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

Bunu yapmak için normal ifadeyi kullanabilirsiniz. Aşağıdaki gibi bir şey.

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

String email = "xyz@xyzdomain.com";

Matcher matcher = pattern.matcher(email);

boolean matchFound = matcher.matches();

Not: Yukarıda verilen normal ifadeyi kontrol edin, olduğu gibi kullanmayın.

android kullanın: inputType = "textEmailAddress" aşağıdaki gibi:

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

ve:

       boolean isEmailValid(CharSequence email) {
        return android.util.Patterns.EMAIL_ADDRESS.matcher(email)
                .matches();
      }

Bunun gibi bir Kotlin uzantısı yazabilirsiniz:

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

Ve sonra şöyle deyin:

email.isValidEmail()

PatternsPakette android.utilburada faydalı olan bir sınıf var. Aşağıda her zaman e-postaları ve diğer birçok şeyi doğrulamak için kullandığım yöntem var

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

E-posta kimliğini doğrulamak istediğiniz bu yöntemi çağırın.

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

Bir E-posta doğrulama android için bazı InBuilt Desen sağlar.Ama sadece API seviye 8 ve üstü destekler .

E-posta doğrulamasını kontrol etmek için bu kalıbı kullanmak için kod.

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

Bu yöntemi yürüttükten sonra , bu yöntemin true değerini döndürmesi durumunda e-postayı kaydetmeye izin verdiğinizden ve bu yöntemin false döndürmesi durumunda , e-postanın "Geçersiz" olduğunu belirten bir ileti görüntülediğinden emin olun.

Umarım cevabını alırsın, teşekkürler.

E-posta adreslerini 'doğrulamaya' çalışmamanızı şiddetle tavsiye edebilir miyim, iyi bir sebep olmadan kendinizi çok fazla işe sokacaksınız.

Girilen kodların kendi kodunuzu kırmayacağından emin olun - örneğin, İstisnaya neden olabilecek boşluk veya geçersiz karakterler.

Başka bir şey, minimum geri dönüş için size çok fazla iş neden olacaktır ...

E-posta adresi biçiminizi doğrulayın. Ex-virag@gmail.com

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

API 8 veya üstünü kullanıyorsanız, Patternse-postayı doğrulamak için hazır sınıfı kullanabilirsiniz. Basit kod:

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

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

Şans eseri, API düzeyini 8'den az destekliyor olsanız bile, Patterns.javadosyayı projenize kopyalayıp referans verebilirsiniz . Sen kaynak kodunu alabilirsiniz Patterns.javadan bu bağlantı

Burada android.util.Patterns.EMAIL_ADDRESS

[A-z-Z0-9 + ._ \% - +] {1,256} \ @ [a-z-0-9] [a-z-0-9 -]. {0,64} ([a z-a-0-9] [a-z-0-9 -] {0,25}) +

String eğer eşleşecekse

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

Bazı özel eşleşme e-postalarına örnek

a@b.c
a+@b-.c
a@b.c.d.e.f.g.h

Durumunuz için bu kalıbı değiştirebilir ve ardından doğrulayabilirsiniz.

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

Rakamlarla başlayan e-posta adresini kabul edemeyen bu basit yöntemi deneyin:

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

Bu kodu deneyin .. Gerçekten işe yarıyor ..

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

Aşağıdaki benim tarafımdan kullanıldı. Ancak normal e-postalardan daha fazla karakter içeriyor ama bu benim için bir gereklilikti.

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

Bu sorunun cevabı: - Verilen noktaları içeren bir e-posta adresini doğrulama gerekliliği

Explanation-

1. (?!. *? ..) Ardışık 2 noktayı reddetmek için "Negatif Bakış Başlığı".
2. [A-Za-z0-9.! # \ $ \% \ & \ '* + - / \ = \? \ ^ _ `{\ |} \ ~] + En az bir karakter tanımlandı. ("\" çıkış için kullanılır).
3. @ Bir tane "@" olabilir.
4. [A-Za-z0-9] + sonra en az bir karakter tanımlandı.
5. [A-Za-z0-9 -.] * Sıfır veya tanımlanan herhangi bir karakter tekrarı.
6. [A-Za-z0-9] + Noktadan sonra en az bir karakter.

Buradaki anahtar, e-posta adresini tam olarak doğrulamak istediğinizdir. Sadece sözdizimsel doğruluğunu kontrol etmek istemiyorsunuz, e-posta adresinin gerçek olup olmadığını kontrol etmek istiyorsunuz.

Bunun iki nedeni: gerçek kullanıcılar e-posta adreslerini yanlış yazar ve bazı kullanıcılar sahte e-posta adresleri girebilir. Bu nedenle, sözdizimsel bir kontrol ve bir varoluş kontrolü yapmak istiyorsunuz.

Android'de bulduğum bunu yapmanın en iyi yolu, bunun için ücretsiz Cloudmersive Doğrulama API'sını kullanmaktır .

Kod şöyle görünür:

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. \"support@cloudmersive.com\". 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();
}

Bunu tüm uygulamalarımda kullanıyorum ve giriş noktasında UX'deki e-posta adreslerini doğrulayabildiğim için harika .

Genişletme fonksiyonlarını kullanan en basit Kotlin çözümü:

fun String.isEmailValid() =
            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}" +
                            ")+"
            ).matcher(this).matches()

ve sonra şu şekilde doğrulayabilirsiniz:

"testemail6589@gmail.com".isEmailValid()

Normal ifadelerin çoğunun uluslararası alan adları (IDN) ve .mobi veya .info gibi yeni üst düzey alan adları için geçerli olmadığını unutmayın (ülke kodlarını veya .org, .com, .gov vb.).

Geçerli bir kontrol yerel kısmı (at-sign'dan önce) ve alan kısmını ayırmalıdır. Ayrıca, yerel parçanın ve alanın maksimum uzunluğunu da dikkate almalısınız (at-sign dahil toplam 255 karakter).

En iyi yaklaşım, adresi IDN uyumlu bir formatta dönüştürmek (gerekirse), yerel bölümü (RFC) doğrulamak, adresin uzunluğunu ve alan adının kullanılabilirliğini kontrol etmek (DNS MX araması) veya sadece bir e-posta göndermektir. .

Linkify sınıfında, telefon numaralarını ve e-posta adreslerini almak için tasarlanmış düzenli ifadeler ve bunun gibi ilgili olabilecek bazı oldukça yararlı yardımcı yöntemler vardır:

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

Ben follwing kodu kullandım.Bu rendeleyin çalışır umarım bu size yardımcı olacaktır.

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

ve follwing yöntemini kullanın.Bu, e-posta geçerliyse true değerini döndürür.

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

e-posta sizin e-postanızdır.

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

    }

Normal ifade sevenler için, şimdiye kadar bulduğum en iyi (ör. RFC 822 ile uyumlu) e-posta modeli aşağıdaki gibidir (PHP tarafından sağlanan filtrelerden önce). API <8 ile oynayanlar için bunu Java'ya çevirmek kolay sanırım:

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

Oval.jar dosyası ile android'de her türlü doğrulama işlemini çok kolay yapabilirsiniz. OVal, her türlü Java nesnesi için pragmatik ve genişletilebilir bir genel amaçlı doğrulama çerçevesidir.

bu bağlantıyı takip et: http://oval.sourceforge.net/userguide.html

Bunu buradan indirebilirsiniz: http://oval.sourceforge.net/userguide.html#download

Değişkenlerdeki etiketleri ayarlayarak doğrulamayı kullanabilirsiniz

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

Ayrıca kullanabilirsiniz

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

E-posta geçerli değilse, bir AddressException oluşturur .

Ne yazık ki Android jndi-dns'i desteklemiyor , ancak size daha güçlü bir e-posta doğrulaması hakkında fikir vermek için, bunu e-posta etki alanını doğrulamak için kullanabilirsiniz. Belki bir Android gurusu benzer alternatifler olup olmadığını gösterebilir ve gösterebilir ... "Normal" java ile örnek bir uygulama burada mevcuttur .

DÜZENLE

Sadece javax.mail'in de desteklemediğini anladım ... Ama bu yazı bir çözüm gösteriyor .