【代码复用】反射获取所有类注解

扫描所有包：

public class ScanUtil{
    /** 是否循环迭代 **/
    boolean recursive = true;
    /** 包名集合 **/
    private List<String> packageNames = new ArrayList<String>();
    /** 过滤器 **/
    private ScanPackageFilter filter = null;
    /** 监听器 **/
    private ScanPackageListener listener = null;
    //接收扫描出来的所有类、接口
    public static List<String> allClass=new ArrayList<>();
    /**
     * 是否循环迭代
     *
     * @return
     */
    public boolean isRecursive()
    {
        return recursive;
    }

    /**
     * 设置是否循环迭代
     *
     * @param recursive
     */
    public void setRecursive(boolean recursive)
    {
        this.recursive = recursive;
    }

    /**
     * 获得过滤器
     *
     * @return
     */
    public ScanPackageFilter getFilter()
    {
        return filter;
    }

    /**
     * 设置过滤器
     *
     * @param filter
     */
    public void setFilter(ScanPackageFilter filter)
    {
        this.filter = filter;
    }

    /**
     * 获得监听器
     *
     * @return
     */
    public ScanPackageListener getListener()
    {
        return listener;
    }

    /**
     * 设置监听器
     *
     * @param listener
     */
    public void setListener(ScanPackageListener listener)
    {
        this.listener = listener;
    }

    /**
     * 添加扫描包
     *
     * @param packageName
     */
    public void addPackage(String packageName)
    {
        if (packageName == null || !packageName.matches("[\\w]+(\\.[\\w]+)*"))
        {
            throw new IllegalArgumentException("非法包名.");
        }
        this.packageNames.add(packageName);
    }

    /**
     * 清空扫描包
     */
    public void clearPackage()
    {
        this.packageNames.clear();
    }

    /**
     * 扫描
     */
    public void scan()
    {
        for (String packageName : packageNames)
        {
            scan(packageName);
        }
    }

    /**
     * 是否接受
     *
     * @param clazz
     * @return
     */
    private boolean accept(Class<?> clazz)
    {
        if (this.filter != null)
        {
            return this.filter.accept(clazz);
        }
        return true;
    }

    /**
     * 触发扫描到合法类
     *
     * @param clazz
     * @return
     */
    private void trrigerOnScanClass(Class<?> clazz)
    {
        if (this.listener != null)
        {
            this.listener.onScanClass(clazz);
        }
    }

    /**
     * 扫描到类
     *
     * @param clazz
     * @return
     */
    private void onScanClass(Class<?> clazz)
    {
        if (accept(clazz))
        {
            trrigerOnScanClass(clazz);
        }
    }

