View as presentation

→ Slide 1

Co to jest Spring Framework

Spring to zaawansowana platforma do tworzenia aplikacji w Javie. Składa się z wielu modułów wspierających różne aspekty tworzenia aplikacji.

Kluczowym elementem jest kontener IoC (Inversion of Control) udostępniający mechanizm wstrzykiwania zależności (Dependency Injection), co przyspiesza i upraszcza składanie aplikacji.

Spring to „framework frameworków„ - jeden z najpopularniejszych i najbardziej wszechstronnych frameworków w ekosystemie Java.

Strona projektu: spring.io

Spring w IntelliJ IDEA: Spring support in IntelliJ IDEA

→ Slide 2

Najważniejsze cechy Spring

  • Aspect-Oriented Programming (AOP) - programowanie aspektowe dla obsługi zagadnień przekrojowych (logowanie, obsługa wyjątków, zarządzanie transakcjami, zabezpieczenia)
  • Inversion of Control (IoC) - odwrócenie kontroli nad tworzeniem i zarządzaniem obiektami
  • Dependency Injection (DI) - automatyczne wstrzykiwanie zależności do komponentów
→ Slide 3

Aspect-Oriented Programming (AOP)

  • AOP to programowanie aspektowe - podejście pozwalające na wydzielenie zagadnień przekrojowych (cross-cutting concerns).
  • Przykłady zagadnień przekrojowych:
    • Logowanie
    • Obsługa wyjątków
    • Zarządzanie transakcjami
    • Zabezpieczenia
  • AOP pozwala na oddzielenie logiki biznesowej od tych zagadnień, co prowadzi do czystszego i bardziej modularnego kodu.
→ Slide 4

Inversion of Control (IoC)

  • IoC to zasada odwrócenia kontroli nad tworzeniem i zarządzaniem obiektami.
    • Mniejsze sprzężenie między klasami
    • Łatwiejsze testowanie
    • Większa elastyczność i skalowość
  • Tradycyjne podejście: aplikacja sama tworzy obiekty, które potrzebuje.
  • Spring IoC: aplikacja otrzymuje obiekty od kontenera IoC. Kontener zarządza tworzeniem, konfiguracją i niszczeniem obiektów.

IoC - Inversion of Control

→ Slide 5

Dependency Injection

  • Wstrzykiwanie zależności (DI) to mechanizm, w którym zależności są dostarczane do obiektu z zewnątrz.
  • Sposoby wstrzykiwania:
    • przez konstruktor - zalecane, zapewnia niezmienność i łatwość testowania
    • przez settery - mniej bezpieczne, może prowadzić do niekompletnych obiektów
    • przez pola - najrzadziej stosowane, brak kontroli nad wstrzykiwaniem

Przykład przez konstruktor: 

@Service
public class UserService {
    private final UserRepository repository;
 
    public UserService(UserRepository repository) {
        this.repository = repository;
    }
}

Spring - moduły

→ Slide 6

Podstawowe moduły Spring

  • Spring Core - kontener IoC i wstrzykiwanie zależności
  • Spring Web - aplikacje webowe (Spring MVC)
  • Spring Data - uproszczona praca z bazami danych
  • Spring Security - bezpieczeństwo i autoryzacja
  • Spring AOP - programowanie aspektowe
  • Spring Test - wsparcie dla testów jednostkowych
  • Spring Boot - automatyczna konfiguracja i szybki start
→ Slide 7

Zalety korzystania ze Spring

  • Gotowe szablony wspierające wiele technologii (JDBC, Hibernate, JPA, itp.)
  • Luźne powiązanie między komponentami - łatwość rozszerzania
  • Łatwość testowania aplikacji dzięki DI
  • Lekkość - wybieramy tylko potrzebne komponenty
  • Szybkość prac developerskich
  • Wysoki poziom abstrakcji
  • Silne wsparcie społeczności i dostawców
→ Slide 8

Najważniejsze elementy Spring

  • IoC Container - zarządza cyklem życia beanów i wstrzykiwaniem zależności.
  • Bean - obiekt zarządzany przez kontener Spring. Każdy bean ma unikalną nazwę i konfigurację.
  • Bean Scopes - zakresy beanów:
    • Singleton - jedna instancja dla całej aplikacji (domyślny, @Component, @Service, @Repository, @Controller)
    • Prototype - nowa instancja za każdym razem
    • Request - jedna instancja na żądanie HTTP
    • Session - jedna instancja na sesję
  • ApplicationContext - główny interfejs do komunikacji z kontenerem IoC. Dostęp do beanów, obsługa zdarzeń, zasoby.
→ Slide 9

Cykl życia beanów

  • Tworzenie (instantiation)
  • Konfiguracja właściwości - wstrzykiwanie zależności
  • Inicjalizacja (init method)
  • Użytkowanie
  • Niszczenie (destroy method)

Cykl życia beanów

