The article details how the vivo Game Center’s appointment service migrated billions of rows to a dedicated MySQL database with zero‑downtime by implementing a double‑write strategy via a custom MyBatis interceptor that mirrors updates and queries to the new database, handling full and incremental sync, primary‑key consistency, transaction limits, and final cut‑over steps.
This article presents ten practical MyBatis dynamic‑SQL techniques—including foreach, if, choose, selectKey, trim, and sql fragments—explaining their attributes, common pitfalls, and providing complete Java mapper and XML examples that help reduce boilerplate and avoid errors.
This article details the background, requirements, and evaluation of migration options for the appointment service, explains why a double‑write approach with a custom MyBatis plugin was chosen, and walks through the full‑sync, incremental sync, code refactoring, plugin implementation, switch‑over procedures, and post‑migration validation to achieve reliable data isolation and system stability.
This article provides a comprehensive guide to using MyBatis dynamic SQL tags—including foreach, if, choose, trim, selectKey, and sql fragments—explaining their attributes, usage scenarios, and offering detailed Java and XML code examples to improve query flexibility and reduce errors.
The article details a zero‑downtime migration of a high‑traffic reservation service from a shared MySQL instance to an isolated database by employing a double‑write strategy implemented through a custom MyBatis plugin, covering full and incremental sync, consistency verification, traffic shifting, and key lessons on primary‑key handling and asynchronous write side‑effects.
This article provides a comprehensive guide to using MyBatis dynamic SQL tags such as foreach, if, choose, trim, selectKey, and sql fragments, illustrating best practices with detailed code examples for building flexible, error‑free queries and updates in Java backend applications.
This article introduces the MyBatis‑SQL‑Viewer plugin, detailing its capabilities such as converting MyBatis XML to real SQL, mock data generation, SQL compliance and index checks, execution, performance testing, and how to install and use it within IntelliJ IDEA for efficient backend development.
This article demonstrates how to efficiently insert 300,000 rows into a MySQL table by using MyBatis batch operations, JDBC batch processing, and various performance optimizations such as batch size tuning, transaction management, and connection pooling.
This guide explains three common ways to output MyBatis SQL statements and their execution times—using simple configuration logging, a custom MyBatis interceptor plugin, and the third‑party p6spy library—along with code examples and practical considerations for development and production environments.
This article explains how to quickly test MyBatis SQL statements by bypassing the Spring container, using a minimal MyBatis configuration, adding support for PageHelper pagination and MyBatis‑Plus plugins, and provides code examples and a plugin recommendation for efficient backend development.
This article presents a real‑world case study of a high‑concurrency data‑processing interface whose response time was reduced from 30 seconds to under one second by diagnosing SQL bottlenecks, refactoring MyBatis code, applying PostgreSQL array aggregation, and introducing a Caffeine cache, while also discussing the limits of relational databases and promoting related AI services.
The latest update of the Cool Request IDEA plugin introduces a powerful Trace function that automatically records execution times for any method—including Spring @Scheduled and xxl‑job tasks—offers customizable latency coloring, MyBatis SQL timing, call‑count indicators, and scriptable environment variables for seamless token handling and JSON parsing.
This article explains how Spring 3.0's pure annotation development simplifies bean configuration, demonstrates defining beans with @Component, managing bean scopes, performing various injection techniques, reading properties files, and integrating MyBatis, providing complete code examples and best‑practice tips for backend Java developers.
This article explains what MyBatis second‑level cache is, why it’s needed, how to configure it globally and per‑mapper, the underlying CachingExecutor mechanism, and typical scenarios where enabling the cache can dramatically reduce database load and speed up read‑heavy applications.
This tutorial explains how Spring's pure annotation mode replaces XML bean definitions, covers component scanning, bean scopes, dependency injection techniques, property loading, and demonstrates seamless integration with MyBatis for streamlined backend development.
This article explains how Spring’s pure annotation development replaces XML bean definitions, covers component scanning, bean scopes, derived annotations, various injection methods, property file loading, and demonstrates seamless Spring‑MyBatis integration, showing step‑by‑step code examples that simplify backend configuration.
This article introduces MyBatis‑Mate, an official MyBatis‑Plus extension that provides enterprise‑level capabilities such as sharding, data auditing, field encryption, dictionary binding, data masking, automatic DDL maintenance, dynamic data‑source switching, distributed transaction logging, and fine‑grained data permissions for Spring Boot applications.
This article introduces MyBatis-Mate, an official MyBatis‑Plus extension offering enterprise‑level capabilities such as dictionary binding, field encryption, data masking, dynamic DDL maintenance, sharding, multi‑datasource switching, performance logging, and data permission control, with detailed Spring Boot integration examples.
This article examines nine design patterns employed within MyBatis—Builder, Factory, Singleton, Proxy, Decorator, Adapter, Composite, Template Method, and Iterator—detailing their roles, source code examples, and how they facilitate configuration parsing, SQL execution, and caching in the framework.
This article presents a real‑world case study of a high‑concurrency transaction‑handling API that originally required 30 seconds to process over two million records, and details the step‑by‑step SQL, Java, and caching optimizations that brought the response time down to under one second.
This article demonstrates how to insert 300,000 rows into a MySQL table using MyBatis and JDBC, compares direct batch insertion, row‑by‑row insertion, and optimized batch strategies, and provides performance measurements and practical tips for efficient large‑scale data loading.
This article explains MyBatis dynamic SQL, recounts a first‑hand OOM incident caused by missing backend validation, and shares practical lessons on parameter checking, balancing reusable versus specialized interfaces, and adopting defensive programming to build more reliable backend systems.
This article explains how to enforce data permission control in Java backend applications by using MyBatis mapper annotations, ThreadLocal rule propagation, and a MyBatis interceptor that parses and rewrites SQL statements with permission constraints, providing minimal intrusion to existing business logic.
Learn how to enforce data permission rules in Java applications by using MyBatis mapper annotations, ThreadLocal context propagation, and custom MyBatis interceptors that modify SQL via Druid's AST parser, ensuring minimal intrusion to existing business logic.
This article demonstrates how to insert 300,000 rows into a MySQL table efficiently by defining a User entity, configuring MyBatis and JDBC, comparing direct batch insertion, row‑by‑row insertion, and optimized batch strategies with configurable batch sizes and wait times, and provides performance results and best‑practice recommendations.
The article reveals that MyBatis’s OGNL treats a single‑character literal like '1' as a Character, causing equality checks against String values in if tags to fail, and shows how using double quotes, toString(), or proper type conversion resolves the comparison pitfall.
This article explores MyBatis dynamic SQL, shares a real OOM incident caused by missing backend validation, and offers practical tips on parameter checking, balancing reusable and specialized interfaces, and adopting defensive programming to build more reliable Java backend services.
This article walks through MyBatis dynamic SQL tags—foreach, concat, choose, selectKey, if, where, trim, set, and sql fragments—explaining their attributes, usage patterns, and common pitfalls, and provides complete XML and Java code examples for each technique.
This article explains how to use MyBatis dynamic SQL tags—including foreach, concat, choose, selectKey, if, where, set, trim, and sql fragments—providing clear examples and tips to write concise, error‑free XML mappings for Java backend applications.
This article introduces a self‑built tool that automatically generates database, service, DAO, and controller code for CRUD operations based on table definitions, explains its underlying template‑and‑parameter mechanism, demonstrates usage with a sample product table, and provides customizable templates and dynamic parameters for extensibility.
This article provides a comprehensive guide to MyBatis dynamic SQL, covering foreach loops, conditional if, choose, selectKey, trim, and sql fragments, with detailed explanations and full XML and Java code examples to help developers write efficient, error‑free mappings.
This article investigates a concurrency bug in MyBatis caused by OGNL expression evaluation using reflection, explains the root cause through stack trace and source code analysis, and proposes solutions such as upgrading MyBatis or avoiding private inner‑class methods like Arrays.asList.
An old Java project using MySQL, MyBatis, and an outdated mysql‑connector‑java driver encounters a “Conversion not supported for type java.time.LocalDateTime” error after swapping MyBatis for MyBatis‑Plus; the article walks through reproducing the issue, analyzing MyBatis version changes, upgrading the JDBC driver, and fixing subsequent bugs.
This article dissects MyBatis's source code, revealing how more than ten classic design patterns—such as Factory, Singleton, Builder, Adapter, Proxy, Composite, Decorator, Template, Strategy, and Iterator—are applied to decouple complex scenarios, improve extensibility, and streamline ORM operations.
This article provides a comprehensive guide to MyBatis dynamic SQL tags—including foreach, if, choose, trim, and selectKey—showing how to configure XML, handle collections, build flexible queries, and avoid common pitfalls when generating SQL statements.
This article walks through three ways to map JSON columns to Java objects in MyBatis, explains why simple String or JSONObject approaches are fragile, and provides a complete custom TypeHandler implementation, registration, and usage example for complex entity fields.
The article walks through MyBatis’s internal execution pipeline, from loading the configuration file and building a SqlSessionFactory, to creating a SqlSession, generating a MapperProxy for the mapper interface, and finally invoking the mapped method which triggers JDBC operations, while detailing caching and executor mechanisms.
MyBatis, a widely used Java ORM, embeds around ten classic design patterns—including Factory, Singleton, Builder, Adapter, Proxy, Composite, Decorator, Template Method, Strategy, and Iterator—to modularize object creation, structure, and behavior, thereby simplifying complex data access and caching mechanisms within its architecture.
This article walks through replacing MyBatis with MyBatis‑Plus in a legacy Java project, explains the “Conversion not supported for type java.time.LocalDateTime” error caused by MyBatis 3.5.1 and an outdated mysql‑connector‑java driver, and shows how upgrading the driver resolves the issue while offering debugging tips.
This article analyzes common anomalies caused by the PageHelper pagination plugin in a Java backend project—such as duplicate user registration, limited query results, and password‑reset errors—traces them to ThreadLocal misuse, explains the internal workflow of startPage, getLocalPage, and clearPage, and offers practical recommendations to avoid these pitfalls.
This article presents a comprehensive performance test of inserting massive amounts of randomly generated person records into MySQL, comparing three strategies—MyBatis lightweight insertion, direct JDBC handling, and JDBC batch processing—both with and without transactions, and concludes that combining batch processing with transactions yields the fastest insertion speed for large‑scale data loads.
This article explains how to dramatically improve MySQL insert speed by adjusting database settings, choosing the MyISAM engine, and applying batch insertion methods such as concatenated SQL, transaction‑wrapped inserts, and MyBatis‑Flex saveBatch, complete with test code and performance results.
This article walks through replacing MyBatis with MyBatis‑Plus in a legacy Java project, demonstrates the LocalDateTime conversion error caused by MySQL‑connector‑java version incompatibility, shows how upgrading the driver resolves the issue, and shares a cautionary tale about unintended bugs after component upgrades.
This article explains why MyBatis SqlSession is not thread‑safe, outlines strategies such as using per‑thread instances or ThreadLocal to secure it, and details how Spring's SqlSessionTemplate leverages dynamic proxies and ThreadLocal storage to provide thread‑safe database operations.
This article explains how to boost MySQL insertion speed by adjusting server hardware, tuning database parameters, choosing the MyISAM engine, and especially applying three batch‑insert techniques—SQL concatenation, MyBatis‑Flex saveBatch, and manual transaction batching—while showing test results and configuration tips.
This article demonstrates how to mask sensitive data such as phone numbers, ID cards, and personal information using SQL string functions, a Java library (sensitive‑plus), and the MyBatis‑Mate Sensitive Jackson plugin, providing complete code examples, configuration files, and test results for backend developers.
The article walks through a performance test of inserting over 100,000 rows with many columns, showing how a naïve loop takes about 80 seconds while JDBC batch, manual transaction control, and MyBatis/MyBatis‑Plus batch APIs can reduce the time to roughly one second.
This article describes a Java data isolation solution that adds an 'env' field to tables, uses a MyBatis interceptor to rewrite SQL for environment‑aware queries, and introduces custom annotations with AOP to selectively skip environment checks, detailing implementation, challenges, and best practices.
The article shows how to efficiently load 300,000 MySQL rows in Java by comparing MyBatis and plain-JDBC batch inserts, demonstrating that batching 1,000‑5,000 records per transaction with proper transaction control, connection pooling, and MySQL tuning reduces insertion time from hours to seconds.
A legacy Java project using MySQL, MyBatis 3.5.0, and an old mysql‑connector‑java version encounters a Conversion not supported for java.time.LocalDateTime error after switching to MyBatis‑Plus, and the article walks through root‑cause analysis, version upgrades, and practical fixes.
This article demonstrates how to insert 300,000 rows into a MySQL table using MyBatis and JDBC, compares bulk batch insertion with per‑row looping, discusses packet size limits, transaction handling, performance metrics, and provides practical code snippets and optimization tips for efficient large‑scale data loading.
This article demonstrates various methods for inserting 300,000 rows into a MySQL database using Java, including direct batch insertion with MyBatis, row‑by‑row insertion, and optimized batch strategies for both MyBatis and JDBC, along with performance results and practical tips.
This article explains MyBatis dynamic SQL, its purpose, and how to use various tags such as if, where, trim, choose, foreach, include, sql, resultMap, association, and collection, providing detailed code examples and best‑practice guidelines for building flexible and secure SQL statements in Java applications.
This article explains MyBatis dynamic SQL concepts, details the nine dynamic tags (if, where, set, choose, trim, foreach, sql, include, association), provides complete XML mapper examples with code snippets, and demonstrates one‑to‑many, many‑to‑one, and many‑to‑many association queries for Java backend development.
This article explains how PageHelper's static ThreadLocal pagination parameters can be polluted by exceptions or thread reuse, leading to incorrect query results, and provides detailed analysis of the plugin's internals together with practical solutions such as invoking clearPage() via filters or aspects.
This article describes how to achieve data environment isolation in a Java application by creating a custom MyBatis interceptor and annotation, allowing automatic SQL modification to handle env fields, reducing code changes, improving safety, and supporting flexible deployment across pre‑release, gray, and production environments.
This article explains how to design a SaaS system that isolates each subsidiary's data by adding a tenant_id column to a shared MySQL table, converting the table to LIST‑partitioned storage, and enforcing tenant‑level access through stored procedures and a MyBatis interceptor, complete with code examples and testing steps.
This article analyzes why the total record count returned by PageHelper mismatches the actual number of rows, examines the underlying PageInfo and PageSerializable source code, and provides a concrete solution that avoids type conversion and directly constructs PageInfo from the mapper result to ensure accurate pagination.
This article demonstrates how to wrap EasyExcel within a Spring Boot + MyBatis‑Plus project to provide clean, reusable import and export APIs, covering environment setup, annotation usage, controller implementation, core service design, common pitfalls, and solutions for date and template handling.
This article walks through the challenges of sharing a single database across pre‑release, gray, and online environments, explains how to add an env field for isolation, and shows a custom MyBatis interceptor and annotation‑driven AOP solution that rewrites SQL to automatically handle environment filtering and insertion while keeping business code untouched.
This article explains pagination rationalization in SpringBoot using MyBatis PageHelper, illustrates common unreasonable pagination scenarios, demonstrates a bug caused by page deletion, and shows how a simple two‑line configuration or per‑query setting resolves the issue while detailing the underlying implementation.
This article explains how MyBatis implements first‑level (session) and second‑level (namespace) caches, details their activation conditions, common pitfalls—especially when integrated with SpringBoot—and provides step‑by‑step configuration, code examples, and best‑practice recommendations to ensure cache effectiveness while avoiding hidden hazards.
This article explains why MyBatis' default SqlSession implementation is not thread‑safe, how Spring‑MyBatis integration introduces SqlSessionTemplate and its dynamic proxy, and how transaction‑bound ThreadLocal management ensures safe SqlSession usage across multiple threads.
The article explains the root causes of frequent OutOfMemoryError in a Java backend service, analyzes how MyBatis’s SQL building can exhaust heap memory, demonstrates a reproducible test case, and offers practical recommendations to prevent and resolve such memory leaks.
This article explains why the @Transactional annotation fails in Spring when using multithreading, demonstrates a failing example, and provides a solution using manual SqlSession management to guarantee that all database changes are rolled back if any thread encounters an exception.
This article explains MyBatis caching mechanisms, detailing the scope, implementation, configuration, and differences between first-level (SqlSession) and second-level (mapper) caches, and how they improve query performance while outlining their default behaviors and usage considerations.
Unexpected duplicate registrations, truncated query results, and password‑reset SQL errors in a Java backend were traced to PageHelper’s ThreadLocal pagination state persisting across requests when startPage() is called without immediate query execution, so developers should ensure immediate execution or manually clear the ThreadLocal to prevent stale LIMIT clauses.
This article explains how to use a MyBatis interceptor to cheaply improve database stability for high‑growth tables, compares common archiving and sharding solutions, and provides a complete, code‑driven implementation of date‑based horizontal sharding with binlog‑driven double‑write to handle critical‑point data continuity.
This article explains how to efficiently insert massive amounts of data (over 100,000 rows) into a MySQL table by comparing plain JDBC single‑row inserts, JDBC batch inserts, MyBatis/MyBatis‑Plus foreach dynamic SQL, and the built‑in MyBatis‑Plus saveBatch method, while highlighting configuration tips and performance results.
The article analyzes unexpected behaviors caused by PageHelper in a Java backend project—such as duplicate registrations, limited query results, and password update errors—by dissecting its source code, ThreadLocal usage, and the importance of proper startPage() and clearPage() handling.
This article walks through the challenges of environment‑specific data isolation in a Java project, explains why adding an env column to every table is impractical, and presents a clean solution using a MyBatis interceptor that rewrites SQL and custom annotations to control filtering, ensuring safe, maintainable code across pre‑release, gray, and production environments.
This article walks through the problem of sharing a single database across pre‑release, gray, and production environments, explains why adding an env column to dozens of tables is error‑prone, and demonstrates a MyBatis interceptor‑based solution with custom annotations that isolates data while preserving backward compatibility.
This article demonstrates how to convert a single‑tenant MySQL application into a multi‑tenant SaaS solution by adding a tenant_id column, using shared‑database partitioning, creating tenant tables, writing stored procedures for dynamic partition management, and implementing a MyBatis interceptor for hierarchical data permissions.
This article walks through converting a single‑tenant MySQL application into a SaaS solution by adding a tenant_id column, using shared‑database table partitioning, creating tenant metadata tables, writing stored procedures to add columns and partitions, and implementing a MyBatis interceptor for automatic data‑permission enforcement.
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.
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.
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.
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.
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 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 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 article explains MyBatis's first‑level and second‑level cache mechanisms, illustrates common consistency problems caused by default cache settings in both distributed and single‑session scenarios, and provides practical recommendations such as adjusting localCacheScope or deep‑copying results to avoid cache pitfalls.
This article examines the various design patterns—such as Factory, Singleton, Builder, Adapter, Proxy, Composite, Decorator, Template, Strategy, and Iterator—employed within the MyBatis source code, explaining their structures, usage scenarios, and related components to illustrate how the framework achieves modularity and flexibility.
This article explains how to use the MyBatis @MapKey annotation to map query results into a Java Map, provides a concrete code example, and delves into the internal processing steps—including MapperProxy, MapperMethod, MethodSignature, and DefaultMapResultHandler—that enable this functionality.
This article explains how to redesign a Java data model so that a single sessionId is stored at the outer level while multiple sceneId/sceneName pairs are nested inside a sceneList, and shows the required MyBatis mapper, XML mapping, service, and controller implementations.
This article provides a step‑by‑step guide on integrating Spring Batch with Spring Boot, covering business scenarios, database setup, Maven dependencies, configuration of JobRepository, JobLauncher, Job, Step, ItemReader, ItemProcessor, ItemWriter, listeners, validators, execution via REST endpoints, troubleshooting with Druid and switching to HikariCP, and demonstrates processing CSV and database data in large batches.
The MyBatis SQL Viewer plugin for IntelliJ IDEA converts MyBatis XML to executable SQL, offers comprehensive mock data generation, compliance and index checks, execution plans, stress testing, and project‑wide scanning, streamlining CRUD development without repeated application restarts.
This article explains the underlying principles and step‑by‑step configuration for integrating Spring Boot with MyBatis to manage multiple data sources, covering BeanFactory, FactoryBean, SqlSessionFactoryBean setup, datasource properties, mapper scanning, and sample controller code for accessing distinct databases.
A Java backend developer investigates why an enum‑based status field becomes an empty string during database insertion, tracing the issue through code inspection, Arthas watches, and ultimately discovering a mis‑implemented enum setter caused by a third‑party library.
This article provides a comprehensive guide to MyBatis dynamic SQL tags—including foreach, if, where, choose, trim, set, and selectKey—showing how to build flexible queries, handle collections, and avoid common pitfalls with clear code examples and best‑practice explanations.
This article describes a practical approach to achieve environment‑based data isolation in Java services by adding an env field to tables, using a MyBatis interceptor to rewrite SQL, and defining custom annotations with AOP to control the isolation logic, while sharing code snippets and lessons learned.
This article walks through the step‑by‑step evolution from raw JDBC to the MyBatis framework, explaining why JDBC should be wrapped, how MyBatis improves connection handling, SQL management, dynamic statements, result mapping, caching, and overall architecture with concrete code examples.
This article provides a comprehensive, step‑by‑step overview of MyBatis’s architecture—including its three‑layer design, configuration parsing, proxy generation, and SQL execution process—while highlighting key features such as SQL mapping, dynamic SQL, parameter and result mapping, transaction management, connection‑pool integration, and second‑level caching.
This article explains how Spring’s FactoryBean mechanism enables seamless integration with MyBatis by detailing the roles of BeanFactory, SqlSessionFactoryBean, MapperScannerConfigurer, and MapperFactoryBean, and provides annotated code examples and XML configuration to illustrate the underlying process and its benefits for transaction management and thread safety.
This guide explains how to implement read‑write separation in Spring Boot applications by configuring master and slave databases, creating dynamic routing data sources, using custom annotations and AOP, integrating HikariCP and MyBatis, and handling thread‑local context for optimal performance.
This article demonstrates why @Transactional fails in multithreaded Spring services, presents a thread‑pool based solution using manual SqlSession control to achieve full rollback across child threads, and provides complete code examples and test results illustrating both failure and successful transaction handling.
This article explains how to redesign a JSON payload that repeats a sessionId for each scene by moving the sessionId to the outer level and using MyBatis resultMap with a collection to map a Session object containing a list of Scene objects, including Java entity definitions, mapper XML, service, and controller code.
The article investigates frequent OutOfMemoryError incidents in a distributed Java service, explains heap and metaspace causes, analyzes MyBatis source that retains large SQL strings in memory, reproduces the issue with heavy IN clauses and limited heap, and offers practical mitigation advice.