最高のJavaメールアドレス検証方法は何ですか?[閉まっている]


247

Javaに適した電子メールアドレス検証ライブラリは何ですか?コモンズバリデーターに代わるものはありますか?


15
私はこれをここに置いておきます:davidcelis.com/blog/2012/09/06/…– mpenkov '30
10/30


包括的な検証を行わないライブラリ(または正規表現)を使用したくないはずです。有効な電子メールアドレスは複雑であるため、検証なしと包括的な検証の中間点はありません。Apache Commonsの実装は包括的ではありません。私は1つのライブラリ(email-rfc2822-validator)のみを認識していますが、それでも巨大な正規表現で動作します。包括的なレクサーは本当に必要なものです。EmailValidator4Jはそれを行うと言いますが、私はそれについての経験がありません。
ベニーボッテマ2017

1
@BennyBottemaコメント付きで質問を編集する代わりに、まだ質問がある場合にこれが閉じられた理由を議論するためにメタ投稿を作成してください。
Machavity

回答:


134

Apache Commonsは、一般に堅実なプロジェクトとして知られています。ただし、実際のメールであり、所有者がサイトでの使用を希望していることを確認するには、そのアドレスに確認メールを送信する必要があります。

編集:ドメインで制限が多すぎて、新しいTLDからの有効な電子メールを受け入れないというバグがありました。

このバグはcommons-validatorバージョン1.4.1の03 / Jan / 15 02:48に解決されました


1
引用した追加の部分には同意しますが、それらはCommons Validationプロジェクトの一部ですか?
duffymo 2009年

2
いいえ、Apache EmailValidatorクラスは確認のために電子メールメッセージを送信しません。
マシューFlaschen

3
ユースケースがユーザーのリモートメールアドレスの検証である場合、このソリューションにはかなりの欠陥があります(InternetAddress.validate()と同様)。EmailValidatorはuser @ [10.9.8.7]を有効なメールアドレスと見なします。 RFC。ただし、ユーザー登録/連絡フォーム用ではない可能性があります。
zillion1 '10 / 10/05

1
Apache Commonsに記載されている@zillion:「この実装は、メールアドレスで発生する可能性のあるすべてのエラーをキャッチすることを保証されていません。」そして、私はあなたが「それが本当の電子メールであることを保証する」ために何をしなければならないかについて述べました。ただし、ローカルIPを使用するアドレスは、まれな環境では有効です。
Matthew Flaschen、2011年

5
Apache Commons EmailValidatorには、IDNをサポートしないという重大な欠点が1つあります。
ピオヘン2014年

261

公式のjavaメールパッケージを使用するのが最も簡単です。

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

59
InternetAddress.validate()は、user @ [10.9.8.7]とuser @ localhostを有効な電子メールアドレスと見なすことに注意してください。これらはRFCに従っています。ただし、ユースケース(Webフォーム)によっては、それらを無効なものとして扱いたい場合があります。
zillion1 '10 / 10/05

8
@ zillion1が言ったようにそれは有効であるだけでなく、bla @ blaのようなものも有効と見なされます。本当に最善の解決策ではありません。
Diego Plentz、2012年

4
@NicholasTolleyCottrellこれはJavaです。ここで例外をスローしてキャッチしますが、私は本当にあなたのポイントを
理解

17
InternetAddressコンストラクターが改ざんされていると思います。または、私のシステムが改ざんされています。またはRFC822が改ざんされています。それとも、今は本当に睡眠を使うことができます。しかし、私はいくつかのコードを試したところ、次の5つの文字列はすべてInternetAddressコンストラクターに渡した場合にすべて有効な電子メールアドレスとして渡され、「明らかに」無効です。:ここでは行く..comcom.abc123。また、先頭または末尾の空白を追加しても、文字列は無効になりません。あなたは裁判官になります!
マーティンアンダーソン

4
ええと、チーズを実行すると正しく機能しません。地獄のjavax.mailライブラリは何にリンクしていますか?
アーロンデビッドソン

91

他の回答で述べたように、Apache Commonsバリデーターを使用できます。

pom.xml:

<dependency>
    <groupId>commons-validator</groupId>
    <artifactId>commons-validator</artifactId>
    <version>1.4.1</version>
</dependency>

build.gradle:

compile 'commons-validator:commons-validator:1.4.1'

インポート:

import org.apache.commons.validator.routines.EmailValidator;

コード:

String email = "myName@example.com";
boolean valid = EmailValidator.getInstance().isValid(email);

ローカルアドレスを許可する

boolean allowLocal = true;
boolean valid = EmailValidator.getInstance(allowLocal).isValid(email);

2
Android Studioでは、コンパイル 'commons-validator:commons-validator:1.4.1'をapp \ build.gradleの依存関係に追加できます{}
Benjiko99

2
実際にプロジェクトをビルドしようとした後、Apache CommonsはAndroidではうまく機能せず、何百もの警告といくつかのエラーがあり、コンパイルもできませんでした。これが、howtodoinjava.com
2014/11/11 /

