ฉันจะตรวจสอบที่อยู่อีเมลได้อย่างไร

เทคนิคที่ดีในการตรวจสอบความถูกต้องของที่อยู่อีเมล (เช่นจากช่องใส่ของผู้ใช้) ใน Android คืออะไร? ดูเหมือนว่าorg.apache.commons.validator.routines.EmailValidatorจะไม่สามารถใช้ได้ มีห้องสมุดอื่น ๆ ที่ทำสิ่งนี้ซึ่งรวมอยู่ใน Android อยู่แล้วหรือฉันต้องใช้ RegExp หรือไม่

อย่าใช้ reg-ex

เห็นได้ชัดว่าต่อไปนี้เป็น reg-ex ที่ตรวจสอบความถูกต้องของที่อยู่อีเมลส่วนใหญ่ที่สอดคล้องกับRFC 2822 (และจะยังคงล้มเหลวในสิ่งต่าง ๆ เช่น "user@gmail.com.nospam" ตามที่จะ 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])+)\])

อาจเป็นวิธีที่ง่ายที่สุดในการตรวจสอบอีเมลเพียงแค่ส่งอีเมลยืนยันไปยังที่อยู่ที่ให้ไว้และมันก็ตีกลับแล้วมันไม่ถูกต้อง

หากคุณต้องการทำการตรวจสอบขั้นพื้นฐานบางอย่างคุณก็สามารถตรวจสอบได้ว่ามันอยู่ในแบบฟอร์ม *@*

หากคุณมีการตรวจสอบเฉพาะตรรกะทางธุรกิจบางอย่างคุณสามารถดำเนินการโดยใช้ regex เช่นต้องเป็นบัญชี gmail.com หรือบางอย่าง

ตัวเลือกอื่นคือการสร้างในรูปแบบเริ่มต้นด้วย API ระดับ 8

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

รูปแบบแหล่งที่ดูได้

หรือ

โซลูชันบรรทัดเดียวจาก @AdamvandenHoven:

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

รูปแบบถัดไปจะใช้ในจดหมาย 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}" +
          ")+"
      );

คุณสามารถใช้ฟังก์ชั่น

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

ตั้งแต่ API 8 (android 2.2) มีรูปแบบ: android.util.Patterns.EMAIL_ADDRESS http://developer.android.com/reference/android/util/Patterns.html

ดังนั้นคุณสามารถใช้มันเพื่อตรวจสอบอีเมลของคุณ:

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

ผลตอบแทนจริงถ้าอีเมลที่ถูกต้อง

UPD: รหัสแหล่งที่มาของรูปแบบนี้คือ:

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

อ้างถึง: http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/2.2_r1.1/android/util/Patterns.java

ดังนั้นคุณสามารถสร้างมันเองสำหรับความเข้ากันได้กับ API <8

เรามีเครื่องมือจับคู่รูปแบบอีเมลที่เรียบง่ายในขณะนี้

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

ใช้รหัสบรรทัดเดียวอย่างง่ายสำหรับการตรวจสอบอีเมล

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

ใช้เหมือน ...

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

นี่คือคำแนะนำของ Android Studio:

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

คุณสามารถใช้การแสดงออกปกติเพื่อทำเช่นนั้น บางสิ่งบางอย่างดังต่อไปนี้

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

String email = "xyz@xyzdomain.com";

Matcher matcher = pattern.matcher(email);

boolean matchFound = matcher.matches();

หมายเหตุ: ตรวจสอบนิพจน์ทั่วไปที่ระบุด้านบนอย่าใช้ตามที่เป็น

ใช้ android: inputType = "textEmailAddress" ดังต่อไปนี้:

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

และ:

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

คุณสามารถเขียนนามสกุล Kotlin ดังนี้:

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

แล้วเรียกมันว่าสิ่งนี้:

email.isValidEmail()

มีPatternsคลาสในแพ็คเกจandroid.utilซึ่งเป็นประโยชน์ที่นี่ ด้านล่างเป็นวิธีที่ฉันใช้ในการตรวจสอบอีเมลและอื่น ๆ อีกมากมายเสมอ

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

เรียกวิธีนี้ในที่ที่คุณต้องการตรวจสอบ ID อีเมล

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

สำหรับหุ่นยนต์ตรวจสอบอีเมลให้รูปแบบ InBuiltบางอย่างแต่รองรับเฉพาะAPI ระดับ 8 ขึ้นไป