    /**
     * 从包package中获取所有的Class
     *
     * @param packageName
     * @return
     */
    private void scan(String packageName)
    {
        // 获取包的名字 并进行替换
        String packageDirName = packageName.replace('.', '/');
        // 定义一个枚举的集合 并进行循环来处理这个目录下的things
        Enumeration<URL> dirs = null;
        try
        {
            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");
                    // 以文件的方式扫描整个包下的文件 并添加到集合中
                    findAndAddClassesInPackageByFile(packageName, filePath);
                }
                else if ("jar".equals(protocol))
                {
                    // 如果是jar包文件
                    // 定义一个JarFile
                    JarFile jar = null;
                    try
                    {
                        // 获取jar
                        jar = ((JarURLConnection) url.openConnection()).getJarFile();
                        // 从此jar包 得到一个枚举类
                        Enumeration<JarEntry> entries = jar.entries();
                        // 同样的进行循环迭代
                        while (entries.hasMoreElements())
                        {
                            // 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如META-INF等文件
                            JarEntry entry = entries.nextElement();
                            String name = entry.getName();
                            // 如果是以/开头的
                            if (name.charAt(0) == '/')
                            {
                                // 获取后面的字符串
                                name = name.substring(1);
                            }
                            // 如果前半部分和定义的包名相同
                            if (name.startsWith(packageDirName))
                            {
                                int idx = name.lastIndexOf('/');
                                // 如果以"/"结尾 是一个包
                                if (idx != -1)
                                {
                                    // 获取包名 把"/"替换成"."
                                    packageName = name.substring(0, idx).replace('/',
                                            '.');
                                }
                                // 如果可以迭代下去 并且是一个包
                                if ((idx != -1) || recursive)
                                {
                                    // 如果是一个.class文件 而且不是目录
                                    if (name.endsWith(".class") && !entry.isDirectory())
                                    {
                                        // 去掉后面的".class" 获取真正的类名
                                        String className = name.substring(
                                                packageName.length() + 1,
                                                name.length() - 6);
                                        try
                                        {
                                            // 添加到classes
                                            // 使用Class.forName会触发类静态方法
                                            Class<?> clazz = Thread.currentThread()
                                                    .getContextClassLoader().loadClass(
                                                            packageName + '.' + className);
                                            onScanClass(clazz);
                                        }
                                        catch (ClassNotFoundException e)
                                        {
                                            System.err.println("加载类出错");
                                        }
                                    }
                                }
                            }
                        }
                    }
                    catch (IOException e)
                    {
                        System.err.println("在扫描用户定义视图时从jar包获取文件出错");
                        e.printStackTrace();
                    }
                }
            }
        }
        catch (IOException e)
        {
            System.err.println("扫描出错");
            e.printStackTrace();
        }
    }

    /**
     * 以文件的形式来获取包下的所有Class
     *
     * @param packageName
     * @param packagePath
     */
    private void findAndAddClassesInPackageByFile(String packageName,
                                                  String packagePath){
        // 获取此包的目录 建立一个File
        File dir = new File(packagePath);
        // 如果不存在或者 也不是目录就直接返回
        if (!dir.exists() || !dir.isDirectory())
        {
            System.err.println("用户定义包名 " + packageName + " 下没有任何文件");
            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());
            }
            else
            {
                // 如果是java类文件 去掉后面的.class 只留下类名
                String className = file.getName().substring(0,
                        file.getName().length() - 6);

                try
                {
                    String classTotalName=packageName + '.' + className;
                    allClass.add(classTotalName);
                    Class<?> clazz = Thread.currentThread().getContextClassLoader()
                            .loadClass(classTotalName);
                    onScanClass(clazz);

                }
                catch (ClassNotFoundException e)
                {
                    System.err.println("添加用户自定义视图类错误 找不到此类的.class文件");
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 扫描包过滤器
     *
     * @author jianggujin
     *
     */
    public static interface ScanPackageFilter
    {
        /**
         * 是否接受
         *
         * @param clazz
         * @return
         */
        public boolean accept(Class<?> clazz);
    }

    /**
     * 扫描包监听
     *
     * @author jianggujin
     *
     */
    public static interface ScanPackageListener
    {
        /**
         * 扫描到合法类执行
         *
         * @param clazz
         */
        public void onScanClass(Class<?> clazz);
    }

    public static void main(String[] args)
    {
        ScanUtil scanUtil = new ScanUtil();
        scanUtil.addPackage(ScanUtil.class.getPackage().getName());
        scanUtil.setFilter(new ScanPackageFilter()
        {

            @Override
            public boolean accept(Class<?> clazz)
            {
                return true;
            }
        });
        scanUtil.setListener(new ScanPackageListener()
        {

            @Override
            public void onScanClass(Class<?> clazz)
            {
                System.out.println("扫描信息："+clazz);
            }
        });
        scanUtil.scan();
    }

    public static List<String> getAllClassList(){
        ScanUtil scanUtil = new ScanUtil();
        scanUtil.addPackage(ScanUtil.class.getPackage().getName());
        scanUtil.setFilter(new ScanPackageFilter()
        {

            @Override
            public boolean accept(Class<?> clazz)
            {
                return true;
            }
        });
        scanUtil.setListener(new ScanPackageListener()
        {

            @Override
            public void onScanClass(Class<?> clazz)
            {
               // System.out.println("扫描信息："+clazz);
            }
        });
        scanUtil.scan();
        return allClass;
    }
}

获取注解：

public class AnnoReflect {
    public static List<String> clearAnnoClass(){

        //获取到整个项目内所有类
        List<String> list= ScanUtil.getAllClassList();

        //循环得到含有RUNTIME的注解的类
        Iterator iterator=list.iterator();

        while(iterator.hasNext()){
            String classTotalName=(String)iterator.next();

            //ScanUtil本身也要删除
            if(classTotalName.contains("ScanUtil")){
                iterator.remove();
            }

            //System.out.println(classTotalName);
            try {

                //获取相应类的Class对象
                Class<?> clazz = Class.forName(classTotalName);

                //得到类的注解
                Annotation[] classAnnos = clazz.getDeclaredAnnotations();

                if (classAnnos != null) {
                    //
                    for (Annotation anno : classAnnos) {
                        //如果某个类的注解含有RUNTIME表示它是注解类，要删除
                        if (anno.toString().contains("RUNTIME")) {
                            iterator.remove();
                        }
                    }
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
        return list;

    }

    /**
     *
     * @return
     */
    public static Map<String,List<String>> getAnnoReflect() {
        //返回值
        Map<String,List<String>> map=new HashMap<>();

        //获取到干净的遍历Class，去除了注解类和工具类本身
        List<String> list=clearAnnoClass();

        //测试代码
        //System.out.println(JSON.toJSONString(list));

        //放在这里List一直接收
        //List<String> classAnnoList=new ArrayList<>();

        //存储方法注解
        //List<String> methodAnnoList=new ArrayList<>();
        //
        for(String classTotalName:list){

            try {
                //获取当前类
                Class<?> clazz=Class.forName(classTotalName);
                //类注解
                Annotation[] classAnnos=clazz.getDeclaredAnnotations();

                if(classAnnos!=null && classAnnos.length>0){
                    //存储类注解,应该放在此处，变量作用域尽量小，而且是使用一次创建一次
                    List<String> classAnnoList=new ArrayList<>();

                    for(Annotation anno:classAnnos){

                        System.out.println("类："+classTotalName+"----------的注解："+anno);
                        //将注解添加
                        classAnnoList.add(anno.toString());

                    }
                    map.put(classTotalName,classAnnoList);

                }

                //获取当前类所有方法
                Method[] methods=clazz.getDeclaredMethods();

                for(Method method:methods){

                    //方法注解
                    Annotation[] methodAnnos=method.getDeclaredAnnotations();

                    if(methodAnnos!=null && methodAnnos.length>0){
                        //存储方法注解
                        List<String> methodAnnoList=new ArrayList<>();
                        for(Annotation anno:methodAnnos){

                            System.out.println("类："+classTotalName+"中的方法-------"+method+"-------的注解："+anno);

                            methodAnnoList.add(anno.toString());

                        }
                        map.put(classTotalName+"."+method,methodAnnoList);

                    }
                }


            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
        return map;
    }


    public static void main(String[] args) {
        System.out.println(JSON.toJSONString(getAnnoReflect()));
    }
}