In this article, we will see what is spring MVC how we will develop our project using spring MVC and how it helps to build our applications fastly without focusing more on the configuration side.

MVC architecture:
In this type of architecture, we have a clear-cut separation of logic. All the code is in the form of M(Model) V(View) C(Controller).

Advantages of MVC architecture:
1. As we have multiple layers there is clear-cut separation.
2. Modification in one layer will not impact the other.
3. Maintenance and enhancement are easy.
4. Industry standard approach.

We have a few frameworks that provide abstraction on top of MVC architecture. A few of the frameworks are:
1. Struts
2. JSF
3. Web Work
4. Spring MVC
5. ADF

Advantages of using a framework with MVC architecture:
1. Ready-made servlet controller, no need to write controller logic manually.
2. Ready-made servlet controller can trap all the incoming requests to the application.
3. Framework itself takes care of navigation and view Data management.
4. Avoided boilerplate code. (like configuring servlet for every)

We will see Spring MVC/ Spring Boot MVC in this part where the Ready-made servlet Controller/ Front Controller is DispatcherServlet.

DispatcherServlet is already coded and made ready by the Spring team.
To use the dispatcher servlet we need to use the below annotations:
1. @Controller (spring Bean + Controller class)
2. @RequestMapping (controller class having request mapping and type)

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
public class DemoController {
    @RequestMapping(value = "/print", method = RequestMethod.GET)
    public String printRequest() {
        return "Hello";
    }
}

The above is an example of a controller handler with Request mapping of “/print” and with method type as “GET”.

Different values as method arguments are as below:
1. Servlet Request
2. Servlet Response
3. Path Variable
4. Request Param
5. Request Header
6. Request Attribute
7. Model Attribute
8. Session Attribute
9. Error, Binding result.

Different values as method responses are as below:
1. String
2. View
3. Model
4. Model and View
5. void
6. Model Attribute

Note: In SpringBoot-MVC Apps the following components comes automatically so we
need not develop them
a. DispatcherServlet
b. IOC-Container
c. HandlerMapping
d. ViewResolver

To get all these we need to go for a starter file called “spring-
boot-starter-web”.

The general flow of the spring MVC application is as below.

The main part of Spring MVC is the Dispatcher servlet which will trap all the incoming requests process and send the requests to a particular controller.

Few of the annotations are commonly used while developing Spring MVC applications.

1. @Controller:
   This annotation defines the class as a component and will treat it as a controller entry point for all incoming requests.
   This annotation is always applied at the class level.
   ex:
   @Controller
   public class DemoController {
   }
2. @RequestMapping:
   This annotation is used to define the end point for which the method annotated needs to be executed and the request type.
   This annotation is used at the method level.
   ex:
   @RequestMapping(value = “/print”, method = RequestMethod.GET)
   To simplify more we also have
   @GetMapping
   @PostMapping
   @PatchMapping
   @DeleteMapping
   for the above annotations, no need to specify the RequestMethod, the annotation itself resembles the method type.
3. @RequestHeader:
   This annotation is used to get any parameter from the header in the incoming request.
   This is used as a parameter for the method.
4. @RequestBody:
   This annotation is used to get the request body from API convert to a given model or POJO specified and store the value.
   This is used as a parameter for the method.
5. @PathVaribale:
   This annotation is used to get any value from the path specified in the URL.
   This is also used as a parameter for the method.
6. @QueryParam:
   This annotation is used to get any query parameters provided in the URL.
   This is also used as a parameter.

@Controller
public class DemoController {
    @RequestMapping(value = "/student/{studentId}", method = RequestMethod.GET)
    public Student printStudent(
            @RequestHeader String authorization,
            @RequestBody Student student,
            @PathVariable String studentId
    ) {
        return student;
    }
}

Attaching the student project which contains the CRUD operations
1. creating a student.
2. updating a student based on Id.
3. get students based on Id.
4. delete student based on Id.
5. get all the students.

Project Link, will be updated.

Please do follow for more articles and learn with me.
you can connect with me here. linkedin

Monolithic Architecture:
In this type of architecture, complete code is maintained at only one server. All the different types of business logic are handled in one server. This can scale horizantally.

