# Karta ćwiczenia laboratoryjnego

[![Java](https://img.shields.io/badge/Java-ED8B00?style=for-the-badge&logo=openjdk&logoColor=white)](https://www.java.com/)
[![Spring Boot](https://img.shields.io/badge/Spring_Boot-6DB33F?style=for-the-badge&logo=springboot&logoColor=white)](https://spring.io/projects/spring-boot)
[![Spring IoC](https://img.shields.io/badge/Spring_IoC-6DB33F?style=for-the-badge&logo=spring&logoColor=white)](https://docs.spring.io/spring-framework/reference/core/beans.html)
[![Spring AOP](https://img.shields.io/badge/Spring_AOP-6DB33F?style=for-the-badge&logo=spring&logoColor=white)](https://docs.spring.io/spring-framework/reference/core/aop.html)
[![Spring Annotations](https://img.shields.io/badge/@Autowired-6DB33F?style=for-the-badge&logo=spring&logoColor=white)](https://docs.spring.io/spring-framework/reference/core/beans/annotation-config/autowired.html)
[![AspectJ](https://img.shields.io/badge/AspectJ-FF6600?style=for-the-badge&logo=eclipse&logoColor=white)](https://www.eclipse.org/aspectj/doc/released/progguide/index.html)
[![Maven](https://img.shields.io/badge/Maven-C71A36?style=for-the-badge&logo=apachemaven&logoColor=white)](https://maven.apache.org/guides/index.html)


## 📋 Informacje podstawowe

| Pole | Wartość |
| --- | --- |
| Przedmiot | Spring |
| Forma zajęć | laboratorium |
| Ćwiczenie | Lab. 3 / Spring CORE - AOP |
| Data | 18.04.2026 |
| Nazwisko i imię studenta | ...................................................... |
| Rok/semestr | Rok 3, semestr 6 [studia niestacjonarne] |
| Ocena | ocena cząstkowa |
| Uwagi do ćwiczenia | **brak** |

## 📝 Opis zadania laboratoryjnego
Napisz program, który wykorzystuje IoC w Java Spring. Program posiada klasę główną `Robot` oraz klasy (`@Component`) `CzujnikRuchu` i `SilnikGlowny`. Klasa `CzujnikRuchu` posiada dwie metody: `odczyt()` zwracającą wartość odległości od przeszkody oraz `setStan()` przyjmującą wartości `ON`/`OFF` (`true`/`false`). Klasa `SilnikGlowny` posiada metodę umożliwiającą odczytanie stanu silnika oraz zatrzymanie i uruchomienie silnika. Zbuduj robota składającego się z czujnika i silnika (zastosuj `@Autowired`) oraz możliwość sterowania nim. Następnie zdefiniuj aspekt, który loguje przed i po wywołaniu metod.

## 📦 Wymagania

Kod programu należy umieścić w polu **Kod programu** tego pliku.
Plik `.md` należy dodać do projektu.

Całość należy spakować do formatu `.zip`:

`WSZIB_R3IN_NazwiskoImie_Spring_Lab3.zip`

W miejscu `NazwiskoImie` należy wpisać swoje nazwisko i imię (uwaga na kolejność).
Wynik pracy w formie archiwum `zip` powinien zawierać:
 - folder `Program`
 - uzupełniony ten plik tj. `.md`.

Archiwum `WSZIB_R3IN_NazwiskoImie_Spring_Lab3.zip` należy uzupełnić o swoje dane w nazwie i przesłać poprzez:

[![Upload](https://img.shields.io/badge/Upload-upload.pelo.com.pl-blue?style=for-the-badge&logo=upload&logoColor=white)](https://upload.pelo.com.pl)

## 🎯 Ogólny opis zadania

Celem zadania jest przygotowanie aplikacji Spring Boot demonstrującej mechanizm IoC (Inversion of Control) oraz AOP (Aspect-Oriented Programming). Aplikacja symuluje działanie robota składającego się z czujnika ruchu i silnika głównego. Kontener Spring zarządza zależnościami między komponentami za pomocą `@Autowired`. Aspekt przechwytuje wywołania wszystkich metod komponentów i loguje informacje przed i po ich wykonaniu.

## ✅ Wymagania funkcjonalne

| Kod wymagania | Wymaganie | Poziom |
| --- | --- | --- |
| WF-01 | Klasa `CzujnikRuchu` oznaczona `@Component` posiada metodę `odczyt()` zwracającą symulowaną wartość odległości od przeszkody. | wysoki |
| WF-02 | Klasa `CzujnikRuchu` posiada metodę `setStan(boolean stan)` ustawiającą stan czujnika (`ON`/`OFF`). | wysoki |
| WF-03 | Klasa `SilnikGlowny` oznaczona `@Component` posiada metodę odczytującą aktualny stan silnika. | wysoki |
| WF-04 | Klasa `SilnikGlowny` posiada metody `start()` i `stop()` umożliwiające uruchomienie i zatrzymanie silnika. | wysoki |
| WF-05 | Klasa `Robot` wstrzykuje `CzujnikRuchu` i `SilnikGlowny` za pomocą `@Autowired` i umożliwia sterowanie robotem. | wysoki |
| WF-06 | Zdefiniowany aspekt (`@Aspect`) przechwytuje wywołania metod i loguje komunikaty przed (`@Before`) i po (`@After`) ich wykonaniu. | wysoki |
| WF-07 | Aplikacja uruchamia przykładowy scenariusz sterowania robotem w metodzie `main`. | średni |

## 🔧 Wymagania niefunkcjonalne

| Kod wymagania | Wymaganie | Poziom |
| --- | --- | --- |
| WNF-01 | Aplikacja powinna wykorzystywać mechanizm autokonfiguracji Spring Boot (`@SpringBootApplication`). | wysoki |
| WNF-02 | Zarządzanie zależnościami powinno być realizowane przez kontener IoC Spring (bez ręcznego tworzenia obiektów przez `new`). | wysoki |
| WNF-03 | Aspekt powinien być skonfigurowany za pomocą adnotacji (`@Aspect`, `@Component`) i Spring AOP. | wysoki |
| WNF-04 | Struktura projektu powinna być zgodna z konwencją Spring Boot (Maven lub Gradle). | średni |
| WNF-05 | Kod Java powinien być czytelny, poprawnie sformatowany i podzielony na osobne klasy/pliki. | średni |
| WNF-06 | Rozwiązanie powinno być przygotowane bez wykorzystania wsparcia AI. | niski |
| WNF-07 | Archiwum `.zip` powinno zawierać folder `Program` z projektem oraz uzupełniony (ten) plik `.md`. | wysoki |

## 🧩 Diagram klas

```mermaid
classDiagram
    class Robot {
        -CzujnikRuchu czujnik
        -SilnikGlowny silnik
        +steruj()
    }
    class CzujnikRuchu {
        -boolean stan
        +odczyt() double
        +setStan(boolean stan)
    }
    class SilnikGlowny {
        -boolean pracuje
        +getStan() boolean
        +start()
        +stop()
    }
    class LogowanieAspekt {
        +logujPrzed(JoinPoint jp)
        +logujPo(JoinPoint jp)
    }

    Robot --> CzujnikRuchu : @Autowired
    Robot --> SilnikGlowny : @Autowired
    LogowanieAspekt ..> CzujnikRuchu : @Before / @After
    LogowanieAspekt ..> SilnikGlowny : @Before / @After
    LogowanieAspekt ..> Robot : @Before / @After
```

**Legenda diagramu:**

| Symbol | Opis |
| --- | --- |
| `──>` (linia ciągła) | Zależność przez wstrzykiwanie `@Autowired` — `Robot` posiada referencję do komponentu |
| `..>` (linia przerywana) | Powiązanie aspektowe — `LogowanieAspekt` przechwytuje wywołania metod (`@Before` / `@After`) |


## <span style="color:red">💻 KOD PROGRAMU - REALIZACJA</span>

### JAVA (RobotApplication.java)
```java
// Wklej tutaj kod Java
```

### JAVA (CzujnikRuchu.java)
```java
// Wklej tutaj kod Java
```

### JAVA (SilnikGlowny.java)
```java
// Wklej tutaj kod Java
```

### JAVA (Robot.java)
```java
// Wklej tutaj kod Java
```

### JAVA (LogowanieAspekt.java)
```java
// Wklej tutaj kod Java
```

---

## 🏆 Ocena

### Ocena kodu

| Kryterium | Opis | Punkty (max) | Punkty uzyskane |
| --- | --- | --- | --- |
| K-01 | Poprawna struktura projektu Spring Boot | 1 | |
| K-02 | Klasa `CzujnikRuchu` – metody `odczyt()` i `setStan()` | 2 | |
| K-03 | Klasa `SilnikGlowny` – metody `start()`, `stop()`, `getStan()` | 2 | |
| K-04 | Klasa `Robot` z wstrzykiwaniem `@Autowired` | 2 | |
| K-05 | Aspekt `LogowanieAspekt` z `@Before` i `@After` | 2 | |
| K-06 | Działający scenariusz sterowania w metodzie `main` | 1 | |
| **Suma** | | **10** | |

### Ocena końcowa

| Pole | Wartość |
| --- | --- |
| Ocena (2–5) | |
| Uwagi prowadzącego | |
| Data wystawienia oceny | |
| Podpis prowadzącego | |