一个注解引发的话题

一个注解引发的话题

引用

从元注解开始

1. @Target,
2. @Retention

这些在jdk中的java.lang.annotation包中可以找到。

秉着用到什么就记录什么的思维习惯，先从target开始入手

先看实例代码

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface AnnoMsg {
    /**
     * @return msg类型
     */
    short msgType();
}

Target的作用就是描述该注解可以用在什么地方。

参数我用的是ElementType.Type（是用来描述类、接口、枚举等声明的）所以该注解不能用在方法上或者一些字段上

Retention则描述了该注解的生命问题。

参数我用的是RetentionPolicy.RUNTIME（表示只在运行时有效）

使用自己的注解

当我开始使用的时候也就意味着我已经给相关的类或接口或枚举附加了一些信息，当程序开始run我就可以通过它做一些处理，但是请牢记注解只是为了起到辅助性的效果，我们不应该因为它的加入而影响大局逻辑

看实例代码

@AnnoMsg(msgType = 10)
public class RequestMsg{

    public static void main(String[] args) {
        if (RequestMsg.class.isAnnotationPresent(AnnoMsg.class)){
            AnnoMsg annoMsg = RequestMsg.class.getAnnotation(AnnoMsg.class);
            System.out.println("msgType:"+annoMsg.msgType());
        }
    }
}

通过反射当判断是AnnoMsg类型则可以获取该实体类进行下面操作

输出信息：

msgType:10

那么反射来了,下面的代码一部分是从网上拿的@_@~，做个记录为了以后方便查找

上实例代码

    private static Map<Short, Class<?>> typeToMsgClassMap;  

    // class文件过滤器
    private static MyFilter myFilter = new MyFilter(true);

    /**
     * 初始化MsgClassMap
     * 遍历包引用注解的类 
     * 取得消息类的class文件
     * 
     * @throws ClassNotFoundException
     * @throws IOException
     */
    public static void initMsgClassMap() 
            throws ClassNotFoundException, IOException {

        Map<Short, Class<?>> tmpMap = new HashMap<Short, Class<?>>();
        //引用注解的类所在的包 package anno; RequestMsg所在的包
        Set<Class<?>> classSet = getClasses("anno");
        if (classSet != null) {
            for (Class<?> clazz : classSet) {
                if (clazz.isAnnotationPresent(AnnoMsg.class)) {
                    AnnoMsg annoMsg = clazz.getAnnotation(AnnoMsg.class);
                    tmpMap.put(annoMsg.msgType(), clazz);
                }
            }
        }

        typeToMsgClassMap = Collections.unmodifiableMap(tmpMap);
    }

    /**
     * 从包package中获取所有的Class
     * 
     * @param pack
     * @return
     * @throws ClassNotFoundException 
     * @throws IOException 
     */
    private static Set<Class<?>> getClasses(String pack) 
            throws ClassNotFoundException, IOException {
        // 第一个class类的集合
        Set<Class<?>> classes = new LinkedHashSet<Class<?>>();
        // 是否循环迭代
        boolean recursive = true;
        // 获取包的名字，并进行替换
        String packageName = pack;
        String packageDirName = packageName.replace('.', '/');
        // 定义一个枚举的集合，并进行循环来处理这个目录下的things
        Enumeration<URL> dirs;
        dirs = Thread.currentThread().getContextClassLoader()
                .getResources(packageDirName);
        // 循环迭代下去
        while (dirs.hasMoreElements()) {
            // 获取下一个元素
            URL url = dirs.nextElement();
            // 得到协议的名称
            String protocol = url.getProtocol();
            // 如果是以文件的形式保存在文件系统上
            if ("file".equals(protocol)) {
                System.err.println("file类型的扫描");
                // 获取包的物理路径
                String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
                // 以文件的方式扫描整个包下的文件，并添加到集合中
                findClassesInPackageByFile(packageName, filePath,
                        recursive, classes);
            } else if ("jar".equals(protocol)) {
                // 如果是jar包文件
                // 定义一个JarFile
                System.err.println("jar类型的扫描");
                JarFile jar;
                // 获取jar
                JarURLConnection jarURLConnection = (JarURLConnection) url
                        .openConnection();
                jar = jarURLConnection.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);
                                // 添加到classes
                                classes.add(Class.forName(packageName + '.'
                                                + className));
                            }
                        }
                    }
                }
            }
        }

        return classes;
    }


    /**
     * 以文件的形式来获取包下的所有Class
     * 
     * @param packageName
     * @param packagePath
     * @param recursive
     * @param classes
     * @throws ClassNotFoundException 
     */
    private static void findClassesInPackageByFile(String packageName,
            String packagePath, final boolean recursive, Set<Class<?>> classes) 
                    throws ClassNotFoundException {

        // 获取此包的目录，建立一个File
        File dir = new File(packagePath);
        // 如果不存在或者，也不是目录就直接返回
        if (!dir.exists() || !dir.isDirectory()) {
            return;
        }
        // 如果存在，就获取包下的所有文件，包括目录
        File[] dirfiles = dir.listFiles(myFilter);
        // 循环所有文件
        for (File file : dirfiles) {
            // 如果是目录，则继续扫描
            if (file.isDirectory()) {
                findClassesInPackageByFile(
                        packageName + "." + file.getName(),
                        file.getAbsolutePath(), recursive, classes);
            } else {
                // 如果是java类文件，去掉后面的.class，只留下类名
                String className = file.getName().substring(0,
                        file.getName().length() - 6);

                // 添加到集合中去
                classes.add(Thread.currentThread().getContextClassLoader()
                        .loadClass(packageName + '.' + className));
            }
        }
    }

/**
 * 过滤得到需要的class文件
 * 
 * @author fengjing
 * @version 1.0
 *
 */
class MyFilter implements FileFilter {

    private boolean recursive;

    public MyFilter(boolean recursive) {
        this.recursive = recursive;
    }

    public boolean accept(File file) {
        return (recursive && file.isDirectory())
                || (file.getName().endsWith(".class") 
                        && file.getName().contains("$") == false
                        && file.getName().startsWith("User"));
    }
}

通过反射获取实例，从而实现代码也是一种设计的手段与方法，做成工具类是很合适的