The article examines the One‑Billion‑Row benchmark challenge, showcasing a GraalVM‑powered Java solution and comparing its performance against dozens of languages—from C and Rust to Python and JavaScript—highlighting stark speed differences and the impact of AOT and JIT compilation techniques.
This article explains the concept of SQL injection, demonstrates a vulnerable query example, and provides a step‑by‑step Spring Boot and MyBatis implementation—including table creation, Java controller, service, DAO, mapper, and configuration—to illustrate how proper parameter handling prevents injection attacks.
Spring developers should replace the deprecated RestTemplate with the reactive WebClient, which offers non‑blocking I/O, a fluent functional API, streaming support, richer error handling and configurable timeouts, while still allowing synchronous calls via block(), as demonstrated by practical Spring Boot 3 code examples.
This tutorial walks you through creating a Spring Boot project, configuring OpenAI credentials, building a controller, and using Spring AI's Prompt and PromptTemplate classes to integrate generative AI capabilities into your backend application.
This article explains the core concepts, architecture, and implementation details of Xxl-Job, a lightweight distributed task scheduling platform, covering the scheduler center, executor, job handling, demo setup, routing strategies, trigger mechanisms, and result callbacks.
This article explains how Spring's @Configuration annotation triggers CGLIB proxy generation to manage @Bean methods, ensuring that internal calls return the same singleton instance, and contrasts this behavior with using @Component for configuration classes.
This article explains the Snowflake ID algorithm, its 64‑bit structure, provides a complete Java implementation, discusses common issues such as clock rollback and node ID management, and compares Snowflake IDs with UUIDs while suggesting Baidu's UidGenerator as a robust improvement.
This article explains Zookeeper's session management mechanism, detailing why TCP alone is insufficient for client liveness detection, how Zookeeper implements its own heartbeat protocol, and the internal data structures and algorithms—including expiryMap and SessionTracker—that efficiently track and expire sessions.
This article explains why MQ is needed beyond in‑process event listeners, details the required dependencies for Spring Boot 3, shows how to configure RocketMQ, provides code snippets for producer, consumer, and testing, and offers practical tips for handling async, batch, and one‑way messaging.
This guide explains how to secure Spring Boot API responses using RSA asymmetric encryption, covering the theory of RSA, practical scenarios, Maven setup, annotation‑based encryption/decryption, configuration files, and a JavaScript front‑end example for encrypting request payloads.
This article explains how to use MyBatis's @MapKey annotation to map query results into a Java Map, compares common data‑retrieval approaches, provides a concrete example with mapper code, and delves into the internal parsing and result‑handling mechanisms that enable key‑value mapping.
A Chengdu software engineer shares a candid, step‑by‑step recount of his job‑hunting journey, from low‑pay outsourcing traps to tough interview questions on Java, cloud, data structures, and design patterns, culminating in a modest offer and hard‑earned lessons for future candidates.
This article analyzes whether Java lambda expressions can lead to memory leaks similar to anonymous inner classes by comparing their compiled bytecode, demonstrating that lambdas only retain a reference to the outer class when they explicitly capture its members.
This article introduces a lightweight, open‑source SMS platform built with SpringBoot and Vue, explains its server‑side architecture, provides step‑by‑step deployment instructions, and demonstrates how to send templated messages using a simple Java SDK.
This article explains how to configure Guava Cache with expiration and refresh policies, analyzes its thread model under high concurrency, and presents two implementation approaches for asynchronous refresh combined with multi‑level caching to achieve low latency and reduced GC overhead.
This article explains Spring's bean scopes—including singleton, prototype, request, session, and application—detailing their lifecycles, appropriate use cases, and how to configure them with code examples, while also covering common pitfalls and proxy solutions for web environments.
This article presents a detailed three‑step plan used by Zhezhuan to detect and eliminate zombie services, unused code methods, and obsolete component dependencies through monitoring, static analysis with Spoon, and Java‑agent based runtime tracing, achieving significant resource savings and improved code health.
This article explains how to automate repetitive unit‑conversion tasks in Java backend code by first using a map‑based reflection utility and then enhancing it with a custom annotation to declaratively specify conversion types for DTO fields.
This article explains why duplicate form submissions occur, the risks they pose, and demonstrates a Spring Boot solution that uses a custom @RequestLock annotation together with Redis SETNX to generate a unique key and block rapid repeated requests, complete with project setup, code examples, and usage instructions.
This article explains how Domain‑Driven Design (DDD) combined with Spring Data JPA enables clean, object‑oriented modeling of order workflows, introduces the Repository pattern for persistence, and demonstrates the full lifecycle—from creation to address modification and payment—through concise Java code and SQL examples.
This article provides a step‑by‑step guide to building a Spring Boot starter that abstracts Amazon S3‑compatible object storage services such as Alibaba Cloud OSS, Tencent COS, Qiniu OSS, and MinIO, covering dependency setup, configuration properties, template interfaces, implementation, auto‑configuration, packaging, and testing.
This article provides a comprehensive, step‑by‑step analysis of MyBatis, covering its core features, three‑layer architecture, configuration file parsing, dynamic proxy generation, and the detailed process of executing SQL statements within the framework.
This article explains why scheduled jobs run twice in a multi‑node deployment, shows how to isolate the timing logic into a single service, and demonstrates using ElasticJob with Zookeeper for sharding, distributed locks, and high‑availability to ensure each task executes exactly once.
This tutorial explains how Spring's internationalization (i18n) works, covering core APIs, bean initialization, configuration for both classic Spring and Spring Boot, message resource files, placeholder usage, and convenient accessor utilities, with full code examples for seamless multi‑language support.
Spring’s transaction propagation defines seven behaviors—REQUIRED, SUPPORTS, MANDATORY, REQUIRES_NEW, NOT_SUPPORTED, NEVER, and NESTED—detailing how methods join, create, suspend, or nest transactions, and the article explains each type, practical scenarios, and how proper selection ensures atomicity, consistency, and correct rollback handling.
This article explains how to implement API request rate limiting in Spring Boot by creating a custom @RequestLimit annotation, using Redis to track request counts, and configuring a HandlerInterceptor and WebMvcConfig to enforce limits on controller methods.
This article introduces the Hutool Java utility library, outlines its modules, shows how to add it to a Maven project, and provides practical code examples for HTTP requests, random codes, pinyin conversion, timing, number handling, data masking, email sending, and Bloom filters, demonstrating how Hutool can streamline backend development.
This tutorial explains why BeanUtil.copyProperties is discouraged in Java projects and shows how to install and use the Bean Converter IDEA plugin to automatically generate setter injection code, streamlining bean mapping and improving development efficiency.
This article introduces a Java virtual‑thread based asynchronous task framework, detailing its design constraints, a thread‑safe task queue, daemon thread management, and overloaded execute methods for Runnable and Groovy Closure, along with code examples and performance testing considerations.
This article explains how to execute two dependent tasks in parallel, guarantee their successful completion before a final step, and maintain transaction consistency across multiple threads in Spring by using CompletableFuture, programmatic transaction management, and a custom transaction‑resource copying mechanism.
This article walks through a real‑world performance overhaul of Apache HttpClient—using a singleton client, connection pooling, a custom keep‑alive strategy, timeout tuning, and idle‑connection monitoring—to reduce average request time from 250 ms to about 80 ms for a high‑throughput service.
This article compares placing a try‑catch block inside versus outside a Java for‑loop, showing concrete code examples, execution results, memory‑usage measurements, and practical recommendations based on how exceptions affect loop termination and performance.
This article examines the causes of slow startup in large Spring applications, presents visual analysis techniques and a toolbox—including Arthas, JVM Sandbox, Async Profiler, and Spring Startup Analyzer—and provides concrete installation, configuration, and optimization procedures that can reduce startup time by 70‑80% while improving development efficiency and resource utilization.
This guide walks developers through upgrading from Spring Boot 2.x to 3.x, covering JDK 17 migration, pom.xml changes, configuration property updates, Jakarta EE transition, security reconfiguration, Kafka template adjustments, and OpenAPI integration, with code examples for each step.
An in‑depth Spring Security guide covering custom configurations, authentication providers, user‑details services, path‑based authorization, role hierarchies, exception handling, custom filters, multiple filter chains, method security, internationalization, and session management, complete with practical code examples for Spring Boot 2.7.
The article outlines which Java technologies—such as JSP, Struts, Hibernate, Servlet, Applet, Swing, JDBC, and XML—are now largely obsolete or unnecessary to learn for modern backend development, offering criteria for judging relevance and recommending focus on current frameworks like Spring MVC and MyBatis.
This article details a step‑by‑step optimization of Apache HttpClient—including connection pooling, keep‑alive, singleton client usage, timeout tuning, and response handling—to reduce average request latency from 250 ms to about 80 ms in a high‑throughput Java service.
This article provides an in‑depth overview of Java's BigDecimal class, covering its purpose for high‑precision arithmetic, frequently used constructors, essential methods for arithmetic and conversion, techniques for formatting numbers, handling of common exceptions, and includes practical code examples and a utility class for precise calculations.
This article compiles a comprehensive set of ByteDance daily internship interview questions covering Java backend fundamentals, networking protocols, operating system concepts, Linux process management, Redis data structures and persistence, MySQL indexing and query optimization, as well as essential algorithms, providing detailed explanations and code examples for each topic.
To achieve fast bulk inserts in MyBatis, open a session with ExecutorType.BATCH and insert records individually (letting JDBC batch them), limit foreach‑generated statements to about 20‑50 rows, or use MyBatis dynamic‑SQL or plain JDBC batch, avoiding massive SQL parsing and CPU overload.
This article introduces SpringBoot 3.2's JdbcClient, explains how to add the dependency, inject it, and demonstrates fluent‑API query and insert operations—including positional, named, map‑based parameters and custom RowMapper—showing how to perform CRUD without heavyweight ORM frameworks.
This article introduces PowerJob, a Java‑based enterprise distributed task scheduler, outlines its key features, installation methods, step‑by‑step server and client setup, task creation, and detailed configuration options for robust backend job management.
This article documents how the Helios scoring service, which originally took several seconds to retrieve a day's worth of data, was optimized from hundreds of milliseconds down to tens of milliseconds by analyzing Arthas trace data and applying multiple code and algorithm improvements.
This article explains how to estimate capacity, choose appropriate garbage collectors, and configure JVM memory settings—including heap size, young generation, thread stack, and GC options—for a service that processes one million login requests per day on a node with 8 GB of RAM, providing step‑by‑step guidance and example command lines.
This guide explores the JDK command‑line utilities located in %JAVA_HOME%\bin, explaining how tools such as jps, jstat, jinfo, jmap, jhat and jstack can be used to monitor JVM processes, analyze performance bottlenecks, inspect memory usage, generate heap dumps, and adjust runtime parameters for more efficient and stable Java applications.
This article demonstrates three practical techniques—using a HashSet, leveraging Java 8 Stream API, and applying Map's merge functionality—to combine two List collections while eliminating duplicate elements, complete with full Java code examples and output illustration.
This article explains the concept, advantages, and implementation methods of Single Sign‑On (SSO) and provides two complete hands‑on examples—including architecture diagrams, database schema, configuration, and Java code for token‑based, ticket‑based, and RSA/AES encrypted SSO flows—using SpringBoot, Vue and Uni‑App.
This article presents a Java-based rule engine design, illustrating rule abstraction, concrete rule implementations, and a flexible executor supporting AND/OR logic, accompanied by code examples and a discussion of its advantages and drawbacks for maintainability.
This article introduces Java 8 Stream API, explains how to create streams from collections, demonstrates common intermediate operations such as filter, map, flatMap, limit, skip, distinct, sorted, peek, and shows terminal actions like forEach, count, max, min, findFirst, findAny, and match methods with practical code examples.
This article compiles common technical interview questions for bank software positions, covering Java fundamentals, MySQL storage engines and indexes, thread‑pool parameters, HTTP GET/POST differences, TCP vs UDP characteristics, session and cookie handling, Redis data types, and C++ memory management, providing concise explanations and examples for each topic.
The article first presents a detailed analysis of Tencent's 2024 campus recruitment salary packages for various programmer offers, then introduces a classic algorithmic challenge of reversing a linked list in groups of k nodes, providing step‑by‑step explanation and a complete Java implementation.
The article outlines how the Taobao “Calm Guard” project accelerates rapid‑iteration development by employing reusable patterns—including a Spring‑based Strategy registry, a hierarchical fatigue‑control framework, generic cache upsert via functional parameters, and precise AOP aspects—resulting in faster, more stable, and maintainable code.
This article presents a curated list of the twelve most popular Java open‑source projects on GitHub in May 2023, providing repository URLs, star counts and concise descriptions to help developers discover valuable resources across backend, cloud‑native, and data‑integration domains.
This tutorial walks through Spring AOP's control flow pointcuts and introduction advice, showing how to define dynamic pointcuts, create advisors, and use @DeclareParents to add interfaces to beans, complete with practical code examples and output analysis.
This article explains how to design and implement a distributed rate‑limiting solution that supports multiple concurrent rules—such as per‑minute and per‑hour limits—by analyzing the shortcomings of simple string counters, introducing atomic Lua scripts and Zset structures, and providing complete Java annotation and AOP code examples.
This article details the background, pain points, and step‑by‑step technical solution behind refactoring a massive 670,000‑line, 46‑module ticketing application at Alibaba, highlighting architecture redesign, code simplification, performance gains, and a pragmatic rollout plan.
This article explains how Java's break and continue statements work, demonstrates why a simple break cannot exit nested loops, and shows how to use labeled break (and similarly labeled continue) to terminate all loops at once with clear code examples.
Rate limiting protects system stability by capping request rates, and this article explains five Java algorithms—Fixed Window, Sliding Window, Leaky Bucket, Token Bucket, and Guava's RateLimiter—showing their principles, pros and cons, and providing sample implementations and a Spring @Limit annotation for practical enforcement.
This guide walks through configuring the Alipay sandbox, adding Maven dependencies, setting up application.yml, implementing Java configuration classes, creating controller endpoints for payment, handling asynchronous callbacks, processing refunds, and using RabbitMQ delayed queues to auto‑cancel unpaid orders, all with complete code examples.
This article explains ten practical techniques for implementing robust parameter validation in Spring Boot applications, covering built‑in annotations, custom constraints, server‑side checks, internationalization, validation groups, cross‑field rules, exception handling, testing, and the importance of complementary client‑side validation.
This article explains why traditional LIKE queries fail on encrypted sensitive fields, analyzes common scenarios, and presents four practical solutions—including tokenized ciphertext mapping—along with environment setup, Maven dependencies, and complete Spring Boot code to enable secure fuzzy searches on encrypted data.
Tired of manually creating entity classes, CRUD interfaces and SQL for dozens of tables, the author built an open‑source utility that generates complete backend code—including models, DAOs, services and controllers—in a single click, dramatically cutting development time.
This article explains the definitions, characteristics, and overflow cases of sequential and circular queues and stacks, provides Java implementations for these data structures, demonstrates their usage with sample code and results, and discusses practical applications of queue thinking in database-driven workflows.
This article explains how to monitor, interpret, and optimize Java Garbage Collection by using JDK flags, IDE configurations, and the gceasy.io visualizer, providing step‑by‑step guidance, sample logs, and performance metrics for effective JVM tuning.
This article explains various comparison methods in Java, including equality operators, the equals() method, Comparator and Comparable interfaces, and provides code examples for primitive, object, string comparisons, as well as custom sorting logic, highlighting their roles in sorting, searching, and data handling.
This guide explains why and how to create a custom HttpMessageConverter in Spring Boot 2.7.12, covering the implementation of the converter, its registration in the MVC configuration, testing with Postman, and the underlying request‑response processing mechanism.
This article explains seven subtle issues when using Spring's BeanUtils.copyProperties—such as type mismatches, null overwrites, wrong imports, inner‑class copying failures, shallow copy side effects, and performance drawbacks—providing code examples and recommendations to avoid them.
This article explains the inner workings of Nacos' long‑polling mechanism, covering both client‑side scheduling and server‑side handling, with detailed code walkthroughs, architectural diagrams, and insights into how configuration changes are detected and propagated in a distributed system.
This article introduces four powerful IntelliJ IDEA debugging techniques—adding log statements at breakpoints, using field breakpoints, configuring exception breakpoints, and setting method breakpoints—to help developers efficiently trace code execution and inspect variables without cluttering the source.
Learn how to use Spring's @Nullable annotation (or its Java equivalents) to safely handle missing beans during dependency injection, avoiding startup errors, with code examples, underlying mechanism details, and comparisons to other approaches like required=false, Optional, and ObjectFactory.
This article introduces Java thread pools, explaining their purpose, creation using ThreadPoolExecutor, execution flow, advantages such as resource reuse and management, common blocking queues, rejection policies, and provides multiple code examples of various pool types and a comprehensive monitoring example.
This article introduces mybatis-plus-generator-ui, a highly customizable web‑based code generator built on MyBatis‑Plus that supports multiple databases, offers interactive UI for generating Entity, Mapper, Service, Controller and other layers, and provides detailed usage, configuration, and extension instructions for Java backend developers.
This article presents mybatis-plus-generator-ui, a web‑based code generation framework that wraps MyBatis‑Plus, explains its features, shows how to integrate it via Maven and a Spring Boot entry point, demonstrates customization through templates and NameConverter, and provides guidance for building the UI frontend.
This article explains how Java achieves "write once, run anywhere" through platform‑independent bytecode, describes the .class file structure, introduces tools for viewing bytecode, and provides detailed guidance on using the ASM library’s Core and Tree APIs for bytecode enhancement, including practical code demos and application scenarios.
This article demonstrates five Java thread‑communication approaches—using a volatile flag, Object.wait()/notify(), CountDownLatch, ReentrantLock with Condition, and LockSupport—each illustrated with complete code examples and explanations of their behavior and limitations.
This article explains why RocketMQ messages can pile up, analyzes the consumer pull‑process bottlenecks of consumption latency and concurrency, and provides practical strategies—including logging, JVM stack inspection, and concurrency tuning—to identify and eliminate the root causes of message backlog.
This tutorial explains how to integrate Feign‑reactive into a Spring Boot 2.7 application, covering dependencies, reactive interface definitions, fallback handling, custom configurations, timeout, load‑balancing, and circuit‑breaker settings with complete code examples.
This article explains how to diagnose and dramatically reduce SpringBoot service startup latency by examining SpringApplicationRunListener phases, Bean scanning overhead, BeanPostProcessor timing, and cache auto‑configuration, then applying JavaConfig and starter‑based solutions to cut startup from minutes to seconds.
This article explains how to install pycryptodome (or pycryptodomex) to perform SM2 signing and verification in Python, provides complete code examples, and offers guidance for ensuring compatibility with Java's Bouncy Castle SM2 implementation.
This article explains the concept of idempotency, why it is essential for API reliability, and demonstrates four practical idempotency strategies—including database primary keys, optimistic locking, token validation, and Redis caching—implemented via custom annotations and the Strategy pattern in a Spring‑Boot Java project.
Jedis uses Apache Commons’ GenericObjectPool to manage Redis connections, with Spring‑Data‑Redis creating a JedisConnectionFactory that holds a configurable pool where borrowObject and returnObject handle idle queues, eviction and validation settings (testOnBorrow, testWhileIdle, etc.) can be tuned, and JMX metrics aid troubleshooting.
This article explains how to dynamically modify Cron expressions for scheduled tasks in SpringBoot applications, covering @EnableScheduling, @Scheduled, mutable and immutable task configurations, custom interfaces, and code examples for registering, refreshing, and managing tasks at runtime without external schedulers.
The article details a step‑by‑step investigation of a Spring Boot service that failed to meet a 500 requests/second target, analyzes slow SQL, thread‑pool misconfiguration, excessive logging, and high CPU usage, and presents concrete optimizations that roughly doubled throughput.
This article explains how to implement a hot‑plugable AOP mechanism in Spring that lets end users enable or disable logging advice at runtime by dynamically adding or removing Advice, Advisor, and Proxy definitions through custom endpoints and event listeners.
This article explains how to classify interface exceptions, implement unified handling using Spring Boot's @ControllerAdvice and custom ErrorController, and provides practical code examples for business, system, client, and filter exceptions, including redirect and error page strategies.
This article explains how JVM synchronized locks and MySQL row locks can interact to cause deadlocks, demonstrates the problem with sample Spring code, shows the resulting lock‑wait timeout exception, and provides a refactoring solution to avoid the deadlock.
This article explains how the open‑source AutoDev plugin builds an end‑to‑end AI‑assisted coding solution that fine‑tunes open LLMs, constructs a Unit Eval dataset, engineers prompts for unit‑test generation, and enforces quality through a unified write‑evaluate pipeline.
This article walks through the painful migration from Apache HttpClient 4.x to 5.3, detailing modular design, customization, HTTP/2 support, connection management, API changes such as retry strategy, request/response configuration, interceptors, async client, and provides concrete Maven snippets and code comparisons to help developers evaluate whether the upgrade is worthwhile.
This article walks through multiple ways to add text or image watermarks to PDF files in a Spring Boot application, covering Apache PDFBox, iText, Ghostscript command‑line, Free Spire.PDF, and Aspose.PDF, with Maven dependencies, step‑by‑step code examples, and practical tips for preserving original documents.
This article explains how to set conditional breakpoints in IntelliJ IDEA to skip unnecessary iterations during debugging, illustrating the technique with a Java loop example and highlighting its usefulness for locating issues in complex code structures.
This article revisits defensive programming, explores quirky variable‑naming techniques—including single‑character, Chinese, and multilingual identifiers—and humorously breaks down core OOP concepts while stressing the developer’s irreplaceable role in modern software projects.
This article explains how to set up WebSocket communication in Spring Boot 2.7.12, covering the protocol basics, handshake process, custom HandlerMapping, annotation-driven routing, and a reactive WebFlux handler with code examples, plus deployment considerations behind reverse proxies.
The article compares interview questions from ten years ago, which focused on basic Java concepts, with today's interviews that probe deep system design, distributed architecture, performance troubleshooting, and data consistency, highlighting the increasing difficulty and breadth of knowledge required for modern developers.
This article explains the fundamental concepts of processes and threads, uses a gaming analogy to illustrate their relationship, and details three ways to create threads in Java—extending Thread, implementing Runnable, and implementing Callable—along with common thread control methods such as sleep, join, and setDaemon.
This article outlines common pitfalls of using Spring's BeanUtils.copyProperties for object property copying in Java backend development, including type mismatches, null overwrites, incorrect imports, inner class issues, shallow copy behavior, and performance drawbacks, and advises caution when employing this utility.
This article introduces Spring Boot 3.2's new JdbcClient, explains its fluent API style, shows how to add the dependency, inject it, and perform various query and insert operations with code examples, highlighting its advantages over traditional ORM frameworks.
This article provides a detailed, global‑level review of MyBatis, covering its main features such as SQL mapping, dynamic SQL, parameter and result mapping, transaction management, connection‑pool integration, second‑level cache, as well as the three‑layer architecture, configuration parsing, proxy creation, and SQL execution process.
This guide explains how MSE Nacos integrates with Alibaba Cloud KMS to encrypt and protect sensitive configuration data, covering the security challenges, architecture, encryption/decryption workflows, recommended configuration items, step‑by‑step setup, and Java/Go SDK examples for cloud‑native applications.
This article explains how to build a high‑performance file chunk (slice) upload system using Spring Boot and MinIO, covering project setup, MinIO configuration, controller and service implementation, front‑end integration with Thymeleaf, and performance optimizations such as parallel uploading and resumable transfers.
This article evaluates the performance of large language model (LLM) inference on the Java platform, examining llama2.java implementations that leverage Java Streams, the Vector API, Project Panama, and TornadoVM GPU acceleration, and compares them against native C versions across various model sizes.
