===========

Framework
===========

=> Semi Developed software which provides common logics required for projects
development

=> Frameworks will help the developers to implement more functionality in less time

=> When we use framework to develop the project, we can focus only on business
logic.

==================
Types of Frameworks
==================

1) Frontend Frameworks : To develop user interface in the project.

Ex: Angular

2) Web Frameworks : To develop web layer in the project

Ex: Struts (Outdated)

3) ORM Frameworks : To develop persistence layer in the project.

Ex: Hibernate

=> By using Struts we can develop only Web Layer in the Project ( Controllers )

=> By using Hibernate we can develop only Data Access Layer (Persistence Layer)

Note: To overcome the problems of Struts framework, Spring Framework came into
market.

=> Spring Framework is called as Application Development Framework

=> By using Spring framework we can develop end to end application

=> Spring is free & open source framework

=> Spring Framework developed in Modular Fashion

Note: Spring framework means collection of modules

==============
Spring Modules
==============

1) Spring Core
2) Spring Context
3) Spring JDBC
4) Spring ORM
5) Spring AOP
6) Spring Web MVC
7) Spring Security
8) Spring Social
9) Spring Batch
10) Spring Data JPA
11) Spring REST
12) Spring Cloud

Note: Spring is very flexible framework. It will not force to use all modules.
Based on requirement we can pickup particular module and we can use it.

=> Spring is versatile framework ( Easily it can be integrated with other

frameworks )

=> The current version of Spring framework is 6.0

=> Spring framework is under license of VM Ware Tanza...

URL : www.spring.io

===================================================================================
============

1) Spring Core : It is base module in the spring framework.

=> Spring Core Module providing fundamental concepts of Spring Framework

1) IOC Container ( Inversion Of Control )

2) Dependency Injection

3) Bean Life cycle

4) Bean Scopes

5) Autowiring etc...

2) Spring Context : It will deal with configurations required for our Spring
Applications.

3) Spring AOP : Aspect Oriented Programming

=> AOP is used to seperate business logics & Secondary logics in the project

Ex: Security, Logging, Tx, Auditing, Exception Handling...

Note: If we combine business logics & secondary logics then we will face maintence
issues of our project.

4) Spring JDBC : Spring JDBC is used to simplify Database Communication logic

=> In java jdbc we need to write boiler plate code (repeated code) like below
in several classes

=> Load driver

=> Get connection
=> Create Statement
=> Execute Query
=> Close connection
 => Using Spring JDBC we can directley execute query the remaining part Spring
JDBC will take care

5) Spring Web MVC : It is used to develop both Web Applications & Distributed
Applications

=> Web Applications ( C 2 B )

Ex: Gmail.com, facebook.com etc...

=> Distributed Applications ( B 2 B ) / Web Services or RESTFul

Service

Ex:

IRCTC ---- MakeMyTrip

Passport --- AADHAR app

6) Spring ORM (Object Relational Mapping)

=> Spring Framework having integration with ORM frameworks

Ex: Spring ORM , Spring Data JPA etc....

Note: JDBC will represent data in text format where as Hibernate ORM will represent
data in Objects format.

7) Spring Security

=> Security is very crucial for every application

=> Using Spring Security We can implement Authentication &

Authorization

=> Spring Security with OAuth2.0

=> Spring Security with JWT (JSON Web Tokens)

8) Spring Batch : Batch means bulk operation

=> Reading data from Excel and store it into database table

=> Sending Monthly statements to customers in email

=> Sending Reminders to customers as Bulk SMS

9) Spring Cloud : It provides some common tools to quickly build distributed

systems.

=> It provides service registry to register all our microservices at

one place
 => It provides API Gateway to have single entry point for all our apis

=> Load Balancer

=> Monitoring

=> Circutit Breaker ( Fault Tolerant Systems / Resillence )

=> Distributed Messaging

=> Routing

10) Spring Test : It provides Unit Test framework

===================================================================================
============

=============================================================================
Spring Core : It is all about Managing dependencies among the classes with loosely
coupling
=============================================================================