1
Benjiko99と同じ問題。依存関係を追加し、プロジェクトの文句を言わないのコンパイル後に、ゼロ以外の終了コード2でのjava.exe完成言う
アミット・ミッタル

1
Android Studioでもエラーが発生しました。1.4.1から1.5.1に変更しましたが、うまくいきます!
Matt

1
注:org.apache.commons.validatorのEmailValidatorが非推奨となっているため(私は1.6 commons Validatorを使用しています)
HopeKing

71

遅い答えですが、シンプルで価値があると思います。

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

テストケース

ここに画像の説明を入力してください

本番環境では、ドメイン名の検証はネットワークごとに実行する必要があります。


40
これは、IDNと一緒にほとんどのRFCルールを無視する非常に残酷に単純化したバリデーターです。私はこれをすべての製品品質のアプリで回避します。
mlaccetti 2014年

1
me@company.co.ukは無効になります...
Alexander Burakevych 2014年

14
RFCの対象となるものに対して、独自の正規表現ベースのバリデーターをロールバックしないでください。
Josh Glover

6
ときどきパンクするタイヤを気にしない限り、ホイールの再発明は問題ありません
dldnh

それは良いことですが、すべての場合に適しているわけではありません。
Andrain 2018

21

クライアントから受け取ったフォームの検証、または単にBeanの検証を行う場合は、シンプルにしてください。厳密な検証を行って一部のユーザーを拒否するよりも、緩やかなメール検証を行うことをお勧めします(たとえば、Webサービスに登録しようとしている場合)。電子メールのユーザー名部分で許可されているほとんどすべてと非常に多くの新しいドメイン(例:.company、.entreprise、.estate)が文字通り毎月追加されるため、制限しない方が安全です。

Pattern pattern = Pattern.compile("^.+@.+\\..+$");
Matcher matcher = pattern.matcher(email);

3
これは本当に良い点です。合理的なアプリには、とにかくこの入力が悪用されるのを防ぐための他の手段が必要です
jmaculate

4
末尾のドットを避けるために、「^。+ @。+(\\。[^ \\。] +)+ $」に変更してみませんか?
Xingang Huang

7

ここで質問に遅れますが、私はこのアドレスでクラスを維持しています:http : //lacinato.com/cm/software/emailrelated/emailaddress

Les Hazlewoodのクラスに基づいていますが、多数の改善といくつかのバグの修正が行われています。Apacheライセンス。

私はそれがJavaで最も有能な電子メールパーサーであると信じています、そしてそれがそこにあるかもしれませんが、私はどの言語でももう1つ有能なものをまだ見ていません。これはレクサースタイルのパーサーではありませんが、いくつかの複雑なJava正規表現を使用しているため、効率が良くありませんが、私の会社では100億を超える実際のアドレスを解析してきました。これは確かに高性能で使用できます。状況。おそらく年に1回、正規表現のスタックオーバーフローを引き起こすアドレスに(適切に)ヒットしますが、これらは数百または数千文字の長さのスパムアドレスであり、引用符やかっこなどが多数含まれています。

RFC 2822と関連する仕様は、電子メールアドレスに関しては非常に許容範囲が広いため、このようなクラスはほとんどの用途にとって過剰です。たとえば、仕様、スペース、およびすべてによると、以下は正当なアドレスです。

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

メールサーバーはそれを許可しませんが、このクラスはそれを解析できます(そしてそれを使用可能な形式に書き換えます)。

既存のJavaメールパーサーオプションは耐久性が不十分であることがわかったため(すべてのオプションが一部の有効なアドレスを解析できなかったため)、このクラスを作成しました。

コードは十分に文書化されており、特定の電子メールフォームを許可または禁止するための変更しやすいオプションが多数あります。また、アドレスの特定の部分(左側、右側、個人名、コメントなど)にアクセスし、メールボックスリストヘッダーを解析/検証し、return-pathを解析/検証するための多くのメソッドも提供します(ヘッダー間で一意です)など。

記述されたコードにはjavamailの依存関係がありますが、コードが提供するマイナーな機能が必要ない場合は簡単に削除できます。


1
こんにちは、オープンソースコミュニティを公開するためにGitHubにコピーしました。これで、誰もがコードのコメント、文書化、改善を行うことができます。github.com/bbottema/email-rfc2822-validator。私はLesにより古いバージョンを使用するために使用されるが、私は原因正規表現凍結バグにそれを削除する必要がありました:leshazlewood.com/2006/11/06/emailaddress-java-class/...
ベニーBottemaに

7

@EmailHibernate Validatorの追加の制約から誰も思いついなかったのはなぜだろうと思います。バリデーター自体はEmailValidatorです。


Apacheコモンズに代わるものですが、その実装はほとんどの正規表現ベースのライブラリと同様に初歩的です。ドキュメントから:「ただし、この記事で説明するように、100%準拠の電子メール検証ツールを実装することは必ずしも実用的ではありません」。私が知っている唯一の正規表現ベースの包括的なバリデーターはemail-rfc2822-validatorです。それ以外の場合、EmailValidator4Jは有望なようです。
ベニーボッテマ2017