Advantages:
- we can scale horizontally.
- This is fast as there are no network calls involved.
- simple to scale horizontally.

Disadvantages:
- Small change also need to deploy all the code to reflect the change.
- A lot of testing is required as all the code is impacted even if small changes.
- If service is down everything is down.
- Handling code will be difficult as it is in one repository.
- limitation of size and complexity.
- Too hard to understand complete application.
- If any new technology adoption to new technology is difficult.

Microservice Architecture:
In this type of architecture, code is broken down into smaller services where each service will handle the logic individually and are inter connected. We need to use some service discovery mechanism to route the calls to individual services. service discoveries can be (eureka,API gateway etc.). The API Gateway is responsible for tasks such as load balancing, caching, access control, API metering, and monitoring.

Database in this type of architecture can be single also where all the serives talk to single DB.

Advantages:
- Handling code will be easy.
- Faster deployment.
- No need to know about complete application, knowing about one service also we can work on it.
- Adapting to new technologies can be very easy.
- Different services can be in different programming languages.
- Cost effective sometimes. (We can scale only required service when there are any sales in Amazon they will scale the login services and payment services rest need not be scaled.)
- Small changes can be done easily.
- No need to test the entire application, only changes in particular services can be tested.

Disadvantages:
- Even if one service is down, the rest services will be running.
- Network calls are involved so there will be little latency involved while making any inter-service communication.

In summary choosing what type of architecture to use depends on many factors. Size of your team, how complex is your project, and many more.
It is important to understand monolithic architecture because internally in microservice architecture we will be using it. The Microservices architecture pattern is the better choice for complex, evolving applications.

Please do follow for more articles and learn with me.
you can connect with me here. linkedin

Introduction:

Project development involves a lot of steps that need to be done manually like downloading dependencies, adding paths to external dependencies organizing the files in proper directories, and a lot more.
Humans will make errors while doing these manual tasks.

What if we have some tool that will do all of these manual steps for us based on the commands? That tool is known as MAVEN.
Maven is a project management tool that manages all the manual steps for project development.

Maven uses POM (Project Object Model) to know about the complete details of the project like managing dependencies, adding plugins, and building the software.

Installing Maven:

1. Download the zip file from Maven's official site https://maven.apache.org/download.cgi and extract.
2. Create a maven path environment variable.
3. Create a JAVA_HOME path environment variable this is Java JDK.
4. Verify whether maven is installed with maven commands
   mvn -version

Apache Maven 3.6.3
Maven home: /usr/share/maven
Java version: 11.0.18, vendor: Ubuntu, runtime: /usr/lib/jvm/java-11-openjdk-amd64
Default locale: en_IN, platform encoding: UTF-8
OS name: "linux", version: "5.15.0-69-generic", arch: "amd64", family: "unix"

you need to get like this which contains details about Maven.

Creating Maven Project:

creating a maven project can be done 2 ways
1. using CLI (Command Line interface).
2. using any IDE(IntelliJ, Eclipse, Netbeans etc)

1. Using CLI:
   Go to the terminal and execute the below commands

mvn archetype:generate

This will show all the different archetype projects available in a central repository we can select one and proceed. 2038 for the standalone project.
select and proceed.
select version number
GroupId — a unique base name of the company or group that created the project.
ArtificatId — a unique name of the project.
Version — version of the project.
Package — package name for the project.
Provide all the above information and confirm. A project with a given artifact name will be created in the working directory.
(or) we can use the below command to create.

mvn archetype:generate -DgroupId=Hemasai -DartifactId=MavenTest -
DarchetypeArtifactId=maven-archetype-quickstart
-Dpackage=com.hemasai -Dversion=1.0 -DinteractiveMode=false

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
    <groupId>Hemasai</groupId>
    <artifactId>MavenTest</artifactId>
    <packaging>jar</packaging>
    <version>1.0</version>
  <name>MavenTest</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

2. using any IDE:
Go to any IDE and create a new project as a maven project.
Here also we need to give all the details GAV [GroupId, ArtificatId, Version].
Once the project gets created we can see the same pom.xml file as we have seen in the above part.

