Spring注解的原理与自定义注解的实现

最新推荐文章于 2024-06-28 17:41:02 发布
最新推荐文章于 2024-06-28 17:41:02 发布
阅读量1.6w 收藏 40
点赞数 5
分类专栏： spring JAVA springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wooyulin/article/details/79158483
版权
JAVA 同时被 3 个专栏收录
6 篇文章 0 订阅
订阅专栏
springboot
3 篇文章 0 订阅
订阅专栏
spring
2 篇文章 0 订阅
订阅专栏
本文只是用于记录个人在学习annotation过程中的心德，所以知识面不太完善。
1、注解的基本概念
    Java 的annotation提供的是一种类似于注释的机制，注解本身不做任何事，好比一个配置或者说一个标记。用于 包、类型、构造方法、方法、成员变量、参数及本地变量的标记。
    程序后续可以利用java的反射机制来了解各种元素是否有何标记，针对不同的标记，作出相应的操作。

总而言之，annotation并没有那么玄乎，并不是打个标记就会帮你做什么事情，这个要做的事情还是要在后续配套的反射函数来自己实现。

2、spring注解的原理
以前看到spring的各种注解、xml配置就可以实现很多的东西，对新手而言是很难理解的，但其实只要懂了java的注解原理，这些都是很简单的。就好像spring 在xml里面配置了

以下便以一个读取xml中配置的注解例子来理解一下原理（这个例子我是照搬zxf的，这个原博主我找不到了，因为看的都是别人转载的，我觉得这个例子很好，所以就照搬过来了）
1、定义注解
package com.yulam.myannotation.annotation ;

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

/**
* @author: 5yl
* time : 2018/1/24 下午10:49
*/

// 在运行时执行
@Retention (RetentionPolicy. RUNTIME )
// 注解适用地方(字段和方法)
@Target ({ ElementType. FIELD , ElementType. METHOD })
public @ interface ZxfResource {

    //注解的name属性
    public String name () default "" ;
}

2、 带有注解的服务类
    
