Umfassender Leitfaden zum Spring Framework

Home PDF

Dieser Blogbeitrag wurde mit Unterstützung von ChatGPT-4o verfasst.

Inhaltsverzeichnis

Einführung

Spring ist eines der beliebtesten Frameworks für die Entwicklung von Enterprise-Anwendungen in Java. Es bietet umfassende Infrastrukturunterstützung für die Entwicklung von Java-Anwendungen. In diesem Blog werden wir verschiedene Aspekte des Spring-Ökosystems behandeln, darunter Spring Boot, Datenverwaltung, die Erstellung von RESTful-Diensten, Scheduling, Tests und fortgeschrittene Funktionen wie die Spring Advice API.

Spring Boot Framework

Erste Schritte mit Spring Boot

Spring Boot erleichtert die Erstellung eigenständiger, produktionsreifer Spring-basierter Anwendungen. Es bietet eine vorgefasste Sichtweise auf die Spring-Plattform und Drittanbieter-Bibliotheken, sodass Sie mit minimaler Konfiguration beginnen können.

Dependency Injection

Dependency Injection (DI) ist ein Kernprinzip von Spring. Es ermöglicht die Erstellung von lose gekoppelten Komponenten, wodurch Ihr Code modularer und einfacher zu testen wird.

Beispiel für die Feldinjektion:

  @Component
  public class UserService {
      
      @Autowired
      private UserRepository userRepository;
      
      // Geschäftslogik-Methoden
  }

Beispiel für Constructor Injection:

  @Component
  public class UserService {
      
      private final UserRepository userRepository;

      @Autowired
      public UserService(UserRepository userRepository) {
          this.userRepository = userRepository;
      }
      
      // Geschäftslogik-Methoden
  }

Beispiel für Method Injection:

  @Component
  public class UserService {
      
      private UserRepository userRepository;

      @Autowired
      public void setUserRepository(UserRepository userRepository) {
          this.userRepository = userRepository;
      }
      
      // Geschäftslogik-Methoden
  }

    public User findUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

Diese Annotationen machen Ihre Spring-Konfiguration lesbarer und prägnanter, und sie helfen dem Spring-Framework, die Abhängigkeiten zwischen den verschiedenen Beans zu verwalten und zu verbinden.

Ereignisse in Spring

Der Ereignismechanismus von Spring ermöglicht es Ihnen, Anwendungsereignisse zu erstellen und darauf zu reagieren.

public MyCustomEvent(Object source, String message) {
    super(source);
    this.message = message;
}

      public String getMessage() {
          return message;
      }
  }

      @EventListener
      public void handleMyCustomEvent(MyCustomEvent event) {
          System.out.println("Empfange Spring Custom Event - " + event.getMessage());
      }
  }

      public void publishCustomEvent(final String message) {
          System.out.println("Benutzerdefiniertes Ereignis wird veröffentlicht. ");
          MyCustomEvent customEvent = new MyCustomEvent(this, message);
          applicationEventPublisher.publishEvent(customEvent);
      }
  }

Datenverwaltung mit Spring

Spring Data JDBC

Spring Data JDBC bietet einfachen und effektiven JDBC-Zugriff.

Spring Data JPA

Spring Data JPA erleichtert die Implementierung von JPA-basierten Repositories.

Spring Data Redis

Spring Data Redis bietet die Infrastruktur für den Redis-basierten Datenzugriff.

public void save(String key, Object value) {
    redisTemplate.opsForValue().set(key, value);
}

Übersetzung:

public void save(String key, Object value) {
    redisTemplate.opsForValue().set(key, value);
}

Hinweis: Der Code bleibt auf Englisch, da es sich um eine Programmiersprache handelt und die Methodennamen und Schlüsselwörter in der Regel nicht übersetzt werden.

  public Object find(String key) {
      return redisTemplate.opsForValue().get(key);
  }

Transaktionen und DAO-Unterstützung

