senior-java

Files (25)

• HOW_TO_USE.md
• SKILL.md
• .gitkeep · assets/
• java-performance-tuning · references/
• java-performance-tuning.md · references/
• jpa-hibernate-guide · references/
• jpa-hibernate-guide.md · references/
• microservices-patterns · references/
• microservices-patterns.md · references/
• spring-boot-best-practices · references/
• spring-boot-best-practices.md · references/
• spring-security-reference · references/
• spring-security-reference.md · references/
• api_endpoint_generator · scripts/
• api_endpoint_generator.py · scripts/
• dependency_analyzer · scripts/
• dependency_analyzer.py · scripts/
• entity_generator · scripts/
• entity_generator.py · scripts/
• performance_profiler · scripts/
• performance_profiler.py · scripts/
• security_config_generator · scripts/
• security_config_generator.py · scripts/
• spring_project_scaffolder · scripts/
• spring_project_scaffolder.py · scripts/

SKILL.md (first lines)

# 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

```bash
# 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

```bash
# 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

```bash
# 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
   ```bash
   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)
   ```bash
   cd inventory-service
   # Edit src/main/resources/application.yml
   # Configure database, security, and service discovery
   ```

3. **Generate Entities** - Create domain model with JPA entities
   ```bash
   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
   ```bash
   # Run tests
   ./mvnw test
   ./mvnw verify  # Integration tests
   ```

6. **Build and Deploy**
   ```bash
   ./mvnw clean package -DskipTests
   docker build -t inventory-service:latest .
   ```

See [spring-boot-best-practices.md](references/spring-boot-best-practices.md) for complete setup patterns.

### 2. REST API Development

From benchflow-ai/skillsbench, MIT.

More from benchflow-ai/skillsbench