This article introduces an open‑source MyBatis‑Plus dynamic‑table starter, explains why dynamic table names are needed for large‑scale data, outlines its key features, provides step‑by‑step installation and quick‑start instructions, demonstrates advanced usage, debugging tips, FAQs, and real‑world scenarios.
This article explains how to design a consistent JSON response format for Spring Boot APIs, covering status‑code conventions, message handling, a reusable Result wrapper class, controller simplification, and a global @ResponseResult annotation with interceptor and advice for automatic response packaging.
This guide walks you through a fully open‑source, pure‑Java solution for converting uploaded .docx files to PDF in a Spring Boot application, covering library selection, Maven dependencies, a reusable utility class, controller implementation, and handling Chinese font issues on Windows and Linux.
Learn how to convert user‑uploaded .docx files to PDF in a Spring Boot application using the pure‑Java docx4j library, covering solution comparison, Maven dependencies, utility class implementation, controller endpoint, and handling Chinese font issues on Windows and Linux.
This guide explains how to integrate the asyncTool library into a Spring Boot project, configure custom thread pools, understand core interfaces like IWorker and ICallback, and use the provided Builder API to define serial, parallel, and mixed task flows with detailed code examples and best‑practice cautions.
Upgrading to Spring Boot 4 brings Jackson 3, which reorganizes packages, replaces ObjectMapper with JsonMapper, changes the default date format to ISO‑8601, and converts checked exceptions to RuntimeException, requiring developers to adapt code, adjust configurations, and understand the design rationale to avoid runtime bugs.
Upgrading to Spring Boot 4 brings Jackson 3, which introduces four major breaking changes—package reorganization, replacement of ObjectMapper with JsonMapper, a shift to ISO‑8601 date serialization, and the removal of checked exceptions—each explained with code examples, migration tips, and the rationale behind the design.
This article walks through building a pure‑Java DOCX‑to‑PDF converter in Spring Boot using docx4j, compares it with alternatives, shows Maven dependencies, provides a utility class and controller example, and explains how to resolve Chinese font garbling on both Windows and Linux.
Spring Boot 4 restructures the framework into independent auto‑configuration modules, reducing package bloat, speeding up startup, lowering memory usage, and providing more precise and flexible configuration options for developers migrating from earlier versions.
The author builds a lightweight Spring Pets test suite, evaluates three AI‑assisted migration strategies—contextual, incremental and hybrid—using OpenAI GPT‑4o, reports conversion coverage, performance, cost and practical challenges, and shares open‑source tooling for future Java framework migrations.
This guide walks through using JPackage (standard from JDK 16) to create native Windows, macOS, and Linux installers for Spring Boot applications, covering JDK requirements, platform‑specific tools, custom JRE creation with jlink, Maven integration, and step‑by‑step command examples.
The article demonstrates how to achieve a ten‑fold reduction in API response time by building a three‑level cache pyramid (Caffeine L1, Redis L2, DB L3) in Spring Boot 3, covering dependencies, configuration, core template code, warm‑up, monitoring, load‑test results and common high‑concurrency pitfalls.
This article introduces the Reflector library—a comprehensive Java reflection utility—covers its core features, shows how to download it from GitHub, and provides step‑by‑step code examples for accessing private fields, invoking methods, creating instances, handling annotations, copying objects, and more, all with expected output.
This article walks through designing a flexible login module that supports password, WeChat, and SMS authentication by applying the Strategy and Factory patterns in a Spring Boot project, showing code examples, project structure, and best‑practice tips for clean, maintainable backend development.
To keep Spring Boot applications stable under tens of thousands to millions of requests per second, this guide explains why load balancing evolves from a simple traffic splitter to a multi‑layer system and details seven critical strategies—from edge CDN to service mesh—required for resilient, cost‑effective high‑concurrency deployments.
json-io, a decade‑old Java JSON library known for zero‑config, circular‑reference support, and lightweight size, has added full TOON (Token‑Oriented Object Notation) read/write capabilities, a token‑efficient format designed for LLMs that can cut serialization costs by 30‑60% and integrates seamlessly with Spring Boot and Spring AI.
This guide explores eight lesser‑known Hibernate annotations—such as @EntityGraph, @Formula, @SQLRestriction, @SQLDelete, @JoinFormula, @Cache, @DynamicUpdate/Insert, and @Filter/FilterDef—demonstrating how they improve performance, simplify queries, and enhance data handling in Spring Boot 3 applications for developers.
This article evaluates popular Java web frameworks by measuring performance, ecosystem maturity, learning curve, development efficiency, enterprise adoption and innovation, providing concrete data and practical recommendations for each framework’s strengths, use‑cases and drawbacks.
This guide walks through constructing a sustainable performance‑engineering pipeline—from monitoring and metrics collection with SkyWalking, Prometheus, and Grafana, through targeted load testing and bottleneck analysis, to capacity modeling and alert solidification—for Spring Boot services.
This guide explains how to build, run, and deploy the open‑source Arthas Tunnel tool—including Maven compilation, Docker and Helm deployment, UI startup, and integration with Spring Boot via the eden‑architect framework—while providing configuration examples and repository links for quick setup.
This guide walks a junior developer through why logging is essential, how to configure Logback in Spring Boot, use Lombok @Slf4j, choose appropriate log levels, apply parameterized messages, control output volume, enable asynchronous logging, manage log files with rolling policies, and integrate a centralized ELK stack for distributed systems.
IntelliJ IDEA 2025.3 introduces a unified, 30% smaller edition, quieter development workflow, full Spring Framework 7 and Spring Boot 4 support, enhanced language features for Java, Kotlin and Scala, improved Git integration, terminal and build‑tool optimizations, plus performance upgrades for large web projects.
This article presents seven concrete Spring Boot startup optimization techniques—including lazy bean initialization, precise component scanning, JVM flag tuning, auto‑configuration pruning, class‑loading shortcuts, lazy database connections, and GraalVM native compilation—backed by real‑world benchmarks that reduce launch times by up to 71% across e‑commerce, micro‑service, logistics and payment services.
Spring Boot packages all dependencies and an embedded web server into a single executable JAR, allowing developers to launch the application with a simple "java -jar" command without external configuration or server deployment.
When a Spring Boot application using @Scheduled is deployed on multiple servers, each instance triggers the same job, leading to duplicate processing; this article explains why the problem occurs, reviews simple single‑node and Redis lock approaches, and provides a step‑by‑step guide to integrate the ShedLock framework for reliable, annotation‑driven distributed locking.
This article reveals ten hidden Spring Boot 3 configuration tricks—from disabling the whitelabel error page and shrinking Tomcat threads to enabling HTTP/2, tuning HikariCP, caching static assets, and leveraging Actuator metrics—each illustrated with code snippets and practical steps to boost application performance.
This tutorial demonstrates how to use Jackson's JsonNode within a Spring Boot 3 environment to parse dynamic JSON, access and modify fields, convert nodes to POJOs, traverse the tree, and perform path‑based queries, providing complete code examples for each operation.
This guide explains Java's Service Provider Interface (SPI) mechanism, compares it with APIs, and walks through creating a multi‑module Maven project that defines SPI interfaces, implements plugins, loads external JARs with a custom class loader, and integrates the plugins into a Spring Boot application for dynamic authentication.
The article evaluates 13 Java web frameworks across performance, ecosystem maturity, learning curve, development efficiency, enterprise adoption, and innovation, providing concrete metrics, strengths, suitable scenarios, and a tiered ranking from dominant to legacy options.
This article explains how to replace static permission annotations in Spring Boot with flexible SpEL expressions, showing step‑by‑step how to create a @PreAuth annotation, an AOP aspect, an expression parser, and a utility class that evaluates role‑ and time‑based access rules at runtime.
This guide explains why random UUIDs are inefficient as primary keys, introduces the TSID library that creates 64‑bit time‑ordered identifiers, and provides step‑by‑step Maven setup, API usage, JPA integration, and testing examples for Spring Boot 3.5.0.
This guide explains how to build a complete multi‑dimensional network bandwidth throttling solution in Spring Boot 3 using a custom token‑bucket algorithm, HandlerInterceptor, HttpServletResponseWrapper, and RateLimitedOutputStream to precisely control download, video streaming, and API traffic.
This article explains how to connect Spring Boot to external services by choosing the appropriate HTTP client (RestTemplate, Feign, WebClient), configuring beans, implementing service methods, and applying various data‑synchronization techniques such as full sync, UPSERT, incremental sync, webhook callbacks, and message‑queue based replication.
The article evaluates 13 Java web frameworks across performance, ecosystem maturity, learning curve, development efficiency, enterprise adoption, and innovation, classifying them into tiers—from the dominant Spring Boot to legacy Struts 2—based on objective metrics such as GitHub stars, benchmark results, and market usage.
The article explains how to achieve a graceful termination of a Linux process by sending SIGTERM (kill -15), how the signal translates into a thread interrupt that causes sleep to throw an exception, and why the end‑flag still prints in a simple Spring Boot‑style example.
This guide explains why @Scheduled jobs run on every Spring Boot instance in a cluster, and presents three practical solutions—Spring Integration's Redis lock, Redisson, and ShedLock—complete with Maven dependencies, configuration snippets, code examples, and runtime screenshots to guarantee that only one node executes the scheduled task at a time.
This guide explains how to embed the Arthas online monitoring tool into a Spring Boot application using the Arthas Spring Boot Starter, configure telnet and HTTP ports, access the console via terminal or web, and extend debugging across multiple services with Arthas Tunnel while addressing security considerations.
JSONPath offers a concise, XPath‑like syntax for extracting data from complex JSON structures, and this guide shows how to integrate it into Spring Boot, compare FastJSON, Jackson, and Gson implementations, and provides practical code examples, advanced configurations, and selection advice for Java projects.
Spring Boot 4.0.1 introduced a critical virtual‑thread configuration bug that disables Jetty’s virtual threads, causing massive CPU waste and slow responses; the article explains the bug’s cause, the official fix in v4.0.1, and provides upgrade steps, workarounds, and monitoring tips.
This article presents a complete Spring Boot 3 solution for multi‑dimensional network bandwidth throttling using a manually implemented token‑bucket algorithm, custom HandlerInterceptor, HttpServletResponseWrapper, and RateLimitedOutputStream, with detailed code samples, configuration options, and performance tuning guidance.
The article analyzes why Spring MVC controllers often become massive with repetitive validation, logging, and business logic, demonstrates an ugly controller example, then shows step‑by‑step refactoring using @Valid, assertion utilities, and a global exception handler to dramatically reduce code size and improve readability.
This guide explains why parameter validation is crucial for Spring Boot applications and walks through ten practical techniques—including built‑in annotations, custom constraints, server‑side checks, meaningful error messages, i18n, validation groups, cross‑field validation, exception handling, testing, and client‑side considerations—to help developers build robust, secure APIs.
The article shows how cluttered Spring controllers filled with try‑catch blocks, manual field checks, and business logic can be refactored into concise, readable code by using @Valid, assertion utilities, and a global exception handler, cutting the code size roughly in half.
This article introduces a ServiceManager component that uses Lambda expressions to automatically inject services, handle logging, cache service metadata, and manage exceptions, allowing Spring Boot controllers to call service methods with a single line of code.
This guide explains how to implement precise, multi‑dimensional network bandwidth throttling in Spring Boot 3 using a manually coded token‑bucket algorithm, HandlerInterceptor, HttpServletResponseWrapper, and RateLimitedOutputStream to control download, video streaming, and API traffic.
This guide details a step‑by‑step strategy for optimizing Druid in Spring Boot, covering environment setup, core pool parameters, monitoring, security hardening, leak detection, dynamic tuning, and common pitfalls to achieve high‑performance, stable, and secure database connections in production.
The article critiques the hype around unified Java data‑access libraries like dbVisitor, compares them with purpose‑built ORM Jimmer, and argues that in the AI era lightweight tools such as Spring Boot's JdbcClient may replace traditional ORMs altogether.
This article analyzes seven typical reasons why Spring transactions become ineffective or fail to roll back—such as wrong method visibility, final modifiers, self‑invocation, unmanaged beans, multithreading, non‑transactional tables, mis‑configured propagation or exception handling—and provides concrete code examples and practical solutions.
A detailed analysis shows that when a class is annotated with both @Configuration/@Bean and @Component, Spring creates only one bean—the one defined by @Configuration/@Bean—overriding the @Component definition, and explains how this behavior changed across Spring and Spring Boot versions.
This tutorial walks you through configuring Spring Boot 3.5.5 with ShardingSphere‑JDBC 5.5.2 to achieve database sharding, read‑write splitting, connection‑pool optimization using Druid, and demonstrates the complete code for entities, mappers, services, and controllers, plus verification steps.
This guide walks you through configuring JDK and Maven, installing essential VS Code extensions for Java development, setting up MySQL, creating a Spring Boot project with Maven, and running it using the Cursor IDE, including tips for troubleshooting common version and configuration errors.
This article explains how to design a highly available service registry for microservice architectures, covering high‑availability mechanisms, performance optimizations, scalability strategies, core registry functions, and provides a complete Java Spring Boot implementation using Redis.
By combining a local Caffeine cache, a remote Redis layer, and a MySQL database into a three‑tier cache pyramid, this guide shows how to reduce API response time from 28 ms to 2 ms, cut CPU usage by 35 %, and achieve up to 14‑fold performance gains, complete with configuration, code, and monitoring tips.
This article explains the TCC (Try‑Confirm‑Cancel) transaction model, its three practical variants, and provides a step‑by‑step guide with code examples for integrating Seata TCC into a Spring‑Boot e‑commerce order service, while addressing common pitfalls such as idempotency, empty rollbacks, and hanging transactions.
After upgrading IntelliJ IDEA, a Java project fails with the error ‘cannot access org.springframework.boot.SpringApplication – class file has wrong version 61.0’, which can be resolved by adjusting Maven runner settings to delegate IDE build actions to Maven and restarting the IDE.
This article walks through integrating Spring Boot with external APIs, comparing RestTemplate, Feign, and WebClient, and presents three data‑synchronization approaches—full, incremental, and real‑time—detailing step‑by‑step configurations, code examples, and the trade‑offs of each method.
After upgrading to Spring Boot 4, the article explains why both Jackson 2 and Jackson 3 appear together, outlines the four major breaking changes—including package reorganization, the shift from ObjectMapper to JsonMapper, new default date serialization, and the removal of checked exceptions—and offers migration tips.
This guide walks you through upgrading a Spring Boot project from 3.x to 4.0, covering Gradle version bump, dependency version catalog updates, starter module changes, Jackson 3 migration, Redisson API adjustments, and verification steps, while highlighting common pitfalls and official upgrade paths.
This article explains how to build short‑lived microservices using Spring Cloud Task on Spring Boot 3.5.0, covering environment setup, Maven dependencies, quick start code, configuration files, first task implementation, advanced options like custom table prefixes, external and parent task IDs, and task execution listeners with full code examples and screenshots.
This guide shows how to replace Spring Boot's default console banner by creating a custom banner.txt with ASCII graphics, using built‑in placeholders for version, port, profile and date, adding ANSI color codes, and optionally disabling the default banner to print a fully customized startup message from Java code.
This guide explains how to integrate Spring Boot DevTools into a Spring Boot project to achieve automatic hot deployment and remote debugging, covering Maven dependency setup, IDE configuration, Docker packaging, and step‑by‑step code examples.
The article shares a seasoned Java developer’s hands‑on review of IntelliJ IDEA 2025.3, highlighting the new Islands theme, built‑in support for Spring Boot 4 and Java 25, full‑line code completion, and integration of the Claude Code AI plugin, while offering practical usage tips and personal recommendations.
An in‑depth comparison of Spring Boot and Quarkus evaluates startup time, build speed, binary size, CPU, memory, and response latency using reactive APIs and native images, then outlines migration steps, Spring API compatibility, and practical benefits for developers moving Java microservices to Kubernetes‑native environments.
This article explains how @Autowired and @Resource differ in Spring Boot, covering their injection mechanisms, priority rules, applicable environments, and code examples, helping developers choose the appropriate annotation based on type‑based or name‑based injection needs.
The article explains why adding Redis alone often remains slow, introduces a three‑level cache pyramid (L1 Caffeine, L2 Redis, L3 MySQL) built with Spring Boot 3, and shows how this design reduces request latency from 28 ms to 2 ms, cuts CPU usage by 35 % and achieves up to 14‑fold throughput improvement.
Spring Boot 4 upgrades its default JSON processor to Jackson 3, introducing new package names, immutable builders, ISO‑8601 date serialization, and removal of checked exceptions, while preserving annotation compatibility for a smooth migration.
The article demonstrates how to combine Spring Boot 3, Caffeine local cache, and Redis into a three‑level cache pyramid, reducing API response time from 28 ms to 2 ms, cutting CPU usage by 35 %, and providing detailed configuration, code examples, performance benchmarks, and mitigation strategies for common high‑concurrency pitfalls.
This guide explains how to use Spring's built‑in Mapped Diagnostic Context (MDC) to generate a traceId for each request, configure Logback to include it in logs, and propagate the traceId through HTTP filters, RabbitMQ messages, thread‑pool tasks, and XXL‑Job scheduled jobs, complete with code examples and configuration snippets.
This guide shows how to integrate Apache Tika into a Spring Boot application by adding Maven dependencies, configuring a tika-config.xml file, creating a @Configuration class that provides a Tika bean, and using the bean to detect, translate, and parse various document formats.
This guide walks through integrating Spring Boot with external services using RestTemplate, Feign, and WebClient, then compares full, incremental, and real‑time data‑synchronization approaches, providing step‑by‑step code examples, configuration details, and practical trade‑off analysis.
This comprehensive guide walks you through the fundamentals, architecture, and key features of Ctrip's Apollo configuration center, then shows step‑by‑step how to create a Spring Boot client, manage environments, clusters, and namespaces, and finally package and deploy the application on Kubernetes with live configuration updates.
This guide explains how Spring Task turns Java applications into self‑managed schedulers, showing three quick steps to add the dependency, enable @EnableScheduling, and write @Scheduled methods, then dives into cron syntax, common use cases, pitfalls, performance tuning, and future enhancements.
Spring Boot 4.0 and Spring Framework 7 introduce a comprehensive overhaul—including Jakarta EE 11, JDK 25, JSpecify null‑safety, Project Leyden AOT, declarative HTTP clients, Jackson 3, native API versioning, built‑in resilience, OpenTelemetry, and a dual‑track Spring AI roadmap—providing developers with a modern, cloud‑native Java stack.
This tutorial walks through Jackson usage in Spring Boot 3, covering annotations for ignoring fields, renaming properties, custom serialization/deserialization, constructor handling, property visibility, date formatting, efficient JSON read/write, and enum handling with clear code samples and output screenshots.
This article explains how to build a lightweight, production‑grade idempotency middleware for Spring Boot 3 using AOP, a custom @Idempotent annotation, SpEL‑generated keys, and Redis atomic operations, covering architecture, core components, code examples, use cases, and performance characteristics.
This article explains Java's Service Provider Interface (SPI), compares it with traditional APIs, and provides a step‑by‑step guide to create a multi‑module Maven project, custom class loader, and Spring Boot application that dynamically loads authentication plugins from external JARs.
This comprehensive guide walks through preparing the environment, fine‑tuning core Druid pool parameters, building a robust monitoring system, strengthening security, detecting connection leaks, applying advanced runtime tweaks, and avoiding common pitfalls to achieve high performance and stability in production Spring Boot applications.
This article explains how Java's new virtual threads (Project Loom) can transform Spring Boot applications, delivering up to three‑fold QPS improvements and up to 67% lower memory usage, by replacing heavyweight platform threads with lightweight coroutine‑style execution, and provides detailed comparisons, benchmarks, code samples, and migration guidance.
Learn how to dramatically reduce Docker build times for Spring Boot applications by using the official Jarmode=tools layered jar feature, extracting layers, and employing multi‑stage Dockerfiles with optimized runtime settings, caching strategies, and optional security and performance enhancements.
After testing MiniMax M2.1 on a full‑stack e‑commerce order‑management task, the author finds the model correctly implements DDD layers, transaction handling, custom exceptions, and even generates a polished cyber‑punk UI, while its Java‑to‑Go code respects each language’s concurrency model and scores over 88 on the VIBE benchmark.
This article explains how Spring Boot 4.0’s @EnableMultiFactorAuthentication annotation simplifies the implementation of password‑plus‑one‑time‑token multi‑factor authentication, providing step‑by‑step code examples, custom token services, endpoint‑level MFA configuration, and production‑grade considerations.
This guide walks through preparing the environment, fine‑tuning core Druid parameters, managing connection lifecycles, building a monitoring stack, hardening security, detecting leaks, applying advanced runtime tweaks, and avoiding common pitfalls to achieve stable, high‑performance database pooling in Spring Boot.
The author, a non‑elite undergraduate and a modest 211 master’s graduate, shares a step‑by‑step 80‑day crash‑course that turned zero Java experience into multiple offers from major tech firms, emphasizing fundamental understanding, AI‑assisted learning, and thoughtful project trade‑offs.
The article explains why Druid can fail in a live Spring Boot service and provides a comprehensive, step‑by‑step optimization guide covering core pool parameters, monitoring setup, security hardening, leak detection, dynamic tuning, and best‑practice pitfalls to achieve stable, high‑performance database connections.
This article explains how to replace annotation‑based controllers with Spring Boot 3 functional routing, covering both servlet‑blocking and reactive WebFlux implementations, complete with code examples for handlers, routers, parameter validation, nested routes, filters, and resource redirects.
This guide walks through step‑by‑step how to prepare the environment, fine‑tune core Druid connection‑pool parameters, set up comprehensive monitoring, harden security, detect leaks, and apply advanced runtime optimizations to achieve stable, high‑throughput database access in Spring Boot applications.
This guide walks you through designing a scalable login module that supports dozens of authentication methods by combining the Strategy and Factory patterns with Spring Boot, providing clean code, easy extensibility, and robust testing without the tangled if‑else spaghetti.
This article explains the concept of software scaffolding, why it is essential for modern microservice development, and reviews popular scaffolding tools such as Spring Boot, Vue, Maven, Netty, Java EE, and Dropwizard, highlighting their benefits and practical usage.
Upgrading to Spring Boot 4 can cause missing @WebMvcTest, MockMvc, and other compilation errors because the framework modularizes its large autoconfigure JAR into many smaller starters, requiring updated dependencies and configuration changes to restore test execution and improve startup performance.
This article explains how Apache Ignite's memory‑first architecture, distributed compute grid, and event‑driven streaming enable sub‑100 ms decision making, high throughput, and strong consistency for real‑time bidding platforms, with practical code examples, Spring Boot integration, monitoring tips, and security considerations.
This article explains how to perform a graceful shutdown of Java services by using Linux kill signals, configuring JVM SignalHandler and Runtime shutdown hooks, releasing resources such as thread pools and sockets, and exposing a Spring Boot Actuator endpoint for controlled termination, complete with code examples and configuration details.
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 guide with code examples for Spring Boot integration.
This tutorial walks you through setting up a local Java Spring Boot service, installing and configuring cpolar for HTTP tunneling, creating and fixing a public address, and using the cpolar listener to monitor and replay API requests, complete with code snippets and screenshots.
This article demonstrates how to replace tangled if‑else login code with a clean Spring Boot solution that combines the Factory and Strategy patterns, enabling easy addition of multiple authentication methods such as password, WeChat, SMS, and future providers while improving extensibility, readability, and testability.
This article walks through analyzing a Spring Boot microservice project, configuring parent and child Maven pom files, packaging the required backend modules, and deploying both the backend JARs and the frontend static assets to a server using Java and http‑server.
Discover ten practical Spring Boot configuration techniques—including YAML anchors, externalized secrets, profile groups, type‑safe properties, random values, and cloud‑aware settings—that reduce duplication, improve safety, and make multi‑environment management effortless.
This article explains the trade‑offs between using a shared thread pool and creating dedicated pools in Java backend services, outlines scenario‑based decision rules, provides concrete Spring‑Boot configuration examples, and offers advanced dynamic tuning and interview‑style Q&A for reliable concurrency management.
This guide explains why sensitive configuration and user data must be encrypted in Spring Boot projects, demonstrates how to use Jasypt for property‑level encryption and custom AOP‑based field masking, and dives into the underlying PBE algorithm and source‑code mechanics.
This article walks you through creating a GraphQL API in Spring Boot 3 using the GraphQL SPQR library, covering environment setup, model and service definitions, resolver implementation, controller configuration, and optional starter usage with full code examples.
This guide explains what Spring Task is, walks through three steps to set up scheduled jobs in Spring Boot, demystifies Cron expressions, showcases common use cases, offers advanced configuration tips, warns about pitfalls, and outlines performance‑tuning and future directions for reliable backend scheduling.
