This article analyzes MyBatis-Plus Pro, a framework that extends MyBatis-Plus by providing a BaseController to auto-generate CRUD APIs, detailing its architecture, reflection-based query wrapper generation, pros/cons, ideal use cases, and best practices for avoiding common pitfalls.
This article demonstrates how to implement dynamic data source switching in Spring Boot using ThreadLocal and AbstractRoutingDataSource, covering configuration, annotation-based switching, and runtime data source registration with Druid.
This tutorial demonstrates how to replace auto-increment IDs with UUIDv7 in Spring Boot 3.5 using JPA and MyBatis-Plus, covering UUIDv7's timestamp-based structure, the java-uuid-generator library, and custom identifier generator implementations for both persistence frameworks.
This article walks through implementing Twitter's Snowflake algorithm in Spring Boot for distributed ID generation, covering 64-bit structure, clock drift mitigation strategies (wait, error, historical compensation), pre-generated ID pools with double buffering for 120k QPS, MyBatis-Plus integration, and Meituan Leaf design insights.
This article details MyBatis-Plus 3.5.15's new support for Spring Boot 4.0 and Jackson 3.0, providing step-by-step migration guidance including starter dependency changes, JSON field handling with Jackson3TypeHandler, and common upgrade pitfalls like starter mismatches and factoryBeanObjectType errors.
This article analyzes the performance bottleneck of LIMIT OFFSET deep pagination in MySQL with millions of rows, demonstrates EXPLAIN plan analysis, compares traditional pagination, subquery, covering index, and keyset pagination approaches, provides Spring Boot implementation examples for MyBatis-Plus and JPA, and benchmarks showing keyset pagination maintains constant response time regardless of page depth.
This article walks through the Snowflake algorithm for distributed ID generation, detailing its timestamp, workerId and sequence fields, handling clock rollback and sequence overflow, and provides a complete Java implementation with integration examples for Hutool and MyBatis‑Plus, including configuration and test code.
This article reviews six practical approaches—from database column defaults to AOP interceptors—for automatically populating common fields such as timestamps, creator, and tenant IDs in SpringBoot applications, compares their pros, cons, and applicability, and offers guidance on selecting the most suitable solution.
SpringBoot developers can eliminate repetitive manual setting of common fields like create_time, update_time, create_by, and update_by by using six automatic filling solutions—from database default values and MyBatis‑Plus meta‑object handlers to JPA auditing, MyBatis interceptors, AOP aspects, and controller request‑body advice—each with its own pros, cons, and ideal scenarios.
This article examines common pitfalls of MyBatis-Plus IPage pagination, explains why naive approaches like using two mapper methods or setting pageSize to Integer.MAX_VALUE cause performance and consistency issues, and presents a single‑SQL strategy with custom count handling, cursor streaming, and best‑practice configurations for seamless pagination and full‑data export.
This article details a production-ready dynamic data permission system using Spring Boot 3.x and MyBatis-Plus 3.5+, covering row-level interception via JSqlParser, column-level masking with Jackson serialization, RBAC+ABAC hybrid model, two-level caching with Caffeine and Redis, and lessons learned from handling complex JOINs, hot updates, and performance overhead.
The article explains how to avoid common pitfalls in handling statutory holidays for enterprise attendance systems by building an independent work‑day calendar service, storing daily date types in a database, providing unified SpringBoot APIs for rule evaluation, and offering a Vue3 visual calendar for HR to maintain holidays, adjustments, and custom company holidays.
The article walks through creating a SpringBoot project from scratch, covering IDE setup pain points, project initialization, version compatibility between SpringBoot, Spring Cloud and Kafka, Maven dependency management, core scaffold classes such as global exception handling, logging aspect, CORS and Swagger configuration, and recommends useful tools like embedded Redis, MariaDB, Hutool, MyBatis‑Plus, MapStruct and Redisson.
This article walks through a side‑by‑side examination of MyBatis‑Flex and MyBatis‑Plus, covering entity annotations, query construction, pagination, architectural differences, APT‑generated code, multi‑table joins, partial updates, and the trade‑offs of each design, helping developers choose the right ORM for their projects.
This article presents twelve practical MyBatis‑Plus techniques—including avoiding isNull checks, selecting specific fields, batch operations, EXISTS subqueries, safe ordering, LambdaQuery type safety, between clauses, index‑aware sorting, pagination limits, null‑handling, performance tracking, enum mapping, logical deletion, optimistic locking, and increment/decrement methods—to help developers write cleaner, faster, and more maintainable Java code.
This article shares production-hardened patterns for multi-tenant SaaS using Spring Boot, covering isolation mode selection, ThreadLocal-based context propagation, MyBatis-Plus SQL interception for automatic tenant_id injection, Feign and async thread propagation, HikariCP tuning, composite indexing, cursor pagination, and real-world pitfalls like interceptor ordering, transaction-bound data source switching, and ThreadLocal leakage.
This article presents a comprehensive interview self‑test for MyBatis‑Plus, covering its relationship with MyBatis, BaseMapper CRUD implementation, SqlMethod and AbstractMethod roles, MapperProxy interception, LambdaQueryWrapper type safety, Wrapper condition handling, interceptor chain, pagination mechanisms, logical delete rewriting, MetaObjectHandler fill timing, thread‑safety pitfalls, and best‑practice recommendations.
This guide demonstrates how to set up a Spring Boot 3.x project with MyBatis‑Plus, configure Maven dependencies, H2 database, and JPA, then write comprehensive JUnit 5 tests covering CRUD, LambdaQueryWrapper queries, pagination, logical deletion, and automatic timestamp filling, with step‑by‑step commands to run the tests.
This article compares MyBatis-Plus and MyBatis-Flex across eight dimensions—including design philosophy, development efficiency, query flexibility, performance, database support, advanced features, dependency weight, and community ecosystem—to help developers choose the most suitable persistence framework for their projects.
This article presents a step‑by‑step guide to constructing a full‑stack SpringBoot + Vue3 project with production‑grade features such as global exception handling, unified error codes, JWT authentication, multi‑environment configuration, CORS solutions, pagination, Pinia state management, on‑demand UI imports, and Nginx reverse‑proxy deployment.
The article catalogs six production‑ready pitfalls of MyBatis‑Plus—duplicate Snowflake IDs, batch‑insert disorder, enum storage errors, camel‑case mismatches, auto‑fill failures, and JSON field loss—explains their root causes with concrete examples and code, and provides practical solutions to keep the framework reliable in high‑concurrency environments.
This guide curates essential AI Agent Skills for the Java ecosystem, covering backend tools like Spring Boot, MyBatis‑Plus, and Redis, frontend frameworks such as Vue and React, installation commands, custom Skill examples, and recommended full‑stack workflows to boost project productivity.
The article demonstrates how to use Spring Boot and MyBatis-Plus to record user-product visit logs via an atomic INSERT ON DUPLICATE KEY UPDATE upsert, while isolating any remote-call failures through layered try-catch blocks so that logging never disrupts the main product-detail response.
This article analyzes MybatisPlus Pro, explaining how it eliminates repetitive CRUD code in MyBatis‑Plus projects by providing a BaseController and utility classes that auto‑generate service and controller layers, while also detailing its internal mechanisms, advantages, drawbacks, suitable scenarios, and common pitfalls.
This article provides a detailed comparison between Mybatis-Plus and Mybatis-Flex, examining their design philosophies, core mechanisms, feature sets, performance benchmarks, database support, dependency weight, and community maturity, and offers practical guidance on choosing the right framework for different project scenarios.
The author recounts three years of applying Domain‑Driven Design to a microservice ecosystem, sharing concrete pitfalls, code‑first modeling from database tables, and a structured 24‑article series that guides developers to refactor existing Spring Boot + MyBatis Plus projects without rewriting the framework.
This article enumerates ten frequent pitfalls when using MyBatis‑Plus—such as incorrect total counts in pagination, pagination interceptor misconfiguration, logical‑delete failures, auto‑fill issues, optimistic‑lock mismatches, null handling in query wrappers, poor batch‑insert performance, enum mapping errors, type‑handler problems, and overall pros and cons—providing concrete examples, root‑cause analysis, and practical solutions for each.
This article analyzes ten frequent pitfalls when using MyBatis-Plus—such as incorrect pagination totals, pagination plugin misconfiguration, logical delete failures, auto‑fill issues, optimistic‑lock mismatches, null handling in QueryWrapper, batch‑insert performance, enum mapping errors, wrapper condition overrides, and type‑handler problems—provides root‑cause explanations, concrete code examples, and practical solutions to help developers write more robust and efficient Java backend code.
This article examines ten frequent pitfalls when using MyBatis-Plus—such as incorrect pagination counts, disabled pagination, logical‑delete mishandling, auto‑fill failures, optimistic‑lock issues, batch‑insert slowness, enum mapping errors, JSON type‑handler problems, and query‑wrapper quirks—explains their causes, and provides concrete code‑level solutions and best‑practice recommendations.
The article enumerates ten typical traps when using MyBatis-Plus—such as incorrect pagination counts, ineffective pagination plugins, logical delete mishandling, auto‑fill failures, optimistic‑lock issues, null‑value conditions, batch‑insert slowness, enum mapping errors, wrapper overwrites, and type‑handler problems—explains why they occur, and provides concrete code‑level solutions and best‑practice recommendations.
A newcomer swapped MyBatis for MyBatis‑Plus in an old Java project, which caused a runtime exception about unsupported java.time.LocalDateTime conversion; the root cause was a MyBatis version change and an outdated MySQL JDBC driver, fixed by upgrading the driver.
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.
A newcomer replaced MyBatis with MyBatis‑Plus in an old MySQL‑based project, triggering a "Conversion not supported for type java.time.LocalDateTime" error, which was traced to MyBatis 3.5.1 dropping built‑in type handling and an outdated mysql‑connector‑java, and resolved by upgrading the connector and adjusting validation logic.
A newcomer replaced MyBatis with MyBatis‑Plus in an old MySQL‑based project, encountered a "Conversion not supported for type java.time.LocalDateTime" error, traced it to MyBatis 3.5.1 dropping built‑in type handling and an outdated mysql‑connector‑java driver, and resolved it by upgrading the driver while also fixing a related validation bug that caused production failures.
This article introduces an open‑source MyBatis‑Plus dynamic‑table starter, explains why dynamic table names are needed for large‑scale data, outlines its key features, provides step‑by‑step installation and quick‑start instructions, demonstrates advanced usage, debugging tips, FAQs, and real‑world scenarios.
This 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 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.
The article details a step‑by‑step migration from MyBatis 3.5.0 to MyBatis‑Plus 3.1.1, explains why the conversion error for java.time.LocalDateTime appears after the switch, shows how to trace the root cause through stack traces, upgrades the mysql‑connector‑java to 5.1.37 (and later 5.1.42) to resolve the issue, and shares broader lessons about component upgrades and unexpected bugs.
This article walks through creating a lightweight material‑management ERP system—including login, dashboard, inventory, inbound and outbound modules—using Vue 3 for the front end and Spring Boot 3, Java 17, MySQL, and MyBatis‑Plus for the back end, highlighting the architecture and development efficiency tricks employed.
This article explains why multi‑source data fragmentation hurts service code, introduces Apache Calcite as a query‑abstraction layer that decouples data location from query logic, and provides step‑by‑step Spring Boot 3 integration, practical code samples, common pitfalls, performance tips, and real‑world scenarios.
A legacy project using MySQL 5.7, MyBatis 3.5.0 and mysql‑connector‑java 5.1.26 encounters a "Conversion not supported for type java.time.LocalDateTime" error after switching to MyBatis‑Plus 3.1.1, which is traced to MyBatis 3.5.1 dropping built‑in LocalDateTime handling and the old connector not supporting the type, requiring an upgrade to mysql‑connector‑java 5.1.37 or later.
The article reviews the most common MyBatis‑Plus traps encountered in large‑scale Java services—duplicate Snowflake IDs, batch‑insert reordering, enum storage mismatches, camel‑case mapping errors, auto‑fill loss, and JSON field disappearance—explaining each root cause, illustrating it with real code snippets, and providing concrete solutions to keep production systems stable.
A Java backend project upgraded from MyBatis 3.5.0 to MyBatis‑Plus 3.1.1 encountered a LocalDateTime conversion exception caused by an outdated MySQL connector, and the article walks through version diagnostics, connector upgrades, and additional validation bugs that surfaced during production.
The article walks through replacing MyBatis 3.5.0 with MyBatis‑Plus 3.1.1 in a legacy Java project, uncovers version‑specific LocalDateTime conversion failures, shows how upgrading mysql‑connector‑java resolves them, and reflects on the broader impact of component upgrades on production stability.
This article walks through replacing MyBatis with MyBatis‑Plus in a Java project, diagnosing a Conversion not supported for java.time.LocalDateTime error, uncovering its root cause in MyBatis and mysql‑connector‑java version mismatches, and sharing lessons from subsequent validation bugs and production incidents.
This tutorial walks you through integrating MyBatis-Plus with Spring Boot, covering environment preparation, Maven dependencies, configuration of data sources, entity annotations, CRUD operations, pagination, logical deletion, enum handling, automatic field filling, multi‑datasource support, and testing with a REST controller.
The article presents a step‑by‑step, code‑driven design of a Spring Cloud SaaS multi‑tenant solution that balances resource sharing and strict data isolation by using a shared‑database, shared‑schema approach with tenant_id filtering, ThreadLocal context, MyBatis‑Plus interceptors, Redis key prefixing, Sa‑Token session segregation, and Spring Boot auto‑configuration.
The article walks through swapping MyBatis for MyBatis‑Plus in a legacy Java project, explains the LocalDateTime conversion error caused by MyBatis 3.5.1 and an outdated MySQL driver, shows how upgrading mysql‑connector‑java resolves the issue, and warns that component upgrades can trigger cascading bugs that require thorough testing.
Learn how to efficiently handle upserts in MySQL by leveraging the native DUPLICATE KEY UPDATE feature, simplifying code with a custom MyBatis‑Plus AbstractMethod injector, complete with thread‑safe locking, SQL generation, and integration steps for seamless backend development.
This article explains how to add data‑permission filtering to MyBatis‑Plus by creating a custom annotation, implementing a global interceptor, wiring a permission‑handler, configuring the interceptor in the MyBatis‑Plus plugin, and extending the solution with role‑based scopes for advanced use cases.
This guide walks through adding MyBatis-Plus to a Spring Boot project, configuring basic settings, using CRUD operations, condition builders, pagination, advanced features like auto‑fill, logical delete, optimistic locking, code generation, common pitfalls, and practical recommendations for effective usage.
Learn how to seamlessly integrate MyBatis‑Plus with ShardingSphere‑JDBC for high‑performance sharding, covering core principles, step‑by‑step workflow, and detailed solutions to typical pitfalls such as SQL parsing, pagination conflicts, key generation, query routing, transaction handling, broadcast tables, injection risks, and shard algorithm design.
This article explains how MyBatis‑Plus and ShardingSphere‑JDBC work together for sharding and scaling, outlines their core responsibilities, details the step‑by‑step SQL processing flow, and provides practical solutions to typical issues such as SQL parsing errors, pagination conflicts, primary‑key generation clashes, missing sharding keys, distributed transaction complexities, broadcast‑table misconfigurations, injection risks, and uneven sharding algorithms.
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 shares practical strategies for optimizing MyBatis‑Plus CRUD operations in massive‑data scenarios, covering query, insert, update, delete, batch processing, and database‑level tuning to keep performance stable when tables exceed ten million rows.
The article walks through replacing MyBatis with MyBatis‑Plus in a legacy project, explains the LocalDateTime conversion errors caused by version changes in MyBatis and mysql‑connector‑java, shows how upgrading the JDBC driver resolves the issue, and shares lessons on cautious component upgrades and testing.
This article introduces MyBatis-Plus, explains its core zero‑invasion features such as effortless single‑table CRUD, powerful Lambda condition builders, and a rich plugin system, then provides practical guidelines and code examples for building secure, high‑performance DAO layers in microservice back‑ends.
This article introduces MyBatis-Plus as a zero‑intrusion enhancement to MyBatis, explains its core values of convenience, safety, and compatibility, details CRUD methods, condition builders, plugin mechanisms, and best‑practice guidelines for building efficient, secure backend services.
This article introduces MyBatis-Plus, explains its core zero‑injection CRUD capabilities, demonstrates powerful condition builders, plugin extensions, and best practices for secure, efficient data access, including custom query objects, micro‑service integration, and advanced mapper customization, helping developers boost backend productivity.
This article walks through a real‑world scenario where replacing MyBatis with MyBatis‑Plus caused a LocalDateTime conversion exception due to changes in MyBatis 3.5.1 and an outdated mysql‑connector‑java driver, demonstrates how to pinpoint the root cause via stack traces, and provides step‑by‑step fixes including driver upgrades and version considerations, while also sharing lessons learned from related validation bugs.
This article explains how to enforce data‑access restrictions in MyBatis‑Plus by creating a custom @UserDataPermission annotation, building an InnerInterceptor that rewrites SQL queries, handling role‑based scopes, and integrating the interceptor into the MyBatis‑Plus plugin for both basic and advanced use cases.
A developer upgraded an old Spring Boot project by swapping MyBatis for MyBatis‑Plus, ran into a Conversion not supported for java.time.LocalDateTime error, traced the root cause to MyBatis 3.5.1 delegating type conversion to an outdated mysql‑connector‑java, and resolved it by upgrading the connector and adjusting validation logic, illustrating the ripple effects of component upgrades.
The article analyzes the repetitive maintenance of common fields like createTime and updateUser in SpringBoot CRUD services, presents six production‑tested strategies—including MyBatis‑Plus meta‑object handling, AOP with custom annotations, multi‑data‑source adaptation, distributed ID generation, caching, batch optimization, and audit logging—detailing implementations, pitfalls, and best‑practice recommendations that can cut code by 90% and boost development efficiency.
Learn how to leverage MyBatis-Plus’s type-safe LambdaQueryWrapper together with Spring Boot’s @Async annotation to build efficient, asynchronous database operations, covering basic usage, advanced thread-pool configuration, exception handling, transaction management, and real-world scenarios for backend developers.
Learn how to combine MyBatis-Plus's type‑safe LambdaQueryWrapper with Spring Boot's @Async annotation to build readable, maintainable queries and execute them asynchronously, including configuration of custom thread pools, exception handling, transaction management, and practical use cases such as reporting and batch processing.
This guide shows how to combine MyBatis-Plus dynamic data source routing with ShardingSphere-JDBC for horizontal sharding and read‑write splitting, including Maven dependencies, YAML configuration, Spring bean setup, and a custom load‑balancing algorithm to keep @DS annotations functional.
This tutorial explains how to implement dynamic data source switching in Spring Boot by combining ThreadLocal with AbstractRoutingDataSource, covering custom context holders, configuration, annotation‑driven switching, dynamic addition of data sources, and complete code examples with test results.
This article presents a production‑tested, six‑step automation strategy—combining MyBatis‑Plus auto‑fill, AOP interceptors, JWT‑based user retrieval, multi‑data‑source handling, distributed ID generation, and audit logging—to completely remove manual maintenance of common fields like create_time and update_by in Java order modules, boosting efficiency and reducing bugs.
This article presents a production‑tested, six‑strategy solution—including MyBatis‑Plus auto‑fill, AOP, JWT, multi‑datasource handling, distributed ID generation, and audit logging—to eliminate repetitive maintenance of common fields in Java order modules, boosting efficiency and reducing bugs.
This article analyzes the poor performance of MyBatis‑Plus saveBatch, compares it with single inserts, manual SQL batching, and JDBC executeBatch, and shows how enabling the rewriteBatchedStatements flag can dramatically improve batch insert speed.
A comprehensive step‑by‑step tutorial shows how to integrate MyBatis‑Plus into a Spring Boot project, covering dependencies, configuration, entity annotations, CRUD operations, pagination, logical deletion, enum handling, automatic field filling, multi‑datasource support, and testing.
This article explains a puzzling Spring Boot transaction rollback caused by MyBatis-Plus's saveBatch method, reproduces the error with nested @Transactional calls, analyzes why the rollback flag is set, and offers a practical workaround by replacing the framework batch operation with a custom mapper implementation.
This article presents a production‑tested, six‑step solution for automatically handling common entity fields such as createTime, updateTime, createUser, and updateUser in Java backend systems, covering MyBatis‑Plus auto‑fill, AOP interception, multi‑data‑source adaptation, distributed ID generation, pitfalls avoidance, performance tuning, and audit logging.
This tutorial walks through creating a generic BaseController that provides CRUD, list, pagination, and count operations for any entity by adding MyBatis‑Plus, writing a utility class for query building, configuring a pagination interceptor, and extending the base class in concrete controllers, all illustrated with complete Java code snippets.
This article analyzes the pain points of manually maintaining common fields in order‑related entities and presents a production‑tested solution that combines MyBatis‑Plus automatic filling, custom AOP annotations, multi‑data‑source handling, distributed ID generation, and auditing to dramatically reduce boilerplate code and bugs.
The article explains how to replace hand‑written SQL join statements in MyBatis with an object‑oriented approach by adding the mybatis‑plus‑join library, configuring the Maven dependency, and writing concise Java code that leverages MPJQueryWrapper for clear and error‑free join queries.
This article introduces the Mybatis-Plus Generator UI, a highly customizable web‑based code generator that wraps Mybatis‑Plus, explains its features, shows how to integrate it via Maven, run a sample main class, configure generation strategies, customize templates and naming rules, and even extend the frontend with Yarn builds.
This article presents a production‑validated solution that combines MyBatis‑Plus auto‑fill, AOP, JWT, multi‑data‑source handling, distributed ID generation, performance tuning, and audit logging to eliminate repetitive maintenance of common fields such as createTime, updateTime, createUser, and updateUser in Java backend order services.
This article presents a production‑tested solution for automatically handling common entity fields such as createTime, updateTime, createUser, and updateUser in Java backend systems, combining MyBatis‑Plus auto‑fill, AOP interceptors, custom annotations, multi‑datasource support, distributed ID generation, and auditing techniques to eliminate repetitive code and reduce bugs.
This guide shows how to create a reusable BaseController using MyBatis‑Plus, reflection utilities, and Spring Boot annotations to provide automatic CRUD, list, pagination and count endpoints for any entity with minimal code.
This article explains the concept of SaaS multi‑tenant architecture, compares three data‑isolation designs, and demonstrates how to implement elegant tenant‑level data isolation in Java using MyBatis‑Plus’s tenant plugin, complete with configuration, handler code, SQL examples, and troubleshooting tips.
This article describes a utility method that leverages Java reflection and generics to automatically generate a MyBatis-Plus QueryWrapper from a DTO, handling field‑name mapping, type‑specific query conditions, and camel‑to‑snake case conversion for seamless database queries.
The article demonstrates advanced MyBatis‑Plus techniques—including high‑speed batch inserts with rewriteBatchedStatements, logical deletes via global config, automatic timestamp and user fields through MetaObjectHandler, JSON serialization with JacksonTypeHandler, dynamic table naming via an interceptor, and a brief multi‑tenant overview—to streamline development and reduce boilerplate code.
This article explains the concept of SQL injectors in MyBatis‑Plus, lists the built‑in injectable methods, shows how to configure them globally, demonstrates creating a custom mapper and injector with full code examples, and provides step‑by‑step testing procedures for extending MyBatis‑Plus functionality.
The article walks through migrating an old MySQL‑5.7 project from MyBatis 3.5.0 to MyBatis‑Plus 3.1.1, diagnosing a LocalDateTime conversion exception caused by an outdated mysql‑connector‑java driver, and resolves it by upgrading the driver version, highlighting the need for careful component compatibility checks.
This article explains how to implement a custom MyBatis-Plus pagination interceptor that parallelizes COUNT and data queries using CompletableFuture and a configurable thread pool in Spring Boot, suitable for large single-table and complex multi-table pagination scenarios, and provides detailed configuration and code examples.
This article introduces MyBatis‑Plus, an enhancement for MyBatis, outlining its lightweight features, step‑by‑step setup including database creation, Maven dependency, configuration, entity and mapper definitions, CRUD operations, pagination, optimistic locking, logical deletion, condition wrappers, and code generation utilities for rapid backend development.
This article demonstrates how Java 8's functional interfaces, especially Function and SFunction, can be used to abstract and reuse data‑validation logic, dramatically reducing boilerplate code, improving readability, and making validation rules easier to maintain and extend.
Facing the need to query multiple databases in a Spring Boot application, this guide walks through building a custom dynamic datasource solution using ThreadLocal and AbstractRoutingDataSource, covering core implementations, annotation‑based switching, dynamic datasource addition, configuration, and comprehensive test results.
The article demonstrates how to build a dynamic Chain of Responsibility in a Spring Boot and MyBatis‑Plus application by defining an abstract handler, implementing concrete @Component beans that modify a shared Lombok‑based context, retrieving them via an ApplicationContext‑aware proxy utility, and invoking them in a client‑specified order through a REST endpoint, while suggesting LiteFlow as a production alternative.
This article demonstrates how to use Java 8 functional interfaces, especially Function and the MyBatis‑Plus SFunction wrapper, to eliminate repetitive data‑validation code, improve readability, and create reusable validation utilities for backend services.
This article demonstrates how Java 8’s functional interfaces, especially Function and SFunction, can refactor repetitive data‑validation logic into a generic, reusable method, reducing boilerplate, improving readability, and enabling flexible validation scenarios such as checking column values, matching expected values, and verifying values against allowed lists.
MyBatis-Plus, an enhanced toolkit for MyBatis, simplifies CRUD operations and injects dynamic SQL, and this release introduces numerous bug fixes, new annotations, code‑generator enhancements, and upgrades to MyBatis, Spring Boot, and Kotlin, with important migration notes for developers.
This article explains how to create a custom annotation and a MyBatis‑Plus interceptor that automatically injects data‑permission SQL conditions based on the current user's role, showing both a basic implementation and an advanced version with role‑based scope handling, complete with code examples and integration steps.
This article walks through migrating an old MySQL‑5.7 project from MyBatis 3.5.0 to MyBatis‑Plus 3.1.1, explains the "Conversion not supported for type java.time.LocalDateTime" exception, shows how upgrading mysql‑connector‑java resolves the issue, and shares lessons learned from a production bug caused by an over‑optimistic validation change.
By configuring MySQL’s rewriteBatchedStatements=true, pre‑generating primary keys, adjusting MyBatis executor settings, and employing asynchronous multithreaded batch inserts, this guide demonstrates how to accelerate MyBatis‑Plus saveBatch operations from seconds to milliseconds, achieving up to a 2000% performance gain in large‑scale data scenarios.
This article walks through the process of swapping MyBatis for MyBatis‑Plus in a legacy Java project, explains why upgrading MyBatis to 3.5.1 triggers a LocalDateTime conversion error, shows how updating mysql‑connector‑java resolves the issue, and shares the broader pitfalls of component upgrades and bug fixes.
This article walks through a real‑world case where swapping MyBatis for MyBatis‑Plus introduced a LocalDateTime conversion error, explains the root cause in MyBatis version changes and JDBC driver support, and shares subsequent bug fixes and lessons on cautious component upgrades.
This article analyzes why MyBatis-Plus generates duplicate primary keys in clustered Docker/K8S environments due to worker‑id and datacenter‑id collisions, introduces Seata's improved Snowflake algorithm that decouples from the OS clock, explains its implementation with Java code, and shows how to integrate it as a global ID generator to improve database performance and avoid page splits.
This article walks through replacing MyBatis with MyBatis-Plus in a Spring Boot project, explains the LocalDateTime conversion error caused by MyBatis 3.5.1 and an outdated MySQL connector, and shows how upgrading the connector resolves the issue while highlighting the risks of component upgrades.