Spring vereinfacht die Verwaltung von Transaktionen und die Unterstützung von DAO (Data Access Object).

      public User findById(Long id) {
          return jdbcTemplate.queryForObject("SELECT * FROM users WHERE id = ?", new Object[]{id}, new UserRowMapper());     
      }
  }

JDBC und ORM

Spring bietet umfassende Unterstützung für JDBC und ORM (Object-Relational Mapping).

(Die Methode findAll gibt eine Liste aller Benutzer zurück, indem sie eine SQL-Abfrage ausführt und die Ergebnisse mit einem UserRowMapper in User-Objekte umwandelt.)

Erstellung von RESTful Services

Spring REST Clients

Spring bietet eine Vielzahl von Optionen für die Erstellung von REST-Clients, die es Entwicklern ermöglichen, effizient mit RESTful-Webdiensten zu interagieren. Im Folgenden werden einige der wichtigsten Ansätze vorgestellt:

  1. RestTemplate: Dies ist der klassische und am häufigsten verwendete Client in Spring. Er bietet eine einfache und flexible API für das Senden von HTTP-Anfragen und das Verarbeiten von Antworten. RestTemplate unterstützt verschiedene HTTP-Methoden wie GET, POST, PUT, DELETE usw.

    RestTemplate restTemplate = new RestTemplate();
String url = "https://api.example.com/resource";
String response = restTemplate.getForObject(url, String.class);

  2. WebClient: Mit der Einführung von Spring WebFlux wurde WebClient als reaktiver REST-Client eingeführt. Er ist die empfohlene Alternative zu RestTemplate für reaktive Anwendungen und bietet eine nicht-blockierende API.

    WebClient webClient = WebClient.create("https://api.example.com");
Mono<String> response = webClient.get()
    .uri("/resource")
    .retrieve()
    .bodyToMono(String.class);

  3. Feign: Feign ist ein deklarativer REST-Client, der die Erstellung von REST-Clients durch die Verwendung von Annotationen vereinfacht. Er ist besonders nützlich, wenn Sie mit Microservices arbeiten und eine klare, lesbare Schnittstelle wünschen.

    @FeignClient(name = "exampleClient", url = "https://api.example.com")
public interface ExampleClient {
    @GetMapping("/resource")
    String getResource();
}

  4. RestClient: Ab Spring 6.1 gibt es eine neue, vereinfachte API namens RestClient, die eine moderne und benutzerfreundliche Alternative zu RestTemplate bietet. Sie kombiniert die Einfachheit von RestTemplate mit den Vorteilen von WebClient.

    RestClient restClient = RestClient.create();
String response = restClient.get()
    .uri("https://api.example.com/resource")
    .retrieve()
    .body(String.class);

Jeder dieser Clients hat seine eigenen Vor- und Nachteile, und die Wahl des richtigen Clients hängt von den spezifischen Anforderungen Ihres Projekts ab. RestTemplate ist nach wie vor eine gute Wahl für traditionelle Anwendungen, während WebClient und RestClient für moderne, reaktive Anwendungen besser geeignet sind. Feign bietet eine elegante Lösung für die Arbeit mit Microservices.

Spring erleichtert die Erstellung von RESTful-Clients.

FeignClient

Der FeignClient ist ein deklarativer Web-Service-Client, der die Erstellung von REST-Clients in Java-Anwendungen vereinfacht. Er ist Teil des Spring Cloud-Projekts und ermöglicht es Entwicklern, RESTful-Services auf eine einfache und intuitive Weise aufzurufen, ohne sich um die Details der HTTP-Kommunikation kümmern zu müssen.

Mit FeignClient können Sie einfach eine Schnittstelle definieren und mit Annotationen versehen, um die gewünschten REST-Endpunkte zu beschreiben. Feign übernimmt dann die Implementierung der HTTP-Anfragen und die Verarbeitung der Antworten.

Hier ist ein einfaches Beispiel für die Verwendung von FeignClient:

