Annotationen in Java sind Metadaten, die Informationen über die
Struktur eines Programms bereitstellen. Sie haben keinen direkten
Einfluss auf die Ausführung des Codes, können aber zur Laufzeit oder
während der Kompilierungsphase von Werkzeugen und Frameworks verwendet
werden, um spezifisches Verhalten zu implementieren oder zu ändern.
Annotationen werden durch ein vorangestelltes At-Zeichen
(@) gekennzeichnet und können an Deklarationen von Klassen,
Methoden, Variablen, Parametern und sogar anderen Annotationen
angebracht werden.
Annotationen in Java werden vor dem Element platziert, das sie
annotieren sollen. Ein einfaches Beispiel ist die
@Override-Annotation, die angibt, dass die darunterliegende
Methode eine Methode der Basisklasse oder eines implementierten
Interfaces überschreibt.
@Override
public String toString() {
return "Beispielklasse";
}Zur Definition einer eigenen Annotation verwendet man das
@interface-Keyword gefolgt vom Namen der Annotation.
Annotationen können optional mit Elementen ausgestattet werden, die wie
Methodendeklarationen aussehen, jedoch keine Parameter enthalten und
keine Ausnahmen werfen dürfen.
public @interface MeineAnnotation {
String beschreibung() default "Standardbeschreibung";
int wert();
}In diesem Beispiel definiert MeineAnnotation zwei
Elemente: beschreibung, mit einem Standardwert, und
wert, ohne Standardwert, was bedeutet, dass es beim
Verwenden der Annotation angegeben werden muss.
Eigene Annotationen werden angewendet, indem man sie vor das zu annotierende Element setzt und, falls erforderlich, Werte für ihre Elemente bereitstellt.
@MeineAnnotation(beschreibung = "Eine spezifische Beschreibung", wert = 10)
public void meineMethode() {
// Code hier
}Im Spring Framework werden Annotationen intensiv genutzt, um Dependency Injection, Transaktionsmanagement, Konfiguration und andere Aspekte der Anwendungsentwicklung zu vereinfachen. Einige der häufigsten Spring-Annotationen umfassen:
@Component: Kennzeichnet eine Klasse als Bean, die vom
Spring Container verwaltet wird.@Service, @Repository,
@Controller: Spezialisierungen von @Component
für bestimmte Schichten in einer Anwendung.@Autowired: Markiert eine Abhängigkeit, die vom Spring
Container injiziert werden soll.@RequestMapping: Kennzeichnet eine Methode, die eine
HTTP-Anfrage an einen Pfad in einer Controller-Klasse behandelt.Die Verwendung von Annotationen im Spring Framework erleichtert die Konfiguration und das Management von Java-Anwendungen erheblich, indem es eine deklarative Methode zur Definition der Anwendungslogik und -infrastruktur bietet.
Um eine Spring-Anwendung ohne Spring Boot zu starten, müssen Sie mehrere Schritte manuell durchführen, die Spring Boot typischerweise automatisiert. Folgendes ist erforderlich:
Zunächst müssen Sie die erforderlichen Spring Framework-Bibliotheken
zu Ihrem Projekt hinzufügen. Dies kann durch Hinzufügen der
Abhängigkeiten in Ihrer pom.xml (für Maven-Projekte) oder
build.gradle (für Gradle-Projekte) geschehen. Sie benötigen
mindestens spring-context für den IoC-Container.
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.x</version> <!-- Ersetzen Sie x mit der neuesten Unterversion -->
</dependency>
</dependencies>Definieren Sie Ihre Beans und die Anwendungskonfiguration. Dies kann
über XML-Konfigurationsdateien, Annotationen in einer
@Configuration-Klasse oder eine Kombination aus beidem
erfolgen.
@Configuration
public class AppConfig {
@Bean
public MeinService meinService() {
return new MeinServiceImpl();
}
}In Ihrer Hauptklasse oder am Einstiegspunkt Ihrer Anwendung müssen
Sie eine Instanz von ApplicationContext initialisieren, die
Ihre Bean-Konfigurationen lädt. Dieser Schritt ist entscheidend, da
hierdurch der Spring Container gestartet wird, der Ihre Beans
verwaltet.
public class Hauptklasse {
public static void main(String[] args) {
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
MeinService service = context.getBean(MeinService.class);
service.ausfuehren(); // Ihre Geschäftslogik hier ausführen
}
}Nachdem der ApplicationContext initialisiert wurde,
können Sie Beans aus dem Container abrufen und verwenden. Beans können
über ihre ID oder den Klassentyp abgerufen werden. Die Nutzung von
Dependency Injection (z.B. mit @Autowired) ist ebenfalls
möglich, erfordert jedoch, dass die entsprechenden Klassen vom Spring
Container verwaltet werden.
Diese Schritte bilden die Grundlage für die Erstellung einer Spring-Anwendung ohne Spring Boot. Während Spring Boot viele Konfigurationen und Initialisierungen automatisiert, bietet Ihnen das manuelle Setup von Spring mehr Kontrolle und Flexibilität über Ihre Anwendungskonfiguration und den Initialisierungsprozess.
Wenn Sie für OAuth 2.0 Keycloak als Identity und Access Management-Lösung verwenden möchten, können Sie Spring Security zusammen mit Keycloak nutzen, um eine sichere Authentifizierung und Autorisierung in Ihrer Spring-Anwendung zu implementieren. Hier ist ein grundlegender Leitfaden, wie Sie dabei vorgehen können:
Zuerst müssen Sie Keycloak installieren und konfigurieren. Dies beinhaltet das Einrichten eines Keycloak-Servers, das Erstellen eines Realms für Ihre Anwendung und das Konfigurieren von Clients und Benutzerrollen innerhalb dieses Realms. Die Keycloak-Dokumentation bietet ausführliche Anleitungen zur Installation und Einrichtung.
Fügen Sie die erforderlichen Abhängigkeiten zu Ihrem Spring
Boot-Projekt hinzu, um Spring Security und die Keycloak-Adapter zu
integrieren. In Ihrer pom.xml könnten diese Abhängigkeiten
etwa so aussehen:
<dependencies>
<!-- Spring Boot Starter Security -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<!-- Keycloak Spring Boot Adapter -->
<dependency>
<groupId>org.keycloak</groupId>
<artifactId>keycloak-spring-boot-starter</artifactId>
<version>IhreKeycloakVersion</version>
</dependency>
</dependencies>Stellen Sie sicher, dass Sie die passende Version des Keycloak-Starters verwenden, die mit Ihrer Keycloak-Server-Version kompatibel ist.
Konfigurieren Sie Keycloak in Ihrer Spring Boot-Anwendung durch
Hinzufügen der entsprechenden Konfigurationswerte in die
application.properties oder application.yml.
Sie müssen mindestens die Adresse Ihres Keycloak-Servers, den
Realm-Namen und die Client-Konfiguration angeben.
keycloak.auth-server-url=http://localhost:8080/auth
keycloak.realm=IhrRealm
keycloak.resource=clientId
keycloak.credentials.secret=clientSecret
keycloak.bearer-only=trueErstellen Sie eine Sicherheitskonfigurationsklasse, die von
KeycloakWebSecurityConfigurerAdapter erbt, um die
Sicherheitseinstellungen anzupassen. Dies könnte beispielsweise so
aussehen:
@Configuration
@EnableWebSecurity
public class SecurityConfig extends KeycloakWebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
super.configure(http);
http
.authorizeRequests()
.antMatchers("/admin/*").hasRole("ADMIN")
.anyRequest().permitAll();
}
// Weitere Konfiguration ...
}Diese Konfiguration stellt sicher, dass nur Benutzer mit der Rolle
ADMIN Zugriff auf Pfade unter /admin/
haben.
Stellen Sie sicher, dass Sie in Keycloak Benutzer und Rollen entsprechend den Sicherheitsanforderungen Ihrer Anwendung konfigurieren. Diese Rollen werden dann in der Sicherheitskonfiguration Ihrer Spring-Anwendung verwendet.
Nachdem Sie alles konfiguriert haben, starten Sie Ihre Spring Boot-Anwendung. Sie sollten nun in der Lage sein, sich mit den Benutzeranmeldedaten, die in Keycloak konfiguriert sind, zu authentifizieren. Die Authentifizierung erfolgt über Keycloak, und Ihre Anwendung verwendet die von Keycloak bereitgestellten Tokens, um den Zugriff zu kontrollieren.
Das Integrieren von Keycloak mit Spring Security bietet eine robuste Lösung für das Management von Authentifizierungen und Autorisierungen, die leicht skaliert und an komplexe Anwendungsfälle angepasst werden kann.