ublic class UserServiceImpl {

    public UserDaoImpl userDao ;
    public User1DaoImpl user1Dao ;

    // 字段上的注解,可以配置name属性
    @ZxfResource
    public User2DaoImpl user2Dao ;

    // set方法上的注解，带有name属性
    @ZxfResource ( name = "userDao" )
    public void setUserDao (UserDaoImpl userDao) {
        this . userDao = userDao ;
    }

    // set方法上的注解，没有配置name属性
    @ZxfResource
    public void setUser1Dao (User1DaoImpl user1Dao) {
        this . user1Dao = user1Dao ;
    }

    public void show () {
        userDao .show() ;
        user1Dao .show1() ;
        user2Dao .show2() ;
        System. out .println( "这里是Service方法........" ) ;
    }
 
3、要注入的类
其中2、3类我就不一一列出来了，但是会放上源码
package com.yulam.myannotation.dao ;

/**
* @author: 5yl
* time : 2018/1/24 下午10:53
*/

public class UserDaoImpl {

    String name ;

    public void show(){
        System. out.println( "这里是dao方法........") ;
    }
}
4、xml文件
<? xml version ="1.0" encoding ="UTF-8" ?>
<beans>
    <!--这里的class记得改，不然后面反射找不到 -->
    <bean id = "userDao" class ="com.yulam.myannotation.dao.UserDaoImpl" />
    <bean id = "user1Dao" class ="com.yulam.myannotation.dao.User1DaoImpl" />
    <bean id = "user2Dao" class ="com.yulam.myannotation.dao.User2DaoImpl" />
    <bean id = "userService" class = "com.yulam.myannotation.service.UserServiceImpl" />
</beans>
5、与注解配套的处理器
其中有定义一个BeanDefine，这个只是简单的pojo，只有id、className两个属性用于装载xml解析出来的bean
package com.yulam.myannotation.service ;

import com.yulam.myannotation.annotation. ZxfResource ;
import com.yulam.myannotation.pojo.BeanDefine ;
import lombok.extern.slf4j. Slf4j ;
import org.dom4j.Document ;
import org.dom4j.DocumentException ;
import org.dom4j.Element ;
import org.dom4j.io.SAXReader ;

import java.beans.Introspector ;
import java.beans.PropertyDescriptor ;
import java.lang.reflect.Field ;
import java.lang.reflect.Method ;
import java.util.* ;

/**
* @author: 5yl
* time : 2018/1/25 上午9:29
*/

@Slf4j
public class ClassPathXMLApplicationContext {
//    Logger log = Logger.getLogger(ClassPathXMLApplicationContext.class);

    List<BeanDefine> beanList = new ArrayList<BeanDefine>() ;
    Map<String , Object> sigletions = new HashMap<String , Object>() ;

    public ClassPathXMLApplicationContext(String fileName) {
        //读取配置文件中管理的bean
        this.readXML(fileName) ;
        //实例化bean
        this.instancesBean() ;
        //注解处理器
        this.annotationInject() ;
    }

    /**
     * 读取Bean配置文件
     * @param fileName
     * @return
     */
    @SuppressWarnings( "unchecked")
    public void readXML(String fileName) {
        Document document = null;
        SAXReader saxReader = new SAXReader() ;
        try {
            ClassLoader classLoader =
                    Thread. currentThread().getContextClassLoader() ;
            document = saxReader.read(classLoader.getResourceAsStream(fileName)) ;
            Element beans = document.getRootElement() ;
            for (Iterator<Element> beansList = beans.elementIterator() ;
                 beansList.hasNext() ;) {
                Element element = beansList.next() ;
                BeanDefine bean = new BeanDefine(
                        element.attributeValue( "id") ,
                        element.attributeValue( "class")) ;
                beanList.add(bean) ;
            }
        } catch (DocumentException e) {
            log.info( "读取配置文件出错....") ;
        }
    }

    /**
     * 实例化Bean
     */
    public void instancesBean() {
        for (BeanDefine bean : beanList) {
            try {
                sigletions.put(bean.getId() ,
                        Class. forName(bean.getClassName()).newInstance()) ;
            } catch (Exception e) {
                log.info( "实例化Bean出错...") ;
            }
        }
    }

    /**
     * 注解处理器
     * 如果注解ZxfResource配置了name属性，则根据name所指定的名称获取要注入的实例引用，
     * 如果注解ZxfResource;没有配置name属性，则根据属性所属类型来扫描配置文件获取要
     * 注入的实例引用
     *
     */
    public void annotationInject(){
        for(String beanName: sigletions.keySet()){
            Object bean = sigletions.get(beanName) ;
            if(bean!= null){
                this.propertyAnnotation(bean) ;
                this.fieldAnnotation(bean) ;
            }
        }
    }

    /**
     * 处理在set方法加入的注解
     * @param bean 处理的bean
     */
    public void propertyAnnotation(Object bean){
        try {
            //获取其属性的描述
            PropertyDescriptor[] ps =
                    Introspector. getBeanInfo(bean.getClass()).getPropertyDescriptors() ;
            for(PropertyDescriptor proderdesc : ps){
                //获取所有set方法
                Method setter = proderdesc.getWriteMethod() ;
                //判断set方法是否定义了注解
                if(setter!= null && setter.isAnnotationPresent( ZxfResource. class)){
                    //获取当前注解，并判断name属性是否为空
                    ZxfResource resource = setter.getAnnotation( ZxfResource. class) ;
                    String name = "" ;
                    Object value = null;
                    if(resource.name()!= null&&! "".equals(resource.name())){
                        //获取注解的name属性的内容
                        name = resource.name() ;
                        value = sigletions.get(name) ;
                    } else{ //如果当前注解没有指定name属性,则根据类型进行匹配
                        for(String key : sigletions.keySet()){
                            //判断当前属性所属的类型是否在配置文件中存在
                            if(proderdesc.getPropertyType().isAssignableFrom( sigletions.get(key).getClass())){
                                //获取类型匹配的实例对象
                                value = sigletions.get(key) ;
                                break;
                            }
                        }
                    }
                    //允许访问private方法
                    setter.setAccessible( true) ;
                    //把引用对象注入属性
                    setter.invoke(bean , value) ;
                }
            }
        } catch (Exception e) {
            log.info( "set方法注解解析异常..........") ;
        }
    }

    /**
     * 处理在字段上的注解
     * @param bean 处理的bean
     */
    public void fieldAnnotation(Object bean){
        try {
            //获取其全部的字段描述
            Field[] fields = bean.getClass().getFields() ;
            for(Field f : fields){
                if(f!= null && f.isAnnotationPresent( ZxfResource. class)){
                    ZxfResource resource = f.getAnnotation( ZxfResource. class) ;
                    String name = "" ;
                    Object value = null;
                    if(resource.name()!= null&&! "".equals(resource.name())){
                        name = resource.name() ;
                        value = sigletions.get(name) ;
                    } else{
                        for(String key : sigletions.keySet()){
                            //判断当前属性所属的类型是否在配置文件中存在
                            if(f.getType().isAssignableFrom( sigletions.get(key).getClass())){
                                //获取类型匹配的实例对象
                                value = sigletions.get(key) ;
                                break;
                            }
                        }
                    }
                    //允许访问private字段
                    f.setAccessible( true) ;
                    //把引用对象注入属性
                    f.set(bean , value) ;
                }
            }
        } catch (Exception e) {
            log.info( "字段注解解析异常..........") ;
        }
    }

    /**
     * 获取Map中的对应的bean实例
     * @param beanId
     * @return
     */
    public Object getBean(String beanId) {
        return sigletions.get(beanId) ;
    }


}

6、运行函数
package com.yulam.myannotation.service ;

import static org.junit.Assert.* ;

public class ClassPathXMLApplicationContextTest {

    public static void main(String[] args) {
        ClassPathXMLApplicationContext path = new ClassPathXMLApplicationContext(
                "configAnnotation.xml") ;
        UserServiceImpl userService =(UserServiceImpl)path.getBean( "userService") ;
        userService.show() ;
    }

}
结果：
这里是dao方法........
这里是dao1111方法........
这里是dao22222方法........
这里是Service方法........

Process finished with exit code 0

其中的原理代码中ZXF已经说的很明白了。放上源代码吧，原转载博主那里是没有可以直接运行的，对于新手来说，又一个可以直接运行的可以省很多时间。 

https://github.com/Wooyulin/annotation-test

Wooyulin
关注
  • 5
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
这一次搞懂Spring自定义标签以及注解解析原理说明
09-07
主要介绍了这一次搞懂Spring自定义标签以及注解解析原理说明，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
一篇文章带你搞懂 Java 注解的原理
南淮北安的博客
11-12 6540
文章目录一、注解的本质二、元注解三、Java 内置的三大注解四、注解与反射五、总结 一、注解的本质 注解的本质就是一个继承了 Annotation 接口的接口 例如： JDK 内置注解的定义： @Target(ElementType.METHOD) @Retention(RetentionPolicy.SOURCE) public @interface Override { } 这是注解 @Override 的定义，其实它本质上就是： public interface Override extends A
SpringBoot 注解原理，自动装配原理，图文并茂，万字长文！
最新发布
2401_85112749的博客
06-28 502
由于文案过于长，在此就不一一介绍了，这份Java后端架构进阶笔记内容包括：Java集合，JVM、Java并发、微服务、SpringNetty与 RPC 、网络、日志 、Zookeeper 、Kafka 、RabbitMQ 、Hbase 、MongoDB、Cassandra 、Java基础、负载均衡、数据库、一致性算法、Java算法、数据结构、分布式缓存等等知识详解。本知识体系适合于所有Java程序员学习，关于以上目录中的知识点都有详细的讲解及介绍，掌握该知识点的所有内容对你会有一个质的提升，
天天用注解，你知道注解到底是怎样实现的吗？
热门推荐
Mr_wxc的博客
07-16 1万+
注解，也叫元数据，是一种代码级别的说明。它是JDK1.5引入的一个特性，与类、接口、枚举类所在同一个层次。它可以声明在包、类、方法、成员变量、构造器、局部变量、方法参数等的上面，用来对这些元素进行说明、注释。也可以把注解理解为代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过注解开发人员可以在不改变原有代码和逻辑的情况下在源代码中嵌入补充信息。 1、注解的作用分类 (1)生成文档相关的注释说明：通过代码里标识的注解可以生成文档相关的注释说明。 下面我们就来演示一下，首先我们编
注解及其原理
qq_44441957的博客
11-18 6427
Java 注解及其原理（一）： 一、 1.什么是注解？ java注解（Annotation）又称java标注，是JDK5.0引入的一种注释机制。java中的类、方法、变量、参数、和包等都可以被标注。java标注可以通过反射获取标注内容。供给指定的工具或框架使用。 理解Annotation的关键，是理解Annotation的语法和用法。 2.注解的用处 1 最常见的就是生成文档，也是java最早提供的注解。最常用的有@param @return等 ...
面试官：我们天天用注解，那你知道注解的实现原理吗？
07-23 658
注解，也叫元数据，是一种代码级别的说明。它是JDK1.5引入的一个特性，与类、接口、枚举类所在同一个层次。它可以声明在包、类、方法、成员变量、构造器、局部变量、方法参数等的上面，用来对这些元素进行说明、注释。也可以把注解理解为代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过注解开发人员可以在不改变原有代码和逻辑的情况下在源代码中嵌入补充信息。 1、注解的作用分类 (1)生成文档相关的注释说明：通过代码里标识的注解可以生成文档相关的注释说明。 下面我们就来演示一下，首先我们.
Spring常用注解及自定义Filter的实现
08-25
Spring常用注解及自定义Filter的实现 Spring框架中有许多非常重要的注解，我们在平时的开发中经常会用到它们。这些注解可以帮助我们简化配置、提高开发效率和代码的可读性。 @Configuration注解通常用在配置类上...
详解使用Spring AOP和自定义注解进行参数检查
08-27
通过自定义注解和spring AOP，我们可以实现参数的校验，提高代码的可读性和可维护性。 自定义注解 在本篇文章中，我们定义了三个自定义注解：`ValidParam`、`NotNull`和`NotEmpty`。`ValidParam`注解用于标注需要...
Spring AOP 自定义注解的实现代码
08-30
Spring AOP 自定义注解的实现代码 Spring AOP（Aspect-Oriented Programming）是一种面向方面编程的技术，它可以将散布在应用程序中的各种关注点（例如安全、日志、事务等）提取出来，形成一个独立的模块，以便于...
Spring AOP + 注解实现统一注解功能
08-27
本文我们通过Spring AOP和Java的自定义注解来实现日志的插入功能，该方案对原有业务入侵较低，实现较灵活。下面我们将详细介绍该功能的实现原理和相关知识点。 1. 概述 在一般系统中，当我们做了一些重要的操作时...
Java注解实现原理
hongfenglx的博客
09-30 1472
一、今天将从以下4个方面来系统的学习一下java注解 什么是注解 注解的用途 注解使用演示 注解的实现原理 1.什么是注解 注解也叫元数据，例如我们常见的@Override和@Deprecated，注解是JDK1.5版本开始引入的一个特性，用于对代码进行说明，可以对包、类、接口、字段、方法参数、局部变量等进行注解。 ...
深入理解java注解的实现原理
Thinkingcao的专栏
11-13 4048
前言 在Spring 2.0及早期时代，Web项目开发是通过配置文件 xml来实现 Bean 的依赖注入，有多少个Bean，就在xml配置问价中加多少个，这样一来在 Bean 的数量越来越多的时候，xml的配置也就会越来越复杂，显得格外的冗余，很多代码都是一个模式，需要做下封装才好。Spring 2.0在xml配置文件上做了一定的优化，让配置看起来越来越简单，但是并没语完全解决xml冗余的问题...
理解java注解的实现原理
qq_43842093的博客
05-01 1万+
JAVA 注解的基本原理（重点） https://www.cnblogs.com/yangming1996/p/9295168.html 从以下4个方面来系统的学习一下java注解 什么是注解 注解的用途 注解使用演示 注解的实现原理 1，什么是注解 注解也叫元数据，例如我们常见的@Override和@Deprecated，注解是JDK1.5版本开始引入的一个特性，用于对代码进行说明，可以对包、类、接口、字段、方法参数、局部变量等进行注解 一般常用的注解可以分为三类： 一类是Java自带的标准注解，包
注解Annotation实现原理与自定义注解例子
weixin_30708329的博客
05-03 1034
什么是注解？ 对于很多初次接触的开发者来说应该都有这个疑问？Annontation是Java5开始引入的新特征，中文名称叫注解。它提供了一种安全的类似注释的机制，用来将任何的信息或元数据（metadata）与程序元素（类、方法、成员变量等）进行关联。为程序的元素（类、方法、成员变量）加上更直观更明了的说明，这些说明信息是与程序的业务逻辑无关，并且供指定的工具或框架使用。Annonta...
java注解的实现原理
CTO_1649900265的专栏
06-08 2795
今天将从以下4个方面来系统的学习一下java注解 什么是注解 注解的用途 注解使用演示 注解的实现原理 1．什么是注解 注解也叫元数据，例如我们常见的@Override和@Deprecated，注解是JDK1.5版本开始引入的一个特性，用于对代码进行说明，可以对包、类、接口、字段、方法参数、局部变量等进行注解 一般常用的注解可以分为三类： 一类是Java自带的标准注解，包括@Override（标明重写某个方法）、@Deprecated（标明某个类或方法过时）和@SuppressWarni
深入理解Java注解的实现原理，注解的本质
weixin_54542328的博客
11-22 333
定义注解使用注解return "";获取注解try {​。
注解底层实现原理
Java持续实践
02-21 1408
文章目录注解获取属性值的底层实现注解的工作原理 注解获取属性值的底层实现 JVM会为注解生成代理对象. 这一节的文章中提到的获取注解信息的代码 https://javaweixin6.blog.csdn.net/article/details/113914653 注意注解的生命周期都要设置为runtime 程序运行时, 设置如下的jvm参数, 保存生成的代理对象成为文件 -Djdk.proxy.ProxyGenerator.saveGeneratedFiles=true 只获取成员属性的值. 运行上
Spring重要注解介绍以及原理
qq_47075878的博客
05-09 962
*** 4)、自定义组件想要使用Spring容器底层的一些组件(ApplicationContext,BeanFactory,xxx);* 自定义组件实现xxxAware;在创建对象的时候，会调用接口(Aware)规定的方法注入相关组件；* 把Spring底层一些组件注入到自定义的bean中;* xxxAware:功能使用xxxProcessor来处理的;* 例： ApplicationContextAware ==> ApplicationContextAwareProcessor;
自定义注解实现原理
m0_47743175的博客
11-27 976
自定义注解实现原理
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值