Maven Build LifeCycle and Phases:

Maven has 3 life cycles. Each life cycle contains number of phases
1. clean (3 phases)
2. default (23 phases)
3. site (4 phases).
We will be seeing the most important maven life cycle phases.

• validate — checks the correctness of the project
• compile — compiles the provided source code into binary artifacts
• test — run the unit tests
• package — packages compiled code into a (jar, war, ear) file
• integration-test — executes additional tests, which require the packaging
• verify — checks if the package is valid
• install — installs the package file into the local Maven repository
• deploy — deploys the package file to a remote server or repository.

Advantages:

1. Can download jars automatically.
2. Dependency management.
3. Provides standard project directory structure.
4. Support Maven inheritance to share jar files and plugins among multiple projects.
5. Allows to develop multi-module projects
6. Build automation
7. can generate project documentation and run tests.
8. can clean and install the projects on local servers and remote servers.

References:
https://maven.apache.org/guides/getting-started/
https://maven.apache.org/guides/introduction/introduction-to-the-pom.html
https://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html

Please do follow for more articles and learn with me.
Feel free to connect with me on LinkedIn.

We can read the properties in 2 ways in SpringBoot:
1. @Value
2. @ConfigurationProperties.

@Value:

This will perform the field-level injection. We can use it to inject each value into spring bean properties. This will inject only one value at a time.

By default, in Spring Boot all the properties are picked from the application.properties file in src/main/java/resources.

As application.properties is default file we no need to provide any path to read properties from any file

@Component
public class Employee {

    @Value("${com.hemasai.name}")  // getting name from application.properties
    private String name;

    @Value("${com.hemasai.email}") // getting email from application.properties
    private String email;

  ......
}

application.properties

com.hemasai.name = "hemasai"
com.hemasai.email ="testxml@gmail.com"

In the above application.properties file, we have given name and email and in the employee class, we inject these values using @Value.

But now, if we want to read files from another file, we need to import that file and use the same @Value annotation. The file should also be present in the resources folder.

input.properties

name = "Hemasai"
email = "Testemail@gmail.com"

@Component
@PropertySource(value = "input.properties")  //reading from the mentioned file
public class Employee {
    @Value("${name}")
    private String name;
    @Value("${email}")
    private String email;

  ....
}

@PropertySource will import the given file into the respective bean, then we will be using the same @Value to get the property.

@ConfigurationProperties:

When we don’t need to use @Value annotation, then we can use this annotation on the class level and get the properties.
This will make use of setter methods to set the values.

application.properties

com.hemasai.name = "hemasai"
com.hemasai.email ="test@gmail.com"

@Component
@ConfigurationProperties(value = "com.hemasai")
public class Employee {

    private String name;  // getting com.hemasai.name from propeties file
    private String email; // getting com.hemasai.email from properties file
    ..
}

As we see in the above code we are using the @ConfigurationProperties on the Employee class, this annotation will have some prefix default empty and add the variable name to the prefix and search with that key in the application.properties file.

In the above case com.hemasai is a prefix and the name is added to the prefix and com.hemasai.name is searched in the application.properties.

The properties can be read from the YAML file also.
Need to create on YAML file with required values and place in resources folder.

Differences between Value and ConfigurationProperties:

Value:
1. This can be used in both the spring framework and Spring Boot.
2. Single value injection.
3. Common prefixes are not required for all keys.
4. Keys in the properties file and property name need not match.
5. If some key is not found this will throw an error.
6. we can’t read properties using a YAML file.

ConfigurationProperties:
1. This can be used only in Spring Boot.
2. Bulk values are injected at once.
3. Common prefix is required for all the properties.
4. Key in the properties file and property name should match.
5. If some key is not found this will not inject anything and not throw an error.
6. we can read properties using the YAML file also.

Please do follow for more articles and learn with me.
Special Thanks to Nitin M who made these concepts very easy.

Spring:

