LaunchPad is Oorian's embedded server solution for deploying applications as self-contained executable JARs. No more installing and configuring Tomcat or Glassfish—just compile your application and run it. In this post, we'll explore how LaunchPad works and the design decisions behind it.
Why Self-Contained Apps?
Traditional Java web application deployment has always been a multi-step process: install an application server, configure it correctly, package your app as a WAR file, deploy it, and hope everything works together. This approach made sense in the early 2000s when servers were expensive and you wanted to run multiple applications on one machine.
Today's world looks different. Containers, microservices, and cloud platforms have changed how we think about deployment. A single executable JAR that contains everything it needs to run is far more portable, easier to manage, and perfect for modern deployment pipelines.
LaunchPad brings this simplicity to Oorian applications.
Getting Started in 5 Lines of Code
Here's everything you need to run an Oorian application standalone:
public static void main(String[] args)
{
LaunchPad launcher = new LaunchPad();
launcher.setPort(8080);
launcher.launch(MyApplication.class);
}That's it. Run the main method, and your Oorian application is serving requests at http://localhost:8080. No XML configuration files, no deployment descriptors, no external server installation.
Built on Battle-Tested Jetty
LaunchPad wraps Eclipse Jetty, one of the most widely deployed embedded servers in the Java ecosystem. Jetty powers countless production applications, from small microservices to massive distributed systems. You get enterprise-grade reliability with zero-configuration convenience.
Configuration When You Need It
While LaunchPad works out of the box with sensible defaults, you can customize everything through a fluent API:
LaunchPad launcher = new LaunchPad();
// Basic configuration
launcher.setPort(8080)
.setContextPath("/myapp")
.setShutdownPort(8005);
// SSL/HTTPS support
launcher.enableSsl("/path/to/keystore.jks", "password")
.setSslPort(8443);
// Thread pool tuning
launcher.setThreadPool(10, 200)
.setIdleTimeout(30000);
// Features
launcher.setGzipEnabled(true)
.setHealthEndpointEnabled(true)
.setHealthEndpointPath("/health");
launcher.launch(MyApplication.class);Externalized Configuration
For production deployments, you can externalize configuration to a properties file:
# server.properties
server.port=8080
server.shutdown.port=8005
server.context.path=/
server.threads.min=10
server.threads.max=200
# SSL
server.ssl.enabled=true
server.ssl.port=8443
server.ssl.keystore=/etc/myapp/keystore.jks
server.ssl.keystore.password=changeit
# Features
server.gzip.enabled=true
server.health.enabled=true
server.health.path=/healthThen load it in your launcher:
LaunchPad launcher = new LaunchPad();
launcher.setConfigFile("/etc/myapp/server.properties");
launcher.launch(MyApplication.class);Programmatic settings always override file settings, giving you flexibility for development overrides.
Key Features
GZIP Compression
LaunchPad enables GZIP compression by default for text content (HTML, CSS, JavaScript, JSON). This typically reduces response sizes by 70-80%, improving load times with zero effort on your part.
Health Endpoint
A built-in /health endpoint returns a simple "OK" response, perfect for:
- Load balancer health checks
- Kubernetes liveness and readiness probes
- Monitoring system uptime checks
The endpoint is enabled by default and can be customized or disabled if needed.
SSL/HTTPS
Adding HTTPS support is a single method call. LaunchPad handles all the SSL context configuration internally. For production, you'll typically use a reverse proxy (nginx, HAProxy) for TLS termination, but having built-in HTTPS support is valuable for development and internal services.
IDE Hot Restart
One of the most developer-friendly features: the shutdown port mechanism. When you restart your application from your IDE, LaunchPad automatically signals the previous instance to shut down. No more "Address already in use" errors or manually killing processes.
Full Oorian Feature Support
Every Oorian feature works with LaunchPad:
- Communication modes: AJAX, SSE, and WebSocket all work seamlessly
- File uploads: Multipart handling works out of the box
- Sessions: Full session management support
- Static resources: Serve files from a configured directory
Perfect for Docker
LaunchPad applications are ideal for containerization. Your Dockerfile becomes remarkably simple:
FROM eclipse-temurin:21-jre
COPY target/myapp-with-dependencies.jar /app/myapp.jar
EXPOSE 8080
CMD ["java", "-jar", "/app/myapp.jar"]The health endpoint integrates naturally with Docker health checks:
HEALTHCHECK --interval=30s --timeout=3s \
CMD curl -f http://localhost:8080/health || exit 1Kubernetes Ready
For Kubernetes deployments, the health endpoint serves as both liveness and readiness probe:
spec:
containers:
- name: myapp
image: myapp:latest
ports:
- containerPort: 8080
livenessProbe:
httpGet:
path: /health
port: 8080
initialDelaySeconds: 30
periodSeconds: 10
readinessProbe:
httpGet:
path: /health
port: 8080
initialDelaySeconds: 5
periodSeconds: 5Monitoring Support
LaunchPad provides built-in JMX support for operations teams. When enabled, Jetty components are exposed as MBeans that you can monitor with JConsole, VisualVM, or any JMX-compatible tool.
For cloud-native monitoring, we're also adding optional Prometheus metrics support. Add the Micrometer dependency to your project, enable metrics, and you'll get a /metrics endpoint with JVM and Jetty statistics ready for Prometheus scraping.
Ideal for Microservices
LaunchPad's lightweight nature makes it perfect for microservice architectures:
- Fast startup: Applications start in seconds, not minutes
- Small footprint: Minimal memory overhead beyond your application
- Independent deployment: Each service is completely self-contained
- Easy scaling: Spin up new instances without server configuration
When to Use LaunchPad
LaunchPad is ideal for:
- New applications: Start simple without worrying about server setup
- Microservices: Deploy independent, self-contained services
- Docker/Kubernetes: Container-ready from day one
- Development: Run and debug locally with minimal setup
- Small to medium applications: When you don't need a full application server
Traditional WAR deployment still makes sense if you're deploying to an existing application server infrastructure or need features like hot deployment of multiple applications.
Learn More
LaunchPad will be part of the Oorian framework when it becomes publicly available. In the meantime, you can explore the LaunchPad feature page for an overview, or read the LaunchPad User's Guide for comprehensive documentation on configuration and deployment options.
LaunchPad represents our commitment to making Oorian applications easy to deploy in modern environments. Stay tuned for more updates as we continue developing Oorian!