189 lines
4.6 KiB
Markdown
189 lines
4.6 KiB
Markdown
|
---
|
|||
|
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
|
|||
|

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