=> In project we will develop several classes. All those classes we can categorize
into 3 types

1) POJO

2) Java Bean

3) Component

================================
What is Pojo ( Plain Old Java Object )
===============================

=> Any Java class which can be compiled by using only JDK software is called as
POJO class.

Ex-1 : Below class is valid POJO

class Demo1 {

int id;
String name;
}

Ex-2 : Below class is valid POJO

class Demo2 extends Thread {

int id;
String name;
}

Ex-3 : Below class is valid POJO

class Demo3 implements Runnable {

 // run method
}

Ex-4 : Below class is not POJO because Servlet is part of JEE

class Demo4 implements Servlet {

// run method
}

===================
What is Java Bean ?
===================

=> Any java class which follows bean specification rules is called as Java Bean.

1) Class should implement serializable interface

2) Class should have private data members (variables)

3) Every private variable should have public setter & public getter method

4) Class should have zero-param constructor

Note : Bean classes are used to write business logic and to store and retrieve data

===================
What is Component ?
===================

=> The java classes which contains business logic is called as Component classes

Ex: Controllers, Services , Dao classes

=> Controller classes will have logic to deal with Request & Response

=> Service classes will have business logic of our project

Ex: Generate OTP, Send OTP, Send Email, Encrypt & Decrypt PWD
etc...

=> DAO classes will contain the logic to communicate with Database

===================================================================================
============

=> In a project we will develop multiple classes and those classes will be
dependent on other classes.

Ex:

=> Controller class will call service class methods

=> Service class will call Dao class methods

=> In Java one class can talk to another class in 2 ways

1) Inheritence ( IS - A )

2) Composition ( HAS - A )

=====================
Car & Engine Example
=====================

class Engine {

void start ( ) {
// logic
}

class Car {

void drive( ) {
// star the engine
// drive the car
}
}

=> If we want to drive the car then we need to start the Engine that means Car
class drive ( ) method should call Engine class start ( ) method.

Q) In how many ways Car class can call Engine class method ?

=> in 2 ways

1) Inheritence

2) Composition

============================= IS-A approach ========================

package in.ashokit;

public class Engine {

public int start ( ) {

// logic
return 1;
}
}

package in.ashokit;

public class Car extends Engine {

public void drive() {

// start the engine

 int start = super.start();

if (start >= 1) {
System.out.println("Journey Started");
}

// start the journey

}
}
========================== HAS - A Relation ===============================

public class Car {

public void drive() {

Engine eng = new Engine ( );

int start = eng.start();

if (start >= 1) {
System.out.println("Journey Started");
}

// start the journey

}
}

Note: Tomorrow, if Engine class constructor modified then our Car class will be
effected.

===================================================================================
==============

Note: If we use any approach from above then Car class will become tightley coupled
with Engine class. That is not recommended.

##################### Always we need to develop our classes with Loosely Coupling

######################

=> Loosely coupling means without creating Object and without Inheriting properties
we should be able to access one class method in another class.

=> If we make any changes in Engine class then Car class shouldn't be effected then
we can say our classes are loosely coupled.

######################## To develop classes with loosely coupling we need to use

Interfaces ############

package in.ashokit;

public class Car {

private IEngine eng;

 public Car(IEngine eng) {
this.eng = eng;
}

public void drive() {

int start = eng.start();

if (start >= 1) {
System.out.println("Journey Started...");
} else {
System.out.println("Engine in trouble...");
}
}
}
---------------------------------------------------------------
package in.ashokit;

public class Main {

public static void main(String[] args) {

Car car = new Car (new PetrolEngine());

car.drive();
}
}

---------------------------------------------------------------------------

===========================
What is Dependency Injection ?
============================

=> The process of injecting one class object into another class is called as
'Dependency Injection'.

=> We can perform Dependency Injection in 3 ways

1) Setter Injection

2) Constructor Injection

3) Field Injection

-------------------------------- Example to Understand Dependency Injection