@FeignClient(name = "example-service", url = "https://api.example.com")
public interface ExampleServiceClient {

    @GetMapping("/users/{id}")
    User getUserById(@PathVariable("id") Long id);

    @PostMapping("/users")
    User createUser(@RequestBody User user);
}

In diesem Beispiel wird ein FeignClient namens ExampleServiceClient erstellt, der mit dem Service unter https://api.example.com kommuniziert. Die Methoden getUserById und createUser definieren die REST-Endpunkte, die aufgerufen werden können.

FeignClient ist besonders nützlich in Microservices-Architekturen, wo verschiedene Dienste miteinander kommunizieren müssen. Es reduziert den Boilerplate-Code und macht den Code lesbarer und wartbarer.

Feign ist ein deklarativer Web-Service-Client.

E-Mail, Aufgaben und Terminplanung

E-Mail-Support

Spring bietet Unterstützung für das Versenden von E-Mails.

Aufgabenausführung und -planung

Die Unterstützung von Spring für die Aufgabenausführung und -planung macht es einfach, Aufgaben auszuführen.

Testen in Spring

Testen mit Mockito

Mockito ist eine leistungsstarke Mock-Bibliothek für Tests.

@InjectMocks
private UserService userService;

@Test
public void testFindUserById() {
    User user = new User();
    user.setId(1L);
    Mockito.when(userRepository.findById(1L)).thenReturn(Optional.of(user));
}

          User result = userService.findUserById(1L);
          assertNotNull(result);
          assertEquals(1L, result.getId().longValue());
      }
  }

Testen mit MockMvc

MockMvc ermöglicht es Ihnen, Spring MVC-Controller zu testen.

@Test
public void testGetUser() throws Exception {
    mockMvc.perform(get("/users/1"))
        .andExpect(status().isOk())
        .andExpect(content().contentType(MediaType.APPLICATION_JSON))
        .andExpect(jsonPath("$.id").value(1));
}
}

Überwachung und Verwaltung

Spring Boot Actuator

Spring Boot Actuator ist ein leistungsstarkes Modul, das in Spring Boot-Anwendungen integriert ist und eine Vielzahl von Funktionen zur Überwachung und Verwaltung der Anwendung bereitstellt. Es bietet Endpunkte, die es ermöglichen, den Gesundheitszustand der Anwendung zu überprüfen, Metriken zu sammeln, Umgebungsvariablen anzuzeigen und vieles mehr. Diese Funktionen sind besonders nützlich in Produktionsumgebungen, wo die Überwachung und Verwaltung der Anwendung von entscheidender Bedeutung ist.

Einige der wichtigsten Funktionen von Spring Boot Actuator sind:

  1. Health Checks: Überprüft den Gesundheitszustand der Anwendung und zeigt an, ob sie ordnungsgemäß funktioniert.
  2. Metrics: Sammelt und zeigt verschiedene Metriken an, wie z.B. Speichernutzung, Anzahl der HTTP-Anfragen und vieles mehr.
  3. Environment: Zeigt die aktuellen Umgebungsvariablen und Konfigurationseigenschaften an.
  4. Loggers: Ermöglicht die dynamische Änderung der Log-Level zur Laufzeit.
  5. Mappings: Zeigt alle verfügbaren HTTP-Endpunkte und ihre zugehörigen Handler-Methoden an.

Um Spring Boot Actuator in einer Anwendung zu verwenden, müssen Sie lediglich die entsprechende Abhängigkeit in Ihrer pom.xml (für Maven) oder build.gradle (für Gradle) hinzufügen:

Maven:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Gradle:

implementation 'org.springframework.boot:spring-boot-starter-actuator'

Nachdem Sie die Abhängigkeit hinzugefügt haben, können Sie die Actuator-Endpunkte über HTTP aufrufen. Standardmäßig sind die meisten Endpunkte unter dem Pfad /actuator verfügbar. Zum Beispiel können Sie den Gesundheitszustand der Anwendung über den Endpunkt /actuator/health überprüfen.

