（原创）JAVA注解应用——实现属性的自动检测

一、什么是注解

Annotation(注解)是JDK5.0及以后版本引入的新特性。它可以用于创建文档，跟踪代码中的依赖性，甚至执行基本编译时检查。注解是以‘@注解名’在代码中存在的，根据注解参数的个数，我们可以将注解分为：标记注解、单值注解、完整注解三类。它们都不会直接影响到程序的语义，只是作为注解（标识）存在，我们可以通过反射机制编程实现对这些元数据（用来描述数据的数据）的访问。

二、注解能做什么

Annotation提供了一种安全的类似注释的机制，为我们在代码中添加信息提供了一种形式化得方法，使我们可以在稍后某个时刻方便的使用这些数据（通过解析注解来使用这些数据），用来将任何的信息或者元数据与程序元素（类、方法、成员变量等）进行关联。其实就是更加直观更加明了的说明，这些说明信息与程序业务逻辑没有关系，并且是供指定的工具或框架使用的。Annotation像一种修饰符一样，应用于包、类型、构造方法、方法、成员变量、参数及本地变量的申明语句中。

Annotation其实是一种接口。通过java的反射机制相关的API来访问Annotation信息。相关类（框架或工具中的类）根据这些信息来决定如何使用该程序元素或改变它们的行为。Java语言解释器在工作时会忽略这些Annotation，因此在JVM中这些Annotation是“不起作用”的，只能通过配套的工具才能对这些Annotation类型的信息进行访问和处理。

三、使用注解实现JAVABEAN中属性的自动检测

我们要接下来实现的功能很简单，假设有这么一个场景：外部需要调用某系统接口实现某一功能，其中接口参数是用JavaBean进行传递，JavaBean中定义了几个属性，系统中对这几个属性有着严格的限制，比如：非空、长度限制、参数取值限制等等。

按照传统的方法，我们可能需要针对每个javabean中的每个属性都要写对应的逻辑的判断，设想一下，如果这个系统的接口有1000个，是不是我们应该事先1000个逻辑？NONONO，不需要，java注解功能可以很好的事先这个问题。

1.要实现上面的三个监测，我们需要定义三个不同的注解，代码如下：

package com.maomq.testannotation.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 必填项注解
 * @author maomq
 * @since 2013-08-29
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
@Documented
public @interface Required {

}

package com.maomq.testannotation.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 元素长度范围注解
 * @author maomq
 * @since 2013-08-29
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
@Documented
public @interface LengthLimitRange {

    static final int MIN_VALUE = 0;
    
    static final int MAX_VALUE = 255;
    
    public int minValue() default MIN_VALUE;
    
    public int maxValue() default MAX_VALUE;    
}

package com.maomq.testannotation.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 字符串范围注解
 * @author maomq
 * @since 2013-08-29
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
@Documented
public @interface ArrayStringRange {
    public String[] valueArray();
}

2.注解定义好了，下一步应该定义注解的判断逻辑，这里我们引入一个接口，它将定义所有的监测规则

package com.maomq.testannotation.checker;

import java.lang.reflect.Field;

/**
 * 注解检测实现接口类
 * 
 * @author maomq
 * @since 2013-08-29
 */
public interface FieldAnnotationChecker {

    /**
     * 返回check结果
     * 
     * @param value
     * @param field
     * @return boolean
     */
    public boolean check(Object value, Field field);
}

package com.maomq.testannotation.checker;

import java.lang.reflect.Field;
import java.util.Collection;
import java.util.Map;

/**
 * 注解检测实现类
 * @author maomq
 * @since 2013-08-29
 */
public class RequiredAnnotationChecker implements FieldAnnotationChecker {