5

Les Hazlewoodは、Java正規表現を使用して、完全にRFC 2822に準拠した電子メール検証クラスを作成しました。あなたはでそれを見つけることができますhttp://www.leshazlewood.com/?p=23。ただし、その完全性(またはJava RE実装)は非効率につながります。長いアドレスの解析時間に関するコメントを読んでください。


1
Les Hazlewoodの優れたクラス(いくつかのバグはあります)に基づいて構築しました。(この質問に対する別の回答を参照してください。)Java regexメソッドは維持しましたが、パフォーマンスが重要な環境では問題なく使用できます。あなたがしているすべてがアドレスの解析である場合、パフォーマンスが問題になる可能性がありますが、ほとんどのユーザーにとって、それは彼らがしていることの始まりにすぎないと思います。クラスの更新により、多くの長い再帰の問題も修正されました。
lacinato 2012年

これは古いライブラリであり、2回、最後にemail-rfc2822-validatorに置き換えられました。それはまだすべての現代のニーズに適合しますが、それでも隠れたパフォーマンスのバグが発生する傾向があります(新しいRFC仕様による限定された変更をサポートしていません)。
ベニーボッテマ2017

3

Zend_Validator_Emailのコードの一部を移植しました。

@FacesValidator("emailValidator")
public class EmailAddressValidator implements Validator {

    private String localPart;
    private String hostName;
    private boolean domain = true;

    Locale locale;
    ResourceBundle bundle;

    private List<FacesMessage> messages = new ArrayList<FacesMessage>();

    private HostnameValidator hostnameValidator;

    @Override
    public void validate(FacesContext context, UIComponent component, Object value) throws ValidatorException {
        setOptions(component);
        String email    = (String) value;
        boolean result  = true;
        Pattern pattern = Pattern.compile("^(.+)@([^@]+[^.])$");
        Matcher matcher = pattern.matcher(email);

        locale = context.getViewRoot().getLocale();
        bundle = ResourceBundle.getBundle("com.myapp.resources.validationMessages", locale);

        boolean length = true;
        boolean local  = true;

        if (matcher.find()) {
            localPart   = matcher.group(1);
            hostName    = matcher.group(2);

            if (localPart.length() > 64 || hostName.length() > 255) {
                length          = false;
                addMessage("enterValidEmail", "email.AddressLengthExceeded");
            } 

            if (domain == true) {
                hostnameValidator = new HostnameValidator();
                hostnameValidator.validate(context, component, hostName);
            }

            local = validateLocalPart();

            if (local && length) {
                result = true;
            } else {
                result = false;
            }

        } else {
            result          = false;
            addMessage("enterValidEmail", "invalidEmailAddress");
        }

        if (result == false) {
            throw new ValidatorException(messages);
        }

    }

    private boolean validateLocalPart() {
        // First try to match the local part on the common dot-atom format
        boolean result = false;

        // Dot-atom characters are: 1*atext *("." 1*atext)
        // atext: ALPHA / DIGIT / and "!", "#", "$", "%", "&", "'", "*",
        //        "+", "-", "/", "=", "?", "^", "_", "`", "{", "|", "}", "~"
        String atext = "a-zA-Z0-9\\u0021\\u0023\\u0024\\u0025\\u0026\\u0027\\u002a"
                + "\\u002b\\u002d\\u002f\\u003d\\u003f\\u005e\\u005f\\u0060\\u007b"
                + "\\u007c\\u007d\\u007e";
        Pattern regex = Pattern.compile("^["+atext+"]+(\\u002e+["+atext+"]+)*$");
        Matcher matcher = regex.matcher(localPart);
        if (matcher.find()) {
            result = true;
        } else {
            // Try quoted string format

            // Quoted-string characters are: DQUOTE *([FWS] qtext/quoted-pair) [FWS] DQUOTE
            // qtext: Non white space controls, and the rest of the US-ASCII characters not
            //   including "\" or the quote character
            String noWsCtl = "\\u0001-\\u0008\\u000b\\u000c\\u000e-\\u001f\\u007f";
            String qText = noWsCtl + "\\u0021\\u0023-\\u005b\\u005d-\\u007e";
            String ws = "\\u0020\\u0009";

            regex = Pattern.compile("^\\u0022(["+ws+qText+"])*["+ws+"]?\\u0022$");
            matcher = regex.matcher(localPart);
            if (matcher.find()) {
                result = true;
            } else {
                addMessage("enterValidEmail", "email.AddressDotAtom");
                addMessage("enterValidEmail", "email.AddressQuotedString");
                addMessage("enterValidEmail", "email.AddressInvalidLocalPart");
            }
        }

        return result;
    }

    private void addMessage(String detail, String summary) {
        String detailMsg = bundle.getString(detail);
        String summaryMsg = bundle.getString(summary);
        messages.add(new FacesMessage(FacesMessage.SEVERITY_ERROR, summaryMsg, detailMsg));
    }

