Làm thế nào tôi nên xác nhận một địa chỉ email?

Kỹ thuật tốt để xác thực địa chỉ email (ví dụ: từ trường nhập của người dùng) trong Android là gì? org.apache.commons.validator.routines.EmailValidator dường như không có sẵn. Có thư viện nào khác đang làm điều này được bao gồm trong Android hay tôi sẽ phải sử dụng RegExp?

Đừng sử dụng reg-ex.

Rõ ràng sau đây là một reg-ex xác nhận chính xác hầu hết các địa chỉ email phù hợp với RFC 2822 , (và vẫn sẽ thất bại với những thứ như "user@gmail.com.nospam", như org.apache.commons.validator. thói quen.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])+)\])

Có thể là cách dễ nhất để xác thực e-mail chỉ cần gửi e-mail xác nhận đến địa chỉ được cung cấp và nó bị trả lại sau đó không hợp lệ.

Nếu bạn muốn thực hiện một số kiểm tra cơ bản, bạn có thể kiểm tra xem nó có ở dạng không *@*

Nếu bạn có một số xác thực logic kinh doanh cụ thể thì bạn có thể thực hiện điều đó bằng cách sử dụng biểu thức chính quy, ví dụ: phải là tài khoản gmail.com hoặc một cái gì đó.

Một tùy chọn khác là các Mẫu được xây dựng bắt đầu bằng API Cấp 8:

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

Các mẫu có thể xem được

HOẶC LÀ

Giải pháp một dòng từ @AdamvandenHoven:

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

Mẫu tiếp theo được sử dụng trong thư 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}" +
          ")+"
      );

Bạn có thể sử dụng chức năng

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

Vì API 8 (android 2.2) có một mẫu: android.util.Potypes.EMAIL_ADDRESS http://developer.android.com/reference/android/util/Potypes.html

Vì vậy, bạn có thể sử dụng nó để xác thực yourEmailString:

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

trả về đúng nếu email hợp lệ

CẬP NHẬT: Mã nguồn mẫu này là:

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

tham khảo: http://grepcode.com/file/reposective.grepcode.com/java/ext/com.google.android/android/2.2_r1.1/android/util/Potypes.java

Vì vậy, bạn có thể tự xây dựng nó để tương thích với API <8.

Chúng tôi có trình so khớp mẫu Email đơn giản ngay bây giờ

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

Sử dụng mã một dòng đơn giản để xác thực email

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

sử dụng như ...

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

Đây là đề xuất của Android Studio:

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

Bạn có thể sử dụng biểu thức chính quy để làm như vậy. Một cái gì đó như sau.

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

String email = "xyz@xyzdomain.com";

Matcher matcher = pattern.matcher(email);

boolean matchFound = matcher.matches();

Lưu ý: Kiểm tra biểu thức chính quy được đưa ra ở trên, không sử dụng nó như hiện tại.

sử dụng android: inputType = "textEmailAddress" như dưới đây:

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

và:

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

Bạn có thể viết một phần mở rộng Kotlin như thế này:

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

Và sau đó gọi nó như thế này:

email.isValidEmail()

Có một Patternslớp trong gói android.utilcó lợi ở đây. Dưới đây là phương pháp tôi luôn sử dụng để xác thực email và nhiều nội dung khác

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

Gọi Phương thức này nơi bạn muốn xác thực 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;
   }
}

Đối với một xác thực Email, Android cung cấp một số Mẫu InBuilt . Nhưng nó chỉ hỗ trợ API cấp 8 trở lên .

Đây là mã để sử dụng mẫu đó để kiểm tra xác thực email.

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

Hãy chắc chắn rằng sau khi thực hiện phương thức này, bạn nên kiểm tra xem nếu phương thức này trả về đúng thì bạn cho phép lưu email và nếu phương thức này trả về false thì hiển thị thông báo rằng email là "Không hợp lệ".

Hy vọng bạn nhận được câu trả lời của bạn, Cảm ơn bạn.

Tôi có thể thực sự khuyên bạn không nên cố gắng 'xác thực' địa chỉ email, bạn sẽ tự mình làm rất nhiều việc mà không có lý do chính đáng.

Chỉ cần đảm bảo những gì được nhập sẽ không phá vỡ mã của riêng bạn - ví dụ: không có khoảng trắng hoặc ký tự không hợp lệ nào có thể gây ra Ngoại lệ.

Bất cứ điều gì khác sẽ chỉ khiến bạn có rất nhiều công việc để mang lại lợi nhuận tối thiểu ...

Xác thực định dạng địa chỉ email của bạn. Ex-virag @ gmail

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

Nếu bạn đang sử dụng API 8 trở lên, bạn có thể sử dụng Patternslớp có sẵn để xác thực email. Mã mẫu:

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

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

Nếu tình cờ nếu bạn thậm chí hỗ trợ cấp API dưới 8, thì bạn chỉ cần sao chép Patterns.javatệp vào dự án của mình và tham chiếu nó. Bạn có thể lấy mã nguồn Patterns.javatừ liên kết này

Đây là 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 sẽ phù hợp với nó nếu

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

Ví dụ một số email phù hợp đặc biệt

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

