From [this Spring documentation](http://docs.spring.io/spring/docs/3.2.6.RELEASE/spring-framework-reference/htmlsingle/#beans-factory-autowire) I know that when I use @Bean, the default is already equivalent to:

@Bean(autowire = Autowire.NO)

> 
> (Default) No autowiring. Bean references must be defined via a ref element. Changing the default setting is not recommended for larger deployments, because specifying collaborators explicitly gives greater control and clarity. To some extent, it documents the structure of a system.
> 
> 
> 

I am just trying to understand what this means for me. If my system is 100% Java Config **and has no XML configuration**, then from what I can tell, when I use @Bean, the 'Autowire.no' has no impact whatsoever. 

**EDIT**

By "no impact" I mean that other @Autowired references to this bean ARE autowired (in other Java Config classes). I suspect that is because with Java Config there is no explicit 'ref element' defined, so this (default) setting has no effect.

Example:

First Config:

```
package a.b.c;

@Configuration
public class AlphaConfig {

    @Bean(autowire = Autowire.NO)
    public AlphaBeanType alphaBean() {
        return new AlphaBeanType();
    }
}

```

Then in second config:

```
package d.e.f;

import a.b.c.AlphaBeanType;

@Configuration
public class AnotherConfig {

    @Autowire
    private AlphaBeanType alphaBeanType;

    @Bean
    . . .
}

```

What I see is that 'alphaBeanType' is always autowired in the second config class - which seems to be in conflict with the documentation - hence my question.

**end edit**

Of course, I can't quite tell from the documentation! Does anyone know for sure?
['https://Stackoverflow.com/questions/21020187', 'https://Stackoverflow.com', 'https://Stackoverflow.com/users/1538856/']
The `autowire` element of the `@Bean` annotation (as well as the `autowire` attribute of the `bean` element in xml-based config) determines the autowiring status of the **bean's own properties** and has no relation to how a bean which is marked with the `@Bean` annotation will be injected into other beans. 

On the other hand the `@Autowired` annotation explicitly 

> 
> marks a constructor, field, setter method or config method as to be autowired by Spring's dependency injection facilities.
> 
> 
> 

So in your case the `@Bean` annotation declared on the `alphaBean` method with the default `Autowire.NO` mode disables automatic (that is implicit) injection of the properties (if any) of the `AlphaBeanType` bean. While the `@Autowired` annotation indicates that an `AlphaBeanType` bean should be injected into `AnotherConfig` configuration object.
That is what the spring documentation says though right? the default is NO. So, even if you do explicitly specify it it shouldnt have any impact. Also, when you do specify a bean, what you did mention of it being Autowire.No is correct. so it shouldnt have any impact.