→ Slide 10

Adnotacje Spring

@Component - oznacza klasę jako komponent zarządzany przez Spring.

@Service - specjalizacja @Component, oznacza klasę jako usługę biznesową.

@Repository - specjalizacja @Component, oznacza klasę do dostępu do danych.

@Autowired - wstrzykuje zależność (może być na polu, setterze lub konstruktorze).

@Configuration - oznacza klasę, która zawiera definicje beanów.

@Bean - oznacza metodę, która zwraca bean zarządzany przez Spring. 

@Configuration
public class AppConfig {  
    @Bean
    public UserService userService() {
        return new UserService(userRepository());
    }
 
    @Bean
    public UserRepository userRepository() {
        return new UserRepository();
    }
}
→ Slide 11

Konfiguracja Spring

  • XML - plik XML z konfiguracją 
      <beans>
    <bean id="userService" class="com.example.UserService"/>
  </beans>
  • Adnotacje - oznaczamy klasy adnotacjami (@Component, @Service, …) i Spring sam je wykrywa przez component scanning
  • konfiguracja w kodzie Java 
    @Configuration
public class AppConfig {
    @Bean
    public UserService userService() {  
        return new UserService(userRepository());
    } 
 
    @Bean
    public UserRepository userRepository() {
        return new UserRepository();
    }
}
→ Slide 12

Co to jest Spring Boot

Spring Boot to framework oparty na Spring, który upraszcza i przyspiesza tworzenie aplikacji Spring.

  • Szybkie tworzenie aplikacji - gotowe szablony i konfiguracje
  • Automatyczna konfiguracja - Spring Boot sam konfiguruje wspólne komponenty
  • Wbudowany serwer aplikacji (Tomcat, Netty, Jetty)
  • Prostota - mniej kodu do napisania
  • Produkcyjność - szybki start i iteracyjny rozwój
  • Łatwa integracja z innymi technologiami - gotowe startery
  • Łatwość wdrażania - pojedynczy plik JAR z całą aplikacją
→ Slide 13

Instalacja i konfiguracja

  • Ręczna konfiguracja projektu Maven lub Gradle z zależnościami Spring Boot
  • Szablon Spring Boot w IntelliJ IDEA
    File > New > Project > Spring Boot
  • Spring Initializer (https://start.spring.io) - narzędzie do generowania szablonu projektu.
→ Slide 14

Struktura projektu Spring Boot

Struktura projektu Spring Boot

Struktura katalogów:

  • src/main/java - kod źródłowy aplikacji
  • src/main/resources - zasoby (konfiguracja, pliki statyczne)
  • src/test/java - testy
  • pom.xml lub build.gradle - konfiguracja budowania

Plik application.properties lub application.yml - konfiguracja aplikacji.

→ Slide 15

Tworzenie i uruchamianie aplikacji

Główna klasa aplikacji: 

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

Adnotacja @SpringBootApplication odpowiada za:

  • @Configuration - definiuje klasę jako źródło konfiguracji
  • @EnableAutoConfiguration - włącza automatyczną konfigurację
  • @ComponentScan - szuka komponentów w bieżącym pakiecie
→ Slide 16

Typowa struktura aplikacji

Warstwy architektoniczne w Spring Boot

→ Slide 17

Warstwy architektoniczne

  • Presentation Layer (warstwa prezentacji)
    • Obsługa żądań HTTP
    • Kontrolery (@RestController, @Controller)
  • Service Layer (warstwa usług)
    • Logika biznesowa
    • Klasy serwisów (@Service)
  • Data Access Layer (warstwa dostępu do danych)
    • Operacje na bazie danych
    • Repozytoria (@Repository)
  • Domain/Model Layer
    • Encje i modele danych (@Entity)
    • Reguły biznesowe
→ Slide 18

Spring Boot MVC

  • Model - reprezentacja danych aplikacji, obiekty biznesowe.
    • obiekty Java, encje JPA, DTO
  • View - warstwa prezentacji, widoki
    • HTML, template (Thymeleaf, JSP, FreeMarker)
  • Controller - obsługuje żądania użytkownika, aktualizuje model, wybiera widok.
    • klasy oznaczone @Controller lub @RestController
    • @Controller - metody zwracają nazwy widoków
    • @RestController - metody zwracają dane (JSON)
→ Slide 19

Kontrolery w Spring MVC

Przykład prostego kontrolera: 

@Controller
@RequestMapping("/users")
public class UserController {
 
    @GetMapping
    public String listUsers(Model model) {
        model.addAttribute("users", userService.findAll());
        return "users/list";
    }
 
    @PostMapping
    public String createUser(@ModelAttribute User user) {
        userService.save(user);
        return "redirect:/users";
    }
}

Adnotacje:

  • @Controller - oznacza klasę jako kontroler
  • @RequestMapping - mapuje URL
  • @GetMapping, @PostMapping - mapuje konkretne metody HTTP
→ Slide 20

Przykład REST API

@RestController
@RequestMapping("/api/users")
public class UserRestController {
 
    @GetMapping
    public List<User> getAllUsers() {
        return userService.findAll();
    }
 
    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.findById(id);
    }
 
    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.save(user);
    }
 
    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.delete(id);
    }
}
→ Slide 21

