validation email regex - Was ist die beste Validierungsmethode für Java-E-Mail-Adressen?





11 Answers

Am einfachsten ist es, das offizielle Java-E-Mail-Paket zu verwenden :

public static boolean isValidEmailAddress(String email) {
   boolean result = true;
   try {
      InternetAddress emailAddr = new InternetAddress(email);
      emailAddr.validate();
   } catch (AddressException ex) {
      result = false;
   }
   return result;
}
emailvalidator commons javax

Was sind die Bibliotheken für die Validierung von E-Mail-Adressen für Java? Gibt es Alternativen zum Commons Validator ?




Späte Antwort, aber ich denke, es ist einfach und würdig:

    public boolean isValidEmailAddress(String email) {
           String ePattern = "^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\])|(([a-zA-Z\\-0-9]+\\.)+[a-zA-Z]{2,}))$";
           java.util.regex.Pattern p = java.util.regex.Pattern.compile(ePattern);
           java.util.regex.Matcher m = p.matcher(email);
           return m.matches();
    }

Testfälle :

Zu Produktionszwecken sollten Domain-Name-Validierungen netzwerkweise durchgeführt werden.




Spät zur Frage, hier, aber: Ich unterhalte eine Klasse an dieser Adresse: http://lacinato.com/cm/software/emailrelated/emailaddress

Es basiert auf Les Hazlewoods Klasse, hat aber zahlreiche Verbesserungen und behebt einige Bugs. Apache-Lizenz.

Ich glaube, es ist der leistungsfähigste E-Mail-Parser in Java, und ich muss noch einen fähigen in jeder Sprache sehen, obwohl es einen da draußen gibt. Es ist kein Lexer-artiger Parser, sondern verwendet einige komplizierte Java-Regex und ist daher nicht so effizient, wie es sein könnte, aber meine Firma hat weit über 10 Milliarden reale Adressen damit analysiert: Es ist sicherlich in einer Hochleistung verwendbar Lage. Vielleicht einmal pro Jahr wird es eine Adresse treffen, die einen Regex-Stack-Überlauf verursacht (dies ist angemessen), aber dies sind Spam-Adressen, die Hunderte oder Tausende von Zeichen lang sind, mit vielen Anführungszeichen und Klammern und dergleichen.

RFC 2822 und die zugehörigen Spezifikationen sind in Bezug auf E-Mail-Adressen wirklich ziemlich freizügig, so dass eine Klasse wie diese für die meisten Anwendungen übertrieben ist. Zum Beispiel ist das folgende eine legitime Adresse, gemäß Spezifikation, Leerzeichen und allem:

"<bob \" (here) " < (hi there) "bob(the man)smith" (hi) @ (there) example.com (hello) > (again)

Kein Mailserver würde dies erlauben, aber diese Klasse kann es analysieren (und in ein verwendbares Formular umschreiben).

Wir haben festgestellt, dass die vorhandenen Java-E-Mail-Parseroptionen nicht ausreichend haltbar sind (das heißt, sie konnten nicht alle gültigen Adressen analysieren). Daher haben wir diese Klasse erstellt.

Der Code ist gut dokumentiert und verfügt über viele einfach zu ändernde Optionen, um bestimmte E-Mail-Formulare zuzulassen oder zu sperren. Es bietet auch eine Vielzahl von Methoden, um auf bestimmte Teile der Adresse (linke Seite, rechte Seite, persönliche Namen, Kommentare usw.) zuzugreifen, um Mailbox-Listen-Header zu analysieren / zu validieren, um den Rückpfad zu analysieren / validieren (was unter den Headern einzigartig ist) und so weiter.

Der Code, wie er geschrieben wurde, hat eine Javamail-Abhängigkeit, aber er kann leicht entfernt werden, wenn Sie die kleinere Funktionalität, die er bietet, nicht möchten.




Les Hazlewood hat eine sehr gründliche RFC 2822-konforme E-Mail-Validierungsklasse mit regulären Java-Ausdrücken geschrieben. Sie finden es unter http://www.leshazlewood.com/?p=23 . Seine Gründlichkeit (oder die Implementierung von Java RE) führt jedoch zu Ineffizienz - lesen Sie die Kommentare zu Parsing-Zeiten für lange Adressen.




