首页 文章

什么是最好的Java电子邮件地址验证方法? [关闭]

提问于
浏览
248

Java有哪些好的电子邮件地址验证库? commons validator还有其他选择吗?

19 回答

  • 7

    使用official java email package是最简单的:

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

    Apache Commons通常被称为一个可靠的项目 . 但请记住,如果您想确保它是真实的电子邮件,并且所有者希望在您的网站上使用该电子邮件,那么您仍需要向该地址发送验证电子邮件 .

    编辑:有一个错误,它在域上限制太多,导致它不接受来自新TLD的有效电子邮件 . 这个错误在03 / Jan / 15 02:48在commons-validator版本1.4.1中解决

  • 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);
    
  • 21

    迟到的答案,但我认为这很简单,值得:

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

    Test Cases

    enter image description here

    出于 生产环境 目的,域名验证应以网络方式执行 .

  • -2

    如果您正在尝试从客户端收到表单验证,或者只是进行bean验证 - 请保持简单 . 最好是进行松散的电子邮件验证,而不是做一个严格的电子邮件验证并拒绝某些人(例如,当他们尝试注册您的Web服务时) . 几乎所有允许在电子邮件的用户名部分和每个月都添加的许多新域名(例如.company,.entreprise,.estate),更安全的不限制:

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

    问题的后期,这里,但是:我在这个地址维持一个 class :http://lacinato.com/cm/software/emailrelated/emailaddress

    它基于Les Hazlewood的课程,但有许多改进并修复了一些错误 . Apache许可证 .

    我相信它是Java中功能最强大的电子邮件解析器,我还没有看到任何一种语言的能力,尽管可能有一种语言 . 它不是lexer风格的解析器,但使用了一些复杂的java正则表达式,因此效率不高,但是我的公司用它解析了超过100亿个真实地址:它当然可用于高性能情况 . 也许每年一次,它会打到一个地址,导致正则表达式堆栈溢出(适当),但这些是垃圾邮件地址,数百或数千个字符长,有许多引号和括号等 .

    RFC 2822和相关的规格在电子邮件地址方面确实非常宽松,所以像这样的类对于大多数用途来说都是过度的 . 例如,以下是合法地址,根据规范,空格和所有:

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

    没有邮件服务器允许这样做,但是这个类可以解析它(并将其重写为可用的表单) .

    我们发现现有的Java电子邮件解析器选项不够耐用(意思是,它们都不能解析一些有效的地址),所以我们创建了这个类 .

    代码已有详细记录,并且有许多易于更改的选项,允许或禁止某些电子邮件表单 . 它还提供了许多方法来访问地址的某些部分(左侧,右侧,个人名称,注释等),以解析/验证邮箱列表 Headers ,以解析/验证返回路径(在 Headers 中是唯一的),等等 .

    编写的代码具有javamail依赖关系,但如果您不想要它提供的次要功能,则很容易删除 .

  • 1

    我只是想知道为什么没有人从Hibernate Validator的附加约束中得出@Email . 验证器本身是EmailValidator .

  • 71

    Les Hazlewood使用Java正则表达式编写了一个非常全面的RFC 2822兼容的电子邮件验证器类 . 你可以在http://www.leshazlewood.com/?p=23找到它 . 但是,它的彻底性(或Java RE实现)会导致效率低下 - 阅读有关长地址解析时间的注释 .

  • -2

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

    还有一个有效的IDNs.xml,其中包含不同tld的正则表达式模式(太大而无法包含:)

    <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>
    
  • 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将为您提供一些帮助 . 我've found it'用于验证Intranet地址(即内部站点的电子邮件地址) . 但是对于互联网邮件服务器来说它没那么有用(参见本页顶部的警告)

  • 0

    虽然Apache公共有很多替代方案,但它们的实现方式却是如此最基本的(如Apache commons' implementation本身),甚至在其他情况下也是错误的 .

    我'd also stay away from so called simple '非限制性' regex; there'没有这样的事情 . 例如@ is allowed multiple times取决于上下文,您如何知道所需的那个?即使电子邮件应该有效,简单的正则表达也不会理解它 . 任何more complex变成error-prone甚至包含hidden performance killers . 你打算如何保持像this这样的东西?

    我所知道的唯一全面的RFC兼容的基于正则表达式的验证器是email-rfc2822-validator,其'refined'正则表达式适当地命名为Dragons.java . 它只支持较旧的RFC-2822规范,尽管它足以满足现代需求(RFC-5322 updates它已经超出了日常用例的范围) .

    really what you want is a lexer 正确解析字符串并根据RFC语法将其分解为组件结构 . EmailValidator4J在这方面似乎很有希望,但仍然年轻且有限 .

    您拥有的另一个选择是使用Web服务,例如Mailgun经过实战测试的validation webserviceMailboxlayer API(刚刚获得了第一个Google搜索结果) . 它不是严格符合RFC标准,但足以满足现代需求 .

  • -3

    你想验证什么?电子邮件地址?

    只能检查电子邮件地址的格式一致性 . 见标准:RFC2822 . 最好的方法是使用正则表达式 . 如果不发送电子邮件,您永远不会知道是否真的存在 .

    我检查了公共验证器 . 它包含一个org.apache.commons.validator.EmailValidator类 . 似乎是一个很好的起点 .

  • 134

    当前的Apache Commons Validator版本是1.3.1 .

    验证的类是org.apache.commons.validator.EmailValidator . It has an import for org.apache.oro.text.perl.Perl5Util这是一个退休的Jakarta ORO project .

    顺便说一句,我发现有一个1.4版本,here are the API docs . 在site它说:"Last Published: 05 March 2008 | Version: 1.4-SNAPSHOT",但那不是最终的 . 唯一的方法来 Build 自己(但这是一个快照,而不是RELEASE)和使用,或从here下载 . 这意味着1.4三年(2008-2011)尚未最终确定 . 这不是在Apache 's style. I' m寻找更好的选择,但没有想要发现任何错误 .

  • 1

    您可能还想查看长度 - 电子邮件最多可达254个字符 . 我使用apache commons验证器,但它没有检查这个 .

  • 7

    似乎没有任何完美的库或方法可以自己执行此操作,除非您必须时间向电子邮件地址发送电子邮件并等待响应(尽管这可能不是一个选项) . 我最终使用了这里的建议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();
    }
    
  • 261

    这是最好的方法:

    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

  • 5

    另一种选择是使用Hibernate email validator,使用注释 @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);
        }
    
    }
    
  • 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();
        }
    
    }
    

相关问题