Es ist auch möglich, die Sicherheit und Sichtbarkeit der Endpunkte zu konfigurieren, um sicherzustellen, dass nur autorisierte Benutzer Zugriff auf sensible Informationen haben.

Spring Boot Actuator ist ein unverzichtbares Werkzeug für die Überwachung und Verwaltung von Spring Boot-Anwendungen und trägt dazu bei, die Stabilität und Leistung der Anwendung in Produktionsumgebungen zu gewährleisten.

Spring Boot Actuator bietet produktionsreife Funktionen zur Überwachung und Verwaltung Ihrer Anwendung.

Fortgeschrittene Themen

Spring Advice API

Die Spring Advice API ist ein zentraler Bestandteil des Spring Frameworks, der es ermöglicht, zusätzliches Verhalten in die Anwendungslogik einzufügen, ohne den eigentlichen Code zu ändern. Dies wird durch die Verwendung von Aspekten (Aspects) erreicht, die bestimmte Punkte in der Ausführung des Programms (sogenannte Join Points) abfangen und dort zusätzliche Logik ausführen können.

Arten von Advice

In Spring gibt es verschiedene Arten von Advice, die an unterschiedlichen Stellen in der Ausführung eines Programms ausgeführt werden können:

  1. Before Advice: Wird ausgeführt, bevor eine Methode aufgerufen wird.
  2. After Returning Advice: Wird ausgeführt, nachdem eine Methode erfolgreich zurückgekehrt ist.
  3. After Throwing Advice: Wird ausgeführt, wenn eine Methode eine Ausnahme wirft.
  4. After (Finally) Advice: Wird ausgeführt, nachdem eine Methode beendet wurde, unabhängig davon, ob sie erfolgreich war oder eine Ausnahme geworfen hat.
  5. Around Advice: Wird um eine Methode herum ausgeführt und kann die Ausführung der Methode vollständig kontrollieren.

Beispiel für Before Advice

Hier ist ein einfaches Beispiel für die Verwendung von Before Advice in Spring:

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {

    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore() {
        System.out.println("Methode wird aufgerufen...");
    }
}

In diesem Beispiel wird der logBefore-Advice ausgeführt, bevor eine Methode in der com.example.service-Paket aufgerufen wird.

Konfiguration

Um die Advice-API in Spring zu verwenden, müssen Sie sicherstellen, dass die AspectJ-Unterstützung aktiviert ist. Dies kann durch die Annotation @EnableAspectJAutoProxy in einer Konfigurationsklasse erfolgen:

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
    // Weitere Konfigurationen
}

Fazit

Die Spring Advice API bietet eine leistungsstarke Möglichkeit, Cross-Cutting Concerns wie Logging, Sicherheit und Transaktionsmanagement in Ihre Anwendung zu integrieren, ohne den eigentlichen Geschäftslogik-Code zu verändern. Durch die Verwendung von Aspekten können Sie eine saubere und modulare Codebasis beibehalten.

Die Advice API von Spring bietet erweiterte AOP-Fähigkeiten (Aspektorientierte Programmierung).

@After("execution(* com.example.service.*.*(..))")
public void logAfter(JoinPoint joinPoint) {
    System.out.println("Nach der Methode: " + joinPoint.getSignature().getName());
}
}

Fazit

Spring ist ein leistungsstarkes und vielseitiges Framework, das die Entwicklung von Enterprise-Anwendungen vereinfachen kann. Durch die Nutzung der Funktionen von Spring Boot, Spring Data, Spring REST und anderen Spring-Projekten können Entwickler robuste, skalierbare und wartbare Anwendungen effizient erstellen. Mit der Integration von Tools wie Spring Boot Actuator und Testframeworks können Sie sicherstellen, dass Ihre Anwendungen produktionsreif und gut getestet sind.

Back 2025.01.18 Donate