@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 与@Resource的区别(详细)

    万次阅读 多人点赞 2018-06-10 19:44:00
    http://www.cnblogs.com/happyyang/articles/3553687.htmlhttp://blog.csdn.net/revent/article/details/49203619http://blog.csdn.net/ad921012/article/details/49679745spring不但支持自己定义的@Autowired注解,...

    参考博文:

    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")
    privateBaseDao baseDao;

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

    1
    2
    @Resource(name="baseDao")
    privateBaseDao baseDao;

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

     

    spring @Qualifier注解

     

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

    ①可能存在多个UserDao实例

     

    [java] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    1. @Autowired   
    2. @Qualifier("userServiceImpl")   
    3. public IUserService userService;   

     

    或者

    [java] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    1. @Autowired   
    2. public void setUserDao(@Qualifier("userDao") UserDao userDao) {   
    3.     this.userDao = userDao;   
    4. }  

     

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

     

    ②可能不存在UserDao实例

     

    [java] view plaincopy在CODE上查看代码片派生到我的代码片
     
     
    1. @Autowired(required = false)   
    2. 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 {

    @AutoWire   //当使用这个注入的时候上面的 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得了,如果你喜欢用@AutoWire也行,不用写名字。

     

    通常情况一个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标签时默认情况下使用
    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方式进行装配;如果没有匹配,则回退为一个原始类型进行匹配,如果匹配则自动装配
    展开全文
  • @Resource与@Autowired用法区别

    万次阅读 多人点赞 2018-09-11 09:32:14
    spring中,@Resource和@Autowired都是做bean的注入时使用。使用过程中,有时候@Resource 和 @Autowired可以替换使用;有时,则不可以。  下面,根据自己的学习,整理下这两个注解使用中的共同点和不同点,及用法上...

        spring中,@Resource和@Autowired都是做bean的注入时使用。使用过程中,有时候@Resource 和 @Autowired可以替换使用;有时,则不可以。

        下面,根据自己的学习,整理下这两个注解使用中的共同点和不同点,及用法上的不同。

         共同点

         @Resource和@Autowired都可以作为注入属性的修饰,在接口仅有单一实现类时,两个注解的修饰效果相同,可以互相替换,不影响使用。

        不同点

    • @Resource是Java自己的注解,@Resource有两个属性是比较重要的,分是name和type;Spring将@Resource注解的name属性解析为bean的名字,而type属性则解析为bean的类型。所以如果使用name属性,则使用byName的自动注入策略,而使用type属性时则使用byType自动注入策略。如果既不指定name也不指定type属性,这时将通过反射机制使用byName自动注入策略。
    • @Autowired是spring的注解,是spring2.5版本引入的,Autowired只根据type进行注入,不会去匹配name。如果涉及到type无法辨别注入对象时,那需要依赖@Qualifier或@Primary注解一起来修饰。

         

         我们创建一个简单的springboot项目demo,

             定义一个接口Human.java,里面一个方法 runMarathon,

             一个实现类Man.java

             一个Controller类HumanController.java,里面注入Human接口的实现

               

               附各Java类源码

    package com.example.annotation.service;
    
    /**
     * service接口定义
     * @author Administrator
     */
    public interface Human {
    	
    	/**
    	 * 跑马拉松
    	 * @return
    	 */
    	String runMarathon();
    }
    
    package com.example.annotation.service.impl;
    
    import com.example.annotation.service.Human;
    import org.springframework.stereotype.Service;
    
    /**
     * service接口第一实现类
     * @author Administrator
     */
    @Service
    public class Man implements Human {
    
    	public String runMarathon() {
    		return "A man run marathon";
    	}
    }
    
    package com.example.annotation.controller;
    
    import javax.annotation.Resource;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    import com.example.annotation.service.Human;
    
    /**
     * controller层实现类
     * @author Administrator
     */
    @RestController
    @RequestMapping("/an")
    public class HumanController {
    
    	@Resource
    	private Human human;
    	
    	@RequestMapping("/run")
    	public String runMarathon() {
    		return human.runMarathon();
    	}
    }

               至此,代码整理完成,启动springboot,浏览器地址栏输入http://localhost:8080/an/run

    改动一:

    将HumanController.java 类中的注解替换为@Autowired,再次启动,可以正常访问,与上图相同,这里不再贴访问结果图。

    改动二:

    再增加一个实现类Woman.java

    package com.example.annotation.service.impl;
    
    import com.example.annotation.service.Human;
    import org.springframework.stereotype.Service;
    
    /**
     * service接口第二实现类
     * @author Administrator
     */
    @Service
    public class Woman implements Human {
    
    	public String runMarathon() {
    		return "An woman run marathon";
    	}
    }
    

    HumanController.java 注解使用@Resource

            @Resource
    	private Human human;

    启动springboot,控制台会报错,报错信息太多,截取关键信息

    2018-09-10 16:07:10.362  WARN 5592 --- [  restartedMain] ConfigServletWebServerApplicationContext : Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'humanController': Injection of resource dependencies failed; nested exception is org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'com.example.annotation.service.Human' available: expected single matching bean but found 2: man,woman
    

    找关键信息 expected single matching bean but found 2: man,woman,被期望的单一结果被匹配到两个结果man和woman。

    这里,我们需要借助@Resource注解的name属性或@Qualifier来确定一个合格的实现类

    代码修改为 

            @Resource(name="woman")
    	private Human human;

    或 

            @Resource
    	@Qualifier("woman")
    	private Human human;

    上面,我们指定了Human接口的实现类是Woman.java,启动springboot,访问 http://localhost:8080/an/run

    改动三:

    在改动二的基础上,将注解替换为@Autowired,启动报错

    Description:
    
    Field human in com.example.annotation.controller.HumanController required a single bean, but 2 were found:
    	- man: defined in file [D:\DEV_ENV\springbootws\annotation\target\classes\com\example\annotation\service\impl\Man.class]
    	- woman: defined in file [D:\DEV_ENV\springbootws\annotation\target\classes\com\example\annotation\service\impl\Woman.class]
    
    
    Action:
    
    Consider marking one of the beans as @Primary, updating the consumer to accept multiple beans, or using @Qualifier to identify the bean that should be consumed
    

    报错信息很明显,HumanController需要一个bean实现,但是找到了两个 man 和woman

    解决方案:使用@Primary注解,在有多个实现bean时告诉spring首先@Primary修饰的那个;或者使用@Qualifier来标注需要注入的类。

    @Qualifier修改方式与改动二的相同,依然是修改HumanController.java 中间注入的Human上面,这里不再复述

    @Primary是修饰实现类的,告诉spring,如果有多个实现类时,优先注入被@Primary注解修饰的那个。这里,我们希望注入Man.java ,那么修改Man.java为

    package com.example.annotation.service.impl;
    
    import org.springframework.context.annotation.Primary;
    import org.springframework.stereotype.Service;
    import com.example.annotation.service.Human;
    
    /**
     * service接口第一实现类
     * @author Administrator
     */
    @Service
    @Primary
    public class Man implements Human {
    
    	public String runMarathon() {
    		return "A man run marathon";
    	}
    }
    

    启动springboot后,可以看到注入的已经是Man.java 了。

    以上,个人学习总结,如有不当之处,欢迎留言批评斧正。谢谢

    展开全文
  • 在我们写controller或者Service层的时候,需要注入很多的mapper接口或者另外的service接口,这时候就会写很多的@AutoWired注解,代码看起来很乱 lombok提供了一个注解: @RequiredArgsConstructor(onConstructor =...

    在我们写controller或者Service层的时候,需要注入很多的mapper接口或者另外的service接口,这时候就会写很多的@AutoWired注解,代码看起来很乱
    lombok提供了一个注解:

    @RequiredArgsConstructor(onConstructor =@_(@Autowired))
    写在类上可以代替@AutoWired注解,需要注意的是在注入时需要用final定义,或者使用@notnull注解
    
    private final User u;
    

    使用注解之前要去下载lombok插件哦~
    lombok还有很多的功能,不用再写get,set方法等等,快去自己发掘吧!

    展开全文
  • @Resource与@Autowired注解的区别

    万次阅读 多人点赞 2017-01-10 16:21:13
    同事:没错,但是现在都使用@Autowired。我:我研究一下。 在大学,学习J2EE实训时一直使用的是@Resource注解,后来我就养成习惯了。现在对这两个注解做一下解释: @Resource默认按照名称方式进行bean匹配,@A

    一、写本博文的原因

     

    年初刚加入到现在的项目时,在使用注解时我用的@Resource。后来,同事:你怎么使用@Resource注解?我:使用它有错吗?同事:没错,但是现在都使用@Autowired。我:我研究一下。

    在大学,学习J2EE实训时一直使用的是@Resource注解,后来我就养成习惯了。现在对这两个注解做一下解释:

     

    • @Resource默认按照名称方式进行bean匹配,@Autowired默认按照类型方式进行bean匹配
    • @Resource(import javax.annotation.Resource;)是J2EE的注解,@Autowired( import org.springframework.beans.factory.annotation.Autowired;)是Spring的注解

    @Autowired注解默认按类型(byType)装配依赖对象,它要求依赖对象必须存在;若允许依赖对象不存在,可设:@Autowired(required = false) 。
    @Autowired也可以按名称(byName)装配,需要结合@Qualifier:
    @Autowired
    @Qualifier("manImpl")

    @Resource默认按名称(byName)装配,也可按类型装配,装配顺序如下: 

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

    Spring属于第三方的,J2EE是Java自己的东西。使用@Resource可以减少代码和Spring之间的耦合。

     

    二、@Resource注入

    现在有一个接口Human和两个实现类ManImpl、WomanImpl,在service层的一个bean中要引用了接口Human,这种情况处理如下:

    接口Human

     

    package testwebapp.com.wangzuojia.service;
    
    public interface Human {
    	
    	public void speak();
    	
    	public void walk();
    }
    


    实现类ManImpl

     

     

    package testwebapp.com.wangzuojia.service.impl;
    
    import org.springframework.stereotype.Service;
    
    import testwebapp.com.wangzuojia.service.Human;
    
    @Service
    public class ManImpl implements Human {
    
    	public void speak() {
    		System.out.println(" man speaking!");
    
    	}
    
    	public void walk() {
    		System.out.println(" man walking!");
    
    	}
    
    }

     

     

    实现类WomanImpl

     

    package testwebapp.com.wangzuojia.service.impl;
    
    import org.springframework.stereotype.Service;
    
    import testwebapp.com.wangzuojia.service.Human;
    
    @Service
    public class WomanImpl implements Human {
    
    	public void speak() {
    		System.out.println(" woman speaking!");
    
    	}
    
    	public void walk() {
    		System.out.println(" woman walking!");
    
    	}
    
    }

     

     

    主调类SequenceServiceImpl

    package testwebapp.com.wangzuojia.service.impl;
    
    import java.util.Map;
    
    import javax.annotation.Resource;
    
    import org.springframework.stereotype.Service;
    
    import testwebapp.com.wangzuojia.dao.SequenceMapper;
    import testwebapp.com.wangzuojia.service.Human;
    import testwebapp.com.wangzuojia.service.SequenceService;
    
    @Service
    public class SequenceServiceImpl implements SequenceService {
    
    	@Resource
    	private SequenceMapper sequenceMapper;
    	public void generateId(Map<String, String> map) {
    		sequenceMapper.generateId(map);
    		
    	}
    	//起服务此处会报错
    	@Resource
    	private Human human;
    
    }

     

    这时候启动tomcat会包如下错误:

     

     

    严重: Exception sendingcontext initialized event to listener instance of classorg.springframework.web.context.ContextLoaderListenerorg.springframework.beans.factory.BeanCreationException: Error creating beanwith name 'sequenceServiceImpl': Injection of resource dependencies failed;nested exception isorg.springframework.beans.factory.NoUniqueBeanDefinitionException: Noqualifying bean of type [testwebapp.com.wangzuojia.service.Human] is defined:expected single matching beanbut found 2: manImpl,womanImpl atorg.springframework.context.annotation.CommonAnnotationBeanPostProcessor.postProcessPropertyValues(CommonAnnotationBeanPostProcessor.java:311) atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1214) atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:543) atorg.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:482) atorg.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:306) atorg.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:230) atorg.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:302) atorg.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:197) atorg.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:772) atorg.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:838) atorg.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:537) atorg.springframework.web.context.ContextLoader.configureAndRefreshWebApplicationContext(ContextLoader.java:446) atorg.springframework.web.context.ContextLoader.initWebApplicationContext(ContextLoader.java:328) atorg.springframework.web.context.ContextLoaderListener.contextInitialized(ContextLoaderListener.java:107) atorg.apache.catalina.core.StandardContext.listenerStart(StandardContext.java:4717) atorg.apache.catalina.core.StandardContext.startInternal(StandardContext.java:5179)atorg.apache.catalina.util.LifecycleBase.start(LifecycleBase.java:183) atorg.apache.catalina.core.ContainerBase$StartChild.call(ContainerBase.java:1404) atorg.apache.catalina.core.ContainerBase$StartChild.call(ContainerBase.java:1394) atjava.util.concurrent.FutureTask.run(FutureTask.java:266) atjava.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142) atjava.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)atjava.lang.Thread.run(Thread.java:745) Caused by:org.springframework.beans.factory.NoUniqueBeanDefinitionException: Noqualifying bean of type [testwebapp.com.wangzuojia.service.Human] is defined: expectedsingle matching bean but found 2: manImpl,womanImpl atorg.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:1126) atorg.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:1014) atorg.springframework.context.annotation.CommonAnnotationBeanPostProcessor.autowireResource(CommonAnnotationBeanPostProcessor.java:508) atorg.springframework.context.annotation.CommonAnnotationBeanPostProcessor.getResource(CommonAnnotationBeanPostProcessor.java:486) atorg.springframework.context.annotation.CommonAnnotationBeanPostProcessor$ResourceElement.getResourceToInject(CommonAnnotationBeanPostProcessor.java:615) atorg.springframework.beans.factory.annotation.InjectionMetadata$InjectedElement.inject(InjectionMetadata.java:169) atorg.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:88) atorg.springframework.context.annotation.CommonAnnotationBeanPostProcessor.postProcessPropertyValues(CommonAnnotationBeanPostProcessor.java:308) ...22 more

     

    报错的地方给我们提示了:but found 2: manImpl,womanImpl      意思是Human有两个实现类。解决方案如下:

    package testwebapp.com.wangzuojia.service.impl;
    
    import java.util.Map;
    
    import javax.annotation.Resource;
    
    import org.springframework.stereotype.Service;
    
    import testwebapp.com.wangzuojia.dao.SequenceMapper;
    import testwebapp.com.wangzuojia.service.Human;
    import testwebapp.com.wangzuojia.service.SequenceService;
    
    @Service
    public class SequenceServiceImpl implements SequenceService {
    
    	@Resource
    	private SequenceMapper sequenceMapper;
    	public void generateId(Map<String, String> map) {
    		sequenceMapper.generateId(map);
    		
    	}
    	
    	@Resource(name = "manImpl")//注意是manImpl不是ManImpl,因为使用@Service,容器为我们创建bean时默认类名首字母小写
    	private Human human;
    
    }

     

    这样启动服务就不会报错了。如果是使用的@Autowired注解,要配上@Qualifier("manImpl"),代码如下:

     

    package testwebapp.com.wangzuojia.service.impl;
    
    import java.util.Map;
    
    import javax.annotation.Resource;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.stereotype.Service;
    
    import testwebapp.com.wangzuojia.dao.SequenceMapper;
    import testwebapp.com.wangzuojia.service.Human;
    import testwebapp.com.wangzuojia.service.SequenceService;
    
    @Service
    public class SequenceServiceImpl implements SequenceService {
    
    	@Resource
    	private SequenceMapper sequenceMapper;
    	public void generateId(Map<String, String> map) {
    		sequenceMapper.generateId(map);
    		
    	}
    	
    	@Autowired
    	@Qualifier("manImpl")
    	private Human human;
    
    }

     

     

     

     

     

    展开全文
  • @Autowired(required=false)注入注意的问题

    万次阅读 多人点赞 2018-03-16 14:47:14
    1、前言在使用spring开发过程中,我们基本上都是使用@Autowired这个注解,用来注入已有的bean。但是有些时候,会注入失败。当我们加上参数(required=false)就能解决。今天整理一个我在实际开发中的例子2、required...
  • @Autowired

    2019-09-22 22:25:11
    @Autowired 是一个注释,它可以对类成员变量、方法及构造函数进行标注,让 spring 完成 bean 自动装配的工作。 @Autowired 默认是按照类去匹配,当多个bean类型的对象时,配合 @Qualifier 指定按照名称去装配 bean。...
  • @Component public class XxxConfig { // 1 public static XxxConfig xxxConfig ; @Resource private RedisUtil redisUtil; // 2 @PostConstruct public void init() { xxxConfig = this;... // 3....}
  • @AutoWired

    2019-12-11 15:00:54
    Autowired 是一个默认必须找到对应Bean 的注解,如果不能确定其标注属 性一定会存在并且允许这个被标注的属性为null , 那么你可以配置@A utowired 属性required 为false, 例如,像下面一样: @Autowired...
  • 使用@Autowired注解警告Field injection is not recommended

    万次阅读 多人点赞 2018-07-18 10:57:57
    在使用spring框架中的依赖注入注解@Autowired时,idea报了一个警告 大部分被警告的代码都是不严谨的地方,所以我深入了解了一下。 被警告的代码如下: @Autowired UserDao userDao; 警告内容是 Field ...
  • @Autowired 的作用是什么?

    万次阅读 多人点赞 2019-07-24 10:17:14
    @Autowired 的作用是什么? @Autowired 是一个注释,它可以对类成员变量、方法及构造函数进行标注,让 spring 完成 bean 自动装配的工作。 @Autowired 默认是按照类去匹配,配合 @Qualifier 指定按照名称去装配 ...
  • 文章目录@[toc]常用注解注释位置(@Autowired放置在构造器上与放在属性上的区别)对成员变量注释对构造函数注释对成员方法注释@Autowired和构造方法执行的顺序@Autowired与@Resource注入方式(注意)基于Setter的依赖...
  • @Autowired用法详解

    万次阅读 多人点赞 2016-08-25 13:26:17
    默认情况下,@Autowired 注解意味着依赖是必须的,它类似于 @Required 注解,然而,你可以使用 @Autowired 的 (required=false) 选项关闭默认行为。 即使你不为 age 属性传递任何参数,下面的示例也会成功运行...
  • [spring] 注解@Autowired是如何实现的

    万次阅读 多人点赞 2019-03-19 16:53:53
    @Autowired注解用法 @Autowired注解的作用到底是什么 @Autowired注解是如何实现的 例子注解@Override 自己实现一个注解 @Autowired注解实现逻辑分析 问题 注解的有效周期是什么? 注入的bean和用它的bean的...
  • 对@Reference 、@Resource和@Autowired的简单理解

    万次阅读 多人点赞 2018-11-20 00:26:33
    主要谈一下对这三个注解的简单理解: @Reference 、@Resource和@Autowired
  • @Autowired 警告 Field injection is not recommended Spring @Autowired注入
  • 为何需要@Autowired注入,以及@Autowired注释的作用 spring可以自动帮你把Bean里面引用的对象的setter/getter方法省略,它会自动帮你set/get。@Autowired注释进行自动注入时,spring容器中匹配的候选Bean数目必须有...
  • 关于@Autowired和@Resource的区别,@Autowired报红解决方法 先挖个坑,后面有空补上, 1.@Autowired为bytype,是spring中的一个注解。有一点需要注意的是,当使用@Autowired来自动注入接口时,比如注入mapper接口...
  • @autowired 用于测试的实体类User,并将这个类注入到Spring容器中,为@autowired注解放在方法做前提工作 @Component public class User { private String name = "张三"; public String getName() { return ...
  • 在Service层注入Mybatis的Mapper我们通常会使用@Autowired自动注入 1 2 @Autowired private ProductMapper productMapper; 但是这样Intellij IDEA会显示红色告警,提示不能自动注入。...
  • @Resource的作用相当于@Autowired。 @Autowired与@Resource都可以用来装配bean. 都可以写在字段上,或写在setter方法上。 不同点 @Autowired按byType自动注入,而@Resource默认按 byName自动注入。 @Resource有两...
  • @Autowired注解我们实际工作和学习中,用的是比较频繁的。这篇文章主要是结合源码了解它的实际工作过程即是怎么把我们需要的类注入到我们类中的。@Autowired注入过程,实际上分为三个方面:1、元信息解析;2、依赖...
  • @Autowired @Resource

    2021-05-22 15:32:53
    @Autowired 与@Resource的区别: 1、 @Autowired与@Resource都可以用来装配bean. 都可以写在字段上,或写在setter方法上。 2、 @Autowired默认按类型装配(这个注解是属于spring的),默认情况下必须要求依赖对象必须...
  • @Autowired,依赖注入,可选 @Autowired(required=false) private RedisTemplate<String, Object> redisTemplate ; @Bean @ConditionalOnProperty,什么时候创建Bean @Bean @ConditionalOnProperty...
  • 1.Autowired org.springframework.beans.factory.annotation.Autowired SpringBoot项目中使用,依赖注入。 2.Resource javax.annotation.Resource 和@Autowired,只不过是@Autowired是byType自动注入,而@Resource...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 373,225
精华内容 149,290
关键字:

@autowired