    private void setOptions(UIComponent component) {
        Boolean domainOption = Boolean.valueOf((String) component.getAttributes().get("domain"));
        //domain = (domainOption == null) ? true : domainOption.booleanValue();
    }
}

次のようにホスト名バリデータを使用します。

@FacesValidator("hostNameValidator")
public class HostnameValidator implements Validator {

    private Locale locale;
    private ResourceBundle bundle;
    private List<FacesMessage> messages;
    private boolean checkTld = true;
    private boolean allowLocal = false;
    private boolean allowDNS = true;
    private String tld;
    private String[] validTlds = {"ac", "ad", "ae", "aero", "af", "ag", "ai",
        "al", "am", "an", "ao", "aq", "ar", "arpa", "as", "asia", "at", "au",
        "aw", "ax", "az", "ba", "bb", "bd", "be", "bf", "bg", "bh", "bi", "biz",
        "bj", "bm", "bn", "bo", "br", "bs", "bt", "bv", "bw", "by", "bz", "ca",
        "cat", "cc", "cd", "cf", "cg", "ch", "ci", "ck", "cl", "cm", "cn", "co",
        "com", "coop", "cr", "cu", "cv", "cx", "cy", "cz", "de", "dj", "dk",
        "dm", "do", "dz", "ec", "edu", "ee", "eg", "er", "es", "et", "eu", "fi",
        "fj", "fk", "fm", "fo", "fr", "ga", "gb", "gd", "ge", "gf", "gg", "gh",
        "gi", "gl", "gm", "gn", "gov", "gp", "gq", "gr", "gs", "gt", "gu", "gw",
        "gy", "hk", "hm", "hn", "hr", "ht", "hu", "id", "ie", "il", "im", "in",
        "info", "int", "io", "iq", "ir", "is", "it", "je", "jm", "jo", "jobs",
        "jp", "ke", "kg", "kh", "ki", "km", "kn", "kp", "kr", "kw", "ky", "kz",
        "la", "lb", "lc", "li", "lk", "lr", "ls", "lt", "lu", "lv", "ly", "ma",
        "mc", "md", "me", "mg", "mh", "mil", "mk", "ml", "mm", "mn", "mo",
        "mobi", "mp", "mq", "mr", "ms", "mt", "mu", "museum", "mv", "mw", "mx",
        "my", "mz", "na", "name", "nc", "ne", "net", "nf", "ng", "ni", "nl",
        "no", "np", "nr", "nu", "nz", "om", "org", "pa", "pe", "pf", "pg", "ph",
        "pk", "pl", "pm", "pn", "pr", "pro", "ps", "pt", "pw", "py", "qa", "re",
        "ro", "rs", "ru", "rw", "sa", "sb", "sc", "sd", "se", "sg", "sh", "si",
        "sj", "sk", "sl", "sm", "sn", "so", "sr", "st", "su", "sv", "sy", "sz",
        "tc", "td", "tel", "tf", "tg", "th", "tj", "tk", "tl", "tm", "tn", "to",
        "tp", "tr", "travel", "tt", "tv", "tw", "tz", "ua", "ug", "uk", "um",
        "us", "uy", "uz", "va", "vc", "ve", "vg", "vi", "vn", "vu", "wf", "ws",
        "ye", "yt", "yu", "za", "zm", "zw"};
    private Map<String, Map<Integer, Integer>> idnLength;

    private void init() {
        Map<Integer, Integer> biz = new HashMap<Integer, Integer>();
        biz.put(5, 17);
        biz.put(11, 15);
        biz.put(12, 20);

        Map<Integer, Integer> cn = new HashMap<Integer, Integer>();
        cn.put(1, 20);

        Map<Integer, Integer> com = new HashMap<Integer, Integer>();
        com.put(3, 17);
        com.put(5, 20);

        Map<Integer, Integer> hk = new HashMap<Integer, Integer>();
        hk.put(1, 15);

        Map<Integer, Integer> info = new HashMap<Integer, Integer>();
        info.put(4, 17);

        Map<Integer, Integer> kr = new HashMap<Integer, Integer>();
        kr.put(1, 17);

        Map<Integer, Integer> net = new HashMap<Integer, Integer>();
        net.put(3, 17);
        net.put(5, 20);

        Map<Integer, Integer> org = new HashMap<Integer, Integer>();
        org.put(6, 17);

        Map<Integer, Integer> tw = new HashMap<Integer, Integer>();
        tw.put(1, 20);

        Map<Integer, Integer> idn1 = new HashMap<Integer, Integer>();
        idn1.put(1, 20);

        Map<Integer, Integer> idn2 = new HashMap<Integer, Integer>();
        idn2.put(1, 20);

        Map<Integer, Integer> idn3 = new HashMap<Integer, Integer>();
        idn3.put(1, 20);

        Map<Integer, Integer> idn4 = new HashMap<Integer, Integer>();
        idn4.put(1, 20);

        idnLength = new HashMap<String, Map<Integer, Integer>>();

        idnLength.put("BIZ", biz);
        idnLength.put("CN", cn);
        idnLength.put("COM", com);
        idnLength.put("HK", hk);
        idnLength.put("INFO", info);
        idnLength.put("KR", kr);
        idnLength.put("NET", net);
        idnLength.put("ORG", org);
        idnLength.put("TW", tw);
        idnLength.put("ایران", idn1);
        idnLength.put("中国", idn2);
        idnLength.put("公司", idn3);
        idnLength.put("网络", idn4);

        messages = new ArrayList<FacesMessage>();
    }

