Jak powinienem zweryfikować adres e-mail?

Jaka jest dobra technika sprawdzania poprawności adresu e-mail (np. Z pola wprowadzania użytkownika) w systemie Android? org.apache.commons.validator.routines.EmailValidator nie wydaje się być dostępny. Czy robią to inne biblioteki, które są już zawarte w Androidzie, czy też muszę korzystać z RegExp?

Nie używaj reg-ex.

Najwyraźniej poniżej znajduje się reg-ex, który poprawnie sprawdza poprawność większości adresów e-mail zgodnych z RFC 2822 (i nadal nie powiedzie się na przykładach takich jak „użytkownik@gmail.com.nospam”, podobnie jak 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])+)\])

Być może najprostszym sposobem na sprawdzenie poprawności wiadomości e-mail jest wysłanie wiadomości e-mail z potwierdzeniem na podany adres. Odbija się, a następnie jest nieważna.

Jeśli chcesz wykonać podstawowe kontrole, możesz po prostu sprawdzić, czy jest w formularzu *@*

Jeśli masz jakieś zatwierdzenie specyficzne dla logiki biznesowej, możesz to zrobić za pomocą wyrażenia regularnego, np. Musi to być konto gmail.com lub coś takiego.

Inną opcją są wbudowane Wzory zaczynające się od API Poziom 8:

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

Widoczne źródło wzorów

LUB

Jedno liniowe rozwiązanie @AdamvandenHoven:

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

Następny wzór jest używany w poczcie 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}" +
          ")+"
      );

Możesz użyć funkcji

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

Od API 8 (Android 2.2) istnieje wzorzec: android.util.Patterns.EMAIL_ADDRESS http://developer.android.com/reference/android/util/Patterns.html

Możesz więc użyć go do sprawdzenia poprawności e-maila:

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

zwraca true, jeśli adres e-mail jest prawidłowy

UPD: Kod źródłowy tego wzoru to:

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

patrz: http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/2.2_r1.1/android/util/Patterns.java

Możesz więc zbudować go samodzielnie dla kompatybilności z API <8.

Mamy teraz prosty dopasowywanie wzorców e-maili

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

Użyj prostego kodu jednokreskowego do sprawdzania poprawności wiadomości e-mail

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

użyj jak ...

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

Oto sugestie Android Studio:

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

Możesz użyć do tego wyrażenia regularnego. Coś takiego jak poniżej.

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

String email = "xyz@xyzdomain.com";

Matcher matcher = pattern.matcher(email);

boolean matchFound = matcher.matches();

Uwaga: Sprawdź podane powyżej wyrażenie regularne, nie używaj go takim, jakim jest.

użyj Androida: inputType = "textEmailAddress" jak poniżej:

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

i:

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

Możesz napisać rozszerzenie Kotlin w następujący sposób:

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

A potem nazwij to tak:

email.isValidEmail()

Istnieje Patternspakiet w pakiecie, android.utilktóry jest tutaj korzystny. Poniżej znajduje się metoda, której zawsze używam do sprawdzania poprawności wiadomości e-mail i wielu innych rzeczy

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

Zadzwoń do tej metody, pod którą chcesz zweryfikować identyfikator e-mail.

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

W przypadku sprawdzania poprawności adresu e-mail Android udostępnia wzorzec InBuilt. Ale obsługuje tylko interfejs API w wersji 8 i wyższej .

Oto kod używający tego wzorca do sprawdzania poprawności wiadomości e-mail.

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

Upewnij się, że po wykonaniu tej metody powinieneś sprawdzić, czy jeśli ta metoda zwróci wartość true, możesz pozwolić na zapisanie wiadomości e-mail, a jeśli ta metoda zwróci wartość false, wyświetl komunikat, że wiadomość e-mail jest „nieprawidłowa”.

Mam nadzieję, że dostaniesz odpowiedź, dziękuję.

Czy mogę KONIECZNIE zalecić, aby nie próbować „sprawdzać poprawności” adresów e-mail, po prostu dostaniesz się do pracy bez powodu.

Tylko upewnij się, że to, co jest wprowadzone, nie złamie twojego kodu - np. Nie będzie spacji lub niedozwolonych znaków, które mogłyby spowodować wyjątek.

Wszystko inne spowoduje tylko dużo pracy przy minimalnym zwrocie ...

Sprawdź poprawność formatu adresu e-mail. 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;
}

Jeśli używasz interfejsu API 8 lub nowszego, możesz użyć łatwo dostępnej Patternsklasy do sprawdzania poprawności wiadomości e-mail. Przykładowy kod:

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

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

Przypadkowo, jeśli w ogóle obsługujesz poziom API mniejszy niż 8, możesz po prostu skopiować Patterns.javaplik do swojego projektu i odwołać się do niego. Możesz pobrać kod źródłowy Patterns.javaz tego linku

Tutaj jest 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 dopasuje to, jeśli

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

Przykład jakiegoś specjalnego adresu e-mail

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

