Struts2基于Annotation的服务端校验

在使用Struts2开发时，经常会遇到在服务端Action方法中对数据有效性的校验(当然任何框架都会遇到)，当遇到一大堆属性需要校验时就显得繁琐，而struts2本身的校验插件用起来也不是那么简单，最近自己就尝试用Annotation的方式对数据的有效性进行了校验。

 

首先简单介绍下验证思路：

1、制定校验的Annotaion，主要针对Field、方法级别

2、Annotation相应的校验规则

3、采用Struts2中的拦截器进行校验，在拦截器初始化方法中加载校验的Annotaion和校验规则

4、拦截器对请求方法和Action中的Field截取,读取Field上的Annotaion并采用3中保存的校验规则进行校验

5、将校验产生的不通过信息存储在ActionContext中，在具体的Action获取并处理消息

 

接下来看看具体的实现过程，将分为以下几部分：

1、Annotation和AnnotationChecker

这都是声明的常规性Annotation,主要作用在对象的Field上,以下是一个最大长度校验Annotation的声明：

@Target({ ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MaxLength {

    public int value() default 0;

}

MaxLength的校验类MaxLengthChecker,这里约定检验类是在Annotation+Checker:

public class MaxLengthChecker implements Checker {

    @Override
    public CheckerResult check(Object value, String fieldName, Annotation annotation) {
        if (null != value) {
            try {
                List<String> maxLeng = new ArrayList<String>();
                MaxLength maxLength = (MaxLength) annotation;
                String strVal = (String) value;
                maxLeng.add(String.valueOf(maxLength.value()));
                if (strVal.trim().length() > maxLength.value()) {
                    return new CheckerResult(fieldName, CheckerMsgConstant.CHECKER_MAXLENGTH_OVERFLOW, maxLeng);
                }
            } catch (Exception e) {
                //转换为String失败或其他异常给出提示
                return new CheckerResult(fieldName, CheckerMsgConstant.CHECKER_MAXLENGTH_NOTSTR);
            }
        }
        return null;
    }

}

 这里所有Checker实现接口Checker，方法check作为Annotation的校验方法，返回CheckerResult，用来描述在哪个field和相应的失败规则，如下：

public class CheckerResult implements Serializable {

    private static final long serialVersionUID = 103986447231347145L;
    /** 受检查字段 */
    private String            field;
    /** 检查结果错误类型 */
    private String            checkType;
    /** 检查中传递的参数(如最大最小值等) */
    private List<String>      values;

 

2、Struts2拦截器初始化加载所有的校验Annotation

这是校验的主要方法，继承struts2中的拦截器，首先在初始化方法中根据指定路径加载Annotation和AnnotationChecker

    /**
     * load check rules
     */
    public void init() {
        try {
            URL packageUrl = CheckerIntercepter.class.getClassLoader().getResource(
                    CKECHER_ANNOTATION_PACKAGE.replaceAll("\\.", "/"));
            for (String file : new File(packageUrl.getFile()).list()) {
                if (!file.endsWith(".class"))
                    continue;
                String checkerName = file.substring(0, file.length() - 6);
                Checker checker = (Checker) Class.forName(CKECHER_PACKAGE + "." + checkerName + "Checker")
                        .newInstance();
                checkerMap.put(checkerName, checker);
            }
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
        }
    }

这个会在容器启动时加载一次，接下来是拦截器的主要方法intercept，主要获取当前Action和执行的方法。

这里处理了几点：

1、如果方法有@Ignore就直接忽略

2、只处理当前请求参数的annotation

    @Override
    @SuppressWarnings("all")
    public String intercept(ActionInvocation invocation) throws Exception {
        Object obj = invocation.getAction();

        //只处理当前方法的请求参数的校验
        Set<String> paramSet = reqParams(invocation.getInvocationContext().getParameters());
        if (null == paramSet || paramSet.size() == 0) {
            return invocation.invoke();
        }
        reqParas = new WeakReference<Set<String>>(paramSet);

        if (null != obj) {
            //方式是否ignore
            Method method = obj.getClass().getDeclaredMethod(invocation.getProxy().getMethod(), null);
            boolean ignore = true;
            //方法不能为空，并且忽略默认执行方法(execute)
            if (null != method && !IGNORE_METHOD.equals(method)) {
                //方法是否有Ignore标注
                Annotation[] annotations = method.getAnnotations();
                for (Annotation anno : annotations) {
                    if (IGNORE_ANNOTATION.equals(anno.annotationType().getSimpleName())) {
                        ignore = false;
                        break;
                    }
                }

                if (ignore) {
                    List<CheckerResult> list = populateObject(obj, null);
                    if (null != list && !list.isEmpty()) {
                        //如果有校验不通过的消息，存储在ActionContext中供各Action调用
                        invocation.getInvocationContext().put(CheckerMsgConstant.CHECKER, list);
                    }
                }
            }

        }
        return invocation.invoke();
    }

 

3、对Action中的Field中的Annotation进行校验，并支持作为成员变量的自定义类中Field的校验。这里主要是上面的populateObject方法

/**
     * 对当前对象(Action)或Action中的成员变量获取其Field以及相应的Annotation进行校验
     * 
     * @param obj
     * @param clazz
     * @return
     * @author robin
     * @date 2012-7-18
     */
    @SuppressWarnings("all")
    private <T> List<CheckerResult> populateObject(Object obj, Class<T> clazz) {
        List<CheckerResult> result = new ArrayList<CheckerResult>();
        Class clz = obj == null ? clazz : obj.getClass();

        //当前对象如果是Action获取成员变量,如果是作为成员变量的对象,获取相应的父类
        List<Field> fields = new ArrayList<Field>();
        while (!clz.equals(Object.class)) {
            fields.addAll(Arrays.asList(clz.getDeclaredFields()));
            if (clz.getSuperclass().equals(ActionSupport.class) || clz.equals(Class.class)) {
                break;
            }
            clz = clz.getSuperclass();
        }

        for (Field field : fields) {

            //是否有@Ignore、静态、接口、数组成员变量忽略
            if (isIgnored(field)) {
                continue;
            }

            //当前请求参数中是否有该Field
            String fieldName = field.getName();
            if (!reqParas.get().contains(fieldName)) {
                continue;
            }

            Object object = null;
            if (null != obj) {
                try {
                    field.setAccessible(true);
                    object = field.get(obj);
                } catch (Exception e) {
                    LOG.error("FAILED get field value", e);
                    //do nothing
                }
            }

            if (isPrimitive(field.getType())) {
                result.addAll(checker(field, object));
            } else {
                result.addAll(populateObject(object, field.getType()));
            }
        }
        return result;
    }

这里primitives是制定的默认直接进行校验的集合，不过这样做并不太合理。需要进一步考虑下，这是配置：

    /**
     * 判断是否是原生类型(如果是实体对象需要递归调用对其判断)
     * 
     * @param clazz
     * @return
     * @author robin
     * @date 2012-7-20
     */
    private boolean isPrimitive(@SuppressWarnings("rawtypes") Class clazz) {
        return clazz.isPrimitive() || clazz.equals(String.class) || clazz.equals(Date.class)
                || clazz.equals(Boolean.class) || clazz.equals(Byte.class) || clazz.equals(Character.class)
                || clazz.equals(Double.class) || clazz.equals(Float.class) || clazz.equals(Integer.class)
                || clazz.equals(Long.class) || clazz.equals(Short.class) || clazz.equals(Locale.class)
                || clazz.isEnum();
    }

 

 

4、剩下的就是checker方法，对Field和该Field的值进行校验

    /**
     * 对当前Field的Annotation进行校验
     * 
     * @param field
     * @param value
     * @return
     * @author robin
     * @date 2012-7-18
     */
    private List<CheckerResult> checker(Field field, Object value) {
        List<CheckerResult> result = new ArrayList<CheckerResult>();
        Annotation[] annotations = field.getAnnotations();
        for (Annotation anno : annotations) {
            Checker checker = checkerMap.get(anno.annotationType().getSimpleName());
            if (checker != null) {
                CheckerResult check = checker.check(value, field.getName(), anno);
                if (null != check) {
                    result.add(check);
                }
            }
        }
        return result;
    }

 

最后来看看如何使用：

1、需要将当前的拦截器加到项目的default-interceptor-ref如：

		<interceptors>
			<interceptor name="checkerIntercepter" class="org.apache.struts2.valid.common.CheckerIntercepter" />
			<interceptor-stack name="s2webDefaultStack">
				<interceptor-ref name="defaultStack"/>
				<interceptor-ref name="checkerIntercepter" />
			</interceptor-stack>
		</interceptors>
		<default-interceptor-ref name="s2webDefaultStack"/>

 

 2、为了方便使用，提供了一个ActionBase方法，可继承该Action，当然也可以自己处理，因为消息已经在struts2的数据上下文环境中：

List<CheckerResult> result = (List<CheckerResult>) ActionContext.getContext().get(CheckerMsgConstant.CHECKER);

 这是ActionBase中获得消息的一个方法：

    @SuppressWarnings("unchecked")
    protected List<String> getValidInfos() {
        List<String> resultList = new ArrayList<String>();
        List<CheckerResult> result = (List<CheckerResult>) ActionContext.getContext().get(CheckerMsgConstant.CHECKER);
        for (CheckerResult checkerResult : result) {
            //注意：第一个参数默认为类型，为message中的key
            //new String[]{/**默认为字段名称*/, ...(一个或多个参数)}
            resultList.add(getText(checkerResult.getCheckType(), getValidateInfo(checkerResult)));
        }
        return resultList;
    }

    private String[] getValidateInfo(CheckerResult checker) {
        List<String> values = checker.getValues();
        String field = getText(checker.getField());
        if (null != values && values.size() > 0) {
            String[] result = new String[1 + values.size()];
            result[0] = field;
            int index = 1;
            for (String rst : values) {
                result[index] = rst;
                index++;
            }
            return result;
        }
        return new String[] { field };
    }

而验证的错误消息声明如下：

    /** {0}长度不能超过{1} */
    public static final String CHECKER_MAXLENGTH_OVERFLOW = "checker.maxlength.overflow";
    /** {0}不是字符 */
    public static final String CHECKER_MAXLENGTH_NOTSTR   = "checker.maxlength.notstr";

这些消息的key已经在CheckerResult中的checkType体现，并且可以默认提供一系列的消息，如message.properties中：

checker.maxlength.overflow={0}\u957F\u5EA6\u4E0D\u80FD\u8D85\u8FC7{1}

 

3、在业务Action中，可以这样：

public class ValiAction extends ValidBaseAction {
    private static final long  serialVersionUID = -5951668645132875324L;

    @Must
    @MaxLength(5)
    private String             username;
    @Must
    private String             password;

    private PageModule<String> pageModule;

    @Ignore
    public String index() {
        return SUCCESS;
    }

    public String save() {
//获得校验错误消息
        getValidInfos();

以上可见：https://github.com/yooodooo/s2valid.git