Bagaimana saya harus memvalidasi alamat email?

Apa teknik yang baik untuk memvalidasi alamat email (mis. Dari bidang input pengguna) di Android? org.apache.commons.validator.routines.EmailValidator tampaknya tidak tersedia. Apakah ada perpustakaan lain yang melakukan ini yang sudah termasuk dalam Android atau haruskah saya menggunakan RegExp?

Jangan gunakan reg-ex.

Rupanya yang berikut ini adalah reg-ex yang secara benar memvalidasi sebagian besar alamat email yang sesuai dengan RFC 2822 , (dan masih akan gagal pada hal-hal seperti "user@gmail.com.nospam", seperti yang akan 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])+)\])

Mungkin cara termudah untuk memvalidasi email hanya mengirim email konfirmasi ke alamat yang diberikan dan itu memantul maka itu tidak valid.

Jika Anda ingin melakukan beberapa pemeriksaan dasar, Anda bisa mengeceknya dalam formulir *@*

Jika Anda memiliki beberapa validasi logika bisnis khusus maka Anda dapat melakukan itu menggunakan regex, misalnya harus menjadi akun gmail.com atau sesuatu.

Opsi lain adalah Pola bawaan yang dimulai dengan API Level 8:

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

Sumber yang dapat dilihat pola

ATAU

Solusi satu baris dari @AdamvandenHoven:

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

Pola selanjutnya digunakan dalam surat 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}" +
          ")+"
      );

Anda dapat menggunakan fungsi

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

Sejak API 8 (android 2.2) ada pola: android.util.Patterns.EMAIL_ADDRESS http://developer.android.com/reference/android/util/Patterns.html

Jadi Anda bisa menggunakannya untuk memvalidasi yourEmailString Anda:

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

mengembalikan true jika email tersebut valid

UPD: Kode sumber pola ini adalah:

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

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

Jadi, Anda dapat membuatnya sendiri untuk kompatibilitas dengan API <8.

Kami memiliki pencocokan pola Email sederhana sekarang

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

Gunakan kode satu baris sederhana untuk Validasi email

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

gunakan seperti ...

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

Ini adalah saran Android Studio:

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

Anda dapat menggunakan ekspresi reguler untuk melakukannya. Sesuatu seperti yang berikut ini.

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

String email = "xyz@xyzdomain.com";

Matcher matcher = pattern.matcher(email);

boolean matchFound = matcher.matches();

Catatan: Periksa ekspresi reguler yang diberikan di atas, jangan gunakan apa adanya.

gunakan android: inputType = "textEmailAddress" seperti di bawah ini:

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

dan:

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

Anda dapat menulis ekstensi Kotlin seperti ini:

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

Dan menyebutnya seperti ini:

email.isValidEmail()

Ada Patternskelas dalam paket android.utilyang bermanfaat di sini. Di bawah ini adalah metode yang selalu saya gunakan untuk memvalidasi email dan banyak hal lainnya

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

Panggil Metode Ini di mana Anda ingin memvalidasi ID email.

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

Untuk Android validasi Email, berikan beberapa Pola InBuilt . Tapi itu hanya mendukung API level 8 ke atas .

Berikut adalah kode untuk menggunakan pola itu untuk memeriksa validasi email.

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

Pastikan bahwa setelah menjalankan metode ini Anda harus memeriksa bahwa jika metode ini mengembalikan true maka Anda mengizinkan untuk menyimpan email dan jika metode ini kembali salah maka tampilkan pesan bahwa email itu "Tidak Valid".

Semoga Anda mendapatkan jawaban Anda, Terima kasih.

Dapatkah saya SANGAT merekomendasikan Anda tidak mencoba 'memvalidasi' alamat email, Anda hanya akan mendapatkan banyak pekerjaan tanpa alasan yang baik.

Pastikan saja apa yang dimasukkan tidak akan merusak kode Anda sendiri - mis. Tidak ada spasi atau karakter ilegal yang dapat menyebabkan Pengecualian.

Hal lain hanya akan menyebabkan Anda banyak pekerjaan untuk pengembalian minimal ...

Validasikan format alamat email Anda. 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;
}

Jika Anda menggunakan API 8 atau lebih, Anda dapat menggunakan Patternskelas yang tersedia untuk memvalidasi email. Kode sampel:

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

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

Secara kebetulan jika Anda bahkan mendukung level API kurang dari 8, maka Anda cukup menyalin Patterns.javafile ke proyek Anda dan merujuknya. Anda bisa mendapatkan kode sumber Patterns.javadari tautan ini

Disini adalah 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 akan cocok jika

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

Contoh beberapa email pertandingan khusus

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

Anda dapat mengubah pola ini untuk kasus Anda kemudian divalidasi oleh

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

