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

• 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

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

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

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

• 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

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

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

@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();
    }
}

• 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();
      }
  }

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ą

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

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.

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

• 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

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

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

@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);
    }
}

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

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.

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.

• 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

• 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

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);
}

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

Spring Security - framework do zabezpieczeń i autoryzacji.

• Autentykacja - weryfikacja tożsamości użytkownika
• Autoryzacja - sprawdzanie uprawnień do zasobów
• Ochrona przed CSRF
• Ochrona hasła - bcrypt
• Wsparcie dla OAuth2, JWT

@Configuration
@EnableWebSecurity
public class SecurityConfig {
 
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) 
            throws Exception {
        http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/public/**")
                    .permitAll()
                .anyRequest()
                    .authenticated())
            .formLogin();
        return http.build();
    }
}

• Autoryzacja - nadawanie uprawnień:
  • Role - zbiory uprawnień (np. ADMIN, USER)
  • Uprawnienia - konkretne akcje (np. DELETE_USER)
• Uwierzytelnianie - weryfikacja hasła i logowania.
• W Spring Security:
  • @PreAuthorize - weryfikacja uprawnień na metodzie
  • @Secured - alternatywa dla @PreAuthorize
  • SecurityContext - dostęp do informacji o zalogowanym użytkowniku

@RestController
@RequestMapping("/api/admin")
public class AdminController {
 
    @DeleteMapping("/users/{id}")
    @PreAuthorize("hasRole('ADMIN')")
    public void deleteUser(@PathVariable Long id) {
        userService.delete(id);
    }
}

Adnotacja @PreAuthorize sprawdza, czy użytkownik ma rolę ADMIN.