Traditional Approach:
maven pom.xml → mvn clean package → java -jar app.jar
(Takes 30+ seconds)

Spring Boot CLI:
spring run app.groovy
(Takes 2-3 seconds!)

Use Cases:
CLI: Quick prototyping, experimenting, single-file apps
Maven/Gradle: Production apps, complex builds, CI/CD

# Install Spring Boot CLI
brew tap pivotal/tap
brew install springboot

# Verify installation
spring --version
# Output: Spring Boot v3.2.1

# Upgrade to latest version
brew upgrade springboot

# Install SDKMAN first
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"

# Install Spring Boot CLI
sdk install springboot

# List available versions
sdk list springboot

# Install specific version
sdk install springboot 3.2.1

# Use specific version
sdk use springboot 3.2.1

# Verify
spring --version

# Download from: https://repo.spring.io/release/org/springframework/boot/spring-boot-cli/

# Extract to: C:\Program Files\spring-boot-cli

# Add to PATH:
# C:\Program Files\spring-boot-cli\bin

# Verify in PowerShell
spring --version

# Run Spring Boot CLI in Docker
docker run -it --rm \
  -v $(pwd):/workspace \
  -w /workspace \
  openjdk:17 \
  /bin/bash -c "
    curl -s https://raw.githubusercontent.com/spring-projects/spring-boot/main/spring-boot-cli/install.sh | bash
    spring --version
  "

# Show help
spring --help
spring help

# Show version
spring --version

# Help for specific command
spring help create
spring help run
spring help test

# Create project interactively
spring project create --name my-app

# Create with options
spring create --build maven \
              --java-version 17 \
              --language java \
              --packaging jar \
              my-web-app

# List available project types
spring project list

# Run a JAR file
spring run app.jar

# Run a Groovy script
spring run app.groovy

# Run with arguments
spring run app.groovy -- --server.port=9000

# Run with JVM options
spring run app.groovy -Xmx512m -Xms256m

# Watch for changes and restart (like DevTools)
spring run app.groovy --watch

# Create a simple Groovy app
mkdir my-app && cd my-app
touch app.groovy

// app.groovy - Complete Spring Boot app in one file!

@RestController
class HelloController {

    @GetMapping("/")
    String hello() {
        "Hello from Spring Boot CLI!"
    }

    @GetMapping("/api/time")
    LocalDateTime currentTime() {
        LocalDateTime.now()
    }
}

@SpringBootApplication
class Application {}

# Run it!
spring run app.groovy

# App is now running on http://localhost:8080
# curl http://localhost:8080
# Output: Hello from Spring Boot CLI!

# With auto-reload
spring run app.groovy --watch

# Modify app.groovy, save, and app reloads automatically!

// src/main/groovy/Application.groovy
@SpringBootApplication
class Application {}

// src/main/groovy/UserController.groovy
@RestController
@RequestMapping("/api/users")
class UserController {

    @GetMapping
    List<String> list() {
        ["user1", "user2", "user3"]
    }

    @PostMapping
    void create(@RequestBody String username) {
        println "Creating user: $username"
    }
}

// src/main/groovy/AppConfig.groovy
@Configuration
class AppConfig {

    @Bean
    fun messageService() {
        // Return service
    }
}

# Run the whole project
spring run src/main/groovy/**/*.groovy

# Or simpler
spring run src/main/groovy/Application.groovy

# Interactive project creation
spring project create --name demo-project

# This guides you through:
# 1. Project name
# 2. Build tool (Maven/Gradle)
# 3. Language (Java/Kotlin/Groovy)
# 4. Spring Boot version
# 5. Dependencies to include

# Result: Complete Maven/Gradle project
cd demo-project
mvn spring-boot:run

// Complete web app in one file!

@RestController
class BookController {

    private List<String> books = [
        "Spring in Action",
        "Effective Java",
        "Clean Code"
    ]

    @GetMapping("/books")
    List<String> list() {
        books
    }

    @PostMapping("/books")
    void addBook(@RequestBody String title) {
        books << title
    }

    @DeleteMapping("/books/{id}")
    void deleteBook(@PathVariable int id) {
        if (id >= 0 && id < books.size()) {
            books.remove(id)
        }
    }
}

// Automatically started as Spring Boot app!

// These imports happen automatically:
// import org.springframework.boot.autoconfigure.EnableAutoConfiguration
// import org.springframework.context.annotation.Configuration
// import org.springframework.web.bind.annotation.*
// import org.springframework.beans.factory.annotation.*
// import groovy.transform.*

// This class is auto-generated:
@EnableAutoConfiguration
@Configuration
class GroovyApplication {

