java注解原理

最新推荐文章于 2024-01-22 11:07:16 发布
最新推荐文章于 2024-01-22 11:07:16 发布
阅读量200 收藏
点赞数
分类专栏： java基础 文章标签： java 注解实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xxb249/article/details/120179203
版权

        在基于spring开发的时候，一个简单的注解，就可以完成对象创建与注入，感觉非常的神秘，那么注解是怎么实现的呢？今天这里实现了一套类似junit相关注解XTest，XBefore，XAfter注解。

        注解基本实现思路：

1）扫描工程下面所有类文件并获取注解信息以及对应的类信息，这一步非常关键。spring其实也是有这种东西

2）通过反射，创建对象且执行用注解标注的方法

一、注解定义

        首先创建三个注解，注解内容是空，标注是运行时，且用于方法即可，具体如下：

package com.annotation.framework.annotation;

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

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface XTest {
}
package com.annotation.framework.annotation;

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

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface XBefore {
}
package com.annotation.framework.annotation;

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

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface XAfter {
}

二、包扫描

        这一步是非常关键的，因为通过这一步才能收集到类的所有信息，即哪些类中的哪些方法被XTest，XBefore，XAfter标注。

2.1、入口方法

    //入口
    public static AnnotationFramework run(Class clazz, String[] args) throws Exception {
        AnnotationFramework app = new AnnotationFramework();
        //包扫描并且创建对象
        Set<File> files = app.scanRootPackage(clazz);
        app.createBean(files);
        //执行对应的方法
        app.runCases();
        return app;
    }

2.2、scanRootPackage

        实现思路

1）通过入口方法，传进来的Class对象，获取包路径，然后扫描该包路径下所有类信息（实现比较简单，只扫描该包），代码实现过程中使用ClassLoader提供getSystemResource方法获取资源对象（spring中用的就是这个方法，哈哈，抄袭）。

2）将.class文件存储到set集合中，为后面创建对象做准备。

    private Set<File> scanRootPackage(Class clazz) throws Exception {
        Set<File> files = new HashSet<>();
        Package pack = clazz.getPackage();//获取包对象
        String resourcePath = pack.getName().replace(".", "/");

        //根据包路径，获取资源对象，通过资源对象获取File对象，可能是文件也可能是目录
        Enumeration<URL> rootResources = ClassLoader.getSystemResources(resourcePath);//
        while(rootResources.hasMoreElements()) {
            URL node = rootResources.nextElement();
            File file = new File(node.getFile());
            scanPackage(file, files);
        }
        return files;
    }

    //注意递归调用
    private void scanPackage(File file, Set<File> files) throws Exception {
        for (File f : file.listFiles()) {
            if (f.isDirectory()) {
                scanPackage(f, files);
            } else if (f.isFile()){
                String fileName = f.getName();
                String suffix = fileName.substring(fileName.lastIndexOf(".")+1);
                if (suffix.equals("class")) {
                    files.add(f);
                }
            }
        }
    }

2.3、解析.class文件

        上一步，收集到所有的class文件，那么就要逐一对class文件解析，获取注解信息了。这一步中sping使用的asm字节码技术，这里为了方便采用的是classloader方式。

    private void createBean(Set<File> files) throws Exception {
        for (File file : files) {
            createBeanByClassloader(file);
            //这里可以使用 asm字节码技术 解析class文件
            //spring使用的就是asm字节码技术，asm字节码技术比通过classloader方式要快很多，但是由于asm字节码技术比较晦涩
            //有一定的学习门槛
        }
    }
    private void createBeanByClassloader(File file) throws Exception {
        ///Users/abc/IdeaProjects/untitled/target/classes/com/annotation/framework/annotation/XTest.class
        String classFile = file.getPath().substring(file.getPath().indexOf("classes") + 8);
        classFile = classFile.substring(0, classFile.lastIndexOf('.')).replace('/', '.');
        //System.out.println(classFile);
        Class clazz = ClassLoader.getSystemClassLoader().loadClass(classFile);
        if (clazz.getSimpleName().isEmpty()) {
            return;
        }
        genericBean(clazz); //获取到Class对象，反射创建对象
    }