public class Validations {

    private Pattern regexPattern;
    private Matcher regMatcher;

    public String validateEmailAddress(String emailAddress) {

        regexPattern = Pattern.compile("^[(a-zA-Z-0-9-\\_\\+\\.)]+@[(a-z-A-z)]+\\.[(a-zA-z)]{2,3}$");
        regMatcher   = regexPattern.matcher(emailAddress);
        if(regMatcher.matches()) {
            return "Valid Email Address";
        } else {
            return "Invalid Email Address";
        }
    }

    public String validateMobileNumber(String mobileNumber) {
        regexPattern = Pattern.compile("^\\+[0-9]{2,3}+-[0-9]{10}$");
        regMatcher   = regexPattern.matcher(mobileNumber);
        if(regMatcher.matches()) {
            return "Valid Mobile Number";
        } else {
            return "Invalid Mobile Number";
        }
    }

    public static void main(String[] args) {

        String emailAddress = "suryaprakash.pisay@gmail.com";
        String mobileNumber = "+91-9986571622";
        Validations validations = new Validations();
        System.out.println(validations.validateEmailAddress(emailAddress));
        System.out.println(validations.validateMobileNumber(mobileNumber));
    }
}



Was möchtest du bestätigen? Die E-Mail Adresse?

Die E-Mail-Adresse kann nur auf ihre Formatkonformität überprüft werden. Siehe den Standard: RFC2822 . Der beste Weg, dies zu tun, ist ein regulärer Ausdruck. Sie werden nie wissen, ob wirklich existiert, ohne eine E-Mail zu senden.

Ich überprüfte den Commons Validator. Es enthält eine org.apache.commons.validator.EmailValidator-Klasse. Scheint ein guter Ausgangspunkt zu sein.




Obwohl es viele Alternativen zu Apache-Commons gibt, sind ihre Implementierungen bestenfalls rudimentär (wie die Apache-Commons-Implementierung selbst) und in anderen Fällen sogar falsch.

Ich würde mich auch von sogenannten einfachen, nicht einschränkenden Regexen fernhalten; Das gibt es nicht. Zum Beispiel ist @ je nach Kontext mehrmals erlaubt , woher wissen Sie, dass die erforderliche vorhanden ist? Einfache Regex wird es nicht verstehen, obwohl die E-Mail gültig sein sollte. Alles Komplexere wird error-prone oder enthält sogar versteckte Performance-Killer . Wie werden Sie so etwas beibehalten?

The only comprehensive RFC compliant regex based validator I'm aware of is email-rfc2822-validator with its 'refined' regex appropriately named Dragons.java . It supports only the older RFC-2822 spec though, although appropriate enough for modern needs (RFC-5322 updates it in areas already out of scope for daily use cases).

But really what you want is a lexer that properly parses a string and breaks it up into the component structure according to the RFC grammar. EmailValidator4J seems promising in that regard, but is still young and limited.

Another option you have is using a webservice such as Mailgun's battle-tested validation webservice or Mailboxlayer API (just took the first Google results). It is not strictly RFC compliant, but works well enough for modern needs.




There don't seem to be any perfect libraries or ways to do this yourself, unless you have to time to send an email to the email address and wait for a response (this might not be an option though). I ended up using a suggestion from here http://blog.logichigh.com/2010/09/02/validating-an-e-mail-address/ and adjusting the code so it would work in Java.

public static boolean isValidEmailAddress(String email) {
    boolean stricterFilter = true; 
    String stricterFilterString = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,4}";
    String laxString = ".+@.+\\.[A-Za-z]{2}[A-Za-z]*";
    String emailRegex = stricterFilter ? stricterFilterString : laxString;
    java.util.regex.Pattern p = java.util.regex.Pattern.compile(emailRegex);
    java.util.regex.Matcher m = p.matcher(email);
    return m.matches();
}



