---
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

<u>CoffeeBean.java</u>
```java
public class CoffeeBean {
    private String type;

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

    public String getType() {
        return type;
    }
}
```

<u>Water.java</u>
```java
public class Water {
    private int amount;

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

    public int getAmount() {
        return amount;
    }
}

```

<u>CoffeeMachine.java</u>
```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
![Video](https://www.youtube.com/watch?v=LSEYdU8Dp9Y)


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:

```java

// 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|Beans]]
### 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](IoC%20and%20Spring.md#Controller) and [Repository](IoC%20and%20Spring.md#Repository)
- Annotated with `@Service`