实用的java注解工具类

注解，相信大家都会知道，像@requestMapping，@Resource，@Controller等等的一些注解，大家都用过，那么，他的工具类你用过吗？下面就和大家一起来分享一下注解工具类。
首 Java 注解
定义：注解（Annotation），也叫元数据。一种代码级别的说明。
它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。
它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。

从上图可以看出，java注解可以分为：标准注解，元注解

元注解：        

　　元注解的作用就是负责注解其他注解。Java5.0定义了4个标准的meta-annotation类型，它们被用来提供对其它 annotation类型作说明。Java5.0定义的元注解：       
　　　　1.@Target,      
　　　　2.@Retention,       
　　　　3.@Documented,      
　　　　4.@Inherited        
　　这些类型和它们所支持的类在java.lang.annotation包中可以找到。下面我们看一下每个元注解的作用和相应分参数的使用说明。       

    @Target：    

    　　　@Target说明了Annotation所修饰的对象范围：Annotation可被用于 packages、types（类、接口、枚举、Annotation类型）、类型成员（方法、构造方法、   
    成员变量、枚举值）、方法参数和本地变量（如循 环变量、catch参数）。在Annotation类型的声明中使用了target可更加明晰其修饰的目标。  
    作用：用于描述注解的使用范围（即：被描述的注解可以用在什么地方）    

    　　取值(ElementType)有： 

        1.@Target(ElementType.TYPE)  —— 可以适用于任何类的元素
        2.@Target(ElementType.FIELD)  —— 只适用于字段或属性
        3.@Target(ElementType.METHOD)  —— 只适用于方法的注解
        4.@Target(ElementType.PARAMETER)  —— 只适用于方法的参数
        5.@Target(ElementType.CONSTRUCTOR) —— 只适用于构造函数
        6.@Target(ElementType.LOCAL_VARIABLE) —— 只适用于局部变量
        7.@Target(ElementType.ANNOTATION_TYPE) —— 指明声明类型本身是一个注解类型
        8.@Target(ElementType.PACKAGE) —— 只适用于包的注解

实例如下：

package target; 

import java.lang.annotation.ElementType;    
import java.lang.annotation.Target; 


@Target(ElementType.TYPE)   
public @interface Table {   

    /**
     * 
         * @description 数据库表名称注解，默认值为类名称
         * @author  liushaocheng       
         * @created 2016年6月6日 下午8:11:51     
         * @return
     */
    public String tableName() default "className";
}   

注解Table 可以用于注解类、接口(包括注解类型) 或enum声明,而注解NoDBColumn仅可用于注解类的成员变量。   

@Retention： 

　　@Retention定义了该Annotation被保留的时间长短：某些Annotation仅出现在源 代码中，而被编译器丢弃；而另一些却被编译在class文件中； 
编译在class文件中的Annotation可能会被虚拟机忽略，而另一些在class 被装载时将被读取（请注意并不影响class的执行，因为Annotation与class在使用上是被分离的）。   
使用这个meta-Annotation可以对 Annotation的“生命周期”限制。 
作用：表示需要在什么级别保存该注释信息，用于描述注解的生命周期（即：被描述的注解在什么范围内有效）   
　　取值（RetentionPoicy）有：  

　　　　1.SOURCE:在源文件中有效（即源文件保留）    
　　　　2.CLASS:在class文件中有效（即class保留）   
　　　　3.RUNTIME:在运行时有效（即运行时保留）    

Retention meta-annotation类型有唯一的value作为成员，它的取值来自java.lang.annotation.RetentionPolicy的枚举类型值。具体实例如下：   

package retention;  

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

@Target(ElementType.FIELD)  
@Retention(RetentionPolicy.RUNTIME) 
public @interface Column {  

    public String name() default "filedName";

    public String setFunName() default "setField";
}   

Column注解的的RetentionPolicy的属性值是RUTIME,这样注解处理器可以通过反射，获取到该注解的属性值，从而去做一些运行时的逻辑处理    

@Documented:    

　　@Documented用于描述其它类型的annotation应该被作为被标注的程序成员的公共API，因此可以被例如javadoc此类的工具文档化。Documented是一个标记注解，没  
有成员。    
实例如下：   

package documented; 

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; 


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

    public String name() default "fieldName";
}   

@Inherited：

　　@Inherited 元注解是一个标记注解，@Inherited阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited修饰的annotation类型被用于一个class，则这个
annotation将被用于该class的子类。
　　注意：@Inherited annotation类型是被标注过的class的子类所继承。类并不从它所实现的接口继承annotation，方法并不从它所重载的方法继承annotation。
　　当@Inherited annotation类型标注的annotation的Retention是RetentionPolicy.RUNTIME，则反射API增强了这种继 承性。如果我们使用java.lang.reflect去查询一个
Inherited annotation类型的annotation时，反射代码检查将展开工作：检查class和其父类，直到发现指定的annotation类型被发现， 或者到达类继承结构的顶层。

