This tutorial explains how to use MyBatis interceptor mechanisms to dynamically modify SQL statements at runtime in a Spring Boot application, covering interceptor types, implementation steps, configuration, core code, testing, and common use cases such as SQL monitoring, pagination, and data permission filtering.
This article investigates the root causes of frequent OutOfMemoryError incidents in a distributed Java backend, explains how MyBatis and DruidDataSource can exhaust heap and metaspace, demonstrates a reproducible test with JVM options and multithreading, and offers practical mitigation strategies.
This article explains three MySQL pagination methods—simple LIMIT syntax, MyBatis RowBounds logical pagination, and the powerful MyBatis-PageHelper plugin—detailing their usage, configuration, code examples, and performance considerations to help Java developers efficiently handle large data sets.
When interviewers ask how to insert a thousand rows with MyBatis, the answer isn’t just a simple Java for‑loop; you need to consider batch processing, disable autocommit, and understand MyBatis’s limits to choose the most reliable and performant approach.
This article demonstrates how to leverage MyBatis interceptor mechanism in a Spring Boot 3 application to dynamically modify SQL statements, showing step‑by‑step implementation, configuration, core code, testing, and common use cases such as SQL monitoring, pagination, and data permission filtering.
MyBatis-Flex is a lightweight, high‑performance extension to MyBatis that adds full CRUD, pagination, multi‑table and batch operations while preserving all MyBatis features, supports multi‑datasource relations, recursive queries, and provides extensive annotations such as @Relation for flexible data mapping, with recent v1.4.9 updates and bug fixes.
This article explains how MyBatis first‑level (session) and second‑level (cross‑session) caches work, the conditions required for them to function, common pitfalls when integrating with SpringBoot, and step‑by‑step instructions to enable and safely use second‑level caching in real projects.
This article explains how to smoothly migrate a legacy single‑database system to a sharded architecture by using dual‑write, mapping‑key routing, custom transaction handling, and offline/real‑time diff checks, while detailing the underlying MyBatis integration and component‑based design.
This article explains MyBatis streaming queries, introduces the Cursor interface and its key methods, shows how to implement streaming with code examples, discusses suitable application scenarios, and outlines important considerations for efficient, low‑memory data processing in Java backend systems.
The article explains MyBatis first‑level and second‑level caching mechanisms, their activation conditions, integration pitfalls with Spring Boot, and how to enable and use them safely, including configuration steps, code examples, and warnings about hidden risks of second‑level cache.
This article provides a comprehensive guide to MyBatis dynamic SQL, demonstrating how to use if, choose, trim, foreach, and bind tags for conditional queries, updates, inserts, batch operations, and database‑agnostic expressions, complete with Maven project setup, SQL scripts, and test cases.
This article introduces MyBatis streaming query using the Cursor interface, explains its core methods, demonstrates implementation with code examples, discusses suitable application scenarios, and outlines important considerations for efficient and safe large‑scale data processing in Java backend development.
This article introduces MyBatis streaming queries, explains the Cursor interface and its methods, provides step‑by‑step code examples for configuration and implementation, discusses practical application scenarios such as large‑scale data processing, and highlights important considerations for efficient and safe usage.
This article describes the challenges of migrating a long‑running monolithic database to a sharded architecture, presents a two‑stage smooth migration strategy using double‑write, diff verification, and mapping‑key techniques, and details the componentized design, core implementation, and configuration of a reusable sharding framework built on MyBatis and Spring.
This article explains how to design and implement a business operation logging feature using Spring AOP in a Spring Boot project, covering requirement analysis, anti‑pattern pitfalls, AOP design, environment and dependency setup, database schema, annotation and aspect code, and testing procedures.
This article explores how Lombok’s auto‑generated getter/setter methods can conflict with MyBatis property naming conventions and cause null values, examines the underlying reflection logic in MyBatis, and also reveals why the @Accessor(chain=true) annotation disrupts EasyExcel’s CGLIB‑based mapping, offering practical solutions.
This article explains how Lombok's generated getter and setter method names can conflict with MyBatis property resolution and cause issues when using EasyExcel's @Accessor(chain=true) annotation, and provides detailed code examples and solutions to resolve these incompatibilities.
This article demonstrates multiple strategies for inserting 300,000 rows into a MySQL table using MyBatis and JDBC, comparing batch‑insert, single‑row loops, packet size limits, transaction handling, and performance tuning techniques such as batch size, waiting intervals, and index management.
This guide explains how to use MyBatis dynamic SQL tags such as foreach, if, where, choose, trim, and selectKey, providing practical examples for conditional queries, batch inserts, updates, and reusable SQL fragments to write flexible and error‑free MySQL statements in Java applications.
This article explains the concept and purpose of Spring Boot starters, compares mybatis‑spring with mybatis‑spring‑boot‑starter through code examples, and details how the starter simplifies MyBatis integration by handling dependencies, configuration files, auto‑configuration, and mapper scanning for Java backend projects.
This article explains how to export large MySQL datasets in SpringBoot by streaming data directly to CSV, avoiding full‑memory loads that cause OutOfMemoryError, and provides complete JPA and MyBatis implementations, performance testing, and practical code examples for production use.
This article reviews several Java technologies that have become obsolete or less relevant—such as JSP, Struts, Hibernate, Applet, Swing, JDBC, and XML—explaining why newcomers can safely ignore them and focus on modern alternatives like Spring MVC, MyBatis, and deep Servlet knowledge.
This article provides a detailed tutorial on setting up MyBatis Generator in a Spring Boot application, covering configuration file placement, XML adjustments, Maven dependencies, execution steps, and the resulting model, mapper, and XML files with full code examples.
The article explains that MyBatis PageHelper performs an extra full‑table count query causing pagination to take over eight seconds on a 10,000‑row table, analyzes the root cause, and provides a concrete solution by customizing the count SQL with a _COUNT method and optimized mapper definitions.
This article explains how to handle large‑scale data inserts with multithreading in Spring Boot using MyBatis, why the @Transactional annotation fails across threads, and how to achieve reliable all‑or‑nothing rollbacks by manually managing transactions with SqlSession and thread pools.
The article explains three ways to perform batch inserts with MyBatis—ordinary single-row inserts, foreach‑based bulk inserts, and ExecutorType.BATCH—analyzes their SQL logs, performance bottlenecks, MySQL limits, and provides practical recommendations for large‑scale data insertion.
This article explains why MyBatis foreach‑based batch inserts become extremely slow with thousands of rows, demonstrates how the generated giant SQL statement hurts performance, and shows how switching to ExecutorType.BATCH or limiting rows per INSERT dramatically reduces insertion time.
This article explains how to export tens of millions of rows from MySQL using Spring Boot by streaming data with JPA or MyBatis, avoiding OutOfMemoryError, switching to CSV format, and provides complete code examples, performance comparison, and tips for generating test data.
This guide demonstrates how to integrate the MybatisX IDEA plugin with a Spring Boot project, covering database setup, Maven dependency configuration, plugin installation, connection testing, code generation, and sample controller implementation to accelerate MyBatis and MyBatis-Plus development.
This article explains XSS attack types, SQL injection risks, and provides practical SpringBoot filter implementations with MyBatis prepared statements and custom deserializers to sanitize request parameters, JSON bodies, and prevent malicious script and database attacks.
The article explains how to process massive MySQL data sets—covering data migration, export, and batch handling—by comparing regular pagination, streaming queries using server‑side cursors, and cursor‑based fetchSize techniques, and provides concrete MyBatis code examples for each approach.
This article explains why MyBatis foreach‑based batch inserts become extremely slow with thousands of rows, analyzes the underlying SQL generation and parsing costs, and demonstrates how using ExecutorType.BATCH or limiting rows per INSERT can reduce a 14‑minute operation to under two seconds.
The article explains how to prevent OutOfMemoryError when exporting massive MySQL datasets by streaming records with JPA or MyBatis, writing them directly to CSV files, and demonstrates significant memory savings compared to traditional batch export methods.
This article introduces FastMyBatis—a lightweight, zero‑configuration MyBatis extension for Spring Boot—covering its core principles, Maven setup, sample CRUD controller, service and mapper implementations, a comprehensive list of mapper methods, Query object usage examples, and links to the open‑source repository.
This article examines how MyBatis leverages around ten core design patterns—including Factory, Singleton, Builder, Adapter, Proxy, Composite, Decorator, Template, Strategy, and Iterator—to decouple complex scenarios, improve modularity, and streamline ORM operations within its extensive codebase.
To efficiently process massive MySQL result sets without exhausting JVM memory, this article explains three query strategies—regular pagination, stream-based retrieval using MyBatis cursors, and cursor-based fetching with configurable fetchSize—detailing their implementations, advantages, and practical considerations.
Processing massive datasets in MySQL can cause OOM and slow performance; this article explains when to use regular pagination, streaming queries, and cursor-based fetching, compares their trade‑offs, and provides MyBatis code examples with @Options and @ResultType to handle millions of rows efficiently.
This article presents a practical guide to implementing monthly sharding for high‑volume billing data using MySQL stored procedures, dynamic table creation, and SpringBoot‑MyBatis integration, covering schema design, code examples, and query strategies for inserting, retrieving, and managing partitioned tables.
This article presents five common batch‑insert approaches for MyBatis and MyBatis‑Plus—including a for‑loop, manual batch commit, collection‑based batch, saveBatch, and InsertBatchSomeColumn—provides complete code examples, configuration steps, and measured execution times to help Java backend developers choose the most efficient method.
This article provides a comprehensive guide to MyBatis dynamic SQL tags—including foreach, if, choose, trim, selectKey, and related constructs—explaining their attributes, usage scenarios, and offering detailed Java and XML code examples for building flexible and error‑free database queries.
This article explains how to overcome export failures for reports exceeding ten thousand rows by using MyBatis streaming reads with JDBC, detailing the three read modes, required MyBatis configurations, and providing complete controller, service, DAO, and mapper code examples.
This article provides a comprehensive guide on using Spring Batch within a Spring Boot application, covering CSV and database data sources, detailed configuration beans, custom readers, processors, writers, listeners, validation, and execution via a REST controller, along with practical troubleshooting tips.
This article shares common pitfalls of Java candidates, emphasizes building a solid Java foundation, and provides a curated collection of over 100 interview questions covering Spring, Redis, MyBatis, and multithreading, with a QR code for accessing the full answer set.
This article provides a comprehensive guide to MyBatis, covering its basic concepts, Maven dependency configuration, XML setup, entity and mapper definitions, execution flow using dynamic proxies, and a custom lightweight framework implementation with full Java code examples.
This article explains how to overcome export failures caused by large data volumes in a legacy Java system by switching from default full-result JDBC reads to a forward‑only streaming approach using MyBatis, detailing environment setup, configuration changes, and complete code examples for controller, service, DAO, and mapper layers.
This article presents a detailed overview of five commonly used MyBatis and MyBatis-Plus batch insertion methods, including code examples, configuration steps, and performance measurements for inserting ten thousand records, helping developers choose the most efficient approach for large‑scale data insertion in Java backend projects.
This article provides a comprehensive step‑by‑step guide on integrating Spring Batch with Spring Boot, covering configuration, entity and mapper definitions, job, step, reader, processor, writer implementations, database setup, error handling, and execution via a REST controller, complete with code examples.
This article explains how to replace repetitive try‑catch blocks in Java Spring applications with a unified exception handling strategy that leverages @ControllerAdvice, custom Assert utilities, enum‑based error codes, and standardized response objects to improve code readability, maintainability, and internationalisation.
This article evaluates the efficiency of inserting massive datasets into MySQL using three Java strategies—MyBatis without transactions, direct JDBC with and without transactions, and JDBC batch processing—by measuring execution times for millions of records and analyzing the impact of transactions and batching.
This article presents and compares five practical batch‑insert methods for MyBatis and MyBatis‑Plus, covering preparation steps, code implementations, configuration details, and performance results, helping developers choose the most efficient approach for inserting large volumes of data in Java backend projects.
This article presents a full‑stack student management system built with Vue on the front end and SpringBoot + MyBatis on the back end, detailing project introduction, deployment steps, technology stacks, core functionalities, database design, and source code acquisition.
This article evaluates the efficiency of inserting massive synthetic person data into MySQL using Java, comparing MyBatis, plain JDBC (with and without transactions), and JDBC batch processing, and presents detailed timing results for each strategy across tens of millions of rows.
This post shares a free, extensive compilation of interview questions and detailed explanations covering Java fundamentals, multithreading, Spring framework, Redis, MyBatis and other backend technologies, encouraging systematic preparation and offering a QR‑code method to obtain the full document.
This article reviews the Java ecosystem, explains criteria for deeming technologies outdated, and advises developers to drop JSP, Struts, Hibernate, Applet, Swing, JDBC, and XML while focusing on mastering Servlets, Spring MVC, and lightweight ORM tools like MyBatis.
This article compiles over a thousand interview questions and detailed explanations covering core Java fundamentals, multithreading, Spring framework, Redis, MyBatis, and related backend technologies, offering a free downloadable resource to help candidates prepare effectively for major tech company interviews.
This tutorial explains how to integrate MyBatis into a Spring Boot project, covering setup, basic CRUD examples, dynamic SQL techniques, one‑to‑one and one‑to‑many mappings, pagination support, and provides complete code snippets for each step.
This article explains how a high‑traffic e‑commerce system reduced database QPS by over 80% and response latency by more than 40% through a systematic DAO‑level caching solution, detailing the background, design trade‑offs, implementation steps, global cache architecture, deployment practices, and observed limitations.
This article thoroughly explains how MyBatis binds mapper interfaces to XML files, details the step‑by‑step SQL execution flow—including mapper retrieval, statement preparation, parameter handling, and result mapping—and demonstrates how to create custom typeHandlers for both input parameters and result sets.
This article dissects MyBatis’s internal workflow, explaining how mapper interfaces are linked to XML files, detailing the step‑by‑step SQL execution process, and demonstrating how to create and apply custom typeHandlers for parameter setting and result mapping, all based on MyBatis 3.5.5 source code.
This article explains MyBatis's first-level (SqlSession-scoped) and second-level (Mapper-scoped) caching mechanisms, their default behaviors, key generation, configuration options, and the impact of Spring integration, and provides recommendations for disabling caches in distributed environments to avoid data inconsistency.
This article explains MyBatis caching fundamentals, detailing first- and second-level cache concepts, configuration, cache invalidation scenarios, and custom cache integration with EHCache, supplemented by practical code snippets and quiz questions to illustrate cache behavior across SqlSessions.
This guide walks you through installing the MyBatisCodeHelper‑Pro IntelliJ plugin, configuring it to generate Java entity, DAO, mapper and service code, customizing type mappings, creating SQL scripts, and using shortcuts to produce find, update, delete, and pagination methods efficiently for backend development.
Drawing on two decades of Java experience, this article evaluates outdated Java technologies—JSP, Struts, Hibernate, and others—based on real‑world development relevance, interview usefulness, and depth of understanding, and offers clear recommendations on what to skip and what to master.
This guide walks you through integrating MyBatis with Spring Boot, covering basic CRUD operations, dynamic SQL constructs like if, choose, where, set, foreach, as well as advanced mapping techniques, pagination plugins, and practical code examples to help you master MyBatis in real-world projects.
This article presents a detailed performance test of inserting massive data into MySQL with Java, comparing three strategies—MyBatis lightweight insertion without transactions, direct JDBC handling with and without transactions, and JDBC batch processing—showing timing results for millions of rows and offering practical recommendations for high‑throughput data loading.
This article explains the core concepts of MyBatis caching, details how first‑level and second‑level caches work, shows configuration options, illustrates cache invalidation scenarios, and demonstrates custom cache integration with EHCache through practical code examples and test questions.
This article walks through the most common MyBatis SQL injection patterns—like, IN, and ORDER BY—explains why they occur, and provides a step‑by‑step hands‑on methodology for locating, reproducing, and confirming the flaws in a real Java CMS project.
This article provides a comprehensive tutorial on using Spring annotations for pure annotation‑based development, defining beans, managing bean scopes, performing various injection techniques, reading configuration properties, and integrating Spring with MyBatis, complete with code examples and best‑practice tips.
This article demonstrates how to securely store and retrieve sensitive fields such as phone numbers in a MySQL database by creating a custom Java Encrypt class, a MyBatis TypeHandler for automatic encryption/decryption, configuring the mapper XML, and verifying the solution with test results.
This article walks through MyBatis's complete query lifecycle—from configuration parsing, SqlSessionFactory creation, and mapper loading to the actual SELECT execution—while reproducing a pre‑3.4.5 bug caused by foreach variable leakage and presenting the official fix and upgrade recommendations.
This article presents a comprehensive Java web application that combines movies, music, and books, built with Spring Boot, MyBatis, Redis, and Nginx, and provides detailed environment specifications, architecture diagrams, feature screenshots, and step‑by‑step deployment instructions.
This article provides a step‑by‑step tutorial on using Spring annotations for bean definition, component scanning, scope management, autowiring, qualifier usage, simple value injection, property file loading, and finally demonstrates how to integrate Spring with MyBatis for streamlined data access in Java backend projects.
This guide walks through common MyBatis SQL injection patterns—like fuzzy queries, IN clauses, and ORDER BY misuse—showing how to locate vulnerable XML, trace the call chain, and confirm exploitation with a crafted request, providing practical steps for Java security auditors.
This article compiles a large set of interview questions frequently asked by top tech companies, covering Java fundamentals, multithreading, Spring framework, MyBatis, Redis, and related concepts, and provides a free QR‑code link for downloading the complete question set with answers.
This article explains the principles, implementation steps, and configuration of MyBatis first‑level (SqlSession) and second‑level (mapper) caches, compares their scopes and behaviors, and provides practical guidance on when and how to enable each cache to improve database query performance.
This article demonstrates how to mask sensitive data such as phone numbers and ID cards using SQL functions, introduces Java masking libraries, and provides a complete MyBatis-Mate Sensitive Jackson example with configuration, custom strategies, entity annotations, controller endpoints, and sample responses.
The article advises that POJO class attributes should always use wrapper types without preset default values, illustrating several pitfalls such as null‑overridden defaults during Jackson deserialization, BeanUtils copy failures, MyBatis dynamic SQL issues, and RPC/API default‑value bugs.
This article compares Fluent MyBatis, native MyBatis, and MyBatis Plus by implementing a student score aggregation query, showcasing code examples, generator settings, and a detailed feature matrix to help developers choose the most efficient ORM for complex SQL construction.
After taking over a system via a server image, the author uncovered malicious modifications that used a ternary expression to force id=1, causing MyBatis to generate a “where 1=1” clause that deleted the entire T_QUART_DATA table, and later discovered cron jobs that removed core jars, illustrating a thorough forensic debugging process.
This article explains how to model a session that contains multiple scenes in a Java backend, defines corresponding entity classes, creates a MyBatis custom mapper with XML result mapping, and implements service and Spring MVC controller layers to expose the data via a clean API.
This comprehensive guide explains MyBatis fundamentals, compares it with Hibernate, details its lifecycle, configuration, dynamic SQL, caching, lazy loading, batch operations, pagination, and plugin development, providing code examples and best‑practice recommendations for Java backend developers.
An in‑depth guide explains why using MyBatis’s foreach for bulk inserts can cause severe performance degradation, especially with large tables, and demonstrates how switching to ExecutorType.BATCH or limiting batch sizes to 20‑50 rows dramatically reduces insertion time from minutes to seconds.
The article explains why MyBatis batch inserts using a foreach-generated single INSERT statement can cause severe CPU and latency issues, and demonstrates how to achieve fast bulk insertion by limiting batch size or switching to ExecutorType.BATCH with code examples.
The article explains why MyBatis foreach‑based batch inserts can cause extreme CPU usage and long execution times, demonstrates how combining multiple VALUES into a single INSERT or using ExecutorType.BATCH dramatically improves performance, and provides practical code examples and sizing recommendations.
This article explains common anomalies caused by PageHelper in MyBatis projects, such as duplicate registrations and unexpected LIMIT clauses, analyzes the underlying ThreadLocal mechanism, and provides practical guidance on correctly using startPage() and clearPage() to prevent pagination bugs.
This article explains the origins and purpose of Spring transactions, demonstrates how to quickly set them up with code examples, explores key features and common pitfalls, and provides an in‑depth comparison of the REQUIRED, REQUIRES_NEW, and NESTED propagation types for robust backend development.
This article examines unexpected bugs caused by PageHelper in a Java/MyBatis project—such as duplicate registrations, limited dropdown results, and password‑reset errors—traces them to ThreadLocal misuse, explains the library’s internal pagination flow, and offers practical fixes to avoid these pitfalls.
This article explains how to use MyBatis plugins to transparently encrypt specified database fields on write and decrypt them on read, covering the requirement background, system architecture, interceptor design, annotation usage, mapper adjustments, handling of pagination count queries, and practical implementation details.
The article demonstrates how to implement lightweight field-level encryption in MyBatis by adding encrypted columns, creating a custom interceptor that encrypts annotated parameters on write and decrypts them on read, handling executor, statement, parameter, and result set processing, and addressing pagination count queries.
This article explains how PageHelper integrates with MyBatis, analyzes common pagination bugs such as unexpected LIMIT clauses, duplicate registrations, and password‑reset errors, and demonstrates the internal ThreadLocal handling, startPage usage, and proper cleanup to avoid thread‑local pollution.
This article explains the fundamentals of SQL injection attacks, outlines their severe consequences, and provides a comprehensive set of prevention principles and practical measures—including parameterized queries, strong typing, input validation, and secure MyBatis configurations—to help developers safeguard backend applications and databases.
This article demonstrates how to mask sensitive data such as phone numbers, ID cards, and emails in MySQL and Java applications by combining SQL string functions with the MyBatis‑Mate Sensitive Jackson plugin, providing complete configuration, custom strategies, and runnable Spring Boot examples.
This article provides a comprehensive analysis of MyBatis, covering its core architecture, the process of obtaining SqlSessionFactory and SqlSession, the dynamic proxy mechanism for mappers, the execution flow of SQL statements, the plugin system, first‑ and second‑level caching strategies, and how Spring manages MyBatis mappers through factory beans and import registrars.
This guide walks through setting up a front‑back separated student management system, detailing Vue‑based front‑end deployment, SpringBoot + MyBatis back‑end configuration, database initialization, core features for admin, teacher, and student roles, and provides code snippets and screenshots to illustrate the complete workflow.
The guide recommends fine‑grained MySQL management in a MyBatis‑based order system—avoiding generic or dynamic SQL, explicitly using indexes, listing columns, limiting results, batching inserts, and checking row counts—while applying appropriate concurrency control (pessimistic FOR UPDATE or optimistic versioning) to improve performance, stability, and data integrity.
This guide explains what caching is, why it’s essential for database‑driven applications, and how MyBatis implements first‑level and second‑level caches, including configuration steps, sample code, execution results, and key considerations to ensure effective cache usage.
This guide explains how to create a music website using Vue 3 for the front‑end and Spring Boot with MyBatis for the back‑end, covering project features, technology stack, development environment, repository cloning, resource setup, configuration, and launch commands.
When using MessageFormat to inject integer parameters into dynamically generated MyBatis SQL, large numbers are automatically formatted with commas (e.g., 10000 becomes 10,000), which can break SQL statements, and the article explains why this happens and how to prevent it by converting numbers to strings before formatting.
This article introduces MyBatis‑Mate, an official MyBatis‑Plus extension that provides enterprise‑grade capabilities such as dictionary binding, field encryption, data masking, dynamic table maintenance, audit logging, sharding, multi‑datasource switching, and customizable data‑scope handling, all illustrated with code examples.
This comprehensive guide explains what MyBatis is, compares it with Hibernate, details its core components, configuration, dynamic SQL, caching, plugins, pagination, and practical usage patterns, providing Java developers with clear examples, code snippets, and visual diagrams to master the framework efficiently.