    public HostnameValidator() {
        init();
    }

    @Override
    public void validate(FacesContext context, UIComponent component, Object value) throws ValidatorException {
        String hostName = (String) value;

        locale = context.getViewRoot().getLocale();
        bundle = ResourceBundle.getBundle("com.myapp.resources.validationMessages", locale);

        Pattern ipPattern = Pattern.compile("^[0-9a-f:\\.]*$", Pattern.CASE_INSENSITIVE);
        Matcher ipMatcher = ipPattern.matcher(hostName);
        if (ipMatcher.find()) {
            addMessage("hostname.IpAddressNotAllowed");
            throw new ValidatorException(messages);
        }

        boolean result = false;

        // removes last dot (.) from hostname 
        hostName = hostName.replaceAll("(\\.)+$", "");
        String[] domainParts = hostName.split("\\.");

        boolean status = false;

        // Check input against DNS hostname schema
        if ((domainParts.length > 1) && (hostName.length() > 4) && (hostName.length() < 255)) {
            status = false;

            dowhile:
            do {
                // First check TLD
                int lastIndex = domainParts.length - 1;
                String domainEnding = domainParts[lastIndex];
                Pattern tldRegex = Pattern.compile("([^.]{2,10})", Pattern.CASE_INSENSITIVE);
                Matcher tldMatcher = tldRegex.matcher(domainEnding);
                if (tldMatcher.find() || domainEnding.equals("ایران")
                        || domainEnding.equals("中国")
                        || domainEnding.equals("公司")
                        || domainEnding.equals("网络")) {



                    // Hostname characters are: *(label dot)(label dot label); max 254 chars
                    // label: id-prefix [*ldh{61} id-prefix]; max 63 chars
                    // id-prefix: alpha / digit
                    // ldh: alpha / digit / dash

                    // Match TLD against known list
                    tld = (String) tldMatcher.group(1).toLowerCase().trim();
                    if (checkTld == true) {
                        boolean foundTld = false;
                        for (int i = 0; i < validTlds.length; i++) {
                            if (tld.equals(validTlds[i])) {
                                foundTld = true;
                            }
                        }

                        if (foundTld == false) {
                            status = false;
                            addMessage("hostname.UnknownTld");
                            break dowhile;
                        }
                    }

                    /**
                     * Match against IDN hostnames
                     * Note: Keep label regex short to avoid issues with long patterns when matching IDN hostnames
                     */
                    List<String> regexChars = getIdnRegexChars();

                    // Check each hostname part
                    int check = 0;
                    for (String domainPart : domainParts) {
                        // Decode Punycode domainnames to IDN
                        if (domainPart.indexOf("xn--") == 0) {
                            domainPart = decodePunycode(domainPart.substring(4));
                        }

                        // Check dash (-) does not start, end or appear in 3rd and 4th positions
                        if (domainPart.indexOf("-") == 0
                                || (domainPart.length() > 2 && domainPart.indexOf("-", 2) == 2 && domainPart.indexOf("-", 3) == 3)
                                || (domainPart.indexOf("-") == (domainPart.length() - 1))) {
                            status = false;
                            addMessage("hostname.DashCharacter");
                            break dowhile;
                        }

                        // Check each domain part
                        boolean checked = false;

                        for (int key = 0; key < regexChars.size(); key++) {
                            String regexChar = regexChars.get(key);
                            Pattern regex = Pattern.compile(regexChar);
                            Matcher regexMatcher = regex.matcher(domainPart);
                            status = regexMatcher.find();
                            if (status) {
                                int length = 63;

                                if (idnLength.containsKey(tld.toUpperCase())
                                        && idnLength.get(tld.toUpperCase()).containsKey(key)) {
                                    length = idnLength.get(tld.toUpperCase()).get(key);
                                }

                                int utf8Length;
                                try {
                                    utf8Length = domainPart.getBytes("UTF8").length;
                                    if (utf8Length > length) {
                                        addMessage("hostname.InvalidHostname");
                                    } else {
                                        checked = true;
                                        break;
                                    }
                                } catch (UnsupportedEncodingException ex) {
                                    Logger.getLogger(HostnameValidator.class.getName()).log(Level.SEVERE, null, ex);
                                }


                            }
                        }


                        if (checked) {
                            ++check;
                        }
                    }

                    // If one of the labels doesn't match, the hostname is invalid
                    if (check != domainParts.length) {
                        status = false;
                        addMessage("hostname.InvalidHostnameSchema");

                    }
                } else {
                    // Hostname not long enough
                    status = false;
                    addMessage("hostname.UndecipherableTld");
                }

            } while (false);

            if (status == true && allowDNS) {
                result = true;
            }

        } else if (allowDNS == true) {
            addMessage("hostname.InvalidHostname");
            throw new ValidatorException(messages);
        }

        // Check input against local network name schema;
        Pattern regexLocal = Pattern.compile("^(([a-zA-Z0-9\\x2d]{1,63}\\x2e)*[a-zA-Z0-9\\x2d]{1,63}){1,254}$", Pattern.CASE_INSENSITIVE);
        boolean checkLocal = regexLocal.matcher(hostName).find();
        if (allowLocal && !status) {
            if (checkLocal) {
                result = true;
            } else {
                // If the input does not pass as a local network name, add a message
                result = false;
                addMessage("hostname.InvalidLocalName");
            }
        }


        // If local network names are not allowed, add a message
        if (checkLocal && !allowLocal && !status) {
            result = false;
            addMessage("hostname.LocalNameNotAllowed");
        }

        if (result == false) {
            throw new ValidatorException(messages);
        }

    }

