精华内容
下载资源
问答
  • 一、区别

    区别

    1、提供方:

            @Autowired:由org.springframework.beans.factory.annotation.Autowired提供,即Spring提供;

            @Resource:由javax.annotation.Resource提供,即J2EE提供,要求JDK1.6及以上;

    2、注入方式
           @Autowired:a.按照类型注入(byType),因此默认情况下它要求其所依赖的对象必须存在,如果允许 
                                     null值,只需设置其required属性为false(@Autowired(required=false))。
                                  b.由于其按照类型注入,因此如果一个接口有多个实现时,使用@Autowired注解就有可 
                                     能失败,此时可以配合@Qualifier注解指定依赖的具体实现类;如:
                                     @Autowired
                                     @Qualifier("具体实现类名")

           @Resource:提供了按照byName和byType两种方式注入,默认方式为byName;对应的两种属性分别为 
                                  name和type;
                                  如:@Resource(name="指定类名")

    3、@Resource装配顺序

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

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

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

                             d. 如果既没有指定name,又没有指定type,则自动按照byName方式进行装配;如果没有匹配,则回退为一个原始类型进行匹配,如果匹配则自动装配;

    展开全文
  • Spring中Autowired注解,Resource注解和xml default-autowire工作方式异同 2012/11/07 17:25:28 No Comments Tags: autowire, default-autowire, java, resource, spring, 源码分析 Posted :java开发, 开源框架, ...
    Spring中Autowired注解,Resource注解和xml default-autowire工作方式异同
    2012/11/07 17:25:28 No Comments
    Tags: autowire, default-autowire, java, resource, spring, 源码分析 Posted :java开发, 开源框架, 编程开发

    前面说到了关于在xml中有提供default-autowire的配置信息,从spring 2.5开始,spring又提供了一个Autowired以及javaEE中标准的Resource注释,都好像可以实现类似的自动注入。那么是不是每个都实现同样的方式呢,这里面的几个配置到底有哪些异同点。哪个更全,哪个更优先,这些都需要对spring的内部原理有详细的了解才可以进行了解。
    在以下文章时,首先有几个概念需要列出:
    字段名称:即fieldName,这个即propertyDescriper的getPropertyName返回信息。
    setter名称:即方法setter除set之外的名称,如setAbc,则名称为abc,这里的abc不一定和fieldName相同。
    参数名称:即在参数中所定义的参数的名称,如setAbc(Abc a123)。这里的参数名称就是a123。
    本文所使用spring版本为spring3.0.2。

    处理类和处理顺序异同

    default-autowire是在xml中进行配置的,而这个配置从spring初始就提供了。而Autowired注解,则是从2.5自支持以java1.5之后才出现的,这就必然导致对相应的处理以及逻辑是不同的。那么每个方式的处理顺序是怎样的呢,从我写的文章:Spring中获取一个bean的流程-2.也可以由下面的代码得出:
    if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
    mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
    MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

    // Add property values based on autowire by name if applicable.
    if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
    autowireByName(beanName, mbd, bw, newPvs);
    }

    // Add property values based on autowire by type if applicable.
    if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
    autowireByType(beanName, mbd, bw, newPvs);
    }

    pvs = newPvs;
    }
    ......
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
    if (bp instanceof InstantiationAwareBeanPostProcessor) {
    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
    pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);

    以上代码来源于类AbstractAutowireCapableBeanFactory的populateBean方法。从上可以看出,spring首先处理在bean定义上的autowire属性,然后再处理后面的InstantiationAwareBeanPostProcessor类。首先bean定义上的autowire属性,可以来自于<bean>定义时autowire属性,也可以来自于整个xml定义中<beans>节点中的default-autowire属性。

    那么@Autowired注解和@Resource注解在哪儿处理呢,看上面的代码,有个InstantiationAwareBeanPostProcessor类,如果你仔细查看里面的实现,你可以发现里面即为处理相应注解类的实现。而这些注解类,只要在xml中启用了<context:annotation-config/>,即可以开启这些类了。而我们的Autowired注解,由AutowiredAnnotationBeanPostProcessor来进行处理,而Resource类,则由CommonAnnotationBeanPostProcessor进行处理。

    处理内容和处理范围异同

    xml中default-autowire配置

    首先,针对于xml配置中的default-autowire配置,我们都知道byName是通过name注入而byType是通过类型注入。byType没有好争议的,是根据类型从所有bean查找满足条件的bean,如果找到一个,则使用此bean。但是如果没有找到,则不会报错,但是如果发现有2个以上的侯选者,则会报No unique bean of type的错误信息。

    针对于byName,则是根据propertyDescriptor,即满足bean规范的字段信息进行注入。之所以这里重点提bean规范,请看以下代码:


    private TxInterface tx2;

    public TxInterface getTx3() {
    return tx2;
    }

    public void setTx5(TxInterface tx3) {
    this.tx2 = tx3;
    }

    这里是不会进行任何注入的,因为里面的tx2,根本不满足bean规范。但如果将方法setTx5修改为setTx2,则就满足bean规范,就会进行byName注入了。

    @Autowired注解

    再来看Autowired注解,有的人说autowired注解是按照byType方式进行配置,其实这个说法是错的,至少是不完善的。为什么呢,这需要我们来查看整个autowire的流程,如以下代码示:

    Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
    if (matchingBeans.isEmpty()) {
    if (descriptor.isRequired()) {
    raiseNoSuchBeanDefinitionException(type, "", descriptor);
    }
    return null;
    }
    if (matchingBeans.size() > 1) {
    String primaryBeanName = determinePrimaryCandidate(matchingBeans, descriptor);
    if (primaryBeanName == null) {
    throw new NoSuchBeanDefinitionException(type, "expected single matching bean but found " +
    matchingBeans.size() + ": " + matchingBeans.keySet());
    }
    if (autowiredBeanNames != null) {
    autowiredBeanNames.add(primaryBeanName);
    }
    return matchingBeans.get(primaryBeanName);
    }
    // We have exactly one match.
    Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
    if (autowiredBeanNames != null) {
    autowiredBeanNames.add(entry.getKey());
    }
    return entry.getValue();

    以上代码来自于类DefaultListableBeanFactory的doResolveDependency方法。这是由类AutowiredAnnotationBeanPostProcessor类通过调用inject方法时,需要通过调用beanFactory.resolveDependency(descriptor, beanName, autowiredBeanNames, typeConverter)来解析引用信息。我们仔细看以上的逻辑,可以从下面的顺序进行处理。

    首先根据类型找到所有可以满足条件的bean
    判断bean长度,如果没有,则根据@autowired中的required属性进行判断是否抛出异常(默认为true)
    如果多于一个,则尝试寻找最优的那一个,如果最优的未找到,则抛出异常
    如果只有一个,则直接使用此bean

    这个逻辑与byType类似,但还不完全相同。不相同的则在第3点处理上,byType如果多于一个,则直接抛出异常。而这里有一个寻找最优bean的过程。即方法determinePrimaryCandidate的实现。实现代码不再列出。但根据@Autowired所放置位置有所不同。

    放置在setter方法上,则使用MethodParameter的parameterName进行查找,请注意这里的parameterName。这个属性只有在编译时保留了debug的localVariable才会存在,否则即为null属性。这个属性即参数的名称。如果localVariable不存在,则直接退化为byType。如果有,就按照参数名称进行查找。这里的参数名称不是setter后面的名称,也不是字段名。如以下代码所示:
    1

    public void setTx2(TxInterface tx1) {this.tx2 = tx1;}

    这里的名称为tx1,而不是tx2。

    放置在字段上,则直接使用字段名称。进行查找。

    @Resource注解

    最后看Resource注解,也有的人说resource是按byName注解,即就完全错了。实际上Resource根本不会走byName方式,我们来看@Resource如何寻找一个bean。默认在不写Resource(name)的情况下:

    String name = element.name;

    if (this.fallbackToDefaultTypeMatch && element.isDefaultName &&
    factory instanceof AutowireCapableBeanFactory && !factory.containsBean(name)) {
    autowiredBeanNames = new LinkedHashSet<String>();
    resource = ((AutowireCapableBeanFactory) factory).resolveDependency(
    element.getDependencyDescriptor(), requestingBeanName, autowiredBeanNames, null);
    }
    else {
    resource = factory.getBean(name, element.lookupType);
    autowiredBeanNames = Collections.singleton(name);
    }

    if (factory instanceof ConfigurableBeanFactory) {
    ConfigurableBeanFactory beanFactory = (ConfigurableBeanFactory) factory;
    for (String autowiredBeanName : autowiredBeanNames) {
    beanFactory.registerDependentBean(autowiredBeanName, requestingBeanName);
    }
    }

    return resource;

    以上代码来自于类CommonAnnotationBeanPostProcessor中的autowireResource方法,是由此类通过getResourceToInject获取将要注入的bean来调用的。上面的方法详细描述了整个过程,如下所示:

    获取element的名称,判断beanFactory是否存在此name的bean
    如果存在,则直接使用此name进行查询
    否则退化到默认的autowire查找方式

    从上面的第三步,可以看出,Resource在没有根据name查找到的情况下,会走Autowire的方式。所以,从范围来看Resouce的查找范围比Autowire范围更大。

    再来看第1步,获取element的名称,这里说是element的名称,因为它的来源有2个地方。一是在resouce注解中配置的name属性,第二就是setter名称或者是field名称(取决于@Resource的配置地点),。这里说的是setter名称,而不是属性名称,这就是需要注意的地方。来源代码如下所示:

    String resourceName = resource.name();
    this.isDefaultName = !StringUtils.hasLength(resourceName);
    if (this.isDefaultName) {
    resourceName = this.member.getName();
    if (this.member instanceof Method && resourceName.startsWith("set") && resourceName.length() > 3) {
    resourceName = Introspector.decapitalize(resourceName.substring(3));
    }
    }

    来源于类ResourceElement的initAnnotation方法。因此,如果方法为如下所示:


    @Resource
    public void setTx2(TxInterface tx5) {
    this.tx4 = tx5;
    }

    则获取到的name就是tx2,而不是字段名称tx4。当然,上面的写法不是标准的java bean规范写法,但只是演示这种情况。那么,在系统存在多个满足type的情况下,如果上面的方法中的tx2的bean未找到,那么接下来就寻找名为tx5(autowire规则),再找不到就该报Not Unique异常了。

    值得注意的是,如果在使用resource时,根据resource的name找到了bean,但该bean并不是所需要的bean类型,则就要报类型不匹配错误了。即spring在查找时,并没有保证类型判断,即你配置一个name的tx2的bean,但该类型即为TxInterface2而不是TxInterface,则spring在后期直接报异常,而不会fallback了。但Autowired注解则不会产生这种情况,因为它只会从满足type的情况中的bean中查找。

    总结

    在使用Autowired注解和Resource注解以及xml中的default-autowire注解时,需要详细地了解每个注解的工作方式和工作范围,在大多数情况下。这几种方式都差不多,但在细节方面有差异。从笔者对于代码的严谨角度,我并不推荐在xml中配置default-autowire,因为这会导致所有的bean,不管需不需要注入,spring都会帮你注入。从一方面是好事,从另一方面就管得太多。如果确实要配置default-autowire,请再配置另一个属性default-autowire-candidates,这个属性可以固定default-autowire的范围,比如*Service,可以只针对Service结尾的bean进行autowire包装。

    最后,@Autowire注解不是xml配置中的default-autowire-byType,而@Resource也不是@Autowire,更不是xml配置中的default-autowire-byName。不能够简单地混为一谈。
    展开全文
  • @Resource和@Autowired 的区别 @Resource的作用相当于@Autowired,只不过@Autowired按byType自动注入,而@Resource默认按 byName自动注入罢了。@Resource有两个属性是比较重要的,分是nametype,Spring将@Resource...

    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注解进行使用,如下:

    @Autowired()@Qualifier("baseDao")
    privateBaseDao baseDao;
    

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

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

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

    spring @Qualifier注解

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

    ①可能存在多个UserDao实例

       @Autowired   
        @Qualifier("userServiceImpl")   
        public IUserService userService;   
    
    

    或者

      @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 {

    @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:
    springautowiredqualifierbytypebyname
     在使用Spring框架中@Autowired标签时默认情况下使用
    Java代码

    @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代码

    @Qualifier  
    

    @Qualifier

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

    Java代码

    @Qualifier("XXX")  
    

    @Qualifier(“XXX”)

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

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

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

    Java代码

    @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 或者 @Autowire 一、应用放在字段上则注入规则是: 1.先使用字段名字匹配到Bean,查找到bean则注入,如果类型不匹配则此时有异常,注入失败 2.如果字段名字没有匹配到Bean则Spring会尝试采用字段类型匹配...

    @Resource 或者 @Autowire

    一、应用放在字段上则注入规则是:
    1.先使用字段名字匹配到Bean,查找到bean则注入,如果类型不匹配则此时有异常,注入失败
    2.如果字段名字没有匹配到Bean则Spring会尝试采用字段类型匹配,如果找到一个Bean则注入,如果字段类型是接口则又可能会匹配到多个类型,则会抛出匹配到多个bean的异常,注入失败
    二、应用到setter上
    1.先使用属性名字(参数类型属性 eg:setName 属性名字就是:name)匹配bean,查找到bean则注入,如果类型不匹配则此时有异常,注入失败
    2.如果属性名字没有匹配到bean,则Spring会尝试采用属性参数类型匹配,如果找到Bean则注入,如果属性参数类型是接口则有可能会匹配到多个类型,则会抛出匹配到多个bean的异常,注入失败

    两者的功能区别除了找的名字不同(其实一样)之外,最大的差别是应用在字段上时,注入时会进行寻找setter方法去注入,而setter方法则不需要找在去找setter方法。这样就提高了效率

    但是为了让代码有可看性和可塑性大多数还是要将注解放在字段上

    如果将setter方法的修饰符变为private私有的。这个时候如果你把注解放在属性上,这个时候spring框架单单通过属性就不能找到setter方法。
    但是把注解放在私有的setter方法上,这个时候sping底层其实是用了反射机制,反射机制可以无视java的规则。可以反射调用私有的方法。
    当然我们也不会将setter方法变为私有的…

    展开全文
  • Spring注解@Resource和@Autowire区别 @Autowire Autowire默认按照类型装配,默认情况下它要求依赖对象必须存在如果允许为null,可以设置它required属性为false,如果我们想使用按照名称装配,可以结合@Qualifier...
  • 注解 @Resource和@Autowire区别 @Resource和@Autowired的区别 @Resource和@Autowired都可以用来装配bean,都可以用于字段或setter方法。 @Autowired默认按类型装配,默认情况下必须要求依赖对象必须存在,如果要...
  • 自动注入Bean时,使用@Autowired@Resource两个注解区别区别: 更详细的解释 1、@Autowired ①Spring框架自带的注解 ②按照byType类型注入bean,默认情况下要求依赖对象必须存在 2、@Resource ①J2E的注解 ②...
  • 在applicationContext.xml中扫描service所在的包第三步:在需要注入的service中加上@service注解第四步:在controller中在需要注入的service上加上@Resource或者@Autowire就可以了...
  • 注解@Resource与@Autowired的区别 @Resource和@Autowire区别
  • @Resource @Autowire区别

    千次阅读 2019-06-05 22:48:46
    @Resource @Autowire区别 @Resource 是J2EE的注解,@Autowire 是Spring的注解 @Autowire注入时By Type 如果要使用 By Name 需要配合@Qualifier 使用如下 @Autowire @Qualifier(“size”) Size size; @...
  • @Resource 这属于java自带的注解 javax.annotation.Resource @Autowired默认是按照类型来注入的,默认情况下要求依赖对象必须存在。 如果允许依赖对象为null,需设置required属性为false, 需要按名字注入的话...
  • @Autowire注解与自动装配

    万次阅读 2016-10-19 16:31:07
    前面我们已经学会使用@Resource注解注入属性,并且我们还编码剖析了@... 用@Autowire注解完成属性装配@Autowire注解和@Resource一样,同样也可以标注在字段或属性的setter方法上,但它默认按类型装配。 我们将@Autowi
  • @Autowire和@Resource注解区别

    万次阅读 多人点赞 2019-01-13 22:53:00
    @Autowire和@Resource都是Spring支持的注解方式动态装配bean。 详解 @Autowire @Autowire默认按照类型(by-type)装配,默认情况下要求依赖对象必须存在。 如果允许依赖对象为null,需设置required属性为false,即 @...
  • @Autowire 作用:可以对类成员变量,方法以及构造函数进行标注,让spring完成bean自动装配(spring通过依赖注入创建实例)的工作。 @Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType....
  • 【Spring】@Resource和@Autowire区别

    千次阅读 2017-04-02 22:02:54
    spring不但支持自己定义的@Autowired注解,还支持几个由JSR-250规范定义的注解,它们分别是@Resource、@PostConstruct以及@PreDestroy。  @Resource的作用相当于@Autowired,只不过@Autowired按byType自动注入,而...
  • @Resource 相当与 @Autowire 加上 @Qualifier @Autowire默认按照类型装配,默认情况下必须要求依赖对象必须存在,如果要允许null值,可以设置它的required属性为false。 @Resource装配顺序 如果同时指定nametype...
  • 前面我们已经学会使用@Resource注解注入属性,并且我们还编码剖析了@...现在我们来学习使用@Autowire注解注入属性,本文是建立在编码剖析@Resource注解的实现原理的案例基础上的。 用@Autowire注解完成属性...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,275
精华内容 4,510
关键字:

resource和autowire注解的区别