นี่คือรหัสสำหรับใช้รูปแบบนั้นเพื่อตรวจสอบการตรวจสอบอีเมล

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

ตรวจสอบให้แน่ใจว่าหลังจากดำเนินการตามวิธีนี้คุณควรตรวจสอบว่าหากวิธีนี้คืนจริงจากนั้นคุณอนุญาตให้บันทึกอีเมลและหากวิธีนี้คืนค่าเท็จจากนั้นแสดงข้อความว่าอีเมลนั้น "ไม่ถูกต้อง"

หวังว่าคุณจะได้รับคำตอบขอบคุณ

ฉันขอแนะนำให้คุณอย่าพยายามที่จะยืนยันความถูกต้องของที่อยู่อีเมลคุณจะต้องทำงานให้มากโดยไม่มีเหตุผล

เพียงให้แน่ใจว่าสิ่งที่ป้อนจะไม่ทำลายรหัสของคุณเอง - เช่นไม่มีการเว้นวรรคหรือตัวอักษรผิดกฎหมายซึ่งอาจทำให้เกิดข้อยกเว้น

สิ่งอื่นใดที่ทำให้คุณทำงานอย่างหนักเพื่อผลตอบแทนน้อยที่สุด ...

ตรวจสอบรูปแบบที่อยู่อีเมลของคุณ 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 ขึ้นไปคุณสามารถใช้Patternsคลาสที่พร้อมใช้งานเพื่อตรวจสอบความถูกต้องของอีเมล รหัสตัวอย่าง:

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

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

โดยบังเอิญหากคุณยังสนับสนุนระดับ API น้อยกว่า 8 คุณก็สามารถคัดลอกPatterns.javaไฟล์ลงในโครงการของคุณและอ้างอิงได้ คุณสามารถรับซอร์สโค้ดได้Patterns.javaจากลิงค์นี้

ที่นี่คือ 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 จะจับคู่ถ้า

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

ตัวอย่างอีเมลการจับคู่แบบพิเศษ

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

คุณสามารถแก้ไขรูปแบบนี้สำหรับกรณีของคุณจากนั้นตรวจสอบโดย

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

ลองวิธีการง่ายๆที่ไม่สามารถยอมรับที่อยู่อีเมลที่ขึ้นต้นด้วยตัวเลข:

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

ลองใช้รหัสนี้ .. มันใช้งานได้จริง ..

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

ฉันใช้งานต่อไปนี้ อย่างไรก็ตามมันมีอักขระพิเศษมากกว่าอีเมลปกติ แต่นี่เป็นข้อกำหนดสำหรับฉัน

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

คำตอบของคำถามนี้: - ความต้องการในการตรวจสอบที่อยู่อีเมลที่มีคะแนนที่กำหนด

Explanation-