1. Spring is a framework for JEE technologies/ Application framework.
2. Dependency injection and Dependency lookup is the main feature in spring.
3. Spring supports XML-driven configuration as an input to the spring IOC container.
4. We(users) need to create an IOC container explicitly.
5. Allows developing spring apps using XML-based, Annotation based, and pure Java based.
6. Doesn't provide an embedded server to use in Web apps.
7. Doesn’t provide an embedded inMemory Database.
8. Lightweight because of no configuration.
9. No support for microservice architecture-based application development.
10. Spring requires developers to write more code for setting up the application, configuring dependencies, and managing infrastructure.

Spring Boot:

1. Spring Boot provides an abstraction for the spring framework and simplifies spring application development.
2. AutoConfiguration (providing common things automatically) is the main feature in spring boot.
3. Doesn’t support XML-based configuration as an input to the spring IOC container.
4. we(users) need not create an IOC container explicitly, it gets created automatically using SpringApplication.run().
5. Supports only one style of configuration which is AutoConfiguration where inputs are supplied through the application.properties.
6. provides an embedded server tomcat, and Jetty to use web applications.
7. provides an embedded inMemory database (H2).
8. Heavyweight because of AutoConfiguration.
9. support microservice architecture-based application development.
10. Spring Boot, provides a lot of pre-configured settings that developers can use to get started quickly and reduce boilerplate code.

In simple words
spring framework + embededservers — Configuration = SpringBoot

Please do follow for more articles and learn with me.
Special Thanks to Nitin M who made these all concepts very easy.

To perform dependency injection, we must provide configuration metadata to the spring IOC container.
There are 4 different ways of configuring metadata
1. XML-based approach.
2. Annotation-driven configuration.
3. Using Java code configuration.
4. Spring boot AutoDriven configuration.

We have already seen the 3 ways of configuring metadata to spring application in the earlier posts. Now we will see the Spring Boot auto-driven Configuration.
Spring Boot provides a feature called “auto-configuration” that helps developers avoid the need for boilerplate code when setting up a Spring application. Auto-configuration is a mechanism that automatically configures certain Spring components based on the dependencies that are present on the classpath.

Why SpringBoot?:
1. Build the applications rapidly.
2. No XML configuration.
3. Provide a range of non-functional features that are common to large classes of projects

Developing Your First Spring Boot Application:

spring provides UI to generate the spring boot application spring.start.io.
we can generate the spring application by providing the required information.

Once we go to the above site we will get the options mentioned in the above image.

Project:
This indicates the build system of the project.

Language:
This indicates in which language we need the spring application.

Spring Boot:
This indicates the sprint boot version to use, always go for the release version don't go for SNAPSHOT/ M2

Project Metadata:
This section needs the project information we need to create. Basic project information like what is the group, artifact, project name and description, and packaging mode.

Dependencies:
If we want any dependencies we can add them here for standalone projects we will not have any dependencies.
For web applications, we can have dependencies like Spring MVC, and Spring Data JPA that we can select from here.

Once we provide all the information Click on Generate and one project will be downloaded and we can import that project using any of the IDE which has build system support.

We will have the project structure as shown in the above image. We will have the pom.xml file which contains information about the project and what dependencies this project needs etc.,

We will be having the main method in the spring application. This is a standard method that follows the Java convention for an application entry point. Our main method delegates to Spring Boot’s Spring Application class by calling run.

The main code will be in the TestApplication.java file

@SpringBootApplication
public class TestAppApplication {

 public static void main(String[] args) {
  SpringApplication.run(TestAppApplication.class, args);
 }

}

@SpringBootApplication:
This annotation is the main part of the Spring boot application this refers 3 annotations
1. @EnableAutoConfiguration: It enables auto-configuration.
2. @ComponentScan: This annotation scans for the stereotype annotations in the package and subpackage.
3. @SpringBootConfiguration: This is to make the current class a configuration class.

SpringApplication.run(TestAppApplication.class, args);

The above line will create the container for the spring application and make the container ready to get the beans.

SpringApplication.run() will internally use the AnnotationConfigApplicationContext to create an IOC container using the java class as @Configuration. In fact the same class will act like a configuration class (TestAppApplication.java).

@SpringBootApplication
public class TestAppApplication {

 public static void main(String[] args) {

  ConfigurableApplicationContext context
    = SpringApplication.run(TestAppApplication.class, args);

  context.getBean(Courier.class);
  context.close();
 }

}

