Tối Ưu Hiệu Suất & Profiling trong Spring Boot

java -XX:StartFlightRecording=duration=60s,filename=recording.jfr \
     -jar target/myapp.jar

java -XX:StartFlightRecording=disk=true,maxsize=500m,maxage=1d \
     -XX:FlightRecorderOptions=stackdepth=256 \
     -jar target/myapp.jar

# Tìm PID
jps -l
 
# Bắt đầu recording
jcmd <PID> JFR.start name=profile duration=120s filename=profile.jfr
 
# Dừng recording thủ công
jcmd <PID> JFR.stop name=profile
 
# Dump recording hiện tại
jcmd <PID> JFR.dump name=profile filename=dump.jfr

# Khởi chạy JMC (nếu đã cài)
jmc
 
# Hoặc dùng jfr command-line tool (JDK 17+)
jfr print --events jdk.CPULoad recording.jfr
jfr summary recording.jfr

# Cài VisualVM (macOS)
brew install --cask visualvm
 
# Khởi chạy
visualvm

@RestController
@RequestMapping("/api/debug")
@Profile("dev") // Chỉ available trong dev profile
public class ProfilingController {
 
    @Autowired
    private MeterRegistry meterRegistry;
 
    @GetMapping("/jfr/start")
    public ResponseEntity<String> startRecording()
            throws Exception {
        ProcessBuilder pb = new ProcessBuilder(
            "jcmd",
            String.valueOf(ProcessHandle.current().pid()),
            "JFR.start",
            "name=debug",
            "duration=60s",
            "filename=debug-recording.jfr"
        );
        pb.redirectErrorStream(true);
        Process process = pb.start();
        String output = new String(
            process.getInputStream().readAllBytes());
        return ResponseEntity.ok(
            "Recording started: " + output);
    }
 
    @GetMapping("/memory")
    public Map<String, Object> memoryInfo() {
        Runtime runtime = Runtime.getRuntime();
        return Map.of(
            "maxMemory", formatBytes(runtime.maxMemory()),
            "totalMemory",
                formatBytes(runtime.totalMemory()),
            "freeMemory",
                formatBytes(runtime.freeMemory()),
            "usedMemory", formatBytes(
                runtime.totalMemory()
                    - runtime.freeMemory())
        );
    }
 
    private String formatBytes(long bytes) {
        return String.format("%.2f MB",
            bytes / (1024.0 * 1024.0));
    }
}

<!-- pom.xml -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
 
<!-- Micrometer Prometheus registry (cho Prometheus/Grafana) -->
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

# application.yml
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus,env
  endpoint:
    health:
      show-details: when-authorized
  metrics:
    tags:
      application: ${spring.application.name}
    distribution:
      percentiles-histogram:
        http.server.requests: true
      sla:
        http.server.requests: 50ms,100ms,200ms,500ms,1s

# Tất cả HTTP request metrics
curl localhost:8080/actuator/metrics/http.server.requests
 
# Lọc theo endpoint
curl "localhost:8080/actuator/metrics/http.server.requests?tag=uri:/api/users"
 
# Lọc theo status
curl "localhost:8080/actuator/metrics/http.server.requests?tag=status:200"

# Memory usage
curl localhost:8080/actuator/metrics/jvm.memory.used
 
# GC pause time
curl localhost:8080/actuator/metrics/jvm.gc.pause
 
# Thread count
curl localhost:8080/actuator/metrics/jvm.threads.live
 
# CPU usage
curl localhost:8080/actuator/metrics/process.cpu.usage

# HikariCP active connections
curl localhost:8080/actuator/metrics/hikaricp.connections.active
 
# Connection wait time
curl localhost:8080/actuator/metrics/hikaricp.connections.acquire
 
# Connection pool usage
curl localhost:8080/actuator/metrics/hikaricp.connections.usage

@Service
public class OrderService {
 
    private final Counter orderCounter;
    private final Timer orderProcessingTimer;
    private final DistributionSummary orderValueSummary;
 
