Terminologies used in Spring Framework

Tight Coupling, Loose Coupling, Dependency Injection, IOC Container, Application Context, Spring
Bean,Auto Wiring

Component Scan

Point 1:

@ Configuration – Is used to create one or more than one Beans at runtime by using

@ Bean annotation . – use same bean name in application context when retrieving the bean by using
getBean method .

Here we can customized Bean name by mentioned name attribute with annotation

@Bean(name=”whatever”)

To call it we will use

var context= new AnnotationConfigApplicationContext(configurationClassname.class);

context.getBean(“beanName”);

Point 2 :

In Java 16 we have feature “record” which will create Pojo Bean and we don’t need to create setter or
getter as this will automatically.

Use above of class

Ex. record Person(String name, int age) {};

Point3:

@configuration is kind @Component but not vice versa.

Spring Container – Is also called Spring Context or IOC container which managed the spring beans and
their life cycles .It takes classes (Pojo , Configuration ) as input and creates a running system.

There are two popular IOC containers:

Bean Factory- This is core Spring IOC Container. Basic Spring Container

ApplicationContext : it extended version of spring Bean Factory .Its advance container with enterprise-
specific feature.

 Easy to use in Web application .

 Easy Internationalization

 Easy Integration with Spring AOP

Java Bean Vs POJO Vs Spring Bean:
Java Bean (Using in EJB which nowdays rare to use )-

It contains non-arg constructor,

Getter/setter method of fields

Implements Serializable interface

class JavaBean implements Serializable{
private int num;
JavaBean(){

}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
}

PoJo – Plain old java object

Every class is POJO in java.

class Pojo
{
int number ;
String Text;
public String toString() {
return number + " "+Text;
}
}

Spring Bean – Bean which managed by Spring Container.

Point 4 – If you have multiple Beans for same class then we use

@Primary to solve the problem

(Ex – Issue - No qualifying bean of type 'com.in28minutes.learnspringframework.Person'

available: expected single matching bean but found 3:
person2,person2MethodCall,person2ParameterPass
)

Also Can use

@Qualifier to simulate which Bean spring container will called if multi matching Beans.
If we need to create objects and ask Spring to create Bean for us then we use @Component- Bean
creates by Spring Container(instance of class which is managed by Spring framework)

@ComponentScan (“package name”)– Scan the package where it can find the class (Bean or component
) for which spring would create the object.

If we don’t defined it will check in same package

@Qualifier (“name of bean”)- When SPECIFIC Bean should be auto-wired (name of bean can be used
as Qualifier)

@Primary- A bean should be given preference when multiple candidates are qualified. Specific Bean
should be auto-wired.

Primary vs Qualifier-

Primary-When need to give preference of Bean then use Primary and use just @Autowired annotation

Qualifier-When need to use specific Bean then use @Autowired +@ Qualifier.

@Qaulifer is higher priority than @Primary

Dependency Injection types:

Constructor Based- Dependencies are set by creating Bean using its constructor(@ Autowired is not
mandatory on this and recommended )

Setter Based- Dependencies are set by calling setter methods on your beans.(@ Autowired on setter
methods)

Field– No setter or constructor – Dependencies are set using reflection. (Using @Autowired on field)

@Component
class MyBusinessClass{
@Autowired
Dependecies1 s1;
@Autowired
Dependencies2 s2;
}

Dependency (Example – GammingRunner Class needs GamingConsoleImple)

Dependency Injections – Identify the beans , their dependencies and wire them together (it will also
called Inversion of Control - IOC)

Autowiring - Process of wiring in dependencies for a Spring Bean

Comparision Between @Comnponent and @ Bean

Heading @Component @Bean

Where Can be used in any java classes Typically, it is used on metho

ds in Configuration classes.

Ease of use Very easy to use. Just need to Need to write all code
write annotation

Autowiring Yes- Constructor, Setter or Field Yes- method call or method

parameter

Who creates Beans? Spring Framework You write Bean creation code

Recommended for Instantiating Beans for your own 1. Custom Business

application code: @Component Logic

2. Instantiating Bean for

3 rd. party libraries:
@Bean

Initialization of Spring Bean-