1. (?!. *? .. ) "Negative Lookhead" เพื่อลบ 2 จุดติดต่อกัน
2. [A-Za-z0-9.! # \ $ \% \ & \ '* + - / \ = \? \ ^ _ `{\ |} \ ~] + กำหนดอย่างน้อยหนึ่งตัวอักษร ("\" ใช้เพื่อหลบหนี)
3. @ อาจมี "@" หนึ่งรายการ
4. [A-Za-z0-9] + จากนั้นกำหนดอย่างน้อยหนึ่งตัวอักษร
5. [A-Za-z0-9 -.] * เป็นศูนย์หรือมีการทำซ้ำอักขระใด ๆ
6. [A-Za-z0-9] + อย่างน้อยหนึ่งตัวอักษรหลังจากจุด

กุญแจสำคัญในที่นี้คือคุณต้องการตรวจสอบที่อยู่อีเมลทั้งหมด คุณไม่เพียงต้องการตรวจสอบความถูกต้องทางไวยากรณ์คุณต้องการตรวจสอบว่าที่อยู่อีเมลเป็นของจริงหรือไม่

สาเหตุที่ชัดเจนสองประการ:ผู้ใช้จริงมักพิมพ์ที่อยู่อีเมลผิดและผู้ใช้บางรายอาจใส่ที่อยู่อีเมลปลอม ดังนั้นคุณต้องการตรวจสอบวากยสัมพันธ์และตรวจสอบการมีอยู่

วิธีที่ดีที่สุดในการทำสิ่งนี้ที่ฉันได้พบบน Android คือการใช้Cloudmersive Validation APIฟรีสำหรับสิ่งนี้

รหัสมีลักษณะดังนี้:

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

ฉันใช้สิ่งนี้ในแอพทั้งหมดของฉันและมันยอดเยี่ยมเพราะฉันสามารถตรวจสอบที่อยู่อีเมลในUX ได้ตั้งแต่ต้น

วิธีแก้ปัญหา Kotlin ที่ง่ายที่สุดโดยใช้ฟังก์ชันส่วนขยาย:

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

และจากนั้นคุณสามารถตรวจสอบเช่นนี้

"testemail6589@gmail.com".isEmailValid()

โปรดทราบว่านิพจน์ทั่วไปส่วนใหญ่ไม่ถูกต้องสำหรับชื่อโดเมนสากล (IDN) และโดเมนระดับบนสุดใหม่เช่น. mobi หรือ. info (หากคุณตรวจสอบรหัสประเทศหรือ. org, .com, .gov เป็นต้น)

การตรวจสอบที่ถูกต้องควรแยกส่วนโลคัล (ก่อนเครื่องหมาย at) และส่วนโดเมน คุณควรพิจารณาความยาวสูงสุดของชิ้นส่วนและโดเมนท้องถิ่น (รวม 255 chars รวมถึง at-sign)

วิธีที่ดีที่สุดคือการแปลงที่อยู่ในรูปแบบที่เข้ากันได้กับ IDN (ถ้าจำเป็น) ตรวจสอบชิ้นส่วนในพื้นที่ (RFC) ตรวจสอบความยาวของที่อยู่และตรวจสอบความพร้อมใช้งานของโดเมน (การค้นหา DNS MX) หรือเพียงส่งอีเมล .

ชั้น Linkify มีวิธีการช่วยเหลือที่มีประโยชน์ซึ่งอาจมีความเกี่ยวข้องรวมถึงนิพจน์ทั่วไปที่ออกแบบมาเพื่อรับหมายเลขโทรศัพท์และที่อยู่อีเมลและเช่น:

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

ฉันใช้รหัส follwing แล้วมันทำงานได้ดีมากฉันหวังว่านี่จะช่วยคุณได้

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

และใช้วิธีการ follwing ผลตอบแทนจริงถ้าอีเมลถูกต้อง

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

อีเมล์คืออีเมลของคุณ

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

    }

สำหรับคนรัก regex รูปแบบอีเมลที่ดีที่สุด (เช่นสอดคล้องกับ RFC 822) ที่ฉันพบตั้งแต่ตอนนี้เป็นดังต่อไปนี้ ฉันเดาว่ามันง่ายที่จะแปลเป็น Java - สำหรับผู้ที่เล่นกับ 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 ;
}

คุณสามารถทำการตรวจสอบความถูกต้องในรูปแบบ Android ได้อย่างง่ายดายโดยไฟล์ Oval.jar OVal เป็นกรอบการตรวจสอบวัตถุประสงค์ทั่วไปที่ใช้งานได้จริงและขยายได้สำหรับวัตถุ Java ชนิดใด ๆ

ตามลิงค์นี้: http://oval.sourceforge.net/userguide.html

คุณสามารถดาวน์โหลดได้ที่นี่: http://oval.sourceforge.net/userguide.html#download

คุณสามารถใช้การตรวจสอบโดยการตั้งค่าแท็กในตัวแปร

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

คุณสามารถใช้

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

ถ้าอีเมลไม่ถูกต้องก็จะโยนAddressException

น่าเสียดายที่ Android ไม่รองรับ jndi-dnsแต่เพื่อให้คุณมีความคิดในการตรวจสอบอีเมลที่มีประสิทธิภาพยิ่งขึ้นคุณสามารถใช้มันเพื่อตรวจสอบความถูกต้องของโดเมนอีเมล บางทีกูรู Android จะช่วยและแสดงถ้ามีทางเลือกที่คล้ายกัน ... การใช้ตัวอย่างด้วย java "ปกติ" สามารถใช้ได้ที่นี่

แก้ไข

ฉันเพิ่งตระหนักว่า javax.mail ไม่ได้สนับสนุนค่า ... แต่การโพสต์นี้แสดงให้เห็นวิธีแก้ปัญหา