java服务器端的参数检测

一个简单java服务器端参数检测
1、可以做扩展应用
2、减少代码编写量，统一检测路口
3、降低学习门槛、减少学习成本


import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ValidatorUtil {
public final static String EMAIL_REG = "^([a-zA-Z0-9_\\-\\.]+)@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.)|(([a-zA-Z0-9\\-]+\\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\\]?)$";
public final static String MOBILENO_REG = "^((13[0-9])|(15[^4,\\D])|(18[0,5-9]))\\d{8}$";
public final static String NUMBER_REG = "^(0|[1-9]\\d*)$|^(0|[1-9]\\d*)\\.(\\d+)$";

/**
* 检测单个字符串
*
* @param str
*            需要检测的字符串
* @param rule
*            检测的规则 规则如下：
*            1、空检测 自动检测
*            2、长度检测使用Len(5,10),没有下限Len(0,10),没有上限Len(5,0);
*            3、规则匹配检测isEmail,isMobile,isIp，isCard
*            4、类型检测int、number(int表示必须是整数、number表示为数字)
*            5、多规则以“|”分隔，例如Len(5,10)|isMail|int
* @param desc
*            描述 可以为空
* @return 检测通过，返回Null,检测不通过返回对应的错误信息
*/
public static String checkStr(String str, String ruleStr, String desc) {
// 规则检测
if (isEmpty(ruleStr)) {
return desc + "规则字符串为空!";
}
if (isEmpty(desc)) {
desc = "";
}
// 字符串空检测
if (isEmpty(str)) {
return desc + "检测的字符串为空!";
}
// 解析规则

// 解析长度验证
Pattern patternLen = Pattern.compile("Len\\((\\d{1}),(\\d{1,})\\)*");
Matcher matcherLen = patternLen.matcher(ruleStr);
if (matcherLen.find()) {
try {
int minLen = Integer.parseInt(matcherLen.group(1));
int maxLen = Integer.parseInt(matcherLen.group(2));
String matchLenRs = matchLen(str, minLen, maxLen);
if (!isEmpty(matchLenRs))
return desc+matchLenRs;
} catch (Exception e) {
return desc + "长度配置有误!";
}
}
// 解析规则匹配
Pattern patternReg = Pattern
.compile("(isEmail)|(isMobile)|(isIp)|(isCard)");
Matcher matcherReg = patternReg.matcher(ruleStr);
if (matcherReg.find()) {
if (matcherReg.group(1) != null) {
// 验证邮箱
if (!isEmail(str, null)) {
return "邮箱格式错误!";
}
} else if (matcherReg.group(2) != null) {
if (!isMobileNO(str, null)) {
return "手机号码格式错误!";
}
} else if (matcherReg.group(3) != null) {
// 验证Ip地址
} else {
// 验证身份证
}

}
// 解析类型匹配
Pattern patternType = Pattern.compile("(int)|(number)");
Matcher matcherType = patternType.matcher(ruleStr);
if (matcherType.find()) {
if (matcherType.group(1) != null) {
// 验证为整数
try {
Integer.parseInt(str);
} catch (Exception e) {
return desc + "不是整数!";
}
} else {
// 验证为数字
if (!isNumber(str, null)) {
return desc + "不是数字!";
}
}
}
return null;
}

/**
* 字符串长度匹配
*
* @param str
*            匹配字符串
* @param minLen
*            最小长度，没有限制为0
* @param maxLen
*            最大长度，没有限制为0
* @return
*/
public static String matchLen(String str, int minLen, int maxLen) {
if (maxLen <= minLen) {
return "最大长度必须大于最小长度!";
}
if (minLen > 0 && str.length() < minLen)
return "不满足最小长度!";
if (maxLen > 0 && str.length() > maxLen)
return "不满足最大长度!";
return null;
}

/**
* 是否是数字
*
* @param numberStr
* @param regEx
*            正则表达式，可以为空
* @return
*/
public static boolean isNumber(String numberStr, String regEx) {
if (isEmpty(regEx))
regEx = NUMBER_REG;
Pattern p = Pattern.compile(regEx);
Matcher m = p.matcher(numberStr);
return m.matches();
}

/**
* 是否是邮箱
*
* @param email
*            邮箱
* @param regEx
*            正则表达式，可以为空
* @return
*/
public static boolean isEmail(String email, String regEx) {
if (isEmpty(regEx))
regEx = EMAIL_REG;
Pattern p = Pattern.compile(regEx);
Matcher m = p.matcher(email);
return m.matches();
}

/**
* 是否是手机号码
*
* @param mobile
*            手机号码
* @param regEx
*            正则表达式，可以为空
* @return
*/
public static boolean isMobileNO(String mobile, String regEx) {
if (isEmpty(regEx))
regEx = MOBILENO_REG;
Pattern p = Pattern.compile(regEx);
Matcher m = p.matcher(mobile);
return m.matches();
}

/**
* 判断是否非空，忽略null和“”
*
* @param s
* @return
*/
public static boolean isEmpty(String s) {
if (s == null) {
return true;
} else if (s.equals("")) {
return true;
} else {
return false;
}
}

public static void main(String[] args) {
String ruleStr = "isEmail|Len(5,20)";
String mail = "[e-mail]";
String desc = "测试";
// 解析规则
String result = ValidatorUtil.checkStr(mail, ruleStr, desc);
System.out.println(result);
// Matcher matcher = pattern.matcher(ruleStr);
// if (matcher.find()) {
// System.out.println(matcher.groupCount());
// // System.out.println(minLen);
// // int maxLen = Integer.parseInt(matcher.group(2));
// // System.out.println(maxLen);
// System.out.println(matcher.group(2));
// }
}
}