이메일 주소를 어떻게 확인해야합니까?

Android에서 이메일 주소 (예 : 사용자 입력 필드)를 확인하는 좋은 방법은 무엇입니까? org.apache.commons.validator.routines.EmailValidator 를 사용할 수없는 것 같습니다. Android에 이미 포함되어 있거나 RegExp를 사용해야하는 다른 라이브러리가 있습니까?

정규식을 사용하지 마십시오.

다음은 RFC 2822 를 준수하는 대부분의 전자 우편 주소를 올바르게 확인하는 정규식입니다 (org.apache.commons.validator와 마찬가지로 "user@gmail.com.nospam"와 같은 경우에는 여전히 실패 함). 루틴 .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])+)\])

제공된 주소로 확인 이메일을 보내기 위해 이메일을 검증하는 가장 쉬운 방법 일 수 있으며 반송 된 다음 유효하지 않습니다.

기본 검사를 수행하려는 경우 양식에 있는지 확인할 수 있습니다. *@*

비즈니스 로직 별 유효성 검사가있는 경우 정규식을 사용하여 수행 할 수 있습니다 (예 : 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입니다.

따라서이를 사용하여 yourEmailString의 유효성을 검사 할 수 있습니다.

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

이메일이 유효하면 true를 반환

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

이 메소드를 실행 한 후이 메소드가 true 를 리턴 하면 이메일을 저장할 수 있고이 메소드가 false를 리턴하는지 확인해야합니다. 를 하면 이메일이 "Invalid"라는 메시지를 표시 .

답변을 받으시기 바랍니다. 감사합니다.

이메일 주소를 '확인'하지 말 것을 강력하게 권유 할 수 있습니까? 정당한 이유없이 많은 일을하게 될 것입니다.

입력 한 내용이 자신의 코드를 손상시키지 않도록하십시오 (예 : 공백이나 불법 문자가 없어 예외를 일으킬 수 있음).

다른 것들은 최소한의 수익을 위해 많은 일을 일으킬 것입니다 ...

이메일 주소 형식을 확인하십시오. 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();
}

우연히 8 미만의 API 레벨을 지원하는 경우 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();
}

이 질문에 대한 답변 :- 주어진 포인트로 이메일 주소를 확인하기위한 요구 사항

설명-

1. (?!. *? ..) "네거티브 룩 헤드"는 연속 된 2 개의 점을 무효화합니다.
2. [A-Za-z0-9.! # \ $ \ % \ & \ '* +-/ \ = \? \ ^ _`{\ |} \ ~] + 한 문자 만 정의됩니다. ( "\"는 이스케이프에 사용됩니다).
3. @ "@"가 하나있을 수 있습니다.
4. 그런 다음 [A-Za-z0-9] +는 하나의 문자 만 정의합니다.
5. [A-Za-z0-9-.] * 0 또는 반복되는 문자 정의.
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 부호 앞)과 도메인 부분을 구분해야합니다. 또한 로컬 부분과 도메인의 최대 길이 (at-sign 포함 255 자)를 고려해야합니다.

가장 좋은 방법은 주소를 IDN 호환 형식 (필요한 경우)으로 변환하고, 로컬 부분 (RFC)을 확인하고, 주소 길이와 도메인의 가용성 (DNS MX 조회)을 확인하거나 전자 메일을 보내는 것입니다. .

Linkify 클래스에는 전화 번호와 전자 메일 주소 등을 가져 오도록 설계된 정규식을 비롯하여 관련이있을 수있는 매우 유용한 도우미 메서드가 있습니다.

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

나는 다음 코드를 사용했다.

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

이메일이 유효하면 true를 반환합니다.

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

    }

정규 표현식 애호가들에게, 지금까지 내가 찾은 최고의 (예 : RFC 822로 구성되는) 이메일 패턴은 다음과 같습니다 (PHP 제공 필터 이전). 나는 API <8을 사용하는 사람들을 위해 이것을 Java로 쉽게 변환 할 수 있다고 생각합니다.

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 파일을 사용하면 Android에서 모든 유형의 유효성 검사를 매우 쉽게 수행 할 수 있습니다. 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를 지원하지 않지만 보다 강력한 이메일 유효성 검사에 대한 아이디어를 제공하기 위해 이메일 도메인을 유효성 검사하는 데 사용할 수 있습니다. 어쩌면 안드로이드 전문가가 비슷한 대안이 있는지 보여주고 도움을 줄 수있을 것입니다 ... "regular"java를 사용한 예제 구현 은 여기에 있습니다. .

편집하다

방금 javax.mail이 지원되지 않는다는 것을 깨달았습니다 ... 그러나이 게시물은 해결 방법을 보여줍니다 .