This article walks through the design and implementation of a TCP long‑connection communication scheme using Netty and Spring Boot 2.2.0, covering project architecture, module layout, message flow, detailed code explanations, testing procedures, and deployment considerations.
This article explains why Disruptor—a lock‑free, high‑throughput Java queue from LMAX—was chosen over traditional brokers, details its core concepts such as RingBuffer, Sequence, and WaitStrategy, and provides a step‑by‑step SpringBoot demo that can handle up to six million orders per second without pressure.
This guide walks through why Retrieval‑Augmented Generation (RAG) is needed for large language models, explains the three‑step indexing and query workflow, details LangChain4j’s core components, and provides a complete SpringBoot example—including Maven setup, configuration, service code, and troubleshooting—to create a private document‑vector search system powered by Ollama.
This article walks through the design and implementation of a distributed image‑captcha login system using SpringBoot, Kaptcha, and Redis, comparing traditional session‑based approaches with a front‑back‑end separated architecture and providing complete code examples for each component.
This guide demonstrates how to integrate LangChain4j into a SpringBoot application to enable multi‑turn chat memory and per‑user session isolation using @MemoryId, configuring ChatMemoryProvider, updating the AI service interface, and testing with curl requests.
Easy‑Trans is a SpringBoot starter that provides five translation modes—simple ID‑to‑name, dictionary code‑to‑text, enum mapping, RPC cross‑service, and custom data source—allowing developers to replace repetitive lookup code with a single @Trans annotation, optionally enabled with caching for high performance.
Easy‑Trans is a SpringBoot starter that eliminates repetitive ID‑to‑name, dictionary code‑to‑text, and cross‑service field translation code by using a single @Trans annotation, offering five translation modes, Maven integration, YAML configuration, and optional Redis caching to boost performance and reduce boilerplate.
This article shows how to integrate Apache Tika into a Spring Boot application, enabling automatic detection and extraction of text and metadata from over a thousand file formats with only a few configuration steps and concise Java code.
Learn how to transform a simple LangChain4j demo into a production‑ready AI agent web application by designing a robust architecture, implementing multi‑agent orchestration, RAG, tool integration, session management, observability, security, and scalable deployment with Spring Boot, PostgreSQL, Redis, Kafka, Docker and Kubernetes.
This article provides a detailed walkthrough of SpringBoot plugin development, covering the benefits of modular decoupling, common implementation approaches such as Java SPI, custom configuration, Spring factories, and practical code examples that demonstrate how to create, load, and use plugins for extensible SMS services.
The article examines common pitfalls of using a simple parent_id column for menu hierarchies, compares three storage models—adjacency list, path enumeration, and closure table—shows their trade‑offs, and provides a SpringBoot/MyBatis‑Plus implementation that combines adjacency and closure tables for optimal read‑write performance.
Upgrading a Spring Boot application from 2.1.8 to 2.5.6 can break existing CORS configurations, but adding a WebMvcConfigurer bean with allowedOriginPatterns resolves the new cross‑origin restrictions, as demonstrated with concrete code examples.
This article explains how the open‑source Easy‑Trans library can be integrated into SpringBoot 3 projects to automatically translate dictionary, association, and enum fields using a single annotation, eliminating repetitive code while maintaining high performance and minimal configuration.
This article explains how to use SpringBoot’s plugin mechanisms—including Java SPI, custom configuration, and Spring Factories—to achieve module decoupling, dynamic extensibility, and easy third‑party integration, and provides step‑by‑step code examples and a complete micro‑service case study.
This comprehensive guide walks Java developers through designing, architecting, and implementing a scalable, secure, and observable enterprise AI question‑answering system that combines LLM calls, RAG retrieval, multi‑agent orchestration, memory management, tool integration, and high‑concurrency engineering best practices.
This tutorial explains OCR fundamentals, introduces Tesseract and its Java wrapper Tess4j, shows how to download language data, integrate Tess4j into a SpringBoot 3 project with Maven configuration, and provides test code for Chinese, English, and mixed‑language image recognition while highlighting performance considerations.
This guide explains why the FIRMS Java client was created, describes the FIRMS fire data service, details the library's modular structure, shows how to obtain a MapKey, provides Spring configuration and usage examples, and includes Maven installation instructions for seamless integration into Java or Spring Boot projects.
This tutorial walks through the fundamentals of OCR, explains how to download the required Tesseract traineddata files, shows how to add Tess4j as a Maven dependency, configure SpringBoot with custom properties, and provides complete Java test code for Chinese, English, and mixed‑language image recognition, highlighting performance considerations and file‑naming requirements.
This article reviews the Qoder JetBrains plugin, explaining its memory‑perception and dual‑engine architecture, detailing installation steps, showcasing an end‑to‑end Spring Boot voting app generated by the AI, and discussing model choices and practical benefits for Java developers.
This tutorial shows how to use the Java‑based magic‑api framework to generate Spring Boot HTTP endpoints directly from a UI, covering dependency setup, datasource configuration, database preparation, CRUD scripts, validation, result mapping, transaction handling, and Swagger integration.
This guide walks through installing magic-api in a SpringBoot project, configuring data sources, creating CRUD endpoints with magic-script, adding validation, transaction handling, and integrating Swagger for API documentation, complete with code snippets and configuration examples.
The article outlines the motivation, phased planning, architecture, task breakdown, implementation, and testing of a compact reminder platform built with Java 17/SpringBoot 3, Vue 3, Uniapp, MyBatisPlus, Redis, and RocketMQ, detailing each functional module and UI screen.
This guide walks through installing Nginx UI via Docker, configuring its dashboard, setting up static and dynamic proxy rules, and deploying a SpringBoot 3 + Vue e‑commerce project (mall) with both admin and front‑end services, demonstrating server monitoring, SSL management, and user authentication features.
This guide shows how to use Canal to capture MySQL binlog changes, forward them through RabbitMQ, and process them in a SpringBoot application, providing a clean, decoupled way to record both new and old data for insert, update, and delete operations.
The article explains how excessive if‑else branching in multi‑business systems harms code maintainability, and demonstrates how a workflow engine combined with a plugin extension mechanism can isolate business logic, simplify testing, and enable flexible execution chains, using the open‑source MemberClub project as a concrete example.
This article explains why large file downloads can fail on unstable networks, how to use HTTP Range headers and status codes for resumable downloads, and provides a complete SpringBoot implementation—including controller, service logic, and range‑parsing code—to enable reliable partial content delivery.
This article walks through installing Alibaba's CloudToolkit IntelliJ IDEA plugin and using it to automate the packaging, upload, and one‑click deployment of a SpringBoot application to a Docker container on a remote server, including terminal and file‑transfer features.
This guide introduces Alibaba’s free CloudToolkit IntelliJ IDEA plugin, explains how to install it, configure remote hosts, and use its built‑in terminal and deployment features to automatically package a SpringBoot application into a Docker image, upload scripts, and launch the container with one click.
It describes a fully open‑source Bilibili‑style video platform built with SpringBoot backend and Vue frontend, detailing system demo screenshots, functional requirements (video playback, upload, user, interaction, community), tech stack choices, video processing pipeline, deployment steps, and code acquisition instructions.
This tutorial shows how to implement graceful dynamic data source switching in SpringBoot by combining ThreadLocal with AbstractRoutingDataSource, configuring master/slave databases, adding a @DS annotation with AOP support, and enabling runtime addition of new data sources.
This guide explains how to integrate the Hera log platform into SpringBoot applications, covering architecture, Maven dependencies, YAML configuration, custom field providers, trace enablement, console usage, performance tuning, high‑availability design, and common pitfalls to dramatically improve log‑search efficiency in distributed systems.
This article walks through building an elegant dynamic data‑source switch in SpringBoot by combining ThreadLocal with AbstractRoutingDataSource, covering the context holder, custom routing class, YAML configuration, testing, annotation‑driven switching, and runtime addition of new data sources.
Integrating the Hera log platform into SpringBoot resolves common distributed‑system logging pain points—centralized storage, full‑trace linkages, and cost‑effective retention—by adding a non‑intrusive agent, configuring custom fields, enabling trace IDs, and providing a web console for rapid, multi‑service debugging and analysis.
This article introduces DynamicTp, an open‑source framework that extends Java's ThreadPoolExecutor to enable real‑time, configuration‑center‑driven parameter adjustments, live monitoring, alerting, and seamless integration with popular middleware thread pools, all while requiring zero code intrusion.
This article walks through converting a SpringBoot Maven project (mall‑tiny) to Gradle, explains Gradle’s key features and plugins, shows step‑by‑step setup, demonstrates dependency migration, compares build times with Maven, and provides a complete Gradle build script with reference links.
This guide walks through installing the Kingbase ES database via Docker, configuring persistence, adding the official driver to a Spring Boot project, adjusting the application.yml for PostgreSQL compatibility, and troubleshooting common container startup issues and SQL import procedures.
A performance comparison of SpringBoot 4.0 with virtual threads shows Tomcat achieving up to fifteen times higher QPS than Jetty, while startup times remain similar, and provides step‑by‑step instructions for building native Docker images and switching containers.
This article explains how to update a Spring Boot application without stopping the old process by letting a new instance start on the same port, detailing the Tomcat internals, the required ServletContainerInitializer callbacks, and providing a complete, step‑by‑step implementation with code samples and a live test.
Learn a practical approach to count online users in real time by leveraging Redis sorted sets (zset) with SpringBoot, covering user identification via tokens or browser fingerprinting, key Redis commands (zadd, zrangeByScore, zremrangeByScore, zrem), and scheduled cleanup logic.
This article explains how to invoke external services from a Spring Boot application using three approaches—raw HttpClient, Spring's RestTemplate, and Feign—providing code examples, configuration steps, and tips for handling headers and tokens.
The article examines five scenarios where Spring's @Transactional annotation falls short—stock shortage, MQ messaging, batch processing, logging, and isolation/timeout settings—and demonstrates six practical techniques, including programmatic transactions, parameter tuning, transaction synchronizers, event listeners, manual transaction control, and propagation strategies, all backed by runnable demo code.
This article presents a step‑by‑step experiment that uses JMeter to generate 20,000 HTTP calls against a SpringBoot 2.5.4 service, captures detailed GC logs, calculates the heap memory allocated per request, analyses the impact of request payload and logging, and offers practical tuning recommendations.
This article introduces a powerful visual service‑management script for SpringBoot applications that replaces manual start‑stop commands with an interactive, color‑coded console, offering configuration‑driven control, intelligent start/stop flows, real‑time monitoring, log handling, batch operations, automated deployment and safe rollback to dramatically improve operational efficiency and reliability.
A detailed benchmark shows that enabling Java virtual threads in Spring Boot 4.0 makes Tomcat handle up to fifteen times more requests than Jetty, while startup times remain similar, and the article explains the test setup, configuration steps, native image builds, and the reasons behind Jetty's limitation.
The article shares Xiao Meng’s full‑stack hiring process, listing practical first‑ and second‑round interview questions—from SQL pagination and SpringBoot CORS to RPC frameworks and AI‑assisted coding—while explaining the company’s focus on hands‑on ability and recent AI tool adoption.
This guide outlines a complete backend architecture for high‑volume GPS data, detailing the overall system flow, technology stack choices, Maven dependencies, data models, Kafka producer/consumer configurations, SpringBoot controllers, asynchronous processing, Redis caching, health checks, Docker deployment, and performance tuning recommendations to ensure stability and scalability.
The article explains how excessive if‑else branching in business‑centered back‑ends leads to tangled, hard‑to‑maintain code, and demonstrates how a flow‑engine combined with plugin extensions can isolate business logic, improve extensibility, and simplify testing, using the open‑source MemberClub project as a concrete example.
This article examines three practical approaches—microservice isolation, Redis‑based whitelist, and gateway‑plus‑AOP—to prevent external exposure of internal APIs, compares their trade‑offs, and provides a complete SpringBoot implementation of the gateway‑AOP solution with code samples.
This guide explains how to set up the open‑source Arthas Tunnel Server—covering its core features, Maven build steps, IDE and command‑line startup, Docker and Helm deployment options, and integration into Spring Boot applications using the eden‑architect framework.
A real‑world performance disaster caused by N+1 queries in a SpringBoot project was solved by replacing recursive database calls with a single batch query, building an in‑memory hash map, and adding multi‑level caching, achieving a 100× speedup and dramatically reducing system load.
An in‑depth comparison of anti‑hotlinking techniques shows how Nginx can enforce protection with a single directive in milliseconds, while SpringBoot offers five approaches—Filter, Interceptor, Nginx config, signed URL, and hybrid strategy—each with different performance, security, and maintenance trade‑offs.
This article dissects the SpringBoot class‑loading mechanism, explaining how the JVM parent‑delegation model is selectively overridden with custom class loaders like LaunchedURLClassLoader and RestartClassLoader, and how these changes integrate with Spring's bean lifecycle, auto‑configuration, and practical troubleshooting techniques.
This article explains why traditional SpringBoot logging falls short, introduces the Hera log platform’s three core benefits, outlines a layered integration architecture, and provides a detailed five‑step guide—including Maven dependencies, YAML configuration, custom field providers, log output, traceability, and console usage—plus performance, high‑availability, security tips and common pitfalls.
This article explains why traditional string‑search and regex methods struggle with large keyword sets, introduces the deterministic finite automaton (DFA) approach using a Trie structure for linear‑time matching, provides full Java implementations, and discusses real‑world applications and advanced optimizations such as double‑array Tries, Aho‑Corasick, and sharding with Bloom filters.
This guide shows how to containerize Java SpringBoot JAR or traditional WAR projects with Docker and Nginx, providing a unified, reproducible deployment pipeline that eliminates environment conflicts, simplifies port management, and enables seamless development‑to‑production transitions.
This article explains how to update a SpringBoot application without stopping the service by letting the old and new processes share the same port, detailing the underlying Tomcat and ServletContainerInitializer mechanisms, providing a step‑by‑step implementation and a demo for seamless zero‑downtime deployments.
This guide walks you through installing the RustFS distributed object storage via Docker, using its visual console, and configuring a SpringBoot project to upload and delete files through the RustFS S3‑compatible API, complete with code snippets and practical screenshots.
This guide explains how to embed the Netty framework within a Spring Boot application to handle custom protocols, covering Netty basics, Maven dependencies, server bootstrap configuration, custom decoder implementation, and event handler setup for robust, high‑performance asynchronous communication.
This guide explains how to determine the heap memory consumption of individual HTTP and RPC calls in a SpringBoot application by setting up a JMeter load test, enabling detailed GC logging, and analyzing the results to optimize JVM parameters and improve performance.
This article explains how to measure the exact heap memory consumption of individual SpringBoot HTTP and RPC requests by calculating required memory from request size, configuring JVM GC parameters, creating a JMeter test plan, collecting GC logs, and analyzing results to identify optimization opportunities.
This article measures the heap memory allocated by a single SpringBoot HTTP and RPC request using JMeter load testing and detailed GC logs, revealing that even tiny payloads can consume around 34 KB of heap, and discusses how request size, logging, and JVM settings affect memory usage and GC frequency.
This article explains how using JSON Schema as a single source of truth can drive both front‑end rendering and back‑end validation in Java SpringBoot applications, eliminating duplicated validation logic, reducing maintenance costs, and enabling dynamic, versioned forms with real‑time user feedback.
This guide walks through deploying OnlyOffice (Docker or Ubuntu), configuring the server, adding a Vue front‑end with the OnlyOffice API, building a Spring Boot controller to serve and save documents, handling callbacks, and troubleshooting common issues such as service status, token settings, and proxy configuration.
A popular claim that changing a Java field name from "userName" to "usrNme" can cut API latency by dozens of milliseconds is examined, revealing why hashCode calculations, reflection, and caching have negligible impact compared to real bottlenecks like I/O, GC, and thread scheduling.
DynamicTp is an open‑source SpringBoot starter that lets developers monitor, alert on, and adjust ThreadPoolExecutor parameters at runtime via popular configuration centers, offering zero‑intrusion integration, extensible metrics, multi‑channel notifications, and support for a wide range of middleware thread pools.
This article walks through the design and implementation of a complete seckill (flash‑sale) system built on SpringBoot, MyBatis, MySQL, RabbitMQ and Redis, covering double MD5 password hashing, distributed sessions, unified exception handling, caching strategies, memory flags, pre‑decrement inventory, asynchronous order processing, oversell prevention, and rate limiting, with code snippets and UI screenshots.
This guide presents a visual, configuration‑driven service manager for SpringBoot applications that streamlines start/stop operations, provides real‑time status and resource monitoring, offers intelligent log handling, supports batch actions, and includes an automated deployment and rollback workflow to improve operational efficiency and reliability.
SpringBoot 3.0 drops the long‑standing spring.factories file in favor of per‑extension imports files, eliminating full‑classpath scans, improving startup speed, aligning with Java modules, and enabling seamless GraalVM native‑image support, while providing a clear migration path for existing projects.
This article walks through extracting images from PDF files in a SpringBoot application and using Tess4j to perform OCR, comparing popular OCR libraries, showing configuration details, code snippets, and tips for improving accuracy and performance.
This article explains why traditional System.out printing is insufficient, introduces Spring Boot's built‑in SLF4J/Logback logging, demonstrates how to obtain and use a logger, details log levels, configuration of log levels, file persistence, rolling policies, formatting, and shows how Lombok's @Slf4j annotation can simplify logger usage.
Learn how to create flexible, low‑code dynamic forms by leveraging JSON Schema with SpringBoot on the backend and Vue3 on the frontend, covering schema definition, validation, storage, API design, and automatic UI rendering, plus advanced tips for versioning, low‑code builders, and multi‑platform support.
This article explains the recurring pain points of Java web report development and presents a self‑service visual reporting solution that uses metadata discovery, dynamic SQL generation, and drag‑and‑drop UI to let business users build charts instantly, dramatically reducing development effort.
This article presents twelve practical techniques for dynamically modifying SpringBoot configuration values without restarting the application, ranging from simple @Value listeners to advanced solutions such as Nacos, Apollo, dynamic data sources, in‑memory maps, scheduled polling, event‑driven updates, and Spring Cloud Config, helping developers achieve flexible and resilient runtime configuration management.
This article explains how to replace SpringBoot's default embedded Tomcat with the high‑performance Undertow server, details the necessary Maven changes, compares Tomcat and Undertow in terms of throughput and memory usage, and concludes why Undertow is the better choice for high‑concurrency Java web applications.
AipexBase, the first Chinese open‑source AI‑native backend‑as‑a‑service platform, lets developers and AI agents bypass traditional server, database, and authentication code by using an MCP‑compatible SDK, with step‑by‑step deployment, API key generation, and integration examples that demonstrate end‑to‑end intelligent app creation.
This article explains how to design and implement a plugin architecture in Java, covering the standard ServiceLoader SPI, custom configuration‑driven loading, dynamic JAR loading with reflection, and Spring Boot's spring.factories mechanism, complete with practical code examples and diagrams.
This guide walks you through the complete WeChat mini‑program login flow, covering front‑end wx.login usage, back‑end code2Session exchange for openId and unionId, phone number retrieval, database schema design, API contracts, token generation, interceptor validation, and environment configuration.
This guide shows how to integrate springdoc‑openapi 2.7.0 with Spring Boot 3.5.6 to generate an online Swagger UI, covering Maven dependencies, configuration class, annotation usage, response wrapper, version compatibility notes, and the URL to access the generated documentation.
This guide walks through setting up a Docker‑Compose environment, configuring Canal to capture MySQL binlog changes, integrating it with a SpringBoot client, and forwarding change events to RabbitMQ, providing complete code snippets and step‑by‑step instructions for real‑time data change tracking.
This article explains why front‑end debouncing is insufficient for preventing duplicate orders, then walks through four backend strategies—local cache with AOP, Redis atomic operations, database unique indexes, and token verification—providing core principles, code examples, and pros/cons for each.
This article explains why many large enterprises forbid the default Tomcat in SpringBoot projects, comparing memory usage, concurrency handling, architectural differences, and configuration flexibility of Tomcat and Undertow, and provides migration guidelines and real‑world case studies.
This guide explains how to add Alipay sandbox payment support to the open‑source mall project built with SpringBoot 3 and Vue, covering the required code changes, three‑step payment flow, and the minimal configuration needed to enable secure online transactions.
This guide walks you through creating a SpringBoot parent project, adding common, business, and API‑gateway submodules, configuring dependency management, structuring the repository, isolating logs, and building or running individual modules, while highlighting common pitfalls and best‑practice layouts.
Manual start‑stop, unclear status, scattered logs and risky rollbacks make SpringBoot production deployments error‑prone, while a visual, configuration‑driven Bash manager provides an intuitive UI, real‑time monitoring, intelligent start/stop, batch operations and automated deployment to dramatically improve efficiency and reliability.
SpringBoot’s “convention over configuration” simplifies development, but its default settings—such as limited Tomcat connections, minimal HikariCP pool size, unchecked JPA lazy loading, unrestricted file upload limits, and inadequate logging and caching—can cause performance bottlenecks and runtime failures, so this guide details essential configuration adjustments to ensure robust, production‑ready applications.
This guide walks you through adding the appropriate SpringDoc OpenAPI dependencies for Spring Boot 2.x or 3.x, configuring the library, creating sample controllers with OpenAPI annotations, customizing documentation metadata, and using advanced features like API grouping, hidden endpoints, and offline generation.
Learn how to implement a Java Agent that enables non‑intrusive monitoring of SpringBoot applications, covering agent basics, bytecode manipulation with Byte Buddy, metric collection via Micrometer, Prometheus/Grafana integration, and advanced extensions such as JVM metrics, HTTP client tracing, and distributed tracing.
This article walks through why SpringDoc replaces SpringFox, shows step‑by‑step minimal configuration, dependency setup, controller annotations, API grouping (both programmatic and declarative), and necessary adjustments for WebMvcConfigurer and Spring Security to generate OpenAPI 3 documentation in a Spring Boot project.
This article introduces a SpringBoot online debugging injector that lets backend developers add, adjust, and remove fine‑grained debug rules at runtime, eliminating midnight alarm calls, costly redeployments, and performance bottlenecks while keeping production services safe and uninterrupted.
This article explains why compressing large GeoJSON payloads is essential for WebGIS applications and provides step‑by‑step guidance on configuring Gzip compression globally or selectively in SpringBoot, complete with code examples and performance results.
This article explains the pain points of traditional Java backend debugging, compares existing solutions, and presents a SpringBoot zero‑impact online debug injector built with ByteBuddy, Java Instrumentation, and a lightweight Tailwind/Alpine.js UI that enables instant, precise, and secure method‑level debugging in production.
This article explains how to build a SpringBoot‑MyBatis interceptor that captures SQL execution, constructs a hierarchical call tree, and visualizes it with D3.js, providing real‑time performance monitoring and debugging for complex business systems.
This article explains how to achieve zero‑downtime updates for SpringBoot applications by allowing two processes to share the same port, detailing the underlying Tomcat and ServletContainerInitializer mechanisms, providing a step‑by‑step implementation with code examples, and demonstrating seamless hot‑swap without service interruption.
This article combines a visual ranking of overtime intensity at major Chinese internet firms with a comprehensive Java interview guide covering URL processing, DNS resolution, HTTP status codes, TCP termination, abstract classes vs interfaces, HashMap versus ConcurrentHashMap, HashSet internals, MySQL functions, and the SpringBoot startup sequence.
This article presents a SpringBoot‑MyBatis solution that captures SQL execution via an interceptor, builds a hierarchical call tree, visualizes it with D3.js, and provides REST APIs for real‑time monitoring, performance statistics, and configuration, helping developers debug complex queries and identify slow SQL.
This article demonstrates how to build a SpringBoot‑based SQL call‑tree visualization system using a MyBatis interceptor, D3.js front‑end, and thread‑local context to capture, organize, display and analyze SQL execution hierarchies, performance metrics and slow‑SQL detection for complex business applications.
Scaffolding tools—ranging from backend frameworks like SpringBoot and Dropwizard to frontend solutions such as Vue CLI—streamline development by enforcing reuse, DRY, and open‑close principles, reducing boilerplate, preventing reinventing the wheel, and accelerating microservice architecture adoption.
This article explains how to automate the handling of common entity fields such as creation time, update time, and user identifiers in Java backend services by using MyBatis-Plus automatic filling, custom AOP aspects, multi‑data‑source configuration, distributed ID generation, and auditing techniques, dramatically reducing boiler‑plate code and bugs.
This article examines common default configuration issues in SpringBoot—such as Tomcat connection limits, HikariCP pool size, JPA lazy loading, Jackson timezone handling, logging, caching, file upload limits, async execution, and transaction timeouts—and provides practical adjustments to improve performance and reliability in production environments.
This article combines a look at big‑tech work intensity with a comprehensive interview guide covering website request flow, DNS resolution, HTTP status codes, TCP four‑way handshake, Java abstract classes vs interfaces, HashMap vs ConcurrentHashMap, HashSet internals, MySQL functions, and SpringBoot startup steps.
