Summary  
This chapter explains the three-tier architecture pattern, detailing how to separate responsibilities into controller, service, and repository layers, and how requests flow through these annotated components in a Spring Boot application.  

General domain of usage  
Web applications (REST APIs)

Detta görs för att **separera** specifik logik i olika **klasser**/**paket**, istället för att **skriva** allt i en **enda klass**.

Den **ordning** i vilken en **förfrågan** behandlas är `Controller` → `Service` → `Repository`. Därefter returneras **svaret** i **omvänd** ordning: `Repository` -> `Service` -> `Controller`. Vi börjar **implementeringen** med `Repository`-**lagret**.

Detta är det **lägsta lagret**, där vi tar emot **bearbetad data** från `Service`-**lagret** och **lagrar det i vår databas**.

Dessa **klasser** är **markerade** med `@Repository`-**annoteringen** för att **läggas till** i **Spring-kontexten**.

QFJlcG9zaXRvcnkKcHVibGljIGNsYXNzIFJlcG9zaXRvcnlMZXZlbCB7CiAgICAvLyBjb25uZWN0IERCCn0=

Här sker **kärnlogiken** i **applikationen**. I **tjänster** **hanteras** eller **modifieras data** innan den skickas vidare till **repository-lagret**.

**För tjänster** används `@Service`-**annoteringen**, vilket **deklarerar** **klassen** som en `service` som innehåller **affärslogik**.

QFNlcnZpY2UKcHVibGljIGNsYXNzIFNlcnZpY2VMZXZlbCB7CgogICAgcHVibGljIHZvaWQgbG9naWMoKSB7CiAgICAgICAgLy9UT0RPOiB3cml0ZSBidXNpbmVzcyBsb2dpYwogICAgfQp9

Detta **lager** hanterar den initiala interaktionen mellan **klient** och **server**. **Alla förfrågningar** som skickas från **klienten** anländer hit, och det är **ansvarigt** för att ta emot data **tillhandahållen av klienten**.

Det bearbetar inkommande **HTTP-förfrågningar** och returnerar **HTTP-svar**. Kontroller fungerar som en "brygga" mellan **klient** och **affärslogik**.

**På denna nivå** används **två annoteringar** för att utse en **klass** som **kontroller**:

- `@RestController`: Deklarerar en **klass** som en **REST-kontroller**, som hanterar **HTTP-förfrågningar** och returnerar data i **JSON-format**;

- `@Controller`: Deklarerar en klass som en **MVC-kontroller**, som hanterar **förfrågningar** och **returnerar vyer** (t.ex. **HTML**).

QENvbnRyb2xsZXIKcHVibGljIGNsYXNzIENvbnRyb2xsZXJMZXZlbCB7CgogICAgQEdldE1hcHBpbmcoIi9yb290IikKICAgIHB1YmxpYyBTdHJpbmcgZ2V0UGFnZSgpIHsKICAgICAgICByZXR1cm4gInRlbXBsYXRlIjsKICAgIH0KfQ==

`@GetMapping` **-annoteringen** specificerar **URL:en** för en **given förfrågan**. Detta innebär att vi lägger till den **angivna sökvägen** `/root` till **domänen**, och i gengäld får vi den **motsvarande sidan**.

## Exempel på användning av Controller


Här är **länken** till <a href="https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-thymeleaf" style="text-decoration:none;" target="_blank">Thymeleaf</a>-beroendet i **Maven-repositoriet**.

## Men vad händer om du inte följer detta tillvägagångssätt?

**Tekniskt sett, ingenting**. Även om du skriver **all affärslogik** i **controllern**, ansluter till **databasen** där och **returnerar svaret** till **klienten** från samma plats, **kommer allt att fungera på samma sätt**.

Dock är det **osannolikt att du kommer ihåg** vad du **skrev** där efter några **veckor**, eftersom all **applikationslogik** kommer att ligga på **ett ställe**, vilket är **väldigt opraktiskt**.

# Sammanfattning

**Trelagersarkitekturen** ger en **tydlig uppdelning** av ansvar mellan lagren `controllers`, `services` och `repositories`, vilket **gör** utvecklingsprocessen mer **organiserad** och **lättare att underhålla**.

**Varje lager** fokuserar på sin **specifika uppgift**, vilket förenklar både **arbetsflödet** och **projektledningen**.

Denna kurs täcker viktiga aspekter av backendutveckling med Spring Boot, inklusive grunderna i HTTP och Spring, design och implementering av RESTful API:er, arbete med relationsdatabaser samt testning av applikationer. Efter avslutad kurs har användaren en gedigen förståelse för backendutveckling med Spring Boot, vilket möjliggör design och implementering av robusta RESTful API:er samt effektiv hantering av data med relationsdatabaser. Deltagaren får även praktisk erfarenhet av att testa applikationer för att säkerställa hög kodkvalitet och funktionalitet.

Du kommer att lära dig grunderna i backendutveckling, inklusive hur HTTP-protokollet fungerar och skillnaderna mellan HTTP och HTTPS. Du kommer även att studera HTTP-statuskoder och dataformat som JSON och XML för överföring av information mellan klient och server.

I denna sektion fördjupar vi oss i de grundläggande koncepten för backendutveckling med Spring. Vi behandlar olika ämnen, inklusive en introduktion till Spring, principerna för Inversion of Control (IoC) och Dependency Injection (DI), strukturen för ett Spring Boot-projekt, Spring MVC, trelagersarkitektur och uppgiftshantering. Varje kapitel bygger vidare på det föregående för att ge en heltäckande förståelse av backendutveckling i en Spring-miljö.

Detta avsnitt behandlar grunderna och den praktiska implementeringen av RESTful API:er, med början i den teoretiska förståelsen av REST och dess kärnprinciper. Det inkluderar även att bygga ett eget API, arbeta med DTO:er, hantera undantag, integrera Swagger för dokumentation samt testa API:et.

Detta avsnitt behandlar grunderna i arbete med relationsdatabaser, inklusive anslutningsinställningar, migrationer och interaktion med Object-Relational Mappers (ORM) med hjälp av JPA och Hibernate. Det diskuterar hur databaser integreras med Spring Boot-applikationer och utforskar viktiga aspekter av transaktionshantering för att säkerställa dataintegritet. Målet med detta avsnitt är att förbättra dina databaskunskaper och främja deras effektiva användning vid applikationsutveckling.

Detta avsnitt fokuserar på testning av backendapplikationer och täcker viktiga ämnen såsom grunderna i testning, enhetstestning med JUnit och integrationstestning. Det behandlar även användningen av mock-objekt med Mockito-biblioteket för att skapa effektiva och isolerade tester. Detta avsnitt hjälper utvecklare att förstå vikten av testning och lära sig hur man använder verktyg för att förbättra kvaliteten och tillförlitligheten i sina applikationer.