--------------------------------
public class Car {

private IEngine eng ;

public void setEng(IEngine eng) {

this.eng = eng;
}

public void drive() {

int start = eng.start();

if (start >= 1) {
 System.out.println("Journey Started...");
} else {
System.out.println("Engine in trouble...");
}
}
}
------------------------------------------------------------------------------

=> In the above program 'Car' class is dependent on 'Engine' object that means
'Engine' class object should be injected into 'Car' class.

Note: Car is dependent on Engine

==============================
Setter Injection (SI)
=============================

=> Setter Injection means, Injecting dependent object into target object using
target class setter method.

public class Car {

private IEngine eng;

public void setEng(IEngine eng) {

this.eng = eng;
}

public void drive() {

int start = eng.start();
// logic
}
}

public class Main {

public static void main(String[] args) {

// creating target obj

Car car = new Car();

// injecting dependent obj into target thru setter method (Setter

Injection - SI)
car.setEng(new PetrolEngine());

car.drive();
}
}

=========================
Constructor Injection ( CI )
========================

=> Constructor Injection means, Injecting dependent object into target object using
target class constructor.
public class Car {

private IEngine eng;

public Car (IEngine eng) {

this.eng = eng;
}

public void drive() {

int start = eng.start();
// logic
}
}

public class Main {

public static void main(String[] args) {

// creating target obj ( Constructor Injection )

Car car = new Car(new DieselEngine());

car.drive();
}
}

==============================================================

Q) Can we perform both SI & CI for single variable ?

Yes, but Setter Injection will override Constructor Injection value.

public class Main {

public static void main(String[] args) {

// creating target obj ( Constructor Injection - CI )

Car car = new Car(new DieselEngine());

// Setter Injection - SI
car.setEng(new PetrolEngine());

car.drive();
}
}

===================
Field Injection - FI
===================

=> Field Injection means, injecting depending object into target class using target
class variable is called as Field Injection.

public class Car {

 private IEngine eng;

public void drive() {

int start = eng.start();

if (start >= 1) {
System.out.println("Journey Started...");
} else {
System.out.println("Engine in trouble...");
}
}
}

###### Note: We can access private variables outside of the class using Reflection
API like below ######

public class Main {

public static void main(String[] args) throws Exception {

Class<?> clz = Class.forName("in.ashokit.Car");

Object object = clz.newInstance();

Car carObj = (Car) object;

Field engField = clz.getDeclaredField("eng");

engField.setAccessible(true);

// Injecting value to variable

engField.set(carObj, new PetrolEngine());

carObj.drive();
}
}

================
IOC Container
================

-> IoC stands for Inversion Of Control.

-> IoC is responsible for Dependency Injection in Spring Applications.

-> Dependency Injection means creating and injecting dependent bean objects into
target bean classes.

Note: IoC container will manage life cycle of Spring Beans.

Note : We need to provide " Java classes + Bean Configuration " as input for IOC
then IOC will perform DI and provides Spring Beans which are ready to use.

===================
What is Spring Bean ?
===================

-> Any Java class whose lifecycle (creation to destruction) is managed by IOC is
called as Spring Bean.

-> We can represent Java class as Spring Bean in 2 ways

1) XML Approach

Ex: <bean id ="id1" class = "pkg.ClassName" />

2) Annotation Approach (Recommended)

Ex: @Component, @Service, @Repository etc....

Note: In Spring we can use both XML & Annotation approaches. SpringBoot will
support only Annotations (no xmls)

=======================
How to Start IoC in Spring ?
=======================

1) BeanFactory (Outdated)

2) ApplicationContext (recommended)

Ex: ApplicationContext context = new

ClassPathXmlApplicationContext(String configFile);

Note: Bean Configuration file contains Bean Definitions

(target class, dependent class, Dependency Injection type)

Note: When IoC container started it will read bean defintions from Bean
Configuration File
and it will perform Dependency Injection.

===============================================
First Application Development using Spring Core Module
===============================================

Pre-Requesites : JDK 1.8v, STS IDE