三、通过反射创建对象

        上面获取到class对象后，我们就可以获取到方法（类）上的Annotation信息了，具体如下

    private void genericBean(Class clazz) {
        String name = Bean.genericBeanName(clazz.getSimpleName());
        for (Method method : clazz.getDeclaredMethods()) {
            for (Annotation annotation : method.getAnnotations()) {
                if (annotation.annotationType().getName().equals(XTest.class.getName())) {
                    StoreSingleBean(name, clazz, method, 0);
                } else if (annotation.annotationType().getName().equals(XBefore.class.getName())) {
                    StoreSingleBean(name, clazz, method, 1);
                } else if (annotation.annotationType().getName().equals(XAfter.class.getName())) {
                    StoreSingleBean(name, clazz, method, 2);
                }
            }
        }
    }

        外层遍历所有方法 ，内层遍历方法标注的所有注解，然后判断注解是否为XTest，XAfter，XBefore，当属于这三个注解时，就创建Bean对象。

    private void StoreSingleBean(String beanName, Class clazz, Method method, int type) {
        Bean bean = this.map.get(beanName);//Map<String, Bean> map = new ConcurrentHashMap<>();
        if (bean == null) {
            bean = new Bean(beanName, clazz);
            this.map.put(beanName, bean);
        }
        if (type == 0) {// XTest
            bean.PutTest(method);
        } else if (type == 1) {// XBefore
            bean.PutBefore(method);
        } else if (type == 2) {
            bean.PutAfter(method);
        }
    }

 创建Bean对象比较简单，具体如下：

public class Bean {
    private String beanName;
    private Class clazz; //class对象
    private Object instance; //实例对象
    private List<Method> before; //用XBefore标注的方法列表
    private List<Method> after; //用XAfter标注的方法列表
    private List<Method> test; //用XTest标准的方法列表