    public OrderService(MeterRegistry meterRegistry) {
        this.orderCounter = Counter.builder("orders.created")
            .description("Total orders created")
            .tag("type", "all")
            .register(meterRegistry);
 
        this.orderProcessingTimer = Timer
            .builder("orders.processing.time")
            .description("Order processing duration")
            .publishPercentiles(0.5, 0.95, 0.99)
            .register(meterRegistry);
 
        this.orderValueSummary = DistributionSummary
            .builder("orders.value")
            .description("Order values distribution")
            .baseUnit("dollars")
            .publishPercentiles(0.5, 0.95)
            .register(meterRegistry);
    }
 
    public Order createOrder(OrderRequest request) {
        return orderProcessingTimer.record(() -> {
            Order order = processOrder(request);
            orderCounter.increment();
            orderValueSummary.record(
                order.getTotalAmount().doubleValue());
            return order;
        });
    }
 
    private Order processOrder(OrderRequest request) {
        // Business logic
        return new Order(/* ... */);
    }
}

@Component
public class QueueMetrics {
 
    private final BlockingQueue<Task> taskQueue;
 
    public QueueMetrics(MeterRegistry registry,
            BlockingQueue<Task> taskQueue) {
        this.taskQueue = taskQueue;
 
        Gauge.builder("task.queue.size", taskQueue,
                BlockingQueue::size)
            .description("Current task queue size")
            .register(registry);
 
        Gauge.builder("task.queue.remaining",
                taskQueue,
                BlockingQueue::remainingCapacity)
            .description("Remaining queue capacity")
            .register(registry);
    }
}

curl localhost:8080/actuator/prometheus

# HELP http_server_requests_seconds
# TYPE http_server_requests_seconds histogram
http_server_requests_seconds_bucket{method="GET",uri="/api/users",status="200",le="0.05"} 142
http_server_requests_seconds_bucket{method="GET",uri="/api/users",status="200",le="0.1"} 198
http_server_requests_seconds_bucket{method="GET",uri="/api/users",status="200",le="0.2"} 210
http_server_requests_seconds_count{method="GET",uri="/api/users",status="200"} 215
http_server_requests_seconds_sum{method="GET",uri="/api/users",status="200"} 18.432

# application.yml
spring:
  jpa:
    properties:
      hibernate:
        generate_statistics: true
        session.events.log.LOG_QUERIES_SLOWER_THAN_MS: 100
  datasource:
    hikari:
      leak-detection-threshold: 30000  # 30 giây

logging:
  level:
    org.hibernate.stat: DEBUG
    org.hibernate.SQL: DEBUG
    org.hibernate.type.descriptor.sql.BasicBinder: TRACE

Session Metrics {
    726313 nanoseconds spent acquiring 1 JDBC connections;
    326040 nanoseconds spent releasing 1 JDBC connections;
    3524968 nanoseconds spent preparing 12 JDBC statements;  ← 12 queries!
    42803543 nanoseconds spent executing 12 JDBC statements;
    0 nanoseconds spent executing 0 JDBC batches;
}

spring:
  datasource:
    hikari:
      # Kích thước pool
      maximum-pool-size: 20       # Max connections
      minimum-idle: 5             # Min idle connections
 
      # Timeouts
      connection-timeout: 10000   # 10s để lấy connection
      idle-timeout: 300000        # 5 phút idle trước khi loại bỏ
      max-lifetime: 1800000       # 30 phút tuổi thọ tối đa
 
      # Validation
      validation-timeout: 5000    # 5s cho validation query
 
      # Phát hiện leak
      leak-detection-threshold: 60000  # Cảnh báo nếu giữ > 60s
 
      # Metrics
      register-mbeans: true

optimal_pool_size = (core_count * 2) + effective_spindle_count
 
Ví dụ: Server 4-core với SSD
optimal_pool_size = (4 * 2) + 1 = 9

@Scheduled(fixedRate = 30000) // Mỗi 30 giây
public void logPoolMetrics() {
    HikariPoolMXBean poolProxy = hikariDataSource
        .getHikariPoolMXBean();
 
    log.info("HikariCP - Active: {}, Idle: {}, " +
             "Waiting: {}, Total: {}",
        poolProxy.getActiveConnections(),
        poolProxy.getIdleConnections(),
        poolProxy.getThreadsAwaitingConnection(),
        poolProxy.getTotalConnections());
}

spring:
  jpa:
    properties:
      hibernate:
        jdbc:
          batch_size: 50
          batch_versioned_data: true
        order_inserts: true
        order_updates: true