1) Create Maven Project in IDE

2) Add 'Spring Context' Dependency in pom.xml file (search here :

www.mvnrepository.com)

<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.22.RELEASE</version>
</dependency>
 </dependencies>

3) Create Required Java classes (Ex: IEngine, PetrolEngine, DieselEngine and Car )

4) Create Bean Configuration File and configure Bean Definitions

<?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
http://www.springframework.org/schema/beans/spring-beans.xsd">

<bean id="petrolEng" class="in.ashokit.beans.PetrolEngine" />

<bean id="car" class="in.ashokit.beans.Car">

<property name="eng" ref="petrolEng" />
</bean>

</beans>

Note: Here <property/> tag represents setter injection.

5) Create Main class and start IOC Container to test the application.

public class App {

public static void main(String[] args) {

// starting iOC container
ApplicationContext context = new
ClassPathXmlApplicationContext("Beans.xml");

// getting bean object from IOC

Car car = context.getBean(Car.class);
car.drive();
}
}

=================================================
Difference Between BeanFactory & ApplicationContext
=================================================

=> BeanFactory interface having - XmlBeanFactory as implementation class

BeanFactory factory = new XmlBeanFactory(new

ClassPathResource("Beans.xml"));

=> ApplicationContext interface having - ClassPathXmlApplicationcontext as

implementation class

ApplicationContext context = new

ClassPathXmlApplicationContext("Beans.xml");

=> BeanFactory will follow Lazy Loading concept that means when we request then
only it will create Bean object.

=> ApplicationContext will follow Eager Loading for Singleton Beans. For Prototype
beans it will also follow Lazy Loading
-----------------------------------------Note: Spring Bean default scope is
Singleton----------------------------------------------

Eager Loading means creating objects for Spring Bean when IoC starts

Lazy Loading means creating objects for Spring Bean when we call
getBean ( ) method.

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
---

Note: XmlBeanFactory is deprected that means it may not available in future

versions of Spring.

Note: It is recommended to create IoC using Application Context.

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------
--

public class Main {

public static void main(String[] args) {

System.out.println("===== BeanFactory Started =====");

BeanFactory factory = new XmlBeanFactory(new

ClassPathResource("Beans.xml"));

System.out.println("===== ApplicationContex Started =====");

ApplicationContext context = new

ClassPathXmlApplicationContext("Beans.xml");
Car bean = context.getBean(Car.class);
bean.drive();
}
}

-----------------------------------------------------------------------------------
-----------------------------------------------------------------------------------

==================================================================
How to differentiate Setter Injection & Construction Injection in Bean Config
File ?
==================================================================

=> <property /> tag represents setter injection

=> <constructor-arg /> tag represents constructor injection

<bean id="petrolEng" class="in.ashokit.beans.PetrolEngine" />

<bean id="dieselEng" class="in.ashokit.beans.DieselEngine" />

<bean id="car" class="in.ashokit.beans.Car">

<property name="eng" ref="dieselEng" />
<constructor-arg name="eng" ref="petrolEng" />
</bean>
Note: When we perform both SI & CI then SI will override CI value.

==============================================================

============
Bean Scopes
============

=> Scope represents how many objects should be created for a Spring Bean

=> In Spring framework we have below scopes

1) singleton ( default scope )

2) prototye

3) request

4) session

=> To represent bean scope we will use "scope" attribute

<bean id="id" class="pkg.classname" scope = "singleton | prototye |

request | session " />

-> Singleton scope means only one object will be created for the class in IOC
Container. This is default scope of spring bean.

-> Prototype scope means every time new object will be created.

Note: request & session scopes are related to Spring Web MVC Module.

===================================
Why Spring Bean is by default Singleton ?
===================================

=> To save memory of JVM spring team made singleton as default scope for the spring
beans.

Ex: Rest Controllers, Controllers, Services and DAOs will be considered as

Singleton in the project

Ex: TicketGenerator class is used to generate new Ticket for every customer

TicketGenerator ----> Singleton bean