We can get the beans using the same process as we are doing in other types of configuring the IOC container.

Advantages of Spring Boot:
1. No Xml file is involved in configuring the container.
2. Developing the application is too fast.
3. Readability and maintainability are easy.
4. Auto Configuration.
5. No need to create an IOC container explicitly.

Please do follow for more articles and learn with me.
Special Thanks to Nitin M who made these all concepts very easy.

To perform dependency injection, we must provide configuration metadata to the spring IOC container.
There are 4 different ways of configuring metadata
1. XML-based approach.
2. Annotation-driven configuration.
3. Using Java code configuration.
4. Spring boot AutoDriven configuration.

Out of these, we have already seen XML-based approach and Annotation-driven configuration, now we will see the Java code configuration.
In the XML-based and Annotation-driven configurations, we have used two containers Bean Factory and Application Context to get the beans.
Now to work on Java-based configuration Bean factory won’t work we should only work on Application Context.

Application Context Container:
1. This is an extension of the bean factory.
2. Implementation classes of ApplicationContext(I) are below:
a. FileSystemXmlApplicationContext(standalone)
b. ClassPathXmlApplicationContext(standalone)
c. XmlWebApplicationContext(SpringMVC apps)
d. AnnotationConfigApplicationContext(Standaloneapp’s)
e. AnnotationConfigWebApplicationContext(SpringMVC apps)

We will use AnnotationConfigApplicationContext and AnnotationConfigWebApplicationContext based on the requirement when we are working using Java-based configuration.

In a pure Java-based configuration Spring application, the application context is configured entirely using Java code, rather than XML configuration files. This approach provides a more flexible and type-safe way to configure the application context and can make it easier to maintain and refactor the application.

Steps / Rules to build Java-based projects easily:
1. Annotate all the user-defined classes using stereotype annotations(@Component, @Service, @Repository) so the spring container can manage beans. (or)
we can also use the @Bean annotation in the configuration class to generate beans of the required class.

2. Add one configuration class and annotate with @Configuration and we can use @ComponentScan to scan all the beans in the provided base package.

Note :- Configuration internally creates a component so the container can access this class and this class will become the configuration class for the application.

@Configuration
@ComponentScan(basePackages = "src")
public class AppConfig {

.....//If any pre defined class need to provide beans information here.
}

3. Configure the pre-defined classes using @Bean in the configuration class which is mentioned above.
4. Inject all the dependencies using the @Autowired annotation which we have seen in the earlier posts.
5. use AnnotationConfigApplicationContext class to create an IOC container having @Configuration class as the input class name

public class TestApp {
    public static void main(String[] args) {

        ApplicationContext applicationContext = 
                new AnnotationConfigApplicationContext(AppConfig.class);

        applicationContext.getBean(...); // to get the bean of particular class 
                              //provide the class name as the parameter.

        ((AbstractApplicationContext)applicationContext).close();
    }
}

Done application is ready and we can work with whatever beans we want and perform the business logic.

Advantages of Java-based configuration:
1. XML-based configuration can be avoided.
2. Improves readability.
3. Debugging becomes easy.
4. Foundation for spring boot.

Please do follow for more articles and learn with me.
Special Thanks to Nitin M who made these all concepts very easy.

As we already know there are 4 ways to configure the metadata (bean information) to the spring container.
1. XML file based
2. Annotations based
3. Pure Java code base
4. Spring Boot Auto Driven

Now we will see the Annotation based configuration and a few of the annotations. We may be using the annotations but how can the spring container come to know and deal with the annotations for that we need to inform the spring container through XML file adding <context:annotation-config/>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>

</beans>

<context:annotation-config/> This will check for the required beans which are defined.

@Required:
When we are working on constructor injection if any parameter is missing we will get an exception but for setter injection, we will not get any exception.
To provide this functionality we can use the @Required annotation on setters.

@Autowired:
As we have already seen what is Auto wiring earlier, we know we can do it in three ways bytype, byName, and constructor.
This Autowired also does the same byType, byName, and constructor mode of auto wiring.
By Default auto wiring on byType.

