---

=== CORE IDENTITY ===

name: senior-java title: Senior Java Skill Package description: World-class Java and Spring Boot development skill for enterprise applications, microservices, and cloud-native systems. Expertise in Spring Framework, Spring Boot 3.x, Spring Cloud, JPA/Hibernate, and reactive programming with WebFlux. Includes project scaffolding, dependency management, security implementation, and performance optimization. domain: engineering subdomain: java-development

=== WEBSITE DISPLAY ===

difficulty: advanced time-saved: "60%+ on project scaffolding, 40% on security implementation" frequency: "Daily for enterprise development teams" use-cases:

• Building enterprise Spring Boot applications with production-ready configuration
• Designing microservices with Spring Cloud and service discovery
• Implementing JPA/Hibernate data layers with optimized queries
• Setting up Spring Security with OAuth2 and JWT authentication
• Performance tuning JVM applications and reactive WebFlux systems

=== RELATIONSHIPS ===

related-agents: [cs-java-engineer] related-skills: [senior-backend, senior-architect] related-commands: [] orchestrated-by: [cs-java-engineer]

=== TECHNICAL ===

dependencies: scripts: [spring_project_scaffolder.py, dependency_analyzer.py, entity_generator.py, api_endpoint_generator.py, security_config_generator.py, performance_profiler.py] references: [spring-boot-best-practices.md, microservices-patterns.md, jpa-hibernate-guide.md, spring-security-reference.md, java-performance-tuning.md] assets: [] compatibility: "Python 3.8+; platforms: macos, linux, windows" tech-stack:

• Java 17/21 LTS
• Spring Boot 3.x
• Spring Framework 6.x
• Spring Cloud
• Spring Security
• Spring Data JPA
• Hibernate ORM
• Maven/Gradle
• JUnit 5
• Mockito
• Docker
• Kubernetes

=== EXAMPLES ===

examples:

• title: "Spring Boot Project Scaffolding" input: "python scripts/spring_project_scaffolder.py my-service --type microservice --db postgresql" output: "Complete Spring Boot 3.x project with layered architecture, Docker setup, and CI/CD pipeline"
• title: "Entity Generation" input: "python scripts/entity_generator.py User --fields 'id:Long,email:String,name:String,createdAt:LocalDateTime'" output: "JPA entity with repository, service, controller, and DTO classes"

=== ANALYTICS ===

stats: downloads: 0 stars: 0 rating: 0.0 reviews: 0

=== VERSIONING ===

version: v1.0.0 author: Claude Skills Team contributors: [] created: 2025-12-16 updated: 2025-12-16 license: MIT

=== DISCOVERABILITY ===

tags:

• java
• spring-boot
• spring-framework
• microservices
• jpa
• hibernate
• spring-cloud
• webflux
• enterprise
• cloud-native
• maven
• gradle
• api
• backend featured: false verified: true

---

Senior Java

World-class Java and Spring Boot development skill for enterprise applications, microservices, and cloud-native systems. Expertise in Spring Framework, Spring Boot 3.x, Spring Cloud, JPA/Hibernate, and reactive programming with WebFlux.

Overview

This skill provides production-ready Java and Spring Boot development capabilities through six Python automation tools and comprehensive reference documentation. Whether building enterprise monoliths, microservices architectures, or reactive systems, this skill ensures best practices, scalable architecture, and enterprise-grade security.

What This Skill Provides:

• Spring Boot project scaffolding with layered architecture
• JPA entity and repository generation with optimized queries
• RESTful API endpoint scaffolding with proper error handling
• Spring Security configuration (OAuth2, JWT, RBAC)
• Dependency analysis and upgrade recommendations
• JVM performance profiling and optimization guidance

Use this skill when:

• Starting new Spring Boot projects or microservices
• Implementing JPA/Hibernate data layers
• Designing RESTful APIs with Spring MVC or WebFlux
• Setting up authentication and authorization
• Optimizing JVM and application performance
• Reviewing Java code for quality and patterns

Core Value: Save 60%+ time on project scaffolding while ensuring enterprise-grade architecture, security compliance, and performance optimization.

Core Capabilities

• Spring Boot Scaffolding - Generate production-ready Spring Boot 3.x projects with layered architecture, Docker configuration, and CI/CD pipelines
• Entity Generation - Create JPA entities with repositories, services, controllers, DTOs, and mappers following DDD patterns
• API Development - Scaffold RESTful endpoints with validation, error handling, pagination, and OpenAPI documentation
• Security Implementation - Configure Spring Security with OAuth2, JWT, role-based access control, and security best practices
• Dependency Management - Analyze dependencies for vulnerabilities, outdated versions, and upgrade paths
• Performance Optimization - Profile JVM applications, identify bottlenecks, and generate optimization recommendations

Quick Start

Create Spring Boot Project

# Create microservice with PostgreSQL
python scripts/spring_project_scaffolder.py order-service --type microservice --db postgresql

# Create monolith with MySQL and security
python scripts/spring_project_scaffolder.py ecommerce-app --type monolith --db mysql --security oauth2

# Create reactive WebFlux service
python scripts/spring_project_scaffolder.py notification-service --type reactive --db mongodb

Generate JPA Entity

# Generate complete entity stack (entity, repository, service, controller, DTO)
python scripts/entity_generator.py Product --fields "id:Long,name:String,price:BigDecimal,category:String,createdAt:LocalDateTime"