@Service
@Transactional
public class ProductImportService {
 
    @PersistenceContext
    private EntityManager entityManager;
 
    public int importProducts(
            List<ProductDto> products) {
        int batchSize = 50;
 
        for (int i = 0; i < products.size(); i++) {
            Product product = mapToEntity(products.get(i));
            entityManager.persist(product);
 
            // Flush và clear mỗi batch
            if (i > 0 && i % batchSize == 0) {
                entityManager.flush();
                entityManager.clear();
            }
        }
        entityManager.flush();
        entityManager.clear();
 
        return products.size();
    }
 
    private Product mapToEntity(ProductDto dto) {
        Product product = new Product();
        product.setName(dto.getName());
        product.setPrice(dto.getPrice());
        product.setCategory(dto.getCategory());
        return product;
    }
}

@Service
public class ReportService {
 
    @Transactional(readOnly = true)
    public List<SalesReport> generateMonthlyReport(
            YearMonth month) {
        // Hibernate bỏ qua dirty checking cho read-only
        // transactions, tiết kiệm CPU time
        return reportRepository
            .findByMonth(month.getMonthValue(),
                         month.getYear());
    }
}

// Repository với query hints
public interface ProductRepository
        extends JpaRepository<Product, Long> {
 
    @QueryHints({
        @QueryHint(
            name = "org.hibernate.readOnly",
            value = "true"),
        @QueryHint(
            name = "org.hibernate.fetchSize",
            value = "50")
    })
    @Query("SELECT p FROM Product p WHERE p.active = true")
    List<Product> findAllActive();
}

server:
  compression:
    enabled: true
    min-response-size: 1024      # Nén responses > 1KB
    mime-types:
      - application/json
      - application/xml
      - text/html
      - text/xml
      - text/plain
      - application/javascript
      - text/css

# Không có compression
curl -s -o /dev/null -w "%{size_download}" \
  http://localhost:8080/api/products
# Output: 45230
 
# Có compression
curl -s -o /dev/null -w "%{size_download}" \
  -H "Accept-Encoding: gzip" \
  http://localhost:8080/api/products
# Output: 8124 (nhỏ hơn 82%)

@Configuration
public class WebConfig implements WebMvcConfigurer {
 
    @Bean
    public FilterRegistrationBean<ShallowEtagHeaderFilter>
            shallowEtagHeaderFilter() {
        FilterRegistrationBean<ShallowEtagHeaderFilter>
            filterBean = new FilterRegistrationBean<>(
                new ShallowEtagHeaderFilter());
        filterBean.addUrlPatterns("/api/*");
        filterBean.setName("etagFilter");
        return filterBean;
    }
}

@RestController
@RequestMapping("/api/products")
public class ProductController {
 
    @GetMapping("/{id}")
    public ResponseEntity<Product> getProduct(
            @PathVariable Long id) {
        Product product = productService.findById(id);
 
        return ResponseEntity.ok()
            .cacheControl(CacheControl
                .maxAge(Duration.ofMinutes(10))
                .mustRevalidate())
            .eTag(String.valueOf(
                product.getUpdatedAt().hashCode()))
            .body(product);
    }
 
    @GetMapping("/categories")
    public ResponseEntity<List<String>> getCategories() {
        List<String> categories =
            productService.getAllCategories();
 
        // Categories hiếm khi thay đổi — cache 1 giờ
        return ResponseEntity.ok()
            .cacheControl(CacheControl
                .maxAge(Duration.ofHours(1))
                .cachePublic())
            .body(categories);
    }
}

@RestController
@RequestMapping("/api/reports")
public class ReportController {
 
    @Autowired
    private ReportService reportService;
 
    // Synchronous — block Tomcat thread
    @GetMapping("/sync/{id}")
    public Report getReportSync(@PathVariable Long id) {
        return reportService.generateReport(id);
    }
 
    // Async với CompletableFuture — giải phóng Tomcat thread
    @GetMapping("/async/{id}")
    public CompletableFuture<Report> getReportAsync(
            @PathVariable Long id) {
        return CompletableFuture.supplyAsync(
            () -> reportService.generateReport(id));
    }
 