AutoWire using ByName:
If more than one bean of the same type is found then we will get an exception. There are 3 classes that are implementing courier class.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

 <context:annotation-config/>

<!-- Dependent bean -->
<bean id="amazon" class="src.courier.Amazon"/>
<bean id="dtdc" class="src.courier.Dtdc"/>
<bean id="bluedart" class="src.courier.BlueDart"/>

<!-- target bean -->
<bean id="flip" class="src.services.Flipkart"/>

public class Flipkart {

    @Autowired
    private Courier courier;

..................,,,
}

In the above code as we have 3 beans of courier type so we will get an exception. We can rectify the above using primary in XML file or we can use @Qualifer on top of the courier instance.

    <bean id="amazon" class="src.courier.Amazon"/>
    <bean id="dtdc" class="src.courier.Dtdc"/>
    <bean id="bluedart" class="src.courier.BlueDart" primary="true"/>

public class Flipkart {

    @Autowired
    @Qualifier("bluedart")
    private Courier courier;

  ..............,,,
}

If we use both the @Qualifier and primary = “true”, Qualifier if given high preference.

AutoWire using ByName:

<!-- Dependent bean -->
<bean id="amazon" class="src.courier.Amazon"/>
<bean id="dtdc" class="src.courier.Dtdc"/>
<bean id="courier" class="src.courier.BlueDart"/>

<!-- target bean -->
<bean id="flip" class="src.services.Flipkart"/>

public class Flipkart {

    @Autowired
    private Courier courier;

..................,,,
}

As we are having only one bean with the courier as name auto wiring will happen using By Name.

AutoWire using Constructor:
We will be using Autowired annotation at the constructor level and if multiple beans we will use the Qualifier

public class Flipkart {
    private Courier courier;
    
        @Autowired
    public Flipkart(@Qualifier("bluedart") Courier courier) {
        this.courier = courier;
    }
}

Setter Injection using Autowired:

public class Flipkart {

    private Courier courier;
    
    @Autowired
    public void setCourier(@Qualifier("bluedart") Courier courier) {
        this.courier = courier;
    }
}

@PostConstruct:
We can write our own custom init methods and annotate with PostConstruct then the spring container will execute that first and then it process to the business logic.

@PreDestroy:
We can also write the same destroy method to clear all the data before the container leaves the particular class and annotate with the PreDestroy.

Stereotype Annotations:

In Spring Framework, stereotype annotations are used to indicate the roles of specific classes in the application. Stereotype annotations are a type of metadata that provide hints to Spring about how to handle certain classes, and they can be used to simplify the configuration and management of Spring components.
Spring can automatically detect stereotyped classes and register bean definitions with the ApplicationContext.
To auto-detect these classes and register the beans we need to provide the below XML file in which we provide a base package to scan for these stereotyped classes. <context:component-scan base-package=”org.example”/>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="org.example"/>

</beans>

We have the following annotations in spring:
1. Component
2. Controller
3. Service
4. Repository

1. Component:
   This annotation is used to mark a class as a Spring component, which means it will be scanned and registered with the Spring container as a bean. This annotation can be used with any class, but it is typically used with domain objects, utility classes, and other non-specific classes.
2. Controller:
   Component +
   This annotation is used to mark a class as a Spring MVC controller, which means it will be scanned and registered with the Spring container as a bean. This annotation is typically used with classes that handle HTTP requests and responses.
3. Service:
   Component +
   This annotation is used to mark a class as a Spring service, which means it will be scanned and registered with the Spring container as a bean. This annotation is typically used with classes that perform business logic and data access operations.
4. Repository:
   Component +
   This annotation is used to mark a class as a Spring repository, which means it will be scanned and registered with the Spring container as a bean. This annotation is typically used with classes that perform data access operations, such as querying a database.

Advantages:
- code readability and maintainability will be good.
- save a lot of time adding all the configuration.
- we can mention the clear role of a particular class.

We will be seeing more annotations in the coming posts.

Please do follow for more articles and learn with me.
Special Thanks to Nitin M who made these all concepts very easy.