    private void addMessage(String msg) {
        String bundlMsg = bundle.getString(msg);
        messages.add(new FacesMessage(FacesMessage.SEVERITY_ERROR, bundlMsg, bundlMsg));
    }

    /**
     * Returns a list of regex patterns for the matched TLD
     * @param tld
     * @return 
     */
    private List<String> getIdnRegexChars() {
        List<String> regexChars = new ArrayList<String>();
        regexChars.add("^[a-z0-9\\x2d]{1,63}$");
        Document doc = null;
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setNamespaceAware(true);

        try {
            InputStream validIdns = getClass().getClassLoader().getResourceAsStream("com/myapp/resources/validIDNs_1.xml");
            DocumentBuilder builder = factory.newDocumentBuilder();
            doc = builder.parse(validIdns);
            doc.getDocumentElement().normalize();
        } catch (SAXException ex) {
            Logger.getLogger(HostnameValidator.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(HostnameValidator.class.getName()).log(Level.SEVERE, null, ex);
        } catch (ParserConfigurationException ex) {
            Logger.getLogger(HostnameValidator.class.getName()).log(Level.SEVERE, null, ex);
        }

        // prepare XPath
        XPath xpath = XPathFactory.newInstance().newXPath();

        NodeList nodes = null;
        String xpathRoute = "//idn[tld=\'" + tld.toUpperCase() + "\']/pattern/text()";

        try {
            XPathExpression expr;
            expr = xpath.compile(xpathRoute);
            Object res = expr.evaluate(doc, XPathConstants.NODESET);
            nodes = (NodeList) res;
        } catch (XPathExpressionException ex) {
            Logger.getLogger(HostnameValidator.class.getName()).log(Level.SEVERE, null, ex);
        }


        for (int i = 0; i < nodes.getLength(); i++) {
            regexChars.add(nodes.item(i).getNodeValue());
        }

        return regexChars;
    }

    /**
     * Decode Punycode string
     * @param encoded
     * @return 
         */
    private String decodePunycode(String encoded) {
        Pattern regex = Pattern.compile("([^a-z0-9\\x2d]{1,10})", Pattern.CASE_INSENSITIVE);
        Matcher matcher = regex.matcher(encoded);
        boolean found = matcher.find();

        if (encoded.isEmpty() || found) {
            // no punycode encoded string, return as is
            addMessage("hostname.CannotDecodePunycode");
            throw new ValidatorException(messages);
        }

        int separator = encoded.lastIndexOf("-");
            List<Integer> decoded = new ArrayList<Integer>();
        if (separator > 0) {
            for (int x = 0; x < separator; ++x) {
                decoded.add((int) encoded.charAt(x));
            }
        } else {
            addMessage("hostname.CannotDecodePunycode");
            throw new ValidatorException(messages);
        }

        int lengthd = decoded.size();
        int lengthe = encoded.length();

        // decoding
        boolean init = true;
        int base = 72;
        int index = 0;
        int ch = 0x80;

        int indexeStart = (separator == 1) ? (separator + 1) : 0;
        for (int indexe = indexeStart; indexe < lengthe; ++lengthd) {
            int oldIndex = index;
            int pos = 1;
            for (int key = 36; true; key += 36) {
                int hex = (int) encoded.charAt(indexe++);
                int digit = (hex - 48 < 10) ? hex - 22
                        : ((hex - 65 < 26) ? hex - 65
                        : ((hex - 97 < 26) ? hex - 97
                        : 36));

                index += digit * pos;
                int tag = (key <= base) ? 1 : ((key >= base + 26) ? 26 : (key - base));
                if (digit < tag) {
                    break;
                }
                pos = (int) (pos * (36 - tag));
            }
            int delta = (int) (init ? ((index - oldIndex) / 700) : ((index - oldIndex) / 2));
            delta += (int) (delta / (lengthd + 1));
            int key;
            for (key = 0; delta > 910; key += 36) {
                delta = (int) (delta / 35);
            }
            base = (int) (key + 36 * delta / (delta + 38));
            init = false;
            ch += (int) (index / (lengthd + 1));
            index %= (lengthd + 1);
            if (lengthd > 0) {
                for (int i = lengthd; i > index; i--) {
                    decoded.set(i, decoded.get(i - 1));
                }
            }

            decoded.set(index++, ch);
        }

        // convert decoded ucs4 to utf8 string
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < decoded.size(); i++) {
            int value = decoded.get(i);
            if (value < 128) {
                sb.append((char) value);
            } else if (value < (1 << 11)) {
                sb.append((char) (192 + (value >> 6)));
                sb.append((char) (128 + (value & 63)));
            } else if (value < (1 << 16)) {
                sb.append((char) (224 + (value >> 12)));
                sb.append((char) (128 + ((value >> 6) & 63)));
                sb.append((char) (128 + (value & 63)));
            } else if (value < (1 << 21)) {
                sb.append((char) (240 + (value >> 18)));
                sb.append((char) (128 + ((value >> 12) & 63)));
                sb.append((char) (128 + ((value >> 6) & 63)));
                sb.append((char) (128 + (value & 63)));
            } else {
                addMessage("hostname.CannotDecodePunycode");
                throw new ValidatorException(messages);
            }
        }

        return sb.toString();

    }