    // Streaming large responses
    @GetMapping(value = "/stream",
        produces = MediaType.APPLICATION_NDJSON_VALUE)
    public Flux<Report> streamReports() {
        return reportService.streamAllReports();
    }
}

server:
  tomcat:
    threads:
      max: 200          # Max worker threads
      min-spare: 20     # Min idle threads
    max-connections: 8192
    accept-count: 100   # Queue size khi tất cả threads bận
    connection-timeout: 20000

spring:
  jackson:
    serialization:
      WRITE_DATES_AS_TIMESTAMPS: false
    deserialization:
      FAIL_ON_UNKNOWN_PROPERTIES: false
    default-property-inclusion: non_null  # Bỏ qua null fields

@Configuration
public class JacksonConfig {
 
    @Bean
    public Jackson2ObjectMapperBuilderCustomizer
            jacksonCustomizer() {
        return builder -> builder
            .featuresToDisable(
                SerializationFeature
                    .WRITE_DATES_AS_TIMESTAMPS,
                DeserializationFeature
                    .FAIL_ON_UNKNOWN_PROPERTIES)
            .featuresToEnable(
                DeserializationFeature
                    .READ_UNKNOWN_ENUM_VALUES_AS_NULL)
            .serializationInclusion(
                JsonInclude.Include.NON_NULL);
    }
}

public class Views {
    public static class Summary {}
    public static class Detail extends Summary {}
}
 
@Entity
public class Product {
 
    @JsonView(Views.Summary.class)
    private Long id;
 
    @JsonView(Views.Summary.class)
    private String name;
 
    @JsonView(Views.Summary.class)
    private BigDecimal price;
 
    @JsonView(Views.Detail.class)
    private String fullDescription;
 
    @JsonView(Views.Detail.class)
    private List<Review> reviews;
}
 
@RestController
@RequestMapping("/api/products")
public class ProductController {
 
    // Trả về chỉ id, name, price
    @GetMapping
    @JsonView(Views.Summary.class)
    public List<Product> listProducts() {
        return productService.findAll();
    }
 
    // Trả về tất cả fields bao gồm description, reviews
    @GetMapping("/{id}")
    @JsonView(Views.Detail.class)
    public Product getProduct(@PathVariable Long id) {
        return productService.findById(id);
    }
}

# Từ ứng dụng đang chạy
jcmd <PID> GC.heap_dump /tmp/heapdump.hprof
 
# Tự động khi OutOfMemoryError (thêm vào JVM args)
java -XX:+HeapDumpOnOutOfMemoryError \
     -XX:HeapDumpPath=/var/log/app/ \
     -jar myapp.jar

// ❌ Memory leak — tăng mãi
private final Map<String, Object> cache =
    new HashMap<>();
 
public Object getData(String key) {
    return cache.computeIfAbsent(key,
        k -> expensiveQuery(k));
}
 
// ✅ Cache có giới hạn với eviction
private final Map<String, Object> cache =
    Collections.synchronizedMap(
        new LinkedHashMap<>(100, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(
                    Map.Entry<String, Object> eldest) {
                return size() > 1000;
            }
        }
    );
 
// ✅ Tốt hơn: Dùng Spring Cache với TTL (xem bài Redis)
@Cacheable(value = "data", key = "#key")
public Object getData(String key) {
    return expensiveQuery(key);
}

// ❌ Stream không đóng — database connection bị leak
public List<User> getActiveUsers() {
    return userRepository.streamAll()
        .filter(User::isActive)
        .collect(Collectors.toList());
}
 
// ✅ Try-with-resources đóng stream
@Transactional(readOnly = true)
public List<User> getActiveUsers() {
    try (Stream<User> stream =
             userRepository.streamAll()) {
        return stream
            .filter(User::isActive)
            .collect(Collectors.toList());
    }
}

// ❌ Listener đăng ký nhưng không bao giờ gỡ
@Component
public class NotificationListener {
 
    @Autowired
    private ApplicationEventPublisher publisher;
 
    @PostConstruct
    public void init() {
        // Mỗi hot-reload trong dev thêm một listener!
        publisher.publishEvent(
            new ListenerRegisteredEvent(this));
    }
}
 
// ✅ Dùng @EventListener (Spring quản lý lifecycle)
@Component
public class NotificationListener {
 