# Generate with relationships
python scripts/entity_generator.py Order --fields "id:Long,customer:Customer,items:List<OrderItem>,total:BigDecimal" --relations "customer:ManyToOne,items:OneToMany"

Analyze Dependencies

# Check for vulnerabilities and updates
python scripts/dependency_analyzer.py pom.xml --check-security

# Generate upgrade report
python scripts/dependency_analyzer.py build.gradle --output report.md

Access Documentation

• Spring Boot patterns: references/spring-boot-best-practices.md
• Microservices design: references/microservices-patterns.md
• JPA/Hibernate guide: references/jpa-hibernate-guide.md
• Security reference: references/spring-security-reference.md
• Performance tuning: references/java-performance-tuning.md

Key Workflows

1. New Spring Boot Microservice

Time: 30-45 minutes

1. Scaffold Project - Generate microservice with Spring Boot 3.x, Docker, and CI/CD

   python scripts/spring_project_scaffolder.py inventory-service --type microservice --db postgresql --security jwt
   

2. Configure Environment - Set up application.yml with profiles (dev, staging, prod)

   cd inventory-service
   # Edit src/main/resources/application.yml
   # Configure database, security, and service discovery
   

3. Generate Entities - Create domain model with JPA entities

   python scripts/entity_generator.py Inventory --fields "id:Long,productId:Long,quantity:Integer,warehouse:String"
   python scripts/entity_generator.py InventoryMovement --fields "id:Long,inventory:Inventory,quantity:Integer,type:MovementType,timestamp:LocalDateTime"
   

4. Implement Business Logic - Add service layer logic and validation rules

5. Add Tests - Generate unit and integration tests

   # Run tests
   ./mvnw test
   ./mvnw verify  # Integration tests
   

6. Build and Deploy

   ./mvnw clean package -DskipTests
   docker build -t inventory-service:latest .
   

See spring-boot-best-practices.md for complete setup patterns.

2. REST API Development

Time: 20-30 minutes per endpoint group

1. Design API Contract - Define endpoints following REST conventions

   python scripts/api_endpoint_generator.py products --methods GET,POST,PUT,DELETE --paginated
   

2. Implement Validation - Add Jakarta validation annotations and custom validators

3. Configure Error Handling - Set up global exception handler with problem details (RFC 7807)

4. Add OpenAPI Documentation - Configure SpringDoc for automatic API docs

5. Test Endpoints - Generate integration tests with MockMvc or WebTestClient

See spring-boot-best-practices.md for API design patterns.

3. JPA/Hibernate Optimization

Time: 1-2 hours for complex data models

1. Analyze Current Queries - Profile repository methods for N+1 problems

   python scripts/performance_profiler.py --analyze-queries src/
   

2. Optimize Fetch Strategies - Configure lazy/eager loading appropriately

3. Add Query Hints - Implement entity graphs and query hints for complex queries

4. Configure Caching - Set up Hibernate second-level cache with Hazelcast or Redis

5. Implement Pagination - Use Spring Data's Slice or Page for large datasets

See jpa-hibernate-guide.md for optimization patterns.

4. Spring Security Implementation

Time: 1-2 hours

1. Generate Security Config - Create security configuration for chosen auth method

   python scripts/security_config_generator.py --type jwt --roles ADMIN,USER,MANAGER
   

2. Configure OAuth2/JWT - Set up token generation, validation, and refresh

3. Implement RBAC - Add role-based access control to endpoints

4. Add Method Security - Configure @PreAuthorize and @PostAuthorize annotations

5. Test Security - Generate security integration tests

See spring-security-reference.md for security patterns.

Python Tools

spring_project_scaffolder.py

Generate production-ready Spring Boot project structures with complete configuration.

Key Features:

• Spring Boot 3.x with Java 17/21 support
• Multiple project types (microservice, monolith, reactive)
• Database configuration (PostgreSQL, MySQL, MongoDB, H2)
• Docker and Docker Compose setup
• GitHub Actions CI/CD pipeline
• Layered architecture (controller, service, repository)
• Lombok and MapStruct integration

Common Usage:

# Microservice with PostgreSQL and JWT security
python scripts/spring_project_scaffolder.py user-service --type microservice --db postgresql --security jwt

# Monolith with MySQL and OAuth2
python scripts/spring_project_scaffolder.py ecommerce --type monolith --db mysql --security oauth2

# Reactive service with MongoDB
python scripts/spring_project_scaffolder.py notification-service --type reactive --db mongodb

# Help
python scripts/spring_project_scaffolder.py --help

entity_generator.py

Generate complete JPA entity stacks with repository, service, controller, and DTO.

Key Features:

• JPA entity with Lombok annotations
• Spring Data JPA repository with custom queries
• Service layer with transaction management
• REST controller with validation
• DTO and mapper (MapStruct)
• Relationship support (OneToMany, ManyToOne, ManyToMany)

Common Usage:

# Basic entity
python scripts/entity_generator.py Customer --fields "id:Long,name:String,email:String"

# Entity with relationships
python scripts/entity_generator.py Order --fields "id:Long,customer:Customer,total:BigDecimal" --relations "customer:ManyToOne"

# Entity with audit fields
python scripts/entity_generator.py Product --fields "id:Long,name:String,price:BigDecimal" --auditable

# Help
python scripts/entity_generator.py --help

api_endpoint_generator.py

Scaffold RESTful API endpoints with validation and documentation.

Key Features:

• CRUD endpoint generation
• Request/response DTOs
• Jakarta validation annotations
• OpenAPI annotations
• Pagination supp