    /**
     * Eliminates empty values from input array
     * @param data
     * @return 
     */
    private String[] verifyArray(String[] data) {
        List<String> result = new ArrayList<String>();
        for (String s : data) {
            if (!s.equals("")) {
                result.add(s);
            }
        }

        return result.toArray(new String[result.size()]);
    }
}

そして、さまざまなTLDの正規表現パターンを含むvalidIDNs.xml(大きすぎるため:)

<idnlist>
    <idn>
        <tld>AC</tld>
        <pattern>^[\u002d0-9a-zà-öø-ÿāăąćĉċčďđēėęěĝġģĥħīįĵķĺļľŀłńņňŋőœŕŗřśŝşšţťŧūŭůűųŵŷźżž]{1,63}$</pattern>
    </idn>
    <idn>
        <tld>AR</tld>
        <pattern>^[\u002d0-9a-zà-ãç-êìíñ-õü]{1,63}$</pattern>
    </idn>
    <idn>
        <tld>AS</tld>
        <pattern>/^[\u002d0-9a-zà-öø-ÿāăąćĉċčďđēĕėęěĝğġģĥħĩīĭįıĵķĸĺļľłńņňŋōŏőœŕŗřśŝşšţťŧũūŭůűųŵŷźż]{1,63}$</pattern>
    </idn>
    <idn>
        <tld>AT</tld>
        <pattern>/^[\u002d0-9a-zà-öø-ÿœšž]{1,63}$</pattern>
    </idn>
    <idn>
        <tld>BIZ</tld>
        <pattern>^[\u002d0-9a-zäåæéöøü]{1,63}$</pattern>
        <pattern>^[\u002d0-9a-záéíñóúü]{1,63}$</pattern>
        <pattern>^[\u002d0-9a-záéíóöúüőű]{1,63}$</pattern>
    </id>
</idlist>

この答えは明白な理由でもう適用されません。TLD検証を削除します。英語以外の電子メールアドレスを受け入れる場合は、おそらくそれで問題ありません。
Christopher Schneider

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

2

電子メールアドレスが有効かどうかを確認する場合は、VRFYを使用すると簡単にアクセスできます。イントラネットアドレス(つまり、内部サイトの電子メールアドレス)を検証するのに役立ちます。ただし、インターネットメールサーバーにはあまり役立ちません(このページの上部にある警告を参照してください)。


2

Apacheコモンズには多くの代替案がありますが、それらの実装は(Apacheコモンズの実装自体のように)せいぜい初歩的なものであり、他のケースではまったく間違っています。

私は、いわゆる単純な「非制限」正規表現も避けます。そのようなことはありません。たとえば、@はコンテキストに応じて複数回許可されますが、必要なものがあることをどのようにして知ることができますか?単純な正規表現は、電子メールが有効であるべきであるにもかかわらず、それを理解しません。何より複雑になり、エラーが発生しやすいかさえも含む隠されたパフォーマンスキラーこのようなものをどのように維持しますかますか?

私が知っている唯一の包括的なRFC準拠の正規表現ベースのバリデーターは、email-rfc2822-validatorであり、Dragons.javaという適切な名前の「洗練された」正規表現があります。ただし、最新のニーズには十分に適していますが、RFC-5322 は古いRFC-2822仕様のみをサポートしています(RFC-5322 は、日常のユースケースではすでに範囲外の領域で更新します)。