Bạn có thể sửa đổi mẫu này cho trường hợp của bạn sau đó xác nhận bằng

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

Hãy thử phương pháp đơn giản này không thể chấp nhận địa chỉ email bắt đầu bằng chữ số:

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

Hãy thử mã này .. Nó thực sự hoạt động ..

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

Sau đây được sử dụng bởi tôi. Tuy nhiên, nó chứa nhiều ký tự hơn các email bình thường nhưng đây là một yêu cầu đối với tôi.

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

Trả lời câu hỏi này: - Yêu cầu xác thực địa chỉ email với các điểm đã cho

Giải trình-

1. (?!. *? ..) "Cái nhìn tiêu cực" để phủ định 2 dấu chấm liên tiếp.
2. [A-Za-z0-9.! # \ $ \% \ & \ '* + - / \ = \? \ ^ _ « ("\" được sử dụng để thoát).
3. @ Có thể có một "@".
4. [A-Za-z0-9] + sau đó ít nhất một ký tự được xác định.
5. [A-Za-z0-9 -.] * Không hoặc bất kỳ sự lặp lại của ký tự được xác định.
6. [A-Za-z0-9] + Toàn bộ một char sau khi chấm.

Chìa khóa ở đây là bạn muốn xác nhận đầy đủ địa chỉ email. Bạn không chỉ muốn kiểm tra tính chính xác của cú pháp, bạn muốn kiểm tra xem địa chỉ email có thật không.

Hai lý do rõ ràng: người dùng thực thường nhập sai địa chỉ email của họ và một số người dùng có thể nhập địa chỉ email giả. Do đó, bạn muốn thực hiện kiểm tra cú pháp và kiểm tra sự tồn tại.

Cách tốt nhất để làm điều này mà tôi đã tìm thấy trên Android là sử dụng API xác thực Cloudmerive miễn phí cho việc này.

Mã trông như thế này:

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

Tôi đang sử dụng điều này trong tất cả các ứng dụng của mình và thật tuyệt vời vì tôi có thể xác thực các địa chỉ email trong UX tại điểm nhập cảnh.

Giải pháp đơn giản nhất của Kotlin sử dụng các hàm mở rộng:

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

và sau đó bạn có thể xác nhận như thế này:

"testemail6589@gmail.com".isEmailValid()

Lưu ý rằng hầu hết các biểu thức thông thường không hợp lệ đối với tên miền quốc tế (IDN) và các tên miền cấp cao mới như .mobi hoặc .info (nếu bạn kiểm tra mã quốc gia hoặc .org, .com, .gov, v.v.).

Kiểm tra hợp lệ nên tách phần cục bộ (trước dấu hiệu) và phần tên miền. Bạn cũng nên xem xét độ dài tối đa của phần cục bộ và miền (tổng cộng 255 ký tự bao gồm cả ký hiệu).

Cách tiếp cận tốt nhất là chuyển đổi địa chỉ theo định dạng tương thích IDN (nếu được yêu cầu), xác thực phần cục bộ (RFC), kiểm tra độ dài của địa chỉ và kiểm tra tính khả dụng của tên miền (tra cứu DNS MX) hoặc chỉ cần gửi email .

Lớp Linkify có một số phương thức trợ giúp khá hữu ích có thể có liên quan, bao gồm các biểu thức thông thường được thiết kế để nhận số điện thoại và địa chỉ email, v.v.

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

Tôi đã sử dụng mã follwing. Điều này hoạt động rất tốt. Tôi hy vọng điều này sẽ giúp bạn.

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

và sử dụng phương thức follwing. Điều này trả về true nếu email hợp lệ.

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

email là email của bạn

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

    }

Đối với những người yêu thích regex, mẫu email tốt nhất (ví dụ như phù hợp với RFC 822) mà tôi từng tìm thấy kể từ bây giờ là mẫu sau (trước các bộ lọc do PHP cung cấp). Tôi đoán thật dễ dàng để dịch cái này sang Java - cho những người chơi với 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 ;
}

Bạn có thể thực hiện bất kỳ loại xác thực nào trong Android rất dễ dàng bằng tệp oval.jar. OVal là một khung xác thực mục đích chung có thể mở rộng và thực dụng cho bất kỳ loại đối tượng Java nào.

theo liên kết sau: http://oval.sourceforge.net/userguide.html

Bạn có thể từ chối điều này từ đây: http://oval.sourceforge.net/userguide.html#doad

Bạn có thể sử dụng xác nhận bằng cách đặt thẻ trong các biến

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

Bạn cũng có thể sử dụng

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

Nếu email không hợp lệ nó sẽ ném một AddressException .

Thật không may, Android không hỗ trợ jndi-dns , nhưng chỉ để cung cấp cho bạn ý tưởng về xác thực email mạnh mẽ hơn, bạn có thể sử dụng nó để xác thực tên miền email. Có lẽ một chuyên gia Android có thể giúp đỡ và hiển thị nếu có các lựa chọn thay thế tương tự ... Một triển khai ví dụ với java "thông thường" có sẵn ở đây .

BIÊN TẬP

Tôi chỉ nhận ra rằng javax.mail không hỗ trợ cả ... Nhưng bài đăng này cho thấy một cách giải quyết .