INOTEQ GmbH

**keycloak-demo**

@Path("/hello")
public class ExampleResource {

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {
        return "Hello from Quarkus REST";
    }
}
public class EmailMasking {
    public static void main(String[] args) {
        String email = "john.doe@example.com";

        // Erstelle eine Maskierung für die EMail
        StringBuilder maskedEmail = new StringBuilder();
        maskedEmail.append(email.substring(0, 3));
        maskedEmail.append("*".repeat(email.length() - 6));
        maskedEmail.append(email.substring(email.length() - 3))

        // Maskierte EMail: joh**************com
        System.out.println("Maskierte Email: " + maskedEmail.toString());
    }
}
public class EmojiUsageAnalyzer {
    public static void main(String[] args) {
        String message = "Hallo 😀! Wie geht's dir heute? 😊";

        int emojiCount = countEmojis(message);

        // Anzahl der Emojis in der Nachricht: 2
        System.out.println("Anzahl der Emojis in der Nachricht: " + emojiCount);
    }

    public static int countEmojis(String text) {
        int count = 0;
        int length = text.length();

        for (int i = 0; i < length;) {
            int codePoint = text.codePointAt(i);
            if (Character.isEmoji(codePoint)) {
                count++;
            }
            i += Character.charCount(codePoint);
        }

        return count;
    }
}
public class SliderControl {
    public static void main(String[] args) {
        int sliderPosition = 150; // Beispielwert für die Position des Schiebereglers
        int minPosition = 0;
        int maxPosition = 100;

        // Begrenze die Position des Schiebereglers auf den Bereich [minPosition, maxPosition]
        int clampedPosition = Math.clamp(sliderPosition, minPosition, maxPosition);

        // Begrenzte Position des Schiebereglers: 100
        System.out.println("Begrenzte Position des Schiebereglers: " + clampedPosition);
    }
}
sealed interface Animal {
    String getName();
}

final class Cat implements Animal { /* ... */ }

final class Dog implements Animal { /* ... */ }

// Alternative
sealed interface Animal permits Cat, Dog { ... }

sealed interface Shape {}

final class Circle implements Shape {
    double radius;
    Circle(double radius) { this.radius = radius; }
}

final class Rectangle implements Shape {
    double length, width;
    Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }
}

final class Square implements Shape {
    double side;
    Square(double side) { this.side = side; }
}

public class Main {
    public static void main(String[] args) {
        Shape shape = new Circle(5.0);
        String result = switch (shape) {
            case Circle c -> "Kreis mit Radius " + c.radius;
            case Rectangle r -> "Rechteck mit Länge " + r.length + " und Breite " + r.width;
            case Square s -> "Viereck mit Breite " + s.side;
        };
        // Kreis mit Radius 5
        System.out.println(result);
    }
}
public record Point(int x, int y) {}

public class Main {
    public static void main(String[] args) {
        Point point = new Point(10, 20);
        String result = switch (point) {
            case Point(int x, int y) -> "Punkt bei (" + x + ", " + y + ")";
        };
        // Punkt bei (10, 20)
        System.out.println(result);
    }
}
public record Rectangle(Point topLeft, Point bottomRight) {}

public class Main {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle(new Point(0, 0), new Point(10, 20));
        String result = switch (rectangle) {
            case Rectangle(Point(int x1, int y1), Point(int x2, int y2)) -> 
                "Rechteck von (" + x1 + ", " + y1 + ") bis (" + x2 + ", " + y2 + ")";
        };
        // Rechteck von (0, 0) bis (10, 20)
        System.out.println(result);
    }
}
import java.util.ArrayList;
import java.util.List;