しかし、実際に必要なのは、文字列を適切に解析し、RFC文法に従ってコンポーネント構造に分解するレクサーです。EmailValidator4Jはその点で有望であるように見えますが、まだ若く制限があります。

あなたが持っている別のオプションは、Mailgunの戦いでテストされた検証WebサービスMailboxlayer APIなどのWebサービスを使用することです(最初のGoogleの結果を取得しただけです)。厳密にRFCに準拠しているわけではありませんが、現代のニーズには十分対応できます。


1

何を検証しますか?メールアドレスは?

電子メールアドレスは、フォーマットの適合性についてのみチェックできます。標準を参照してください:RFC2822。そのための最良の方法は正規表現です。メールを送信せずに本当に存在するかどうかは決してわかりません。

Commons Validatorを確認しました。org.apache.commons.validator.EmailValidatorクラスが含まれています。良い出発点のようです。


私は必ず正規表現は、それはだ、そうするための最良の方法であるわけではない、かなり読めないあなたは手紙にRFC従うつもりなら
user2813274

@ user2813274に同意すると、スパゲッティ正規表現ではなく、適切なレクサーが必要になります。
ベニーボッテマ2017

1

現在のApache Commons Validatorのバージョンは1.3.1です。

検証するクラスはorg.apache.commons.validator.EmailValidatorです。廃止されたJakarta OROプロジェクトからのorg.apache.oro.text.perl.Perl5Utilのインポートがあります。ます。

ところで、私は1.4のバージョンがあることを発見しました、ここにAPIドキュメントがあります。オンサイトそれが言う:「:2008年3月5日|バージョン:最終発行日1.4-SNAPSHOTを」、それは最終的ではありません。自分を構築する唯一の方法(ただし、これはRELEASEではなくスナップショットです)を使用するか、ここからダウンロードします。これは、1.4が3年間(2008〜2011年)確定していないことを意味します。これはApacheのスタイルではありません。より良いオプションを探していますが、非常に採用されているオプションは見つかりませんでした。十分にテストされたものを使用したい、バグにぶつからないようにしたい。


1.4 SNAPSHOTにはJakarta OROも必要です。Apache Commons Validatorは私には使えません。
ミスト

最後にDr.Vetを選びました。クンパナスフローリンのソリューション:mkyong.com/regular-expressions/…–
ミスト

1
私はApache Commonsバリデーターがうまく機能することに同意しますが、それは非常に遅い-呼び出しごとに3ms以上であることがわかりました。
Nic Cottrell、2012

パフォーマンスは私にとってそれほど重要ではありません。
ミスト

現在のトランクSNAPSHOT(現在のところSVN REV 1227719)には、OROのような外部依存関係はもうありません-検証モジュール全体はもう必要ありません-4つのクラスorg.apache.commons.validator.routines.EmailValidator、InetAddressValidator、DomainValidatorおよびRegexValidatorは一人で立つことができます
イェルク・

0

長さを確認することもできます-電子メールは最大254文字です。私はApache Commons Validatorを使用していますが、これはチェックされません。


RFC 2821種(セクション4.5.3.1)が指定local-part64との長さdomain255の長さを(彼らは長いが、他のソフトウェアによって拒否される可能性がありますによって許可されていることを言います。)
sarnold

-2

メールアドレスにメールを送信して応答を待つ必要がある場合を除いて、これを自分で行うための完璧なライブラリや方法はないようです(ただし、これはオプションではない場合があります)。私はここhttp://blog.logichigh.com/2010/09/02/validating-an-e-mail-address/からの提案を使用して 、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();
}

-2

これが最良の方法です。

public static boolean isValidEmail(String enteredEmail){
        String EMAIL_REGIX = "^[\\\\w!#$%&’*+/=?`{|}~^-]+(?:\\\\.[\\\\w!#$%&’*+/=?`{|}~^-]+)*@(?:[a-zA-Z0-9-]+\\\\.)+[a-zA-Z]{2,6}$";
        Pattern pattern = Pattern.compile(EMAIL_REGIX);
        Matcher matcher = pattern.matcher(enteredEmail);
        return ((!enteredEmail.isEmpty()) && (enteredEmail!=null) && (matcher.matches()));
    }

出典:-http: //howtodoinjava.com/2014/11/11/java-regex-validate-email-address/

http://www.rfc-editor.org/rfc/rfc5322.txt


-2

別のオプションは、アノテーションを使用するか、プログラムのようにバリデータークラスを使用して、Hibernate電子メールバリデーターを使用すること@Emailです。

import org.hibernate.validator.internal.constraintvalidators.hv.EmailValidator; 

class Validator {
    // code
    private boolean isValidEmail(String email) {
        EmailValidator emailValidator = new EmailValidator();
        return emailValidator.isValid(email, null);
    }

}

なぜ反対票か。これは、Hibernate Validatorで使用されるものと同じクラスです。
デリック2018

-3

RFCからの許可された文字を使用して、合理的な個別のblah @ domainアドレスが必要な場合の私の実用的なアプローチを示します。住所は事前に小文字に変換する必要があります。

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

}
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.