Adnotacje dla REST API

@RestController - kombinacja @Controller i @ResponseBody, zwraca JSON.

@RequestMapping - mapuje URL i metody HTTP.

@GetMapping, @PostMapping, @PutMapping, @DeleteMapping - skróty dla konkretnych metod HTTP.

@PathVariable - parametry w ścieżce URL (np. /users/{id}).

@RequestParam - parametry zapytania (np. ?page=1&size=10).

@RequestBody - mapowanie body żądania na obiekt Java.

@ResponseBody - konwersja obiektu na JSON.

→ Slide 22

Obsługa plików statycznych

Spring Boot automatycznie serwuje pliki statyczne z folderów:

  • src/main/resources/static
  • src/main/resources/public
  • src/main/resources/resources
  • src/main/resources/META-INF/resources

Pliki (HTML, CSS, JavaScript, obrazy) są dostępne bezpośrednio w aplikacji.

→ Slide 23

Services

  • Warstwa usług (Service Layer) - logika biznesowa aplikacji
  • Klasy serwisów oznaczone adnotacją @Service
  • Oddzielenie logiki biznesowej od warstwy prezentacji i dostępu do danych
interface UserService {
    List<User> findAll();
    User findById(Long id);
    User save(User user);
    void delete(Long id);
}
 
@Service
public class UserServiceImpl implements UserService {  
 
    @Autowired
    private final UserRepository repository;
 
    public List<User> findAll() {
        return repository.findAll();
    }
 
  /* ... */   
}
→ Slide 24

Łączenie z bazą danych

  • Spring Boot wspiera wiele baz danych (relacyjne i nierelacyjne):
    • MySQL, PostgreSQL, SQLite, H2 (baza w pamięci, do testów), Oracle, Microsoft SQL Server, MongoDB
  • Automatyczna konfiguracja połączenia z bazą danych na podstawie zależności i ustawień w application.properties.
  • Spring Data JPA - uproszczona praca z bazami danych, automatyczne mapowanie obiektów na tabele, generowanie zapytań SQL, CRUD operacje bez pisania SQL.
  • Konfiguracja w application.properties:
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=password
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
→ Slide 25

Spring Data JPA

  • JPA (Java Persistence API) - standard do mapowania obiektów na bazę danych.
  • Hibernate - najpopularniejsza implementacja JPA.
  • Spring Data JPA - uproszczona praca z JPA.
    • Automatyczne mapowanie obiektów na tabele
    • Automatyczne generowanie zapytań SQL
    • CRUD operacje bez pisania SQL
→ Slide 26

Encje i repozytoria

Definicja encji: 

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
 
    @Column(nullable = false, unique = true)
    private String email;
 
    @Column(nullable = false)
    private String name;
}

Definicja repozytorium: 

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    User findByEmail(String email);
}
→ Slide 27

Aplikacja CRUD

  • CRUD - Create, Read, Update, Delete operacje na bazie danych.
  • Spring Data JPA automatycznie dostarcza metody CRUD:
    • save() - tworzenie i aktualizacja
    • findAll() - pobranie wszystkich
    • findById() - pobranie po ID
    • delete() - usunięcie
  • Można definiować własne metody w repozytorium na podstawie konwencji nazewnictwa.
→ Slide 28

Konfiguracja połączenia z bazą danych

Ustawienia w application.properties lub application.yml:

  • spring.datasource.url - URL bazy danych
  • spring.datasource.username - nazwa użytkownika
  • spring.datasource.password - hasło
  • spring.jpa.hibernate.ddl-auto - strategia zarządzania schematem bazy danych (create, update, validate, none)
  • spring.jpa.show-sql - wyświetlanie generowanych zapytań SQL w konsoli
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=password
→ Slide 29

Obsługa błędów w REST API

Globalna obsługa wyjątków: 

@ControllerAdvice
public class GlobalExceptionHandler {
 
    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<String> handleNotFound(
            ResourceNotFoundException ex) {
        return ResponseEntity
            .status(HttpStatus.NOT_FOUND)
            .body(ex.getMessage());
    }
 
    @ExceptionHandler(Exception.class)
    public ResponseEntity<String> handleGeneral(Exception ex) {
        return ResponseEntity
            .status(HttpStatus.INTERNAL_SERVER_ERROR)
            .body("Błąd serwera");
    }
}

@ControllerAdvice - klasa globalnej obsługi wyjątków.

@ExceptionHandler - metoda obsługująca konkretny typ wyjątku.

→ Slide 30

Dokumentacja