    @Override
    public boolean check(Object value, Field field) {
        if (null == value)
        {
            System.out.println("The required value is null!");
            return false;
        }
        
        if (value instanceof String)
        {
            String strValue = (String) value;
            if(strValue.isEmpty())
            {
                System.out.println("The required value is null!");
                return false;
            }
        }
        else if (value instanceof Collection<?>)
        {
            Collection<?> collValue = (Collection<?>) value;
            if(collValue.isEmpty())
            {
                System.out.println("The required value is null!");
                return false;
            }
        }
        else if (value instanceof Map<?, ?>)
        {
             Map<?, ?> mapValue = ( Map<?, ?>) value;
            if(mapValue.isEmpty())
            {
                System.out.println("The required value is null!");
                return false;
            }
        }
        return true;
    }

}

package com.maomq.testannotation.checker;

import java.lang.reflect.Field;
import java.util.Collection;
import java.util.Map;

import com.maomq.testannotation.annotation.LengthLimitRange;

/**
 * 注解检测实现类
 * 
 * @author maomq
 * @since 2013-08-29
 */
public class LengthLimitRangeAnnotationChecker implements
        FieldAnnotationChecker {

    @Override
    public boolean check(Object value, Field field) {
        if (null == value) {
            System.out.println("The value is null or empty!");
            return true;
        }

        LengthLimitRange lengthRange = field
                .getAnnotation(LengthLimitRange.class);

        int maxValue = lengthRange.maxValue();

        int minValue = lengthRange.minValue();

        if (value instanceof String) {
            String strValue = (String) value;
            if (strValue.length() > maxValue || strValue.length() < minValue) {
                System.out
                        .println("The input value is out of the value limit range!");
                return false;
            }
        } else if (value instanceof Collection<?>) {
            Collection<?> collValue = (Collection<?>) value;
            if (collValue.size() > maxValue || collValue.size() < minValue) {
                System.out
                        .println("The input value is out of the value limit range!");
                return false;
            }
        } else if (value instanceof Map<?, ?>) {
            Map<?, ?> mapValue = (Map<?, ?>) value;
            if (mapValue.values().size() > maxValue
                    || mapValue.values().size() < minValue) {
                System.out
                        .println("The input value is out of the value limit range!");
                return false;
            }
        }
        return true;
    }

}

package com.maomq.testannotation.checker;

import java.lang.reflect.Field;

import com.maomq.testannotation.annotation.ArrayStringRange;

/**
 * 注解检测实现类
 * 
 * @author maomq
 * @since 2013-08-29
 */
public class ArrayStringRangeAnnotationChecker implements
        FieldAnnotationChecker {

    @Override
    public boolean check(Object value, Field field) {
        if (null == value) {
            System.out.println("The value is null or empty!");
            return true;
        }

        ArrayStringRange arrayRange = field
                .getAnnotation(ArrayStringRange.class);

        String[] strArray = arrayRange.valueArray();

        if (value instanceof String && strArray.length > 0) {
            for (String strTemp : strArray) {
                if (strTemp.equalsIgnoreCase(value.toString())) {
                    return true;
                }
            }
            System.out.println("The input value is out of the value range!");
            return false;
        }

        return true;
    }

}

3.检测逻辑也完成了，我们是针对每个JAVABEAN中的属性，因此，不可避免的需要一个Util类获取JavaBean中的属性，上代码：

package com.maomq.testannotation;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.maomq.testannotation.annotation.ArrayStringRange;
import com.maomq.testannotation.annotation.LengthLimitRange;
import com.maomq.testannotation.annotation.Required;
import com.maomq.testannotation.checker.ArrayStringRangeAnnotationChecker;
import com.maomq.testannotation.checker.FieldAnnotationChecker;
import com.maomq.testannotation.checker.LengthLimitRangeAnnotationChecker;
import com.maomq.testannotation.checker.RequiredAnnotationChecker;

/**
 * 注解检测测试类
 * @author maomq
 * @since 2013-08-29
 */
public class AnnotationCheckerUtil {

    private static Map<Class<?>, FieldAnnotationChecker> holder = new HashMap<Class<?>, FieldAnnotationChecker>();
    
