View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.commons.validator.routines;
18  
19  import java.io.Serializable;
20  import java.util.regex.Matcher;
21  import java.util.regex.Pattern;
22  
23  /**
24   * <p>Perform email validations.</p>
25   * <p>
26   * Based on a script by <a href="mailto:stamhankar@hotmail.com">Sandeep V. Tamhankar</a>
27   * http://javascript.internet.com
28   * </p>
29   * <p>
30   * This implementation is not guaranteed to catch all possible errors in an email address.
31   * </p>.
32   *
33   * @version $Revision: 1649927 $
34   * @since Validator 1.4
35   */
36  public class EmailValidator implements Serializable {
37  
38      private static final long serialVersionUID = 1705927040799295880L;
39  
40      private static final String SPECIAL_CHARS = "\\p{Cntrl}\\(\\)<>@,;:'\\\\\\\"\\.\\[\\]";
41      private static final String VALID_CHARS = "[^\\s" + SPECIAL_CHARS + "]";
42      private static final String QUOTED_USER = "(\"[^\"]*\")";
43      private static final String WORD = "((" + VALID_CHARS + "|')+|" + QUOTED_USER + ")";
44  
45      private static final String EMAIL_REGEX = "^\\s*?(.+)@(.+?)\\s*$";
46      private static final String IP_DOMAIN_REGEX = "^\\[(.*)\\]$";
47      private static final String USER_REGEX = "^\\s*" + WORD + "(\\." + WORD + ")*$";
48  
49      private static final Pattern EMAIL_PATTERN = Pattern.compile(EMAIL_REGEX);
50      private static final Pattern IP_DOMAIN_PATTERN = Pattern.compile(IP_DOMAIN_REGEX);
51      private static final Pattern USER_PATTERN = Pattern.compile(USER_REGEX);
52  
53      private final boolean allowLocal;
54  
55      /**
56       * Singleton instance of this class, which
57       *  doesn't consider local addresses as valid.
58       */
59      private static final EmailValidator EMAIL_VALIDATOR = new EmailValidator(false);
60  
61      /**
62       * Singleton instance of this class, which does
63       *  consider local addresses valid.
64       */
65      private static final EmailValidator EMAIL_VALIDATOR_WITH_LOCAL = new EmailValidator(true);
66  
67      /**
68       * Returns the Singleton instance of this validator.
69       *
70       * @return singleton instance of this validator.
71       */
72      public static EmailValidator getInstance() {
73          return EMAIL_VALIDATOR;
74      }
75  
76      /**
77       * Returns the Singleton instance of this validator,
78       *  with local validation as required.
79       *
80       * @param allowLocal Should local addresses be considered valid?
81       * @return singleton instance of this validator
82       */
83      public static EmailValidator getInstance(boolean allowLocal) {
84          if(allowLocal) {
85             return EMAIL_VALIDATOR_WITH_LOCAL;
86          }
87          return EMAIL_VALIDATOR;
88      }
89  
90      /**
91       * Protected constructor for subclasses to use.
92       *
93       * @param allowLocal Should local addresses be considered valid?
94       */
95      protected EmailValidator(boolean allowLocal) {
96          super();
97          this.allowLocal = allowLocal;
98      }
99  
100     /**
101      * <p>Checks if a field has a valid e-mail address.</p>
102      *
103      * @param email The value validation is being performed on.  A <code>null</code>
104      *              value is considered invalid.
105      * @return true if the email address is valid.
106      */
107     public boolean isValid(String email) {
108         if (email == null) {
109             return false;
110         }
111 
112         if (email.endsWith(".")) { // check this first - it's cheap!
113             return false;
114         }
115 
116         // Check the whole email address structure
117         Matcher emailMatcher = EMAIL_PATTERN.matcher(email);
118         if (!emailMatcher.matches()) {
119             return false;
120         }
121 
122         if (!isValidUser(emailMatcher.group(1))) {
123             return false;
124         }
125 
126         if (!isValidDomain(emailMatcher.group(2))) {
127             return false;
128         }
129 
130         return true;
131     }
132 
133     /**
134      * Returns true if the domain component of an email address is valid.
135      *
136      * @param domain being validated, may be in IDN format
137      * @return true if the email address's domain is valid.
138      */
139     protected boolean isValidDomain(String domain) {
140         // see if domain is an IP address in brackets
141         Matcher ipDomainMatcher = IP_DOMAIN_PATTERN.matcher(domain);
142 
143         if (ipDomainMatcher.matches()) {
144             InetAddressValidator inetAddressValidator =
145                     InetAddressValidator.getInstance();
146             return inetAddressValidator.isValid(ipDomainMatcher.group(1));
147         }
148         // Domain is symbolic name
149         DomainValidator domainValidator =
150                 DomainValidator.getInstance(allowLocal);
151         return domainValidator.isValid(domain) ||
152                 domainValidator.isValidTld(domain);
153     }
154 
155     /**
156      * Returns true if the user component of an email address is valid.
157      *
158      * @param user being validated
159      * @return true if the user name is valid.
160      */
161     protected boolean isValidUser(String user) {
162         return USER_PATTERN.matcher(user).matches();
163     }
164 
165 }