Injecting dependent beans into the target beans is called Dependency Injection/ Auto wiring.
Spring can auto resolve the dependencies using the configuration provided to the spring container.
Spring will reduce the need for constructor arguments when we use auto wiring in the configuration using XML based.
Auto Wiring can be done in 2 ways:
1. Explicit Auto wiring / Manual Injection
a. <property name = “ “ ref = “ “ />
b. <constructor-arg name = “ “ ref = “ “ />
We have already seen this type of injection setter and constructor injection in the Dependency Injection part.

2. Auto wiring / Auto Injection
In this type auto wiring can be done in 3 ways:
1. byName
2. byType
3. constructor

Limitations:
1. This is only possible in Object type/ reference type beans
2. There is a possibility of ambiguity.
3. Readability of the spring bean configuration file will need improvement.

1.byName:
This type of auto wiring follows setter injection.
The container finds a dependent spring bean class/ object based on the id that is matching with the target class.
There is no possibility of an ambiguity problem because the bean ids in the IOC container are unique.

    <bean id="courier" class="src.courier.Amazon"/>
<!--    courier is the type of the Object what we used in the Flipkart object-->
    <bean id="dtdc" class="src.courier.Dtdc"/>
    <bean id="bluedart" class="src.courier.BlueDart"/>

    <bean id="flip" class="src.services.Flipkart" autowire="byName"/>

In the above XML file, we have 3 beans that are implementing courier type interface. so if it is by Name container will look for the courier type of object with the same name(courier) while injecting that in the Flipkart service.

2. byType
This type of auto wiring also follows setter injection.
There will be a possibility of ambiguity problem because in the container there can be different beans of the same type.
We can resolve the ambiguity problem using “primary = true”.

    <bean id="amazon" class="src.courier.Amazon"/>
    <bean id="dtdc" class="src.courier.Dtdc" primary="true"/>
    <bean id="bluedart" class="src.courier.BlueDart"/>

    <bean id="flip" class="src.services.Flipkart" autowire="byType"/>

In the above configuration file if we have auto wire using byType which looks for the type of courier object we have 3 classes that are implementing the courier interface and we have 3 beans where we get an ambiguity problem. we get rid of this using “primary = true” for one of the beans.

3. constructor
This type of auto wiring follows constructor injection.
There will be no possibility of ambiguity as we have only one bean with a name.
In this type, the constructor param name should match the dependent class bean id for the auto wiring to happen.

    <bean id="amazon" class="src.courier.Amazon"/>
    <bean id="dtdc" class="src.courier.Dtdc"/>
    <bean id="courier" class="src.courier.BlueDart"/>
<!--    courier is the constructor name what we used in the Flipakrt object creation-->

    <bean id="flip" class="src.services.Flipkart" autowire="constructor"/>

In the above configuration file, we have 3 beans of courier type and auto wire is using the constructor. we make one bean of courier type so that when we are using the constructor injection it picks the courier bean.

Scope attribute in Spring bean:
We can define the bean scope when the container creates the bean. This is powerful and flexible because we can choose the scope of objects we create instead of having the scope of the object at the java class level.
Spring framework supports 5 types of scopes
1. singleton(default)
2. prototype
3. request
4. session
5. global session

out of which 3 are available only if we use web-aware Application Context.
We will be seeing the other two types here:

1. Singleton:
This is the default scope for any bean in the spring.
IOC container will never make the spring class a singleton java class, but it creates only one object stores this object in the internal cache and returns the object whenever the bean is used.

    <!--    Configuring dependent bean-->
    <bean id="student" class="src.model.Student" scope="singleton"/>

    <!--    configuration target bean-->
    <bean id="university" class="src.University">
        <constructor-arg ref="student"/>

2. Prototype:
IOC container will create a new object for the spring bean class for every getBean().
The container does not keep the scope of spring bean in the cache.

    <!--    Configuring dependent bean-->
    <bean id="student" class="src.model.Student" scope="prototype"/>

    <!--    configuration target bean-->
    <bean id="university" class="src.University">
        <constructor-arg ref="student"/>

Please do follow for more articles and learn with me.
Special Thanks to Nitin M who made these all concepts very easy.

As we all know Spring framework/Spring Boot is the most popular web development framework. In spring all the objects are treated as Beans.