实例如下：

package inherited;  

import java.lang.annotation.Inherited;  

@Inherited  
public @interface Greeting {    

    public enum FontColor{BLUE, RED, GREEN};

    String name();

    FontColor fontColor() default 
}   

好了，介绍完json的分类，接下来就是json的工具类的写法，以下就是json的工具类代码，希望可以帮到大家！

package com.bwie.util;


import java.io.File;  
import java.io.FileFilter;  
import java.io.IOException;  
import java.lang.reflect.Method;
import java.net.URL;  
import java.net.URLDecoder;  
import java.util.ArrayList;  
import java.util.Enumeration;  
import java.util.List;  

import org.springframework.web.bind.annotation.RequestMapping;

/**
 * 
     * Title: GetAnnotationValueUtil.java    
     * Description: 获取注解的值     
 */
public class GetAnnotationValueUtil {  

    /**
     * 
         * @description 获取注解的值
         * @author  liushaocheng       
         * @return
     */
    public static List<String> getRequestMappingValue(String packageName) {

        GetAnnotationValueUtil getAnnotationValueUtil = new GetAnnotationValueUtil();

         //第一个class类的集合  
        List<Class<?>> classes = new ArrayList<Class<?>>();  

        //是否循环迭代  
        boolean recursive = true;  

        //获取包的名字 并进行替换  
        String packageDirName = packageName.replace('.', '/');  

        //定义一个枚举的集合 并进行循环来处理这个目录下的文件 
        Enumeration<URL> dirs;  
        try {  
            //读取指定package下的所有class
            dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName); 

            while (dirs.hasMoreElements()){  
                URL url = dirs.nextElement();  

                //得到协议的名称  
                String protocol = url.getProtocol();

                //判断是否以文件的形式保存在服务器上  
                if ("file".equals(protocol)) {  
                    //获取包的物理路径  
                    String filePath = URLDecoder.decode(url.getFile(), "UTF-8");  

                    //以文件的方式扫描整个包下的文件 并添加到集合中  
                    getAnnotationValueUtil.findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes);
                } 
            }  
        } catch (IOException e) { 
            e.printStackTrace();  
        } 

        List<String> stringList = new ArrayList<String>();

        for (Class<?> clazz : classes) {
            //循环获取所有的类
            Class<?> c = clazz;

            //获取类的所有方法
            Method[] methods = c.getMethods();

            for (Method method : methods) {
                //获取RequestMapping注解
                RequestMapping annotation = method.getAnnotation(RequestMapping.class);

                if (annotation != null) {
                    //获取注解的value值
                    String[] value = annotation.value();
                    for (String string : value) {
                        //放入List集合
                        stringList.add(string);
                    }
                }
            }
        }
        return stringList;
    }

   /**
    * 
        * @description 获取包下的所有类    
        * @param packageName
        * @param packagePath
        * @param recursive
        * @param classes
    */
    public void findAndAddClassesInPackageByFile(String packageName, String packagePath, final boolean recursive, List<Class<?>> classes){  

        //获取此包的目录 建立一个File  
        File dir = new File(packagePath);  

        //如果不存在或者 也不是目录就直接返回  
        if (!dir.exists() || !dir.isDirectory()) {  
            return;  
        }  
        //如果存在 就获取包下的所有文件 包括目录  
        File[] dirfiles = dir.listFiles(new FileFilter() {  
              //自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)  
              public boolean accept(File file) { 

                return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));  
              }  
        }); 
        //循环所有文件  
        for (File file : dirfiles) { 
            //如果是目录 则继续扫描  
            if (file.isDirectory()) {
                findAndAddClassesInPackageByFile(packageName + "." + file.getName(),  
                                      file.getAbsolutePath(),  
                                      recursive,  
                                      classes);  
            }  
            else {  
                //如果是java类文件 去掉后面的.class 只留下类名  
                String className = file.getName().substring(0, file.getName().length() - 6); 
                try {  
                    //添加到集合中去  
                    classes.add(Thread.currentThread().getContextClassLoader().loadClass(packageName + "." + className));  
                } catch (ClassNotFoundException e) {  
                    e.printStackTrace();  
                }  
            }  
        } 
    }

    private GetAnnotationValueUtil() {

    }    
}

使用说明：
传入一个类似于“com.bwie.controoler”的包名，就会搜索这个包下的所有类的RequestMapping注解里的值，然后放到集合中输出