Ticket -----> Prototye Bean

===========
Autowiring
===========

=> We can inject dependent bean into target in 2 ways

1) Manual Wiring

2) Autowiring

-> Manual wiring means programmer will inject dependent object into target object
using
<property/> tag or <constructor-arg/> tag using 'ref' attribute.

<bean id="dieselEng" class="in.ashokit.beans.DieselEngine" />

<bean id="car" class="in.ashokit.beans.Car">

<property name="eng" ref="dieselEng" />
</bean>

-> Autowiring means IoC container will identify dependent bean and it will inject
into target bean
(we no need to use any ref attribute in bean configuration file)

-> Autowiring will work based on below modes

1) byName
2) byType
3) constructor
4) no

Note: Autowiring will not work bydefault, We have to enable autowiring on target
bean like below.

<bean id="id" class="pkg.Classname" auto-wire="byName | byType |

constructor | no " />

==========
byName
==========

=> byName means IoC will identify dependent bean object based on bean id or bean
name.

public class Car {

private IEngine eng;

public void setEng(IEngine eng) {

System.out.println("setEng ( ) method called....");
this.eng = eng;
}

public void drive() {

int status = eng.start();
 if (status >= 1) {
System.out.println("Journey Started..");
} else {
System.out.println("Engine Trouble");
}
}
}

<?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
http://www.springframework.org/schema/beans/spring-beans.xsd">

<bean id="eng1" class="in.ashokit.beans.PetrolEngine" />

<bean id="eng" class="in.ashokit.beans.DieselEngine" />

<bean id="car" class="in.ashokit.beans.Car" autowire="byName"/>

</beans>

Note: In the above example Car class variable name is matched with 'DieselENgine'
bean id hence DieselEngine obj will be injected into Car.

========
byType
========

=> byType means IoC will identity dependent bean object based on data type of the
variable in Target class.

private IEngine eng; ====> data type of eng is IEngine which

is an interface

=> If one interface having 2 implementations then there is a chance of getting

Ambiguity problem. To overcome that we need to use 'autowire-candiate' attribute.

autowire-candidate="false" ====> Not Eligible for Autowiring

autowire-candidate="true" ===> Eligible for Autowiring

Note: As an alternate for "autowire-candidate=true" we can use "primary=true" to

consider bean for Autowiring.

<?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
http://www.springframework.org/schema/beans/spring-beans.xsd">

<bean id="eng2" class="in.ashokit.beans.PetrolEngine" autowire-

candidate="false"/>

<bean id="eng1" class="in.ashokit.beans.DieselEngine" autowire-

candidate="true"/>
 <bean id="car" class="in.ashokit.beans.Car" autowire="byType" />

</beans>

(or)

<?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
http://www.springframework.org/schema/beans/spring-beans.xsd">

<bean id="eng2" class="in.ashokit.beans.PetrolEngine" primary="true" />

<bean id="eng1" class="in.ashokit.beans.DieselEngine" />

<bean id="car" class="in.ashokit.beans.Car" autowire="constructor" />

</beans>

===========
constructor
===========

=> It is used to perform Autowiring by calling target class constructor

package in.ashokit.beans;

public class Car {

private IEngine eng;

public Car(IEngine eng) {

this.eng = eng;
}

public void drive() {

int status = eng.start();

if (status >= 1) {
System.out.println("Journey Started..");
} else {
System.out.println("Engine Trouble");
}
}
}

<?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
http://www.springframework.org/schema/beans/spring-beans.xsd">

<bean id="eng2" class="in.ashokit.beans.PetrolEngine" autowire-

candidate="false"/>
 <bean id="eng1" class="in.ashokit.beans.DieselEngine" autowire-
candidate="true"/>

<bean id="car" class="in.ashokit.beans.Car" autowire="constructor" />

</beans>

===============================================================================

Note: Autowiring is applicable for Reference Type variable (not applicable for
primitive types)

====================
Spring Bean Life Cycle
====================

=> Life cycle means starting to ending or birth to death

