@Bean Annotation

@Bean is a method level annotation used to declare a bean managed by spring application context.

The @Bean annotation is used within a class annotated with @Configuration, indicating that the bean defined is specific to that configuration class.

Let’s create one simple StudentService class containing getMessage() method as shown below:

Now, create a configuration class named StudentConfig and annotate it with @Configuration, which implicitly includes the @Component annotation. Then, define a method and annotate it with @Bean to instantiate and initialize a StudentService bean.

StudentService bean will get register in the spring application context.

Run application and check console to see below output when StudentService bean for instantiated.

Ways to Access Bean

Below are the ways to access bean’s methods:

Using StudentService Bean class name:

Using @Bean annotation using Alias:

Declare attribute name attribute /alias as “stud”.

Access bean using bean’s alias:

NOTE: As shown above, we can declare the name attribute with multiple values as part of the @Bean annotation. This allows us to access the bean using the given name instead of the class name.

InitMethod and DestroyMethod

The @Bean annotation allows us to specify initMethod and destroyMethod, which are called during bean creation and before the application context is closed, respectively.

In StudentService Bean class create two separate methods as init() and destroy()

declare both the init() and destroy() method as part of @Bean annotation initMethod and destroyMethod attribute.

Run spring application and verify below output post application startup as it will call constructor and init():

It will execute destroy method just before application gets stop as shown below:

Dependency Injection:

@Bean Supports Dependency Injection

Beans can depend on other beans, and Spring will automatically resolve dependencies.

Spring will automatically inject the repository bean.

@Bean Scope

By default bean scope in singleton. Scope can be change with the help of @Scope annotation.

@Scope(“singleton”): Single instance through out application lifecycle.

@Scope(“prototype”): Create new instance every time the bean is requested.