public class TraditionalThreadExample {
    public static void main(String[] args) throws InterruptedException {
        int numberOfThreads = 10000;
        List threads = new ArrayList<>();

        for (int i = 0; i < numberOfThreads; i++) {
            Thread thread = new Thread(() -> {
                try {
                    // Simuliert eine Netzwerkantwort
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            threads.add(thread);
        }

        long startTime = System.currentTimeMillis();
        for (Thread thread : threads) {
            thread.start();
        }
        for (Thread thread : threads) {
            thread.join();
        }
        long endTime = System.currentTimeMillis();

        // Herkömmliche Threads: 5548 ms
        System.out.println("Herkömmliche Threads: " + (endTime - startTime) + " ms");
    }
}

import java.util.ArrayList;
import java.util.List;

public class VirtualThreadExample {
    public static void main(String[] args) throws InterruptedException {
        int numberOfThreads = 10000;
        List threads = new ArrayList<>();

        for (int i = 0; i < numberOfThreads; i++) {
            Thread thread = Thread.ofVirtual().start(() -> {
                try {
                    // Simuliert eine Netzwerkantwort
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            threads.add(thread);
        }

        long startTime = System.currentTimeMillis();
        for (Thread thread : threads) {
            thread.join();
        }
        long endTime = System.currentTimeMillis();

        // Virtuelle Threads: 1032 ms
        System.out.println("Virtuelle Threads: " + (endTime - startTime) + " ms");
    }
}

try (var es = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10000; i++) { es.submit(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
    }
}
dependencies {
    ...
    testImplementation 'org.springframework.boot:spring-boot-starter-test:3.2.2'
    testImplementation 'com.microsoft.playwright:playwright:1.41.1'
}

...

tasks.named('test') {
    useJUnitPlatform()
}

import ...

@SpringBootTest(
    classes = [DemoApplication::class],
    webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT
)
class DemoTest {
    companion object {
        // Playwright setup
        private var playwright: Playwright? = null
        private var browser: Browser? = null
        private var context: BrowserContext? = null
        private var page: Page? = null

        @JvmStatic
        @BeforeAll
        fun launchBrowser() {
            playwright = Playwright.create()

            browser = playwright?.chromium()?.launch(
                // Run playwright in headed mode with slow motion to see what's happening
                BrowserType.LaunchOptions().setHeadless(false).setSlowMo(100.0)
            )
        }

        @JvmStatic
        @AfterAll
        fun closeBrowser() {
            playwright?.close()
        }
    }

    @BeforeEach
    fun createContextAndPage() {
        context = browser?.newContext()
        page = context?.newPage()
    }

    @AfterEach
    fun closeContext() {
        context?.close()
    }
}

@Test
fun publicEndpointTest() {
    page?.navigate("http://localhost:8080/public")
    assertThat(page?.locator("body")).hasText("Hello from a public endpoint!")
}

@Test
fun privateEndpointTest() {
    // Unable to access private endpoint without logging in and redirects to login page
    page?.navigate("http://localhost:8080/private")

    // Login with example user 'John Doe' by filling the login form and submitting it
    page?.fill("#username", "john.doe")
    page?.fill("#password", "password")
    page?.locator("input[type=submit]")?.click()
    // Wait for redirect to previously requested private endpoint
    page?.waitForURL("http://localhost:8080/private?continue")

    // Check for expected content on private endpoint
    assertThat(page?.locator("body")).hasText("Hello from a private endpoint!")
}
companion object {
    // Start a Keycloak instance with an import file for the demo realm
    @JvmStatic
    private val keycloakContainer = KeycloakContainer().apply {
        withRealmImportFile("realm.json")
        portBindings = listOf("8081:8080")
        start()
    }

    // Register the Keycloak issuer URL as a dynamic property for the Spring Boot application
    @JvmStatic
    @DynamicPropertySource
    private fun registerResourceServerIssuerProperty(registry: DynamicPropertyRegistry) {
        registry.add("spring.security.oauth2.client.provider.demo-provider.issuer-uri") {
            "${keycloakContainer.authServerUrl}/realms/demo-realm"
        }
    }

    ...

    @JvmStatic
    @BeforeAll
    fun launchBrowser() {
        playwright = Playwright.create()
        browser = playwright?.chromium()?.launch() // Use headless mode
    }

   ...
}
image: mcr.microsoft.com/playwright/java:v1.41.0-jammy

services:
  - name: docker:dind
    command: [ "--tls=false" ]

variables:
  DOCKER_HOST: "tcp://docker:2375"
  DOCKER_TLS_CERTDIR: ""
  DOCKER_DRIVER: overlay2

before_script:
  - GRADLE_USER_HOME="$(pwd)/.gradle"
  - export GRADLE_USER_HOME

stages:
  - test

tests:
  stage: test
  script:
    - ./gradlew test

Running with gitlab-runner 14.7.0 (98daeee0)
  on gitlab-runner-01 y7AkGoZD
Preparing the "docker" executor 00:34
...
Preparing environment 00:00
...
Getting source from Git repository 00:02
...
Executing "step_script" stage of the job script 03:52
Using docker image sha256:df9599e540016f99fbcd1d862224ae9d1cf30df17fa5d367c969ee37cc060afb for mcr.microsoft.com/playwright/java:v1.41.0-jammy with digest mcr.microsoft.com/playwright/java@sha256:390fdf6801be59dd7bc6a3fad6344ae9d795b6585d102af293b57d61076d0824 ...
$ GRADLE_USER_HOME="$(pwd)/.gradle"
$ export GRADLE_USER_HOME
$ ./gradlew test
Downloading https://services.gradle.org/distributions/gradle-8.5-bin.zip
............10%.............20%............30%.............40%.............50%............60%.............70%.............80%............90%.............100%
Welcome to Gradle 8.5!
Here are the highlights of this release:
 - Support for running on Java 21
 - Faster first use with Kotlin DSL
 - Improved error and warning messages
For more details see https://docs.gradle.org/8.5/release-notes.html
Starting a Gradle Daemon (subsequent builds will be faster)
> Task :checkKotlinGradlePluginConfigurationErrors
> Task :processResources
> Task :processTestResources
> Task :compileKotlin
> Task :compileJava NO-SOURCE
> Task :classes
> Task :compileTestKotlin
> Task :compileTestJava NO-SOURCE
> Task :testClasses
> Task :test
OpenJDK 64-Bit Server VM warning: Sharing is only supported for boot loader classes because bootstrap classpath has been appended
Deprecated Gradle features were used in this build, making it incompatible with Gradle 9.0.
You can use '--warning-mode all' to show the individual deprecation warnings and determine if they come from your own scripts or plugins.
For more on this, please refer to https://docs.gradle.org/8.5/userguide/command_line_interface.html#sec:command_line_warnings in the Gradle documentation.
BUILD SUCCESSFUL in 3m 50s
6 actionable tasks: 6 executed
Cleaning up project directory and file based variables 00:01
Job succeeded
public class Task {
    private int id;
    private String description;
    private int priority;

    public Task(int id, String description, int priority) {
        this.id = id;
        this.description = description;
        this.priority = priority;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getDescription() {
        return description;
    }

    public void setPriority(int priority) {
        this.priority = priority;
    }

    public float getPriority() {
        return priority;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = Integer.hashCode(this.id) * prime;
        result = prime * result + Integer.hashCode(this.priority);
        result = prime * result + ((this.description == null) ? 0 : this.description.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object var1) {
        if (this != var1) {
            if (var1 instanceof Task) {
                Task var2 = (Task) var1;
                if (this.id == var2.id
                  && Intrinsics.areEqual(this.description, var2.description)
                  && this.priority == var2.priority) {
                    return true;
                }
            }
            return false;
        } else {
            return true;
        }
    }

    @Override
    public String toString() {
        return "Task [id=" + id + ", description=" + description + ", priority=" + priority + "]";
    }
}
data class Task(
    var id: Int,
    var description: String,
    var priority: Int
)
public final String[] listOfNames = new String[]{"Alice", "Bob", "Mallory"}
listOfNames.forEach { name -> println(name) }
val listOfNames = listOf("Alice", "Bob", "Mallory")
listOfNames.forEach { println(it) }
public final String name = null
System.out.println(name.length) // NullPointerException
val name: String? = null
println(name?.length) // null
...
dependencies {
    ...

    implementation 'org.springframework.boot:spring-boot-starter-thymeleaf:3.2.0'
}
...

    Index

ignored

myIndexText=This is index!
package com.example.demo

import org.springframework.stereotype.Controller
import org.springframework.ui.Model
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.RequestMapping

@Controller
@RequestMapping
class DemoController {
    @GetMapping("/")
    fun myIndexEndpoint(model: Model): String {
        return "index"
    }
}

...
@Controller
@RequestMapping
class DemoController {
    @GetMapping("/")
    fun myIndexEndpoint(model: Model): String {
        model.addAttribute("myEndpoints", listOf("foo", "bar", "baz"))
        return "index"
    }

    @GetMapping("/foo")
    fun fooEndpoint(): String = "foo"

    @GetMapping("/bar")
    fun barEndpoint(): String = "bar"

    @GetMapping("/baz")
    fun bazEndpoint(): String = "baz"
}

myIndexText=This is index!
myNavigateText=Navigate to {0}
myFooText=This is foo!
myBarText=This is bar!
myBazText=This is baz!

...

...

    ignored

...

    Foo

ignored

    Bar

ignored

    Baz

ignored

...
plugins {
    ...
    // Gradle plugin for Node
    id 'com.github.node-gradle.node' version '7.0.1'
}
...
// Necessary for node-gradle plugin
node {
    download = true
}

// This task will run `tailwindcss` command and generate the output.css file from styles.css
tasks.register('tailwind', NpxTask) {
    command = 'tailwindcss'
    args = ['-i', './src/main/resources/static/styles.css', '-o', './src/main/resources/static/output.css']

    // This task depends on npmInstall task
    dependsOn(tasks.npmInstall)
}

// Make npmInstall task depend on npmSetup task and adds package.json as input
tasks.npmInstall {
    inputs.file('package.json')
    dependsOn(tasks.npmSetup)
}

tasks.withType(KotlinCompile).configureEach {
    ...
    // Update the output.css file every time after compiling Kotlin code
    dependsOn(tasks.tailwind)
}
...

/** @type {import('tailwindcss').Config} */
module.exports = {
    content: ["./src/**/*.{html,js}"],
}
{
  "devDependencies": {
    "@tailwindcss/forms": "^0.5.7",
    "tailwindcss": "^3.3.6"
  }
}
@tailwind base;
@tailwind components;
@tailwind utilities;

body {
    @apply bg-gray-200 w-full p-4 flex flex-col gap-4 items-center justify-center;
}

.headline {
    @apply text-4xl font-extrabold leading-none tracking-tight;
}

.headline-white {
    @apply text-white;
}

.btn {
    @apply font-bold py-2 px-4 rounded;
}
.btn-blue {
    @apply bg-blue-500 text-white;
}
.btn-blue:hover {
    @apply bg-blue-700;
}

    Index

ignored

    ignored

    Foo

ignored

    Bar

ignored

    Baz

ignored

package com.example.demo

import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration
import org.springframework.boot.runApplication

// Deaktivierung der default Authentifizierung von Spring Security
@SpringBootApplication(exclude = [SecurityAutoConfiguration::class])
class DemoApplication

fun main(args: Array) {
    runApplication(*args)
}

package com.example.demo

import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RestController

@RestController
class DemoController {
    @RequestMapping("/")
    fun helloWorld() = "Hello World!"
}

package com.example.demo

import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RestController

@RestController
class DemoController {
    @RequestMapping("/", "/public")
    fun publicEndpoint() = "Hello from a public endpoint!"

    @RequestMapping("/private")
    fun privateEndpoint() = "Hello from a private endpoint!"
}

docker run -p 8081:8080 -e KEYCLOAK_ADMIN=admin -e KEYCLOAK_ADMIN_PASSWORD=admin quay.io/keycloak/keycloak start-dev
spring:
  security:
    oauth2:
      client:
        provider:
          # provider name used for registration
          demo-provider:
            # Keycloak realm URL: "{keycloak-url}/realms/{realm-name}"
            issuer-uri: http://localhost:8081/realms/demo-realm
        registration:
          # client-id from Keycloak client configuration
          demo-client:
            # provider from above
            provider: demo-provider
            # client-id from Keycloak client configuration
            client-id: demo-client
            scope: openid
            # default redirect URI: "{baseUrl}/login/oauth2/code/{registrationId}"
            redirect-uri: http://localhost:8080/login/oauth2/code/demo-client

package com.example.demo

import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.security.config.Customizer
import org.springframework.security.config.annotation.web.builders.HttpSecurity
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity
import org.springframework.security.web.SecurityFilterChain

@Configuration
@EnableWebSecurity
class SecurityConfiguration {
    @Bean
    fun securityFilterChain(http: HttpSecurity): SecurityFilterChain =
        http
            .authorizeHttpRequests {
                it
                    // Only allow authenticated users here
                    .requestMatchers("/private/**")
                    .fullyAuthenticated()
                    // Allow all other requests
                    .anyRequest()
                    .permitAll()
            }
            // Use OAuth 2.0 Login to handle authentication
            .oauth2Login(Customizer.withDefaults())
            .build()
}

...
@RequestMapping("/private/user")
    fun userEndpoint(): String {
        val user = SecurityContextHolder.getContext().authentication.principal as OAuth2User
        return "Name: ${user.attributes["name"]}, " +
            "Email: ${user.attributes["email"]}, " +
            "Roles: ${user.attributes["roles"]}"
    }
...
> brew install node
> npm install -g @angular/cli
> ng version
     _                      _                 ____ _     ___
    / \   _ __   __ _ _   _| | __ _ _ __     / ___| |   |_ _|
   / △ \ | '_ \ / _` | | | | |/ _` | '__|   | |   | |    | |
  / ___ \| | | | (_| | |_| | | (_| | |      | |___| |___ | |
 /_/   \_\_| |_|\__, |\__,_|_|\__,_|_|       \____|_____|___|
                |___/

Angular CLI: 9.1.0
Node: 12.16.1
OS: win32 x64

> ng new todo-app
? Would you like to add Angular routing? Yes
? Which stylesheet format would you like to use? CSS
...

todo-app/                               # App-Verzeichnis
├── e2e/                                # Hier werden End-to-End-Tests implementiert
├── node_modules/                       # Beinhaltet alle installierten Node.js-Module für das Projekt
├── src/                                # Beinhaltet die Implementierung der App
│   ├── app/                            # In diesem Ordner werden die Komponente, Services, etc, abgelegt
│   │   ├── app-routin.module.ts        # Konfiguration der Navigationsrouten innerhalb der App (welche Komponente ist für welche URL zuständig)
│   │   ├── app.component.css           # CSS-Styles, welche ausschließlich für die aktuelle Komponente gültig sind
│   │   ├── app.component.html          # HTML-Template-Code, welche beim Ausführen der Komponente angezeigt wird
│   │   ├── app.component.spec.ts       # Unit-Tests für die Komponente
│   │   ├── app.component.ts            # "Code-Behind"-Datei, welche die Business-Logik der Komponente beinhaltet
│   │   └── app.module.ts               # Root-Konfigurations-Datei der App, in welcher alle verwendeten Node.js-Module, App-Komponente, etc. registriert werden
│   ├── assets/                         # Beinhaltet Dateien wie Bilder
│   ├── environments/
│   │   ├── environment.prod.ts         # Konfigurationsdatei für den produktiven Betrieb
│   │   └── environment.ts              # Konfigurationsdatei für das Entwickeln
│   ├── ...
│   ├── index.html                      # Root-Datei, welche Aufgerufen wird, wenn der Anwender die SAP aufruft
│   ├── main.ts                         # Einstiegspunkt für die App (Muss in der Regel nicht geändert werden)
│   └── styles.css                      # Datei für globale CSS-Regeln, welche für die gesamte App gelten
├── ...
├── angular.json                        # Konfiguration des Projektes, welche u.a. z.B. die Build-Konfigurationen beinhaltet
└── package.json                        # Konfigurationsdatei, welche angibt, welche Node.js-Module in welcher Version verwendetet werden

> npm install --save bootstrap jquery popper.js

{
  "projects": {
    "todo-app": {
      "architect": {
        "build": {
          "options": {
            "styles": [
              "src/styles.css",
              "node_modules/bootstrap/dist/css/bootstrap.min.css"
            ],
            "scripts": [
              "node_modules/jquery/dist/jquery.min.js",
              "node_modules/popper.js/dist/umd/popper.min.js",
              "node_modules/bootstrap/dist/js/bootstrap.min.js"
            ]
          }
        }
      }
    }
  }
}

> ng serve --open

> ng generate component task-list

CREATE src/app/task-list/task-list.component.html (24 bytes)
CREATE src/app/task-list/task-list.component.spec.ts (643 bytes)
CREATE src/app/task-list/task-list.component.ts (286 bytes)
CREATE src/app/task-list/task-list.component.css (0 bytes)
UPDATE src/app/app.module.ts (485 bytes)

            {{ task.name }}

        High
        Middle
        Low

import { Component, OnInit } from '@angular/core';

import { TaskService } from '../task.service';

@Component({
  selector: 'app-task-list',
  templateUrl: './task-list.component.html',
  styleUrls: ['./task-list.component.css']
})
export class TaskListComponent implements OnInit {
  tasks;

  constructor(private taskService: TaskService) { }

  ngOnInit(): void {
    this.taskService.getTasks()
      .subscribe(tasks => (this.tasks = tasks));
  }
}

// ...

import { RouterModule } from '@angular/router';

// ...

@NgModule({
  // ...
  imports: [

    // ...   

    RouterModule.forRoot([
      { path: '', component: TaskListComponent }
    ])
  ],
  // ... 
})
// ...

import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';

import { Observable } from 'rxjs';

import { Task } from './task';

@Injectable({
  providedIn: 'root'
})
export class TaskService {

  baseUrl = 'https://exmaple.com/api';  // URL to web api

  constructor(
    private http: HttpClient) {}

  /** GET tasks from the server */
  getTasks (): Observable {
    return this.http.get(`${this.baseUrl}/task`);
  }

}
// ...
import { HttpClientModule } from '@angular/common/http';

// ...

@NgModule({
  // ...
  imports: [
    // ...   
    BrowserModule,
    AppRoutingModule,
    ReactiveFormsModule,
    FormsModule,
    HttpClientModule,
    // ...   
  ],
  // ... 
})
// ...

> ng build --prod

Generating ES5 bundles for differential loading...
ES5 bundle generation complete.

chunk {0} runtime-es2015.1eba213af0b233498d9d.js (runtime) 1.45 kB [entry] [rendered]
chunk {0} runtime-es5.1eba213af0b233498d9d.js (runtime) 1.45 kB [entry] [rendered]
chunk {2} polyfills-es2015.690002c25ea8557bb4b0.js (polyfills) 36.1 kB [initial] [rendered]
chunk {3} polyfills-es5.9e286f6d9247438cbb02.js (polyfills-es5) 129 kB [initial] [rendered]
chunk {1} main-es2015.af5b6cb4ca52ef1efbf6.js (main) 376 kB [initial] [rendered]
chunk {1} main-es5.af5b6cb4ca52ef1efbf6.js (main) 456 kB [initial] [rendered]
chunk {4} styles.66057ddcee1a0c134465.css (styles) 146 kB [initial] [rendered]
chunk {scripts} scripts.4f7d6bdd9aa2a2ef7f2f.js (scripts) 165 kB [entry] [rendered]
Date: 2020-04-16T13:22:11.289Z - Hash: c755857ecfed044fd8c0 - Time: 43419ms

      org.springframework.boot
      spring-boot-starter-oauth2-resource-server

    implementation 'org.springframework.boot:spring-boot-starter-oauth2-resource-server'

public class Person {
    public String name;
    public String lastName;

   // ... constructor, getters and setters
}

@RestController
@RequestMapping("/people")
public class PeopleController {
    private List<Person> people = Arrays.asList(Person("foo", "bar"), Person("baz", "bar"));

    @GetMapping("/")
    public ResponseEntity<List<Person>> getAllPeople() {
        return new ResponseEntity(people, HttpStatus.OK);
    } 

    @PostMapping
    public ResponseEntity addPerson(@RequestBody person) {
        people.add(person);
        return new ResponseEntity(HttpStatus.OK);
    }
}

@Configuration
public class AppConf implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                .allowedOrigins("http://example.com")
                .allowedMethods("GET", "POST", "PUT", "DELETE");
    }
}

spring:
  security:
    oauth2:
      resourceserver:
        jwt:
          issuer-uri: http://example-authorization-server.com/keys

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        // allows CORS preflight checks to succeed
        http.cors()

            .and()
                .authorizeRequests()
                .antMatchers("/admin/*")
                .hasRole("ADMIN")
            .and()
                .authorizeRequests()
                .anyRequest()
                .authenticated()
            .and()               
                .sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            .and()
                .oauth2ResourceServer()
                .jwt();
    }
}

   @Test
    void userIsNotAuthenticated_whenGetPeople_thenFail() {
        String token = getToken();

        Response response = RestAssured.given()
                .header(HttpHeaders.AUTHORIZATION, "Bearer " + token)
                .get("http://localhost:8081/people/");

        assertThat(response.statusCode()).isEqualTo(HttpStatus.SC_UNAUTHORIZED);
    }

    @Test
    void userIsAuthenticated_whenGetPeople_thenSucceed() {
        String token = getToken();

        Response response = RestAssured.given()
                .header(HttpHeaders.AUTHORIZATION, "Bearer " + token)
                .get("http://localhost:8081/people/");

        assertThat(response.as(List.class).isEmpty()).isFalse();
    }

@Configuration
@EnableGlobalMethodSecurity(
        prePostEnabled = true,
        securedEnabled = true,
        jsr250Enabled = true)
public class MethodSecurityConfig
        extends GlobalMethodSecurityConfiguration {
}

@Secured({ "ROLE_ADMIN", "ROLE_MEMBER" })
public String getMembershipId(String userId) {
    return userRepository.getMembershipId(userId);
}

@PreAuthorize("hasRole('ROLE_ADMIN') or hasRole('ROLE_MEMBER')")
public String getMembershipId(String userId) {
     //...
}

INOTEQ GmbH

Effiziente Java-Anwendungsentwicklung mit Quarkus und GraalVM

Effiziente Java-Anwendungsentwicklung mit Quarkus und GraalVM

Table of Contents

Quarkus und GraalVM im Überblick

Quarkus: Ein Java-Framework für Cloud-native Workloads

GraalVM: Eine virtuelle Maschine der nächsten Generation

Quarkus und GraalVM gemeinsam: Synergieeffekte

Unterschiede im Entwicklungsprozess

Build Time Optimierung und Laufzeit-Effizienz

Speicherauslastung

Entwicklungsumgebung und Tools

Testing und Debugging

Bereitstellung und Skalierung in Cloud-Umgebungen

Integration von Spring mit GraalVM

Beispiel: Erstellen eines Quarkus-Projekts mit GraalVM

Native Images von GraalVM

Erstellung von Native Images

Vor- und Nachteile von Native Images

Best Practices für die Erstellung von Native Images

Entwicklungstrends

Integration von Künstlicher Intelligenz und Machine Learning

Zukunftsausblick

Fazit

Java 21: Ein kurzer Überblick über die wichtigsten Neuerungen

Java 21: Ein kurzer Überblick über die wichtigsten Neuerungen

Table of Contents

API Updates

Math- und String-basierte APIs

String Methoden

Character Methoden

Math Methoden

Sequenced Collections

Deprecations

Pattern Matching und Record Patterns

Sealed Interfaces

Pattern Matching in Switch-Anweisungen

Record Patterns

Virtual Threads

Grundlagen von Virtual Threads

Vergleich von Threads

Vorteile und Best Practices

Zusammenfassung

Automatisches Front-End-Testing einer OAuth 2.0 Spring-Boot Anwendungen

Automatisches Front-End-Testing einer OAuth 2.0 Spring-Boot Anwendungen

Table of Contents

Keycloak für die Testumgebung

Realm-Export mit Benutzern

Playwright Frontend Tests

Konfiguration

Beispieltests

Keycloak Testcontainer

GitLab Pipeline

Fazit

Referenzierte Artikel

Kotlin vs. Java im Praxischeck: Ein Spring Boot Erfahrungsbericht

Kotlin vs. Java im Praxischeck: Ein Spring Boot Erfahrungsbericht

Table of Contents

Grundlegende Unterschiede

Kotlin in der Industrie und Community

Kotlin in der Praxis

Gemeinsamkeiten und Interoperabilität

Nachteile von Kotlin

Vorteile von Kotlin

Kotlin im Spring Boot Projekt: Eine strategische Entscheidung

Fazit und persönliche Meinung

Entwicklung einer Spring Boot-Anwendung mit Thymeleaf und Tailwind CSS

Entwicklung einer Spring Boot-Anwendung mit Thymeleaf und Tailwind CSS

Inhaltsverzeichnis

Setup von Spring Boot

Integration von Thymeleaf

Thymeleaf-Templates

ignored

Spring Boot Controller

Erweiterung des Beispiels mit weiteren Thymeleaf Funktionen

ignored

ignored

ignored

Styling mittels Tailwind CSS

Verwendung des Gradle Plugin für Node und Konfiguration von Tailwind CSS

Sichern einer Spring Boot WebApp mit OAuth 2.0

Sichern einer Spring Boot WebApp mit OAuth 2.0