Heres my pragmatic approach, where I just want reasonable distinct blah@domain addresses using the allowable characters from the RFC. Addresses must be converted to lowercase beforehand.

public class EmailAddressValidator {

    private static final String domainChars = "a-z0-9\\-";
    private static final String atomChars = "a-z0-9\\Q!#$%&'*+-/=?^_`{|}~\\E";
    private static final String emailRegex = "^" + dot(atomChars) + "@" + dot(domainChars) + "$";
    private static final Pattern emailPattern = Pattern.compile(emailRegex);

    private static String dot(String chars) {
        return "[" + chars + "]+(?:\\.[" + chars + "]+)*";
    }

    public static boolean isValidEmailAddress(String address) {
        return address != null && emailPattern.matcher(address).matches();
    }

}



public void EmailCheck(View v) // This is pattern method import by regular class
{
    String str = "";
    emailid = emailID.getText().toString();

    if(emailid.equalsIgnoreCase(str))
    {
        System.out.println("Please enter your email id");
     }
    else
    {
        Pattern p =Pattern.compile("[a-zA-Z0-9_.]*@[a-zA-Z]*.[a-zA-Z]*");
        Matcher m = p.matcher(emailid);
        boolean bm = m.matches();

        if(bm == true)
        {
            System.out.println("email id is valid");

        }
        else
        {
            System.out.println("email id is Invalid, Re-try again");

        }
    }
}



/*to validate email id without using regex and packages and followed by your validate symbol and domain extensions u can add ... on below try1,holly methods */

import java.util.Scanner;
public test extends Exception
{
}
public class demo extends test
{
    public static boolean try1(char s)
    {
        boolean k = false;
         char[] d={'-','_','.'};//add valid Symbols
         for(int i=0;i<d.length;i++)
         {

             if( s==d[i])
             {
               k=true; 
             }
         }

        return k; 
    }
    public static boolean holly(String s) throws test
    {
         int i=s.lastIndexOf(".");
         int j=s.length();
         String o=s.substring(i+1,j);
         boolean d=false;
         String[] g={"co","in","com","org","net"};//add domain name extenstions
        for(int k=0;k<g.length;k++)
        {
            if(g[k].equals(o))
            {

                d=true;

            }
        }

        if(d==false)
        {
            throw new test();
        }
        return d;

    }
    public static void main(String[] args)
    {
        try
        {
          Scanner s=new Scanner(System.in);
          System.out.println("enter the email no of.id ");
           int n=s.nextInt();
           String[] id=new String[n];
            for(int i=0;i<n;i++)
             {
                 int l=0;
               id[i]=s.next();
               int c=1,c1=0;
                for(int k=c1;k<c;k++)
                    {
                        String b=id[k].toLowerCase();
                        boolean l1=holly(b);
                        if(id[k]==b)
                            {
                            System.out.println(b);
                            }
                    }c1++;
                      int x = 0;
                int count=0,count1=0;
                 char[] a=id[i].toCharArray();
                int g=0;
                 for(int j=0;j<a.length;j++)
                     {

                       if(Character.isLetterOrDigit(a[j]))
                        {
                         }
                       else     
                           {
                              if(a[j]=='@')
                               {
                                count++; 
                             }                       

                         else  
                             {
                              if(Character.isLetterOrDigit(a[j+1]))
                              {

                              }
                              else
                                  throw new test();
                             if(count==1)
                                {
                                  if(a[j]=='.')
                                   {
                                     l++; 
                                    }
                                 }
                              boolean z=try1(a[j]);

                                if(z==true)
                                {
                                }
                                else
                                    g=1;


                               }
                             }

                     }
                                     if(g==1)
                                       {
                                           throw new test();
                                       }
                                    if(count==0)
                                        {
                                            throw new test(); 
                                        }
                                    else if(count==2)
                                    {
                                        throw new test(); 
                                    }



                                    if(l==0)
                                        {
                                            throw new test(); 
                                        }
                    c++;


             }

    }
        catch(test ex)
        {
            System.out.println("enter the id is not correct");
        }
    }
}





Related