This guide walks through adding MyBatis-Plus to a Spring Boot project, configuring basic settings, using CRUD operations, condition builders, pagination, advanced features like auto‑fill, logical delete, optimistic locking, code generation, common pitfalls, and practical recommendations for effective usage.
Spring Boot simplifies transaction management via PlatformTransactionManager and AOP, offering declarative and programmatic approaches, default rollback on runtime exceptions, customizable rollback rules, propagation behaviors, manual rollback techniques, multithreaded transaction handling, and solutions to common pitfalls such as swallowed exceptions and self-invocation issues.
Learn to compile a Spring Boot 3.5.6 application into a fast-starting native binary using GraalVM, configure the environment, add Maven plugins, write simple test code, and package the result into a lightweight Docker image, achieving dramatically reduced startup time and image size.
This tutorial walks through using Zhihu's open‑source FUST microservice framework together with DeepSeek's language model API to design, implement, and deploy a scalable, high‑performance intelligent Q&A system, covering architecture, data models, service layers, and deployment scripts.
This tutorial walks you through setting up a Spring Boot project with Tess4J, adding required dependencies, configuring language data, implementing an OCR service and REST controller, and testing both local file and remote URL image recognition, all with complete code examples.
This tutorial walks through integrating SpringDoc into a Spring Boot project, covering why it replaces SpringFox, how to configure it with minimal settings, add API annotations, set up grouped documentation, and handle static resources and Spring Security for full Swagger UI access.
This article explains common problems of concurrent database updates in Spring Boot 3 and demonstrates five practical solutions—including database locks, optimistic and pessimistic locking, transaction isolation levels, and application‑level locks—accompanied by complete code examples and test results.
An e‑commerce Spring Boot service crashed when uploading large files because Linux’s /tmp is a memory‑based tmpfs that fills RAM, causing OOM kills; the article explains the underlying tmpfs behavior, common pitfalls, and a three‑step solution using /var/tmp with proper configuration and permissions.
This tutorial walks through adding the required Maven dependencies, configuring application.yml, creating SwaggerConfig, implementing sample controllers, accessing the enhanced Knife4j UI and Swagger UI, troubleshooting common issues, and comparing SpringDoc OpenAPI with Knife4j OpenAPI3 to help developers choose the right solution for Spring Boot 3.x projects.
This guide provides a step‑by‑step troubleshooting workflow for Spring Boot microservices using Nacos as a config/registry and MySQL as the database, covering log inspection, process checks, port listening, network connectivity, configuration validation, database connectivity, system resources, startup commands, and an optional one‑click diagnostic script.
This article explains how to use Spring State Machine to model and control order lifecycle transitions in an e‑commerce system, covering core concepts, configuration, listeners, service integration, controller endpoints, and visual results for robust backend state management.
This article demonstrates how to use Jackson's JsonNode tree model within Spring Boot 3, covering node creation, conversion from JSON strings and Java objects, tree manipulation—including adding, editing, and deleting nodes—and serialization back to JSON, with complete code examples for each operation.
This article explains common pitfalls in Java controller interface design—such as inconsistent return formats, missing failure handling, and inappropriate parameters—and demonstrates how a unified ResultBean response combined with AOP logging and exception handling can improve code readability, maintainability, and testability.
This article introduces four of Spring Boot’s expression engines—Groovy, MVEL, JEXL, and JSP EL—showing how to add their Maven dependencies, run concrete code examples, and provides practical guidance on selecting the right engine based on performance, feature richness, and integration ease.
This article presents a comprehensive guide to testing Spring Boot controller layers, covering isolated @WebMvcTest, full‑stack @SpringBootTest, WebTestClient, TestRestTemplate, standalone MockMvc, REST Assured, exception‑handling advice, and pure Mockito unit tests, each with purpose, core annotations, sample code, pros, cons, and usage recommendations.
This article introduces LiteFlow, a lightweight yet powerful rule engine for Java Spring Boot, explains its architecture, supported rule formats, core components, EL rule syntax, data context handling, configuration options, and demonstrates a real e‑commerce workflow with code snippets and diagrams.
This article explains why dynamic configuration refresh is needed in Spring Boot, describes the core principles of @RefreshScope, provides step‑by‑step implementation code, and shares best practices and troubleshooting tips for zero‑downtime configuration updates in production environments.
This article explains how Spring Boot 3.4.2 supports both annotation‑based and programmatic validation, demonstrates when to choose each approach, provides step‑by‑step custom validator implementations for Employee and Department entities, and shows how to integrate these validators with Spring MVC controllers.
This article explains why traditional Java apps require restarts for config changes, introduces Spring Boot's @RefreshScope for zero‑downtime hot‑reloading, details its core principles, provides step‑by‑step implementation, troubleshooting tips, best practices, and advanced use cases for dynamic configuration in production environments.
This tutorial walks through implementing unified user login verification, exception handling, and response formatting in Spring Boot using AOP aspects, HandlerInterceptor, @ControllerAdvice, and ResponseBodyAdvice, providing complete code examples and architectural explanations.
This article demonstrates how to use four lesser‑known Jackson annotations—@JsonAppend, @JsonNaming, @JsonPropertyDescription, and @JsonPOJOBuilder—to extend JSON serialization, customize property naming, enrich JSON Schema documentation, and deserialize immutable objects within Spring Boot 3 applications.
This article provides a comprehensive guide to Spring Batch, covering its purpose, supported business scenarios, core components and interfaces, Maven setup, sample job definitions, parallel execution, decision flows, nested jobs, data reading and writing, validation processing, and REST‑based job scheduling, all illustrated with complete code examples.
Explore 11 practical Spring Boot bean registration methods—from simple @Component scanning to advanced ImportSelector, FactoryBean, and runtime dynamic registration—detailing code examples, use cases, and configuration steps, enabling developers to choose the optimal approach for flexible, modular applications.
This article analyzes MyBatis‑Flex, highlighting its lightweight, flexible, and powerful design, compares its feature set and performance against MyBatis‑Plus and Fluent‑MyBatis, lists supported databases, and provides a step‑by‑step quick‑start tutorial with code examples.
This tutorial shows how to integrate HTMX into Spring Boot 3 projects to build SPA‑like pages without writing JavaScript, covering environment setup, AJAX requests, debounced search, multi‑form queries, HTML fragment rendering, and Server‑Sent Events with full code examples.
Spring Boot’s “convention over configuration” hides many default settings that can cause performance bottlenecks and runtime failures, from Tomcat and HikariCP connection limits to JPA lazy loading, timezone serialization, logging, caching, file upload limits, thread pools, and transaction timeouts, and the article shows how to tune each.
This article introduces Easy-Es, an Elasticsearch ORM that mimics MyBatis‑Plus syntax, walks through its core features, integration steps, entity annotations, mapper and service implementations, and demonstrates simple, advanced, and recommendation search scenarios, highlighting the reduction in boilerplate code.
This article presents a continuously updated collection of 171 Spring Boot 3 practical cases, covering advanced topics such as global exception handling, custom interceptors, bean retrieval, configuration imports, startup runners, bean definition modification, initialization methods, custom scopes, and graceful shutdown, with full code examples and a free PDF ebook.
This article compares five major Java database access technologies—JDBC, Hibernate, Spring Data JPA, JOOQ, and MyBatis—detailing their code examples, strengths, weaknesses, and ideal use cases, while also offering a downloadable Spring Boot 3 case collection PDF for hands‑on practice.
This article explains the importance of database connection pools in Spring Boot projects using KingbaseES, compares four popular pools (DBCP, C3P0, Druid, HikariCP), provides configuration examples, highlights common pitfalls, and offers practical tuning and monitoring guidance for optimal performance.
This article examines five frequent Redis cache anti‑patterns—cache avalanche, unbounded local cache, stale data, missing invalidation, and oversized objects—explaining their pitfalls with code examples and showing concrete fixes that dramatically improve latency, throughput, and memory usage.
This article explains how to use MinIO as an image storage service and implement a Spring Boot scheduled task that periodically deletes outdated image folders, covering dependency setup, delete utilities, performance considerations, cron expressions, thread‑pool tuning, asynchronous execution, configuration extensions, and testing strategies.
This article presents a comprehensive guide to generating PDF documents in Spring Boot 3 applications using iTextpdf and Thymeleaf, covering environment setup, Maven dependencies, data model, HTML template design, controller implementation, and a test case that produces a correctly rendered PDF with external CSS and images.
Learn how to implement graceful shutdown in Spring Boot by understanding the JVM shutdown hook, customizing cleanup logic with ContextClosedEvent listeners and @PreDestroy annotations, and configuring the spring.main.register-shutdown-hook property to ensure resources are released safely during application termination.
This guide shows how to automatically inject userId and orderId into Spring Boot log messages by defining log placeholders, using ThreadLocal, creating a custom @UserLog annotation, and applying a Spring AOP aspect that populates MDC, dramatically simplifying logging in e‑commerce systems.
SpringDoc is a Spring Boot library that automatically generates OpenAPI 3 compliant API documentation, replacing the outdated SpringFox; this guide explains its advantages, minimal configuration steps, grouping techniques, and integration with Swagger UI for seamless API documentation in modern Spring applications.
This article walks through ten practical Spring Boot configuration optimizations—including Tomcat connection pool, HikariCP, Jackson timezone handling, Logback rotation, Caffeine caching, Actuator endpoint exposure, file upload limits, async thread pools, static resource caching, and transaction timeouts—providing ready‑to‑use YAML snippets and clear explanations for each setting.
This guide explains how to use Spring Boot's @RefreshScope to dynamically refresh configuration at runtime without restarting services, covering the underlying mechanism, step‑by‑step implementation, production best practices, troubleshooting tips, and advanced use cases.
This guide explains how to implement an online user counting feature using Redis sorted sets (ZSET) in a Spring Boot application, covering user identification via tokens or browser fingerprinting, adding, querying, and cleaning up entries with zadd, zrangeByScore, zremrangeByScore, and zrem commands.
SpringDoc is a Spring Boot library that automatically generates OpenAPI 3 compliant API documentation, offering seamless integration with Swagger UI; this guide explains its advantages over SpringFox, walks through minimal configuration, grouping strategies, and handling of security and resource handling for robust API documentation.
This article introduces dynamic SQL techniques for Spring Boot 3, compares JPA and MyBatis implementations, and demonstrates how the powerful jpa-search-helper library simplifies complex queries with both map‑based and JSON‑based modes, including pagination and sorting examples.
This guide explains how to use MinIO SDK in a Spring Boot application to schedule automatic deletion of outdated image folders, covering dependency setup, delete methods, performance considerations, cron expression configuration, thread‑pool tuning, asynchronous execution, and extensible configuration via properties.
This article introduces Spring Expression Language (SpEL) for Spring Boot 3, explains its core features such as collection filtering, projection, Elvis and safe navigation operators, method and bean references, regular‑expression handling, and arithmetic expressions, and provides complete runnable code examples demonstrating each technique.
This article walks through Spring Boot 3's powerful annotation‑based parameter validation, covering basic constraints, custom validators, group validation, nested objects, method‑level checks, internationalized messages, programmatic validation, composite annotations, and cross‑field verification with complete code examples.
This guide explains what Spring Boot Actuator is, how to add the dependency, configure exposed endpoints, use common health and metrics endpoints, secure access with basic authentication, limit exposure, and create custom endpoints with full code examples.
This article demonstrates how to implement a lightweight circuit‑breaker mechanism in Spring Boot 3 by defining a custom @Breaker annotation, a failure‑tracking component using LongAdder, and an AOP aspect that handles opening, probing, and fallback logic without external libraries.
This guide explains how to install and use the ANSIescape plugin in Sublime Text to render Spring Boot console logs with proper colors, eliminating unreadable ANSI escape codes and providing step‑by‑step instructions, troubleshooting tips, and ways to revert to plain logs.
This article introduces the EasyCode IntelliJ plugin, explains how it generates CRUD code for Java projects using custom Velocity templates, walks through installation and configuration steps with screenshots, and shows the necessary Spring Boot adjustments to get a fully functional backend up and running.
This guide explains why dynamic configuration refresh is essential, how Spring Boot’s @RefreshScope works, and provides step‑by‑step instructions—including Maven dependencies, Actuator setup, bean creation, and troubleshooting—to update settings on‑the‑fly without restarting the service.
This article explains why dynamic configuration refresh is needed in Spring Boot, details the @RefreshScope mechanism, provides step‑by‑step implementation code, and shares production best practices and troubleshooting tips for zero‑downtime config updates.
The article walks through a year‑long investigation of a 404 error that appears after updating Nacos dynamic routing in Spring Cloud Gateway 3.0.1, explains how stale weight caches cause the failure, and presents a custom event‑listener solution that synchronizes the gateway's weight cache with the latest Nacos configuration.
This article walks through building a robust, long‑running order‑processing workflow in Spring Boot 3 using the open‑source Temporal workflow engine, covering environment setup, Maven dependencies, configuration, workflow and activity definitions, service and controller code, and testing of retry and recovery features.
This article records and analyzes a production incident where multiple Spring Boot microservices each consumed around 12 GB of RAM, explains why the default JVM settings caused the overload, and provides step‑by‑step troubleshooting and tuning recommendations to prevent similar memory‑usage problems.
This tutorial walks through creating a browser‑based SSH client using Spring Boot, JSch, WebSocket, and Xterm.js, covering application scenarios, system architecture, backend and frontend implementation, file transfer features, database setup, performance tuning, and security best practices.
This article explains how to use JAXB with Spring Boot 3 for XML binding, custom adapters, schema generation, validation, and seamless integration, providing step‑by‑step code examples and best‑practice tips for handling XML in Java backend applications.
The article dissects the interview question about ES latency in a MySQL‑Canal‑to‑Elasticsearch pipeline, explains the root causes across four system layers, and presents a comprehensive four‑layer optimization, end‑to‑end observability, routing‑based degradation, and a Java‑based LatencyProbe component to measure and control delay.
This article explains why dynamic configuration refresh is needed in Spring Boot, details the @RefreshScope mechanism, provides step‑by‑step implementation code, and shares best practices and troubleshooting tips for zero‑downtime updates in production environments.
This article explains what a workflow engine is, outlines Flowable’s core architecture and BPMN support, and provides a step‑by‑step Spring Boot integration example—including Maven setup, BPMN model definition, and Java code for starting, submitting, and approving a leave request—while discussing version and archiving recommendations.
This article explains five practical ways to count QPS—from gateway and application instrumentation to monitoring tools, log analysis, and database metrics—while highlighting common pitfalls such as health‑check filtering, thread‑safety, and multi‑node aggregation, helping engineers make informed scaling decisions.
This comprehensive guide walks you through building robust Spring Boot backend APIs, covering environment setup, parameter validation with Validator and groups, custom validation, global exception handling, unified response structures, optional response wrapping, API version control via path and header, and essential security measures such as token authentication, timestamp checks, URL signing, replay protection, and HTTPS usage.
This article explores comprehensive strategies for dramatically reducing Spring Boot application startup latency, covering real‑world case studies, dependency slimming, JVM and CDS tuning, lazy and asynchronous bean initialization, GraalVM native image compilation, and advanced runtime techniques such as CRaC, with detailed metrics and step‑by‑step guidance.
This article introduces a free Spring Boot 3 ebook collection of 164 practical cases and shares ten powerful techniques—including custom @Conditional logic, lazy initialization, structured configuration binding, custom starters, Testcontainers testing, event‑driven programming, hidden Actuator endpoints, fine‑grained startup control, Tomcat performance tuning, and monitoring—to help developers build leaner, faster, and more maintainable backend services.
This article walks Java developers through integrating EasyExcel, defining data models, creating utility classes, handling complex headers, merging cells, custom formatting, and large‑scale streaming exports, while sharing practical pitfalls and solutions for robust Excel generation.
This article walks through building a reusable BaseController using MyBatisPlusPro in a Spring Boot application, covering dependency setup, utility methods for query conversion, generic CRUD endpoints, pagination configuration, and how to extend the controller for specific entities, providing ready‑to‑use code snippets for each step.
This article explains why uncaught exceptions can cripple a Java backend, demonstrates a three‑layer global exception handling strategy with Spring Boot, shows how circuit‑breaker rules further protect services, and provides real‑world data proving crash rates can drop from over 4% to under 0.1%.
The article walks through a detailed Java interview simulation where the candidate designs a high‑performance, microservice‑based e‑commerce transaction and fulfillment system, covering architecture decomposition, caching, concurrency control, distributed transactions, observability, AI‑driven recommendation, and a concrete career roadmap.
This guide shows how to create a Spring Boot and MyBatis interceptor that captures SQL execution, builds a hierarchical call tree, and visualizes it with D3.js, providing performance monitoring, statistics, and thread‑safe management for complex query debugging.
This article explains how to implement secure, time‑limited file access in Spring Boot 3 by generating signed URLs, covering the underlying mechanism, configuration properties, utility classes, REST endpoints, and testing procedures with full code examples.
This article provides a comprehensive interview‑style analysis of Server‑Sent Events (SSE), covering its definition, 20‑year history, core features, data format, Java Spring Boot implementation, client‑side EventSource usage, detailed comparison with WebSocket and other polling techniques, and a decision guide for choosing the right real‑time communication protocol in modern AI‑driven applications.
This guide shows how to integrate the Zlm4j library into a Spring Boot project to quickly set up RTSP, RTMP, HTTP, and RTP streaming services, configure ports, handle authentication and stream state events, and test the setup with ffmpeg and VLC.
This article presents a free, continuously updated collection of 160 practical Spring Boot 3 examples, organized into nine annotation categories with clear explanations and code snippets, allowing developers to master component scanning, bean lifecycle, dependency injection, MVC, configuration, JPA, exception handling, AOP, and testing.
This article explains how to implement a memory‑efficient sign‑in feature and continuous‑sign‑in statistics using Redis BitMap, covering basic commands, Spring Boot integration, key design, code examples, and advanced use cases such as cache‑penetration mitigation, providing step‑by‑step guidance for backend developers.
This tutorial walks you through creating a reusable BaseController in Spring Boot using MyBatis‑Plus, introducing a utility class for dynamic query building, configuring pagination support, and extending the controller for any entity to instantly gain full CRUD, list, pagination, sorting, and count operations.
This article walks through Spring Boot’s most useful built‑in features—including request logging, content‑caching wrappers, OncePerRequestFilter, AOP utilities, starter auto‑configuration, flexible property binding, async scheduling, Actuator monitoring, and SpEL expressions—showing how to apply them with concise code examples to boost productivity and reliability.
This article shares five practical techniques for using Wenxin Code's Zulu and Chat agents—covering context provision, automatic command execution, rule constraints, inline chat, and Git commit shortcuts—to make AI‑generated Java code more reliable, maintainable, and aligned with project standards.
This article explains a complete user login workflow—including registration, verification, token generation, expiration policies, gateway validation, logout, anonymous access, rate‑limiting, and blacklist handling—illustrated with diagrams and a Spring Boot implementation using Redis.
This article explains why masking sensitive data such as ID numbers, phone numbers, and bank cards is essential, then demonstrates five practical Spring Boot 3 solutions—including custom JsonSerializer, Jackson modules, AOP, ResponseBodyAdvice, and JsonFilter—complete with code examples and output screenshots.
This article introduces the Liteflow rule engine, explains its architecture, component types, EL rule syntax, data context handling, Spring Boot configuration, and demonstrates a real‑world e‑commerce order processing scenario with code examples and diagrams.
This article presents ten practical techniques—including lazy loading, lazy database initialization, selective auto‑configuration, log level tuning, JVM flags, dependency trimming, bean optimization, JIT tweaks, classpath scanning reduction, and DevTools restart—to dramatically reduce Spring Boot application startup time.
This article presents a free, continuously updated PDF collection of 161 Spring Boot 3 practical cases that demonstrate core utility classes, complete code snippets, and expected outputs, helping backend developers quickly master common Spring tools and patterns.
This article walks through creating a reusable MyBatisPlus‑based controller framework for Spring Boot, covering dependency setup, utility methods for query building and reflection, a generic BaseController with full CRUD endpoints, pagination configuration, and concrete controller extensions, enabling rapid development of RESTful APIs.
This article explains why controllers are essential yet often over‑engineered, identifies common problems such as tangled validation and inconsistent responses, and demonstrates how to unify return structures, handle String conversion, apply JSR‑303 validation, create custom validators, and centralize exception handling using Spring Boot features.
The article walks through a simulated five‑round Java interview where the candidate designs a high‑concurrency invoice‑issuing service, covering gateway architecture, async Kafka processing, cache strategies, JVM thread‑pool and memory tuning, database‑cache coordination, microservice messaging, system design, performance optimization and AI integration, all illustrated with concrete numbers and code snippets.
This article demonstrates a Spring Boot 3 multi‑module architecture where each module runs its own DispatcherServlet and ApplicationContext while sharing a common parent container, providing complete code examples, configuration steps, and testing insights for building loosely‑coupled backend services.
This guide explains how Spring Boot starters simplify dependency management, how the Spring Boot starter parent centralizes version control, and how to use the built‑in Maven plugin and DevTools for automatic restarts, including step‑by‑step Maven and IntelliJ configurations with code examples.
This tutorial demonstrates how to validate incoming JSON payloads in Spring Boot 3 by generating JSON Schemas, creating a custom filter that checks request bodies before they reach business logic, and registering the filter, complete with code examples and test screenshots.
Scaffolding tools—ranging from backend frameworks like Spring Boot, Maven, and Dropwizard to frontend solutions such as Vue CLI—streamline software development by promoting reuse, adhering to DRY and Open‑Closed principles, and preventing developers from reinventing the wheel, ultimately boosting productivity and maintainability.
This tutorial walks you through adding Spring Security to a Spring Boot project, from adding the starter dependency and creating a simple controller to observing the default login page, understanding the auto‑generated password mechanism, and customizing usernames and passwords for production use.
This article explains how to create a Spring Boot starter that lets you toggle between the native @Scheduled scheduler and XXL‑JOB at runtime via a configuration property, automatically scanning annotated methods, disabling Spring's tasks, and registering them as XXL‑JOB jobs with proper logging.
Learn how to perform comprehensive Excel CRUD operations in Spring Boot 3 using the Fillo library, covering environment setup, Maven dependency, SELECT, INSERT, UPDATE, DELETE, fuzzy search, distinct queries, and row/column configuration, complete with code snippets and result screenshots.
This article introduces the lightweight Jackson‑jr library for Java, demonstrates how to create JSON objects and arrays, use the Composer API, customize serialization with annotations, and presents JMH performance comparisons showing Jackson‑jr’s superior speed over Jackson‑databind and Gson in Spring Boot 3.4.2 environments.
Spring Boot 4, built on Spring Framework 7, introduces elegant API versioning, streamlined Bean registration, null‑safety annotations, simplified HTTP proxy creation, upgraded SPEL, GraalVM native support, Jackson 3.x, newer Servlet/WebSocket versions, and numerous other enhancements, offering developers more powerful and convenient tools.
This article explores the growing importance of retry mechanisms in distributed Spring Boot 3 applications, presenting five practical retry components—Spring‑Retry, Resilience4j‑Retry, Fast‑Retry, Easy‑Retry, and Guava‑Retrying—along with custom annotation examples, configuration details, code snippets, and execution results.
This comprehensive guide walks Java beginners through installing IDEA and JDK, explains Spring Boot 3 fundamentals, demonstrates project creation with Spring Initializr, shows Maven standard layout, configures a simple Hello World REST controller, and covers essential topics such as POM files, GAV coordinates, Maven Wrapper, static resources, templates and unit testing.
This comprehensive tutorial explains database sharding concepts, types, strategies, and implementation in Spring Boot using ShardingSphere, covering configuration, entity and repository code, service and controller layers, integration with pagination, Swagger, ActiveMQ, security, batch processing, FreeMarker, WebSockets, AOP, performance testing, FAQs, real‑world cases, and future trends.
This article provides a step‑by‑step tutorial on configuring Spring Boot to work with MinIO, covering YAML settings, property binding, utility classes for file upload/download, controller and service implementations, key technical points, and best‑practice recommendations for scalable backend file storage.
This article presents a comprehensive, high‑throughput OCR invoice processing solution that combines distributed system design, Spring Boot asynchronous execution, Tesseract deep optimization, multi‑engine fusion, structured data extraction, performance tuning, Kubernetes deployment, and security compliance.
This article explains why traditional if‑else logic hampers complex business rule maintenance and demonstrates how to create a flexible Spring Boot 3 rule engine using strategy and registry patterns, complete with interfaces, implementations, a registry, an engine, and a REST controller for testing.
This comprehensive guide explains how to design high‑quality Spring Boot controller layers, covering architecture planning, RESTful API conventions, parameter validation, unified response structures, exception handling, logging, security, testing, asynchronous processing, and performance optimization with practical code examples and clear best‑practice recommendations.
This article presents a comprehensive guide to optimizing API performance in Spring Boot projects, covering batch processing, asynchronous execution, caching, pre‑processing, pooling, parallelization, indexing, transaction management, code refactoring, pagination, SQL tuning, and lock granularity, complete with code examples and diagrams.
