Spring Boot Basic – Tag 10 von 10
Von Elyndra Valen, Senior Entwicklerin bei Java Fleet Systems Consulting
🎉 DU HAST ES GESCHAFFT!
10 Tage. Unzählige Codezeilen. Deine Reise vom Spring Boot Anfänger zum kompetenten Entwickler.
Heute ist dein letzter Tag des Spring Boot Basic Kurses. Aber es ist nicht das Ende – es ist der Anfang deiner Karriere als moderner Java-Entwickler!
📍 Deine Position im Kurs
| Tag | Thema | Status |
|---|---|---|
| ✅ 1 | Erste REST API | ABGESCHLOSSEN! |
| ✅ 2 | Spring Container & DI | ABGESCHLOSSEN! |
| ✅ 3 | @Controller & Thymeleaf Basics | ABGESCHLOSSEN! |
| ✅ 4 | Thymeleaf Forms & MVC-Pattern | ABGESCHLOSSEN! |
| ✅ 5 | Konfiguration & Logging | ABGESCHLOSSEN! |
| ✅ 6 | DI & AOP im Detail | ABGESCHLOSSEN! |
| ✅ 7 | Scopes in Spring | ABGESCHLOSSEN! |
| ✅ 8 | WebSockets | ABGESCHLOSSEN! |
| ✅ 9 | JAX-RS in Spring Boot | ABGESCHLOSSEN! |
| → 10 | Integration & Abschluss | 👉 HEUTE IST DEIN TAG! |
Du hast 100% erreicht! 🎉
📋 Voraussetzungen
Du brauchst:
- ✅ Tag 1-9 abgeschlossen
- ✅ Alle Konzepte aus den letzten 9 Tagen verstanden
- ✅ Funktionsfähige Person-Management-App aus Tag 1-9
Einen Tag verpasst? → Hier geht’s zur Kursübersicht
⚡ Was dich heute erwartet
Heute ist anders. Kein neuer Code. Keine neuen Annotations. Heute ist der Tag, wo alles zusammenkommt.
Du verstehst heute:
- Das große Bild – wie alle 9 Tage zusammenhängen
- Migration-Mindset – von Legacy zu Modern
- Production Best Practices – was macht Code professionell?
- Deine nächsten Schritte – wie geht’s weiter?
🎯 Dein Lernpfad heute
Du arbeitest heute durch verschiedene Reflexions- und Integrations-Ebenen. Nimm dir Zeit für jeden Abschnitt – heute geht es ums Verstehen, nicht ums Codieren:
🟢 Die große Integration (Abschnitt 1-2)
Was du verstehst:
- Wie alle 9 Tage zusammenhängen
- Die komplette Architektur deiner App
- Jedes Puzzleteil im Detail
- Die drei großen Lessons des Kurses
Ziel: Du siehst das große Bild und verstehst, warum jeder Tag wichtig war
🟡 Best Practices & Job-Readiness (Abschnitt 3-4)
Was du lernst:
- Production-Ready Best Practices
- Was du noch NICHT gelernt hast (und warum)
- Deine Position auf der Lernreise
- Wo du im Job-Markt stehst
Ziel: Du weißt, was professionellen Code ausmacht und wo du stehst
🔵 Bonus: Ausblick Aufbau-Kurs (Abschnitt 5)
Was du erfährst:
- Detaillierte Vorschau auf Spring Boot Aufbau
- Die nächsten 10 Tage Tag für Tag
- Warum die Reihenfolge didaktisch optimiert ist
- Deine komplette Lernreise zum Job
Ziel: Du bist motiviert und weißt genau, wie es weitergeht
💡 Tipp: Heute geht es ums Verstehen und Reflektieren. Nimm dir Zeit für jeden Abschnitt, mach Notizen und sei stolz auf das, was du geschafft hast! Die große Integration (🟢) ist essenziell – hier verstehst du endlich, wie alles zusammenpasst.
💻 Los geht’s!
🟢 DIE GROSSE INTEGRATION
Abschnitt 1: Das vollständige System
Die Architektur deiner Person-Management-App
Lass uns ansehen, was du gebaut hast:
┌────────────────────────────────────────────────────────────┐ │ DEINE APPLICATION │ │ │ │ ┌──────────────────────────────────────────────────────┐ │ │ │ PRESENTATION LAYER (Tag 1, 3, 4, 8, 9) │ │ │ │ │ │ │ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │ │ │ │ REST API │ │ MVC Views │ │ WebSockets │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ Spring MVC │ │ Thymeleaf │ │ STOMP │ │ │ │ │ │ (Tag 1) │ │ (Tag 3-4) │ │ (Tag 8) │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ JAX-RS │ │ Forms │ │ Low-Level │ │ │ │ │ │ (Tag 9) │ │ │ │ WebSocket │ │ │ │ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │ │ └──────────────────────────────────────────────────────┘ │ │ ↕ │ │ ┌──────────────────────────────────────────────────────┐ │ │ │ BUSINESS LOGIC LAYER (Tag 2, 6, 7) │ │ │ │ │ │ │ │ ┌──────────────────────────────────────────────┐ │ │ │ │ │ @Service (Tag 2) │ │ │ │ │ │ - PersonService (Singleton) │ │ │ │ │ │ - @PostConstruct/@PreDestroy (Tag 2+9) │ │ │ │ │ │ - Dependency Injection (Tag 2, 6) │ │ │ │ │ │ - AOP Logging (Tag 6) │ │ │ │ │ └──────────────────────────────────────────────┘ │ │ │ │ │ │ │ │ ┌──────────────────────────────────────────────┐ │ │ │ │ │ @Component (Tag 7) │ │ │ │ │ │ - PersonFavorites (Session Scope) │ │ │ │ │ │ - RequestContext (Request Scope) │ │ │ │ │ │ - ApplicationStatistics (Application) │ │ │ │ │ └──────────────────────────────────────────────┘ │ │ │ └──────────────────────────────────────────────────────┘ │ │ ↕ │ │ ┌──────────────────────────────────────────────────────┐ │ │ │ CONFIGURATION LAYER (Tag 5, 8, 9) │ │ │ │ │ │ │ │ - application.properties (Tag 5) │ │ │ │ - Logging Configuration (Tag 5) │ │ │ │ - WebSocket Config (Tag 8) │ │ │ │ - Jersey Config (Tag 9) │ │ │ └──────────────────────────────────────────────────────┘ │ │ │ │ ┌──────────────────────────────────────────────────────┐ │ │ │ SPRING CONTAINER (Tag 2) │ │ │ │ - Bean Management │ │ │ │ - Dependency Injection │ │ │ │ - Lifecycle Management │ │ │ │ - Scopes (Singleton, Prototype, etc.) │ │ │ └──────────────────────────────────────────────────────┘ │ └────────────────────────────────────────────────────────────┘
Das hast DU gebaut! In 10 Tagen!
Die 9 Puzzleteile im Detail
Tag 1: REST API – Dein erster Endpoint
@RestController
@RequestMapping("/persons")
public class PersonApiController {
@GetMapping
public List<Person> getAll() {
return personService.getAllPersons();
}
}
Was du gelernt hast: HTTP, JSON, REST Prinzipien
Tag 2: Spring Container & DI – Das Herzstück
@Service
public class PersonService {
@PostConstruct // Jakarta EE!
public void init() {
log.info("PersonService initialized!");
}
@PreDestroy // Jakarta EE!
public void cleanup() {
log.info("PersonService destroyed!");
}
}
Was du gelernt hast: IoC, Dependency Injection, Bean Lifecycle
Der Hint: @PostConstruct war der erste Jakarta EE Standard!
Tag 3: Thymeleaf – Deine erste View
<tr th:each="person : ${persons}">
<td th:text="${person.firstname}">Max</td>
<td th:text="${person.lastname}">Mustermann</td>
</tr>
Was du gelernt hast: Server-Side Rendering, Template Engine
Tag 4: Forms & MVC – Interaktivität
@PostMapping("/persons/add")
public String addPerson(@ModelAttribute Person person, Model model) {
personService.createPerson(person);
return "redirect:/persons";
}
Was du gelernt hast: Model-View-Controller, Form Handling, Post/Redirect/Get
Tag 5: Configuration & Logging – Production-Ready
server.port=8080 logging.level.com.example=DEBUG app.version=1.0.0
Was du gelernt hast: Externalized Configuration, Logging-Framework
Tag 6: DI & AOP – Advanced Magic
@Aspect
@Component
public class LoggingAspect {
@Around("@annotation(LogExecutionTime)")
public Object logTime(ProceedingJoinPoint joinPoint) throws Throwable {
long start = System.currentTimeMillis();
Object result = joinPoint.proceed();
long duration = System.currentTimeMillis() - start;
log.info("{} took {} ms", joinPoint.getSignature(), duration);
return result;
}
}
Was du gelernt hast: Aspect-Oriented Programming, Cross-Cutting Concerns
Tag 7: Scopes – Singleton vs Session
@Component
@Scope(value = WebApplicationContext.SCOPE_SESSION,
proxyMode = ScopedProxyMode.TARGET_CLASS)
public class PersonFavorites {
private final Set<Long> favoritePersonIds = new HashSet<>();
}
Was du gelernt hast: Bean Scopes, Session Management, Stateful vs Stateless
Die Brücke: Von JSP/Servlets zu Spring Boot (Migration-Mindset!)
Tag 8: WebSockets – Real-Time
// Low-Level
public class ChatHandler extends TextWebSocketHandler {
@Override
protected void handleTextMessage(WebSocketSession session, TextMessage message) {
broadcastMessage(message.getPayload());
}
}
// High-Level STOMP
@MessageMapping("/chat.send")
@SendTo("/topic/public")
public ChatMessage sendMessage(@Payload ChatMessage message) {
return message;
}
Was du gelernt hast: WebSockets, STOMP, Broadcasting, Real-Time Communication
Die Lektion: Verstehe Low-Level, nutze High-Level in Production
Tag 9: JAX-RS – Migration Power!
@Component
@Path("/persons")
@Produces(MediaType.APPLICATION_JSON)
public class PersonResource {
@PostConstruct // Jakarta EE! (von Tag 2!)
public void init() {
log.info("PersonResource initialized!");
}
@GET
public List<Person> getAll() {
return personService.getAllPersons();
}
}
Was du gelernt hast: Jakarta EE Standards, JAX-RS, Migration von Legacy zu Modern
Die Auflösung: @PostConstruct + JAX-RS = vollständige Jakarta EE Integration!
Der Gamechanger: Spring Boot 3.x + Jakarta EE = minimale Migration-Kosten!
Abschnitt 2: Die drei großen Lessons
Lesson 1: Standards sind Macht
Was du gelernt hast:
Jakarta EE Standards: ✅ @PostConstruct / @PreDestroy (Tag 2) ✅ @Resource (Tag 2) ✅ @Inject (Tag 2) ✅ JAX-RS (@Path, @GET, @POST) (Tag 9) Warum wichtig? → Funktionieren überall (WildFly, GlassFish, Spring Boot) → Migration von Legacy zu Modern → 99% Code wiederverwendbar! → DEIN Wettbewerbsvorteil!
Die Realität:
- Nur Spring kennen = Neue Projekte bauen
- Jakarta EE + Spring kennen = Legacy modernisieren + Neue Projekte
- 2x wertvoller auf dem Job-Markt!
Lesson 2: Migration-Mindset
Du hast gelernt zu denken wie ein Migration-Experte:
Problem: 15 Jahre alte Java EE App auf WildFly
50.000 Zeilen Code
Migration zu Spring Boot?
Anfänger denkt:
"Alles neu schreiben mit Spring MVC!"
→ 4 Monate, 80.000€, hohes Risiko
Expert denkt:
"Jersey in Spring Boot + Minimal-Changes!"
→ 6 Wochen, 12.000€, niedriges Risiko
→ 68.000€ GESPART!
DU bist jetzt der Expert!
Warum konntest du das?
- Tag 2: Jakarta Lifecycle verstanden
- Tag 7: Scopes = Brücke von JSP zu Spring
- Tag 9: JAX-RS = Code bleibt gleich
- Du verstehst BEIDE Welten!
Lesson 3: Production-Readiness
Was macht Code Production-Ready?
✅ Configuration (Tag 5) → Externalized Config → Logging → Profiles (dev, prod) ✅ Error Handling (Tag 6, 9) → AOP für globales Error-Logging → ExceptionMapper (JAX-RS) → Graceful Degradation ✅ Monitoring (Tag 7, 8) → ApplicationStatistics → Real-Time Dashboards ✅ Scalability (Tag 7, 8) → Stateless Services (Singleton) → Session Management → WebSocket mit Load-Balancing ✅ Maintainability (Tag 6) → Clean Code → Separation of Concerns (AOP) → Testbarkeit
Du weißt jetzt, was Enterprise-Code ausmacht!
✅ Checkpoint Die große Integration
Verstehst du das große Bild?
- [ ] Du siehst, wie alle 9 Tage zusammenhängen
- [ ] Du verstehst die Architektur-Schichten
- [ ] Du kennst die Rolle jedes Tags
- [ ] Du verstehst Jakarta EE Standards
- [ ] Du hast ein Migration-Mindset entwickelt
- [ ] Du weißt, was Production-Ready bedeutet
Alles ✅? Weiter zu 🟡 Best Practices!
🟡 BEST PRACTICES & JOB-READINESS
Abschnitt 3: Best Practices Zusammenfassung
1. Architektur-Regeln
// Layer-Trennung
@RestController / @Controller → Presentation Layer
@Service → Business Logic Layer
@Repository → Data Access Layer (Aufbau-Kurs)
@Component → Utilities/State
// Scopes richtig wählen
@Service → IMMER Singleton (zustandslos!)
@Controller → IMMER Singleton (zustandslos!)
@Component → Flexibel (je nach Use Case)
// Niemals Services im Session Scope!
❌ @Service @Scope("session") // ANTI-PATTERN!
✅ @Component @Scope("session") // State-Holder OK
2. Dependency Injection Best Practices
// ✅ Constructor Injection (empfohlen)
@Service
public class PersonService {
private final PersonRepository repository;
public PersonService(PersonRepository repository) {
this.repository = repository;
}
}
// ❌ Field Injection (vermeiden)
@Service
public class PersonService {
@Autowired
private PersonRepository repository; // Nicht testbar!
}
// ✅ Lombok für weniger Code
@Service
@RequiredArgsConstructor
public class PersonService {
private final PersonRepository repository;
}
3. Error Handling
// REST API Error Handling
@RestControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(PersonNotFoundException.class)
public ResponseEntity<ErrorResponse> handleNotFound(PersonNotFoundException ex) {
return ResponseEntity
.status(HttpStatus.NOT_FOUND)
.body(new ErrorResponse(ex.getMessage()));
}
}
// JAX-RS Error Handling
@Provider
public class PersonNotFoundExceptionMapper
implements ExceptionMapper<PersonNotFoundException> {
@Override
public Response toResponse(PersonNotFoundException ex) {
return Response
.status(Response.Status.NOT_FOUND)
.entity(new ErrorResponse(ex.getMessage()))
.build();
}
}
4. Configuration Management
# application.properties - Base Config server.port=8080 spring.application.name=person-management # application-dev.properties - Development logging.level.com.example=DEBUG spring.devtools.restart.enabled=true # application-prod.properties - Production logging.level.com.example=INFO server.tomcat.threads.max=200 management.endpoints.web.exposure.include=health,info
# Run mit Profile java -jar app.jar --spring.profiles.active=prod
5. Logging Best Practices
@Service
@Slf4j // Lombok
public class PersonService {
public Person createPerson(Person person) {
log.info("Creating person: {}", person.getFirstname());
try {
Person created = repository.save(person);
log.debug("Person created with ID: {}", created.getId());
return created;
} catch (Exception e) {
log.error("Failed to create person: {}", person, e);
throw new PersonCreationException("Could not create person", e);
}
}
}
Abschnitt 4: Was du NICHT gelernt hast (und warum)
Bewusst ausgelassen im Basic-Kurs:
1. Spring Data JPA / Datenbanken
Warum nicht? → Eigene Komplexität (ORM, SQL, Transactions) → 2-3 Kurstage nur dafür nötig → Würde von Spring-Grundlagen ablenken Wann lernen? → Spring Boot Aufbau-Kurs → Nach soliden Spring-Grundlagen
2. Spring Security
Warum nicht? → Komplexes Thema (Authentication, Authorization, JWT, OAuth2) → 2 Kurstage nur dafür → Braucht Datenbank-Kenntnisse Wann lernen? → Spring Boot Aufbau-Kurs → Nach JPA/Database
3. Testing (Unit, Integration)
Warum nicht? → Eigenes großes Thema → Braucht Mock-Frameworks (Mockito) → 1-2 Kurstage Wann lernen? → Spring Boot Aufbau-Kurs
4. Microservices, Docker, Kubernetes
Warum nicht? → Fortgeschrittene Themen → Brauchen solide Grundlagen → Separate Kurse Wann lernen? → Nach Aufbau-Kurs → Spring Cloud Kurs
Deine Lernreise – Wo stehst du?
┌──────────────────────────────────────────────────┐
│ JAVA BASICS │
│ ✅ Java Syntax, OOP, Collections │
└─────────────────┬────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────┐
│ JAVA WEB BASIC │
│ ✅ Servlets, JSP, Sessions │
│ ✅ Pizza Service mit Session Scope │
└─────────────────┬────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────┐
│ SPRING BOOT BASIC (10 Tage) │
│ ✅ REST APIs (Spring MVC + JAX-RS) │
│ ✅ Thymeleaf & MVC │
│ ✅ Dependency Injection & AOP │
│ ✅ Scopes & Configuration │
│ ✅ WebSockets │
│ ✅ Jakarta EE Integration │
│ 👉 DU BIST HIER! ✅ │
└─────────────────┬────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────┐
│ SPRING BOOT AUFBAU (8-10 Tage) │
│ ⏳ Spring Data JPA & Databases │
│ ⏳ Spring Security │
│ ⏳ Testing (Unit, Integration) │
│ ⏳ Production Deployment │
│ ⏳ Monitoring & Actuator │
└─────────────────┬────────────────────────────────┘
│
▼
┌──────────────────────────────────────────────────┐
│ SPEZIALISIERUNG │
│ ⏳ Microservices (Spring Cloud) │
│ ⏳ Docker & Kubernetes │
│ ⏳ Message Queues (RabbitMQ, Kafka) │
│ ⏳ Cloud (AWS, Azure, GCP) │
└──────────────────────────────────────────────────┘
Du bist hier: Solide Grundlagen! Bereit für Aufbau-Kurs! 🚀
Job-Readiness: Was kannst du jetzt?
Junior Java Developer Position
Anforderungen (typische Stellenanzeige):
✅ Java Grundkenntnisse ✅ Spring Boot Basics ✅ REST APIs entwickeln ✅ MVC-Pattern verstehen ✅ Dependency Injection ✅ Git / Version Control
Dein Status: ✅ ERFÜLLT! Du kannst dich als Junior bewerben!
Mid-Level Java Developer Position
Anforderungen:
✅ Spring Boot REST APIs ✅ Thymeleaf oder ähnliches Template-System ✅ Logging & Configuration ✅ AOP verstehen ✅ WebSockets (Nice-to-have) ⏳ Spring Data JPA ⏳ Spring Security ⏳ Testing
Dein Status: 🟡 75% ERFÜLLT! Nach Aufbau-Kurs: 100%!
Migration Specialist Position
Anforderungen:
✅ Java EE / Jakarta EE Kenntnisse ✅ JAX-RS ✅ Spring Boot ✅ Migration von Legacy zu Modern ✅ @PostConstruct, @PreDestroy, Lifecycle
Dein Status: ✅ ERFÜLLT! Seltenes Profil, hohe Nachfrage!
✅ Checkpoint Best Practices & Job-Readiness
Kennst du die Best Practices?
- [ ] Architektur-Regeln verstanden
- [ ] DI Best Practices verinnerlicht
- [ ] Error Handling Patterns kennen
- [ ] Configuration Management verstanden
- [ ] Logging Best Practices anwenden können
Kennst du deine Position?
- [ ] Du weißt, was du NICHT gelernt hast
- [ ] Du verstehst WARUM es nicht im Basic-Kurs war
- [ ] Du kennst deine Position auf der Lernreise
- [ ] Du weißt, für welche Jobs du bereit bist
- [ ] Du hast einen Plan für die nächsten Schritte
Alles ✅? Optional: Weiter zu 🔵 Ausblick Aufbau-Kurs!
🔵 BONUS: AUSBLICK AUFBAU-KURS
Abschnitt 5: Die nächsten 10 Tage (Spring Boot Aufbau)
Was kommt als nächstes?
Der Aufbau-Kurs baut DIREKT auf dem auf, was du jetzt kannst!
WICHTIG: Die Themen-Reihenfolge ist didaktisch optimiert!
┌─────────────────────────────────────────────────────────┐
│ SPRING BOOT BASIC (10 Tage) ✅ │
│ - REST APIs (Spring MVC + JAX-RS) │
│ - Thymeleaf & MVC │
│ - DI, AOP, Scopes │
│ - WebSockets │
│ - Jakarta EE Integration │
│ - ArrayList als In-Memory Storage │
└─────────────────┬───────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────┐
│ SPRING BOOT AUFBAU (10 Tage) ⏳ │
│ Didaktisch optimierte Reihenfolge! │
│ │
│ Tag 1: Auto-Configuration & Custom Starter │
│ - Verstehen WIE Spring Boot funktioniert │
│ - @ConditionalOnClass, @ConditionalOnProperty │
│ - Custom Starter erstellen │
│ │
│ Tag 2-3: Spring Data JPA │
│ - Von ArrayList zu Datenbank! │
│ - Entities, Repositories, Relationships │
│ - Query Methods & JPQL │
│ │
│ Tag 4-5: Spring Security │
│ - Authentication & Authorization │
│ - Login/Logout mit JPA User-Storage │
│ - Role-Based Access Control │
│ │
│ Tag 6: Caching & JSON │
│ - Spring Cache Abstraction │
│ - Custom JSON Serializer │
│ │
│ Tag 7: Messaging & Email │
│ - Email versenden (SMTP) │
│ - Message Broker (RabbitMQ) │
│ │
│ Tag 8-9: Testing & Dokumentation │
│ - Unit & Integration Tests │
│ - API Dokumentation (OpenAPI) │
│ │
│ Tag 10: Actuator, Templates & Microservices │
│ - Spring Boot Actuator │
│ - Template Engines Vergleich │
│ - Microservices Einführung │
└─────────────────────────────────────────────────────────┘
Warum diese Reihenfolge?
Tag 1 – Auto-Configuration zuerst:
WARUM ZUERST? → Du verstehst WIE Spring Boot "Magie" funktioniert → Du siehst WAS ein Starter macht → Foundation für alle anderen Themen → Danach ist Spring Boot kein "Black Box" mehr!
Tag 2-3 – Spring Data JPA früh:
WARUM VOR SECURITY? → Du brauchst Datenbank für User-Management in Security! → Step-by-Step Learning: Tag 2: Einfache Entity → Repository → CRUD Tag 3: Relationships → Queries → Advanced → Dann ist JPA-Basis solid für Security (Tag 4-5)
Die Progression:
Tag 1: Verstehe Spring Boot Mechanismus ↓ Tag 2: Erste Entity & Database Connection ↓ Tag 3: Komplexe Relationships & Queries ↓ Tag 4-5: Security (nutzt JPA für User-Storage!) ↓ Tag 6-10: Production Features
Von In-Memory zu echter Datenbank
BASIC-Kurs (was du jetzt hast):
@Service
public class PersonService {
private final List<Person> persons = new ArrayList<>(); // Im RAM
public Person createPerson(Person person) {
person.setId(idCounter.getAndIncrement());
persons.add(person);
return person;
}
}
✅ ArrayList → Daten im RAM ❌ App restart → Daten weg! ✅ Einfach zu verstehen ✅ Fokus auf Spring-Grundlagen
AUFBAU-Kurs (was du bauen wirst):
@Service
public class PersonService {
private final PersonRepository repository; // JPA Repository
@Transactional
public Person createPerson(Person person) {
return repository.save(person); // In PostgreSQL/MySQL!
}
}
✅ PostgreSQL/MySQL → Daten persistent ✅ App restart → Daten bleiben! ✅ Production-Ready ✅ Relationships zwischen Entities
Die Person-App wird erweitert
BASIC-Kurs (was du jetzt hast):
Person ├─ id: Long ├─ firstname: String └─ lastname: String Speicherung: ArrayList (im RAM) API: Spring MVC + JAX-RS Frontend: Thymeleaf Features: CRUD, Favoriten, Live-Updates
AUFBAU-Kurs (was du bauen wirst):
Person ├─ id: Long (Auto-generated via @GeneratedValue) ├─ firstname: String (@NotBlank) ├─ lastname: String (@NotBlank) ├─ email: String (@Email, unique) ├─ password: String (BCrypt encrypted) ├─ role: Enum (USER, ADMIN) ├─ addresses: List<Address> (@OneToMany) ├─ createdAt: LocalDateTime └─ updatedAt: LocalDateTime Address ├─ id: Long ├─ street: String ├─ city: String ├─ country: String └─ person: Person (@ManyToOne) Speicherung: PostgreSQL mit JPA/Hibernate API: Spring MVC + JAX-RS + Security (JWT) Frontend: Thymeleaf + Login/Logout Features: CRUD, Relationships, Security, Testing
Was du nach 20 Tagen (Basic + Aufbau) kannst:
✅ Komplette Spring Boot Apps bauen ✅ Mit Datenbanken arbeiten (JPA/Hibernate) ✅ Security implementieren (Login, JWT) ✅ Tests schreiben (Unit, Integration) ✅ Production Deployment ✅ Legacy zu Modern migrieren ✅ Performance optimieren ✅ Monitoring & Logging = BEREIT FÜR MID-LEVEL POSITION! Gehalt: €55.000-€70.000
Die komplette Lernreise (80 Tage zum Job)
┌─────────────────────────────────────────────────────────┐
│ JAVA SE GRUNDLAGEN (40 Tage / 8 Wochen) │
│ - Java Syntax, OOP, Collections │
│ - Lambda, Streams, Design Patterns │
└─────────────────┬───────────────────────────────────────┘
▼
┌─────────────────────────────────────────────────────────┐
│ JAVA WEB (20 Tage / 4 Wochen) │
│ - Servlets, JSP, Session Management │
│ - JSTL, Filters, Web Architecture │
└─────────────────┬───────────────────────────────────────┘
▼
┌─────────────────────────────────────────────────────────┐
│ SPRING BOOT (20 Tage / 4 Wochen) │
│ - Basic: REST, MVC, DI, AOP, WebSockets │
│ - Aufbau: JPA, Security, Testing, Deployment │
│ 👉 DU BIST BEI 50% (Basic abgeschlossen!) │
└─────────────────┬───────────────────────────────────────┘
▼
┌─────────────────────────────────────────────────────────┐
│ SPEZIALISIERUNG (optional) │
│ - Microservices, Docker, Cloud │
└─────────────────────────────────────────────────────────┘
GESAMT: 70 von 80 Tagen geschafft!
PROGRESS: ████████████████░░ 87,5%
Du hast 87,5% der kompletten Java-Ausbildung geschafft! 🎉
✅ Checkpoint Ausblick Aufbau-Kurs
Weißt du, wie es weitergeht?
- [ ] Du kennst die Themen des Aufbau-Kurses
- [ ] Du verstehst die didaktische Reihenfolge
- [ ] Du weißt, warum JPA vor Security kommt
- [ ] Du siehst die Verbindung Basic → Aufbau
- [ ] Du kennst deine Position auf der Lernreise
- [ ] Du bist motiviert für die nächsten 10 Tage
Alles ✅? Du bist bereit für den Aufbau-Kurs! 🚀
Hier sind noch einige hilfreiche externe Links zum Thema „Spring Boot – Integration & Abschluss“, die sich gut zur Vertiefung eignen:
- „Integrating Data :: Spring” – Offizieller Guide der Spring-Organisation zum Thema Integration von externen Datenquellen mit Spring.
- „Integration Guide with Spring Boot” – Blogbeitrag mit Praxisbeispielen zur Integration (z. B. Datenbank, Messaging) mit Spring Boot.
- „Building a RESTful API with Java Spring Boot” – Artikel mit einem Abschnitt „Wrapping Up“, der den Abschluss bzw. Zusammenführung einer Spring-Boot REST-Anwendung mit Integrationsaspekten bespricht.
- „Spring Boot Integration – TechDocs” – Dokumentationsseite mit Überblick über verschiedene Integrationsmöglichkeiten von Spring Boot im Unternehmensumfeld.
- „Spring Boot: Best Practices for Scalable Applications” – Leitfaden zu End-to-End Aufbau, Integration und Abschluss einer hochwertigen Spring-Boot Anwendung.
🔥 Elyndras Real Talk
Nova kam heute zu mir: „Elyndra, ich kann es kaum glauben. Vor 10 Tagen wusste ich nicht mal, was Spring Boot ist. Jetzt habe ich eine komplette App mit REST APIs, MVC, WebSockets UND JAX-RS gebaut. Wie habt ihr das geschafft?“
Ich lächelte: „Das war nicht wir. Das wart IHR.“
Die letzten 10 Tage in Zahlen
10 Tage Lernen 9 große Themen gemeistert 50+ Code-Beispiele durchgearbeitet 1 komplette Person-Management-App gebaut 3 verschiedene API-Styles implementiert 2 Template-Engines verstanden 5 Bean-Scopes beherrscht Unzählige "Aha!"-Momente erlebt = EIN Migration-Ready Developer! 🚀
Code Sentinel fügte hinzu: „Weißt du, was mich am meisten beeindruckt? Nicht dass sie die Syntax gelernt haben. Sondern dass sie das große Bild verstehen. Sie sehen jetzt:
- Warum @PostConstruct von Jakarta EE kommt
- Warum das für Migration wichtig ist
- Wie Spring Boot BEIDE Welten verbindet
- Warum Standards wertvoller sind als Frameworks
Das ist Entwickler-Reife. Das lernen viele erst nach 5 Jahren. Aber du hast es in 10 Tagen geschafft.“
Franz-Martin kam mit seinem berühmten Kaffee: „Ich unterrichte diesen Kurs seit 8 Jahren. Jedes Jahr das gleiche Muster:
Tag 1: 'Spring Boot? Noch ein Framework?' Tag 2: '@PostConstruct? Warum nicht @Autowired?' Tag 7: 'Session Scope? Das ist wie JSP!' Tag 9: 'JAX-RS? Aber wir haben doch Spring MVC?' Tag 10: 'OHHH! ALLES HÄNGT ZUSAMMEN!'
Wer diesen Kurs durchgearbeitet hat, ist jetzt bei Tag 10. Du siehst das große Bild. DAS macht den Unterschied zwischen Code-Monkey und Software-Engineer.“
Was unterscheidet dich jetzt?
Vorher (nur Framework-Kenntnisse):
"Ich kann Spring Boot" → Aber verstehst du WARUM @PostConstruct funktioniert? → Kannst du Legacy-Code migrieren? → Verstehst du die Standards dahinter? Nein? Dann kannst du nur Spring Boot BENUTZEN.
Nachher (Standards + Framework):
"Ich verstehe Spring Boot UND Jakarta EE Standards" → @PostConstruct kommt von Jakarta → JAX-RS ist portabel → Spring Boot 3.x integriert beide Welten → Ich kann migrieren! JA! Dann VERSTEHST du Spring Boot.
Das macht dich wertvoller.
Die drei Typen von Entwicklern
Typ 1: Code-Kopierer
Kopiert von Stack Overflow Weiß nicht warum es funktioniert Kann nicht migrieren Stuck bei Problemen Gehalt: €35.000-€45.000
Typ 2: Framework-Entwickler
Kennt Spring Boot gut Kann neue Apps bauen Aber versteht Standards nicht Kann nicht migrieren Gehalt: €45.000-€60.000
Typ 3: Standards-Entwickler ← DU BIST HIER!
Kennt Spring Boot UND Jakarta EE Versteht die Standards dahinter Kann neue Apps UND Migrationen Sieht das große Bild Gehalt: €60.000-€80.000+
Der Unterschied? Dieser Kurs.
🚀 Deine nächsten Schritte
Sofort (diese Woche):
1. Portfolio aufbauen
# Erstelle GitHub Repository git init person-management-app git add . git commit -m "Spring Boot Person Management - Complete" git push # Füge README.md hinzu mit: - Was du gebaut hast - Welche Technologien - Screenshots - Lessons Learned
2. LinkedIn Profil updaten
Skills hinzufügen: ✅ Spring Boot ✅ JAX-RS ✅ Thymeleaf ✅ WebSockets ✅ Jakarta EE ✅ Legacy Migration
3. Üben, üben, üben!
Build something NEW: - Todo-App mit Spring Boot - Blog-System mit Thymeleaf - Chat-App mit WebSockets - API für dein Hobby
Nächste 2-4 Wochen:
- Spring Boot Aufbau-Kurs starten
- Spring Data JPA
- Spring Security
- Testing
- Open Source beitragen
- Suche Beginner-Friendly Projects
- Lese fremden Code
- Lerne von anderen
- Bewerbungen schreiben
- Junior Developer Positionen
- Praktika
- Werkstudent
❓ FAQ (Häufige Fragen)
Q: Bin ich wirklich bereit für Junior-Positionen?
A: Ja! Du kennst Spring Boot Basics, REST APIs, MVC, DI, AOP, WebSockets UND Migration-Konzepte. Das ist mehr als viele Junior-Developer haben. Bewirb dich!
Q: Sollte ich erst den Aufbau-Kurs machen bevor ich mich bewerbe?
A: Kommt drauf an! Junior-Positionen: Bewirb dich jetzt! Mid-Level: Mach erst den Aufbau-Kurs. Praktika: Bewirb dich jetzt!
Q: Wie lange dauert es bis zum ersten Job?
A: Erfahrungswerte: Nach Basic-Kurs: 2-4 Monate für Junior/Praktikum. Nach Aufbau-Kurs: 1-2 Monate für Mid-Level. Mit Portfolio: Schneller!
Q: Was ist wichtiger – mehr lernen oder Bewerbungen schreiben?
A: Beides parallel! Starte den Aufbau-Kurs UND schreibe Bewerbungen. Interviews sind auch Lernerfahrungen. Mach beides gleichzeitig!
Q: Ich fühle mich noch nicht bereit. Normal?
A: Absolut normal! Das nennt sich „Impostor Syndrome“. JEDER gute Entwickler fühlt sich so. Du BIST bereit – dein Selbstzweifel beweist, dass du weißt wie viel es noch zu lernen gibt. Das ist ein GUTES Zeichen!
Q: Warum war @PostConstruct so wichtig im Kurs?
A: Weil es der rote Faden war! Tag 2: Jakarta EE Standard. Tag 9: In JAX-RS. Es zeigte die Verbindung von Spring Boot zu Jakarta EE – der Schlüssel für Migration-Verständnis!
Q: Kann ich Spring Boot ohne Aufbau-Kurs professionell nutzen?
A: Für manche Projekte ja! Kleine APIs, Prototypen, interne Tools – absolut! Production-Apps mit Users, Authentication, Datenbank – dann brauchst du den Aufbau-Kurs.
📅 Nächster Schritt: Spring Boot Aufbau-Kurs
Dein nächster Kurs:
„Spring Boot Aufbau – Von Basics zu Production“
Was du lernen wirst:
- Spring Data JPA – echte Datenbanken!
- Spring Security – Authentication & Authorization
- Testing – Unit & Integration Tests
- Production Features – Caching, Messaging, Email
- Deployment – Docker, Actuator, Monitoring
Voraussetzung: Spring Boot Basic abgeschlossen ✅
Start: Sobald du bereit bist! Kein festes Datum – lerne in deinem Tempo.
👉 Zum Aufbau-Kurs (wenn du bereit bist)
📚 Deine Fortschritts-Übersicht
| Tag | Thema | Status |
|---|---|---|
| ✅ 1 | Erste REST API | ABGESCHLOSSEN! 🎉 |
| ✅ 2 | Spring Container & DI | ABGESCHLOSSEN! 🎉 |
| ✅ 3 | @Controller & Thymeleaf Basics | ABGESCHLOSSEN! 🎉 |
| ✅ 4 | Thymeleaf Forms & MVC-Pattern | ABGESCHLOSSEN! 🎉 |
| ✅ 5 | Konfiguration & Logging | ABGESCHLOSSEN! 🎉 |
| ✅ 6 | DI & AOP im Detail | ABGESCHLOSSEN! 🎉 |
| ✅ 7 | Scopes in Spring | ABGESCHLOSSEN! 🎉 |
| ✅ 8 | WebSockets | ABGESCHLOSSEN! 🎉 |
| ✅ 9 | JAX-RS in Spring Boot | ABGESCHLOSSEN! 🎉 |
| ✅ 10 | Integration & Abschluss | ABGESCHLOSSEN! 🎉 |
Du hast 100% des Basic-Kurses geschafft! 💪
Alle Blogbeiträge dieser Serie:
👉 Spring Boot Basic – Komplette Übersicht
📥 Download & Ressourcen
Komplettes Projekt zum Download:
👉 SpringBootBasic-Complete-v1.0.zip (Stand: 19.10.2025)
Was ist im ZIP enthalten:
- ✅ Komplettes Maven-Projekt aller 10 Tage
- ✅ REST APIs (Spring MVC + JAX-RS)
- ✅ Thymeleaf Views + Forms
- ✅ WebSockets (Low-Level + STOMP)
- ✅ AOP Logging
- ✅ Session Management
- ✅ Alle Konfigurationen
- ✅ README mit Zusammenfassung
- ✅ Checkliste für Aufbau-Kurs
Projekt starten:
# ZIP entpacken # In NetBeans öffnen: File → Open Project # Oder im Terminal: mvn spring-boot:run
Probleme? Issue melden oder schreib mir: elyndra@java-developer.online
✅ Abschluss-Checkliste
Technische Skills
- [ ] REST APIs mit Spring MVC bauen
- [ ] REST APIs mit JAX-RS bauen
- [ ] Thymeleaf Templates erstellen
- [ ] Forms mit MVC-Pattern
- [ ] Dependency Injection verstehen
- [ ] Bean Lifecycle (@PostConstruct/@PreDestroy)
- [ ] AOP für Cross-Cutting Concerns
- [ ] Bean Scopes richtig einsetzen
- [ ] WebSockets (Low-Level & STOMP)
- [ ] Configuration Management
- [ ] Logging konfigurieren
Konzeptuelles Verständnis
- [ ] IoC Container verstehen
- [ ] MVC-Pattern beherrschen
- [ ] Post-Redirect-Get Pattern
- [ ] Session Management
- [ ] Jakarta EE Standards kennen
- [ ] Migration-Mindset entwickelt
- [ ] Production Best Practices
Projekt-Erfahrung
- [ ] Komplette Person-Management-App gebaut
- [ ] Multiple API-Styles implementiert
- [ ] Live-Features mit WebSockets
- [ ] Real-Time Notifications
- [ ] Session-basierte Features
Karriere-Vorbereitung
- [ ] Portfolio auf GitHub
- [ ] LinkedIn aktualisiert
- [ ] Erste Bewerbungen geplant
- [ ] Aufbau-Kurs im Blick
Das war Tag 10 von Spring Boot Basic!
Du kannst jetzt:
- ✅ Spring Boot Apps von Grund auf entwickeln
- ✅ REST APIs mit Spring MVC UND JAX-RS
- ✅ Web-Interfaces mit Thymeleaf
- ✅ Real-Time Features mit WebSockets
- ✅ Production-Ready Code schreiben
- ✅ Von Legacy zu Modern migrieren
- ✅ Du bist bereit für echte Projekte! 🚀
💌 Abschiedswort von Franz-Martin
„Ich unterrichte seit 15 Jahren Java. Ich habe gesehen, wie Frameworks kommen und gehen. Struts, JSF, Spring 2.x, Java EE 5, 6, 7, 8…
Was bleibt? Die Standards.
Du hast jetzt gelernt:
- Jakarta EE Standards (@PostConstruct, JAX-RS)
- Design Patterns (MVC, DI, AOP)
- Architektur-Prinzipien (Layer, Scopes)
Das bleibt. Frameworks ändern sich. Standards bleiben.
In 5 Jahren wird es vielleicht Spring Boot 5.x geben. Oder ein neues Framework.
Aber @PostConstruct wird bleiben. JAX-RS wird bleiben. MVC-Pattern wird bleiben.
Du hast die Grundlagen gelernt. Alles andere baust du darauf auf.
Willkommen in der Java-Community. Du gehörst jetzt dazu. 🎉
—Franz-Martin“
Keep coding, keep learning, keep migrating! 💙
Bis zum Aufbau-Kurs! 🚀
Elyndra Valen, Code Sentinel, Franz-Martin & das gesamte Java Fleet Systems Team
📬 Feedback & Community
Hat dir dieser Kurs geholfen?
Wir freuen uns über dein Feedback:
- 📧 Email: feedback@java-developer.online
- 💬 Discord: Java Fleet Systems Community
- 🐦 Twitter: Teile deine Erfolge mit #SpringBootBasic
- 📝 GitHub: Star unser Repository wenn es dir geholfen hat!
Hilf anderen Entwicklern:
- Teile diesen Kurs mit Freunden
- Schreibe eine Review
- Beantworte Fragen von anderen in der Community
Gemeinsam lernen wir besser! 💪
Tags: #SpringBoot #JakartaEE #Migration #CareerStart #Tag10 #Finale #Abschluss