    static {
        holder.put(Required.class, new RequiredAnnotationChecker());
        holder.put(LengthLimitRange.class, new LengthLimitRangeAnnotationChecker());
        holder.put(ArrayStringRange.class, new ArrayStringRangeAnnotationChecker());
    }
    
    /**
     * 获取Bean中所有的属性
     * @param clazz
     * @param fieldList
     */
    private static void getAllField(Class<?> clazz, List<Field> fieldList)
    {
        if (fieldList == null)
        {
            fieldList = new ArrayList<Field>();
        }
        
        Field[] fieldArray = clazz.getDeclaredFields();        
        for (Field fieldTemp : fieldArray)
        {
            fieldList.add(fieldTemp);
        }
        
        Class<?> superClazz = clazz.getSuperclass();
        
        if(superClazz != Object.class)
        {
            getAllField(superClazz, fieldList);
        }
    }
    
    /**
     * 对传入的JAVABean属性进行检测（使用注解）
     * @param objParam
     * @return
     */
    public static boolean checkField(Object objParam)
    {
        List<Field> fieldList = new ArrayList<Field>();
        
        getAllField(objParam.getClass(), fieldList);
        
        if (fieldList == null || fieldList.isEmpty())
        {
            return true;
        }
        
        for (Field fieldTemp : fieldList)
        {
            fieldTemp.setAccessible(true);
            Object value = null;
            try {
                value = fieldTemp.get(objParam);
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            
            Annotation[] fieldAnnotations = fieldTemp.getAnnotations();
            
            for(Annotation annotation : fieldAnnotations)
            {
                FieldAnnotationChecker checker = holder.get(annotation.annotationType());
                
                if (null != checker && !checker.check(value, fieldTemp))
                {
                    return false;
                }
            }
        }
        
        return true;
    }
}

4.上面的工作都已经准备好了，现在可以测试一下了，首先定义一个javabean，并对其中需要检测的项目予以标注。

package com.maomq.testannotation;

import com.maomq.testannotation.annotation.ArrayStringRange;
import com.maomq.testannotation.annotation.LengthLimitRange;
import com.maomq.testannotation.annotation.Required;

/**
 * 注解检测测试Bean类
 * @author maomq
 * @since 2013-08-29
 */
public class TestAnnotationBean {
    //必填项检测
    @Required
    private String userId;
    //必填，长度限制
    @Required
    @LengthLimitRange(minValue = 1, maxValue = 10)
    private String userName;
    //必填，取值范围限制
    @Required
    @ArrayStringRange(valueArray = {"football", "basketball", "swimming"})
    private String habby;
    
    @SuppressWarnings(value = { "" })
    private String description;

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getHabby() {
        return habby;
    }

    public void setHabby(String habby) {
        this.habby = habby;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}

对上面的结果进行验证：

package com.maomq.testannotation;

/**
 * 注解检测测试类
 * @author maomq
 * @since 2013-08-29
 */
public class TestAnnotation {


    public static void main(String[] args) {
        TestAnnotationBean testAnnotationBean =new TestAnnotationBean();
        
        testAnnotationBean.setUserId("AAA");
        testAnnotationBean.setUserName("12345678901");
        testAnnotationBean.setHabby("walking");
        testAnnotationBean.setDescription("ggsgsgsggs");
        
        if(!AnnotationCheckerUtil.checkField(testAnnotationBean))
        {
            System.out.println("Something is wrong!");
        }
    }

}

输出如我们所料：habby不符合取值范围。

The input value is out of the value limit range!
Something is wrong!

四、小结

通过上面的例子我们可以大致了解注解的功能，如果需要深挖，建议大家学习一下Spring中对java注解功能应用，尤其是涉及事务控制的注解，真的很精髓，有兴趣的同学一定要抽时间学习一下，我这只是抛砖引玉，还望不吝赐教。