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.
`no` The traditional Spring default.

No automagical wiring. Bean references must be defined in the XML file via the `<ref/>` element (or `ref` attribute).

We recommend this in most cases as it makes documentation more explicit.

Note that this default mode also allows for annotation-driven autowiring, if activated.

`no` refers to externally driven autowiring only, not affecting any autowiring demands that the bean class itself expresses