@autowired 订阅
@Autowired是一种注解,可以对成员变量、方法和构造函数进行标注,来完成自动装配的工作,@Autowired标注可以放在成员变量上,也可以放在成员变量的set方法上,也可以放在任意方法上表示,自动执行当前方法,如果方法有参数,会在IOC容器中自动寻找同类型参数为其传值。这里必须明确:@Autowired是根据类型进行自动装配的,如果需要按名称进行装配,则需要配合@Qualifier使用; 展开全文
@Autowired是一种注解,可以对成员变量、方法和构造函数进行标注,来完成自动装配的工作,@Autowired标注可以放在成员变量上,也可以放在成员变量的set方法上,也可以放在任意方法上表示,自动执行当前方法,如果方法有参数,会在IOC容器中自动寻找同类型参数为其传值。这里必须明确:@Autowired是根据类型进行自动装配的,如果需要按名称进行装配,则需要配合@Qualifier使用;
信息
外文名
@Autowired
方    式
在applicationContext.xml中加入
定    义
Spring框架中进行注入式
中文名
@Autowired
所    属
计算机
@Autowired注解
Spring框架中进行注入时,使用@Autowired.前者,Spring会直接将UserDao类型的唯一一个bean赋值给userDao这个成员变量;后者,Spring会调用setUserDao方法来将UserDao类型的唯一一个bean装配到userDao这个属性。Spring 2.5 引入了 @Autowired 注释,它可以对类成员变量、方法及构造函数进行标注,完成自动装配的工作。 通过 @Autowired的使用来消除 set ,get方法。要实现我们要精简程序的目的。需要这样来处理:   * 在applicationContext.xml中加入:[c-sharp] view plaincopyprint?Spring 通过一个 BeanPostProcessor 对 @Autowired 进行解析,所以要让 @Autowired 起作用必须事先在 Spring 容器中声明 AutowiredAnnotationBeanPostProcessor Bean。  * 修改在原来注入spring容器中的bean的方法。   在域变量上加上标签@Autowired,并且去掉 相应的get 和set方法清单 6. 使用 @Autowired 注释的 Boss.java[java] view plaincopyprint?package com.baobaotao; import org.springframework.beans.factory.annotation.Autowired; public class Boss { @Autowired private Car car; @Autowired private Office office; … }* 在applicationContext.xml中 把原来 引用的标签也去掉。[xhtml] view plaincopyprint? 这样,当 Spring 容器启动时,AutowiredAnnotationBeanPostProcessor 将扫描 Spring 容器中所有 Bean,当发现 Bean 中拥有 @Autowired 注释时就找到和其匹配(默认按类型匹配)的 Bean,并注入到对应的地方中去。     按照上面的配置,Spring 将直接采用 Java 反射机制对 Boss 中的 car 和 office 这两个私有成员变量进行自动注入。所以对成员变量使用 @Autowired 后,您大可将它们的 setter 方法(setCar() 和 setOffice())从 Boss 中删除。     当然,您也可以通过 @Autowired 对方法或构造函数进行标注,如果构造函数有两个入参,分别是 bean1 和 bean2,@Autowired 将分别寻找和它们类型匹配的 Bean,将它们作为 CountryService (Bean1 bean1 ,Bean2 bean2) 的入参来创建 CountryService Bean。来看下面的代码: 对方法[java] view plaincopyprint?package com.baobaotao; public class Boss { private Car car; private Office office; @Autowired public void setCar(Car car) { this.car = car; } @Autowired public void setOffice(Office office) { this.office = office; } … }
收起全文
精华内容
下载资源
问答
  • @autowired
    2022-02-09 20:24:55

    @Autowired

    @Autowired是用在JavaBean中的注解,通过byType形式,用来给指定的字段或方法注入所需的外部资源

    原理:

    在启动spring IoC时,容器自动装载了一个AutowiredAnnotationBeanPostProcessor后置处理器,当容器扫描到@Autowied、@Resource(是CommonAnnotationBeanPostProcessor后置处理器处理的)或@Inject时,就会在IoC容器自动查找需要的bean,并装配给该对象的属性

    我通俗的理解为:@Autowired是一个自动装配的工具,当这个注解加在某个变量上时,系统自动的去容器里找这个类型的对象,如果容器里只有一个,那个就把容器里的对象注入到该注解指定的变量的位置上(赋值);如果容器里,这个类型的对象多于一个,则按ByName方式查找;如果容器里没有这个对象,那么会抛出异常。解决方法时,使用required=false

    作用:

    @Autowired有什么作用呢 作为spring核心思想IOC的核心注解,我认为他的主要作用就是引入容器里已有的对象的值(它比new好的一点就是,new是创建新的,@Autowired是拿现有的,所以@Autowired能做到数据共享,而new不行

    spring是一个容器,这个容器里面有各种各样的对象,当人们想用容器里的对象时,去容器里拿现有的对象直接用。

    那么什么时候能体现@Autowired的方便性呢?

    当一个类的变量要被多个类使用时,且该变量的内容被多个类共享时,这个时候我们的解决办法就是:把这个要被多次使用且数据共享的类放到spring容器中,由spring容器管理它,我们使用@Autowired引入容器里的类

    举个例子:

    要求实现一个项目要在指定时间发布出去。方案:我首先想到的就是spring的定时任务,那么实现起来的话,我分为任务类(要做什么),任务管理类(任务调度器,添加任务,移除任务),service

    在这个例子是怎么体现数据共享的呢?我们往下看 任务管理类中有一个Map存储正在运行的任务(可以理解为线程池的显示) 那我们发布完项目,这个任务应该结束掉(在线程池中移除),所以,我们需要在执行完任务,就把该任务从线程池中移除,那么就是在任务类中引入任务管理类,并做到共享线程池(map) 做法:在任务管理类上加@Component把它放到spring容器中,再任务类中某变量上加入@Autowired引入容器中的对象。

    注:@Autowired和构造方法

    Java变量的初始化顺序为:静态变量或静态语句块–>实例变量或初始化语句块–>构造方法

    声明:构造方法是在@Autowired前执行

    eg:

    @Autowired写在构造方法外,他的实际值为null

    public class TaskRunnable implements Runnable  {
        private String name;
    
        @Autowired
        private TaskManager taskManager;
        
        public TaskRunnable(String name) {
            this.name = name;
        }
    }
    

    这么写才是正确的,当该类有有参构造时,@Autowired要加在构造方法上能引入容器中的对象

    public class TaskRunnable implements Runnable  {
        private String name;
    
        private TaskManager taskManager;
        @Autowired
        public TaskRunnable(String name,TaskManager taskManager) {
            this.name = name;
            this.taskManager=taskManager;
        }
    }
    
    更多相关内容
  • 主要介绍了@Autowired注入为null问题原因分析吗,小编觉得挺不错的,对日后比较有帮助,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 通过@Bean 和spring的factoryBean注入的bean. 以及对应@service注解注入的类 通过@Autowired 注入对象的时间是现根据类型在根据beanName获取的案例集合
  • WebappApplication 一定要在包的最外层,否则Spring无法对所有的类进行托管,会造成@Autowired 无法注入。接下来给大家介绍解决Springboot @Autowired 无法注入问题,感兴趣的朋友一起看看吧
  • 主要介绍了Spring使用@Autowired为抽象父类注入依赖代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要给大家介绍了因Spring AOP导致@Autowired依赖注入失败的解决方法,文中通过示例代码给大家介绍的非常详细,对大家具有一定的参考学习价值,需要的朋友们下面跟着小编来一起学习学习吧。
  • 通过spring 的BeanPostProcessor 将对象注入到spring之前创建一个代理对象注入到spring容器中,通过@autowired 注入的对象就是指定的代理对象内容
  • Spring框架中 @Autowired 和 @Resource 注解的区别 在 spring 框架中,除了使用其特有的注解外,使用基于 JSR-250 的注解,它包括 @PostConstruct, @PreDestroy 和 @Resource 注释。  首先,咱们简单了解 @...
  • 本篇文章主要介绍最重要的三个Spring注解,也就是@Autowired、@Resource和@Service,具有很好的参考价值。下面跟着小编一起来看下吧
  • 主要介绍了SpringBoot项目使用多线程处理任务时无法通过@Autowired注入bean问题的解决方法,需要的朋友可以参考下
  • 主要介绍了@Autowired(required=false)注入注意的问题,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 主要介绍了Spring Boot 自定义 Shiro 过滤器无法使用 @Autowired问题及解决方法 ,本文给大家介绍的非常详细,具有一定的参考借鉴价值,需要的朋友可以参考下
  • NULL 博文链接:https://forestqqqq.iteye.com/blog/2235292
  • 主要介绍了详解Spring @Autowired 注入小技巧,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要介绍了详解Spring依赖注入:@Autowired,@Resource和@Inject区别与实现原理,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要介绍了你所不知道的Spring的@Autowired实现细节分析,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 今天小编就为大家分享一篇关于SpringBoot集成shiro,MyRealm中无法@Autowired注入Service的问题,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • @Autowired、@Qualifier、@Resource的区别

    参考博文:

    http://www.cnblogs.com/happyyang/articles/3553687.html

    http://blog.csdn.net/revent/article/details/49203619

    http://blog.csdn.net/ad921012/article/details/49679745

    spring不但支持自己定义的@Autowired注解,还支持几个由JSR-250规范定义的注解,它们分别是@Resource、@PostConstruct以及@PreDestroy。
      @Resource的作用相当于@Autowired,只不过@Autowired按byType自动注入,而@Resource默认按 byName自动注入罢了。@Resource有两个属性是比较重要的,分是name和type,Spring将@Resource注解的name属性解析为bean的名字,而type属性则解析为bean的类型。所以如果使用name属性,则使用byName的自动注入策略,而使用type属性时则使用byType自动注入策略。如果既不指定name也不指定type属性,这时将通过反射机制使用byName自动注入策略。
      @Resource装配顺序
      1. 如果同时指定了name和type,则从Spring上下文中找到唯一匹配的bean进行装配,找不到则抛出异常
      2. 如果指定了name,则从上下文中查找名称(id)匹配的bean进行装配,找不到则抛出异常
      3. 如果指定了type,则从上下文中找到类型匹配的唯一bean进行装配,找不到或者找到多个,都会抛出异常
      4. 如果既没有指定name,又没有指定type,则自动按照byName方式进行装配;如果没有匹配,则回退为一个原始类型进行匹配,如果匹配则自动装配;

    @Autowired 与@Resource的区别:

    1、 @Autowired与@Resource都可以用来装配bean. 都可以写在字段上,或写在setter方法上。

    2、 @Autowired默认按类型装配(这个注解是属业spring的),默认情况下必须要求依赖对象必须存在,如果要允许null值,可以设置它的required属性为false,如:@Autowired(required=false) ,如果我们想使用名称装配可以结合@Qualifier注解进行使用,如下:

    1

    2

    @Autowired () @Qualifier ( "baseDao" )

    private BaseDao baseDao;

    3、@Resource(这个注解属于J2EE的),默认按照名称进行装配,名称可以通过name属性进行指定,如果没有指定name属性,当注解写在字段上时,默认取字段名进行安装名称查找,如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是,如果name属性一旦指定,就只会按照名称进行装配。

    1

    2

    @Resource (name= "baseDao" )

    private BaseDao baseDao;

    推荐使用:@Resource注解在字段上,这样就不用写setter方法了,并且这个注解是属于J2EE的,减少了与spring的耦合。这样代码看起就比较优雅。

    spring @Qualifier注解

    @Autowired是根据类型进行自动装配的。如果当Spring上下文中存在不止一个UserDao类型的bean时,就会抛出BeanCreationException异常;如果Spring上下文中不存在UserDao类型的bean,也会抛出BeanCreationException异常。我们可以使用@Qualifier配合@Autowired来解决这些问题。如下:

    ①可能存在多个UserDao实例

    1. @Autowired   
      @Qualifier("userServiceImpl")   
      public IUserService userService; 
        或者
    2. @Autowired   
      public void setUserDao(@Qualifier("userDao") UserDao userDao) {   
          this.userDao = userDao;   
      }  

    这样Spring会找到id为userServiceImpl和userDao的bean进行装配。

    ②可能不存在UserDao实例

    @Autowired(required = false)   
    public IUserService userService  

    个人总结:

    @Autowired//默认按type注入
    @Qualifier("cusInfoService")//一般作为@Autowired()的修饰用
    @Resource(name="cusInfoService")//默认按name注入,可以通过name和type属性进行选择性注入

    一般@Autowired和@Qualifier一起用,@Resource单独用。

    当然没有冲突的话@Autowired也可以单独用

    -----------常用注解--------

    --定义Bean的注解

    @Controller

    @Controller("Bean的名称")

    定义控制层Bean,如Action

    @Service          

    @Service("Bean的名称")

    定义业务层Bean

    @Repository   

    @Repository("Bean的名称")

    定义DAO层Bean

    @Component  

    定义Bean, 不好归类时使用.

    --自动装配Bean (选用一种注解就可以)

    @Autowired  (Srping提供的)

    默认按类型匹配,自动装配(Srping提供的),可以写在成员属性上,或写在setter方法上

    @Autowired(required=true)  

    一定要找到匹配的Bean,否则抛异常。 默认值就是true 

    @Autowired

    @Qualifier("bean的名字") 

    按名称装配Bean,与@Autowired组合使用,解决按类型匹配找到多个Bean问题。

    @Resource   JSR-250提供的

    默认按名称装配,当找不到名称匹配的bean再按类型装配.

    可以写在成员属性上,或写在setter方法上

    可以通过@Resource(name="beanName") 指定被注入的bean的名称, 要是未指定name属性, 默认使用成员属性的变量名,一般不用写name属性.

    @Resource(name="beanName")指定了name属性,按名称注入但没找到bean, 就不会再按类型装配了.

    @Inject   是JSR-330提供的

    按类型装配,功能比@Autowired少,没有使用的必要。

    --定义Bean的作用域和生命过程

    @Scope("prototype")

    值有:singleton,prototype,session,request,session,globalSession

    @PostConstruct 

    相当于init-method,使用在方法上,当Bean初始化时执行。

    @PreDestroy 

    相当于destory-method,使用在方法上,当Bean销毁时执行。

    --声明式事务

    @Transactional  

    @Autowired @Resource @Qualifier的区别

    实用理解:@Autowired @Resource 二选其一,看中哪个就用哪个。

    简单理解:

    @Autowired 根据类型注入, 

    @Resource 默认根据名字注入,其次按照类型搜索

    @Autowired @Qualifie("userService") 两个结合起来可以根据名字和类型注入

    复杂理解:

    比如你有这么一个Bean

    @Service(“UserService”)

    public Class UserServiceImpl implements UserService{};

    现在你想在UserController 里面使用这个UserServiceImpl 

    public Class UserController {

    @AutoWired   //当使用这个注入的时候上面的 UserServiceImpl 只需要这样写 @Service,这样就会自动找到UserService这个类型以及他的子类型。UserServiceImpl 实现了UserService,所以能够找到它。不过这样有一个缺点,就是当UserService实现类有两个以上的时候,这个时候会找哪一个呢,这就造成了冲突,所以要用@AutoWire注入的时候要确保UserService只有一个实现类。

    @Resource 默认情况下是按照名称进行匹配,如果没有找到相同名称的Bean,则会按照类型进行匹配,有人可能会想了,这下好了,用这个是万能的了,不用管名字了,也不用管类型了,但这里还是有缺点。首先,根据这个注解的匹配效果可以看出,它进行了两次匹配,也就是说,如果你在UserService这个类上面这样写注解,@Service,它会怎么找呢,首先是找相同名字的,如果没有找到,再找相同类型的,而这里的@Service没有写名字,这个时候就进行了两次搜索,显然,速度就下降了许多。也许你还会问,这里的@Service本来就没有名字,肯定是直接进行类型搜索啊。其实不是这样的,UserServiceImpl 上面如果有@Service默认的名字 是这个userServiceImpl,注意看,就是把类名前面的大写变成小写,就是默认的Bean的名字了。 @Resource根据名字搜索是这样写@Resource("userService"),如果你写了这个名字叫userService,那么UserServiceImpl上面必须也是这个名字,不然还是会报错。

    @Autowired @Qualifie("userService") 是直接按照名字进行搜索,也就是说,对于UserServiceImpl 上面@Service注解必须写名字,不写就会报错,而且名字必须是@Autowired @Qualifie("userService") 保持一致。如果@Service上面写了名字,而@Autowired @Qualifie() ,一样会报错。

    private UserService userService;

    说了这么多,可能你有些说晕了,那么怎么用这三个呢,要实际的工作是根据实际情况来使用的,通常使用AutoWire和@Resource多一些,bean的名字不用写,而UserServiceImpl上面能会这样写 @Service("userService")。这里的实际工作情况,到底是什么情况呢?说白了就是整个项目设计时候考虑的情况,如果你的架构设计师考虑的比较精细,要求比较严格,要求项目上线后的访问速度比较好,通常是考虑速度了。这个时候@AutoWire没有@Resource好用,因为@Resource可以根据名字来搜索,是这样写的@Resource("userService")。这个@Autowired @Qualifie("userService") 也可以用名字啊,为什么不用呢,原因很简单,这个有点长,不喜欢,增加工作量。因为根据名字搜索是最快的,就好像查数据库一样,根据Id查找最快。因为这里的名字与数据库里面的ID是一样的作用。这个时候,就要求你多写几个名字,工作量自然就增加了。而如果你不用注解,用xml文件的时候,对于注入Bean的时候要求写一个Id,xml文件时候的id就相当于这里的名字。

    说了那么多没用,你能做的就是简单直接,什么最方便就用什么,

    你就直接用@Resource得了,如果你喜欢用@AutoWired也行,不用写名字。

    通常情况一个Bean的注解写错了,会报下面这些错误,最为常见,

    No bean named 'user' is defined,这个表示没有找到被命名为user的Bean,通俗的说,就是名字为user的类型,以及它的子类型,出现这个错误的原因就是注入时候的类型名字为user,而搜索的时候找不到,也就是说可能那个搜索的类型,并没有命令为user,解决办法就是找到这个类型,去命令为user,

    下面这个错误也常见,

    No qualifying bean of type [com.service.UserService] found for dependency:

    这个错误的原因就是类型上面没有加@Service这个注入,不仅仅是@Service,如果是其他层也会出现这个错误,这里我是以Service为例子说明,如果是DAO层就是没有加@Repository,Controller层,则是没有加@Controller。

    还有,如果你还是想再简单点,无论是DAO,Controller,Service三个层,都可以用这个注解,@Component,这个注解通用所有的Bean,这个时候你可能会说了,有通常的为什么用的人少呢,那是因为MVC这个分层的设计原则,用@Repository,@Service,@Controller,这个可以区别MVC原则中的DAO,Service,Controller。便于识别。

    博客2:

    spring autowired qualifier bytype byname 

     在使用Spring框架中@Autowired标签时默认情况下使用

    Java代码 

    1. @Autowired  
     @Autowired

    注释进行自动注入时,Spring 容器中匹配的候选 Bean 数目必须有且仅有一个。当找不到一个匹配的 Bean 时,Spring 容器将抛出 BeanCreationException 异常,并指出必须至少拥有一个匹配的 Bean。

    @Autowired 默认是按照byType进行注入的,如果发现找到多个bean,则,又按照byName方式比对,如果还有多个,则报出异常。

    例子:

    @Autowired
    private ExamUserMapper examUserMapper;  - ExamUserMapper是一个接口

    1. spring先找类型为ExamUserMapper的bean

    2. 如果存在且唯一,则OK;

    3. 如果不唯一,在结果集里,寻找name为examUserMapper的bean。因为bean的name有唯一性,所以,到这里应该能确定是否存在满足要求的bean了

    @Autowired也可以手动指定按照byName方式注入,使用@Qualifier标签,例如:

    @Autowired  ()  @Qualifier  (  "baseDao"  )



      Spring 允许我们通过

    Java代码 

    1. @Qualifier  
    @Qualifier

    注释指定注入 Bean 的名称,这样歧义就消除了,可以通过下面的方法解决异常。 

      

    Java代码 

    1. @Qualifier("XXX")  
    @Qualifier("XXX")

    中的 XX是 Bean 的名称,所以 @Autowired 和 @Qualifier 结合使用时,自动注入的策略就从 byType 转变成 byName 了。 

      @Autowired 可以对成员变量、方法以及构造函数进行注释,而 @Qualifier 的标注对象是成员变量、方法入参、构造函数入参。 

        Spring不但支持自己定义的@Autowired注解,还支持几个由JSR-250规范定义的注解,它们分别是@Resource、@PostConstruct以及@PreDestroy。 

      

    Java代码 

    1. @Resource  
    @Resource

    的作用相当于@Autowired,只不过@Autowired按byType自动注入,而@Resource默认按 byName自动注入罢了。@Resource有两个属性是比较重要的,分是name和type,Spring将@Resource注解的name属性解析为bean的名字,而type属性则解析为bean的类型。所以如果使用name属性,则使用byName的自动注入策略,而使用type属性时则使用byType自动注入策略。如果既不指定name也不指定type属性,这时将通过反射机制使用byName自动注入策略。 

      @Resource装配顺序 
      1. 如果同时指定了name和type,则从Spring上下文中找到唯一匹配的bean进行装配,找不到则抛出异常 
      2. 如果指定了name,则从上下文中查找名称(id)匹配的bean进行装配,找不到则抛出异常 
      3. 如果指定了type,则从上下文中找到类型匹配的唯一bean进行装配,找不到或者找到多个,都会抛出异常 
      4. 如果既没有指定name,又没有指定type,则自动按照byName方式进行装配;如果没有匹配,则回退为一个原始类型进行匹配,如果匹配则自动装配

    展开全文
  • @Autowired与@Resource区别

    万次阅读 2022-04-05 16:06:15
    二、@Autowired 注解处理器 装配方式 注解属性 作用范围 1. 成员变量 2. 构造器 3. 方法 4. 参数 5. 注解 使用技巧 同一类型多个bean @Primary的使用 @Qualifier的使用 装配多个实例 @Autowired装配未生效 三、@...


    一、前言

    @Autowired和@Resource都是用来自动装配bean的。

    • @Resource是JSR-250提供的,它是Java标准,绝大部分框架都支持。
    • @Autowired功能非常强大,但只适用于Spring框架,如果换成了JFinal等其他框架,功能就会失效。

    Spring Bean覆盖配置

    spring:
      main:
        allow-bean-definition-overriding: true
    

    allow-bean-definition-overriding属性用于配置出现相同名称bean的情况如何处理:

    • 值为false时(默认值为false),如果出现相同名称的bean,直接抛异常。
    • 值为true时,表示支持相同名称的bean覆盖,后定义的bean会覆盖之前定义的相同名称的bean。

    下文会提到按类型装配,那么什么是同一类型呢?

    • 父类及其子类都属于父类这一类型
    • 接口及其实现类都属于接口这一类型

    二、@Autowired

    @Autowired是Spring提供的注解,用于自动装配。

    注解处理器

    AutowiredAnnotationBeanPostProcessor类是Autowired注解的注解处理器。

    关于注解处理器可参考文章:https://blog.csdn.net/JokerLJG/article/details/123548694

    装配方式

    • 按类型装配(默认使用的装配方式)。
    • 按名称装配(结合@Qualifier注解使用)。

    注解属性

    • required:默认值true。值为true时,表示必须注入,如bean不存在则会报错;值为false时,表示bean存在就注入,不存在则不注入。

    作用范围

    @Autowired的作用范围:成员变量、构造器、方法、参数、注解。

    1. 成员变量

    @Service
    public class UserService {
    
        @Autowired
        private IUser user;
    }
    

    使用最多的方式。

    2. 构造器

    @Service
    public class UserService {
    
        private IUser user;
    
        @Autowired
        public UserService(IUser user) {
            this.user = user;
        }
    }
    

    构造器上使用Autowired注解,实际上还是使用了成员变量装配的方式,并非构造器装配。

    3. 方法

    @Service
    public class UserService {
    
        @Autowired
        public void test(IUser user) {
           user.test();
        }
    }
    

    Spring会在项目启动的过程中,自动调用一次加了@Autowired注解的方法,我们可以在该方法做一些初始化的工作。

    4. 参数

    在构造器的入参上加Autowired注解

    @Service
    public class UserService {
    
        private IUser user;
    
        public UserService(@Autowired IUser user) {
            this.user = user;
            System.out.println("user:" + user);
        }
    }
    

    在非静态方法的入参上加Autowired注解

    @Service
    public class UserService {
    
        public void test(@Autowired IUser user) {
           user.test();
        }
    }
    

    5. 注解

    略。

    使用技巧

    同一类型多个bean

    当按类型装配时,如果该类型的bean不止一个时,会直接报错。举例说明:

    接口:

    public interface IUser {
        void test();
    }
    

    实现类1:

    @Service
    public class User1 implements IUser{
        @Override
        public void test() {
        }
    }
    

    实现类2:

    @Service
    public class User2 implements IUser{
        @Override
        public void test() {
        }
    }
    

    自动装配:

    @Service
    public class UserService {
    
        @Autowired
        private IUser user;
    }
    

    启动时的错误信息:

    Field userService in com.joker.controller.UserController required a single bean, but 2 were found:
    	- userServiceImpl1: defined in file [D:\work\my\springboot\target\classes\com\joker\controller\UserServiceImpl1.class]
    	- userServiceImpl2: defined in file [D:\work\my\springboot\target\classes\com\joker\controller\UserServiceImpl2.class]
    

    @Primary的使用

    @Primary注解可以解决上述问题(按类型装配时,如果该类型的bean不止一个时,会报错)。

    当我们使用自动配置的方式装配Bean时,如果这个Bean有多个候选者,假如其中一个候选者具有@Primary注解修饰,该候选者会被选中,作为自动装配的bean。

    在上面代码不变的情况下,只需在User1或User2上加@Primary注解,此时@Autowired自动装配会成功,并且自动装配的是加了@Primary注解的这个类对应的bean。

    User1类加@Primary注解

    @Service
    @Primary
    public class User1 implements IUser{
        @Override
        public void test() {
        }
    }
    

    @Qualifier的使用

    通过@Autowired和@Qualifier的结合使用可以按名称装配。

    @Service
    public class UserService {
    
        @Autowired
        @Qualifier("user1")
        private IUser user;
    }
    

    自动装配名称为user1的bean(注意:bean的类型也必须要满足为IUser类型)。

    装配多个实例

    我们一般使用的都是用@Autowired自动装配单个实例,但其实它也可以用来装配多个实例。可以通过List、Set、Map来装配多个实例,如下:

    @Service
    public class UserService {
    
        @Autowired
        private List<IUser> userList;
    
        @Autowired
        private Set<IUser> userSet;
    
        @Autowired
        private Map<String, IUser> userMap;
    }
    

    上面的装配方式会吧IUser类型的多个实例bean都装配的List、Set、Map中。

    @Autowired装配未生效

    下面列举常见@Autowired装配未生效的情况:

    1. @Autowired所在类未加@Controller、@Service、@Component、@Repository等注解,或者或者一些其它情况(如直接new对象的到实例)。这些情况会导致该类的bean并没有交给spring容器去管理,spring就无法完成自动装配的功能。

      public class UserService {
      
          @Autowired
          private IUser user;
      
          public void test() {
              user.say();
          }
      }
      
    2. 注解未被@ComponentScan扫描到。

    三、@Resource

    @Resource是JDK自带的注解,用于自动装配。

    注解处理器

    CommonAnnotationBeanPostProcessor类是Resource的注解处理器。

    装配方式

    @Resource默认按照名称自动注入。

    • 既没指定name,也没指定type,自动按照名称装配(当注解写在字段上时,默认取字段名,当注解写在setter方法上时,默认取属性名进行装配。);如果没有匹配,则退而按照类型装配,找不到则抛出异常。

      如果没有指定 name 属性,

    • 如果指定了name,则从上下文中查找名称(id)匹配的bean进行装配,找不到则抛出异常。

    • 如果指定了type,则从上下文中找到类似匹配的唯一bean进行装配,找不到或是找到多个,都会抛出异常。

    • 如果同时指定了name和type,则从Spring上下文中找到唯一匹配的bean进行装配,找不到则抛出异常。

    注解属性

    Resource注解的主要属性:

    • name:指定需注入的bean的名称
    • type: 指定需注入的bean的类型

    作用范围

    @Resource的作用范围:类、成员变量、方法。

    1. 成员变量

    @Service
    public class UserService {
    
        @Resource
        private IUser user;
    }
    

    2. 方法

    @Service
    public class UserService {
    
        @Resource
        public void test(IUser user) {
            user.test();
        }
    }
    

    3. 类

    略。

    四、@Autowired与@Resource对比

    二者对比

    @Autowired@Resource
    Spring定义的注解JSR-250定义的注解
    默认按类型自动装配默认按名称自动装配
    一个参数:required(默认true),表示是否必须注入七个参数:最重要的两个参数是name、type
    默认按类型自动装配
    如果要按名称自动装配,需要使用@Qualifier一起配合
    默认按名称自动装配
    如果指定了name,则按名称自动装配;如果指定了type,则按类型自动装配
    作用范围:构造器、方法、参数、成员变量、注解作用范围:类、成员变量、方法

    @Autowired装配流程

    请添加图片描述

    @Resource装配流程

    请添加图片描述

    展开全文
  • @Autowired实现的原理

    千次阅读 2022-07-08 23:58:04
    使用@Autowired注入的bean对于目标类来说,从代码结构上来讲也就是一个普通的成员变量,@Autowired和spring一起工作,通过反射为这个成员变量赋值,也就是将其赋为期望的类实例。

    前言

    使用spring开发时,进行配置主要有两种方式,一是xml的方式,二是java config的方式。

    spring技术自身也在不断的发展和改变,从当前springboot的火热程度来看,java config的应用是越来越广泛了,在使用java config的过程当中,我们不可避免的会有各种各样的注解打交道,其中,我们使用最多的注解应该就是@Autowired注解了。这个注解的功能就是为我们注入一个定义好的bean。

    那么,这个注解除了我们常用的属性注入方式之外还有哪些使用方式呢?它在代码层面又是怎么实现的呢?这是本篇文章着重想讨论的问题。

    @Autowired注解用法

    在分析这个注解的实现原理之前,我们不妨先来回顾一下@Autowired注解的用法。

    将@Autowired注解应用于构造函数,如以下示例所示

    @Component
    public class BeanConfig{
    
        @Autowired
        private BeanConfig beanConfig;
    
        @Autowired
        private void setBeanConfig(BeanConfig beanConfig) {
            this.beanConfig = beanConfig;
        }
    }
    

    直接应用于字段是我们使用的最多的一种方式,但是使用构造方法注入从代码层面却是更加好的。除此之外,还有以下不太常见的几种方式

     @Autowired
     private List<BeanConfig> beanConfigList;
    
     @Autowired
     private Set<BeanConfig> beanConfigSet;
    
     @Autowired
     private Map<String, BeanConfig> beanConfigMap;
    

    @Autowired注解的作用到底是什么

    @Autowired这个注解我们经常在使用,现在,我想问的是,它的作用到底是什么呢?

    首先,我们从所属范围来看,事实上这个注解是属于spring的容器配置的一个注解,与它同属容器配置的注解还有:@Required,@Primary, @Qualifier等等。因此@Autowired注解是一个用于容器(container)配置的注解。

    其次,我们可以直接从字面意思来看,@autowired注解来源于英文单词autowire,这个单词的意思是自动装配的意思。自动装配又是什么意思?这个词语本来的意思是指的一些工业上的用机器代替人口,自动将一些需要完成的组装任务,或者别的一些任务完成。而在spring的世界当中,自动装配指的就是使用将Spring容器中的bean自动的和我们需要这个bean的类组装在一起。

    因此,笔者个人对这个注解的作用下的定义就是:将Spring容器中的bean自动的和我们需要这个bean的类组装在一起协同使用。

    接下来,我们就来看一下这个注解背后到底做了些什么工作。

    @Autowired注解是如何实现的

    事实上,要回答这个问题必须先弄明白的是java是如何支持注解这样一个功能的。

    java的注解实现的核心技术是反射,让我们通过一些例子以及自己实现一个注解来理解它工作的原理。

    利用反射,我们利用反射拿到这样目标之后,得为他实现一个逻辑,这个逻辑是这些方法本身逻辑之外的逻辑,这又让我们想起了代理,aop等知识,我们相当于就是在为这些方法做一个增强。事实上的实现主借的逻辑也大概就是这个思路。梳理一下大致步骤如下(重要):

    • 利用反射机制获取一个类的Class对象
    • 通过这个class对象可以去获取他的每一个方法method,或字段Field等等
    • Method,Field等类提供了类似于getAnnotation的方法来获取这个一个字段的所有注解
    • 拿到注解之后,我们可以判断这个注解是否是我们要实现的注解,如果是则实现注解逻辑

    现在我们来实现一下这个逻辑,代码如下:

     public void postProcessProperties() throws Exception {
            // 1. 获取一个类的Class对象
            Class<BeanConfig> beanConfigClass = BeanConfig.class;
            // 2. 通过Class new newInstance() 实例化对象(Spring则从bean容器获取)
            BeanConfig instance = beanConfigClass.newInstance();
            // 3. 获取Class对象所有的字段
            Field[] fields = beanConfigClass.getDeclaredFields();
            for (Field field : fields) {
            // 4. getAnnotation,判断是否有Autowired
                Autowired autowired = field.getDeclaredAnnotation(Autowired.class);
                if (autowired != null) {
                    String fileName = field.getName();
                    Class<?> declaringClass = field.getDeclaringClass();
                    // byType或者byName从bean工厂获取bean对象
                    Object bean = new Object();
                    // 依赖注入
                    field.setAccessible(true);
                    field.set(bean, instance);
                }
            }
        }
    

    从上面的实现逻辑我们不难发现,借助于java的反射我们可以直接拿到一个类里所有的方法,然后再拿到方法上的注解,当然,我们也可以拿到字段上的注解。借助于反射我们可以拿到几乎任何属于一个类的东西

    一个简单的注解我们就实现完了。现在我们再回过头来,看一下@Autowired注解是如何实现的。

    知道了上面的知识,我们不难想到,上面的注解虽然简单,但是@Autowired和他最大的区别应该仅仅在于注解的实现逻辑,其他利用反射获取注解等等步骤应该都是一致的。先来看一下@Autowired这个注解在spring的源代码里的定义是怎样的,如下所示:

    package org.springframework.beans.factory.annotation;
     
    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.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Autowired {
        boolean required() default true;
    }
    

    阅读代码我们可以看到,Autowired注解可以应用在构造方法,普通方法,参数,字段,以及注解这五种类型的地方,它的保留策略是在运行时。下面,我们不多说直接来看spring对这个注解进行的逻辑实现.

    在Spring源代码当中,Autowired注解位于包org.springframework.beans.factory.annotation之中,该包的内容如下:
    在这里插入图片描述
    经过分析,不难发现Spring对autowire注解的实现逻辑位于类:AutowiredAnnotationBeanPostProcessor之中,已在上图标红。其中的核心处理代码如下:

    private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
      LinkedList<InjectionMetadata.InjectedElement> elements = new LinkedList<>();
      Class<?> targetClass = clazz;//需要处理的目标类
           
      do {
       final LinkedList<InjectionMetadata.InjectedElement> currElements = new LinkedList<>();
     
     /*通过反射获取该类所有的字段,并遍历每一个字段,
     并通过方法findAutowiredAnnotation遍历每一个字段的所用注解
     并如果用autowired修饰了,则返回auotowired相关属性*/  
       ReflectionUtils.doWithLocalFields(targetClass, field -> {
        AnnotationAttributes ann = findAutowiredAnnotation(field);
        if (ann != null) {//校验autowired注解是否用在了static方法上
         if (Modifier.isStatic(field.getModifiers())) {
          if (logger.isWarnEnabled()) {
           logger.warn("Autowired annotation is not supported on static fields: " + field);
          }
          return;
         }//判断是否指定了required
         boolean required = determineRequiredStatus(ann);
         currElements.add(new AutowiredFieldElement(field, required));
        }
       });
       //和上面一样的逻辑,但是是通过反射处理类的method
       ReflectionUtils.doWithLocalMethods(targetClass, method -> {
        Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
        if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
         return;
        }
        AnnotationAttributes ann = findAutowiredAnnotation(bridgedMethod);
        if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
         if (Modifier.isStatic(method.getModifiers())) {
          if (logger.isWarnEnabled()) {
           logger.warn("Autowired annotation is not supported on static methods: " + method);
          }
          return;
         }
         if (method.getParameterCount() == 0) {
          if (logger.isWarnEnabled()) {
           logger.warn("Autowired annotation should only be used on methods with parameters: " +
             method);
          }
         }
         boolean required = determineRequiredStatus(ann);
         PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
                       currElements.add(new AutowiredMethodElement(method, required, pd));
        }
       });
        //用@Autowired修饰的注解可能不止一个,因此都加在currElements这个容器里面,一起处理  
       elements.addAll(0, currElements);
       targetClass = targetClass.getSuperclass();
      }
      while (targetClass != null && targetClass != Object.class);
     
      return new InjectionMetadata(clazz, elements);
     }
    

    博主在源代码里加了注释,结合注释就能看懂它做的事情了,最后这个方法返回的就是包含所有带有autowire注解修饰的一个InjectionMetadata集合。这个类由两部分组成:

    public InjectionMetadata(Class<?> targetClass, Collection<InjectedElement> elements) {
      this.targetClass = targetClass;
      this.injectedElements = elements;
     }
    

    一是我们处理的目标类,二就是上述方法获取到的所以elements集合。

    有了目标类,与所有需要注入的元素集合之后,我们就可以实现autowired的依赖注入逻辑了,实现的方法如下:

    @Override
    public PropertyValues postProcessPropertyValues(
      PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeanCreationException {
     
     InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
     try {
      metadata.inject(bean, beanName, pvs);
     }
     catch (BeanCreationException ex) {
      throw ex;
     }
     catch (Throwable ex) {
      throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
     }
     return pvs;
    }
    

    它调用的方法是InjectionMetadata中定义的inject方法,如下

    public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
      Collection<InjectedElement> checkedElements = this.checkedElements;
      Collection<InjectedElement> elementsToIterate =
        (checkedElements != null ? checkedElements : this.injectedElements);
      if (!elementsToIterate.isEmpty()) {
       for (InjectedElement element : elementsToIterate) {
        if (logger.isTraceEnabled()) {
         logger.trace("Processing injected element of bean '" + beanName + "': " + element);
        }
        element.inject(target, beanName, pvs);
       }
      }
     }
    ```
    其逻辑就是遍历,然后调用inject方法,inject方法其实现逻辑如下:
    
    ```java
    /**
     * Either this or {@link #getResourceToInject} needs to be overridden.
     */
    protected void inject(Object target, @Nullable String requestingBeanName, @Nullable PropertyValues pvs)
      throws Throwable {
     
     if (this.isField) {
      Field field = (Field) this.member;
      ReflectionUtils.makeAccessible(field);
      field.set(target, getResourceToInject(target, requestingBeanName));
     }
     else {
      if (checkPropertySkipping(pvs)) {
       return;
      }
      try {
       Method method = (Method) this.member;
       ReflectionUtils.makeAccessible(method);
       method.invoke(target, getResourceToInject(target, requestingBeanName));
      }
      catch (InvocationTargetException ex) {
       throw ex.getTargetException();
      }
     }
    }
    

    对于方法的话,本质就是去调用这个方法,因此这里调用的是method.invoke.

    getResourceToInject方法的参数就是要注入的bean的名字,这个方法的功能就是根据这个bean的名字去拿到它。

    以上,就是@Autowire注解实现逻辑的全部分析。结合源代码再看一遍的话,会更加清楚一点。下面是spring容器如何实现@AutoWired自动注入的过程的图:
    在这里插入图片描述
    总结起来一句话:使用@Autowired注入的bean对于目标类来说,从代码结构上来讲也就是一个普通的成员变量,@Autowired和spring一起工作,通过反射为这个成员变量赋值,也就是将其赋为期望的类实例。

    展开全文
  • Spring中@Autowired注解的工作原理

    千次阅读 多人点赞 2022-02-18 15:48:53
    目录 一、概述 二、@Autowired注解的用法 三、@Autowired自动装配原理 四、源码调试环境 五、AutowiredAnnotationBeanPostProcessor#...@Autowired注解大家再熟悉不过了,在项目中使用 @Autowired注解的比例
  • 谈谈 @Autowired 的实现原理

    千次阅读 2022-06-22 17:14:42
    @Autowired使用 构造函数注入 public Class Outer { private Inner inner; @Autowired public Outer(Inner inner) { this.inner = inner; } } 属性注入 public Class Outer { @Autowired private Inner inner; } ...
  • @Autowired注解的实现原理

    千次阅读 2022-04-13 09:02:12
    @Autowired注解用法 在分析这个注解的实现原理之前,我们不妨先来回顾一下@Autowired注解的用法。 将@Autowired注解应用于构造函数,如以下示例所示 publicclassMovieRecommender{ ...
  • Spring注解@Autowired

    千次阅读 2021-12-25 00:00:55
    Spring注解@Autowired 一、@Autowired注解作用 1、@Autowired 注解@Autowired是Spring对组件自动装配的一种方式。常用于在一个组件中引入其他组件。 //引入Person组件 @Autowired Person person; 自动装配:sprng...
  • 文章目录@[toc]常用注解注释位置(@Autowired放置在构造器上与放在属性上的区别)对成员变量注释对构造函数注释对成员方法注释@Autowired和构造方法执行的顺序@Autowired与@Resource注入方式(注意)基于Setter的依赖...
  • @Autowired是什么 对于Java后端开发的读者在项目中肯定是大量使用@Autowired注解,在controller层使用@Autowired注入service层接口,在service层使用@Autowired注入dao层接口实现MVC的分层,相信这是大家在项目中...
  • @Autowired使用的介绍,和在static属性上使用的方法
  • spring中减少@Autowired代码方法 spring依赖注入常规操作,大量出现@Autowired,代码如下 @Service public class DigitalMeetingServiceImpl extends ServiceImpl<DigitalMeetingMapper, DigitalMeeting> ...
  • @Autowired 与@Resource选择

    千次阅读 2022-03-13 23:21:56
    spring不但支持自己定义的@Autowired注解,还支持几个由JSR-250规范定义的注解,它们分别是@Resource、@PostConstruct以及@PreDestroy。  @Resource的作用相当于@Autowired,只不过@Autowired按byType自动注入,而@...
  • @Autowired的这些新姿势,你学会了?

    千次阅读 多人点赞 2021-05-26 20:52:23
    最近review别人代码的时候,看到了一些@Autowired不一样的用法,觉得有些意思,特定花时间研究了一下,收获了不少东西,现在分享给大家。 也许@Autowired比你想象中更强大。 1. @Autowired的默认装配 我们都知道在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 501,696
精华内容 200,678
关键字:

@autowired