    public Bean(String beanName, Class clazz) {
        this.beanName = beanName;
        this.clazz = clazz;
        try {
            this.instance = clazz.newInstance(); //反射创建实例对象
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        this.before = new LinkedList<>();
        this.after = new LinkedList<>();
        this.test = new LinkedList<>();
    }

    public void PutBefore(Method m) {
        this.before.add(m);
    }
    public void PutAfter(Method m) {
        this.after.add(m);
    }
    public void PutTest(Method m) {
        this.test.add(m);
    }

    public static String genericBeanName(String original) {
        char[] data = original.toCharArray();
        data[0] = Character.toLowerCase(data[0]);
        return new String(data);
    }

    public void runBefore() {
        for (Method m : this.before) {
            try {
                m.invoke(instance);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }
    }

    public void runTest() {
        for (Method m : this.test) {
            try {
                m.invoke(instance);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }
    }

    public void runAfter() {
        for (Method m : this.after) {
            try {
                m.invoke(instance);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }
    }
}

四、应用

        至此，注解功能实现基本完成，下面是应用，那自然就很简单了，创建一个main方法类，然后在创建一个Test类。

public class AnnotationTest {

    public static void main(String[] args) throws Exception {
        AnnotationFramework.run(AnnotationTest.class, args);
    }
}
public class GenericTest {
    @XBefore
    public void test0() {
        System.out.println("test0 XBefore");
    }

    @XAfter
    public void test2() {
        System.out.println("test2 XAfter");
    }

    @XTest
    public void test1() {
        System.out.println("test1 XTest");
    }
}

执行结果如下：

五、总结

        以上是对于注解理解，期间参考了spring的源码实现，基本思路就是按照上面描述一样。只不过spring实现的更复杂一些，支撑功能更强大一些。希望能帮到对于注解感兴趣的小伙伴。之前写过一篇关于lombok gettet，setter的实现《lombok注解实现（annotation）》实现机制不太一样。

xxb249
关注
专栏目录
Java注解与反射原理说明
08-26
Java注解（Annotation）是Java语言提供的一种元数据机制，允许程序员在代码中嵌入信息，这些信息可以被编译器、JVM或其他工具在编译时或运行时读取和处理。注解的主要用途包括代码的自我描述、编译器检查、运行时的...
注解及其原理
qq_44441957的博客
11-18 6454
Java 注解及其原理（一）： 一、 1.什么是注解？ java注解（Annotation）又称java标注，是JDK5.0引入的一种注释机制。java中的类、方法、变量、参数、和包等都可以被标注。java标注可以通过反射获取标注内容。供给指定的工具或框架使用。 理解Annotation的关键，是理解Annotation的语法和用法。 2.注解的用处 1 最常见的就是生成文档，也是java最早提供的注解。最常用的有@param @return等 ...
一篇文章带你搞懂 Java 注解的原理
南淮北安的博客
11-12 6628
文章目录一、注解的本质二、元注解三、Java 内置的三大注解四、注解与反射五、总结 一、注解的本质 注解的本质就是一个继承了 Annotation 接口的接口 例如： JDK 内置注解的定义： @Target(ElementType.METHOD) @Retention(RetentionPolicy.SOURCE) public @interface Override { } 这是注解 @Override 的定义，其实它本质上就是： public interface Override extends A
天天用注解，你知道注解到底是怎样实现的吗？
热门推荐
Mr_wxc的博客
07-16 1万+
注解，也叫元数据，是一种代码级别的说明。它是JDK1.5引入的一个特性，与类、接口、枚举类所在同一个层次。它可以声明在包、类、方法、成员变量、构造器、局部变量、方法参数等的上面，用来对这些元素进行说明、注释。也可以把注解理解为代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过注解开发人员可以在不改变原有代码和逻辑的情况下在源代码中嵌入补充信息。 1、注解的作用分类 (1)生成文档相关的注释说明：通过代码里标识的注解可以生成文档相关的注释说明。 下面我们就来演示一下，首先我们编
深入理解Java注解的实现原理，注解的本质
weixin_54542328的博客
11-22 354
定义注解使用注解return "";获取注解try {​。
Spring重要注解介绍以及原理
qq_47075878的博客
05-09 993
*** 4)、自定义组件想要使用Spring容器底层的一些组件(ApplicationContext,BeanFactory,xxx);* 自定义组件实现xxxAware;在创建对象的时候，会调用接口(Aware)规定的方法注入相关组件；* 把Spring底层一些组件注入到自定义的bean中;* xxxAware:功能使用xxxProcessor来处理的;* 例： ApplicationContextAware ==> ApplicationContextAwareProcessor;
Java 什么是注解及注解原理详细介绍
08-31
Java注解，又称为元数据，是自JDK1.5版本起引入的一种特性，用于在代码中添加额外的信息，可以应用于包、类、接口、字段、方法参数以及局部变量等。注解的主要功能包括： 1. **生成文档**：通过在代码中使用特定的...
java编译原理词法分析器
07-22
Java编译原理是计算机科学中的一个重要领域，它探讨了如何将高级编程语言转换为机器可理解的指令。在这个实验中，我们关注的是词法分析器，这是编译器设计过程中的第一步。词法分析器，也称为扫描器或词法分析阶段，...
Java annotation元注解原理实例解析
08-19
Java Annotation元注解原理实例解析 Java annotation是Java语言中的一种元编程技术，用于在编译期或运行期提供元数据，以便简化代码、提高开发效率和程序的可读性。在这篇文章中，我们将深入探讨Java annotation的...
spring中注解的实现原理
03-23
NULL 博文链接：https://zxf-noimp.iteye.com/blog/1071765
注解Annotation实现原理与自定义注解例子.pdf
01-07
注解Annotation实现原理与自定义注解例子 每当你创建描述符性质的类或者接口时,一旦其中包含重复性的工 作，就可以考虑使用注解来简化与自动化该过程。 Java提供了四种元注解，专门负责新注解的创建工作
java 注解（Annotation）实现原理
不了痕的博客
04-03 2261
一、注解的介绍 注解是java的一种语言特性，在java5的时候开始引入，位于java.lang.annotation包中。 概念：注解是用于给java代码附加元数据，可在编译时或运行时解析并处理这些元数据的方法。简单理解就是给特定的包名、类、方法、成员变量贴上一个特殊意义的标签，人看到这个标签就能清楚他的作用和作用范围，机器看到这个标签就会实现这个标签所对应的业务逻辑（如果有业务逻辑的情况下...
java注解的实现原理
CTO_1649900265的专栏
06-08 2819
今天将从以下4个方面来系统的学习一下java注解 什么是注解 注解的用途 注解使用演示 注解的实现原理 1．什么是注解 注解也叫元数据，例如我们常见的@Override和@Deprecated，注解是JDK1.5版本开始引入的一个特性，用于对代码进行说明，可以对包、类、接口、字段、方法参数、局部变量等进行注解 一般常用的注解可以分为三类： 一类是Java自带的标准注解，包括@Override（标明重写某个方法）、@Deprecated（标明某个类或方法过时）和@SuppressWarni
Java注解实现原理
hongfenglx的博客
09-30 1591
一、今天将从以下4个方面来系统的学习一下java注解 什么是注解 注解的用途 注解使用演示 注解的实现原理 1.什么是注解 注解也叫元数据，例如我们常见的@Override和@Deprecated，注解是JDK1.5版本开始引入的一个特性，用于对代码进行说明，可以对包、类、接口、字段、方法参数、局部变量等进行注解。 ...
注解原理剖析：带你搞懂注解的底层源码和实现机制
威哥爱编程，CSDN 博客专家、全栈领域新星创作者、华为 HDE，愿交天下 IT 技术爱好者
10-20 1552
而在该方法中，有两个需要我们关注的方法：parseMemberValue和annotationForMap，其中的parseMemberValue，就是用来解析我们使用注解时配置的参数值到一个Map集合中。我们可以看到，在上述方法中，内部调用了initAnnotationsIfNecessary()方法，接下来我们看看该方法的内部实现。我们知道，在平时的开发中，注解的运用是随处可见的，所以对于注解的运用，相信大家都不陌生。但我们在代码中使用的注解对象是怎么生成的呢？这些注解的底层是什么样的呢？
Spring注解是如何实现的？
架构师专栏
01-22 1350
1、Java注解（Annotations），首次出现在Java 5中，是一种用于类、方法、变量、参数和Java包的特殊标记。在此之前，Java开发者通常依赖于文档、注释或命名约定来传达某些信息，这些方式并不是语言结构的一部分，因此不能被编译器或运行时环境所理解和利用。本文已收录于，我的技术网站ddkk.com，有大厂完整面经，工作技术，架构师成长之路，等经验分享2、注解的出现，为Java程序提供了一种将元数据（关于数据的数据）直接嵌入代码的方法。
2.4.1、注解介绍
刘东阳的博客
09-06 332
三、注解的使用 注解是在1.5版本引入的，现在已经成为日常程序开发中非常重要的一部分。注解是一种元数据，本身没有任何作用，如果要有，必须依附在具体的对象上，在日常使用中最常见的两个注解是@Override和@Deprecated。 先不考虑注解具体的概念、用法和如何工作等问题，注解与“标签”的概念十分相似，@Override可以理解为在方法上添加了一个标签，其代表的就是“这是一个继承关系中，子类已经重写的方法。”更进一步理解，这个标签在某个方法上加上之后，如果父类中没有该方法，那么在编译的时..
@Autowired注解到底怎么实现的，你能说清楚么？
Java知音
06-24 1568
前言使用spring开发时，进行配置主要有两种方式，一是xml的方式，二是java config的方式。spring技术自身也在不断的发展和改变，从当前springboot的火热程度来看，...
java 注解原理以及反编译
最新发布
07-04
Java注解（Annotation）是一种元数据，用于在程序中提供额外的信息但并不直接参与程序的运行。它们被用来标记代码元素，如类、方法、变量等，以便工具和构建系统能够读取这些信息并执行特定的行为。Java注解不改变源...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值