Możesz zmodyfikować ten wzór dla swojej sprawy, a następnie zatwierdzić przez

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

Wypróbuj tę prostą metodę, która nie może zaakceptować adresu e-mail zaczynającego się od cyfr:

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

Wypróbuj ten kod .. To naprawdę działa ..

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

Wykorzystałem następujące. Zawiera jednak dodatkowe znaki niż zwykłe wiadomości e-mail, ale był to dla mnie wymóg.

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

Odpowiedź na to pytanie: - Wymóg potwierdzenia adresu e-mail z podanymi punktami

Wyjaśnienie-

1. (?!. *? ..) „Negative Lookhead”, aby zanegować 2 kolejne kropki.
2. [A-Za-z0-9.! # \ $ \% \ & \ '* + - / \ = \? \ ^ _ `{\ |} \ ~] + Zdefiniowano co najmniej jeden znak. („\” służy do zmiany znaczenia).
3. @ Może być jeden „@”.
4. [A-Za-z0-9] + następnie zdefiniowano co najmniej jeden znak.
5. [A-Za-z0-9 -.] * Zero lub dowolne zdefiniowane powtórzenie znaku.
6. [A-Za-z0-9] + Przynajmniej jeden znak po kropce.

Kluczem tutaj jest to, że chcesz w pełni zweryfikować adres e-mail. Nie chcesz tylko sprawdzać poprawności składniowej, chcesz sprawdzić, czy adres e-mail jest prawdziwy.

Dwa oczywiste powody: prawdziwi użytkownicy często źle wpisują swoje adresy e-mail, a niektórzy użytkownicy mogą podawać fałszywe adresy e-mail. Dlatego chcesz wykonać kontrolę składniową i kontrolę istnienia.

Najlepszym sposobem na to, co znalazłem na Androidzie, jest użycie do tego darmowego API Cloudmersive Validation API .

Kod wygląda następująco:

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

Używam tego we wszystkich moich aplikacjach i jest to świetne, ponieważ mogę sprawdzić adresy e-mail w UX w punkcie wejścia.

Najprostsze rozwiązanie Kotlin wykorzystujące funkcje rozszerzeń:

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

a następnie możesz sprawdzić w następujący sposób:

"testemail6589@gmail.com".isEmailValid()

Pamiętaj, że większość wyrażeń regularnych jest niepoprawna dla międzynarodowych nazw domen (IDN) i nowych domen najwyższego poziomu, takich jak .mobi lub .info (jeśli sprawdzasz kody krajów lub .org, .com, .gov i tak dalej).

Prawidłowe sprawdzenie powinno oddzielić część lokalną (przed znakiem) i część domeny. Należy również wziąć pod uwagę maksymalną długość części lokalnej i domeny (łącznie 255 znaków, w tym znak at).

Najlepszym rozwiązaniem jest przekształcenie adresu w formacie zgodnym z IDN (jeśli jest wymagany), sprawdzenie części lokalnej (RFC), sprawdzenie długości adresu i sprawdzenie dostępności domeny (wyszukiwanie DNS MX) lub po prostu wysłanie wiadomości e-mail .

Klasa Linkify ma kilka całkiem przydatnych metod pomocniczych, które mogą być istotne, w tym wyrażenia regularne zaprojektowane do pobierania numerów telefonów i adresów e-mail i takie:

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

Użyłem następującego kodu. Działa to z rusztem. Mam nadzieję, że ci to pomoże.

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

i zastosuj metodę podążania. Zwraca wartość true, jeśli wiadomość e-mail jest poprawna.

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

email to twój email-is.

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

    }

Dla miłośników wyrażeń regularnych najlepszy (np. Zgodny z RFC 822) wzór wiadomości e-mail, jaki kiedykolwiek znalazłem, jest następujący (przed dostarczeniem filtrów PHP). Myślę, że łatwo jest to przetłumaczyć na Javę - dla osób grających z 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 ;
}

Za pomocą pliku oval.jar możesz bardzo łatwo przeprowadzić dowolną weryfikację w systemie Android. OVal to pragmatyczne i rozszerzalne ogólne narzędzie do sprawdzania poprawności dla dowolnego rodzaju obiektów Java.

Śledź ten link: http://oval.sourceforge.net/userguide.html

Możesz pobrać to stąd: http://oval.sourceforge.net/userguide.html#download

Możesz użyć walidacji, ustawiając tagi w zmiennych

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

Możesz także użyć

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

Jeśli adres e-mail jest nieprawidłowy, wygeneruje wyjątek adresu .

Niestety, Android nie obsługuje jndi-dns , ale aby dać ci wyobrażenie o bardziej skutecznym sprawdzaniu poprawności wiadomości e-mail, możesz użyć jej do sprawdzenia domeny. Może guru od Androida mógłby pomóc i pokazać, czy istnieją podobne alternatywy ... Przykładowa implementacja z „regularną” javą jest dostępna tutaj .

EDYTOWAĆ

Właśnie zdałem sobie sprawę, że javax.mail nie obsługuje też ... Ale ten post pokazuje obejście .