java简单校验器,持续扩展

package demo.validate;

import java.util.ArrayList;
import java.util.List;

public class Validation {

	public static void main(String[] args) {
		String msg = null;
		// validate one text
		msg = Validation.newInstance().addText("123456").addRule(
				RuleType.NOT_EMPTY).addRule(RuleType.LENGTH, 3).addRule(
				RuleType.NUMBER, 0, 123458).addRule(RuleType.NUMERIC_STRING,
				"123450", "123490").addRule(new Rule() {

			@Override
			public String validate(String text) {
				// validate if the number is odd
				if (Integer.parseInt(text) % 2 == 0) {
					return String.format("%s is not an odd number", text);
				}
				return null;
			}
		}).validate();
		System.out.println(msg);

		// validate batch text by same rule
		Validation instance = Validation.newInstance().addRule(
				RuleType.NOT_EMPTY).addRule(RuleType.LENGTH, 3).addRule(
				RuleType.NUMBER, 0, 123458);
		String[] batch = new String[10];
		for (int i = 0; i < batch.length; i++) {
			batch[i] = "12345" + i;
		}
		for (int i = 0; i < batch.length; i++) {
			String result = instance.addText(batch[i]).validate();
			System.out.println(String.format("text:%s,validate result:%s",
					batch[i], result));
		}
	}

	private static final String NUMBER_REGEX = "([1-9]\\d*)|(0)";
	private static final String NUMERIC_STRING_REGEX = "\\d+";

	public enum RuleType {
		NOT_EMPTY, LENGTH, NUMERIC_STRING, NUMBER, REGEX
	}

	public interface Rule {
		String validate(String text);
	}

	private String text;
	private List<Rule> items = new ArrayList<Rule>();

	private Validation() {

	}

	public static Validation newInstance() {
		return new Validation();
	}

	public Validation addText(String text) {
		return addText(text, true);
	}

	public Validation addText(String text, boolean trim) {
		this.text = text;
		if (trim) {
			if (this.text != null) {
				this.text.trim();
			}
		}
		return this;
	}

	public Validation addRule(Rule rule) {
		items.add(rule);
		return this;
	}

	public Validation addRule(RuleType rule) {
		items.add(new CommonRule(rule));
		return this;
	}

	public Validation addRule(RuleType rule, Object... params) {
		items.add(new CommonRule(rule, params));
		return this;
	}

	public String validate() {
		return Validation.validate(this.text, this.items);
	}

	private class CommonRule implements Rule {
		private RuleType rule;
		private Object[] params = null;

		private CommonRule() {

		}

		private CommonRule(RuleType rule) {
			this.rule = rule;
		}

		private CommonRule(RuleType rule, Object... params) {
			this.rule = rule;
			this.params = params;
		}

		public RuleType getRule() {
			return rule;
		}

		public Object[] getParams() {
			return params;
		}

		@Override
		public String validate(String text) {
			return Validation.validate(text, this);
		}
	}

	public static String validate(String text, List<Rule> rules) {
		Rule[] items = null;
		if (rules != null && !rules.isEmpty()) {
			items = rules.toArray(new Rule[rules.size()]);
		}
		return validate(text, items);
	}

	public static String validate(String text, Rule[] rules) {
		if (rules == null) {
			return null;
		}
		String res = null;
		for (int i = 0; i < rules.length; i++) {
			Rule validator = rules[i];
			if (validator == null) {
				continue;
			}
			res = validator.validate(text);
			if (res != null) {
				break;
			}
		}
		return res;
	}

	private static String validate(String text, CommonRule rule) {
		String res = null;
		RuleType ruleType = rule.getRule();
		Object[] params = rule.getParams();
		if (ruleType == RuleType.NOT_EMPTY) {
			if ((res = validateEmpty(text)) != null) {
				return res;
			}
		}
		if (ruleType == RuleType.LENGTH) {
			int min = 0;
			int max = 0;
			if (params != null) {
				if (params.length > 0) {
					min = (Integer) params[0];
					if (params.length > 1) {
						max = (Integer) params[1];
					}
				}
			}
			if ((res = validateLength(text, min, max)) != null) {
				return res;
			}
		}
		if (ruleType == RuleType.NUMERIC_STRING) {
			String min = null;
			String max = null;
			if (params != null) {
				if (params.length > 0) {
					min = (String) params[0];
					if (params.length > 1) {
						max = (String) params[1];
					}
				}
			}
			if ((res = validateNumericString(text, min, max)) != null) {
				return res;
			}
		}
		if (ruleType == RuleType.NUMBER) {
			int min = 0;
			int max = 0;
			if (params != null) {
				if (params.length > 0) {
					min = (Integer) params[0];
					if (params.length > 1) {
						max = (Integer) params[1];
					}
				}
			}
			if ((res = validateNumber(text, min, max)) != null) {
				return res;
			}
		}
		if (ruleType == RuleType.REGEX) {
			if ((res = validateRegex(text, (String) params[0])) != null) {
				return res;
			}
		}
		return null;
	}

	public static String validateEmpty(String text) {
		if (text == null || text.isEmpty()) {
			return text + " is empty";
		}
		return null;
	}

	public static String validateNumericString(String text, String min,
			String max) {
		if (!text.matches(NUMERIC_STRING_REGEX)) {
			return text + " is not a numeric string";
		}
		String msg = "";
		if (min != null) {
			msg = " more than " + min;
		}
		if (max != null) {
			msg += (msg.length() == 0 ? "" : " and ") + " less than " + max;
		}
		msg = text + " is invalid, should be" + msg;
		if (min != null && text.compareTo(min) < 0) {
			return msg;
		}
		if (max != null && text.compareTo(max) > 0) {
			return msg;
		}
		return null;
	}

	public static String validateNumber(String text, int min, int max) {
		if (!text.matches(NUMBER_REGEX)) {
			return text + " is not a number";
		}
		int number = Integer.parseInt(text);
		String msg = "";
		if (min > 0) {
			msg = " more than " + min;
		}
		if (max > 0) {
			msg += (msg.length() == 0 ? "" : " and ") + " less than " + max;
		}
		if (msg.length() == 0) {
			return null;
		}
		msg = text + " is invalid, should be" + msg;
		if (min > 0 && number < min) {
			return msg;
		}
		if (max > 0 && number > max) {
			return msg;
		}
		return null;
	}

	public static String validateLength(String text, int minLength,
			int maxLength) {
		int length = text.length();
		String msg = "";
		if (minLength > 0) {
			msg = " more than " + minLength;
		}
		if (maxLength > 0) {
			msg += (msg.length() == 0 ? "" : " and ") + " less than "
					+ maxLength;
		}
		if (msg.length() == 0) {
			return null;
		}
		msg = text + " is invalid, the length should be" + msg;
		if (minLength > 0 && length < minLength) {
			return msg;
		}
		if (maxLength > 0 && length > maxLength) {
			return msg;
		}
		return null;
	}

	public static String validateRegex(String text, String regex) {
		if (text.matches(regex)) {
			return null;
		}
		return text + " is invalid";
	}

	public static String validate(String text, Rule validator) {
		if (validator == null) {
			return null;
		}
		return validator.validate(text);
	}

}

123456 is not an odd number
text:123450,validate result:null
text:123451,validate result:null
text:123452,validate result:null
text:123453,validate result:null
text:123454,validate result:null
text:123455,validate result:null
text:123456,validate result:null
text:123457,validate result:null
text:123458,validate result:null
text:123459,validate result:123459 is invalid, should be less than 123458