API&M Unit-02

1) Create a Spring Boot Application

steps:
- Install IDE:
  - Install Eclipse IDE, STS for Java development
- Create Project:
  - Enter details in Spring.io and click generate to download the project Zip
- Extract and import:
  - Extract the project Zip and import it into the IDE
- Download Dependencies:
  - IDE automatically download the required dependencies
- Run the Applications:
  - Main class annotated with @SpringBootApplication and run it as a Java Application

API&M Unit-02

2) REST controller:

REST Controller is the main component in a Spring Boot RESTful service.
It is defined using the @RestController annotation.
Key Annotations:
- @RestController
- @RequestMapping
- @GetMapping, @PostMapping, @PutMapping, @DeleteMapping
- @RequestBody, @PathVariable, @RequestParam

Syntax:

@RestController
@RequestMapping("/request")
public class A
{
   ...
   @GetMapping("/get")
   ...
   @PostMapping("/post")
   ...
   @PutMapping("/put")
   ...
   @DeleteMapping("/delete")
   ...
}

@GetMapping handles GET requests.
@PostMapping handles POST requests.
@PutMapping handles PUT requests.
@DeleteMapping handles DELETE requests.
Program

A.java

@RestController
@RequestMapping("/request")
public class A {
  @GetMapping("/get")
  public String get() {
     return "CC";
  }
  @PostMapping("/post")
  public String post() {
     return "WNS";
  }
  @PutMapping("/put")
  public String put() {
     return "API&M";
  }
  @DeleteMapping("/delete")
  public String delete() {
     return "SCT";
  }
}

Main.java

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

Output:

WNS

API&M

SCT

API&M Unit-02

3) Build a Spring Boot Application with Exception Handling and apply aspects to controller methods

A.java

@RestController
@RequestMapping("/request")
public class A {
  @GetMapping("/get")
  public String get() {
      if(true)
          throw new RuntimeException("Error");
      return "CC";
  }
  @PostMapping("/post")
  public String post() {
      if(true)
          throw new RuntimeException("Error");
      return "WNS";
  }
  @PutMapping("/put")
  public String put() {
      if(true)
          throw new RuntimeException("Error");
      return "API&M";
  }
  @DeleteMapping("/delete")
  public String delete() {
      if(true)
          throw new RuntimeException("Error");
      return "SCT";
  }
}

B.java

@Aspect
@Component
public class B {
   @AfterThrowing(...)
   public void fun(Exception e){
      System.out.println(e.getMessage());
   }
}

Main.java

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

Output:

Error

API&M Unit-02

4) Autowiring in Spring

The process of automatically injecting dependencies between beans is called as Autowiring
It eliminates the manual wiring in XML
Modes of Autowiring:
- NO:
  - There is no automatic connection
  - Dependencies are defined by the developer
  - Developers manually define dependencies in bean configuration
  - syntax:
```
<bean id="a" class="b" />
```
- byName:
  - It connects by name
  - Dependencies are defined by the Spring
  - Dependencies are injected when the property name = bean id
  - syntax:
```
<bean id="a" class="b" autowire="byName" />
```
- byType:
  - It connects by type
  - Dependencies are defined by the Spring
  - Dependencies are injected when a bean has a unique type
  - syntax:
```
<bean id="a" class="b" autowire="byType" />
```
- constructor:
  - It connects through the constructor
  - Dependencies are defined by the Spring
  - It is like byType but applies to constructor arguments
  - syntax:
```
<bean id="a" class="b" autowire="constructor" />
```
- autodetect:
  - It connects automatically, but the older version
  - Dependencies are defined by the Spring
  - It is between byType and Constructor
  - syntax:
```
<bean id="a" class="b" autowire="autodetect" />
```

API&M Unit-02

5) Singleton Scope vs Prototype Scope