Default initialization of Spring Bean is Eager.(Means Spring Container initialized bean at the time of
running while this is not in use )

@Lazy – to make sure that it will initialize when it is required.

 It can be used almost every where @component and @ Bean are used.

 Lazy-resolution proxy will be injected in place of actual dependency.

  Can be used on Configuration class (@Configuration)- all @Bean methods within Configuration
will be lazy initialized.

Eager Initialization is recommended because

1. Error in configuration is discovered immediately at the time of application start up.

You can configure Lazy Initialization using Lazy annotation (Not recommended and not frequently used)

Comparision bwt Lazy and Eager Initialization

Heading Lazy Initialization Eager Initialization

Initialization Time Bean is initialized when it is Bean Initialized at the start

made first use of in the up of the application
application

Default Not Default Default

Code snippet @Lazy or @Lazy(value=true) @Lazy(value=false) or

(absence of @Lazy )

Usage Rarely use Frequently used

Memory use Less as initialized when it is All beans will be

required initialized at the time
of starting up of the
application

Recommended scenarios When bean very rarely used in Most of your beans
application
Scope of Bean-

@Scope(ConfigurableBeanFactory.type of scope)

Prototype – Each time we will get new Bean instance . Many instancse per IOC container

Singlton- Every time will get same bean instance (Its default scope).Only one instance per IOC container

Scope available only for web-aware Spring Application Context

Request- one object instance per single HTTP request

Session- one object instance per user HTTP session

Application- one object instance per web application runtime

WebSocket- one object instance per WebSocket instance

Java Singlton vs Spring Singlton –

Spring Singelton – One object instance as per IOC container (May be chance that JVM is using multiple
IOC container then more than one will available)

Java Singleton (GOF) – One Object Instance as per JVM

Else both are focus on single object

Singleton Vs Prototye scope

Heading Prototype Singleton

Instance Many instances per IOC container One instance per IOC container

Bean New Bean instance created every Same bean instance reused
time the bean referred to

Code snippet @Scope(value=ConfigurableBeanF @Scope(value=ConfigurableBeanFact

actory.SCOPE_PROTOTYPE) ory.SCOPE_SINGLETON) or Default
Default Not Default

Usage Rarely used Frequently

Recommende Stateful Bean Stateless Bean

d scenarios

@PostConstruct – Its called after dependency injected is ready to initialize.

@PreDestroy- to clean up before destroying the object
For CDI implementation in Jakarta EE
Need to add following dependency :
Group id- Jakarta.inject
artifact id- Jakarta.inject-api

Here @Named is alternation of @Component

@Inject is replacement of @Autowired in spring framework

Whenever we need to pass something from controller then we will use Model.

For sending Parameter we will use @RequestParam

3 Important Changes

 Change 01: Use jakarta.servlet.jsp.jstl instead of glassfish-jstl

  Change 02: Use jakarta.tags.core instead
of http://java.sun.com/jsp/jstl/core as taglib
 Change 03: Run mvn clean install to update libraries

Details: https://github.com/in28minutes/master-spring-and-spring-boot/blob/main/spring-boot-
3.2.x-changes.md

Change 01: Use jakarta.servlet.jsp.jstl instead of glassfish-

jstl
Spring Boot 3.2.x and greater
1. <dependency>
2. <groupId>org.glassfish.web</groupId>
3. <artifactId>jakarta.servlet.jsp.jstl</artifactId>
4. </dependency>

jakarta.servlet.jsp.jstl replaces glassfish-jstl (recommended for Spring

Boot <= 3.1.x)
1. <dependency>
2. <groupId>org.eclipse.jetty</groupId>
3. <artifactId>glassfish-jstl</artifactId>
4. </dependency>

jakarta.tags.core instead
Change 02: Use
of http://java.sun.com/jsp/jstl/core as taglib

Spring Boot 3.2.X and greater

Use
1. <%@ taglib prefix="c" uri="jakarta.tags.core" %>
Spring Boot 3.1.X and lower

Use
1. <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

Change 03: Run mvn clean install to update libraries

And then execute the mvn clean install command

Thank you!
in28minutes team (Maahi and Ranga)