    // Your controllers and beans are added here
    // Application is auto-started
}

// Spring Data repositories work automatically!

@Entity
class User {
    @Id
    @GeneratedValue
    Long id
    String name
    String email
}

@Repository
interface UserRepository extends JpaRepository<User, Long> {
    User findByEmail(String email)
    List<User> findByNameLike(String pattern)
}

@RestController
@RequestMapping("/api/users")
class UserApi {

    @Autowired
    UserRepository repo

    @GetMapping
    List<User> list() {
        repo.findAll()
    }

    @PostMapping
    User create(@RequestBody User user) {
        repo.save(user)
    }
}

// Run with:
// spring run app.groovy -- --spring.h2.console.enabled=true
// Access H2 console: http://localhost:8080/h2-console

@EnableScheduling
class ScheduledTasks {

    private AtomicInteger counter = new AtomicInteger(0)

    @Scheduled(fixedRate = 5000)
    void printHello() {
        println "Hello ${LocalTime.now()} - Count: ${counter.incrementAndGet()}"
    }

    @Scheduled(cron = "0 0 * * * *")  // Every hour
    void hourlyTask() {
        println "Running hourly task at ${LocalDateTime.now()}"
    }

    @GetMapping("/count")
    int getCount() {
        counter.get()
    }
}

# application.yml
spring:
  application:
    name: my-app
  jpa:
    hibernate:
      ddl-auto: create-drop

# Run with profile
spring run app.groovy --spring.profiles.active=dev

# Or environment variable
export SPRING_PROFILES_ACTIVE=dev
spring run app.groovy

# Pass properties
spring run app.groovy -- --server.port=9000 --logging.level.root=DEBUG

// @Grab automatically downloads dependencies!

@Grab('org.springframework.boot:spring-boot-starter-web')
@Grab('org.springframework.boot:spring-boot-starter-data-jpa')
@Grab('com.h2database:h2')

@RestController
class HelloController {

    @GetMapping
    String hello() {
        "Dependencies auto-downloaded and available!"
    }
}

// Common dependencies automatically included:
// spring-boot-starter-web
// spring-boot-starter-logging
// junit, mockito, assertj (for testing)

# app.properties
app.name=My Spring App
app.version=1.0.0
app.feature.enabled=true
server.port=8080
logging.level.com.example=DEBUG

// app.groovy

@Configuration
@ConfigurationProperties(prefix = "app")
class AppProperties {
    String name
    String version
    Feature feature = new Feature()

    static class Feature {
        boolean enabled
    }
}

@RestController
class AppController {

    @Autowired
    AppProperties props

    @GetMapping("/info")
    Map getInfo() {
        [
            name: props.name,
            version: props.version,
            feature: props.feature.enabled
        ]
    }
}

// Run with config file
spring run app.groovy --spring.config.location=app.properties

# Test a Groovy script
spring test app_test.groovy

# Or using JUnit with Spring Test

// app_test.groovy

@SpringBootTest
class ApplicationTests {

    @Autowired
    TestRestTemplate restTemplate

    @Test
    void testHelloEndpoint() {
        String body = restTemplate.getForObject("/", String)
        assert body == "Hello!"
    }
}

# Perfect for:
spring run prototype.groovy --watch

# Experiment with Spring features
# Test ideas quickly
# Demonstrate concepts
# Get feedback fast

# ❌ Not suitable for:
# - Large applications
# - Team development
# - Complex builds
# - Proper testing framework
# - CI/CD integration

# ✅ Use Maven/Gradle instead

# v1
spring run app.groovy

# v1.1 - small changes
spring run app.groovy

# v2 - major changes
spring run app_v2.groovy

# Keep old scripts for reference

my-project/
├── application.groovy          # Main entry point
├── controllers/
│   ├── UserController.groovy
│   └── BookController.groovy
├── services/
│   ├── UserService.groovy
│   └── BookService.groovy
├── entities/
│   ├── User.groovy
│   └── Book.groovy
├── application.properties      # Configuration
└── README.md

/**
 * Book Management API
 *
 * Endpoints:
 * GET /api/books - List all books
 * POST /api/books - Create book
 * GET /api/books/{id} - Get book by ID
 * DELETE /api/books/{id} - Delete book
 *
 * Run: spring run app.groovy --watch
 *
 * Dependencies:
 * - H2 Database (in-memory)
 * - Spring Data JPA
 */

@RestController
@RequestMapping("/api/books")
class BookController {
    // ...
}

spring run script.groovy

# Prototype
spring run app.groovy --watch

# Once stable:
spring project create --build maven --name production-app
# Copy logic from CLI version
# Deploy with Maven

# Not recommended: deploying CLI-generated app directly