    @EventListener
    public void onOrderCreated(OrderCreatedEvent event) {
        // Spring xử lý registration/cleanup
        sendNotification(event.getOrder());
    }
}

java \
  -Xms512m \                        # Heap ban đầu
  -Xmx2g \                          # Heap tối đa
  -XX:+UseG1GC \                    # G1 garbage collector
  -XX:MaxGCPauseMillis=200 \        # GC pause mục tiêu
  -XX:+HeapDumpOnOutOfMemoryError \ # Dump khi OOM
  -XX:HeapDumpPath=/var/log/app/ \  # Vị trí heap dump
  -XX:+ExitOnOutOfMemoryError \     # Thoát khi OOM (để container restart)
  -Xlog:gc*:file=/var/log/app/gc.log:time,uptime:filecount=5,filesize=10m \
  -jar myapp.jar

java \
  -Xms1g -Xmx4g \
  -XX:+UseZGC \
  -XX:+ZGenerational \           # Generational ZGC (JDK 21+)
  -Xlog:gc*:file=gc.log:time \
  -jar myapp.jar

# GC pause time
curl localhost:8080/actuator/metrics/jvm.gc.pause
 
# Memory pool usage
curl localhost:8080/actuator/metrics/jvm.memory.used?tag=area:heap
 
# GC count
curl localhost:8080/actuator/metrics/jvm.gc.pause \
  | jq '.measurements[] | select(.statistic=="COUNT")'

# application.yml
spring:
  main:
    log-startup-info: true
 
logging:
  level:
    org.springframework.boot.autoconfigure: DEBUG

java -jar myapp.jar --spring.main.startup-report=true

Spring Boot Startup Report
============================
Startup Time: 4.2 seconds (process: 5.1 seconds)
 
Auto-configuration (top 10 by duration):
  DataSourceAutoConfiguration: 892ms
  HibernateJpaAutoConfiguration: 1240ms
  WebMvcAutoConfiguration: 312ms
  SecurityAutoConfiguration: 289ms
  ...

spring:
  main:
    lazy-initialization: true  # Global lazy init

// Eager (mặc định) — loaded khi startup
@Service
public class PaymentService {
    // Cần ngay cho health checks
}
 
// Lazy — loaded khi sử dụng lần đầu
@Service
@Lazy
public class ReportGenerationService {
    // Chỉ cần khi ai đó request report
}

@SpringBootApplication(exclude = {
    DataSourceAutoConfiguration.class,       // Nếu không dùng DB
    MongoAutoConfiguration.class,            // Nếu không dùng Mongo
    RedisAutoConfiguration.class,            // Nếu không dùng Redis
    MailSenderAutoConfiguration.class,       // Nếu không gửi email
    SecurityAutoConfiguration.class,         // Nếu không dùng security
    FlywayAutoConfiguration.class            // Nếu không dùng Flyway
})
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

java -jar myapp.jar --debug 2>&1 | grep "matched"

<!-- pom.xml — Spring Boot 3.x -->
<plugin>
    <groupId>
        org.graalvm.buildtools
    </groupId>
    <artifactId>
        native-maven-plugin
    </artifactId>
</plugin>

# Build native image
mvn -Pnative native:compile
 
# Chạy — khởi động trong mili giây
./target/myapp

// ❌ Scan mọi thứ dưới com.example
@SpringBootApplication
@ComponentScan("com.example")
public class MyApplication {}
 
// ✅ Chỉ scan những gì cần
@SpringBootApplication
@ComponentScan(basePackages = {
    "com.example.myapp.controller",
    "com.example.myapp.service",
    "com.example.myapp.repository",
    "com.example.myapp.config"
})
public class MyApplication {}

<dependency>
    <groupId>org.openjdk.jmh</groupId>
    <artifactId>jmh-core</artifactId>
    <version>1.37</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.openjdk.jmh</groupId>
    <artifactId>jmh-generator-annprocess</artifactId>
    <version>1.37</version>
    <scope>test</scope>
</dependency>

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@State(Scope.Benchmark)
@Warmup(iterations = 3, time = 1)
@Measurement(iterations = 5, time = 1)
@Fork(2)
public class SerializationBenchmark {
 