Singleton Scope:
- Singleton Scope is the default Scope of a bean
- You don't have to declare the scope of a bean as a singleton explicitly
- Only one instance is created for a single bean definition
- same Object is shared for each request
- It is used for a stateless bean
- Syntax:
```
@Service
public class A
{
  ...
}
```
Prototype Scope:
- Prototype Scope is not the default Scope of a bean
- You have to declare the scope of a bean as a Prototype explicitly
- A new instance is created for a single bean definition
- new Object is created for each request
- It is used for a stateful bean
- syntax:
```
@Component
@Scope("prototype")
public class A
{
    ...
}
```

API&M Unit-02

6) Request scope and Session Scope

Request scope:
- It is created for each request
- It lives for a short time
- Valid only for one HTTP call
- Request Scope is defined with @Scope("request") annotation
- It creates a new Request Data bean
- Syntax:
```
@Component
@Scope("request")
public class A
{
   ...
}
```
Session Scope:
- It is created for each Session
- It lives for a very long time
- valid for many HTTP Calls
- Session Scope is defined with @Scope("session") annotation
- It creates a new session bean
- Syntax:
```
@Component
@Scope("session")
public class A
{
   ...
}
```

API&M Unit-02

7) Logging in a Spring Boot Application:

Logging is the essential feature in a Spring Boot Application
Logging records the important events, errors and debugging information

syntax:

@RestController
@RequestMapping("/request")
public class A
{
  // Create a Logger instance
  public Logger a= ...;
  ...
}

Program:

A.java

@RestController
@RequestMapping("/request")
public class A
{
  // Create a Logger instance
  public Logger a= ...;
  @GetMapping("/get")
  public void logExample()
  {
    a.info("A");
    a.warn("B");
    a.error("C");
  }
  @PostMapping("/post")
  public void logExample()
  {
    a.info("D");
    a.warn("E");
    a.error("F");
  }
  @PutMapping("/put")
  public void logExample()
  {
    a.info("G");
    a.warn("H");
    a.error("I");
  }
  @DeleteMapping("/delete")
  public void logExample()
  {
    a.info("J");
    a.warn("K");
    a.error("L");
  }
}

Main.java

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

Output:

INFO A

WARN B

ERROR C

INFO D

WARN E

ERROR F

INFO G

WARN H

ERROR I

INFO J

WARN K

ERROR L

API&M Unit-02

8) Aspect-Oriented Programming(AOP):

AOP stands for Aspect-Oriented Programming
AOP is used to remove the cross-cutting concerns from the main logic
In spring, an Advisor connects two things:
- Pointcut (where to do, key: @Pointcut, @Aspect)
  - @Pointcut("expression") defines the join points
  - @Aspect creates Advisors
- Advice (what to do, key: @Before, @After, @AfterReturning, @AfterThrowing, @Around)
  - @Before runs before
  - @After runs after
  - @AfterReturning: if method returns
  - @AfterThrowing: if method throws exception
  - @Around: change value/handle Exception

A.java

@Aspect
@Component
Public class A
{
  @pointcut("expression")
  public void fun() {}
  @Before("fun()")
  public void fun1() {
    System.out.println("A");
  }
  @After("fun()")
  public void fun2() {
     System.out.println("B");
  }
  @AfterReturning(pointcut = "fun()", returning = "a")
  public void fun3(Object a) {
     System.out.println(a);
  }
  @AfterThrowing(pointcut = "fun()", throwing = "b")
  public void fun4(Exception b) {
     System.out.println(b.getMessage());
  }
  // AROUND
  @Around("fun()")
  public void fun5() {
     System.out.println("C");
  }
}

Main.java

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

Output:

//returns value

//Error message

API&M Unit-02

9) Cross-Cutting Concerns:

Some features are used in many modules, and those features are not part of the main logic
These are called as cross-cutting concerns.
Example:
- Logging
- Auditing
- Exception Handling
- Security
Role of AOP:
- AOP stands for Aspect-Oriented Programming
- AOP is used to remove the cross-cutting concerns from the main logic