Coba metode sederhana ini yang tidak dapat menerima alamat email yang dimulai dengan angka:

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

Coba kode ini .. Ini benar-benar berfungsi ..

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

Mengikuti digunakan oleh saya. Namun itu berisi karakter tambahan dari email normal tetapi ini merupakan persyaratan bagi saya.

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

Jawaban dari pertanyaan ini: - Persyaratan untuk memvalidasi alamat email dengan poin yang diberikan

Penjelasan-

1. (?!. *? ..) "Negative Lookhead" untuk meniadakan 2 titik berturut-turut.
2. [A-Za-z0-9.! # \ $ \% \ & \ '* + - / \ = \? \ ^ _ `{\ |} \ ~] + Setidaknya satu karakter yang ditentukan. ("\" digunakan untuk melarikan diri).
3. @ Mungkin ada satu "@".
4. [A-Za-z0-9] + lalu atleast satu karakter yang ditentukan.
5. [A-Za-z0-9 -.] * Nol atau pengulangan karakter apa pun yang ditentukan.
6. [A-Za-z0-9] + Setidaknya satu karakter setelah titik.

Kuncinya di sini adalah Anda ingin memvalidasi alamat email sepenuhnya. Anda tidak hanya ingin memeriksa kebenaran sintaksisnya, Anda ingin memeriksa apakah alamat emailnya asli.

Dua alasan yang jelas: pengguna nyata sering salah mengetik alamat email mereka, dan beberapa pengguna mungkin memasukkan alamat email palsu. Oleh karena itu, Anda ingin melakukan pemeriksaan sintaksis dan pemeriksaan keberadaan.

Cara terbaik untuk melakukan ini yang saya temukan di Android adalah dengan menggunakan API Validasi Cloudmersive gratis untuk ini.

Kode ini terlihat seperti ini:

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

Saya menggunakan ini di semua aplikasi saya dan itu bagus karena saya dapat memvalidasi alamat email di UX pada titik masuk.

Solusi Kotlin sederhana menggunakan fungsi ekstensi:

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

dan kemudian Anda dapat memvalidasi seperti ini:

"testemail6589@gmail.com".isEmailValid()

Perhatikan bahwa sebagian besar ekspresi reguler tidak valid untuk nama domain internasional (IDN) dan domain tingkat atas baru seperti .mobi atau .info (jika Anda memeriksa kode negara atau .org, .com, .gov, dan sebagainya).

Pemeriksaan yang valid harus memisahkan bagian lokal (sebelum tanda-di) dan bagian domain. Anda juga harus mempertimbangkan panjang maksimal bagian dan domain lokal (dalam jumlah 255 karakter termasuk pada tanda).

Pendekatan terbaik adalah mengubah alamat dalam format IDN yang kompatibel (jika diperlukan), memvalidasi bagian lokal (RFC), memeriksa panjang alamat dan memeriksa ketersediaan domain (pencarian DNS MX) atau cukup mengirim email .

Kelas Linkify memiliki beberapa metode pembantu yang sangat berguna yang mungkin relevan, termasuk ekspresi reguler yang dirancang untuk mengambil nomor telepon dan alamat email dan semacamnya:

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

Saya telah menggunakan kode follwing. Ini berfungsi. Saya harap ini akan membantu Anda.

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

dan gunakan metode follwing. Ini mengembalikan true jika email valid.

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

email adalah email-is Anda.

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

    }

Untuk pecinta regex, pola email terbaik (misalnya konsisten dengan RFC 822) yang pernah saya temukan sejak sekarang adalah yang berikut (sebelum filter yang disediakan PHP). Saya kira mudah untuk menerjemahkan ini ke dalam Java - bagi mereka yang bermain dengan 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 ;
}

Anda dapat melakukan semua jenis validasi di android dengan sangat mudah menggunakan file oval.jar. OVal adalah kerangka kerja validasi tujuan umum pragmatis dan dapat diperluas untuk segala jenis objek Java.

ikuti tautan ini: http://oval.sourceforge.net/userguide.html

Anda dapat menurunkan ini dari sini: http://oval.sourceforge.net/userguide.html#download

Anda dapat menggunakan validasi dengan menetapkan tag dalam variabel

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

Anda juga bisa menggunakannya

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

Jika email tidak valid maka akan membuang AddressException .

Sayangnya Android tidak mendukung jndi-dns , tetapi hanya untuk memberi Anda gambaran validasi email yang lebih kuat, Anda dapat menggunakannya untuk memvalidasi domain email. Mungkin seorang guru Android dapat membantu dan menunjukkan jika ada alternatif yang serupa ... Contoh implementasi dengan java "reguler" tersedia di sini .

EDIT

Saya baru menyadari bahwa javax.mail juga tidak mendukung ... Tapi pos ini menunjukkan solusi .