    private ObjectMapper objectMapper;
    private Product product;
 
    @Setup
    public void setup() {
        objectMapper = new ObjectMapper();
        objectMapper.registerModule(
            new JavaTimeModule());
 
        product = new Product();
        product.setId(1L);
        product.setName("Wireless Keyboard");
        product.setPrice(new BigDecimal("79.99"));
        product.setDescription(
            "Ergonomic wireless keyboard with " +
            "Bluetooth connectivity");
        product.setCategories(
            List.of("Electronics", "Accessories"));
        product.setCreatedAt(Instant.now());
    }
 
    @Benchmark
    public String jacksonSerialization()
            throws Exception {
        return objectMapper.writeValueAsString(product);
    }
 
    @Benchmark
    public byte[] jacksonSerializationBytes()
            throws Exception {
        return objectMapper.writeValueAsBytes(product);
    }
 
    @Benchmark
    public String gsonSerialization() {
        return new Gson().toJson(product);
    }
 
    public static void main(String[] args)
            throws Exception {
        Options opt = new OptionsBuilder()
            .include(
                SerializationBenchmark.class
                    .getSimpleName())
            .resultFormat(ResultFormatType.JSON)
            .result("benchmark-results.json")
            .build();
        new Runner(opt).run();
    }
}

Benchmark                                   Mode  Cnt   Score   Error  Units
SerializationBenchmark.jacksonBytes         avgt   10   1.245 ± 0.034  us/op
SerializationBenchmark.jacksonString        avgt   10   1.512 ± 0.041  us/op
SerializationBenchmark.gsonSerialization    avgt   10   3.847 ± 0.112  us/op

@SpringBootTest(
    webEnvironment = SpringBootTest.WebEnvironment
        .RANDOM_PORT)
public class PerformanceBaselineTest {
 
    @Autowired
    private TestRestTemplate restTemplate;
 
    @Test
    void getUser_shouldRespondWithin200ms() {
        long start = System.nanoTime();
 
        ResponseEntity<User> response = restTemplate
            .getForEntity("/api/users/1", User.class);
 
        long duration = (System.nanoTime() - start)
            / 1_000_000;
 
        assertThat(response.getStatusCode())
            .isEqualTo(HttpStatus.OK);
        assertThat(duration)
            .as("GET /api/users/1 should complete " +
                "within 200ms, took %dms", duration)
            .isLessThan(200);
    }
 
    @Test
    void listProducts_shouldRespondWithin500ms() {
        long start = System.nanoTime();
 
        ResponseEntity<List> response = restTemplate
            .getForEntity("/api/products?page=0&size=20",
                List.class);
 
        long duration = (System.nanoTime() - start)
            / 1_000_000;
 
        assertThat(response.getStatusCode())
            .isEqualTo(HttpStatus.OK);
        assertThat(duration)
            .as("GET /api/products should complete " +
                "within 500ms, took %dms", duration)
            .isLessThan(500);
    }
}

# Template JVM flags cho production
JAVA_OPTS="\
  -server \
  -Xms${HEAP_SIZE} \
  -Xmx${HEAP_SIZE} \
  -XX:+UseG1GC \
  -XX:MaxGCPauseMillis=200 \
  -XX:+HeapDumpOnOutOfMemoryError \
  -XX:HeapDumpPath=/var/log/app/heapdump.hprof \
  -XX:+ExitOnOutOfMemoryError \
  -Xlog:gc*:file=/var/log/app/gc.log:time:filecount=5,filesize=10m \
  -Djava.security.egd=file:/dev/./urandom \
  -Dspring.profiles.active=prod \
"
 
java $JAVA_OPTS -jar myapp.jar

FROM eclipse-temurin:21-jre-alpine
 
WORKDIR /app
COPY target/*.jar app.jar
 
ENV JAVA_OPTS="\
  -server \
  -Xms512m -Xmx512m \
  -XX:+UseG1GC \
  -XX:MaxGCPauseMillis=200 \
  -XX:+HeapDumpOnOutOfMemoryError \
  -XX:HeapDumpPath=/tmp \
  -XX:+ExitOnOutOfMemoryError"
 
EXPOSE 8080
 
ENTRYPOINT ["sh", "-c", \
  "java $JAVA_OPTS -jar app.jar"]