Notes/Advanced Programming/IoC and Spring.md

type
practical

IoC Definition

Inversion of Control is a design principle in which custom code is executed by an external code. The control of parts of your code is delegated to another logical unit.

Think of when you submit assignment to Themis. You did not write the tests in the program, but they still get executed against your program, as long as the input and output processing is correct.

Dependency Injection

It is a technique where an object receives (or is "injected" with) other objects that it depends on, rather than creating those objects itself.

Example

CoffeeBean.java

public class CoffeeBean {
    private String type;

    public CoffeeBean(String type) {
        this.type = type;
    }

    public String getType() {
        return type;
    }
}

Water.java

public class Water {
    private int amount;

    public Water(int amount) {
        this.amount = amount;
    }

    public int getAmount() {
        return amount;
    }
}

CoffeeMachine.java

public class CoffeeMachine {
    private CoffeeBean coffeeBean;  // <--------
    private Water water;            // Dependencies

    public CoffeeMachine(CoffeeBean coffeeBean, Water water) {
        this.coffeeBean = coffeeBean;
        this.water = water;
    }

    public void makeCoffee() {
        if (coffeeBean == null || water == null) {
            System.out.println("He-Hell nah.");
            return;
        }
        System.out.println("Making coffee with " + coffeeBean.getType() + " beans and " + water.getAmount() + "ml of water.");
    }
}

And then when we instantiate CoffeeMachine, we pass instances of Water and coffeeBean.

How Does Spring Use DI?

Spring manages the creation and wiring of objects for you. Here’s how it works:

1. Beans: Objects managed by Spring.
2. Spring Container: Factory which creates beans. You always need the container.

@Container vs @Bean vs @Component

• A Component is a Container all of which's methods are Beans
• Bean is a Method managed by Spring
• Container is the class decorator which tells spring that we have beans inside

Spring Basics

Spring is a framework, hence its design has to be followed.

Quickstart

1. Import (mvn)
2. Add @SpringBootApplication, import and SpringApplication.run(Main.class)

Handling a REST client

Example:

// Blah blah imports blah


@Controller
public class Control {

	@GetMapping("/api/path_to_resource/{dynamicValue}") // <- GET
	public String lmao(@PathVariable String value) {
		return "You gave me " + value;
	}
	
	@PostMapping("/api/setLol") // <- POST
	public String lmao(@RequestBody String value) {
		System.out.println("Received: " + value);
	}

	// We can also parse json n stuff
    @PostMapping("/api/yoMama")  
    public ResponseEntity<String> parseJson(@RequestBody yoMama obj) { 
        String response = "Received object: name = " + obj.getName() + 
                          ", number = " + obj.getNumber() + 
                          ", hot = " + obj.isHot();
        
        System.out.println(response);
        return ResponseEntity.ok(response);
    }
}

}

class yoMama {
	@Getter @Setter
	private String name;

	@Getter @Setter
	private int number;
	
	@Getter @Setter
	private boolean hot;
	
	public yoMama() {
	}
}

Beans

beans can only be uses by beans

!Beans.canvas

Definition

• Any class that is a dependency and/or is dependent

Purpose

• Solve the problem of dependencies by traversing the project's classes and instantiating them topologically in a procedural manner

Annotations

Check out the Annotation Repository.

Components

Entity

• Table in a DB
• Annotated with @Entity
• Instance corresponds to a row in the DB table

DTO (Data Transfer Object)

• Java object used to transfer data b/n layers
• Decouple internal data from data exposed to client
• Contain only the necessary fields

Repository

• Encapsulates storage, retrieval and search from a DB
• Usually extended from CrudRepository or JpaRepository
• Provides CRUD (Create, Read, Update and Delete) operations and query methods for an entity

Controller

• Handles HTTP requests and returns responses
• Maps HTTP requests to specific methods
• Usually annotated with @RestController and @RequestMapping

Service

• Class that contains logic and operations
• Intermediary between Controller and Repository
• Annotated with @Service