-> Thread Life Cycle

-> Servlet Life Cycle

-> JSP Life cycle

-> Spring Bean Life Cycle

=> Spring Bean object creation and object destruction will be taken care by IOC
container.

=> Spring Bean Life Cycle will be managed by Ioc Container.

=> We can perform some operations using Bean Life Cycle Methods

init ( ) --------> initialization logic

destroy ( ) -----> destruction logic

=> Spring Bean Life Cycle methods we can execute in 3 ways

1) XML Approach (Declarative)

2) Progrmmatic approach

3) Annotations

============ Bean Life Cycle using XML Approach ================

<bean id="motor" class="in.ashokit.beans.Motor"

init-method="start"
destroy-method="stop"/>

init-method ==> It represents the method which should be called after bean obj
created

destroy-method ==> It represents the method which should be called when bean obj
removing from IoC

package in.ashokit.beans;

public class Motor {

public Motor() {
System.out.println("Motor :: Constructor");
}

public void start() {

System.out.println("Motor started....");
}

public void doWork() {

System.out.println("Motor Pulling Water...");
}

public void stop() {

System.out.println("Motor stopped.....");
}

<?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
http://www.springframework.org/schema/beans/spring-beans.xsd">

<bean id="motor" class="in.ashokit.beans.Motor"

init-method="start" destroy-method="stop" />

</beans>

============ Bean Life Cycle using Programmatic Approach ================

=> We need to implement predefined interfaces provided by Spring Framework

1) InitializingBean ---> afterPropertiesSet ( )

2) DisposableBean ---> destroy ( )

public class Motor implements InitializingBean, DisposableBean {

public Motor() {
System.out.println("Motor :: Constructor");
}

public void afterPropertiesSet() throws Exception {

System.out.println("motor started.....");
}

public void doWork() {

System.out.println("Motor Pulling Water...");
}
 public void destroy() throws Exception {
System.out.println("motor stopped.....");
}
}

============ Bean Life Cycle using Annotation Approach ================

@PostConstruct -----> It represents init method

@PreDestroy ----> It represents destroy method

public class Motor {

public Motor() {
System.out.println("Motor :: Constructor");
}

@PostConstruct
public void m1() throws Exception {
System.out.println("motor started.....");
}

public void doWork() {

System.out.println("Motor Pulling Water...");
}

@PreDestroy
public void m2() throws Exception {
System.out.println("motor stopped.....");
}
}

===================================================================================
===
=================================================================================

1) What is Spring Bean

2) How to represent Java class as Spring Bean

3) What is IoC Container

4) What is Bean Configuration File

5) How to start IOC Container

6) First Application Development using Spring Core Module

7) What is Dependency Injection (SI , CI & FI )

8) BeanFactory vs ApplicationContext

9) Lazy loading vs Eager Loading

10) Bean Scopes (Singleton & Prototype)

11) Autowiring & Modes

12) Bean Life Cycle Methods (XML, Programmatic & Annotations)

=================
Spring Annotations
=================

Annotation ===> Represent Metadata

=> Annotations Introduced in Java 1.5v

=> Annotations are alternate for xml configurations

=> In Spring Framework we have several annotations

1) @Configuration : To represent java class as Configuration class

2) @ComponentScan : To identify Spring Bean classes available in the project based

on "basePackageNames"

3) @Component : To represent java class as Spring Bean.

4) @Service: To represent java class as Spring Bean (Business layer classes)

5) @Repository: To represent java class as Spring Bean (Persistence layer classes)

6) @Scope : To represent bean scope

7) @Autowired : To perform dependency injection

8) @Qualifier : To perform autowiring based on byName

9) @Primary : To represent primary bean for Autowiring

10) @Bean : To call the method which returns bean object

===================================================================================
==============
basePackage = in.ashokit

in.ashokit.beans --------> will be scanned

in.ashokit.utils ----------> will be scanned

in.ashokit.dao ------> will be scanned

com.ashokit.service ---> will not be scanned