Bean is an object that is instantiated, assembled, and managed by the spring IOC container. A simple java object which is created, configured, and managed by the spring container is called a bean.
Spring can manage one or more beans. Beans are configured using metadata provided to the spring container.
There are 4 different ways of configuring metadata
1. XML-based approach.
2. Annotation-driven configuration.
3. Using java code configuration.
4. Spring boot AutoDriven configuration.
We have already seen this configuration in this post. configuration article

I am taking an example of XML-based configuration as below:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--    Configuring dependent bean-->
    <bean id="student" class="src.model.Student"/>
    <bean id="course" class="src.model.Course"/>

    <!--    configuration target bean-->
    <bean id="university" class="src.University">
        <constructor-arg ref="student"/>
        <constructor-arg ref="course"/>
    </bean>

</beans>

Spring Bean will have the following metadata so that the configuration, instantiation, and management of beans are identified by spring container:
1. id/name
2. class
3. constructor-arguments
4. properties
5. scope
6. auto wiring
7. lazy-initialization mode
8. initialization method
9. destruction method

1. Name:
In Spring bean can be identified by some name so that it performs dependency injection or creation of objects. If you have not provided any id or name spring automatically creates one unique name to identify the bean.
If you want to provide a name you can give it with an id or name attribute in the bean tag. you can give multiple names also with alias attribute.

<bean id="student" alias="studentObject" />

or

<bean name="student" alias="studentObject" />

2. Class:
Spring while creating a bean it looks for the type of bean it should create for a particular bean Id, then it checks its configuration file for the type or class of object that it is to be created.

<!--    Configuring dependent bean-->
    <bean id="student" class="src.model.Student"/>
    <bean id="course" class="src.model.Course"/>

In the above XML file we are mentioning bean named with the student should be of src.mode.Student class.

3. Constructor arguments
We have seen this in Dependency Injection where we will use constructor injection to inject the dependencies into the target object.
In this we provide a tag <constructor-arg ref=” “/>

<!--    configuration target bean-->
    <bean id="university" class="src.University">
        <constructor-arg ref="student"/>
        <constructor-arg ref="course"/>
    </bean>

In the above code, the University bean is dependent on the student bean and course bean where they are injected using constructor injection using the <constructor-arg ref=” “/> tag

4. Properties:
We have seen the same in the Dependency injection part where the dependent objects are injected into the target object using <property /> tag.

    <!--    configuration target bean-->
    <bean id="university" class="src.University">
        <property name="student" ref="studentBean"/>
        <property name="course" ref="courseBean"/>
    </bean>

In the above code, the university object is dependent on the student and course and we are using setter injection to inject the dependent beans.

5. Scope:
Spring will be able to inject a particular type of object to particular target objects based on the scope of objects created for a particular type. We can configure the bean scope using the configuration metadata instead of the default java class level scope.
Spring supports 5 different types of scopes:
1. Singleton (Default)
2. Prototype
3. Request
4. Session
5. Global Session

6. Auto Wiring:
Spring can auto resolve the dependencies using the configuration provided to the spring container.
Spring will reduce the need of constructor arguments when we use auto wiring in the configuration using XML based.
The auto wiring functionality has 4 modes:
1. No (Default)
2. byName
3. byType
4. constructor

Note :- We will see Autowiring and Scopes in detail in next articles.

7. lazy-initialization mode
There is a requirement where we don’t want all the beans to be instantiated but when we require that specific bean spring container should provide that. we can achieve this using lazy-init=”true” attribute.
Lazy-initialized beans are beans in a Spring context that are not instantiated immediately when the context is created but are instead instantiated when they are first requested.

<!--    Configuring dependent bean-->
    <bean id="student" class="src.model.Student" lazy-init="true"/>
    <bean id="course" class="src.model.Course"/>

In the above code, the student object will not be created at the startup but when we try to create an object which is dependent on this, Spring will create a bean for this student object.

8. initialization method
9. destruction method
we will see this in the upcoming articles when we see the lifecycle of a bean.

Please do follow for more articles and learn with me.
Special Thanks to Nitin M who made these all concepts very easy.